Commit | Line | Data |
---|---|---|
e1929140 RR |
1 | /* |
2 | * jdsample.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 upsampling routines. | |
9 | * | |
10 | * Upsampling input data is counted in "row groups". A row group | |
11 | * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size) | |
12 | * sample rows of each component. Upsampling will normally produce | |
13 | * max_v_samp_factor pixel rows from each row group (but this could vary | |
14 | * if the upsampler is applying a scale factor of its own). | |
15 | * | |
16 | * An excellent reference for image resampling is | |
17 | * Digital Image Warping, George Wolberg, 1990. | |
18 | * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7. | |
19 | */ | |
20 | ||
21 | #define JPEG_INTERNALS | |
22 | #include "jinclude.h" | |
23 | #include "jpeglib.h" | |
24 | ||
25 | ||
26 | /* Pointer to routine to upsample a single component */ | |
27 | typedef JMETHOD(void, upsample1_ptr, | |
28 | (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
29 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); | |
30 | ||
31 | /* Private subobject */ | |
32 | ||
33 | typedef struct { | |
34 | struct jpeg_upsampler pub; /* public fields */ | |
35 | ||
36 | /* Color conversion buffer. When using separate upsampling and color | |
37 | * conversion steps, this buffer holds one upsampled row group until it | |
38 | * has been color converted and output. | |
39 | * Note: we do not allocate any storage for component(s) which are full-size, | |
40 | * ie do not need rescaling. The corresponding entry of color_buf[] is | |
41 | * simply set to point to the input data array, thereby avoiding copying. | |
42 | */ | |
43 | JSAMPARRAY color_buf[MAX_COMPONENTS]; | |
44 | ||
45 | /* Per-component upsampling method pointers */ | |
46 | upsample1_ptr methods[MAX_COMPONENTS]; | |
47 | ||
48 | int next_row_out; /* counts rows emitted from color_buf */ | |
49 | JDIMENSION rows_to_go; /* counts rows remaining in image */ | |
50 | ||
51 | /* Height of an input row group for each component. */ | |
52 | int rowgroup_height[MAX_COMPONENTS]; | |
53 | ||
54 | /* These arrays save pixel expansion factors so that int_expand need not | |
55 | * recompute them each time. They are unused for other upsampling methods. | |
56 | */ | |
57 | UINT8 h_expand[MAX_COMPONENTS]; | |
58 | UINT8 v_expand[MAX_COMPONENTS]; | |
59 | } my_upsampler; | |
60 | ||
61 | typedef my_upsampler * my_upsample_ptr; | |
62 | ||
63 | ||
64 | /* | |
65 | * Initialize for an upsampling pass. | |
66 | */ | |
67 | ||
68 | METHODDEF(void) | |
69 | start_pass_upsample (j_decompress_ptr cinfo) | |
70 | { | |
71 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | |
72 | ||
73 | /* Mark the conversion buffer empty */ | |
74 | upsample->next_row_out = cinfo->max_v_samp_factor; | |
75 | /* Initialize total-height counter for detecting bottom of image */ | |
76 | upsample->rows_to_go = cinfo->output_height; | |
77 | } | |
78 | ||
79 | ||
80 | /* | |
81 | * Control routine to do upsampling (and color conversion). | |
82 | * | |
83 | * In this version we upsample each component independently. | |
84 | * We upsample one row group into the conversion buffer, then apply | |
85 | * color conversion a row at a time. | |
86 | */ | |
87 | ||
88 | METHODDEF(void) | |
89 | sep_upsample (j_decompress_ptr cinfo, | |
90 | JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, | |
91 | JDIMENSION in_row_groups_avail, | |
92 | JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, | |
93 | JDIMENSION out_rows_avail) | |
94 | { | |
95 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | |
96 | int ci; | |
97 | jpeg_component_info * compptr; | |
98 | JDIMENSION num_rows; | |
99 | ||
100 | /* Fill the conversion buffer, if it's empty */ | |
101 | if (upsample->next_row_out >= cinfo->max_v_samp_factor) { | |
102 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | |
103 | ci++, compptr++) { | |
104 | /* Invoke per-component upsample method. Notice we pass a POINTER | |
105 | * to color_buf[ci], so that fullsize_upsample can change it. | |
106 | */ | |
107 | (*upsample->methods[ci]) (cinfo, compptr, | |
108 | input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]), | |
109 | upsample->color_buf + ci); | |
110 | } | |
111 | upsample->next_row_out = 0; | |
112 | } | |
113 | ||
114 | /* Color-convert and emit rows */ | |
115 | ||
116 | /* How many we have in the buffer: */ | |
117 | num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out); | |
118 | /* Not more than the distance to the end of the image. Need this test | |
119 | * in case the image height is not a multiple of max_v_samp_factor: | |
120 | */ | |
121 | if (num_rows > upsample->rows_to_go) | |
122 | num_rows = upsample->rows_to_go; | |
123 | /* And not more than what the client can accept: */ | |
124 | out_rows_avail -= *out_row_ctr; | |
125 | if (num_rows > out_rows_avail) | |
126 | num_rows = out_rows_avail; | |
127 | ||
128 | (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf, | |
129 | (JDIMENSION) upsample->next_row_out, | |
130 | output_buf + *out_row_ctr, | |
131 | (int) num_rows); | |
132 | ||
133 | /* Adjust counts */ | |
134 | *out_row_ctr += num_rows; | |
135 | upsample->rows_to_go -= num_rows; | |
136 | upsample->next_row_out += num_rows; | |
137 | /* When the buffer is emptied, declare this input row group consumed */ | |
138 | if (upsample->next_row_out >= cinfo->max_v_samp_factor) | |
139 | (*in_row_group_ctr)++; | |
140 | } | |
141 | ||
142 | ||
143 | /* | |
144 | * These are the routines invoked by sep_upsample to upsample pixel values | |
145 | * of a single component. One row group is processed per call. | |
146 | */ | |
147 | ||
148 | ||
149 | /* | |
150 | * For full-size components, we just make color_buf[ci] point at the | |
151 | * input buffer, and thus avoid copying any data. Note that this is | |
152 | * safe only because sep_upsample doesn't declare the input row group | |
153 | * "consumed" until we are done color converting and emitting it. | |
154 | */ | |
155 | ||
156 | METHODDEF(void) | |
157 | fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
158 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
159 | { | |
160 | *output_data_ptr = input_data; | |
161 | } | |
162 | ||
163 | ||
164 | /* | |
165 | * This is a no-op version used for "uninteresting" components. | |
166 | * These components will not be referenced by color conversion. | |
167 | */ | |
168 | ||
169 | METHODDEF(void) | |
170 | noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
171 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
172 | { | |
173 | *output_data_ptr = NULL; /* safety check */ | |
174 | } | |
175 | ||
176 | ||
177 | /* | |
178 | * This version handles any integral sampling ratios. | |
179 | * This is not used for typical JPEG files, so it need not be fast. | |
180 | * Nor, for that matter, is it particularly accurate: the algorithm is | |
181 | * simple replication of the input pixel onto the corresponding output | |
182 | * pixels. The hi-falutin sampling literature refers to this as a | |
183 | * "box filter". A box filter tends to introduce visible artifacts, | |
184 | * so if you are actually going to use 3:1 or 4:1 sampling ratios | |
185 | * you would be well advised to improve this code. | |
186 | */ | |
187 | ||
188 | METHODDEF(void) | |
189 | int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
190 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
191 | { | |
192 | my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample; | |
193 | JSAMPARRAY output_data = *output_data_ptr; | |
194 | register JSAMPROW inptr, outptr; | |
195 | register JSAMPLE invalue; | |
196 | register int h; | |
197 | JSAMPROW outend; | |
198 | int h_expand, v_expand; | |
199 | int inrow, outrow; | |
200 | ||
201 | h_expand = upsample->h_expand[compptr->component_index]; | |
202 | v_expand = upsample->v_expand[compptr->component_index]; | |
203 | ||
204 | inrow = outrow = 0; | |
205 | while (outrow < cinfo->max_v_samp_factor) { | |
206 | /* Generate one output row with proper horizontal expansion */ | |
207 | inptr = input_data[inrow]; | |
208 | outptr = output_data[outrow]; | |
209 | outend = outptr + cinfo->output_width; | |
210 | while (outptr < outend) { | |
211 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | |
212 | for (h = h_expand; h > 0; h--) { | |
213 | *outptr++ = invalue; | |
214 | } | |
215 | } | |
216 | /* Generate any additional output rows by duplicating the first one */ | |
217 | if (v_expand > 1) { | |
218 | jcopy_sample_rows(output_data, outrow, output_data, outrow+1, | |
219 | v_expand-1, cinfo->output_width); | |
220 | } | |
221 | inrow++; | |
222 | outrow += v_expand; | |
223 | } | |
224 | } | |
225 | ||
226 | ||
227 | /* | |
228 | * Fast processing for the common case of 2:1 horizontal and 1:1 vertical. | |
229 | * It's still a box filter. | |
230 | */ | |
231 | ||
232 | METHODDEF(void) | |
233 | h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
234 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
235 | { | |
236 | JSAMPARRAY output_data = *output_data_ptr; | |
237 | register JSAMPROW inptr, outptr; | |
238 | register JSAMPLE invalue; | |
239 | JSAMPROW outend; | |
240 | int inrow; | |
241 | ||
242 | for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { | |
243 | inptr = input_data[inrow]; | |
244 | outptr = output_data[inrow]; | |
245 | outend = outptr + cinfo->output_width; | |
246 | while (outptr < outend) { | |
247 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | |
248 | *outptr++ = invalue; | |
249 | *outptr++ = invalue; | |
250 | } | |
251 | } | |
252 | } | |
253 | ||
254 | ||
255 | /* | |
256 | * Fast processing for the common case of 2:1 horizontal and 2:1 vertical. | |
257 | * It's still a box filter. | |
258 | */ | |
259 | ||
260 | METHODDEF(void) | |
261 | h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
262 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
263 | { | |
264 | JSAMPARRAY output_data = *output_data_ptr; | |
265 | register JSAMPROW inptr, outptr; | |
266 | register JSAMPLE invalue; | |
267 | JSAMPROW outend; | |
268 | int inrow, outrow; | |
269 | ||
270 | inrow = outrow = 0; | |
271 | while (outrow < cinfo->max_v_samp_factor) { | |
272 | inptr = input_data[inrow]; | |
273 | outptr = output_data[outrow]; | |
274 | outend = outptr + cinfo->output_width; | |
275 | while (outptr < outend) { | |
276 | invalue = *inptr++; /* don't need GETJSAMPLE() here */ | |
277 | *outptr++ = invalue; | |
278 | *outptr++ = invalue; | |
279 | } | |
280 | jcopy_sample_rows(output_data, outrow, output_data, outrow+1, | |
281 | 1, cinfo->output_width); | |
282 | inrow++; | |
283 | outrow += 2; | |
284 | } | |
285 | } | |
286 | ||
287 | ||
288 | /* | |
289 | * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical. | |
290 | * | |
291 | * The upsampling algorithm is linear interpolation between pixel centers, | |
292 | * also known as a "triangle filter". This is a good compromise between | |
293 | * speed and visual quality. The centers of the output pixels are 1/4 and 3/4 | |
294 | * of the way between input pixel centers. | |
295 | * | |
296 | * A note about the "bias" calculations: when rounding fractional values to | |
297 | * integer, we do not want to always round 0.5 up to the next integer. | |
298 | * If we did that, we'd introduce a noticeable bias towards larger values. | |
299 | * Instead, this code is arranged so that 0.5 will be rounded up or down at | |
300 | * alternate pixel locations (a simple ordered dither pattern). | |
301 | */ | |
302 | ||
303 | METHODDEF(void) | |
304 | h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
305 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
306 | { | |
307 | JSAMPARRAY output_data = *output_data_ptr; | |
308 | register JSAMPROW inptr, outptr; | |
309 | register int invalue; | |
310 | register JDIMENSION colctr; | |
311 | int inrow; | |
312 | ||
313 | for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) { | |
314 | inptr = input_data[inrow]; | |
315 | outptr = output_data[inrow]; | |
316 | /* Special case for first column */ | |
317 | invalue = GETJSAMPLE(*inptr++); | |
318 | *outptr++ = (JSAMPLE) invalue; | |
319 | *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2); | |
320 | ||
321 | for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { | |
322 | /* General case: 3/4 * nearer pixel + 1/4 * further pixel */ | |
323 | invalue = GETJSAMPLE(*inptr++) * 3; | |
324 | *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2); | |
325 | *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2); | |
326 | } | |
327 | ||
328 | /* Special case for last column */ | |
329 | invalue = GETJSAMPLE(*inptr); | |
330 | *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2); | |
331 | *outptr++ = (JSAMPLE) invalue; | |
332 | } | |
333 | } | |
334 | ||
335 | ||
336 | /* | |
337 | * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical. | |
338 | * Again a triangle filter; see comments for h2v1 case, above. | |
339 | * | |
340 | * It is OK for us to reference the adjacent input rows because we demanded | |
341 | * context from the main buffer controller (see initialization code). | |
342 | */ | |
343 | ||
344 | METHODDEF(void) | |
345 | h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr, | |
346 | JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr) | |
347 | { | |
348 | JSAMPARRAY output_data = *output_data_ptr; | |
349 | register JSAMPROW inptr0, inptr1, outptr; | |
350 | #if BITS_IN_JSAMPLE == 8 | |
351 | register int thiscolsum, lastcolsum, nextcolsum; | |
352 | #else | |
353 | register INT32 thiscolsum, lastcolsum, nextcolsum; | |
354 | #endif | |
355 | register JDIMENSION colctr; | |
356 | int inrow, outrow, v; | |
357 | ||
358 | inrow = outrow = 0; | |
359 | while (outrow < cinfo->max_v_samp_factor) { | |
360 | for (v = 0; v < 2; v++) { | |
361 | /* inptr0 points to nearest input row, inptr1 points to next nearest */ | |
362 | inptr0 = input_data[inrow]; | |
363 | if (v == 0) /* next nearest is row above */ | |
364 | inptr1 = input_data[inrow-1]; | |
365 | else /* next nearest is row below */ | |
366 | inptr1 = input_data[inrow+1]; | |
367 | outptr = output_data[outrow++]; | |
368 | ||
369 | /* Special case for first column */ | |
370 | thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); | |
371 | nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); | |
372 | *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4); | |
373 | *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); | |
374 | lastcolsum = thiscolsum; thiscolsum = nextcolsum; | |
375 | ||
376 | for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) { | |
377 | /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */ | |
378 | /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */ | |
379 | nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++); | |
380 | *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); | |
381 | *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4); | |
382 | lastcolsum = thiscolsum; thiscolsum = nextcolsum; | |
383 | } | |
384 | ||
385 | /* Special case for last column */ | |
386 | *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4); | |
387 | *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4); | |
388 | } | |
389 | inrow++; | |
390 | } | |
391 | } | |
392 | ||
393 | ||
394 | /* | |
395 | * Module initialization routine for upsampling. | |
396 | */ | |
397 | ||
398 | GLOBAL(void) | |
399 | jinit_upsampler (j_decompress_ptr cinfo) | |
400 | { | |
401 | my_upsample_ptr upsample; | |
402 | int ci; | |
403 | jpeg_component_info * compptr; | |
404 | boolean need_buffer, do_fancy; | |
405 | int h_in_group, v_in_group, h_out_group, v_out_group; | |
406 | ||
407 | upsample = (my_upsample_ptr) | |
408 | (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, | |
409 | SIZEOF(my_upsampler)); | |
410 | cinfo->upsample = (struct jpeg_upsampler *) upsample; | |
411 | upsample->pub.start_pass = start_pass_upsample; | |
412 | upsample->pub.upsample = sep_upsample; | |
413 | upsample->pub.need_context_rows = FALSE; /* until we find out differently */ | |
414 | ||
415 | if (cinfo->CCIR601_sampling) /* this isn't supported */ | |
416 | ERREXIT(cinfo, JERR_CCIR601_NOTIMPL); | |
417 | ||
418 | /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1, | |
419 | * so don't ask for it. | |
420 | */ | |
421 | do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1; | |
422 | ||
423 | /* Verify we can handle the sampling factors, select per-component methods, | |
424 | * and create storage as needed. | |
425 | */ | |
426 | for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; | |
427 | ci++, compptr++) { | |
428 | /* Compute size of an "input group" after IDCT scaling. This many samples | |
429 | * are to be converted to max_h_samp_factor * max_v_samp_factor pixels. | |
430 | */ | |
431 | h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) / | |
432 | cinfo->min_DCT_scaled_size; | |
433 | v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) / | |
434 | cinfo->min_DCT_scaled_size; | |
435 | h_out_group = cinfo->max_h_samp_factor; | |
436 | v_out_group = cinfo->max_v_samp_factor; | |
437 | upsample->rowgroup_height[ci] = v_in_group; /* save for use later */ | |
438 | need_buffer = TRUE; | |
439 | if (! compptr->component_needed) { | |
440 | /* Don't bother to upsample an uninteresting component. */ | |
441 | upsample->methods[ci] = noop_upsample; | |
442 | need_buffer = FALSE; | |
443 | } else if (h_in_group == h_out_group && v_in_group == v_out_group) { | |
444 | /* Fullsize components can be processed without any work. */ | |
445 | upsample->methods[ci] = fullsize_upsample; | |
446 | need_buffer = FALSE; | |
447 | } else if (h_in_group * 2 == h_out_group && | |
448 | v_in_group == v_out_group) { | |
449 | /* Special cases for 2h1v upsampling */ | |
450 | if (do_fancy && compptr->downsampled_width > 2) | |
451 | upsample->methods[ci] = h2v1_fancy_upsample; | |
452 | else | |
453 | upsample->methods[ci] = h2v1_upsample; | |
454 | } else if (h_in_group * 2 == h_out_group && | |
455 | v_in_group * 2 == v_out_group) { | |
456 | /* Special cases for 2h2v upsampling */ | |
457 | if (do_fancy && compptr->downsampled_width > 2) { | |
458 | upsample->methods[ci] = h2v2_fancy_upsample; | |
459 | upsample->pub.need_context_rows = TRUE; | |
460 | } else | |
461 | upsample->methods[ci] = h2v2_upsample; | |
462 | } else if ((h_out_group % h_in_group) == 0 && | |
463 | (v_out_group % v_in_group) == 0) { | |
464 | /* Generic integral-factors upsampling method */ | |
465 | upsample->methods[ci] = int_upsample; | |
466 | upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group); | |
467 | upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group); | |
468 | } else | |
469 | ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL); | |
470 | if (need_buffer) { | |
471 | upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray) | |
472 | ((j_common_ptr) cinfo, JPOOL_IMAGE, | |
473 | (JDIMENSION) jround_up((long) cinfo->output_width, | |
474 | (long) cinfo->max_h_samp_factor), | |
475 | (JDIMENSION) cinfo->max_v_samp_factor); | |
476 | } | |
477 | } | |
478 | } |