开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
row.c
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：13k
源码类别：

传真(Fax)编程

开发平台：

C/C++

row.c：源码内容
  1. /* $Id: row.c,v 1.1.1.1 2005/11/11 21:32:03 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. /*
  27.  * row -
  28.  * support for operations on image rows.
  29.  *
  30.  */
  31. #include "image.h"
  32. #include "lum.h"
  34. int _RILUM = _RED;
  35. int _GILUM = _GREEN;
  36. int _BILUM = _BLUE;
  38. zerorow(sptr,n)
  39. short *sptr;
  40. int n;
  41. {
  42.     memset(sptr,0,n*sizeof(short));
  43. }
  45. copyrow(s,d,n)
  46. short *s, *d;
  47. int n;
  48. {
  49.     memcpy(d,s,n*sizeof(short));
  50. }
  52. setrow(sptr,val,n)
  53. short *sptr;
  54. int val, n;
  55. {
  56.     if(val==0)
  57. zerorow(sptr,n);
  58.     else {
  59. while(n>=8) {
  60.     sptr[0] = val;
  61.     sptr[1] = val;
  62.     sptr[2] = val;
  63.     sptr[3] = val;
  64.     sptr[4] = val;
  65.     sptr[5] = val;
  66.     sptr[6] = val;
  67.     sptr[7] = val;
  68.     sptr += 8;
  69.     n -= 8;
  70. }
  71. while(n--) 
  72.     *sptr++ = val;
  73.     }
  74. }
  76. #define DOCLAMP(iptr,optr) *(optr) = ((*(iptr)<0) ? 0 : (*(iptr)>255) ? 255 : *(iptr))
  78. clamprow(iptr,optr,n)
  79. short *iptr, *optr;
  80. int n;
  81. {
  82.     while(n>=8) {
  83. DOCLAMP(iptr+0,optr+0);
  84. DOCLAMP(iptr+1,optr+1);
  85. DOCLAMP(iptr+2,optr+2);
  86. DOCLAMP(iptr+3,optr+3);
  87. DOCLAMP(iptr+4,optr+4);
  88. DOCLAMP(iptr+5,optr+5);
  89. DOCLAMP(iptr+6,optr+6);
  90. DOCLAMP(iptr+7,optr+7);
  91. iptr += 8;
  92. optr += 8;
  93. n -= 8;
  94.     }
  95.     while(n--) {
  96. DOCLAMP(iptr,optr);
  97. iptr++;
  98. optr++;
  99.     }
  100. }
  102. accrow(iptr,sptr,w,n)
  103. short *iptr;
  104. short *sptr;
  105. int w, n;
  106. {
  107.     if(w == 1) {
  108. addsrow(iptr,sptr,n);
  109.     } else if(w == -1) {
  110. subsrow(iptr,sptr,n);
  111.     } else {
  112. while(n>=8) {
  113.     iptr[0] += w*sptr[0];
  114.     iptr[1] += w*sptr[1];
  115.     iptr[2] += w*sptr[2];
  116.     iptr[3] += w*sptr[3];
  117.     iptr[4] += w*sptr[4];
  118.     iptr[5] += w*sptr[5];
  119.     iptr[6] += w*sptr[6];
  120.     iptr[7] += w*sptr[7];
  121.     iptr += 8;
  122.     sptr += 8;
  123.     n -= 8;
  124. }
  125. while(n--) 
  126.     *iptr++ += (w * *sptr++);
  127.     }
  128. }
  130. divrow(iptr,optr,tot,n)
  131. short *iptr;
  132. short *optr;
  133. int tot, n;
  134. {
  135.     if(iptr == optr) {
  136. while(n>=8) {
  137.     optr[0] = optr[0]/tot;
  138.     optr[1] = optr[1]/tot;
  139.     optr[2] = optr[2]/tot;
  140.     optr[3] = optr[3]/tot;
  141.     optr[4] = optr[4]/tot;
  142.     optr[5] = optr[5]/tot;
  143.     optr[6] = optr[6]/tot;
  144.     optr[7] = optr[7]/tot;
  145.     optr += 8;
  146.     n -= 8;
  147. }
  148. while(n--) {
  149.     *optr = (*optr)/tot;
  150.     optr++;
  151. }
  152.     } else {
  153. while(n>=8) {
  154.     optr[0] = iptr[0]/tot;
  155.     optr[1] = iptr[1]/tot;
  156.     optr[2] = iptr[2]/tot;
  157.     optr[3] = iptr[3]/tot;
  158.     optr[4] = iptr[4]/tot;
  159.     optr[5] = iptr[5]/tot;
  160.     optr[6] = iptr[6]/tot;
  161.     optr[7] = iptr[7]/tot;
  162.     optr += 8;
  163.     iptr += 8;
  164.     n -= 8;
  165. }
  166. while(n--) 
  167.     *optr++ = (*iptr++)/tot;
  168.     }
  169. }
  171. #define DOTOBW(optr,rptr,gptr,bptr) *(optr) = ILUM(*(rptr),*(gptr),*(bptr))
  173. rgbrowtobw(rbuf,gbuf,bbuf,obuf,n)
  174. unsigned short *rbuf, *gbuf, *bbuf, *obuf;
  175. int n;
  176. {
  177.     while(n>=8) {
  178. DOTOBW(obuf+0,rbuf+0,gbuf+0,bbuf+0);
  179. DOTOBW(obuf+1,rbuf+1,gbuf+1,bbuf+1);
  180. DOTOBW(obuf+2,rbuf+2,gbuf+2,bbuf+2);
  181. DOTOBW(obuf+3,rbuf+3,gbuf+3,bbuf+3);
  182. DOTOBW(obuf+4,rbuf+4,gbuf+4,bbuf+4);
  183. DOTOBW(obuf+5,rbuf+5,gbuf+5,bbuf+5);
  184. DOTOBW(obuf+6,rbuf+6,gbuf+6,bbuf+6);
  185. DOTOBW(obuf+7,rbuf+7,gbuf+7,bbuf+7);
  186. rbuf += 8;
  187. gbuf += 8;
  188. bbuf += 8;
  189. obuf += 8;
  190. n -= 8;
  191.     } 
  192.     while(n--) {
  193. DOTOBW(obuf,rbuf,gbuf,bbuf);
  194. rbuf++;
  195. gbuf++;
  196. bbuf++;
  197. obuf++;
  198.     }
  199. }
  201. /*
  202.  * addsrow -
  203.  * Add two rows together
  204.  *
  205.  */
  206. addsrow(dptr,sptr,n)
  207. short *dptr, *sptr;
  208. int n;
  209. {
  210.     while(n>=8) {
  211. dptr[0] += sptr[0];
  212. dptr[1] += sptr[1];
  213. dptr[2] += sptr[2];
  214. dptr[3] += sptr[3];
  215. dptr[4] += sptr[4];
  216. dptr[5] += sptr[5];
  217. dptr[6] += sptr[6];
  218. dptr[7] += sptr[7];
  219. dptr += 8;
  220. sptr += 8;
  221. n -= 8;
  222.     }
  223.     while(n--) 
  224. *dptr++ += *sptr++;
  225. }
  227. /*
  228.  * subsrow -
  229.  * Subtract two rows
  230.  *
  231.  */
  232. subsrow(dptr,sptr,n)
  233. short *dptr, *sptr;
  234. int n;
  235. {
  236.     while(n>=8) {
  237. dptr[0] -= sptr[0];
  238. dptr[1] -= sptr[1];
  239. dptr[2] -= sptr[2];
  240. dptr[3] -= sptr[3];
  241. dptr[4] -= sptr[4];
  242. dptr[5] -= sptr[5];
  243. dptr[6] -= sptr[6];
  244. dptr[7] -= sptr[7];
  245. dptr += 8;
  246. sptr += 8;
  247. n -= 8;
  248.     }
  249.     while(n--) 
  250. *dptr++ -= *sptr++;
  251. }
  253. bitstorow(bits,sbuf,n)
  254. unsigned char *bits;
  255. short *sbuf;
  256. int n;
  257. {
  258.     int i, val, nbytes;
  260.     nbytes = ((n-1)/8)+1;
  261.     for(i = 0; i<nbytes; i++ ) {
  262. val = *bits++;
  263. if(val&0x80)
  264.     sbuf[0] = 0;
  265. else
  266.     sbuf[0] = 255;
  267. if(val&0x40)
  268.     sbuf[1] = 0;
  269. else
  270.     sbuf[1] = 255;
  271. if(val&0x20)
  272.     sbuf[2] = 0;
  273. else
  274.     sbuf[2] = 255;
  275. if(val&0x10)
  276.     sbuf[3] = 0;
  277. else
  278.     sbuf[3] = 255;
  279. if(val&0x08)
  280.     sbuf[4] = 0;
  281. else
  282.     sbuf[4] = 255;
  283. if(val&0x04)
  284.     sbuf[5] = 0;
  285. else
  286.     sbuf[5] = 255;
  287. if(val&0x02)
  288.     sbuf[6] = 0;
  289. else
  290.     sbuf[6] = 255;
  291. if(val&0x01)
  292.     sbuf[7] = 0;
  293. else
  294.     sbuf[7] = 255;
  295. sbuf += 8;
  296.     }
  297. }
  299. rowtobits(sbuf,bits,n)
  300. short *sbuf;
  301. unsigned char *bits;
  302. int n;
  303. {
  304.     int i, val, nbytes, thresh;
  306.     nbytes = ((n-1)/8)+1;
  307.     thresh = 128;
  308.     for(i = 0; i<nbytes; i++) {
  309. val = 0;
  310. if(sbuf[0]<thresh)
  311.     val |= 0x80;
  312. if(sbuf[1]<thresh)
  313.     val |= 0x40;
  314. if(sbuf[2]<thresh)
  315.     val |= 0x20;
  316. if(sbuf[3]<thresh)
  317.     val |= 0x10;
  318. if(sbuf[4]<thresh)
  319.     val |= 0x08;
  320. if(sbuf[5]<thresh)
  321.     val |= 0x04;
  322. if(sbuf[6]<thresh)
  323.     val |= 0x02;
  324. if(sbuf[7]<thresh)
  325.     val |= 0x01;
  326. sbuf += 8;
  327. *bits++ = val;
  328.     }
  329. }
  331. /* 
  332.  * bit reverse a stream of bytes
  333.  *
  334.  */
  335. bitrevbytes(buf,n)
  336. unsigned char *buf;
  337. int n;
  338. {
  339.     int i, x, br;
  340.     static unsigned char *bitrev;
  342.     if(!bitrev) {
  343. bitrev = (unsigned char *)malloc(256);
  344. for(i=0; i<256; i++) {
  345.     br = 0;
  346.     for(x=0; x<8; x++) {
  347. br = br<<1;
  348. if(i&(1<<x))
  349.     br |= 1;
  350.     }
  351.     bitrev[i] = br;
  352. }
  353.     }
  354.     while(n>=8) {
  355. buf[0] = bitrev[buf[0]];
  356. buf[1] = bitrev[buf[1]];
  357. buf[2] = bitrev[buf[2]];
  358. buf[3] = bitrev[buf[3]];
  359. buf[4] = bitrev[buf[4]];
  360. buf[5] = bitrev[buf[5]];
  361. buf[6] = bitrev[buf[6]];
  362. buf[7] = bitrev[buf[7]];
  363. buf += 8;
  364. n -= 8;
  365.     }
  366.     while(n--) {
  367. buf[0] = bitrev[buf[0]];
  368. *buf++;
  369.     }
  370. }
  372. /* 
  373.  * flip a row of shorts
  374.  *
  375.  */
  376. flipsrow(sptr,n) 
  377. register short *sptr;
  378. register int n;
  379. {
  380.     register short temp, *p1, *p2;
  382.     p1 = sptr;
  383.     p2 = sptr+n-1;
  384.     n = n/2;
  385.     while(n--) {
  386. temp = *p1;
  387. *p1++ = *p2;
  388. *p2-- = temp;
  389.     }
  390. }
  392. /*  cpack -
  393.  * Convert from and to cpack format.
  394.  *
  395.  */
  396. bwtocpack(b,l,n)
  397. register unsigned short *b;
  398. register unsigned long *l;
  399. register int n;
  400. {
  401.     while(n>=8) {
  402. l[0] = 0x00010101*b[0];
  403. l[1] = 0x00010101*b[1];
  404. l[2] = 0x00010101*b[2];
  405. l[3] = 0x00010101*b[3];
  406. l[4] = 0x00010101*b[4];
  407. l[5] = 0x00010101*b[5];
  408. l[6] = 0x00010101*b[6];
  409. l[7] = 0x00010101*b[7];
  410. l += 8;
  411. b += 8;
  412. n -= 8;
  413.     }
  414.     while(n--) 
  415. *l++ = 0x00010101*(*b++);
  416. }
  418. rgbtocpack(r,g,b,l,n)
  419. register unsigned short *r, *g, *b;
  420. register unsigned long *l;
  421. register int n;
  422. {
  423.     while(n>=8) {
  424. l[0] = r[0] | (g[0]<<8) | (b[0]<<16);
  425. l[1] = r[1] | (g[1]<<8) | (b[1]<<16);
  426. l[2] = r[2] | (g[2]<<8) | (b[2]<<16);
  427. l[3] = r[3] | (g[3]<<8) | (b[3]<<16);
  428. l[4] = r[4] | (g[4]<<8) | (b[4]<<16);
  429. l[5] = r[5] | (g[5]<<8) | (b[5]<<16);
  430. l[6] = r[6] | (g[6]<<8) | (b[6]<<16);
  431. l[7] = r[7] | (g[7]<<8) | (b[7]<<16);
  432. l += 8;
  433. r += 8;
  434. g += 8;
  435. b += 8;
  436. n -= 8;
  437.     }
  438.     while(n--) 
  439.         *l++ = *r++ | ((*g++)<<8) | ((*b++)<<16);
  440. }
  442. rgbatocpack(r,g,b,a,l,n)
  443. register unsigned short *r, *g, *b, *a;
  444. register unsigned long *l;
  445. register int n;
  446. {
  447.     while(n>=8) {
  448. l[0] = r[0] | (g[0]<<8) | (b[0]<<16) | (a[0]<<24);
  449. l[1] = r[1] | (g[1]<<8) | (b[1]<<16) | (a[1]<<24);
  450. l[2] = r[2] | (g[2]<<8) | (b[2]<<16) | (a[2]<<24);
  451. l[3] = r[3] | (g[3]<<8) | (b[3]<<16) | (a[3]<<24);
  452. l[4] = r[4] | (g[4]<<8) | (b[4]<<16) | (a[4]<<24);
  453. l[5] = r[5] | (g[5]<<8) | (b[5]<<16) | (a[5]<<24);
  454. l[6] = r[6] | (g[6]<<8) | (b[6]<<16) | (a[6]<<24);
  455. l[7] = r[7] | (g[7]<<8) | (b[7]<<16) | (a[7]<<24);
  456. l += 8;
  457. r += 8;
  458. g += 8;
  459. b += 8;
  460. a += 8;
  461. n -= 8;
  462.     }
  463.     while(n--) 
  464.         *l++ = *r++ | ((*g++)<<8) | ((*b++)<<16) | ((*a++)<<24);
  465. }
  467. #define CPACKTORGB(l,r,g,b)
  468. val = (l);
  469. (r) = (val>>0) & 0xff;
  470. (g) = (val>>8) & 0xff;
  471. (b) = (val>>16) & 0xff;
  473. cpacktorgb(l,r,g,b,n)
  474. register unsigned long *l;
  475. register unsigned short *r, *g, *b;
  476. register int n;
  477. {
  478.     unsigned long val;
  480.     while(n>=8) {
  481. CPACKTORGB(l[0],r[0],g[0],b[0]);
  482. CPACKTORGB(l[1],r[1],g[1],b[1]);
  483. CPACKTORGB(l[2],r[2],g[2],b[2]);
  484. CPACKTORGB(l[3],r[3],g[3],b[3]);
  485. CPACKTORGB(l[4],r[4],g[4],b[4]);
  486. CPACKTORGB(l[5],r[5],g[5],b[5]);
  487. CPACKTORGB(l[6],r[6],g[6],b[6]);
  488. CPACKTORGB(l[7],r[7],g[7],b[7]);
  489. l += 8;
  490. r += 8;
  491. g += 8;
  492. b += 8;
  493. n -= 8;
  494.     }
  495.     while(n--) {
  496. CPACKTORGB(l[0],r[0],g[0],b[0]);
  497. l++;
  498. r++;
  499. g++;
  500. b++;
  501.     }
  502. }
  504. #define CPACKTORGBA(l,r,g,b,a)
  505. val = (l);
  506. (r) = (val>>0) & 0xff;
  507. (g) = (val>>8) & 0xff;
  508. (b) = (val>>16) & 0xff;
  509. (a) = (val>>24) & 0xff;
  511. cpacktorgba(l,r,g,b,a,n)
  512. register unsigned long *l;
  513. register unsigned short *r, *g, *b, *a;
  514. register int n;
  515. {
  516.     unsigned long val;
  518.     while(n>=8) {
  519. CPACKTORGBA(l[0],r[0],g[0],b[0],a[0]);
  520. CPACKTORGBA(l[1],r[1],g[1],b[1],a[1]);
  521. CPACKTORGBA(l[2],r[2],g[2],b[2],a[2]);
  522. CPACKTORGBA(l[3],r[3],g[3],b[3],a[3]);
  523. CPACKTORGBA(l[4],r[4],g[4],b[4],a[4]);
  524. CPACKTORGBA(l[5],r[5],g[5],b[5],a[5]);
  525. CPACKTORGBA(l[6],r[6],g[6],b[6],a[6]);
  526. CPACKTORGBA(l[7],r[7],g[7],b[7],a[7]);
  527. l += 8;
  528. r += 8;
  529. g += 8;
  530. b += 8;
  531. a += 8;
  532. n -= 8;
  533.     }
  534.     while(n--) {
  535. CPACKTORGBA(l[0],r[0],g[0],b[0],a[0]);
  536. l++;
  537. r++;
  538. g++;
  539. b++;
  540. a++;
  541.     }
  542. }
  544. /*
  545.  * normrow -
  546.  * Normalize a row of image data
  547.  *
  548.  */
  549. normrow(image,buf)
  550. IMAGE *image;
  551. short *buf;
  552. {
  553.     int n, max;
  555.     n = image->xsize;
  556.     max = image->max;
  557.     if(max == 255 || max == 0)
  558. return;
  559.     while(n>=8) {
  560. buf[0] = (buf[0]*255)/max;
  561. buf[1] = (buf[1]*255)/max;
  562. buf[2] = (buf[2]*255)/max;
  563. buf[3] = (buf[3]*255)/max;
  564. buf[4] = (buf[4]*255)/max;
  565. buf[5] = (buf[5]*255)/max;
  566. buf[6] = (buf[6]*255)/max;
  567. buf[7] = (buf[7]*255)/max;
  568. buf += 8;
  569. n -= 8;
  570.     }
  571.     while(n--) {
  572. *buf = (*buf*255)/max;
  573. buf++;
  574.     }
  575. }
  577. static short *rbuf, *gbuf, *bbuf;
  578. static int malloclen = 0;
  580. getbwrow(image,buf,y)
  581. IMAGE *image;
  582. short *buf;
  583. int y;
  584. {
  585.     if(malloclen!=image->xsize) {
  586. if(malloclen) {
  587.     free(rbuf);
  588.     free(gbuf);
  589.     free(bbuf);
  590. }
  591. rbuf = (short *)malloc(image->xsize*sizeof(short));
  592. gbuf = (short *)malloc(image->xsize*sizeof(short));
  593. bbuf = (short *)malloc(image->xsize*sizeof(short));
  594. malloclen=image->xsize;;
  595.     }
  596.     if(image->zsize<3) {
  597. getrow(image,buf,y,0);
  598.     } else {
  599. getrow(image,rbuf,y,0);
  600. getrow(image,gbuf,y,1);
  601. getrow(image,bbuf,y,2);
  602. rgbrowtobw(rbuf,gbuf,bbuf,buf,image->xsize);
  603.     }
  604. }
  606. putfliprow(image,buf,y,z,flipcode)
  607. IMAGE *image;
  608. short *buf;
  609. int y, z;
  610. int flipcode;
  611. {
  612.     if(flipcode&1)
  613. flipsrow(buf,image->xsize);
  614.     if(flipcode&2)
  615. putrow(image,buf,(image->ysize-1)-y,z);
  616.     else
  617. putrow(image,buf,y,z);
  618. }
  620. getfliprow(image,buf,y,z,flipcode)
  621. IMAGE *image;
  622. short *buf;
  623. int y, z, flipcode;
  624. {
  625.     if(flipcode&2)
  626. getrow(image,buf,(image->ysize-1)-y,z);
  627.     else
  628. getrow(image,buf,y,z);
  629.     if(flipcode&1)
  630. flipsrow(buf,image->xsize);
  631. }
  633. /* 
  634.  * dithering stuff follows
  635.  *
  636.  */
  637. #define MATSIZE88
  639. #define XSIZE 8
  640. #define YSIZE 8
  642. #ifdef NOTDEF
  643. static short dithmat[YSIZE][XSIZE] = { /* 8x8 Limb */
  644. 0, 8, 36, 44, 2, 10, 38, 46,
  645. 16, 24, 52, 60, 18, 26, 54, 62,
  646. 32, 40,  4, 12, 34, 42, 6, 14,
  647. 48, 56, 20, 28, 50, 58, 22, 30,
  648. 3, 11, 39, 47, 1, 9, 37, 45,
  649. 19, 27, 55, 63, 17, 25, 53, 61,
  650. 35, 43, 7, 15, 33, 41, 5, 13,
  651. 51, 59, 23, 31, 49, 57, 21, 29,
  652. };
  654. static short dithmat[YSIZE][XSIZE] = { /* halftone dots */
  655. 3, 17, 55,     63, 61,     47, 9, 1,
  656. 15,  29, 39, 51, 49, 35, 25, 13,
  657. 40, 32, 26, 20, 22, 30, 36, 42,
  658. 56, 44, 10, 4, 6, 18, 52, 58,
  659. 60, 46, 8, 0, 2, 16, 54, 62,
  660. 48, 34, 24, 12, 14, 28, 38, 50,
  661. 23, 31, 37, 43, 41, 33, 27, 21,
  662. 7, 19, 53, 59, 57, 45, 11, 5,
  663. };
  665. #define TOTAL (XSIZE*YSIZE)
  667. ditherrow(buf,y,n)
  668. short *buf;
  669. int y, n;
  670. {
  671.     int r, val;
  672.     int rshades, rmaxbits;
  673.     short *rdith, *gdith, *bdith;
  675.     rdith = &dithmat[y%YSIZE][0];
  676.     rshades = TOTAL+1;
  677.     rmaxbits = ((rshades-1)/TOTAL);
  678.     while(n--) {
  679. r = *buf;
  680. val = (rshades*r)/255;
  681. if(val>=TOTAL) 
  682.     *buf++ = 255;
  683. else if(val>rdith[n%XSIZE])
  684.     *buf++ = 255;
  685. else
  686.     *buf++ = 0;
  687.     }
  688. }
  689. #endif