diff options
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdsample.c')
-rw-r--r-- | libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdsample.c | 361 |
1 files changed, 0 insertions, 361 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdsample.c b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdsample.c deleted file mode 100644 index 7bc8885..0000000 --- a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/jdsample.c +++ /dev/null | |||
@@ -1,361 +0,0 @@ | |||
1 | /* | ||
2 | * jdsample.c | ||
3 | * | ||
4 | * Copyright (C) 1991-1996, Thomas G. Lane. | ||
5 | * Modified 2002-2008 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 upsampling routines. | ||
10 | * | ||
11 | * Upsampling input data is counted in "row groups". A row group | ||
12 | * is defined to be (v_samp_factor * DCT_v_scaled_size / min_DCT_v_scaled_size) | ||
13 | * sample rows of each component. Upsampling will normally produce | ||
14 | * max_v_samp_factor pixel rows from each row group (but this could vary | ||
15 | * if the upsampler is applying a scale factor of its own). | ||
16 | * | ||
17 | * An excellent reference for image resampling is | ||
18 | * Digital Image Warping, George Wolberg, 1990. | ||
19 | * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. | ||
20 | */ | ||
21 | |||
22 | #define JPEG_INTERNALS | ||
23 | #include "jinclude.h" | ||
24 | #include "jpeglib.h" | ||
25 | |||
26 | |||
27 | /* Pointer to routine to upsample a single component */ | ||
28 | typedef JMETHOD(void, upsample1_ptr, | ||
29 | (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
30 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); | ||
31 | |||
32 | /* Private subobject */ | ||
33 | |||
34 | typedef struct { | ||
35 | struct jpeg_upsampler pub; /* public fields */ | ||
36 | |||
37 | /* Color conversion buffer. When using separate upsampling and color | ||
38 | * conversion steps, this buffer holds one upsampled row group until it | ||
39 | * has been color converted and output. | ||
40 | * Note: we do not allocate any storage for component(s) which are full-size, | ||
41 | * ie do not need rescaling. The corresponding entry of color_buf[] is | ||
42 | * simply set to point to the input data array, thereby avoiding copying. | ||
43 | */ | ||
44 | JSAMPARRAY color_buf[MAX_COMPONENTS]; | ||
45 | |||
46 | /* Per-component upsampling method pointers */ | ||
47 | upsample1_ptr methods[MAX_COMPONENTS]; | ||
48 | |||
49 | int next_row_out; /* counts rows emitted from color_buf */ | ||
50 | JDIMENSION rows_to_go; /* counts rows remaining in image */ | ||
51 | |||
52 | /* Height of an input row group for each component. */ | ||
53 | int rowgroup_height[MAX_COMPONENTS]; | ||
54 | |||
55 | /* These arrays save pixel expansion factors so that int_expand need not | ||
56 | * recompute them each time. They are unused for other upsampling methods. | ||
57 | */ | ||
58 | UINT8 h_expand[MAX_COMPONENTS]; | ||
59 | UINT8 v_expand[MAX_COMPONENTS]; | ||
60 | } my_upsampler; | ||
61 | |||
62 | typedef my_upsampler * my_upsample_ptr; | ||
63 | |||
64 | |||
65 | /* | ||
66 | * Initialize for an upsampling pass. | ||
67 | */ | ||
68 | |||
69 | METHODDEF(void) | ||
70 | start_pass_upsample (j_decompress_ptr cinfo) | ||
71 | { | ||
72 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | ||
73 | |||
74 | /* Mark the conversion buffer empty */ | ||
75 | upsample->next_row_out = cinfo->max_v_samp_factor; | ||
76 | /* Initialize total-height counter for detecting bottom of image */ | ||
77 | upsample->rows_to_go = cinfo->output_height; | ||
78 | } | ||
79 | |||
80 | |||
81 | /* | ||
82 | * Control routine to do upsampling (and color conversion). | ||
83 | * | ||
84 | * In this version we upsample each component independently. | ||
85 | * We upsample one row group into the conversion buffer, then apply | ||
86 | * color conversion a row at a time. | ||
87 | */ | ||
88 | |||
89 | METHODDEF(void) | ||
90 | sep_upsample (j_decompress_ptr cinfo, | ||
91 | JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, | ||
92 | JDIMENSION in_row_groups_avail, | ||
93 | JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, | ||
94 | JDIMENSION out_rows_avail) | ||
95 | { | ||
96 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | ||
97 | int ci; | ||
98 | jpeg_component_info * compptr; | ||
99 | JDIMENSION num_rows; | ||
100 | |||
101 | /* Fill the conversion buffer, if it's empty */ | ||
102 | if (upsample->next_row_out >= cinfo->max_v_samp_factor) { | ||
103 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | ||
104 | ci++, compptr++) { | ||
105 | /* Invoke per-component upsample method. Notice we pass a POINTER | ||
106 | * to color_buf[ci], so that fullsize_upsample can change it. | ||
107 | */ | ||
108 | (*upsample->methods[ci]) (cinfo, compptr, | ||
109 | input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]), | ||
110 | upsample->color_buf + ci); | ||
111 | } | ||
112 | upsample->next_row_out = 0; | ||
113 | } | ||
114 | |||
115 | /* Color-convert and emit rows */ | ||
116 | |||
117 | /* How many we have in the buffer: */ | ||
118 | num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out); | ||
119 | /* Not more than the distance to the end of the image. Need this test | ||
120 | * in case the image height is not a multiple of max_v_samp_factor: | ||
121 | */ | ||
122 | if (num_rows > upsample->rows_to_go) | ||
123 | num_rows = upsample->rows_to_go; | ||
124 | /* And not more than what the client can accept: */ | ||
125 | out_rows_avail -= *out_row_ctr; | ||
126 | if (num_rows > out_rows_avail) | ||
127 | num_rows = out_rows_avail; | ||
128 | |||
129 | (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf, | ||
130 | (JDIMENSION) upsample->next_row_out, | ||
131 | output_buf + *out_row_ctr, | ||
132 | (int) num_rows); | ||
133 | |||
134 | /* Adjust counts */ | ||
135 | *out_row_ctr += num_rows; | ||
136 | upsample->rows_to_go -= num_rows; | ||
137 | upsample->next_row_out += num_rows; | ||
138 | /* When the buffer is emptied, declare this input row group consumed */ | ||
139 | if (upsample->next_row_out >= cinfo->max_v_samp_factor) | ||
140 | (*in_row_group_ctr)++; | ||
141 | } | ||
142 | |||
143 | |||
144 | /* | ||
145 | * These are the routines invoked by sep_upsample to upsample pixel values | ||
146 | * of a single component. One row group is processed per call. | ||
147 | */ | ||
148 | |||
149 | |||
150 | /* | ||
151 | * For full-size components, we just make color_buf[ci] point at the | ||
152 | * input buffer, and thus avoid copying any data. Note that this is | ||
153 | * safe only because sep_upsample doesn't declare the input row group | ||
154 | * "consumed" until we are done color converting and emitting it. | ||
155 | */ | ||
156 | |||
157 | METHODDEF(void) | ||
158 | fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
159 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | ||
160 | { | ||
161 | *output_data_ptr = input_data; | ||
162 | } | ||
163 | |||
164 | |||
165 | /* | ||
166 | * This is a no-op version used for "uninteresting" components. | ||
167 | * These components will not be referenced by color conversion. | ||
168 | */ | ||
169 | |||
170 | METHODDEF(void) | ||
171 | noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
172 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | ||
173 | { | ||
174 | *output_data_ptr = NULL; /* safety check */ | ||
175 | } | ||
176 | |||
177 | |||
178 | /* | ||
179 | * This version handles any integral sampling ratios. | ||
180 | * This is not used for typical JPEG files, so it need not be fast. | ||
181 | * Nor, for that matter, is it particularly accurate: the algorithm is | ||
182 | * simple replication of the input pixel onto the corresponding output | ||
183 | * pixels. The hi-falutin sampling literature refers to this as a | ||
184 | * "box filter". A box filter tends to introduce visible artifacts, | ||
185 | * so if you are actually going to use 3:1 or 4:1 sampling ratios | ||
186 | * you would be well advised to improve this code. | ||
187 | */ | ||
188 | |||
189 | METHODDEF(void) | ||
190 | int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
191 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | ||
192 | { | ||
193 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | ||
194 | JSAMPARRAY output_data = *output_data_ptr; | ||
195 | register JSAMPROW inptr, outptr; | ||
196 | register JSAMPLE invalue; | ||
197 | register int h; | ||
198 | JSAMPROW outend; | ||
199 | int h_expand, v_expand; | ||
200 | int inrow, outrow; | ||
201 | |||
202 | h_expand = upsample->h_expand[compptr->component_index]; | ||
203 | v_expand = upsample->v_expand[compptr->component_index]; | ||
204 | |||
205 | inrow = outrow = 0; | ||
206 | while (outrow < cinfo->max_v_samp_factor) { | ||
207 | /* Generate one output row with proper horizontal expansion */ | ||
208 | inptr = input_data[inrow]; | ||
209 | outptr = output_data[outrow]; | ||
210 | outend = outptr + cinfo->output_width; | ||
211 | while (outptr < outend) { | ||
212 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | ||
213 | for (h = h_expand; h > 0; h--) { | ||
214 | *outptr++ = invalue; | ||
215 | } | ||
216 | } | ||
217 | /* Generate any additional output rows by duplicating the first one */ | ||
218 | if (v_expand > 1) { | ||
219 | jcopy_sample_rows(output_data, outrow, output_data, outrow+1, | ||
220 | v_expand-1, cinfo->output_width); | ||
221 | } | ||
222 | inrow++; | ||
223 | outrow += v_expand; | ||
224 | } | ||
225 | } | ||
226 | |||
227 | |||
228 | /* | ||
229 | * Fast processing for the common case of 2:1 horizontal and 1:1 vertical. | ||
230 | * It's still a box filter. | ||
231 | */ | ||
232 | |||
233 | METHODDEF(void) | ||
234 | h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
235 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | ||
236 | { | ||
237 | JSAMPARRAY output_data = *output_data_ptr; | ||
238 | register JSAMPROW inptr, outptr; | ||
239 | register JSAMPLE invalue; | ||
240 | JSAMPROW outend; | ||
241 | int outrow; | ||
242 | |||
243 | for (outrow = 0; outrow < cinfo->max_v_samp_factor; outrow++) { | ||
244 | inptr = input_data[outrow]; | ||
245 | outptr = output_data[outrow]; | ||
246 | outend = outptr + cinfo->output_width; | ||
247 | while (outptr < outend) { | ||
248 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | ||
249 | *outptr++ = invalue; | ||
250 | *outptr++ = invalue; | ||
251 | } | ||
252 | } | ||
253 | } | ||
254 | |||
255 | |||
256 | /* | ||
257 | * Fast processing for the common case of 2:1 horizontal and 2:1 vertical. | ||
258 | * It's still a box filter. | ||
259 | */ | ||
260 | |||
261 | METHODDEF(void) | ||
262 | h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | ||
263 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | ||
264 | { | ||
265 | JSAMPARRAY output_data = *output_data_ptr; | ||
266 | register JSAMPROW inptr, outptr; | ||
267 | register JSAMPLE invalue; | ||
268 | JSAMPROW outend; | ||
269 | int inrow, outrow; | ||
270 | |||
271 | inrow = outrow = 0; | ||
272 | while (outrow < cinfo->max_v_samp_factor) { | ||
273 | inptr = input_data[inrow]; | ||
274 | outptr = output_data[outrow]; | ||
275 | outend = outptr + cinfo->output_width; | ||
276 | while (outptr < outend) { | ||
277 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | ||
278 | *outptr++ = invalue; | ||
279 | *outptr++ = invalue; | ||
280 | } | ||
281 | jcopy_sample_rows(output_data, outrow, output_data, outrow+1, | ||
282 | 1, cinfo->output_width); | ||
283 | inrow++; | ||
284 | outrow += 2; | ||
285 | } | ||
286 | } | ||
287 | |||
288 | |||
289 | /* | ||
290 | * Module initialization routine for upsampling. | ||
291 | */ | ||
292 | |||
293 | GLOBAL(void) | ||
294 | jinit_upsampler (j_decompress_ptr cinfo) | ||
295 | { | ||
296 | my_upsample_ptr upsample; | ||
297 | int ci; | ||
298 | jpeg_component_info * compptr; | ||
299 | boolean need_buffer; | ||
300 | int h_in_group, v_in_group, h_out_group, v_out_group; | ||
301 | |||
302 | upsample = (my_upsample_ptr) | ||
303 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | ||
304 | SIZEOF(my_upsampler)); | ||
305 | cinfo->upsample = (struct jpeg_upsampler *) upsample; | ||
306 | upsample->pub.start_pass = start_pass_upsample; | ||
307 | upsample->pub.upsample = sep_upsample; | ||
308 | upsample->pub.need_context_rows = FALSE; /* until we find out differently */ | ||
309 | |||
310 | if (cinfo->CCIR601_sampling) /* this isn't supported */ | ||
311 | ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); | ||
312 | |||
313 | /* Verify we can handle the sampling factors, select per-component methods, | ||
314 | * and create storage as needed. | ||
315 | */ | ||
316 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | ||
317 | ci++, compptr++) { | ||
318 | /* Compute size of an "input group" after IDCT scaling. This many samples | ||
319 | * are to be converted to max_h_samp_factor * max_v_samp_factor pixels. | ||
320 | */ | ||
321 | h_in_group = (compptr->h_samp_factor * compptr->DCT_h_scaled_size) / | ||
322 | cinfo->min_DCT_h_scaled_size; | ||
323 | v_in_group = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) / | ||
324 | cinfo->min_DCT_v_scaled_size; | ||
325 | h_out_group = cinfo->max_h_samp_factor; | ||
326 | v_out_group = cinfo->max_v_samp_factor; | ||
327 | upsample->rowgroup_height[ci] = v_in_group; /* save for use later */ | ||
328 | need_buffer = TRUE; | ||
329 | if (! compptr->component_needed) { | ||
330 | /* Don't bother to upsample an uninteresting component. */ | ||
331 | upsample->methods[ci] = noop_upsample; | ||
332 | need_buffer = FALSE; | ||
333 | } else if (h_in_group == h_out_group && v_in_group == v_out_group) { | ||
334 | /* Fullsize components can be processed without any work. */ | ||
335 | upsample->methods[ci] = fullsize_upsample; | ||
336 | need_buffer = FALSE; | ||
337 | } else if (h_in_group * 2 == h_out_group && | ||
338 | v_in_group == v_out_group) { | ||
339 | /* Special case for 2h1v upsampling */ | ||
340 | upsample->methods[ci] = h2v1_upsample; | ||
341 | } else if (h_in_group * 2 == h_out_group && | ||
342 | v_in_group * 2 == v_out_group) { | ||
343 | /* Special case for 2h2v upsampling */ | ||
344 | upsample->methods[ci] = h2v2_upsample; | ||
345 | } else if ((h_out_group % h_in_group) == 0 && | ||
346 | (v_out_group % v_in_group) == 0) { | ||
347 | /* Generic integral-factors upsampling method */ | ||
348 | upsample->methods[ci] = int_upsample; | ||
349 | upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group); | ||
350 | upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group); | ||
351 | } else | ||
352 | ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); | ||
353 | if (need_buffer) { | ||
354 | upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray) | ||
355 | ((j_common_ptr) cinfo, JPOOL_IMAGE, | ||
356 | (JDIMENSION) jround_up((long) cinfo->output_width, | ||
357 | (long) cinfo->max_h_samp_factor), | ||
358 | (JDIMENSION) cinfo->max_v_samp_factor); | ||
359 | } | ||
360 | } | ||
361 | } | ||