4 * Copyright (C) 1991-1996, Thomas G. Lane.
5 * Modified 2002-2020 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.
9 * This file contains upsampling routines.
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).
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.
22 #define JPEG_INTERNALS
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
, JSAMPIMAGE output_data_ptr
));
32 /* Private subobject */
35 struct jpeg_upsampler pub
; /* public fields */
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.
44 JSAMPARRAY color_buf
[MAX_COMPONENTS
];
46 /* Per-component upsampling method pointers */
47 upsample1_ptr methods
[MAX_COMPONENTS
];
49 int next_row_out
; /* counts rows emitted from color_buf */
50 JDIMENSION rows_to_go
; /* counts rows remaining in image */
52 /* Height of an input row group for each component. */
53 int rowgroup_height
[MAX_COMPONENTS
];
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.
58 UINT8 h_expand
[MAX_COMPONENTS
];
59 UINT8 v_expand
[MAX_COMPONENTS
];
62 typedef my_upsampler
* my_upsample_ptr
;
66 * Initialize for an upsampling pass.
70 start_pass_upsample (j_decompress_ptr cinfo
)
72 my_upsample_ptr upsample
= (my_upsample_ptr
) cinfo
->upsample
;
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
;
82 * Control routine to do upsampling (and color conversion).
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.
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
)
96 my_upsample_ptr upsample
= (my_upsample_ptr
) cinfo
->upsample
;
98 jpeg_component_info
* compptr
;
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
;
105 /* Don't bother to upsample an uninteresting component. */
106 if (! compptr
->component_needed
)
108 /* Invoke per-component upsample method. Notice we pass a POINTER
109 * to color_buf[ci], so that fullsize_upsample can change it.
111 (*upsample
->methods
[ci
]) (cinfo
, compptr
,
112 input_buf
[ci
] + (*in_row_group_ctr
* upsample
->rowgroup_height
[ci
]),
113 upsample
->color_buf
+ ci
);
115 upsample
->next_row_out
= 0;
118 /* Color-convert and emit rows */
120 /* How many we have in the buffer: */
121 num_rows
= (JDIMENSION
) (cinfo
->max_v_samp_factor
- upsample
->next_row_out
);
122 /* Not more than the distance to the end of the image. Need this test
123 * in case the image height is not a multiple of max_v_samp_factor:
125 if (num_rows
> upsample
->rows_to_go
)
126 num_rows
= upsample
->rows_to_go
;
127 /* And not more than what the client can accept: */
128 out_rows_avail
-= *out_row_ctr
;
129 if (num_rows
> out_rows_avail
)
130 num_rows
= out_rows_avail
;
132 (*cinfo
->cconvert
->color_convert
) (cinfo
, upsample
->color_buf
,
133 (JDIMENSION
) upsample
->next_row_out
,
134 output_buf
+ *out_row_ctr
,
138 *out_row_ctr
+= num_rows
;
139 upsample
->rows_to_go
-= num_rows
;
140 upsample
->next_row_out
+= num_rows
;
141 /* When the buffer is emptied, declare this input row group consumed */
142 if (upsample
->next_row_out
>= cinfo
->max_v_samp_factor
)
143 (*in_row_group_ctr
)++;
148 * These are the routines invoked by sep_upsample to upsample pixel values
149 * of a single component. One row group is processed per call.
154 * For full-size components, we just make color_buf[ci] point at the
155 * input buffer, and thus avoid copying any data. Note that this is
156 * safe only because sep_upsample doesn't declare the input row group
157 * "consumed" until we are done color converting and emitting it.
161 fullsize_upsample (j_decompress_ptr cinfo
, jpeg_component_info
* compptr
,
162 JSAMPARRAY input_data
, JSAMPIMAGE output_data_ptr
)
164 *output_data_ptr
= input_data
;
169 * This version handles any integral sampling ratios.
170 * This is not used for typical JPEG files, so it need not be fast.
171 * Nor, for that matter, is it particularly accurate: the algorithm is
172 * simple replication of the input pixel onto the corresponding output
173 * pixels. The hi-falutin sampling literature refers to this as a
174 * "box filter". A box filter tends to introduce visible artifacts,
175 * so if you are actually going to use 3:1 or 4:1 sampling ratios
176 * you would be well advised to improve this code.
180 int_upsample (j_decompress_ptr cinfo
, jpeg_component_info
* compptr
,
181 JSAMPARRAY input_data
, JSAMPIMAGE output_data_ptr
)
183 my_upsample_ptr upsample
= (my_upsample_ptr
) cinfo
->upsample
;
184 JSAMPARRAY output_data
, output_end
;
185 register JSAMPROW inptr
, outptr
;
186 register JSAMPLE invalue
;
189 int h_expand
, v_expand
;
191 h_expand
= upsample
->h_expand
[compptr
->component_index
];
192 v_expand
= upsample
->v_expand
[compptr
->component_index
];
194 output_data
= *output_data_ptr
;
195 output_end
= output_data
+ cinfo
->max_v_samp_factor
;
196 for (; output_data
< output_end
; output_data
+= v_expand
) {
197 /* Generate one output row with proper horizontal expansion */
198 inptr
= *input_data
++;
199 outptr
= *output_data
;
200 outend
= outptr
+ cinfo
->output_width
;
201 while (outptr
< outend
) {
202 invalue
= *inptr
++; /* don't need GETJSAMPLE() here */
203 for (h
= h_expand
; h
> 0; h
--) {
207 /* Generate any additional output rows by duplicating the first one */
209 jcopy_sample_rows(output_data
, output_data
+ 1,
210 v_expand
- 1, cinfo
->output_width
);
217 * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
218 * It's still a box filter.
222 h2v1_upsample (j_decompress_ptr cinfo
, jpeg_component_info
* compptr
,
223 JSAMPARRAY input_data
, JSAMPIMAGE output_data_ptr
)
225 JSAMPARRAY output_data
= *output_data_ptr
;
226 register JSAMPROW inptr
, outptr
;
227 register JSAMPLE invalue
;
231 for (outrow
= 0; outrow
< cinfo
->max_v_samp_factor
; outrow
++) {
232 inptr
= input_data
[outrow
];
233 outptr
= output_data
[outrow
];
234 outend
= outptr
+ cinfo
->output_width
;
235 while (outptr
< outend
) {
236 invalue
= *inptr
++; /* don't need GETJSAMPLE() here */
245 * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
246 * It's still a box filter.
250 h2v2_upsample (j_decompress_ptr cinfo
, jpeg_component_info
* compptr
,
251 JSAMPARRAY input_data
, JSAMPIMAGE output_data_ptr
)
253 JSAMPARRAY output_data
, output_end
;
254 register JSAMPROW inptr
, outptr
;
255 register JSAMPLE invalue
;
258 output_data
= *output_data_ptr
;
259 output_end
= output_data
+ cinfo
->max_v_samp_factor
;
260 for (; output_data
< output_end
; output_data
+= 2) {
261 inptr
= *input_data
++;
262 outptr
= *output_data
;
263 outend
= outptr
+ cinfo
->output_width
;
264 while (outptr
< outend
) {
265 invalue
= *inptr
++; /* don't need GETJSAMPLE() here */
269 jcopy_sample_rows(output_data
, output_data
+ 1,
270 1, cinfo
->output_width
);
276 * Module initialization routine for upsampling.
280 jinit_upsampler (j_decompress_ptr cinfo
)
282 my_upsample_ptr upsample
;
284 jpeg_component_info
* compptr
;
285 int h_in_group
, v_in_group
, h_out_group
, v_out_group
;
287 upsample
= (my_upsample_ptr
) (*cinfo
->mem
->alloc_small
)
288 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
, SIZEOF(my_upsampler
));
289 cinfo
->upsample
= &upsample
->pub
;
290 upsample
->pub
.start_pass
= start_pass_upsample
;
291 upsample
->pub
.upsample
= sep_upsample
;
292 upsample
->pub
.need_context_rows
= FALSE
; /* until we find out differently */
294 if (cinfo
->CCIR601_sampling
) /* this isn't supported */
295 ERREXIT(cinfo
, JERR_CCIR601_NOTIMPL
);
297 /* Verify we can handle the sampling factors, select per-component methods,
298 * and create storage as needed.
300 for (ci
= 0, compptr
= cinfo
->comp_info
; ci
< cinfo
->num_components
;
302 /* Don't bother to upsample an uninteresting component. */
303 if (! compptr
->component_needed
)
305 /* Compute size of an "input group" after IDCT scaling. This many samples
306 * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
308 h_in_group
= (compptr
->h_samp_factor
* compptr
->DCT_h_scaled_size
) /
309 cinfo
->min_DCT_h_scaled_size
;
310 v_in_group
= (compptr
->v_samp_factor
* compptr
->DCT_v_scaled_size
) /
311 cinfo
->min_DCT_v_scaled_size
;
312 h_out_group
= cinfo
->max_h_samp_factor
;
313 v_out_group
= cinfo
->max_v_samp_factor
;
314 upsample
->rowgroup_height
[ci
] = v_in_group
; /* save for use later */
315 if (h_in_group
== h_out_group
&& v_in_group
== v_out_group
) {
316 /* Fullsize components can be processed without any work. */
317 upsample
->methods
[ci
] = fullsize_upsample
;
318 continue; /* don't need to allocate buffer */
320 if (h_in_group
* 2 == h_out_group
&& v_in_group
== v_out_group
) {
321 /* Special case for 2h1v upsampling */
322 upsample
->methods
[ci
] = h2v1_upsample
;
323 } else if (h_in_group
* 2 == h_out_group
&&
324 v_in_group
* 2 == v_out_group
) {
325 /* Special case for 2h2v upsampling */
326 upsample
->methods
[ci
] = h2v2_upsample
;
327 } else if ((h_out_group
% h_in_group
) == 0 &&
328 (v_out_group
% v_in_group
) == 0) {
329 /* Generic integral-factors upsampling method */
330 upsample
->methods
[ci
] = int_upsample
;
331 upsample
->h_expand
[ci
] = (UINT8
) (h_out_group
/ h_in_group
);
332 upsample
->v_expand
[ci
] = (UINT8
) (v_out_group
/ v_in_group
);
334 ERREXIT(cinfo
, JERR_FRACT_SAMPLE_NOTIMPL
);
335 upsample
->color_buf
[ci
] = (*cinfo
->mem
->alloc_sarray
)
336 ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
337 (JDIMENSION
) jround_up((long) cinfo
->output_width
,
338 (long) cinfo
->max_h_samp_factor
),
339 (JDIMENSION
) cinfo
->max_v_samp_factor
);