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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
dither.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：26k
源码类别：

浏览器

开发平台：

Unix_Linux

dither.c：源码内容
  1. /*    dither.c 
  2.     - Dave Raggett, 16th December 1994
  3.             - revised 9th Feb 1994 to speed decoding & add gif89 support
  4.     - separated from gif.c by Phill Hallam-Baker
  6.    The colors are preallocated by image.c with 4:8:4 R:G:B colors and
  7.    16 grey scales. These are rendered using an ordered dither based on
  8.    16x16 dither matrices for monochrome, greyscale and color images.
  10.    This approach ensures that we won't run out of colors regardless of
  11.    how many images are on screen or how many independent copies of www
  12.    are running at any time. The scheme is compatible with HP's MPOWER
  13.    tools. The code will be extended to take advantage of 24 bit direct
  14.    color or secondary true color hardware colormaps as soon as practical.
  15. */
  18. #include <X11/Intrinsic.h>
  19. #include <stdio.h>
  20. #include <stdlib.h>
  22. #include "www.h"
  23. #include "image.h"
  25. #define MAXCOLORMAPSIZE 256
  27. #define TRUE    1
  28. #define FALSE   0
  30. #define CM_RED          0
  31. #define CM_GREEN        1
  32. #define CM_BLUE         2
  34. #define INTERLACE       0x40
  35. #define LOCALCOLORMAP   0x80
  38. #define BitSet(byte, bit) (((byte) & (bit)) == (bit))
  39. #define LM_to_uint(a,b)   (((b)<<8)|(a))
  41. extern Display *display;
  42. extern int screen;
  43. extern int RPixelShift;
  44. extern int depth;
  45. extern Colormap colormap;
  46. extern int imaging;  /* set to COLOR888, COLOR232, GREY4 or MONO */
  47. extern int tileWidth, tileHeight;
  48. extern unsigned char *tileData;
  49. extern unsigned long windowColor;
  50. extern unsigned long greymap[16];
  51. extern debug; /* howcome 16/10/94 */
  52. extern unsigned long transparent; /* howcome 30/10/94 */
  53. extern BOOL Quiet; /* howcome 11/8/95 */
  54. extern unsigned char* gamma_table;
  56. extern unsigned long stdcmap[128];  /* 2/3/2 color maps for gifs etc */
  57. unsigned long mycmap[256];
  60. /* mycmap is an array containing X11 pixel values. The layout of the array is as follows:
  62.     mycmap[0] = BlackPixel(display, screen);
  63.     mycmap[127] = WhitePixel(display, screen);
  64.     mycmap[1-126]: magic colors
  66.     mycymap[128] = BlackPixel(display, screen);
  67.     mycmap[143] = WhitePixel(display, screen);
  68.     mycmap[129-142]: magic gray
  70.     150-159: read only colors for application
  71.     160-199: read only colors for current document
  73.     200-209: read/write colors for application
  74.     210-249: read/write colors for current document
  75.     
  76. */
  78. #define RO_COL_DOC_START 160
  79. #define RO_COL_DOC_END   199
  81. #define RW_COL_DOC_START 210
  82. #define RW_COL_DOC_END   249
  85. int Magic256[256] =    /* for halftoning */
  86. {
  87.     0, 223, 48, 207, 14, 237, 62, 221, 3, 226, 51, 210, 13, 236, 61, 220,
  88.     175, 80, 128, 96, 189, 94, 141, 110, 178, 83, 130, 99, 188, 93, 140, 109,
  89.     191, 32, 239, 16, 205, 46, 253, 30, 194, 35, 242, 19, 204, 45, 252, 29,
  90.     112, 143, 64, 159, 126, 157, 78, 173, 115, 146, 67, 162, 125, 156, 77, 172,
  91.     11, 234, 59, 218, 5, 228, 53, 212, 8, 231, 56, 215, 6, 229, 54, 213,
  92.     186, 91, 138, 107, 180, 85, 132, 101, 183, 88, 135, 104, 181, 86, 133, 102,
  93.     202, 43, 250, 27, 196, 37, 244, 21, 199, 40, 247, 24, 197, 38, 245, 22,
  94.     123, 154, 75, 170, 117, 148, 69, 164, 120, 151, 72, 167, 118, 149, 70, 165,
  95.     12, 235, 60, 219, 2, 225, 50, 209, 15, 238, 63, 222, 1, 224, 49, 208,
  96.     187, 92, 139, 108, 177, 82, 129, 98, 190, 95, 142, 111, 176, 81, 128, 97,
  97.     203, 44, 251, 28, 193, 34, 241, 18, 206, 47, 254, 31, 192, 33, 240, 17,
  98.     124, 155, 76, 171, 114, 145, 66, 161, 127, 158, 79, 174, 113, 144, 65, 160,
  99.     7, 230, 55, 214, 9, 232, 57, 216, 4, 227, 52, 211, 10, 233, 58, 217,
  100.     182, 87, 134, 103, 184, 89, 136, 105, 179, 84, 131, 100, 185, 90, 137, 106,
  101.     198, 39, 246, 23, 200, 41, 248, 25, 195, 36, 243, 20, 201, 42, 249, 26,
  102.     119, 150, 71, 166, 121, 152, 73, 168, 116, 147, 68, 163, 122, 153, 74, 169
  104. };
  106. int Magic16[256] =    /* for 16 levels of gray */
  107. {
  108.     0, 13, 3, 12, 1, 14, 4, 13, 0, 13, 3, 12, 1, 14, 4, 13,
  109.     10, 5, 8, 6, 11, 6, 8, 6, 10, 5, 8, 6, 11, 5, 8, 6,
  110.     11, 2, 14, 1, 12, 3, 15, 2, 11, 2, 14, 1, 12, 3, 15, 2,
  111.     7, 8, 4, 9, 7, 9, 5, 10, 7, 9, 4, 10, 7, 9, 5, 10,
  112.     1, 14, 3, 13, 0, 13, 3, 12, 0, 14, 3, 13, 0, 13, 3, 13,
  113.     11, 5, 8, 6, 11, 5, 8, 6, 11, 5, 8, 6, 11, 5, 8, 6,
  114.     12, 3, 15, 2, 12, 2, 14, 1, 12, 2, 15, 1, 12, 2, 14, 1,
  115.     7, 9, 4, 10, 7, 9, 4, 10, 7, 9, 4, 10, 7, 9, 4, 10,
  116.     1, 14, 4, 13, 0, 13, 3, 12, 1, 14, 4, 13, 0, 13, 3, 12,
  117.     11, 5, 8, 6, 10, 5, 8, 6, 11, 6, 8, 7, 10, 5, 8, 6,
  118.     12, 3, 15, 2, 11, 2, 14, 1, 12, 3, 15, 2, 11, 2, 14, 1,
  119.     7, 9, 4, 10, 7, 9, 4, 9, 7, 9, 5, 10, 7, 8, 4, 9,
  120.     0, 14, 3, 13, 1, 14, 3, 13, 0, 13, 3, 12, 1, 14, 3, 13,
  121.     11, 5, 8, 6, 11, 5, 8, 6, 11, 5, 8, 6, 11, 5, 8, 6,
  122.     12, 2, 14, 1, 12, 2, 15, 1, 11, 2, 14, 1, 12, 2, 15, 2,
  123.     7, 9, 4, 10, 7, 9, 4, 10, 7, 9, 4, 10, 7, 9, 4, 10
  125. };
  127. int Magic32[256] =    /* for 8 levels of green */
  128. {
  129.     0, 27, 6, 25, 2, 29, 8, 27, 0, 27, 6, 26, 2, 29, 7, 27,
  130.     21, 10, 16, 12, 23, 11, 17, 13, 22, 10, 16, 12, 23, 11, 17, 13,
  131.     23, 4, 29, 2, 25, 6, 31, 4, 24, 4, 29, 2, 25, 5, 31, 4,
  132.     14, 17, 8, 19, 15, 19, 9, 21, 14, 18, 8, 20, 15, 19, 9, 21,
  133.     1, 28, 7, 27, 1, 28, 6, 26, 1, 28, 7, 26, 1, 28, 7, 26,
  134.     23, 11, 17, 13, 22, 10, 16, 12, 22, 11, 16, 13, 22, 10, 16, 12,
  135.     25, 5, 30, 3, 24, 4, 30, 3, 24, 5, 30, 3, 24, 5, 30, 3,
  136.     15, 19, 9, 21, 14, 18, 8, 20, 15, 18, 9, 20, 14, 18, 8, 20,
  137.     1, 29, 7, 27, 0, 27, 6, 25, 2, 29, 8, 27, 0, 27, 6, 25,
  138.     23, 11, 17, 13, 22, 10, 16, 12, 23, 12, 17, 13, 21, 10, 16, 12,
  139.     25, 5, 31, 3, 23, 4, 29, 2, 25, 6, 31, 4, 23, 4, 29, 2,
  140.     15, 19, 9, 21, 14, 18, 8, 20, 15, 19, 10, 21, 14, 18, 8, 19,
  141.     1, 28, 7, 26, 1, 28, 7, 26, 0, 28, 6, 26, 1, 28, 7, 26,
  142.     22, 11, 16, 12, 22, 11, 17, 13, 22, 10, 16, 12, 23, 11, 17, 13,
  143.     24, 5, 30, 3, 24, 5, 30, 3, 24, 4, 30, 2, 24, 5, 30, 3,
  144.     14, 18, 9, 20, 15, 19, 9, 20, 14, 18, 8, 20, 15, 19, 9, 21
  146. };
  148. int Magic64[256] =    /* for 4 levels of red and blue */
  149. {
  150.     0, 55, 12, 51, 3, 59, 15, 55, 1, 56, 13, 52, 3, 58, 15, 54,
  151.     43, 20, 32, 24, 47, 23, 35, 27, 44, 20, 32, 24, 47, 23, 35, 27,
  152.     47, 8, 59, 4, 51, 11, 63, 7, 48, 9, 60, 5, 50, 11, 62, 7,
  153.     28, 35, 16, 39, 31, 39, 19, 43, 28, 36, 16, 40, 31, 39, 19, 43,
  154.     3, 58, 15, 54, 1, 56, 13, 52, 2, 57, 14, 53, 1, 57, 13, 53,
  155.     46, 22, 34, 26, 45, 21, 33, 25, 45, 22, 33, 26, 45, 21, 33, 25,
  156.     50, 11, 62, 7, 48, 9, 60, 5, 49, 10, 61, 6, 49, 9, 61, 5,
  157.     30, 38, 18, 42, 29, 37, 17, 41, 30, 37, 18, 41, 29, 37, 17, 41,
  158.     3, 58, 15, 54, 0, 56, 12, 52, 4, 59, 16, 55, 0, 55, 12, 51,
  159.     46, 23, 34, 27, 44, 20, 32, 24, 47, 23, 35, 27, 44, 20, 32, 24,
  160.     50, 11, 62, 7, 48, 8, 60, 4, 51, 12, 63, 8, 47, 8, 59, 4,
  161.     31, 38, 19, 42, 28, 36, 16, 40, 31, 39, 19, 43, 28, 36, 16, 40,
  162.     2, 57, 14, 53, 2, 57, 14, 53, 1, 56, 13, 52, 2, 58, 14, 54,
  163.     45, 21, 33, 25, 46, 22, 34, 26, 44, 21, 32, 25, 46, 22, 34, 26,
  164.     49, 10, 61, 6, 49, 10, 61, 6, 48, 9, 60, 5, 50, 10, 62, 6,
  165.     29, 37, 17, 41, 30, 38, 18, 42, 29, 36, 17, 40, 30, 38, 18, 42
  167. };
  170. Byte color_ix_start = 128, color_ix_end = 128;
  173. unsigned long magic2color(Byte ix)
  174. {
  175.     int r, g, b;
  176.     unsigned long color;
  177.     
  179.     r = (ix << 6) & 0xC0;
  180.     g = (ix << 3) & 0xE0;
  181.     b = (ix << 1) & 0xC0;
  183.     GetColor(r, g, b, &color);
  184. /*    fprintf(stderr,"color %d %d %d ->  %ldn",r,g,b,color);*/
  185.     return color;
  186. }
  188. Byte rgb2magic(int r, int g, int b)
  189. {
  190.     /* janet 21/07/95: not used:    int cr, cg, cb; */
  193.     if (r == g && g == b) {
  194. /*
  195. cr = Voltage2Brightness(r);
  196. return(128 | (cr >> 4));
  197. */
  198. return(128 | r >> 4);
  199.     }
  200. /*
  201.     cr = Voltage2Brightness(r);
  202.     cg = Voltage2Brightness(g);
  203.     cb = Voltage2Brightness(b);
  204.     
  205.     r = cr & 0xC0;
  206.     g = cg & 0xE0;
  207.     b = cb & 0xC0;
  208. */
  209.     return ((r >> 6) | (g >> 3) | (b >> 1));
  210. }
  213. long ix2color(int ix)
  214. {
  215.     return mycmap[ix];
  216. }
  219. Byte rgb2ix(int status, int r, int g, int b, Bool blink)
  220. {
  221.     XColor xc;
  222.     /* janet 21/07/95: not used:    int cr, cg, cb; */
  223.     unsigned long pixels[1];
  224.     int i;
  225.     unsigned long px;
  227.     if (status)
  228. return (255);
  230.     xc.red = r << 8;
  231.     xc.green = g << 8;
  232.     xc.blue = b << 8;
  233.     xc.flags = DoRed | DoGreen | DoBlue;
  235.     if (blink) {
  236. if (XAllocColorCells(display, colormap, False, NULL, 0, pixels, 1)) {
  237.     xc.pixel = pixels[0];
  238.     XStoreColor(display, colormap, &xc);
  240.     for(i = RW_COL_DOC_START; (i <= RW_COL_DOC_END) && (mycmap[i] != 0); i++)
  241. ;
  242.     mycmap[i] = xc.pixel;
  243.     return(i);
  244. }
  245.     }
  247.     if (!XAllocColor(display, colormap, &xc)) {
  248.         /* janet 21/07/95: not used: Byte ix; */
  249. /* janet 21/07/95: not used: unsigned long color; */
  250.     
  251. if (VERBOSE_TRACE)
  252.     fprintf(stderr,"Can't allocate exact color for #%2.2x%2.2x%2.2x, ", r, g, b);
  254. r = min(r, 255) & 0xC0;
  255. g = min(g, 255) & 0xE0;
  256. b = min(b, 255) & 0xC0;
  258. if (VERBOSE_TRACE)
  259.     fprintf(stderr,"using substitute #%2.2x%2.2x%2.2xn", r, g, b);
  261. /* fprintf(stderr,"rgb2ix: %dn", ((r >> 6) | (g >> 3) | (b >> 1)));*/
  262. return ((r >> 6) | (g >> 3) | (b >> 1));
  263.     }
  265.     px = xc.pixel;
  267.     for (i = 0; i < 144; i++) {
  268. if (mycmap[i] == px)
  269.     return(i);
  270.     }
  272.     for (i = RO_COL_DOC_START; (i <= RO_COL_DOC_END) && (mycmap[i] != 0); i++) {
  273. if (mycmap[i] == px) {
  274.     if (COLOR_TRACE)
  275. fprintf(stderr,"rgb2ix old: (%d %d %d) %d, %ldn",r,g,b,i,px);
  276.     return(i);
  277. }
  278.     }
  280.     if (i <= RO_COL_DOC_END) {
  281. mycmap[i] = px;
  282. if (COLOR_TRACE)
  283.     fprintf(stderr,"rgb2ix new: (%d %d %d) %d, %ldn",r, g, b, i,px);
  284. return (i);
  285.     }
  287.     fprintf(stderr,"rgb2ix ran out of colors.. n");
  289.     /* janet 21/07/95 function does not return value! */
  290.     /* return ???; */ 
  291. }
  293. long rgb2color(int status, int r, int g, int b, Bool rw)
  294. {
  295.     return(ix2color(rgb2ix(status, r, g, b, rw)));
  296. }
  300. void rgbClear()
  301. {
  302.     int i;
  303.     /* janet 21/07/95: not used:    XColor xca; */
  305.     if (COLOR_TRACE)
  306. fprintf(stderr,"rgbClearn");
  308.     for (i = RO_COL_DOC_START; (i <= RO_COL_DOC_END) && (mycmap[i] != 0); i++) {
  309. if (COLOR_TRACE)
  310.     fprintf(stderr,"rgbClear %d %ldn", i, mycmap[i]);
  311. XFreeColors( display, colormap, &mycmap[i], 1, 0L );
  312. mycmap[i]=0;
  313.     }
  315. }
  317. static int ImageOutputScanlines_1_2_4 (output_image_data *output, 
  318. image_data *idata) {
  319.   /*extern int ImageOutputScanlines_1_2_4 (output_image_data *output, 
  320. image_data *idata) { */
  322.     /*janet 21/07/95: not used:    unsigned char   c;      */
  323.     int             v;
  324.     int             xpos = 0, ypos = 0, yindex;   /* janet 21/07/95: not used: pass = 0 */
  325.     unsigned char   *dp, *scan_buffer;  /* janet 21/07/95: not used: *dy */
  326.     int             cr=0, cg=0, cb=0, r, g, b, row, col; /* 12-Mar-96 <herman@htbrug.hobby.nl> */
  327.     /*  janet 21/07/95: not used:   Color           color; */
  328.     int             ppb, bpl, shift=0;
  329.     int             newbyte;
  331. /* howcome added support for 1,2,4 depths */
  333.     if (depth != 1 && depth !=2 && depth !=4) {
  334. fprintf(stderr,"sorry, images are not supported for depth %dn",depth);
  335. return FALSE;
  336.     }
  338.     ppb = 8/depth; /* pixels per byte */
  339.     bpl = output->bytes_per_row;
  340.     newbyte = 1;
  341.     
  342.     if (TRUE) {
  343.         dp = output->data + output->row * output->bytes_per_row;
  344.         for (yindex = 0; yindex < idata->rows; yindex++) {
  345.     ypos = yindex + output->row;
  346.     scan_buffer = idata->buffer + (yindex * output->width * 3);
  348.             col = ypos & 15;
  350.             for (xpos = 0; xpos < idata->width; ++xpos) {
  351.                 row = xpos & 15;
  353. if (newbyte) {
  354.   *dp = 0;
  355.   newbyte = 0;
  356. }
  358.                 if (imaging == COLOR232) {
  360.     /* do we have to do grayscale like in ImageOutputScanlines_8 ?? */
  362.     switch (idata->components) {
  363.       case 1:
  364. cr = cg = cb = Voltage2Brightness(scan_buffer[xpos]);
  365. /* cr = cg = cb = gamma_table[scan_buffer[xpos]]; */
  366. break;
  367.       case 3:
  368. cr = Voltage2Brightness(scan_buffer [0+(xpos * 3)]);
  369. cg = Voltage2Brightness(scan_buffer [1+(xpos * 3)]);
  370. cb = Voltage2Brightness(scan_buffer [2+(xpos * 3)]);
  371. #if 0
  372. cr = gamma_table[scan_buffer [0+(xpos * 3)]];
  373. cg = gamma_table[scan_buffer [1+(xpos * 3)]];
  374. cb = gamma_table[scan_buffer [2+(xpos * 3)]];
  375. #endif
  376. break;
  377.       default:
  378. fprintf(stderr,"ImageOutputScanlines_1_2_4, components = %dn",idata->components);
  379.     }
  381.                     r = cr & 0xC0;
  382.                     g = cg & 0xE0;
  383.                     b = cb & 0xC0;
  385.                     v = (row << 4) + col;
  387.                     if (cr - r > Magic64[v])
  388.                         r += 64;
  390.                     if (cg - g > Magic32[v])
  391.                         g += 32;
  393.                     if (cb - b > Magic64[v])
  394.                         b += 64;
  396.                  /* clamp error to keep color in range 0 to 255 */
  398.                     r = min(r, 255) & 0xC0;
  399.                     g = min(g, 255) & 0xE0;
  400.                     b = min(b, 255) & 0xC0;
  403.     /* howcome added support for <8 bits 25/1/95 */
  405.     shift = (((7 - (xpos % 8)) % ppb) * depth);
  406.     *dp |= (stdcmap[(r >> 6) | (g >> 3) | (b >> 1)]) << shift;
  407.     if (shift == 0) {
  408. dp++;
  409. newbyte = 1;
  410.     }
  411.                 }
  413.                 else if (imaging == MONO) {
  415.     switch (idata->components) {
  416.       case 1:
  417. cg = Voltage2Brightness(scan_buffer[xpos]);
  418. /* cg = gamma_table[scan_buffer[xpos]]; */
  419. break;
  420.       case 3:
  421. cg = Voltage2Brightness(
  422. (0.59*scan_buffer [0+(xpos * 3)]) +
  423. (0.20*scan_buffer [1+(xpos * 3)]) +
  424. (0.11*scan_buffer [2+(xpos * 3)]));
  425. #if 0
  426. cg = gamma_table[(int)
  427. ((0.59*scan_buffer [0+(xpos * 3)]) +
  428. (0.20*scan_buffer [1+(xpos * 3)]) +
  429. (0.11*scan_buffer [2+(xpos * 3)]))];
  430. #endif
  431. break;
  432.       default:
  433. fprintf(stderr,"ImageOutputScanlines_8, components = %dn",idata->components);
  434.     }
  436.     shift = (((7 - (xpos % 8)) % ppb) * depth);
  438.                     if (cg < Magic256[(row << 4) + col])
  439.                         *dp |= greymap[0] << shift;   /* was *dp++ 17-jan-96 */
  440.                     else
  441.                         *dp |= greymap[15] << shift;  /* idem */
  443.     if (shift == 0) {
  444. dp++;
  445. newbyte = 1;
  446.     }
  447.                 }
  449. else {
  451.     cg = Voltage2Brightness(
  452. (0.59*scan_buffer [0+(xpos * 3)]) +
  453. (0.20*scan_buffer [1+(xpos * 3)]) +
  454. (0.11*scan_buffer [2+(xpos * 3)]));
  455. #if 0
  456.    cg = gamma_table[(int)
  457. ((0.59*scan_buffer [0+(xpos * 3)]) +
  458. (0.20*scan_buffer [1+(xpos * 3)]) +
  459. (0.11*scan_buffer [2+(xpos * 3)]))];
  460. #endif
  461.                     g = cg & 0xF0;
  463.                     if (cg - g > Magic16[(row << 4) + col]) {
  464.                         g += 16;
  465. }
  466.                     g = min(g, 0xF0);
  468.     shift = (((7 - (xpos % 8)) % ppb) * depth);
  470.                     *dp++ |= greymap[g >> 4] << shift;
  472.     if (shift == 0) {
  473. dp++;
  474. newbyte = 1;
  475.     }
  477. }
  478.     }
  480.     if (shift) {
  481. dp++;   /* make sure we start on a new byte for the next line */
  482. newbyte = 1;
  483.     }
  485.         }
  486.     }
  487. }
  489. static int ImageOutputScanlines_8 (output_image_data *output, 
  490. image_data *idata) {
  492.   /*extern int ImageOutputScanlines_8 (output_image_data *output, 
  493. image_data *idata) { */
  495.     /* janet 21/07/95: not used:  unsigned char   c;   */   
  496.     int             v;
  497.     int             xpos = 0, ypos = 0,  yindex; /* janet 21/07/95: not used: pass = 0 */
  498.     unsigned char   *dp, *scan_buffer; /* janet 21/07/95: not used: *dy */
  499.     int             cr=0, cg=0, cb=0, r, g, b, row, col;
  500.     /* janet 21/07/95: not used:     Color           color; */
  502.     if (TRUE) {
  503.         dp = output->data + output->row * output->bytes_per_row;
  505. if (IMAGE_TRACE)
  506.     fprintf(stderr,"ImageOutputScanlines_8 %d %dn", output->row, output->bytes_per_row);
  508.         for (yindex = 0; yindex < idata->rows; yindex++) {
  509.     ypos = yindex + output->row;
  510.     scan_buffer = idata->buffer + (yindex * output->width * idata->components); /* howcome 19/2/95: 3 -> idata->components */
  512.     if (IMAGE_TRACE)
  513. fprintf(stderr,"ImageOutputScanlines: y %d scanbuffer %lxn",yindex, scan_buffer);
  515.             col = ypos & 15;
  517.             for (xpos = 0; xpos < idata->width; ++xpos) {
  518.                 row = xpos & 15;
  520.                 if (imaging == COLOR232) {
  522.     switch (idata->components) {
  524. /* do grayscale */
  526.       case 1:
  527. cr = cg = cb = Voltage2Brightness(scan_buffer[xpos]);
  528. /* cr = cg = cb = gamma_table[scan_buffer[xpos]]; */
  529. g = cg & 0xF0;
  530. if (cg - g > Magic16[(row << 4) + col])
  531.     g += 16;
  532. g = min(g, 0xF0);
  533. *dp++ = greymap[g >> 4];
  534. break;
  536.       case 3:
  537. cr = Voltage2Brightness(scan_buffer [0+(xpos * 3)]);
  538. cg = Voltage2Brightness(scan_buffer [1+(xpos * 3)]);
  539. cb = Voltage2Brightness(scan_buffer [2+(xpos * 3)]);
  540. #if 0
  541. cr = gamma_table[scan_buffer [0+(xpos * 3)]];
  542. cg = gamma_table[scan_buffer [1+(xpos * 3)]];
  543. cb = gamma_table[scan_buffer [2+(xpos * 3)]];
  544. #endif
  545. r = cr & 0xC0;
  546. g = cg & 0xE0;
  547. b = cb & 0xC0;
  549. v = (row << 4) + col;
  551. if (cr - r > Magic64[v])
  552.     r += 64;
  554. if (cg - g > Magic32[v])
  555.     g += 32;
  557. if (cb - b > Magic64[v])
  558.     b += 64;
  560. /* clamp error to keep color in range 0 to 255 */
  562. r = min(r, 255) & 0xC0;
  563. g = min(g, 255) & 0xE0;
  564. b = min(b, 255) & 0xC0;
  566. *dp++ = stdcmap[(r >> 6) | (g >> 3) | (b >> 1)];
  568. break;
  569.       default:
  570. fprintf(stderr,"ImageOutputScanlines_8, components = %dn",idata->components);
  571.     }
  572.                 }
  574.                 else if (imaging == MONO) {
  576.     switch (idata->components) {
  577.       case 1:
  578. cg = Voltage2Brightness(scan_buffer[xpos]);
  579. cg = gamma_table[scan_buffer[xpos]];
  580. break;
  581.       case 3:
  582. cg = Voltage2Brightness(
  583. (0.59*scan_buffer [0+(xpos * 3)]) +
  584. (0.20*scan_buffer [1+(xpos * 3)]) +
  585. (0.11*scan_buffer [2+(xpos * 3)]));
  586. #if 0
  587. cg = gamma_table[(int)
  588. ((0.59*scan_buffer [0+(xpos * 3)]) +
  589. (0.20*scan_buffer [1+(xpos * 3)]) +
  590. (0.11*scan_buffer [2+(xpos * 3)]))];
  591. #endif
  592. break;
  593.       default:
  594. fprintf(stderr,"ImageOutputScanlines_8, components = %dn",idata->components);
  595.     }
  597.                     if (cg < Magic256[(row << 4) + col])
  598.                         *dp++ = greymap[0];
  599.                     else
  600.                         *dp++ = greymap[15];
  601.                 }
  603. else {
  604.     switch (idata->components) {
  605.       case 1:
  606. cg = Voltage2Brightness(scan_buffer[xpos]);
  607. /* cg = gamma_table[scan_buffer[xpos]]; */
  608. break;
  609.       case 3:
  610. cg = Voltage2Brightness(
  611. (0.59*scan_buffer [0+(xpos * 3)]) +
  612. (0.20*scan_buffer [1+(xpos * 3)]) +
  613. (0.11*scan_buffer [2+(xpos * 3)]));
  614. #if 0
  615. cg = gamma_table[(int)
  616. ((0.59*scan_buffer [0+(xpos * 3)]) +
  617. (0.20*scan_buffer [1+(xpos * 3)]) +
  618. (0.11*scan_buffer [2+(xpos * 3)]))];
  619. #endif
  620. break;
  621.       default:
  622. fprintf(stderr,"ImageOutputScanlines_8, components = %dn",idata->components);
  623.     }
  625.                     g = cg & 0xF0;
  627.                     if (cg - g > Magic16[(row << 4) + col]) {
  628.                         g += 16;
  629. }
  630.                     g = min(g, 0xF0);
  631.                     *dp++ = greymap[g >> 4];
  632. }
  633.             }
  634.         }
  635.     }
  636.     return TRUE;  /* janet: added. should it return other value? */
  637. }
  639. static int ImageOutputScanlines_24 (output_image_data *output, 
  640. image_data *idata) {
  641. /*
  642. extern int ImageOutputScanlines_24 (output_image_data *output, 
  643. image_data *idata) { */
  645.   /* janet 24/07/95: not used:    unsigned char   c; */
  646.   /* janet 24/07/95: not used:    int             v; */
  647.     int             xpos = 0, ypos = 0, yindex; /* janet 21/07/95: not used: pass = 0 */
  648.     unsigned char   *dp, *scan_buffer; /* janet 21/07/95: not used: *dy */
  649.     int             row, col; /* janet 21/07/95: not used: cr, cg, cb, r, g, b */
  650.     /* janet 21/07/95: not used:    Color           color; */
  652.     if (TRUE) {
  653.         dp = output->data + output->row * output->bytes_per_row;
  655. if (IMAGE_TRACE)
  656.     fprintf(stderr,"ImageOutputScanlines_24 %d %dn", output->row, output->bytes_per_row);
  658.         for (yindex = 0; yindex < idata->rows; yindex++) {
  659.     ypos = yindex + output->row;
  660.     scan_buffer = idata->buffer + (yindex * output->width * 3);
  662.     if (IMAGE_TRACE)
  663. fprintf(stderr,"ImageOutputScanlines_24: y %d scanbuffer %lxn",yindex, scan_buffer);
  665.             col = ypos & 15;
  667.             for (xpos = 0; xpos < idata->width; ++xpos) {
  668.                 row = xpos & 15;
  670. /*
  671.                 cr = scan_buffer [0+(xpos * 3)];
  672.                 cg = scan_buffer [1+(xpos * 3)];
  673.                 cb = scan_buffer [2+(xpos * 3)];
  674. */
  676.          *dp++ = '';
  677. switch (idata->components) {
  678.   case 1:
  679.     *dp++ = scan_buffer [xpos];
  680.     *dp++ = scan_buffer [xpos];
  681.     *dp++ = scan_buffer [xpos];
  682.     break;
  683.   case 3:
  684.     *dp++ = scan_buffer [((RPixelShift) ? 0 : 2)+(xpos*3)];
  685.     *dp++ = scan_buffer [1+(xpos*3)];
  686.     *dp++ = scan_buffer [((RPixelShift) ? 2 : 0)+(xpos*3)];
  687.     break;
  688.   default:
  689.     fprintf(stderr,"ImageOutputScanlines_8, components = %dn",idata->components);
  690. }
  691.             }
  692.         }
  693.     }
  694.     return TRUE; /* janet 1/8/95: added. should it return other value? */
  695. } 
  697. static int ImageOutputScanlines_16 (output_image_data *output, 
  698. image_data *idata) {
  700.     int             xpos = 0, ypos = 0, yindex;
  701.     unsigned char   *dp, *scan_buffer;
  702.     int             row, col, cr, cg, cb; 
  703.     long            ulp;
  704.   
  705.     if (TRUE) {
  706.         dp = output->data + output->row * output->bytes_per_row;
  708. if (IMAGE_TRACE)
  709.     fprintf(stderr,"ImageOutputScanlines_16 %d %dn", output->row, output->bytes_per_row);
  711.         for (yindex = 0; yindex < idata->rows; yindex++) {
  712.     ypos = yindex + output->row;
  713.     scan_buffer = idata->buffer + (yindex * output->width * 3);
  715.     if (IMAGE_TRACE)
  716. fprintf(stderr,"ImageOutputScanlines_24: y %d scanbuffer %lxn",yindex, scan_buffer);
  718.             col = ypos & 15;
  720.             for (xpos = 0; xpos < idata->width; ++xpos) {
  721.                 row = xpos & 15;
  723. /*
  724.                 cr = scan_buffer [0+(xpos * 3)];
  725.                 cg = scan_buffer [1+(xpos * 3)];
  726.                 cb = scan_buffer [2+(xpos * 3)];
  727. */
  729. switch (idata->components) {
  730.   case 1:
  731.       cr = cg = cb = scan_buffer [xpos];
  732.       GetColor(cr, cg, cb, &ulp);
  733.       *dp++ = ((char*)&ulp)[1]; 
  734.       *dp++ = ((char*)&ulp)[0];
  735.       break;
  736.   case 3:
  737.       cr = scan_buffer [0+(xpos * 3)];
  738.       cg = scan_buffer [1+(xpos * 3)];
  739.       cb = scan_buffer [2+(xpos * 3)];
  740.       GetColor(cr, cg, cb, &ulp);
  741.       *dp++ = ((char*)&ulp)[1]; 
  742.       *dp++ = ((char*)&ulp)[0];
  743.       break; 
  744. default:
  745.     fprintf(stderr,"ImageOutputScanlines_16, components = %dn",idata->components);
  746. }
  747.             }
  748.         }
  749.     }
  750.     return TRUE; /* janet 1/8/95: added. should it return other value? */
  751. } 
  753. #ifdef NEVER
  754. static int ReadColorMap(Block *bp, Image *image, int ncolors, Color *colors, int *grey)
  755. {
  756.     int i, flag, npixels, drb, dgb, dbr;
  757.     unsigned char rgb[3];
  758.     unsigned long pixel, *pixels;
  760.     flag = 1;
  761.     image->npixels = npixels = 0;
  763.     if (imaging == GREY4 || imaging == MONO)
  764.         *grey = flag = 1;
  766.     for (i = 0; i < ncolors; ++i)
  767.     {
  768.         if (! ReadOK(bp, rgb, sizeof(rgb)))
  769.         {
  770.             fprintf(stderr, "bad colormapn");
  771.             return 0;
  772.         }
  774.         colors->red = rgb[0];
  775.         colors->green = rgb[1];
  776.         colors->blue = rgb[2];
  778.      /* apply gamma correction to map voltages to brightness values */
  780.         if (imaging != COLOR888)
  781.         {
  782.             colors->red = Voltage2Brightness(colors->red);
  783.             colors->green = Voltage2Brightness(colors->green);
  784.             colors->blue = Voltage2Brightness(colors->blue);
  785.         }
  787.      /* set grey value iff color is very close to grey (or GREY/MONO imaging) */
  789.         drb = abs(rgb[1] - rgb[0]);
  790.         dgb = abs(rgb[2] - rgb[1]);
  791.         dbr = abs(rgb[0] - rgb[2]);
  793.         if (*grey || (drb < 20 && dgb < 20 && dbr < 20))
  794.         {   
  795.             flag &= 1;
  796.             colors->grey = (3*colors->red + 6*colors->green + colors->blue)/10;
  797.         }
  798.         else
  799.         {
  800.             if (!(*grey))
  801.                 flag = 0;
  803.             colors->grey = 0;
  804.         }
  806.         ++colors;
  807.     }
  809.     *grey = flag;
  810.     return 1;
  811. }
  812. #endif
  815. extern int ImageOutputInit (void *output_in, image_data *data) { 
  816.   /* janet 24/07/95: not used: extern Image *image; */
  818.     output_image_data *output = (output_image_data *) output_in;
  819.     int blocksize;
  820.     /* janet 24/07/95: not used:     int i; */
  822.     output->height = data->height;
  823.     output->width = data->width;
  824.     output->row = 0;
  826.     if ((output->depth == 1) || (output->depth == 2) || (output->depth == 4)) {
  827. int  ppb;
  829.         ppb  = 8/output->depth;
  830.         output->bytes_per_row = data->width/ppb + (data->width%ppb ? 1 : 0); 
  832. /*
  833. fprintf(stderr,"sorry, jpeg images are not supported for depth %dn",depth);
  834. output->data = NULL;
  835. return NULL;
  836. */
  837. }
  838.     else if (output->depth == 8) {
  839. output->bytes_per_row = 1 * data->width;
  840.     }
  841.     else if (output->depth == 16) {
  842.         output->bytes_per_row = 2 * data->width;
  843.     }  
  844.     else if (output->depth == 24) {
  845.         output->bytes_per_row = 4 * data->width;  /* 4 ???? */
  846.     }    
  847.     else {
  848. fprintf(stderr,"sorry, images are not supported for depth %d (%d)n",depth, output->depth);
  849. output->data = NULL;
  850. return FALSE;
  851.     }
  853.     blocksize = output->bytes_per_row * data->height;
  854.     output->data = malloc (blocksize);
  856.     return TRUE; /* janet 1/8/95: added. */
  857. } 
  860. extern int ImageOutputScanlines (void *output_in, image_data *data) { 
  861.     output_image_data *output = (output_image_data *) output_in;
  863.     if (output->data == NULL) {
  864. return FALSE;
  865. }
  867.     else if ((output->depth == 1) || (output->depth == 2) || (output->depth == 4)) {
  868.         ImageOutputScanlines_1_2_4 (output, data);
  869. output->row = output->row + data->rows;
  870. }
  871.     else if (output->depth == 8) {
  872.         ImageOutputScanlines_8 (output, data);
  873. output->row = output->row + data->rows;
  874. }    
  875.     else if (output->depth == 24) {
  876.         ImageOutputScanlines_24 (output, data);
  877. output->row = output->row + data->rows; /* howcome 9/2/94: phill forgot this one */
  878. } 
  879.     else if (output->depth == 16) {
  880.         ImageOutputScanlines_16 (output, data);
  881. output->row = output->row + data->rows;
  882. } 
  883.     else {
  884. fprintf(stderr,"sorry, images are not supported for depth %dn",depth);
  885. return FALSE;
  886. }
  887.     return TRUE;  /* janet 1/8/95: added. */
  888. }