1 /*

     2  * jcsample.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 downsampling routines.

     9  *

    10  * Downsampling input data is counted in "row groups".  A row group

    11  * is defined to be max_v_samp_factor pixel rows of each component,

    12  * from which the downsampler produces v_samp_factor sample rows.

    13  * A single row group is processed in each call to the downsampler module.

    14  *

    15  * The downsampler is responsible for edge-expansion of its output data

    16  * to fill an integral number of DCT blocks horizontally.  The source buffer

    17  * may be modified if it is helpful for this purpose (the source buffer is

    18  * allocated wide enough to correspond to the desired output width).

    19  * The caller (the prep controller) is responsible for vertical padding.

    20  *

    21  * The downsampler may request "context rows" by setting need_context_rows

    22  * during startup.  In this case, the input arrays will contain at least

    23  * one row group's worth of pixels above and below the passed-in data;

    24  * the caller will create dummy rows at image top and bottom by replicating

    25  * the first or last real pixel row.

    26  *

    27  * An excellent reference for image resampling is

    28  *   Digital Image Warping, George Wolberg, 1990.

    29  *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.

    30  *

    31  * The downsampling algorithm used here is a simple average of the source

    32  * pixels covered by the output pixel.  The hi-falutin sampling literature

    33  * refers to this as a "box filter".  In general the characteristics of a box

    34  * filter are not very good, but for the specific cases we normally use (1:1

    35  * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not

    36  * nearly so bad.  If you intend to use other sampling ratios, you'd be well

    37  * advised to improve this code.

    38  *

    39  * A simple input-smoothing capability is provided.  This is mainly intended

    40  * for cleaning up color-dithered GIF input files (if you find it inadequate,

    41  * we suggest using an external filtering program such as pnmconvol).  When

    42  * enabled, each input pixel P is replaced by a weighted sum of itself and its

    43  * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,

    44  * where SF = (smoothing_factor / 1024).

    45  * Currently, smoothing is only supported for 2h2v sampling factors.

    46  */

    47 

    48 #define JPEG_INTERNALS

    49 #include "jinclude.h"

    50 #include "jpeglib.h"

    51 

    52 

    53 /* Pointer to routine to downsample a single component */

    54 typedef JMETHOD(void, downsample1_ptr,

    55 		(j_compress_ptr cinfo, jpeg_component_info * compptr,

    56 		 JSAMPARRAY input_data, JSAMPARRAY output_data));

    57 

    58 /* Private subobject */

    59 

    60 typedef struct {

    61   struct jpeg_downsampler pub;	/* public fields */

    62 

    63   /* Downsampling method pointers, one per component */

    64   downsample1_ptr methods[MAX_COMPONENTS];

    65 } my_downsampler;

    66 

    67 typedef my_downsampler * my_downsample_ptr;

    68 

    69 

    70 /*

    71  * Initialize for a downsampling pass.

    72  */

    73 

    74 METHODDEF(void)

    75 start_pass_downsample (j_compress_ptr cinfo)

    76 {

    77   /* no work for now */

    78 }

    79 

    80 

    81 /*

    82  * Expand a component horizontally from width input_cols to width output_cols,

    83  * by duplicating the rightmost samples.

    84  */

    85 

    86 LOCAL(void)

    87 expand_right_edge (JSAMPARRAY image_data, int num_rows,

    88 		   JDIMENSION input_cols, JDIMENSION output_cols)

    89 {

    90   register JSAMPROW ptr;

    91   register JSAMPLE pixval;

    92   register int count;

    93   int row;

    94   int numcols = (int) (output_cols - input_cols);

    95 

    96   if (numcols > 0) {

    97     for (row = 0; row < num_rows; row++) {

    98       ptr = image_data[row] + input_cols;

    99       pixval = ptr[-1];		/* don't need GETJSAMPLE() here */

   100       for (count = numcols; count > 0; count--)

   101 	*ptr++ = pixval;

   102     }

   103   }

   104 }

   105 

   106 

   107 /*

   108  * Do downsampling for a whole row group (all components).

   109  *

   110  * In this version we simply downsample each component independently.

   111  */

   112 

   113 METHODDEF(void)

   114 sep_downsample (j_compress_ptr cinfo,

   115 		JSAMPIMAGE input_buf, JDIMENSION in_row_index,

   116 		JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)

   117 {

   118   my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;

   119   int ci;

   120   jpeg_component_info * compptr;

   121   JSAMPARRAY in_ptr, out_ptr;

   122 

   123   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;

   124        ci++, compptr++) {

   125     in_ptr = input_buf[ci] + in_row_index;

   126     out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);

   127     (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);

   128   }

   129 }

   130 

   131 

   132 /*

   133  * Downsample pixel values of a single component.

   134  * One row group is processed per call.

   135  * This version handles arbitrary integral sampling ratios, without smoothing.

   136  * Note that this version is not actually used for customary sampling ratios.

   137  */

   138 

   139 METHODDEF(void)

   140 int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,

   141 		JSAMPARRAY input_data, JSAMPARRAY output_data)

   142 {

   143   int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;

   144   JDIMENSION outcol, outcol_h;	/* outcol_h == outcol*h_expand */

   145   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;

   146   JSAMPROW inptr, outptr;

   147   INT32 outvalue;

   148 

   149   h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;

   150   v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;

   151   numpix = h_expand * v_expand;

   152   numpix2 = numpix/2;

   153 

   154   /* Expand input data enough to let all the output samples be generated

   155    * by the standard loop.  Special-casing padded output would be more

   156    * efficient.

   157    */

   158   expand_right_edge(input_data, cinfo->max_v_samp_factor,

   159 		    cinfo->image_width, output_cols * h_expand);

   160 

   161   inrow = 0;

   162   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {

   163     outptr = output_data[outrow];

   164     for (outcol = 0, outcol_h = 0; outcol < output_cols;

   165 	 outcol++, outcol_h += h_expand) {

   166       outvalue = 0;

   167       for (v = 0; v < v_expand; v++) {

   168 	inptr = input_data[inrow+v] + outcol_h;

   169 	for (h = 0; h < h_expand; h++) {

   170 	  outvalue += (INT32) GETJSAMPLE(*inptr++);

   171 	}

   172       }

   173       *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);

   174     }

   175     inrow += v_expand;

   176   }

   177 }

   178 

   179 

   180 /*

   181  * Downsample pixel values of a single component.

   182  * This version handles the special case of a full-size component,

   183  * without smoothing.

   184  */

   185 

   186 METHODDEF(void)

   187 fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,

   188 		     JSAMPARRAY input_data, JSAMPARRAY output_data)

   189 {

   190   /* Copy the data */

   191   jcopy_sample_rows(input_data, 0, output_data, 0,

   192 		    cinfo->max_v_samp_factor, cinfo->image_width);

   193   /* Edge-expand */

   194   expand_right_edge(output_data, cinfo->max_v_samp_factor,

   195 		    cinfo->image_width, compptr->width_in_blocks * DCTSIZE);

   196 }

   197 

   198 

   199 /*

   200  * Downsample pixel values of a single component.

   201  * This version handles the common case of 2:1 horizontal and 1:1 vertical,

   202  * without smoothing.

   203  *

   204  * A note about the "bias" calculations: when rounding fractional values to

   205  * integer, we do not want to always round 0.5 up to the next integer.

   206  * If we did that, we'd introduce a noticeable bias towards larger values.

   207  * Instead, this code is arranged so that 0.5 will be rounded up or down at

   208  * alternate pixel locations (a simple ordered dither pattern).

   209  */

   210 

   211 METHODDEF(void)

   212 h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,

   213 		 JSAMPARRAY input_data, JSAMPARRAY output_data)

   214 {

   215   int outrow;

   216   JDIMENSION outcol;

   217   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;

   218   register JSAMPROW inptr, outptr;

   219   register int bias;

   220 

   221   /* Expand input data enough to let all the output samples be generated

   222    * by the standard loop.  Special-casing padded output would be more

   223    * efficient.

   224    */

   225   expand_right_edge(input_data, cinfo->max_v_samp_factor,

   226 		    cinfo->image_width, output_cols * 2);

   227 

   228   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {

   229     outptr = output_data[outrow];

   230     inptr = input_data[outrow];

   231     bias = 0;			/* bias = 0,1,0,1,... for successive samples */

   232     for (outcol = 0; outcol < output_cols; outcol++) {

   233       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])

   234 			      + bias) >> 1);

   235       bias ^= 1;		/* 0=>1, 1=>0 */

   236       inptr += 2;

   237     }

   238   }

   239 }

   240 

   241 

   242 /*

   243  * Downsample pixel values of a single component.

   244  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,

   245  * without smoothing.

   246  */

   247 

   248 METHODDEF(void)

   249 h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,

   250 		 JSAMPARRAY input_data, JSAMPARRAY output_data)

   251 {

   252   int inrow, outrow;

   253   JDIMENSION outcol;

   254   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;

   255   register JSAMPROW inptr0, inptr1, outptr;

   256   register int bias;

   257 

   258   /* Expand input data enough to let all the output samples be generated

   259    * by the standard loop.  Special-casing padded output would be more

   260    * efficient.

   261    */

   262   expand_right_edge(input_data, cinfo->max_v_samp_factor,

   263 		    cinfo->image_width, output_cols * 2);

   264 

   265   inrow = 0;

   266   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {

   267     outptr = output_data[outrow];

   268     inptr0 = input_data[inrow];

   269     inptr1 = input_data[inrow+1];

   270     bias = 1;			/* bias = 1,2,1,2,... for successive samples */

   271     for (outcol = 0; outcol < output_cols; outcol++) {

   272       *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +

   273 			      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])

   274 			      + bias) >> 2);

   275       bias ^= 3;		/* 1=>2, 2=>1 */

   276       inptr0 += 2; inptr1 += 2;

   277     }

   278     inrow += 2;

   279   }

   280 }

   281 

   282 

   283 #ifdef INPUT_SMOOTHING_SUPPORTED

   284 

   285 /*

   286  * Downsample pixel values of a single component.

   287  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,

   288  * with smoothing.  One row of context is required.

   289  */

   290 

   291 METHODDEF(void)

   292 h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,

   293 			JSAMPARRAY input_data, JSAMPARRAY output_data)

   294 {

   295   int inrow, outrow;

   296   JDIMENSION colctr;

   297   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;

   298   register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;

   299   INT32 membersum, neighsum, memberscale, neighscale;

   300 

   301   /* Expand input data enough to let all the output samples be generated

   302    * by the standard loop.  Special-casing padded output would be more

   303    * efficient.

   304    */

   305   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,

   306 		    cinfo->image_width, output_cols * 2);

   307 

   308   /* We don't bother to form the individual "smoothed" input pixel values;

   309    * we can directly compute the output which is the average of the four

   310    * smoothed values.  Each of the four member pixels contributes a fraction

   311    * (1-8*SF) to its own smoothed image and a fraction SF to each of the three

   312    * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final

   313    * output.  The four corner-adjacent neighbor pixels contribute a fraction

   314    * SF to just one smoothed pixel, or SF/4 to the final output; while the

   315    * eight edge-adjacent neighbors contribute SF to each of two smoothed

   316    * pixels, or SF/2 overall.  In order to use integer arithmetic, these

   317    * factors are scaled by 2^16 = 65536.

   318    * Also recall that SF = smoothing_factor / 1024.

   319    */

   320 

   321   memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */

   322   neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */

   323 

   324   inrow = 0;

   325   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {

   326     outptr = output_data[outrow];

   327     inptr0 = input_data[inrow];

   328     inptr1 = input_data[inrow+1];

   329     above_ptr = input_data[inrow-1];

   330     below_ptr = input_data[inrow+2];

   331 

   332     /* Special case for first column: pretend column -1 is same as column 0 */

   333     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +

   334 		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);

   335     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +

   336 	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +

   337 	       GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +

   338 	       GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);

   339     neighsum += neighsum;

   340     neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +

   341 		GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);

   342     membersum = membersum * memberscale + neighsum * neighscale;

   343     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);

   344     inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;

   345 

   346     for (colctr = output_cols - 2; colctr > 0; colctr--) {

   347       /* sum of pixels directly mapped to this output element */

   348       membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +

   349 		  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);

   350       /* sum of edge-neighbor pixels */

   351       neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +

   352 		 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +

   353 		 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +

   354 		 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);

   355       /* The edge-neighbors count twice as much as corner-neighbors */

   356       neighsum += neighsum;

   357       /* Add in the corner-neighbors */

   358       neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +

   359 		  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);

   360       /* form final output scaled up by 2^16 */

   361       membersum = membersum * memberscale + neighsum * neighscale;

   362       /* round, descale and output it */

   363       *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);

   364       inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;

   365     }

   366 

   367     /* Special case for last column */

   368     membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +

   369 		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);

   370     neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +

   371 	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +

   372 	       GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +

   373 	       GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);

   374     neighsum += neighsum;

   375     neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +

   376 		GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);

   377     membersum = membersum * memberscale + neighsum * neighscale;

   378     *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

   379 

   380     inrow += 2;

   381   }

   382 }

   383 

   384 

   385 /*

   386  * Downsample pixel values of a single component.

   387  * This version handles the special case of a full-size component,

   388  * with smoothing.  One row of context is required.

   389  */

   390 

   391 METHODDEF(void)

   392 fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,

   393 			    JSAMPARRAY input_data, JSAMPARRAY output_data)

   394 {

   395   int outrow;

   396   JDIMENSION colctr;

   397   JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;

   398   register JSAMPROW inptr, above_ptr, below_ptr, outptr;

   399   INT32 membersum, neighsum, memberscale, neighscale;

   400   int colsum, lastcolsum, nextcolsum;

   401 

   402   /* Expand input data enough to let all the output samples be generated

   403    * by the standard loop.  Special-casing padded output would be more

   404    * efficient.

   405    */

   406   expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,

   407 		    cinfo->image_width, output_cols);

   408 

   409   /* Each of the eight neighbor pixels contributes a fraction SF to the

   410    * smoothed pixel, while the main pixel contributes (1-8*SF).  In order

   411    * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.

   412    * Also recall that SF = smoothing_factor / 1024.

   413    */

   414 

   415   memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */

   416   neighscale = cinfo->smoothing_factor * 64; /* scaled SF */

   417 

   418   for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {

   419     outptr = output_data[outrow];

   420     inptr = input_data[outrow];

   421     above_ptr = input_data[outrow-1];

   422     below_ptr = input_data[outrow+1];

   423 

   424     /* Special case for first column */

   425     colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +

   426 	     GETJSAMPLE(*inptr);

   427     membersum = GETJSAMPLE(*inptr++);

   428     nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +

   429 		 GETJSAMPLE(*inptr);

   430     neighsum = colsum + (colsum - membersum) + nextcolsum;

   431     membersum = membersum * memberscale + neighsum * neighscale;

   432     *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);

   433     lastcolsum = colsum; colsum = nextcolsum;

   434 

   435     for (colctr = output_cols - 2; colctr > 0; colctr--) {

   436       membersum = GETJSAMPLE(*inptr++);

   437       above_ptr++; below_ptr++;

   438       nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +

   439 		   GETJSAMPLE(*inptr);

   440       neighsum = lastcolsum + (colsum - membersum) + nextcolsum;

   441       membersum = membersum * memberscale + neighsum * neighscale;

   442       *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);

   443       lastcolsum = colsum; colsum = nextcolsum;

   444     }

   445 

   446     /* Special case for last column */

   447     membersum = GETJSAMPLE(*inptr);

   448     neighsum = lastcolsum + (colsum - membersum) + colsum;

   449     membersum = membersum * memberscale + neighsum * neighscale;

   450     *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

   451 

   452   }

   453 }

   454 

   455 #endif /* INPUT_SMOOTHING_SUPPORTED */

   456 

   457 

   458 /*

   459  * Module initialization routine for downsampling.

   460  * Note that we must select a routine for each component.

   461  */

   462 

   463 GLOBAL(void)

   464 jinit_downsampler (j_compress_ptr cinfo)

   465 {

   466   my_downsample_ptr downsample;

   467   int ci;

   468   jpeg_component_info * compptr;

   469   boolean smoothok = TRUE;

   470 

   471   downsample = (my_downsample_ptr)

   472     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,

   473 				SIZEOF(my_downsampler));

   474   cinfo->downsample = (struct jpeg_downsampler *) downsample;

   475   downsample->pub.start_pass = start_pass_downsample;

   476   downsample->pub.downsample = sep_downsample;

   477   downsample->pub.need_context_rows = FALSE;

   478 

   479   if (cinfo->CCIR601_sampling)

   480     ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);

   481 

   482   /* Verify we can handle the sampling factors, and set up method pointers */

   483   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;

   484        ci++, compptr++) {

   485     if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&

   486 	compptr->v_samp_factor == cinfo->max_v_samp_factor) {

   487 #ifdef INPUT_SMOOTHING_SUPPORTED

   488       if (cinfo->smoothing_factor) {

   489 	downsample->methods[ci] = fullsize_smooth_downsample;

   490 	downsample->pub.need_context_rows = TRUE;

   491       } else

   492 #endif

   493 	downsample->methods[ci] = fullsize_downsample;

   494     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&

   495 	       compptr->v_samp_factor == cinfo->max_v_samp_factor) {

   496       smoothok = FALSE;

   497       downsample->methods[ci] = h2v1_downsample;

   498     } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&

   499 	       compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {

   500 #ifdef INPUT_SMOOTHING_SUPPORTED

   501       if (cinfo->smoothing_factor) {

   502 	downsample->methods[ci] = h2v2_smooth_downsample;

   503 	downsample->pub.need_context_rows = TRUE;

   504       } else

   505 #endif

   506 	downsample->methods[ci] = h2v2_downsample;

   507     } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&

   508 	       (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {

   509       smoothok = FALSE;

   510       downsample->methods[ci] = int_downsample;

   511     } else

   512       ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);

   513   }

   514 

   515 #ifdef INPUT_SMOOTHING_SUPPORTED

   516   if (cinfo->smoothing_factor && !smoothok)

   517     TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);

   518 #endif

   519 }