// Need external definition of: scaleX, scaleY

  // Up to scaleX-1 pixel columns and scaleY pixel rows may be discarded

  // (those not fitting in a scaleX*scaleY block). The discarded pixels are

  // along the right and bottom border of the image, respectively.

  // Benchmark on screenshot for 1 MP: 2.6ms or less (twice as fast as scaleImage!)

  int w, h, w2, h2;

  int[] finalPixels;

  void scaleDown(BufferedImage img) {

    // TODO: remove the slow part

    scaleDown(main grabbableIntPixels_fastOrSlow(img));

  }

  void scaleDown(GrabbableIntPixels gp) {

    w = gp.w;

    int h = this.h = gp.h;

    int w2 = this.w2 = w/scaleX, h2 = this.h2 = h/scaleY;

    int stride = gp.scanlineStride;

    int scaleArea = scaleX*scaleY;

    int[] newPixels = finalPixels = new int[w2*h2];

    int iRow = gp.offset, iOut = 0;

    int[] pixels = gp.data;

    for y to h2: {

      int iIn = iRow;

      for x to w2: {

        // making one pixel of output image inside this block

        int r = 0, g = 0, b = 0;

        int iSub = iIn;

        for subY to scaleY: {

          for subX to scaleX: {

            int rgb = pixels[iSub+subX];

            r += (rgb >> 16) & 0xFF;

            g += (rgb >> 8) & 0xFF;

            b += rgb & 0xFF;

          }

          iSub += stride;

        }

        iIn += scaleX; // advance input scaleX pixels to the right

        newPixels[iOut++] = rgbIntFullAlpha(r/scaleArea, g/scaleArea, b/scaleArea);

      }

      iRow += stride*scaleY;

    } // for y

  }

  BufferedImage get(BufferedImage img) {

    scaleDown(img);

    ret get();

  }

  BufferedImage get() {

    ret bufferedImage(w2, h2, finalPixels);

  }

  GrabbableIntPixels grabbableIntPixels() {

    ret GrabbableIntPixels(finalPixels, w2, h2, 0, w2);

  }