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