LCOV - code coverage report
Current view: directory - media/libjpeg - jcsample.c (source / functions) Found Hit Coverage
Test: app.info Lines: 197 36 18.3 %
Date: 2012-06-02 Functions: 10 5 50.0 %

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

Generated by: LCOV version 1.7