src/main/java/org/apache/pdfbox/jbig2/image/Scanline.java - pdfbox-jbig2 - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.pdfbox.jbig2.image;

 import java.awt.image.MultiPixelPackedSampleModel;
 import java.awt.image.Raster;
 import java.awt.image.SampleModel;
 import java.awt.image.SinglePixelPackedSampleModel;
 import java.awt.image.WritableRaster;


 abstract class Scanline {
   public interface ScanlineFilter {
     public void filter(int x, int y, int componentIndex, Object data, int length);
   }


   /**
    * A Scanline for pixel interleaved byte data with three components. Although its name contains
    * "BGR" it doesn't really matter how the components are organized, als long as there are three of
    * them.
    */
   protected static final class ByteBGRScanline extends Scanline {
     private final Raster srcRaster;
     private final WritableRaster dstRaster;

     private final int data[];

     protected ByteBGRScanline(Raster src, WritableRaster dst, final int length) {
       super(length);
       srcRaster = src;
       dstRaster = dst;

       data = new int[3 * length];
     }

     @Override
     protected void accumulate(final int weight, final Scanline dst) {
       final ByteBGRScanline bcs = (ByteBGRScanline) dst;

       final int abuf[] = data;
       final int bbuf[] = bcs.data;

       for (int b = 0; b < bbuf.length; b++)
         bbuf[b] += weight * abuf[b];
     }

     @Override
     protected void clear() {
       final int[] b = data;
       for (int j = 0; j < b.length; j++)
         b[j] = 0;
     }

     @Override
     protected void fetch(final int x, final int y) {
       srcRaster.getPixels(x, y, length, 1, data);
     }

     @Override
     protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
       final ByteBGRScanline bcs = (ByteBGRScanline) dst;
       final int nx = dst.length;

       // start sum at 1<<shift-1 for rounding
       final int start[] = new int[]{
           1 << postShift[0] - 1, 1 << postShift[1] - 1, 1 << postShift[2] - 1
       };
       final int abuf[] = data;
       final int bbuf[] = bcs.data;

       // the next two blocks are duplicated except for the missing shift
       // operation if preShift==0.
       if (preShift[0] != 0 || preShift[1] != 0 || preShift[2] != 0)
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           int sumr = start[0];
           int sumg = start[1];
           int sumb = start[2];
           for (int wp = 0, ap = wtab.i0 * 3; wp < an && ap < abuf.length; wp++) {
             final int w = wtab.weights[wp];
             sumr += w * (abuf[ap++] >> preShift[0]);
             sumg += w * (abuf[ap++] >> preShift[1]);
             sumb += w * (abuf[ap++] >> preShift[2]);
           }

           int t = sumr >> postShift[0];
           bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
           t = sumg >> postShift[1];
           bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
           t = sumb >> postShift[2];
           bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
         }
       else
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           int sumr = start[0];
           int sumg = start[1];
           int sumb = start[2];
           for (int wp = 0, ap = wtab.i0 * 3; wp < an && ap < abuf.length; wp++) {
             final int w = wtab.weights[wp];
             sumr += w * abuf[ap++];
             sumg += w * abuf[ap++];
             sumb += w * abuf[ap++];
           }

           bbuf[bp++] = sumr >> postShift[0];
           bbuf[bp++] = sumg >> postShift[1];
           bbuf[bp++] = sumb >> postShift[2];
         }
     }

     @Override
     protected void shift(final int[] shift) {
       final int half[] = new int[]{
           1 << shift[0] - 1, 1 << shift[1] - 1, 1 << shift[2] - 1
       };

       final int abuf[] = data;

       for (int b = 0; b < abuf.length;) {
         for (int c = 0; c < 3; c++, b++) {
           final int t = abuf[b] + half[c] >> shift[c];
           abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
         }
       }
     }

     @Override
     protected void store(final int x, final int y) {
       dstRaster.setPixels(x, y, length, 1, data);
     }
   }

   /**
    * A Scanline for packed integer pixels.
    */
   protected static final class IntegerSinglePixelPackedScanline extends Scanline {
     private final Raster srcRaster;
     private final WritableRaster dstRaster;

     private final int data[];
     private final int[] bitMasks;
     private final int[] bitOffsets;
     private final int componentCount;
     private final SinglePixelPackedSampleModel srcSM;
     private final int tmp[];

     protected IntegerSinglePixelPackedScanline(Raster src, WritableRaster dst, final int length) {
       super(length);
       srcRaster = src;
       dstRaster = dst;

       srcSM = (SinglePixelPackedSampleModel) srcRaster.getSampleModel();

       bitMasks = srcSM.getBitMasks();
       bitOffsets = srcSM.getBitOffsets();
       componentCount = bitMasks.length;

       if (componentCount != bitOffsets.length || bitOffsets.length != srcSM.getNumBands())
         throw new IllegalArgumentException("weird: getBitMasks().length != getBitOffsets().length");

       tmp = new int[componentCount];

       data = new int[componentCount * length];
     }

     @Override
     protected void accumulate(final int weight, final Scanline dst) {
       final IntegerSinglePixelPackedScanline ispps = (IntegerSinglePixelPackedScanline) dst;

       final int abuf[] = data;
       final int bbuf[] = ispps.data;

       for (int b = 0; b < bbuf.length; b++)
         bbuf[b] += weight * abuf[b];
     }

     @Override
     protected void clear() {
       final int[] b = data;
       for (int j = 0; j < b.length; j++)
         b[j] = 0;
     }

     @Override
     protected void fetch(final int x, final int y) {
       srcRaster.getPixels(x, y, length, 1, data);
     }

     @Override
     protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
       final IntegerSinglePixelPackedScanline ispps = (IntegerSinglePixelPackedScanline) dst;
       final int nx = dst.length;

       // start sum at 1<<shift-1 for rounding
       final int start[] = tmp;
       for (int c = 0; c < componentCount; c++)
         start[c] = 1 << postShift[c] - 1;

       final int abuf[] = data;
       final int bbuf[] = ispps.data;

       // the next two blocks are duplicated except for the missing shift
       // operation if preShift==0.
       boolean hasPreShift = false;
       for (int c = 0; c < componentCount && !hasPreShift; c++)
         hasPreShift |= preShift[c] != 0;
       if (hasPreShift)
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           for (int c = 0; c < componentCount; c++) {
             int sum = start[c];
             for (int wp = 0, ap = wtab.i0 * componentCount + c; wp < an && ap < abuf.length; wp++, ap += componentCount)
               sum += wtab.weights[wp] * (abuf[ap] >> preShift[c]);

             final int t = sum >> postShift[c];
             bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
           }
         }
       else
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           for (int c = 0; c < componentCount; c++) {
             int sum = start[c];
             for (int wp = 0, ap = wtab.i0 * componentCount + c; wp < an && ap < abuf.length; wp++, ap += componentCount)
               sum += wtab.weights[wp] * abuf[ap];

             bbuf[bp++] = sum >> postShift[c];
           }
         }
     }

     @Override
     protected void shift(final int[] shift) {
       final int half[] = tmp;
       for (int c = 0; c < componentCount; c++)
         half[c] = 1 << shift[c] - 1;

       final int abuf[] = data;

       for (int b = 0; b < abuf.length;) {
         for (int c = 0; c < componentCount; c++, b++) {
           final int t = abuf[b] + half[c] >> shift[c];
           abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
         }
       }
     }

     @Override
     protected void store(final int x, final int y) {
       dstRaster.setPixels(x, y, length, 1, data);
     }
   }

   /**
    * A Scanline for packed integer pixels.
    */
   protected static final class GenericRasterScanline extends Scanline {
     private final Raster srcRaster;
     private final WritableRaster dstRaster;

     private final int componentCount;
     private final int data[][];
     private final SampleModel srcSM;
     private final SampleModel dstSM;
     private final int channelMask[];
     private final int[] tmp;
     private final ScanlineFilter inputFilter;

     protected GenericRasterScanline(Raster src, WritableRaster dst, final int length, int bitsPerChannel[],
         ScanlineFilter inputFilter) {
       super(length);
       srcRaster = src;
       dstRaster = dst;
       this.inputFilter = inputFilter;

       srcSM = srcRaster.getSampleModel();
       dstSM = dstRaster.getSampleModel();

       componentCount = srcSM.getNumBands();

       if (componentCount != dstSM.getNumBands())
         throw new IllegalArgumentException("weird: src raster num bands != dst raster num bands");

       tmp = new int[componentCount];

       data = new int[componentCount][];
       for (int i = 0; i < data.length; i++)
         data[i] = new int[length];

       channelMask = new int[componentCount];
       for (int c = 0; c < componentCount; c++)
         channelMask[c] = (1 << bitsPerChannel[c]) - 1;
     }

     @Override
     protected void accumulate(final int weight, final Scanline dst) {
       final GenericRasterScanline grs = (GenericRasterScanline) dst;

       final int l = grs.data[0].length;
       for (int c = 0; c < componentCount; c++) {
         final int ac[] = data[c];
         final int bc[] = grs.data[c];

         for (int b = 0; b < l; b++)
           bc[b] += weight * ac[b];
       }
     }

     @Override
     protected void clear() {
       for (int c = 0; c < componentCount; c++) {
         final int[] b = data[c];
         for (int x = 0; x < b.length; x++)
           b[x] = 0;
       }
     }

     @Override
     protected void fetch(final int x, final int y) {
       for (int c = 0; c < componentCount; c++) {
         srcRaster.getSamples(x, y, length, 1, c, data[c]);
         if (null != inputFilter)
           inputFilter.filter(x, y, c, data[c], length);
       }
     }

     @Override
     protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
       final GenericRasterScanline grs = (GenericRasterScanline) dst;
       final int nx = dst.length;

       // start sum at 1<<shift-1 for rounding
       final int start[] = tmp;
       for (int c = 0; c < componentCount; c++)
         start[c] = 1 << postShift[c] - 1;

       final int l = data[0].length;

       // the next two blocks are duplicated except for the missing shift
       // operation if preShift==0.
       boolean hasPreShift = false;
       for (int c = 0; c < componentCount && !hasPreShift; c++)
         hasPreShift |= preShift[c] != 0;
       if (hasPreShift)
         for (int c = 0; c < componentCount; c++) {
           final int ac[] = data[c];
           final int bc[] = grs.data[c];
           final int m = channelMask[c];
           for (int b = 0; b < nx; b++) {
             final Weighttab wtab = tabs[b];
             final int an = wtab.weights.length;

             int sum = start[c];
             for (int wp = 0, ap = wtab.i0; wp < an && ap < l; wp++, ap++)
               sum += wtab.weights[wp] * (ac[ap] >> preShift[c]);

             final int t = sum >> postShift[c];
             bc[b] = t < 0 ? 0 : t > m ? m : t;
           }
         }
       else
         for (int c = 0; c < componentCount; c++) {
           final int ac[] = data[c];
           final int bc[] = grs.data[c];

           for (int b = 0; b < nx; b++) {
             final Weighttab wtab = tabs[b];
             final int an = wtab.weights.length;

             int sum = start[c];
             for (int wp = 0, ap = wtab.i0; wp < an && ap < l; wp++, ap++)
               sum += wtab.weights[wp] * ac[ap];

             bc[b] = sum >> postShift[c];
           }
         }
     }

     @Override
     protected void shift(final int[] shift) {
       final int half[] = tmp;
       for (int c = 0; c < componentCount; c++)
         half[c] = 1 << shift[c] - 1;

       final int abuf[][] = data;

       final int l = abuf[0].length;
       for (int c = 0; c < componentCount; c++) {
         final int ac[] = data[c];
         final int m = channelMask[c];

         for (int a = 0; a < l; a++) {
           final int t = ac[a] + half[c] >> shift[c];
           ac[a] = t < 0 ? 0 : t > m ? m : t;
         }
       }
     }

     @Override
     protected void store(final int x, final int y) {
       final int nx = length;
       for (int c = 0; c < componentCount; c++)
         dstRaster.setSamples(x, y, nx, 1, c, data[c]);
     }
   }

   /**
    * A Scanline for BiLevel input data ({@link MultiPixelPackedSampleModel}) to indexed output data
    * (<code>sun.awt.image.ByteInterleavedRaster</code>).
    */
   protected static final class ByteBiLevelPackedScanline extends Scanline {
     private final Raster srcRaster;
     private final WritableRaster dstRaster;

     private final int data[];

     protected ByteBiLevelPackedScanline(Raster src, WritableRaster dst, final int length) {
       super(length);
       srcRaster = src;
       dstRaster = dst;

       data = new int[length];
     }

     @Override
     protected void accumulate(final int weight, final Scanline dst) {
       final ByteBiLevelPackedScanline bblps = (ByteBiLevelPackedScanline) dst;

       final int abuf[] = data;
       final int bbuf[] = bblps.data;

       for (int b = 0; b < bbuf.length; b++)
         bbuf[b] += weight * abuf[b];
     }

     @Override
     protected void clear() {
       final int[] b = data;
       for (int j = 0; j < b.length; j++)
         b[j] = 0;
     }

     @Override
     protected void fetch(final int x, final int y) {
       srcRaster.getPixels(x, y, length, 1, data);
       for (int i = 0; i < length; i++)
         if (data[i] != 0)
           data[i] = 255;
     }

     @Override
     protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
       final ByteBiLevelPackedScanline bblps = (ByteBiLevelPackedScanline) dst;
       final int nx = dst.length;

       // start sum at 1<<shift-1 for rounding
       final int start = 1 << postShift[0] - 1;
       final int abuf[] = data;
       final int bbuf[] = bblps.data;

       // the next two blocks are duplicated except for the missing shift
       // operation if preShift==0.
       final int preShift0 = preShift[0];
       final int postShift0 = postShift[0];
       if (preShift0 != 0)
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           int sum = start;
           for (int wp = 0, ap = wtab.i0; wp < an && ap < abuf.length; wp++) {
             sum += wtab.weights[wp] * (abuf[ap++] >> preShift0);
           }

           final int t = sum >> postShift0;
           bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
         }
       else
         for (int bp = 0, b = 0; b < nx; b++) {
           final Weighttab wtab = tabs[b];
           final int an = wtab.weights.length;

           int sum = start;
           for (int wp = 0, ap = wtab.i0; wp < an && ap < abuf.length; wp++) {
             sum += wtab.weights[wp] * abuf[ap++];
           }

           bbuf[bp++] = sum >> postShift0;
         }
     }

     @Override
     protected void shift(final int[] shift) {
       final int shift0 = shift[0];
       final int half = 1 << shift0 - 1;

       final int abuf[] = data;

       for (int b = 0; b < abuf.length; b++) {
         final int t = abuf[b] + half >> shift0;
         abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
       }
     }

     @Override
     protected void store(final int x, final int y) {
       dstRaster.setPixels(x, y, length, 1, data);
     }
   }

   int y;
   protected final int length;

   protected Scanline(final int width) {
     length = width;
   }

   protected final int getWidth() {
     return length;
   }

   protected abstract void clear();

   protected abstract void fetch(int x, int y);

   protected abstract void filter(int[] preShift, int[] postShift, Weighttab[] xweights, Scanline dst);

   protected abstract void accumulate(int weight, Scanline dst);

   protected abstract void shift(int[] finalshift);

   protected abstract void store(int x, int y);
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.pdfbox.jbig2.image;

	import java.awt.image.MultiPixelPackedSampleModel;
	import java.awt.image.Raster;
	import java.awt.image.SampleModel;
	import java.awt.image.SinglePixelPackedSampleModel;
	import java.awt.image.WritableRaster;


	abstract class Scanline {
	public interface ScanlineFilter {
	public void filter(int x, int y, int componentIndex, Object data, int length);
	}


	/**
	* A Scanline for pixel interleaved byte data with three components. Although its name contains
	* "BGR" it doesn't really matter how the components are organized, als long as there are three of
	* them.
	*/
	protected static final class ByteBGRScanline extends Scanline {
	private final Raster srcRaster;
	private final WritableRaster dstRaster;

	private final int data[];

	protected ByteBGRScanline(Raster src, WritableRaster dst, final int length) {
	super(length);
	srcRaster = src;
	dstRaster = dst;

	data = new int[3 * length];
	}

	@Override
	protected void accumulate(final int weight, final Scanline dst) {
	final ByteBGRScanline bcs = (ByteBGRScanline) dst;

	final int abuf[] = data;
	final int bbuf[] = bcs.data;

	for (int b = 0; b < bbuf.length; b++)
	bbuf[b] += weight * abuf[b];
	}

	@Override
	protected void clear() {
	final int[] b = data;
	for (int j = 0; j < b.length; j++)
	b[j] = 0;
	}

	@Override
	protected void fetch(final int x, final int y) {
	srcRaster.getPixels(x, y, length, 1, data);
	}

	@Override
	protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
	final ByteBGRScanline bcs = (ByteBGRScanline) dst;
	final int nx = dst.length;

	// start sum at 1<<shift-1 for rounding
	final int start[] = new int[]{
	1 << postShift[0] - 1, 1 << postShift[1] - 1, 1 << postShift[2] - 1
	};
	final int abuf[] = data;
	final int bbuf[] = bcs.data;

	// the next two blocks are duplicated except for the missing shift
	// operation if preShift==0.
	if (preShift[0] != 0 \|\| preShift[1] != 0 \|\| preShift[2] != 0)
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sumr = start[0];
	int sumg = start[1];
	int sumb = start[2];
	for (int wp = 0, ap = wtab.i0 * 3; wp < an && ap < abuf.length; wp++) {
	final int w = wtab.weights[wp];
	sumr += w * (abuf[ap++] >> preShift[0]);
	sumg += w * (abuf[ap++] >> preShift[1]);
	sumb += w * (abuf[ap++] >> preShift[2]);
	}

	int t = sumr >> postShift[0];
	bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
	t = sumg >> postShift[1];
	bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
	t = sumb >> postShift[2];
	bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	else
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sumr = start[0];
	int sumg = start[1];
	int sumb = start[2];
	for (int wp = 0, ap = wtab.i0 * 3; wp < an && ap < abuf.length; wp++) {
	final int w = wtab.weights[wp];
	sumr += w * abuf[ap++];
	sumg += w * abuf[ap++];
	sumb += w * abuf[ap++];
	}

	bbuf[bp++] = sumr >> postShift[0];
	bbuf[bp++] = sumg >> postShift[1];
	bbuf[bp++] = sumb >> postShift[2];
	}
	}

	@Override
	protected void shift(final int[] shift) {
	final int half[] = new int[]{
	1 << shift[0] - 1, 1 << shift[1] - 1, 1 << shift[2] - 1
	};

	final int abuf[] = data;

	for (int b = 0; b < abuf.length;) {
	for (int c = 0; c < 3; c++, b++) {
	final int t = abuf[b] + half[c] >> shift[c];
	abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	}
	}

	@Override
	protected void store(final int x, final int y) {
	dstRaster.setPixels(x, y, length, 1, data);
	}
	}

	/**
	* A Scanline for packed integer pixels.
	*/
	protected static final class IntegerSinglePixelPackedScanline extends Scanline {
	private final Raster srcRaster;
	private final WritableRaster dstRaster;

	private final int data[];
	private final int[] bitMasks;
	private final int[] bitOffsets;
	private final int componentCount;
	private final SinglePixelPackedSampleModel srcSM;
	private final int tmp[];

	protected IntegerSinglePixelPackedScanline(Raster src, WritableRaster dst, final int length) {
	super(length);
	srcRaster = src;
	dstRaster = dst;

	srcSM = (SinglePixelPackedSampleModel) srcRaster.getSampleModel();

	bitMasks = srcSM.getBitMasks();
	bitOffsets = srcSM.getBitOffsets();
	componentCount = bitMasks.length;

	if (componentCount != bitOffsets.length \|\| bitOffsets.length != srcSM.getNumBands())
	throw new IllegalArgumentException("weird: getBitMasks().length != getBitOffsets().length");

	tmp = new int[componentCount];

	data = new int[componentCount * length];
	}

	@Override
	protected void accumulate(final int weight, final Scanline dst) {
	final IntegerSinglePixelPackedScanline ispps = (IntegerSinglePixelPackedScanline) dst;

	final int abuf[] = data;
	final int bbuf[] = ispps.data;

	for (int b = 0; b < bbuf.length; b++)
	bbuf[b] += weight * abuf[b];
	}

	@Override
	protected void clear() {
	final int[] b = data;
	for (int j = 0; j < b.length; j++)
	b[j] = 0;
	}

	@Override
	protected void fetch(final int x, final int y) {
	srcRaster.getPixels(x, y, length, 1, data);
	}

	@Override
	protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
	final IntegerSinglePixelPackedScanline ispps = (IntegerSinglePixelPackedScanline) dst;
	final int nx = dst.length;

	// start sum at 1<<shift-1 for rounding
	final int start[] = tmp;
	for (int c = 0; c < componentCount; c++)
	start[c] = 1 << postShift[c] - 1;

	final int abuf[] = data;
	final int bbuf[] = ispps.data;

	// the next two blocks are duplicated except for the missing shift
	// operation if preShift==0.
	boolean hasPreShift = false;
	for (int c = 0; c < componentCount && !hasPreShift; c++)
	hasPreShift \|= preShift[c] != 0;
	if (hasPreShift)
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	for (int c = 0; c < componentCount; c++) {
	int sum = start[c];
	for (int wp = 0, ap = wtab.i0 * componentCount + c; wp < an && ap < abuf.length; wp++, ap += componentCount)
	sum += wtab.weights[wp] * (abuf[ap] >> preShift[c]);

	final int t = sum >> postShift[c];
	bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	}
	else
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	for (int c = 0; c < componentCount; c++) {
	int sum = start[c];
	for (int wp = 0, ap = wtab.i0 * componentCount + c; wp < an && ap < abuf.length; wp++, ap += componentCount)
	sum += wtab.weights[wp] * abuf[ap];

	bbuf[bp++] = sum >> postShift[c];
	}
	}
	}

	@Override
	protected void shift(final int[] shift) {
	final int half[] = tmp;
	for (int c = 0; c < componentCount; c++)
	half[c] = 1 << shift[c] - 1;

	final int abuf[] = data;

	for (int b = 0; b < abuf.length;) {
	for (int c = 0; c < componentCount; c++, b++) {
	final int t = abuf[b] + half[c] >> shift[c];
	abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	}
	}

	@Override
	protected void store(final int x, final int y) {
	dstRaster.setPixels(x, y, length, 1, data);
	}
	}

	/**
	* A Scanline for packed integer pixels.
	*/
	protected static final class GenericRasterScanline extends Scanline {
	private final Raster srcRaster;
	private final WritableRaster dstRaster;

	private final int componentCount;
	private final int data[][];
	private final SampleModel srcSM;
	private final SampleModel dstSM;
	private final int channelMask[];
	private final int[] tmp;
	private final ScanlineFilter inputFilter;

	protected GenericRasterScanline(Raster src, WritableRaster dst, final int length, int bitsPerChannel[],
	ScanlineFilter inputFilter) {
	super(length);
	srcRaster = src;
	dstRaster = dst;
	this.inputFilter = inputFilter;

	srcSM = srcRaster.getSampleModel();
	dstSM = dstRaster.getSampleModel();

	componentCount = srcSM.getNumBands();

	if (componentCount != dstSM.getNumBands())
	throw new IllegalArgumentException("weird: src raster num bands != dst raster num bands");

	tmp = new int[componentCount];

	data = new int[componentCount][];
	for (int i = 0; i < data.length; i++)
	data[i] = new int[length];

	channelMask = new int[componentCount];
	for (int c = 0; c < componentCount; c++)
	channelMask[c] = (1 << bitsPerChannel[c]) - 1;
	}

	@Override
	protected void accumulate(final int weight, final Scanline dst) {
	final GenericRasterScanline grs = (GenericRasterScanline) dst;

	final int l = grs.data[0].length;
	for (int c = 0; c < componentCount; c++) {
	final int ac[] = data[c];
	final int bc[] = grs.data[c];

	for (int b = 0; b < l; b++)
	bc[b] += weight * ac[b];
	}
	}

	@Override
	protected void clear() {
	for (int c = 0; c < componentCount; c++) {
	final int[] b = data[c];
	for (int x = 0; x < b.length; x++)
	b[x] = 0;
	}
	}

	@Override
	protected void fetch(final int x, final int y) {
	for (int c = 0; c < componentCount; c++) {
	srcRaster.getSamples(x, y, length, 1, c, data[c]);
	if (null != inputFilter)
	inputFilter.filter(x, y, c, data[c], length);
	}
	}

	@Override
	protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
	final GenericRasterScanline grs = (GenericRasterScanline) dst;
	final int nx = dst.length;

	// start sum at 1<<shift-1 for rounding
	final int start[] = tmp;
	for (int c = 0; c < componentCount; c++)
	start[c] = 1 << postShift[c] - 1;

	final int l = data[0].length;

	// the next two blocks are duplicated except for the missing shift
	// operation if preShift==0.
	boolean hasPreShift = false;
	for (int c = 0; c < componentCount && !hasPreShift; c++)
	hasPreShift \|= preShift[c] != 0;
	if (hasPreShift)
	for (int c = 0; c < componentCount; c++) {
	final int ac[] = data[c];
	final int bc[] = grs.data[c];
	final int m = channelMask[c];
	for (int b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sum = start[c];
	for (int wp = 0, ap = wtab.i0; wp < an && ap < l; wp++, ap++)
	sum += wtab.weights[wp] * (ac[ap] >> preShift[c]);

	final int t = sum >> postShift[c];
	bc[b] = t < 0 ? 0 : t > m ? m : t;
	}
	}
	else
	for (int c = 0; c < componentCount; c++) {
	final int ac[] = data[c];
	final int bc[] = grs.data[c];

	for (int b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sum = start[c];
	for (int wp = 0, ap = wtab.i0; wp < an && ap < l; wp++, ap++)
	sum += wtab.weights[wp] * ac[ap];

	bc[b] = sum >> postShift[c];
	}
	}
	}

	@Override
	protected void shift(final int[] shift) {
	final int half[] = tmp;
	for (int c = 0; c < componentCount; c++)
	half[c] = 1 << shift[c] - 1;

	final int abuf[][] = data;

	final int l = abuf[0].length;
	for (int c = 0; c < componentCount; c++) {
	final int ac[] = data[c];
	final int m = channelMask[c];

	for (int a = 0; a < l; a++) {
	final int t = ac[a] + half[c] >> shift[c];
	ac[a] = t < 0 ? 0 : t > m ? m : t;
	}
	}
	}

	@Override
	protected void store(final int x, final int y) {
	final int nx = length;
	for (int c = 0; c < componentCount; c++)
	dstRaster.setSamples(x, y, nx, 1, c, data[c]);
	}
	}

	/**
	* A Scanline for BiLevel input data ({@link MultiPixelPackedSampleModel}) to indexed output data
	* (<code>sun.awt.image.ByteInterleavedRaster</code>).
	*/
	protected static final class ByteBiLevelPackedScanline extends Scanline {
	private final Raster srcRaster;
	private final WritableRaster dstRaster;

	private final int data[];

	protected ByteBiLevelPackedScanline(Raster src, WritableRaster dst, final int length) {
	super(length);
	srcRaster = src;
	dstRaster = dst;

	data = new int[length];
	}

	@Override
	protected void accumulate(final int weight, final Scanline dst) {
	final ByteBiLevelPackedScanline bblps = (ByteBiLevelPackedScanline) dst;

	final int abuf[] = data;
	final int bbuf[] = bblps.data;

	for (int b = 0; b < bbuf.length; b++)
	bbuf[b] += weight * abuf[b];
	}

	@Override
	protected void clear() {
	final int[] b = data;
	for (int j = 0; j < b.length; j++)
	b[j] = 0;
	}

	@Override
	protected void fetch(final int x, final int y) {
	srcRaster.getPixels(x, y, length, 1, data);
	for (int i = 0; i < length; i++)
	if (data[i] != 0)
	data[i] = 255;
	}

	@Override
	protected void filter(final int[] preShift, final int[] postShift, final Weighttab[] tabs, final Scanline dst) {
	final ByteBiLevelPackedScanline bblps = (ByteBiLevelPackedScanline) dst;
	final int nx = dst.length;

	// start sum at 1<<shift-1 for rounding
	final int start = 1 << postShift[0] - 1;
	final int abuf[] = data;
	final int bbuf[] = bblps.data;

	// the next two blocks are duplicated except for the missing shift
	// operation if preShift==0.
	final int preShift0 = preShift[0];
	final int postShift0 = postShift[0];
	if (preShift0 != 0)
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sum = start;
	for (int wp = 0, ap = wtab.i0; wp < an && ap < abuf.length; wp++) {
	sum += wtab.weights[wp] * (abuf[ap++] >> preShift0);
	}

	final int t = sum >> postShift0;
	bbuf[bp++] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	else
	for (int bp = 0, b = 0; b < nx; b++) {
	final Weighttab wtab = tabs[b];
	final int an = wtab.weights.length;

	int sum = start;
	for (int wp = 0, ap = wtab.i0; wp < an && ap < abuf.length; wp++) {
	sum += wtab.weights[wp] * abuf[ap++];
	}

	bbuf[bp++] = sum >> postShift0;
	}
	}

	@Override
	protected void shift(final int[] shift) {
	final int shift0 = shift[0];
	final int half = 1 << shift0 - 1;

	final int abuf[] = data;

	for (int b = 0; b < abuf.length; b++) {
	final int t = abuf[b] + half >> shift0;
	abuf[b] = t < 0 ? 0 : t > 255 ? 255 : t;
	}
	}

	@Override
	protected void store(final int x, final int y) {
	dstRaster.setPixels(x, y, length, 1, data);
	}
	}

	int y;
	protected final int length;

	protected Scanline(final int width) {
	length = width;
	}

	protected final int getWidth() {
	return length;
	}

	protected abstract void clear();

	protected abstract void fetch(int x, int y);

	protected abstract void filter(int[] preShift, int[] postShift, Weighttab[] xweights, Scanline dst);

	protected abstract void accumulate(int weight, Scanline dst);

	protected abstract void shift(int[] finalshift);

	protected abstract void store(int x, int y);
	}