• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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, 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)
start_pass_downsample(j_compress_ptr cinfo)82 start_pass_downsample(j_compress_ptr cinfo)
83 {
84   /* no work for now */
85 }
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)
expand_right_edge(JSAMPARRAY image_data,int num_rows,JDIMENSION input_cols,JDIMENSION output_cols)94 expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols,
95                   JDIMENSION output_cols)
96 {
97   register JSAMPROW ptr;
98   register JSAMPLE pixval;
99   register int count;
100   int row;
101   int numcols = (int)(output_cols - input_cols);
102 
103   if (numcols > 0) {
104     for (row = 0; row < num_rows; row++) {
105       ptr = image_data[row] + input_cols;
106       pixval = ptr[-1];         /* don't need GETJSAMPLE() here */
107       for (count = numcols; count > 0; count--)
108         *ptr++ = pixval;
109     }
110   }
111 }
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)
sep_downsample(j_compress_ptr cinfo,JSAMPIMAGE input_buf,JDIMENSION in_row_index,JSAMPIMAGE output_buf,JDIMENSION out_row_group_index)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 {
125   my_downsample_ptr downsample = (my_downsample_ptr)cinfo->downsample;
126   int ci;
127   jpeg_component_info *compptr;
128   JSAMPARRAY in_ptr, out_ptr;
129 
130   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
131        ci++, compptr++) {
132     in_ptr = input_buf[ci] + in_row_index;
133     out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
134     (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
135   }
136 }
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)
int_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)147 int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
148                JSAMPARRAY input_data, JSAMPARRAY output_data)
149 {
150   int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
151   JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
152   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
153   JSAMPROW inptr, outptr;
154   JLONG outvalue;
155 
156   h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
157   v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
158   numpix = h_expand * v_expand;
159   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   expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
166                     output_cols * h_expand);
167 
168   inrow = 0;
169   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
170     outptr = output_data[outrow];
171     for (outcol = 0, outcol_h = 0; outcol < output_cols;
172          outcol++, outcol_h += h_expand) {
173       outvalue = 0;
174       for (v = 0; v < v_expand; v++) {
175         inptr = input_data[inrow + v] + outcol_h;
176         for (h = 0; h < h_expand; h++) {
177           outvalue += (JLONG)GETJSAMPLE(*inptr++);
178         }
179       }
180       *outptr++ = (JSAMPLE)((outvalue + numpix2) / numpix);
181     }
182     inrow += v_expand;
183   }
184 }
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)
fullsize_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)194 fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
195                     JSAMPARRAY input_data, JSAMPARRAY output_data)
196 {
197   /* Copy the data */
198   jcopy_sample_rows(input_data, 0, output_data, 0, cinfo->max_v_samp_factor,
199                     cinfo->image_width);
200   /* Edge-expand */
201   expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
202                     compptr->width_in_blocks * DCTSIZE);
203 }
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)
h2v1_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)219 h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
220                 JSAMPARRAY input_data, JSAMPARRAY output_data)
221 {
222   int outrow;
223   JDIMENSION outcol;
224   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
225   register JSAMPROW inptr, outptr;
226   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   expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
233                     output_cols * 2);
234 
235   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
236     outptr = output_data[outrow];
237     inptr = input_data[outrow];
238     bias = 0;                   /* bias = 0,1,0,1,... for successive samples */
239     for (outcol = 0; outcol < output_cols; outcol++) {
240       *outptr++ =
241         (JSAMPLE)((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1]) + bias) >> 1);
242       bias ^= 1;                /* 0=>1, 1=>0 */
243       inptr += 2;
244     }
245   }
246 }
247 
248 
249 /*
250  * Downsample pixel values of a single component.
251  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
252  * without smoothing.
253  */
254 
255 METHODDEF(void)
h2v2_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)256 h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
257                 JSAMPARRAY input_data, JSAMPARRAY output_data)
258 {
259   int inrow, outrow;
260   JDIMENSION outcol;
261   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
262   register JSAMPROW inptr0, inptr1, outptr;
263   register int bias;
264 
265   /* Expand input data enough to let all the output samples be generated
266    * by the standard loop.  Special-casing padded output would be more
267    * efficient.
268    */
269   expand_right_edge(input_data, cinfo->max_v_samp_factor, cinfo->image_width,
270                     output_cols * 2);
271 
272   inrow = 0;
273   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
274     outptr = output_data[outrow];
275     inptr0 = input_data[inrow];
276     inptr1 = input_data[inrow + 1];
277     bias = 1;                   /* bias = 1,2,1,2,... for successive samples */
278     for (outcol = 0; outcol < output_cols; outcol++) {
279       *outptr++ =
280         (JSAMPLE)((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
281                    GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]) + bias) >> 2);
282       bias ^= 3;                /* 1=>2, 2=>1 */
283       inptr0 += 2;  inptr1 += 2;
284     }
285     inrow += 2;
286   }
287 }
288 
289 
290 #ifdef INPUT_SMOOTHING_SUPPORTED
291 
292 /*
293  * Downsample pixel values of a single component.
294  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
295  * with smoothing.  One row of context is required.
296  */
297 
298 METHODDEF(void)
h2v2_smooth_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)299 h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
300                        JSAMPARRAY input_data, JSAMPARRAY output_data)
301 {
302   int inrow, outrow;
303   JDIMENSION colctr;
304   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
305   register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
306   JLONG membersum, neighsum, memberscale, neighscale;
307 
308   /* Expand input data enough to let all the output samples be generated
309    * by the standard loop.  Special-casing padded output would be more
310    * efficient.
311    */
312   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
313                     cinfo->image_width, output_cols * 2);
314 
315   /* We don't bother to form the individual "smoothed" input pixel values;
316    * we can directly compute the output which is the average of the four
317    * smoothed values.  Each of the four member pixels contributes a fraction
318    * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
319    * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
320    * output.  The four corner-adjacent neighbor pixels contribute a fraction
321    * SF to just one smoothed pixel, or SF/4 to the final output; while the
322    * eight edge-adjacent neighbors contribute SF to each of two smoothed
323    * pixels, or SF/2 overall.  In order to use integer arithmetic, these
324    * factors are scaled by 2^16 = 65536.
325    * Also recall that SF = smoothing_factor / 1024.
326    */
327 
328   memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
329   neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
330 
331   inrow = 0;
332   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
333     outptr = output_data[outrow];
334     inptr0 = input_data[inrow];
335     inptr1 = input_data[inrow + 1];
336     above_ptr = input_data[inrow - 1];
337     below_ptr = input_data[inrow + 2];
338 
339     /* Special case for first column: pretend column -1 is same as column 0 */
340     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
341                 GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
342     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
343                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
344                GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
345                GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
346     neighsum += neighsum;
347     neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
348                 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
349     membersum = membersum * memberscale + neighsum * neighscale;
350     *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
351     inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
352 
353     for (colctr = output_cols - 2; colctr > 0; colctr--) {
354       /* sum of pixels directly mapped to this output element */
355       membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
356                   GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
357       /* sum of edge-neighbor pixels */
358       neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
359                  GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
360                  GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
361                  GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
362       /* The edge-neighbors count twice as much as corner-neighbors */
363       neighsum += neighsum;
364       /* Add in the corner-neighbors */
365       neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
366                   GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
367       /* form final output scaled up by 2^16 */
368       membersum = membersum * memberscale + neighsum * neighscale;
369       /* round, descale and output it */
370       *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
371       inptr0 += 2;  inptr1 += 2;  above_ptr += 2;  below_ptr += 2;
372     }
373 
374     /* Special case for last column */
375     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
376                 GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
377     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
378                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
379                GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
380                GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
381     neighsum += neighsum;
382     neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
383                 GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
384     membersum = membersum * memberscale + neighsum * neighscale;
385     *outptr = (JSAMPLE)((membersum + 32768) >> 16);
386 
387     inrow += 2;
388   }
389 }
390 
391 
392 /*
393  * Downsample pixel values of a single component.
394  * This version handles the special case of a full-size component,
395  * with smoothing.  One row of context is required.
396  */
397 
398 METHODDEF(void)
fullsize_smooth_downsample(j_compress_ptr cinfo,jpeg_component_info * compptr,JSAMPARRAY input_data,JSAMPARRAY output_data)399 fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
400                            JSAMPARRAY input_data, JSAMPARRAY output_data)
401 {
402   int outrow;
403   JDIMENSION colctr;
404   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
405   register JSAMPROW inptr, above_ptr, below_ptr, outptr;
406   JLONG membersum, neighsum, memberscale, neighscale;
407   int colsum, lastcolsum, nextcolsum;
408 
409   /* Expand input data enough to let all the output samples be generated
410    * by the standard loop.  Special-casing padded output would be more
411    * efficient.
412    */
413   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
414                     cinfo->image_width, output_cols);
415 
416   /* Each of the eight neighbor pixels contributes a fraction SF to the
417    * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
418    * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
419    * Also recall that SF = smoothing_factor / 1024.
420    */
421 
422   memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
423   neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
424 
425   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
426     outptr = output_data[outrow];
427     inptr = input_data[outrow];
428     above_ptr = input_data[outrow - 1];
429     below_ptr = input_data[outrow + 1];
430 
431     /* Special case for first column */
432     colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
433              GETJSAMPLE(*inptr);
434     membersum = GETJSAMPLE(*inptr++);
435     nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
436                  GETJSAMPLE(*inptr);
437     neighsum = colsum + (colsum - membersum) + nextcolsum;
438     membersum = membersum * memberscale + neighsum * neighscale;
439     *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
440     lastcolsum = colsum;  colsum = nextcolsum;
441 
442     for (colctr = output_cols - 2; colctr > 0; colctr--) {
443       membersum = GETJSAMPLE(*inptr++);
444       above_ptr++;  below_ptr++;
445       nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
446                    GETJSAMPLE(*inptr);
447       neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
448       membersum = membersum * memberscale + neighsum * neighscale;
449       *outptr++ = (JSAMPLE)((membersum + 32768) >> 16);
450       lastcolsum = colsum;  colsum = nextcolsum;
451     }
452 
453     /* Special case for last column */
454     membersum = GETJSAMPLE(*inptr);
455     neighsum = lastcolsum + (colsum - membersum) + colsum;
456     membersum = membersum * memberscale + neighsum * neighscale;
457     *outptr = (JSAMPLE)((membersum + 32768) >> 16);
458 
459   }
460 }
461 
462 #endif /* INPUT_SMOOTHING_SUPPORTED */
463 
464 
465 /*
466  * Module initialization routine for downsampling.
467  * Note that we must select a routine for each component.
468  */
469 
470 GLOBAL(void)
jinit_downsampler(j_compress_ptr cinfo)471 jinit_downsampler(j_compress_ptr cinfo)
472 {
473   my_downsample_ptr downsample;
474   int ci;
475   jpeg_component_info *compptr;
476   boolean smoothok = TRUE;
477 
478   downsample = (my_downsample_ptr)
479     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
480                                 sizeof(my_downsampler));
481   cinfo->downsample = (struct jpeg_downsampler *)downsample;
482   downsample->pub.start_pass = start_pass_downsample;
483   downsample->pub.downsample = sep_downsample;
484   downsample->pub.need_context_rows = FALSE;
485 
486   if (cinfo->CCIR601_sampling)
487     ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
488 
489   /* Verify we can handle the sampling factors, and set up method pointers */
490   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
491        ci++, compptr++) {
492     if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
493         compptr->v_samp_factor == cinfo->max_v_samp_factor) {
494 #ifdef INPUT_SMOOTHING_SUPPORTED
495       if (cinfo->smoothing_factor) {
496         downsample->methods[ci] = fullsize_smooth_downsample;
497         downsample->pub.need_context_rows = TRUE;
498       } else
499 #endif
500         downsample->methods[ci] = fullsize_downsample;
501     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
502                compptr->v_samp_factor == cinfo->max_v_samp_factor) {
503       smoothok = FALSE;
504       if (jsimd_can_h2v1_downsample())
505         downsample->methods[ci] = jsimd_h2v1_downsample;
506       else
507         downsample->methods[ci] = h2v1_downsample;
508     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
509                compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
510 #ifdef INPUT_SMOOTHING_SUPPORTED
511       if (cinfo->smoothing_factor) {
512 #if defined(__mips__)
513         if (jsimd_can_h2v2_smooth_downsample())
514           downsample->methods[ci] = jsimd_h2v2_smooth_downsample;
515         else
516 #endif
517           downsample->methods[ci] = h2v2_smooth_downsample;
518         downsample->pub.need_context_rows = TRUE;
519       } else
520 #endif
521       {
522         if (jsimd_can_h2v2_downsample())
523           downsample->methods[ci] = jsimd_h2v2_downsample;
524         else
525           downsample->methods[ci] = h2v2_downsample;
526       }
527     } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
528                (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
529       smoothok = FALSE;
530       downsample->methods[ci] = int_downsample;
531     } else
532       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
533   }
534 
535 #ifdef INPUT_SMOOTHING_SUPPORTED
536   if (cinfo->smoothing_factor && !smoothok)
537     TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
538 #endif
539 }
540