1. /*

  2.  * @(#)TexturePaintContext.java	1.23 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package java.awt;

  12. 

  13. import java.awt.image.BufferedImage;

  14. import java.awt.image.Raster;

  15. import java.awt.image.WritableRaster;

  16. import java.awt.image.ColorModel;

  17. import java.awt.image.DirectColorModel;

  18. import java.awt.image.IndexColorModel;

  19. import java.awt.geom.AffineTransform;

  20. import java.awt.geom.NoninvertibleTransformException;

  21. import sun.awt.image.IntegerInterleavedRaster;

  22. import sun.awt.image.ByteInterleavedRaster;

  23. 

  24. abstract class TexturePaintContext implements PaintContext {

  25.     ColorModel colorModel;

  26.     int bWidth;

  27.     int bHeight;

  28.     int maxWidth;

  29. 

  30.     WritableRaster outRas;

  31. 

  32.     double xOrg;

  33.     double yOrg;

  34.     double incXAcross;

  35.     double incYAcross;

  36.     double incXDown;

  37.     double incYDown;

  38. 

  39.     int colincx;

  40.     int colincy;

  41.     int colincxerr;

  42.     int colincyerr;

  43.     int rowincx;

  44.     int rowincy;

  45.     int rowincxerr;

  46.     int rowincyerr;

  47. 

  48.     public static PaintContext getContext(BufferedImage bufImg,

  49. 					  AffineTransform xform,

  50. 					  RenderingHints hints,

  51. 					  Rectangle devBounds) {

  52.         WritableRaster raster = bufImg.getRaster();

  53. 	ColorModel cm = bufImg.getColorModel();

  54. 	int maxw = devBounds.width;

  55. 	Object val = hints.get(hints.KEY_INTERPOLATION);

  56. 	boolean filter =

  57. 	    (val == null

  58. 	     ? (hints.get(hints.KEY_RENDERING) == hints.VALUE_RENDER_QUALITY)

  59. 	     : (val != hints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR));

  60. 	if (raster instanceof IntegerInterleavedRaster &&

  61. 	    (!filter || isFilterableDCM(cm)))

  62. 	{

  63. 	    IntegerInterleavedRaster iir = (IntegerInterleavedRaster) raster;

  64. 	    if (iir.getNumDataElements() == 1 && iir.getPixelStride() == 1) {

  65. 		return new Int(iir, cm, xform, maxw, filter);

  66. 	    }

  67. 	} else if (raster instanceof ByteInterleavedRaster) {

  68. 	    ByteInterleavedRaster bir = (ByteInterleavedRaster) raster;

  69. 	    if (bir.getNumDataElements() == 1 && bir.getPixelStride() == 1) {

  70. 		if (filter) {

  71. 		    if (isFilterableICM(cm)) {

  72. 			return new ByteFilter(bir, cm, xform, maxw);

  73. 		    }

  74. 		} else {

  75. 		    return new Byte(bir, cm, xform, maxw);

  76. 		}

  77. 	    }

  78. 	}

  79. 	return new Any(raster, cm, xform, maxw, filter);

  80.     }

  81. 

  82.     public static boolean isFilterableICM(ColorModel cm) {

  83. 	if (cm instanceof IndexColorModel) {

  84. 	    IndexColorModel icm = (IndexColorModel) cm;

  85. 	    if (icm.getMapSize() <= 256) {

  86. 		return true;

  87. 	    }

  88. 	}

  89. 	return false;

  90.     }

  91. 

  92.     public static boolean isFilterableDCM(ColorModel cm) {

  93. 	if (cm instanceof DirectColorModel) {

  94. 	    DirectColorModel dcm = (DirectColorModel) cm;

  95. 	    return (isMaskOK(dcm.getAlphaMask(), true) &&

  96. 		    isMaskOK(dcm.getRedMask(), false) &&

  97. 		    isMaskOK(dcm.getGreenMask(), false) &&

  98. 		    isMaskOK(dcm.getBlueMask(), false));

  99. 	}

  100. 	return false;

  101.     }

  102. 

  103.     public static boolean isMaskOK(int mask, boolean canbezero) {

  104. 	if (canbezero && mask == 0) {

  105. 	    return true;

  106. 	}

  107. 	return (mask == 0xff ||

  108. 		mask == 0xff00 ||

  109. 		mask == 0xff0000 ||

  110. 		mask == 0xff000000);

  111.     }

  112. 

  113.     TexturePaintContext(ColorModel cm, AffineTransform xform,

  114. 			int bWidth, int bHeight, int maxw) {

  115. 	this.colorModel = cm;

  116. 	this.bWidth = bWidth;

  117. 	this.bHeight = bHeight;

  118. 	this.maxWidth = maxw;

  119. 

  120. 	try {

  121. 	    xform = xform.createInverse();

  122.         } catch (NoninvertibleTransformException e) {

  123. 	    xform.setToScale(0, 0);

  124. 	}

  125. 	this.incXAcross = mod(xform.getScaleX(), bWidth);

  126. 	this.incYAcross = mod(xform.getShearY(), bHeight);

  127. 	this.incXDown = mod(xform.getShearX(), bWidth);

  128. 	this.incYDown = mod(xform.getScaleY(), bHeight);

  129.         this.xOrg = xform.getTranslateX();

  130.         this.yOrg = xform.getTranslateY();

  131. 	this.colincx = (int) incXAcross;

  132. 	this.colincy = (int) incYAcross;

  133. 	this.colincxerr = fractAsInt(incXAcross);

  134. 	this.colincyerr = fractAsInt(incYAcross);

  135. 	this.rowincx = (int) incXDown;

  136. 	this.rowincy = (int) incYDown;

  137. 	this.rowincxerr = fractAsInt(incXDown);

  138. 	this.rowincyerr = fractAsInt(incYDown);

  139. 

  140.     }

  141. 

  142.     static int fractAsInt(double d) {

  143. 	return (int) ((d % 1.0) * Integer.MAX_VALUE);

  144.     }

  145. 

  146.     static double mod(double num, double den) {

  147. 	num = num % den;

  148. 	if (num < 0) {

  149. 	    num += den;

  150. 	    if (num >= den) {

  151. 		// For very small negative numerators, the answer might

  152. 		// be such a tiny bit less than den that the difference

  153. 		// is smaller than the mantissa of a double allows and

  154. 		// the result would then be rounded to den.  If that is

  155. 		// the case then we map that number to 0 as the nearest

  156. 		// modulus representation.

  157. 		num = 0;

  158. 	    }

  159. 	}

  160. 	return num;

  161.     }

  162.     

  163.     /**

  164.      * Release the resources allocated for the operation.

  165.      */

  166.     public void dispose() {

  167.         // Nothing to dispose

  168.     }

  169. 

  170.     /**

  171.      * Return the ColorModel of the output.

  172.      */

  173.     public ColorModel getColorModel() {

  174.         return colorModel;

  175.     }

  176. 

  177.     /**

  178.      * Return a Raster containing the colors generated for the graphics

  179.      * operation.

  180.      * @param x,y,w,h The area in device space for which colors are

  181.      * generated.

  182.      */

  183.     public Raster getRaster(int x, int y, int w, int h) {

  184. 	if (outRas == null ||

  185. 	    outRas.getWidth() < w ||

  186. 	    outRas.getHeight() < h)

  187. 	{

  188. 	    // If h==1, we will probably get lots of "scanline" rects

  189. 	    outRas = makeRaster((h == 1 ? Math.max(w, maxWidth) : w), h);

  190. 	}

  191. 	double X = mod(xOrg + x * incXAcross + y * incXDown, bWidth);

  192. 	double Y = mod(yOrg + x * incYAcross + y * incYDown, bHeight);

  193. 

  194. 	setRaster((int) X, (int) Y, fractAsInt(X), fractAsInt(Y),

  195. 		  w, h, bWidth, bHeight,

  196. 		  colincx, colincxerr,

  197. 		  colincy, colincyerr,

  198. 		  rowincx, rowincxerr,

  199. 		  rowincy, rowincyerr);

  200. 

  201. 	return outRas;

  202.     }

  203. 

  204.     public abstract WritableRaster makeRaster(int w, int h);

  205.     public abstract void setRaster(int x, int y, int xerr, int yerr,

  206. 				   int w, int h, int bWidth, int bHeight,

  207. 				   int colincx, int colincxerr,

  208. 				   int colincy, int colincyerr,

  209. 				   int rowincx, int rowincxerr,

  210. 				   int rowincy, int rowincyerr);

  211. 

  212.     /*

  213.      * Blends the four ARGB values in the rgbs array using the factors

  214.      * described by xmul and ymul in the following ratio:

  215.      *

  216.      *     rgbs[0] * (1-xmul) * (1-ymul) +

  217.      *     rgbs[1] * (  xmul) * (1-ymul) +

  218.      *     rgbs[2] * (1-xmul) * (  ymul) +

  219.      *     rgbs[3] * (  xmul) * (  ymul)

  220.      *

  221.      * xmul and ymul are integer values in the half-open range [0, 2^31)

  222.      * where 0 == 0.0 and 2^31 == 1.0.

  223.      *

  224.      * Note that since the range is half-open, the values are always

  225.      * logically less than 1.0.  This makes sense because while choosing

  226.      * pixels to blend, when the error values reach 1.0 we move to the

  227.      * next pixel and reset them to 0.0.

  228.      */

  229.     public static int blend(int rgbs[], int xmul, int ymul) {

  230. 	// xmul/ymul are 31 bits wide, (0 => 2^31-1)

  231. 	// shift them to 12 bits wide, (0 => 2^12-1)

  232. 	xmul = (xmul >>> 19);

  233. 	ymul = (ymul >>> 19);

  234. 	int accumA, accumR, accumG, accumB;

  235. 	accumA = accumR = accumG = accumB = 0;

  236. 	for (int i = 0; i < 4; i++) {

  237. 	    int rgb = rgbs[i];

  238. 	    // The complement of the [xy]mul values (1-[xy]mul) can result

  239. 	    // in new values in the range (1 => 2^12).  Thus for any given

  240. 	    // loop iteration, the values could be anywhere in (0 => 2^12).

  241. 	    xmul = (1<<12) - xmul;

  242. 	    if ((i & 1) == 0) {

  243. 		ymul = (1<<12) - ymul;

  244. 	    }

  245. 	    // xmul and ymul are each 12 bits (0 => 2^12)

  246. 	    // factor is thus 24 bits (0 => 2^24)

  247. 	    int factor = xmul * ymul;

  248. 	    if (factor != 0) {

  249. 		// accum variables will accumulate 32 bits

  250. 		// bytes extracted from rgb fit in 8 bits (0 => 255)

  251. 		// byte * factor thus fits in 32 bits (0 => 255 * 2^24)

  252. 		accumA += (((rgb >>> 24)       ) * factor);

  253. 		accumR += (((rgb >>> 16) & 0xff) * factor);

  254. 		accumG += (((rgb >>>  8) & 0xff) * factor);

  255. 		accumB += (((rgb       ) & 0xff) * factor);

  256. 	    }

  257. 	}

  258. 	return ((((accumA + (1<<23)) >>> 24) << 24) |

  259. 		(((accumR + (1<<23)) >>> 24) << 16) |

  260. 		(((accumG + (1<<23)) >>> 24) <<  8) |

  261. 		(((accumB + (1<<23)) >>> 24)      ));

  262.     }

  263. 

  264.     static class Int extends TexturePaintContext {

  265. 	IntegerInterleavedRaster srcRas;

  266. 	int inData[];

  267. 	int inOff;

  268. 	int inSpan;

  269. 	int outData[];

  270. 	int outOff;

  271. 	int outSpan;

  272. 	boolean filter;

  273. 

  274. 	public Int(IntegerInterleavedRaster srcRas, ColorModel cm,

  275. 		   AffineTransform xform, int maxw, boolean filter)

  276. 	{

  277. 	    super(cm, xform, srcRas.getWidth(), srcRas.getHeight(), maxw);

  278. 	    this.srcRas = srcRas;

  279. 	    this.inData = srcRas.getDataStorage();

  280. 	    this.inSpan = srcRas.getScanlineStride();

  281. 	    this.inOff = srcRas.getDataOffset(0);

  282. 	    this.filter = filter;

  283. 	}

  284. 

  285. 	public WritableRaster makeRaster(int w, int h) {

  286. 	    WritableRaster ras = srcRas.createCompatibleWritableRaster(w, h);

  287. 	    IntegerInterleavedRaster iiRas = (IntegerInterleavedRaster) ras;

  288. 	    outData = iiRas.getDataStorage();

  289. 	    outSpan = iiRas.getScanlineStride();

  290. 	    outOff = iiRas.getDataOffset(0);

  291. 	    return ras;

  292. 	}

  293. 

  294. 	public void setRaster(int x, int y, int xerr, int yerr,

  295. 			      int w, int h, int bWidth, int bHeight,

  296. 			      int colincx, int colincxerr,

  297. 			      int colincy, int colincyerr,

  298. 			      int rowincx, int rowincxerr,

  299. 			      int rowincy, int rowincyerr) {

  300. 	    int[] inData = this.inData;

  301. 	    int[] outData = this.outData;

  302. 	    int out = outOff;

  303. 	    int inSpan = this.inSpan;

  304. 	    int inOff = this.inOff;

  305. 	    int outSpan = this.outSpan;

  306. 	    boolean filter = this.filter;

  307. 	    boolean normalx = (colincx == 1 && colincxerr == 0 &&

  308. 			       colincy == 0 && colincyerr == 0) && !filter;

  309. 	    int rowx = x;

  310. 	    int rowy = y;

  311. 	    int rowxerr = xerr;

  312. 	    int rowyerr = yerr;

  313. 	    if (normalx) {

  314. 		outSpan -= w;

  315. 	    }

  316. 	    int rgbs[] = filter ? new int[4] : null;

  317. 	    for (int j = 0; j < h; j++) {

  318. 		if (normalx) {

  319. 		    int in = inOff + rowy * inSpan + bWidth;

  320. 		    x = bWidth - rowx;

  321. 		    out += w;

  322. 		    if (bWidth >= 32) {

  323. 			int i = w;

  324. 			while (i > 0) {

  325. 			    int copyw = (i < x) ? i : x;

  326. 			    System.arraycopy(inData, in - x,

  327. 					     outData, out - i,

  328. 					     copyw);

  329. 			    i -= copyw;

  330. 			    if ((x -= copyw) == 0) {

  331. 				x = bWidth;

  332. 			    }

  333. 			}

  334. 		    } else {

  335. 			for (int i = w; i > 0; i--) {

  336. 			    outData[out - i] = inData[in - x];

  337. 			    if (--x == 0) {

  338. 				x = bWidth;

  339. 			    }

  340. 			}

  341. 		    }

  342. 		} else {

  343. 		    x = rowx;

  344. 		    y = rowy;

  345. 		    xerr = rowxerr;

  346. 		    yerr = rowyerr;

  347. 		    for (int i = 0; i < w; i++) {

  348. 			if (filter) {

  349. 			    int nextx, nexty;

  350. 			    if ((nextx = x + 1) >= bWidth) {

  351. 				nextx = 0;

  352. 			    }

  353. 			    if ((nexty = y + 1) >= bHeight) {

  354. 				nexty = 0;

  355. 			    }

  356. 			    rgbs[0] = inData[inOff + y * inSpan + x];

  357. 			    rgbs[1] = inData[inOff + y * inSpan + nextx];

  358. 			    rgbs[2] = inData[inOff + nexty * inSpan + x];

  359. 			    rgbs[3] = inData[inOff + nexty * inSpan + nextx];

  360. 			    outData[out + i] =

  361. 				TexturePaintContext.blend(rgbs, xerr, yerr);

  362. 			} else {

  363. 			    outData[out + i] = inData[inOff + y * inSpan + x];

  364. 			}

  365. 			if ((xerr += colincxerr) < 0) {

  366. 			    xerr &= Integer.MAX_VALUE;

  367. 			    x++;

  368. 			}

  369. 			if ((x += colincx) >= bWidth) {

  370. 			    x -= bWidth;

  371. 			}

  372. 			if ((yerr += colincyerr) < 0) {

  373. 			    yerr &= Integer.MAX_VALUE;

  374. 			    y++;

  375. 			}

  376. 			if ((y += colincy) >= bHeight) {

  377. 			    y -= bHeight;

  378. 			}

  379. 		    }

  380. 		}

  381. 		if ((rowxerr += rowincxerr) < 0) {

  382. 		    rowxerr &= Integer.MAX_VALUE;

  383. 		    rowx++;

  384. 		}

  385. 		if ((rowx += rowincx) >= bWidth) {

  386. 		    rowx -= bWidth;

  387. 		}

  388. 		if ((rowyerr += rowincyerr) < 0) {

  389. 		    rowyerr &= Integer.MAX_VALUE;

  390. 		    rowy++;

  391. 		}

  392. 		if ((rowy += rowincy) >= bHeight) {

  393. 		    rowy -= bHeight;

  394. 		}

  395. 		out += outSpan;

  396. 	    }

  397. 	}

  398.     }

  399. 

  400.     static class Byte extends TexturePaintContext {

  401. 	ByteInterleavedRaster srcRas;

  402. 	byte inData[];

  403. 	int inOff;

  404. 	int inSpan;

  405. 	byte outData[];

  406. 	int outOff;

  407. 	int outSpan;

  408. 

  409. 	public Byte(ByteInterleavedRaster srcRas, ColorModel cm,

  410. 		    AffineTransform xform, int maxw)

  411. 	{

  412. 	    super(cm, xform, srcRas.getWidth(), srcRas.getHeight(), maxw);

  413. 	    this.srcRas = srcRas;

  414. 	    this.inData = srcRas.getDataStorage();

  415. 	    this.inSpan = srcRas.getScanlineStride();

  416. 	    this.inOff = srcRas.getDataOffset(0);

  417. 	}

  418. 

  419. 	public WritableRaster makeRaster(int w, int h) {

  420. 	    WritableRaster ras = srcRas.createCompatibleWritableRaster(w, h);

  421. 	    ByteInterleavedRaster biRas = (ByteInterleavedRaster) ras;

  422. 	    outData = biRas.getDataStorage();

  423. 	    outSpan = biRas.getScanlineStride();

  424. 	    outOff = biRas.getDataOffset(0);

  425. 	    return ras;

  426. 	}

  427. 

  428. 	public void setRaster(int x, int y, int xerr, int yerr,

  429. 			      int w, int h, int bWidth, int bHeight,

  430. 			      int colincx, int colincxerr,

  431. 			      int colincy, int colincyerr,

  432. 			      int rowincx, int rowincxerr,

  433. 			      int rowincy, int rowincyerr) {

  434. 	    byte[] inData = this.inData;

  435. 	    byte[] outData = this.outData;

  436. 	    int out = outOff;

  437. 	    int inSpan = this.inSpan;

  438. 	    int inOff = this.inOff;

  439. 	    int outSpan = this.outSpan;

  440. 	    boolean normalx = (colincx == 1 && colincxerr == 0 &&

  441. 			       colincy == 0 && colincyerr == 0);

  442. 	    int rowx = x;

  443. 	    int rowy = y;

  444. 	    int rowxerr = xerr;

  445. 	    int rowyerr = yerr;

  446. 	    if (normalx) {

  447. 		outSpan -= w;

  448. 	    }

  449. 	    for (int j = 0; j < h; j++) {

  450. 		if (normalx) {

  451. 		    int in = inOff + rowy * inSpan + bWidth;

  452. 		    x = bWidth - rowx;

  453. 		    out += w;

  454. 		    if (bWidth >= 32) {

  455. 			int i = w;

  456. 			while (i > 0) {

  457. 			    int copyw = (i < x) ? i : x;

  458. 			    System.arraycopy(inData, in - x,

  459. 					     outData, out - i,

  460. 					     copyw);

  461. 			    i -= copyw;

  462. 			    if ((x -= copyw) == 0) {

  463. 				x = bWidth;

  464. 			    }

  465. 			}

  466. 		    } else {

  467. 			for (int i = w; i > 0; i--) {

  468. 			    outData[out - i] = inData[in - x];

  469. 			    if (--x == 0) {

  470. 				x = bWidth;

  471. 			    }

  472. 			}

  473. 		    }

  474. 		} else {

  475. 		    x = rowx;

  476. 		    y = rowy;

  477. 		    xerr = rowxerr;

  478. 		    yerr = rowyerr;

  479. 		    for (int i = 0; i < w; i++) {

  480. 			outData[out + i] = inData[inOff + y * inSpan + x];

  481. 			if ((xerr += colincxerr) < 0) {

  482. 			    xerr &= Integer.MAX_VALUE;

  483. 			    x++;

  484. 			}

  485. 			if ((x += colincx) >= bWidth) {

  486. 			    x -= bWidth;

  487. 			}

  488. 			if ((yerr += colincyerr) < 0) {

  489. 			    yerr &= Integer.MAX_VALUE;

  490. 			    y++;

  491. 			}

  492. 			if ((y += colincy) >= bHeight) {

  493. 			    y -= bHeight;

  494. 			}

  495. 		    }

  496. 		}

  497. 		if ((rowxerr += rowincxerr) < 0) {

  498. 		    rowxerr &= Integer.MAX_VALUE;

  499. 		    rowx++;

  500. 		}

  501. 		if ((rowx += rowincx) >= bWidth) {

  502. 		    rowx -= bWidth;

  503. 		}

  504. 		if ((rowyerr += rowincyerr) < 0) {

  505. 		    rowyerr &= Integer.MAX_VALUE;

  506. 		    rowy++;

  507. 		}

  508. 		if ((rowy += rowincy) >= bHeight) {

  509. 		    rowy -= bHeight;

  510. 		}

  511. 		out += outSpan;

  512. 	    }

  513. 	}

  514.     }

  515. 

  516.     static class ByteFilter extends TexturePaintContext {

  517. 	ByteInterleavedRaster srcRas;

  518. 	int inPalette[];

  519. 	byte inData[];

  520. 	int inOff;

  521. 	int inSpan;

  522. 	int outData[];

  523. 	int outOff;

  524. 	int outSpan;

  525. 

  526. 	public static ColorModel xrgbmodel =

  527. 	    new DirectColorModel(24, 0xff0000, 0xff00, 0xff);

  528. 	public static ColorModel argbmodel = ColorModel.getRGBdefault();

  529. 

  530. 	public ByteFilter(ByteInterleavedRaster srcRas, ColorModel cm,

  531. 			  AffineTransform xform, int maxw)

  532. 	{

  533. 	    super((cm.getTransparency() == Transparency.OPAQUE

  534. 		   ? xrgbmodel : argbmodel),

  535. 		  xform, srcRas.getWidth(), srcRas.getHeight(), maxw);

  536. 	    this.inPalette = new int[256];

  537. 	    ((IndexColorModel) cm).getRGBs(this.inPalette);

  538. 	    this.srcRas = srcRas;

  539. 	    this.inData = srcRas.getDataStorage();

  540. 	    this.inSpan = srcRas.getScanlineStride();

  541. 	    this.inOff = srcRas.getDataOffset(0);

  542. 	}

  543. 

  544. 	public WritableRaster makeRaster(int w, int h) {

  545. 	    WritableRaster ras =

  546. 		colorModel.createCompatibleWritableRaster(w, h);

  547. 	    IntegerInterleavedRaster iiRas = (IntegerInterleavedRaster) ras;

  548. 	    outData = iiRas.getDataStorage();

  549. 	    outSpan = iiRas.getScanlineStride();

  550. 	    outOff = iiRas.getDataOffset(0);

  551. 	    return ras;

  552. 	}

  553. 

  554. 	public void setRaster(int x, int y, int xerr, int yerr,

  555. 			      int w, int h, int bWidth, int bHeight,

  556. 			      int colincx, int colincxerr,

  557. 			      int colincy, int colincyerr,

  558. 			      int rowincx, int rowincxerr,

  559. 			      int rowincy, int rowincyerr) {

  560. 	    byte[] inData = this.inData;

  561. 	    int[] outData = this.outData;

  562. 	    int out = outOff;

  563. 	    int inSpan = this.inSpan;

  564. 	    int inOff = this.inOff;

  565. 	    int outSpan = this.outSpan;

  566. 	    int rowx = x;

  567. 	    int rowy = y;

  568. 	    int rowxerr = xerr;

  569. 	    int rowyerr = yerr;

  570. 	    int rgbs[] = new int[4];

  571. 	    for (int j = 0; j < h; j++) {

  572. 		x = rowx;

  573. 		y = rowy;

  574. 		xerr = rowxerr;

  575. 		yerr = rowyerr;

  576. 		for (int i = 0; i < w; i++) {

  577. 		    int nextx, nexty;

  578. 		    if ((nextx = x + 1) >= bWidth) {

  579. 			nextx = 0;

  580. 		    }

  581. 		    if ((nexty = y + 1) >= bHeight) {

  582. 			nexty = 0;

  583. 		    }

  584. 		    rgbs[0] = inPalette[0xff & inData[inOff + x +

  585. 						      inSpan * y]];

  586. 		    rgbs[1] = inPalette[0xff & inData[inOff + nextx +

  587. 						      inSpan * y]];

  588. 		    rgbs[2] = inPalette[0xff & inData[inOff + x +

  589. 						      inSpan * nexty]];

  590. 		    rgbs[3] = inPalette[0xff & inData[inOff + nextx +

  591. 						      inSpan * nexty]];

  592. 		    outData[out + i] = 

  593. 			TexturePaintContext.blend(rgbs, xerr, yerr);

  594. 		    if ((xerr += colincxerr) < 0) {

  595. 			xerr &= Integer.MAX_VALUE;

  596. 			x++;

  597. 		    }

  598. 		    if ((x += colincx) >= bWidth) {

  599. 			x -= bWidth;

  600. 		    }

  601. 		    if ((yerr += colincyerr) < 0) {

  602. 			yerr &= Integer.MAX_VALUE;

  603. 			y++;

  604. 		    }

  605. 		    if ((y += colincy) >= bHeight) {

  606. 			y -= bHeight;

  607. 		    }

  608. 		}

  609. 		if ((rowxerr += rowincxerr) < 0) {

  610. 		    rowxerr &= Integer.MAX_VALUE;

  611. 		    rowx++;

  612. 		}

  613. 		if ((rowx += rowincx) >= bWidth) {

  614. 		    rowx -= bWidth;

  615. 		}

  616. 		if ((rowyerr += rowincyerr) < 0) {

  617. 		    rowyerr &= Integer.MAX_VALUE;

  618. 		    rowy++;

  619. 		}

  620. 		if ((rowy += rowincy) >= bHeight) {

  621. 		    rowy -= bHeight;

  622. 		}

  623. 		out += outSpan;

  624. 	    }

  625. 	}

  626.     }

  627. 

  628.     static class Any extends TexturePaintContext {

  629. 	WritableRaster srcRas;

  630. 	boolean filter;

  631. 

  632. 	public Any(WritableRaster srcRas, ColorModel cm,

  633. 		   AffineTransform xform, int maxw, boolean filter)

  634. 	{

  635. 	    super(cm, xform, srcRas.getWidth(), srcRas.getHeight(), maxw);

  636. 	    this.srcRas = srcRas;

  637. 	    this.filter = filter;

  638. 	}

  639. 

  640. 	public WritableRaster makeRaster(int w, int h) {

  641. 	    return srcRas.createCompatibleWritableRaster(w, h);

  642. 	}

  643. 

  644. 	public void setRaster(int x, int y, int xerr, int yerr,

  645. 			      int w, int h, int bWidth, int bHeight,

  646. 			      int colincx, int colincxerr,

  647. 			      int colincy, int colincyerr,

  648. 			      int rowincx, int rowincxerr,

  649. 			      int rowincy, int rowincyerr) {

  650. 	    Object data = null;

  651. 	    int rowx = x;

  652. 	    int rowy = y;

  653. 	    int rowxerr = xerr;

  654. 	    int rowyerr = yerr;

  655. 	    WritableRaster srcRas = this.srcRas;

  656. 	    WritableRaster outRas = this.outRas;

  657. 	    int rgbs[] = filter ? new int[4] : null;

  658. 	    for (int j = 0; j < h; j++) {

  659. 		x = rowx;

  660. 		y = rowy;

  661. 		xerr = rowxerr;

  662. 		yerr = rowyerr;

  663. 		for (int i = 0; i < w; i++) {

  664. 		    data = srcRas.getDataElements(x, y, data);

  665. 		    if (filter) {

  666. 			int nextx, nexty;

  667. 			if ((nextx = x + 1) >= bWidth) {

  668. 			    nextx = 0;

  669. 			}

  670. 			if ((nexty = y + 1) >= bHeight) {

  671. 			    nexty = 0;

  672. 			}

  673. 			rgbs[0] = colorModel.getRGB(data);

  674. 			data = srcRas.getDataElements(nextx, y, data);

  675. 			rgbs[1] = colorModel.getRGB(data);

  676. 			data = srcRas.getDataElements(x, nexty, data);

  677. 			rgbs[2] = colorModel.getRGB(data);

  678. 			data = srcRas.getDataElements(nextx, nexty, data);

  679. 			rgbs[3] = colorModel.getRGB(data);

  680. 			int rgb = 

  681. 			    TexturePaintContext.blend(rgbs, xerr, yerr);

  682. 			data = colorModel.getDataElements(rgb, data);

  683. 		    }

  684. 		    outRas.setDataElements(i, j, data);

  685. 		    if ((xerr += colincxerr) < 0) {

  686. 			xerr &= Integer.MAX_VALUE;

  687. 			x++;

  688. 		    }

  689. 		    if ((x += colincx) >= bWidth) {

  690. 			x -= bWidth;

  691. 		    }

  692. 		    if ((yerr += colincyerr) < 0) {

  693. 			yerr &= Integer.MAX_VALUE;

  694. 			y++;

  695. 		    }

  696. 		    if ((y += colincy) >= bHeight) {

  697. 			y -= bHeight;

  698. 		    }

  699. 		}

  700. 		if ((rowxerr += rowincxerr) < 0) {

  701. 		    rowxerr &= Integer.MAX_VALUE;

  702. 		    rowx++;

  703. 		}

  704. 		if ((rowx += rowincx) >= bWidth) {

  705. 		    rowx -= bWidth;

  706. 		}

  707. 		if ((rowyerr += rowincyerr) < 0) {

  708. 		    rowyerr &= Integer.MAX_VALUE;

  709. 		    rowy++;

  710. 		}

  711. 		if ((rowy += rowincy) >= bHeight) {

  712. 		    rowy -= bHeight;

  713. 		}

  714. 	    }

  715. 	}

  716.     }

  717. }