diff options
author | David Walter Seikel | 2014-01-13 19:47:58 +1000 |
---|---|---|
committer | David Walter Seikel | 2014-01-13 19:47:58 +1000 |
commit | f9158592e1478b2013afc7041d9ed041cf2d2f4a (patch) | |
tree | b16e389d7988700e21b4c9741044cefa536dcbae /libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c | |
parent | Libraries readme updated with change markers and more of the Irrlicht changes. (diff) | |
download | SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.zip SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.gz SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.bz2 SledjHamr-f9158592e1478b2013afc7041d9ed041cf2d2f4a.tar.xz |
Update Irrlicht to 1.8.1. Include actual change markers this time. lol
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c | 545 |
1 files changed, 0 insertions, 545 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c deleted file mode 100644 index 4d36f85..0000000 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jcsample.c +++ /dev/null | |||
@@ -1,545 +0,0 @@ | |||
1 | /* | ||
2 | * jcsample.c | ||
3 | * | ||
4 | * Copyright (C) 1991-1996, 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 downsampling routines. | ||
9 | * | ||
10 | * Downsampling input data is counted in "row groups". A row group | ||
11 | * is defined to be max_v_samp_factor pixel rows of each component, | ||
12 | * from which the downsampler produces v_samp_factor sample rows. | ||
13 | * A single row group is processed in each call to the downsampler module. | ||
14 | * | ||
15 | * The downsampler is responsible for edge-expansion of its output data | ||
16 | * to fill an integral number of DCT blocks horizontally. The source buffer | ||
17 | * may be modified if it is helpful for this purpose (the source buffer is | ||
18 | * allocated wide enough to correspond to the desired output width). | ||
19 | * The caller (the prep controller) is responsible for vertical padding. | ||
20 | * | ||
21 | * The downsampler may request "context rows" by setting need_context_rows | ||
22 | * during startup. In this case, the input arrays will contain at least | ||
23 | * one row group's worth of pixels above and below the passed-in data; | ||
24 | * the caller will create dummy rows at image top and bottom by replicating | ||
25 | * the first or last real pixel row. | ||
26 | * | ||
27 | * An excellent reference for image resampling is | ||
28 | * Digital Image Warping, George Wolberg, 1990. | ||
29 | * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. | ||
30 | * | ||
31 | * The downsampling algorithm used here is a simple average of the source | ||
32 | * pixels covered by the output pixel. The hi-falutin sampling literature | ||
33 | * refers to this as a "box filter". In general the characteristics of a box | ||
34 | * filter are not very good, but for the specific cases we normally use (1:1 | ||
35 | * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not | ||
36 | * nearly so bad. If you intend to use other sampling ratios, you'd be well | ||
37 | * advised to improve this code. | ||
38 | * | ||
39 | * A simple input-smoothing capability is provided. This is mainly intended | ||
40 | * for cleaning up color-dithered GIF input files (if you find it inadequate, | ||
41 | * we suggest using an external filtering program such as pnmconvol). When | ||
42 | * enabled, each input pixel P is replaced by a weighted sum of itself and its | ||
43 | * eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF, | ||
44 | * where SF = (smoothing_factor / 1024). | ||
45 | * Currently, smoothing is only supported for 2h2v sampling factors. | ||
46 | */ | ||
47 | |||
48 | #define JPEG_INTERNALS | ||
49 | #include "jinclude.h" | ||
50 | #include "jpeglib.h" | ||
51 | |||
52 | |||
53 | /* Pointer to routine to downsample a single component */ | ||
54 | typedef JMETHOD(void, downsample1_ptr, | ||
55 | (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
56 | JSAMPARRAY input_data, JSAMPARRAY output_data)); | ||
57 | |||
58 | /* Private subobject */ | ||
59 | |||
60 | typedef struct { | ||
61 | struct jpeg_downsampler pub; /* public fields */ | ||
62 | |||
63 | /* Downsampling method pointers, one per component */ | ||
64 | downsample1_ptr methods[MAX_COMPONENTS]; | ||
65 | |||
66 | /* Height of an output row group for each component. */ | ||
67 | int rowgroup_height[MAX_COMPONENTS]; | ||
68 | |||
69 | /* These arrays save pixel expansion factors so that int_downsample need not | ||
70 | * recompute them each time. They are unused for other downsampling methods. | ||
71 | */ | ||
72 | UINT8 h_expand[MAX_COMPONENTS]; | ||
73 | UINT8 v_expand[MAX_COMPONENTS]; | ||
74 | } my_downsampler; | ||
75 | |||
76 | typedef my_downsampler * my_downsample_ptr; | ||
77 | |||
78 | |||
79 | /* | ||
80 | * Initialize for a downsampling pass. | ||
81 | */ | ||
82 | |||
83 | METHODDEF(void) | ||
84 | start_pass_downsample (j_compress_ptr cinfo) | ||
85 | { | ||
86 | /* no work for now */ | ||
87 | } | ||
88 | |||
89 | |||
90 | /* | ||
91 | * Expand a component horizontally from width input_cols to width output_cols, | ||
92 | * by duplicating the rightmost samples. | ||
93 | */ | ||
94 | |||
95 | LOCAL(void) | ||
96 | expand_right_edge (JSAMPARRAY image_data, int num_rows, | ||
97 | JDIMENSION input_cols, JDIMENSION output_cols) | ||
98 | { | ||
99 | register JSAMPROW ptr; | ||
100 | register JSAMPLE pixval; | ||
101 | register int count; | ||
102 | int row; | ||
103 | int numcols = (int) (output_cols - input_cols); | ||
104 | |||
105 | if (numcols > 0) { | ||
106 | for (row = 0; row < num_rows; row++) { | ||
107 | ptr = image_data[row] + input_cols; | ||
108 | pixval = ptr[-1]; /* don't need GETJSAMPLE() here */ | ||
109 | for (count = numcols; count > 0; count--) | ||
110 | *ptr++ = pixval; | ||
111 | } | ||
112 | } | ||
113 | } | ||
114 | |||
115 | |||
116 | /* | ||
117 | * Do downsampling for a whole row group (all components). | ||
118 | * | ||
119 | * In this version we simply downsample each component independently. | ||
120 | */ | ||
121 | |||
122 | METHODDEF(void) | ||
123 | sep_downsample (j_compress_ptr cinfo, | ||
124 | JSAMPIMAGE input_buf, JDIMENSION in_row_index, | ||
125 | JSAMPIMAGE output_buf, JDIMENSION out_row_group_index) | ||
126 | { | ||
127 | my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample; | ||
128 | int ci; | ||
129 | jpeg_component_info * compptr; | ||
130 | JSAMPARRAY in_ptr, out_ptr; | ||
131 | |||
132 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | ||
133 | ci++, compptr++) { | ||
134 | in_ptr = input_buf[ci] + in_row_index; | ||
135 | out_ptr = output_buf[ci] + | ||
136 | (out_row_group_index * downsample->rowgroup_height[ci]); | ||
137 | (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr); | ||
138 | } | ||
139 | } | ||
140 | |||
141 | |||
142 | /* | ||
143 | * Downsample pixel values of a single component. | ||
144 | * One row group is processed per call. | ||
145 | * This version handles arbitrary integral sampling ratios, without smoothing. | ||
146 | * Note that this version is not actually used for customary sampling ratios. | ||
147 | */ | ||
148 | |||
149 | METHODDEF(void) | ||
150 | int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
151 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
152 | { | ||
153 | my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample; | ||
154 | int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v; | ||
155 | JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */ | ||
156 | JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size; | ||
157 | JSAMPROW inptr, outptr; | ||
158 | INT32 outvalue; | ||
159 | |||
160 | h_expand = downsample->h_expand[compptr->component_index]; | ||
161 | v_expand = downsample->v_expand[compptr->component_index]; | ||
162 | numpix = h_expand * v_expand; | ||
163 | numpix2 = numpix/2; | ||
164 | |||
165 | /* Expand input data enough to let all the output samples be generated | ||
166 | * by the standard loop. Special-casing padded output would be more | ||
167 | * efficient. | ||
168 | */ | ||
169 | expand_right_edge(input_data, cinfo->max_v_samp_factor, | ||
170 | cinfo->image_width, output_cols * h_expand); | ||
171 | |||
172 | inrow = outrow = 0; | ||
173 | while (inrow < cinfo->max_v_samp_factor) { | ||
174 | outptr = output_data[outrow]; | ||
175 | for (outcol = 0, outcol_h = 0; outcol < output_cols; | ||
176 | outcol++, outcol_h += h_expand) { | ||
177 | outvalue = 0; | ||
178 | for (v = 0; v < v_expand; v++) { | ||
179 | inptr = input_data[inrow+v] + outcol_h; | ||
180 | for (h = 0; h < h_expand; h++) { | ||
181 | outvalue += (INT32) GETJSAMPLE(*inptr++); | ||
182 | } | ||
183 | } | ||
184 | *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix); | ||
185 | } | ||
186 | inrow += v_expand; | ||
187 | outrow++; | ||
188 | } | ||
189 | } | ||
190 | |||
191 | |||
192 | /* | ||
193 | * Downsample pixel values of a single component. | ||
194 | * This version handles the special case of a full-size component, | ||
195 | * without smoothing. | ||
196 | */ | ||
197 | |||
198 | METHODDEF(void) | ||
199 | fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
200 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
201 | { | ||
202 | /* Copy the data */ | ||
203 | jcopy_sample_rows(input_data, 0, output_data, 0, | ||
204 | cinfo->max_v_samp_factor, cinfo->image_width); | ||
205 | /* Edge-expand */ | ||
206 | expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width, | ||
207 | compptr->width_in_blocks * compptr->DCT_h_scaled_size); | ||
208 | } | ||
209 | |||
210 | |||
211 | /* | ||
212 | * Downsample pixel values of a single component. | ||
213 | * This version handles the common case of 2:1 horizontal and 1:1 vertical, | ||
214 | * without smoothing. | ||
215 | * | ||
216 | * A note about the "bias" calculations: when rounding fractional values to | ||
217 | * integer, we do not want to always round 0.5 up to the next integer. | ||
218 | * If we did that, we'd introduce a noticeable bias towards larger values. | ||
219 | * Instead, this code is arranged so that 0.5 will be rounded up or down at | ||
220 | * alternate pixel locations (a simple ordered dither pattern). | ||
221 | */ | ||
222 | |||
223 | METHODDEF(void) | ||
224 | h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
225 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
226 | { | ||
227 | int inrow; | ||
228 | JDIMENSION outcol; | ||
229 | JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size; | ||
230 | register JSAMPROW inptr, outptr; | ||
231 | register int bias; | ||
232 | |||
233 | /* Expand input data enough to let all the output samples be generated | ||
234 | * by the standard loop. Special-casing padded output would be more | ||
235 | * efficient. | ||
236 | */ | ||
237 | expand_right_edge(input_data, cinfo->max_v_samp_factor, | ||
238 | cinfo->image_width, output_cols * 2); | ||
239 | |||
240 | for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { | ||
241 | outptr = output_data[inrow]; | ||
242 | inptr = input_data[inrow]; | ||
243 | bias = 0; /* bias = 0,1,0,1,... for successive samples */ | ||
244 | for (outcol = 0; outcol < output_cols; outcol++) { | ||
245 | *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1]) | ||
246 | + bias) >> 1); | ||
247 | bias ^= 1; /* 0=>1, 1=>0 */ | ||
248 | inptr += 2; | ||
249 | } | ||
250 | } | ||
251 | } | ||
252 | |||
253 | |||
254 | /* | ||
255 | * Downsample pixel values of a single component. | ||
256 | * This version handles the standard case of 2:1 horizontal and 2:1 vertical, | ||
257 | * without smoothing. | ||
258 | */ | ||
259 | |||
260 | METHODDEF(void) | ||
261 | h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
262 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
263 | { | ||
264 | int inrow, outrow; | ||
265 | JDIMENSION outcol; | ||
266 | JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size; | ||
267 | register JSAMPROW inptr0, inptr1, outptr; | ||
268 | register int bias; | ||
269 | |||
270 | /* Expand input data enough to let all the output samples be generated | ||
271 | * by the standard loop. Special-casing padded output would be more | ||
272 | * efficient. | ||
273 | */ | ||
274 | expand_right_edge(input_data, cinfo->max_v_samp_factor, | ||
275 | cinfo->image_width, output_cols * 2); | ||
276 | |||
277 | inrow = outrow = 0; | ||
278 | while (inrow < cinfo->max_v_samp_factor) { | ||
279 | outptr = output_data[outrow]; | ||
280 | inptr0 = input_data[inrow]; | ||
281 | inptr1 = input_data[inrow+1]; | ||
282 | bias = 1; /* bias = 1,2,1,2,... for successive samples */ | ||
283 | for (outcol = 0; outcol < output_cols; outcol++) { | ||
284 | *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + | ||
285 | GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]) | ||
286 | + bias) >> 2); | ||
287 | bias ^= 3; /* 1=>2, 2=>1 */ | ||
288 | inptr0 += 2; inptr1 += 2; | ||
289 | } | ||
290 | inrow += 2; | ||
291 | outrow++; | ||
292 | } | ||
293 | } | ||
294 | |||
295 | |||
296 | #ifdef INPUT_SMOOTHING_SUPPORTED | ||
297 | |||
298 | /* | ||
299 | * Downsample pixel values of a single component. | ||
300 | * This version handles the standard case of 2:1 horizontal and 2:1 vertical, | ||
301 | * with smoothing. One row of context is required. | ||
302 | */ | ||
303 | |||
304 | METHODDEF(void) | ||
305 | h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, | ||
306 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
307 | { | ||
308 | int inrow, outrow; | ||
309 | JDIMENSION colctr; | ||
310 | JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size; | ||
311 | register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr; | ||
312 | INT32 membersum, neighsum, memberscale, neighscale; | ||
313 | |||
314 | /* Expand input data enough to let all the output samples be generated | ||
315 | * by the standard loop. Special-casing padded output would be more | ||
316 | * efficient. | ||
317 | */ | ||
318 | expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, | ||
319 | cinfo->image_width, output_cols * 2); | ||
320 | |||
321 | /* We don't bother to form the individual "smoothed" input pixel values; | ||
322 | * we can directly compute the output which is the average of the four | ||
323 | * smoothed values. Each of the four member pixels contributes a fraction | ||
324 | * (1-8*SF) to its own smoothed image and a fraction SF to each of the three | ||
325 | * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final | ||
326 | * output. The four corner-adjacent neighbor pixels contribute a fraction | ||
327 | * SF to just one smoothed pixel, or SF/4 to the final output; while the | ||
328 | * eight edge-adjacent neighbors contribute SF to each of two smoothed | ||
329 | * pixels, or SF/2 overall. In order to use integer arithmetic, these | ||
330 | * factors are scaled by 2^16 = 65536. | ||
331 | * Also recall that SF = smoothing_factor / 1024. | ||
332 | */ | ||
333 | |||
334 | memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */ | ||
335 | neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */ | ||
336 | |||
337 | inrow = outrow = 0; | ||
338 | while (inrow < cinfo->max_v_samp_factor) { | ||
339 | outptr = output_data[outrow]; | ||
340 | inptr0 = input_data[inrow]; | ||
341 | inptr1 = input_data[inrow+1]; | ||
342 | above_ptr = input_data[inrow-1]; | ||
343 | below_ptr = input_data[inrow+2]; | ||
344 | |||
345 | /* Special case for first column: pretend column -1 is same as column 0 */ | ||
346 | membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + | ||
347 | GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); | ||
348 | neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + | ||
349 | GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + | ||
350 | GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) + | ||
351 | GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]); | ||
352 | neighsum += neighsum; | ||
353 | neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) + | ||
354 | GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]); | ||
355 | membersum = membersum * memberscale + neighsum * neighscale; | ||
356 | *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); | ||
357 | inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; | ||
358 | |||
359 | for (colctr = output_cols - 2; colctr > 0; colctr--) { | ||
360 | /* sum of pixels directly mapped to this output element */ | ||
361 | membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + | ||
362 | GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); | ||
363 | /* sum of edge-neighbor pixels */ | ||
364 | neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + | ||
365 | GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + | ||
366 | GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) + | ||
367 | GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]); | ||
368 | /* The edge-neighbors count twice as much as corner-neighbors */ | ||
369 | neighsum += neighsum; | ||
370 | /* Add in the corner-neighbors */ | ||
371 | neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) + | ||
372 | GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]); | ||
373 | /* form final output scaled up by 2^16 */ | ||
374 | membersum = membersum * memberscale + neighsum * neighscale; | ||
375 | /* round, descale and output it */ | ||
376 | *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); | ||
377 | inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2; | ||
378 | } | ||
379 | |||
380 | /* Special case for last column */ | ||
381 | membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) + | ||
382 | GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]); | ||
383 | neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) + | ||
384 | GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) + | ||
385 | GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) + | ||
386 | GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]); | ||
387 | neighsum += neighsum; | ||
388 | neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) + | ||
389 | GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]); | ||
390 | membersum = membersum * memberscale + neighsum * neighscale; | ||
391 | *outptr = (JSAMPLE) ((membersum + 32768) >> 16); | ||
392 | |||
393 | inrow += 2; | ||
394 | outrow++; | ||
395 | } | ||
396 | } | ||
397 | |||
398 | |||
399 | /* | ||
400 | * Downsample pixel values of a single component. | ||
401 | * This version handles the special case of a full-size component, | ||
402 | * with smoothing. One row of context is required. | ||
403 | */ | ||
404 | |||
405 | METHODDEF(void) | ||
406 | fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr, | ||
407 | JSAMPARRAY input_data, JSAMPARRAY output_data) | ||
408 | { | ||
409 | int inrow; | ||
410 | JDIMENSION colctr; | ||
411 | JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size; | ||
412 | register JSAMPROW inptr, above_ptr, below_ptr, outptr; | ||
413 | INT32 membersum, neighsum, memberscale, neighscale; | ||
414 | int colsum, lastcolsum, nextcolsum; | ||
415 | |||
416 | /* Expand input data enough to let all the output samples be generated | ||
417 | * by the standard loop. Special-casing padded output would be more | ||
418 | * efficient. | ||
419 | */ | ||
420 | expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2, | ||
421 | cinfo->image_width, output_cols); | ||
422 | |||
423 | /* Each of the eight neighbor pixels contributes a fraction SF to the | ||
424 | * smoothed pixel, while the main pixel contributes (1-8*SF). In order | ||
425 | * to use integer arithmetic, these factors are multiplied by 2^16 = 65536. | ||
426 | * Also recall that SF = smoothing_factor / 1024. | ||
427 | */ | ||
428 | |||
429 | memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */ | ||
430 | neighscale = cinfo->smoothing_factor * 64; /* scaled SF */ | ||
431 | |||
432 | for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { | ||
433 | outptr = output_data[inrow]; | ||
434 | inptr = input_data[inrow]; | ||
435 | above_ptr = input_data[inrow-1]; | ||
436 | below_ptr = input_data[inrow+1]; | ||
437 | |||
438 | /* Special case for first column */ | ||
439 | colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) + | ||
440 | GETJSAMPLE(*inptr); | ||
441 | membersum = GETJSAMPLE(*inptr++); | ||
442 | nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + | ||
443 | GETJSAMPLE(*inptr); | ||
444 | neighsum = colsum + (colsum - membersum) + nextcolsum; | ||
445 | membersum = membersum * memberscale + neighsum * neighscale; | ||
446 | *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); | ||
447 | lastcolsum = colsum; colsum = nextcolsum; | ||
448 | |||
449 | for (colctr = output_cols - 2; colctr > 0; colctr--) { | ||
450 | membersum = GETJSAMPLE(*inptr++); | ||
451 | above_ptr++; below_ptr++; | ||
452 | nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) + | ||
453 | GETJSAMPLE(*inptr); | ||
454 | neighsum = lastcolsum + (colsum - membersum) + nextcolsum; | ||
455 | membersum = membersum * memberscale + neighsum * neighscale; | ||
456 | *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16); | ||
457 | lastcolsum = colsum; colsum = nextcolsum; | ||
458 | } | ||
459 | |||
460 | /* Special case for last column */ | ||
461 | membersum = GETJSAMPLE(*inptr); | ||
462 | neighsum = lastcolsum + (colsum - membersum) + colsum; | ||
463 | membersum = membersum * memberscale + neighsum * neighscale; | ||
464 | *outptr = (JSAMPLE) ((membersum + 32768) >> 16); | ||
465 | |||
466 | } | ||
467 | } | ||
468 | |||
469 | #endif /* INPUT_SMOOTHING_SUPPORTED */ | ||
470 | |||
471 | |||
472 | /* | ||
473 | * Module initialization routine for downsampling. | ||
474 | * Note that we must select a routine for each component. | ||
475 | */ | ||
476 | |||
477 | GLOBAL(void) | ||
478 | jinit_downsampler (j_compress_ptr cinfo) | ||
479 | { | ||
480 | my_downsample_ptr downsample; | ||
481 | int ci; | ||
482 | jpeg_component_info * compptr; | ||
483 | boolean smoothok = TRUE; | ||
484 | int h_in_group, v_in_group, h_out_group, v_out_group; | ||
485 | |||
486 | downsample = (my_downsample_ptr) | ||
487 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | ||
488 | SIZEOF(my_downsampler)); | ||
489 | cinfo->downsample = (struct jpeg_downsampler *) downsample; | ||
490 | downsample->pub.start_pass = start_pass_downsample; | ||
491 | downsample->pub.downsample = sep_downsample; | ||
492 | downsample->pub.need_context_rows = FALSE; | ||
493 | |||
494 | if (cinfo->CCIR601_sampling) | ||
495 | ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); | ||
496 | |||
497 | /* Verify we can handle the sampling factors, and set up method pointers */ | ||
498 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | ||
499 | ci++, compptr++) { | ||
500 | /* Compute size of an "output group" for DCT scaling. This many samples | ||
501 | * are to be converted from max_h_samp_factor * max_v_samp_factor pixels. | ||
502 | */ | ||
503 | h_out_group = (compptr->h_samp_factor * compptr->DCT_h_scaled_size) / | ||
504 | cinfo->min_DCT_h_scaled_size; | ||
505 | v_out_group = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) / | ||
506 | cinfo->min_DCT_v_scaled_size; | ||
507 | h_in_group = cinfo->max_h_samp_factor; | ||
508 | v_in_group = cinfo->max_v_samp_factor; | ||
509 | downsample->rowgroup_height[ci] = v_out_group; /* save for use later */ | ||
510 | if (h_in_group == h_out_group && v_in_group == v_out_group) { | ||
511 | #ifdef INPUT_SMOOTHING_SUPPORTED | ||
512 | if (cinfo->smoothing_factor) { | ||
513 | downsample->methods[ci] = fullsize_smooth_downsample; | ||
514 | downsample->pub.need_context_rows = TRUE; | ||
515 | } else | ||
516 | #endif | ||
517 | downsample->methods[ci] = fullsize_downsample; | ||
518 | } else if (h_in_group == h_out_group * 2 && | ||
519 | v_in_group == v_out_group) { | ||
520 | smoothok = FALSE; | ||
521 | downsample->methods[ci] = h2v1_downsample; | ||
522 | } else if (h_in_group == h_out_group * 2 && | ||
523 | v_in_group == v_out_group * 2) { | ||
524 | #ifdef INPUT_SMOOTHING_SUPPORTED | ||
525 | if (cinfo->smoothing_factor) { | ||
526 | downsample->methods[ci] = h2v2_smooth_downsample; | ||
527 | downsample->pub.need_context_rows = TRUE; | ||
528 | } else | ||
529 | #endif | ||
530 | downsample->methods[ci] = h2v2_downsample; | ||
531 | } else if ((h_in_group % h_out_group) == 0 && | ||
532 | (v_in_group % v_out_group) == 0) { | ||
533 | smoothok = FALSE; | ||
534 | downsample->methods[ci] = int_downsample; | ||
535 | downsample->h_expand[ci] = (UINT8) (h_in_group / h_out_group); | ||
536 | downsample->v_expand[ci] = (UINT8) (v_in_group / v_out_group); | ||
537 | } else | ||
538 | ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); | ||
539 | } | ||
540 | |||
541 | #ifdef INPUT_SMOOTHING_SUPPORTED | ||
542 | if (cinfo->smoothing_factor && !smoothok) | ||
543 | TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL); | ||
544 | #endif | ||
545 | } | ||