home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / gnu / gs-2.6.1.4-src.lha / src / amiga / ghostscript-2.6.1 / gdevpbm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-28  |  12.4 KB  |  417 lines
  1. /* Copyright (C) 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* gdevpbm.c */
  20. /* Portable Bit/Gray/PixMap devices for Ghostscript. */
  21. #include "gdevprn.h"
  22. #include "gxlum.h"
  23.  
  24. /* Thanks are due to Jos Vos (jos@bull.nl) for an earlier P*M driver, */
  25. /* on which this one is based. */
  26.  
  27. /*
  28.  * The PGM and PPM drivers have an "optimize" flag, which causes them to
  29.  * fall back to PBM or (for PPM) PGM if the page can be represented that way.
  30.  * This should be a device property, but for now, it's a compile-time option.
  31.  */
  32. #define OPTIMIZE 1
  33.  
  34. /*
  35.  * The code here is designed to work with variable depths for PGM and PPM.
  36.  * The restrictions on depth are as follows.  Numbers in square brackets
  37.  * give the actual restrictions, but the Ghostscript kernel requires that
  38.  * depth be a power of 2 or be 24.
  39.  *    pgm: 1, 2, 4, 8, 16.  [1-16]
  40.  *    pgmraw: 1, 2, 4, 8.  [1-8]
  41.  *    ppm: 4(3x1), 8(3x2), 16(3x5), 24(3x8), 32(3x10).  [3-32]
  42.  *    ppmraw: 4(3x1), 8(3x2), 16(3x5), 24(3x8).  [3-24]
  43.  */
  44.  
  45. /* Structure for P*M devices, which extend the generic printer device. */
  46.  
  47. #define MAX_COMMENT 70            /* max user-supplied comment */
  48. struct gx_device_pbm_s {
  49.     gx_device_common;
  50.     gx_prn_device_common;
  51.     /* Additional state for P*M devices */
  52.     char magic;            /* n for "Pn" */
  53.     char comment[MAX_COMMENT + 1];    /* comment for head of file */
  54.     byte is_raw;            /* 1 if raw format, 0 if plain */
  55.     byte optimize;            /* 1 if optimization OK, 0 if not */
  56.     byte uses_color;        /* 0 if image is black and white, */
  57.                     /* 1 if gray (PGM or PPM only), */
  58.                     /* 2 or 3 if colored (PPM only) */
  59. };
  60. typedef struct gx_device_pbm_s gx_device_pbm;
  61.  
  62. #define bdev ((gx_device_pbm *)pdev)
  63.  
  64. /* ------ The device descriptors ------ */
  65.  
  66. /*
  67.  * Default X and Y resolution.
  68.  */
  69. #define X_DPI 72
  70. #define Y_DPI 72
  71.  
  72. /* Macro for generating P*M device descriptors. */
  73. #define pbm_prn_device(procs, dev_name, magic, is_raw, num_comp, depth, max_gray, max_rgb, print_page)\
  74. {    prn_device_body(gx_device_pbm, procs, dev_name,\
  75.       DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, X_DPI, Y_DPI,\
  76.       0, 0, 0, 0,\
  77.       num_comp, depth, max_gray, max_rgb, max_gray + 1, max_rgb + 1,\
  78.       print_page),\
  79.     magic,\
  80.      { 0 },\
  81.     is_raw,\
  82.     OPTIMIZE\
  83. }
  84.  
  85. /* For PGM and PPM, we need our own color mapping procedures. */
  86. private dev_proc_map_rgb_color(pgm_map_rgb_color);
  87. private dev_proc_map_rgb_color(ppm_map_rgb_color);
  88. private dev_proc_map_color_rgb(pgm_map_color_rgb);
  89. private dev_proc_map_color_rgb(ppm_map_color_rgb);
  90.  
  91. /* We need to initialize uses_color when opening the device. */
  92. private dev_proc_open_device(ppm_open);
  93.  
  94. /* And of course we need our own print-page routines. */
  95. private dev_proc_print_page(pbm_print_page);
  96. private dev_proc_print_page(pgm_print_page);
  97. private dev_proc_print_page(ppm_print_page);
  98.  
  99. /* The device procedures */
  100. private gx_device_procs pbm_procs =
  101.     prn_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close);
  102. private gx_device_procs pgm_procs =
  103.     prn_color_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
  104.     pgm_map_rgb_color, pgm_map_color_rgb);
  105. private gx_device_procs ppm_procs =
  106.     prn_color_procs(ppm_open, gdev_prn_output_page, gdev_prn_close,
  107.     ppm_map_rgb_color, ppm_map_color_rgb);
  108.  
  109. /* The device descriptors themselves */
  110. gx_device_pbm far_data gs_pbm_device =
  111.   pbm_prn_device(pbm_procs, "pbm", '1', 0, 1, 1, 1, 0,
  112.       pbm_print_page);
  113. gx_device_pbm far_data gs_pbmraw_device =
  114.   pbm_prn_device(pbm_procs, "pbmraw", '4', 1, 1, 1, 1, 1,
  115.       pbm_print_page);
  116. gx_device_pbm far_data gs_pgm_device =
  117.   pbm_prn_device(pgm_procs, "pgm", '2', 0, 1, 8, 255, 0,
  118.       pgm_print_page);
  119. gx_device_pbm far_data gs_pgmraw_device =
  120.   pbm_prn_device(pgm_procs, "pgmraw", '5', 1, 1, 8, 255, 0,
  121.       pgm_print_page);
  122. gx_device_pbm far_data gs_ppm_device =
  123.   pbm_prn_device(ppm_procs, "ppm", '3', 0, 3, 24, 255, 255,
  124.       ppm_print_page);
  125. gx_device_pbm far_data gs_ppmraw_device =
  126.   pbm_prn_device(ppm_procs, "ppmraw", '6', 1, 3, 24, 255, 255,
  127.       ppm_print_page);
  128.  
  129. /* ------ Initialization ------ */
  130.  
  131. private int
  132. ppm_open(gx_device *pdev)
  133. {    bdev->uses_color = 0;
  134.     return gdev_prn_open(pdev);
  135. }
  136.  
  137. /* ------ Color mapping routines ------ */
  138.  
  139. /* Map an RGB color to a PGM gray value. */
  140. /* Keep track of whether the image is black-and-white or gray. */
  141. private gx_color_index
  142. pgm_map_rgb_color(gx_device *pdev, ushort r, ushort g, ushort b)
  143. {    /* We round the value rather than truncating it. */
  144.     gx_color_value gray =
  145.         ((r * (ulong)lum_red_weight) +
  146.          (g * (ulong)lum_green_weight) +
  147.          (b * (ulong)lum_blue_weight) +
  148.          (lum_all_weights / 2)) / lum_all_weights
  149.         * pdev->color_info.max_gray / gx_max_color_value;
  150.     if ( !(gray == 0 || gray == pdev->color_info.max_gray) )
  151.         bdev->uses_color = 1;
  152.     return gray;
  153. }
  154.  
  155. /* Map a PGM gray value back to an RGB color. */
  156. private int
  157. pgm_map_color_rgb(gx_device *dev, gx_color_index color, ushort prgb[3])
  158. {    gx_color_value gray =
  159.         color * gx_max_color_value / dev->color_info.max_gray;
  160.     prgb[0] = gray;
  161.     prgb[1] = gray;
  162.     prgb[2] = gray;
  163.     return 0;
  164. }
  165.  
  166. /* Map an RGB color to a PPM color tuple. */
  167. /* Keep track of whether the image is black-and-white, gray, or colored. */
  168. private gx_color_index
  169. ppm_map_rgb_color(gx_device *pdev, ushort r, ushort g, ushort b)
  170. {    ushort bitspercolor = pdev->color_info.depth / 3;
  171.     ulong max_value = (1 << bitspercolor) - 1;
  172.     gx_color_value rc = r * max_value / gx_max_color_value;
  173.     gx_color_value gc = g * max_value / gx_max_color_value;
  174.     gx_color_value bc = b * max_value / gx_max_color_value;
  175.     if ( rc == gc && gc == bc )        /* black-and-white or gray */
  176.     {    if ( !(rc == 0 || rc == max_value) )
  177.             bdev->uses_color |= 1;        /* gray */
  178.     }
  179.     else                        /* color */
  180.         bdev->uses_color = 2;
  181.     return ((((ulong)rc << bitspercolor) + gc) << bitspercolor) + bc;
  182. }
  183.  
  184. /* Map a PPM color tuple back to an RGB color. */
  185. private int
  186. ppm_map_color_rgb(gx_device *dev, gx_color_index color, ushort prgb[3])
  187. {    ushort bitspercolor = dev->color_info.depth / 3;
  188.     ushort colormask = (1 << bitspercolor) - 1;
  189.  
  190.     prgb[0] = ((color >> (bitspercolor * 2)) & colormask) *
  191.         (ulong)gx_max_color_value / colormask;
  192.     prgb[1] = ((color >> bitspercolor) & colormask) *
  193.         (ulong)gx_max_color_value / colormask;
  194.     prgb[2] = (color & colormask) *
  195.         (ulong)gx_max_color_value / colormask;
  196.     return 0;
  197. }
  198.  
  199. /* ------ Internal routines ------ */
  200.  
  201. /* Print a page using a given row printing routine. */
  202. private int
  203. pbm_print_page_loop(gx_device_printer *pdev, char magic, FILE *pstream,
  204.   int (*row_proc)(P4(gx_device_printer *, byte *, int, FILE *)))
  205. {    uint raster = gdev_prn_raster(pdev);
  206.     byte *data = (byte *)gs_malloc(raster, 1, "pbm_begin_page");
  207.     int lnum = 0;
  208.     int code = 0;
  209.     if ( data == 0 )
  210.         return_error(gs_error_VMerror);
  211.     fprintf(pstream, "P%c\n", magic);
  212.     if ( bdev->comment[0] )
  213.         fprintf(pstream, "# %s\n", bdev->comment);
  214.     else
  215.         fprintf(pstream, "# Image generated by Ghostscript (device=%s)\n",
  216.             pdev->dname);
  217.     fprintf(pstream, "%d %d\n", pdev->width, pdev->height);
  218.     switch ( magic )
  219.     {
  220.     case '1':        /* pbm */
  221.     case '4':        /* pbmraw */
  222.         break;
  223.     default:
  224.         fprintf(pstream, "%d\n", pdev->color_info.max_gray);
  225.     }
  226.     for ( ; lnum < pdev->height; lnum++ )
  227.     {    gdev_prn_copy_scan_lines(pdev, lnum, data, raster);
  228.         code = (*row_proc)(pdev, data, pdev->color_info.depth, pstream);
  229.         if ( code < 0 ) break;
  230.     }
  231.     gs_free((char *)data, raster, 1, "pbm_print_page_loop");
  232.     return (code < 0 ? code : 0);
  233. }
  234.  
  235. /* ------ Individual page printing routines ------ */
  236.  
  237. /* Print a monobit page. */
  238. private int
  239. pbm_print_row(gx_device_printer *pdev, byte *data, int depth,
  240.   FILE *pstream)
  241. {    if ( bdev->is_raw )
  242.         fwrite(data, 1, (pdev->width + 7) >> 3, pstream);
  243.     else
  244.     {    byte *bp;
  245.         uint x, mask;
  246.         for ( bp = data, x = 0, mask = 0x80;
  247.               x < pdev->width;
  248.               (mask >>= 1) != 0 || (bp++, mask = 0x80)
  249.             )
  250.         {    putc((*bp & mask ? '1' : '0'), pstream);
  251.             if ( ++x == pdev->width || !(x & 63) )
  252.                 putc('\n', pstream);
  253.         }
  254.     }
  255.     return 0;
  256. }
  257. private int
  258. pbm_print_page(gx_device_printer *pdev, FILE *pstream)
  259. {    return pbm_print_page_loop(pdev, bdev->magic, pstream, pbm_print_row);
  260. }
  261.  
  262. /* Print a gray-mapped page. */
  263. private int
  264. pgm_print_row(gx_device_printer *pdev, byte *data, int depth,
  265.   FILE *pstream)
  266. {    /* Note that bpp <= 8 for raw format, bpp <= 16 for plain. */
  267.     uint mask = (1 << depth) - 1;
  268.     byte *bp;
  269.     uint x;
  270.     int shift;
  271.     for ( bp = data, x = 0, shift = 8 - depth;
  272.           x < pdev->width;
  273.         )
  274.     {    uint pixel;
  275.         if ( shift < 0 )    /* bpp = 16 */
  276.            {    pixel = ((uint)*bp << 8) + bp[1];
  277.             bp += 2;
  278.            }
  279.         else
  280.            {    pixel = (*bp >> shift) & mask;
  281.             if ( (shift -= depth) < 0 )
  282.                 bp++, shift += 8;
  283.            }
  284.         ++x;
  285.         if ( bdev->is_raw )
  286.             putc(pixel, pstream);
  287.         else
  288.             fprintf(pstream, "%d%c", pixel,
  289.                 (x == pdev->width || !(x & 15) ?
  290.                  '\n' : ' '));
  291.     }
  292.     return 0;
  293. }
  294. private int
  295. pxm_pbm_print_row(gx_device_printer *pdev, byte *data, int depth,
  296.   FILE *pstream)
  297. {    /* Compress a PGM or PPM row to a PBM row. */
  298.     /* This doesn't have to be very fast. */
  299.     /* Note that we have to invert the data as well. */
  300.     int delta = (depth + 7) >> 3;
  301.     byte *src = data + delta - 1;        /* always big-endian */
  302.     byte *dest = data;
  303.     int x;
  304.     byte in_mask = (depth >= 8 ? 1 : 0x100 >> depth);
  305.     byte out_mask = 0x80;
  306.     byte out = 0;
  307.     for ( x = 0; x < pdev->width; x++ )
  308.     {    if ( !(*src & in_mask) )
  309.             out |= out_mask;
  310.         if ( depth >= 8 )
  311.             src += delta;
  312.         else
  313.         {    in_mask >>= depth;
  314.             if ( !in_mask )
  315.                 in_mask = 0x100 >> depth,
  316.                 src++;
  317.         }
  318.         out_mask >>= 1;
  319.         if ( !out_mask )
  320.             out_mask = 0x80,
  321.             *dest++ = out,
  322.             out = 0;
  323.     }
  324.     if ( out_mask != 0x80 )
  325.         *dest = out;
  326.     return pbm_print_row(pdev, data, 1, pstream);
  327. }
  328. private int
  329. pgm_print_page(gx_device_printer *pdev, FILE *pstream)
  330. {    return (bdev->uses_color == 0 && bdev->optimize ?
  331.         pbm_print_page_loop(pdev, bdev->magic - 1, pstream,
  332.                     pxm_pbm_print_row) :
  333.         pbm_print_page_loop(pdev, bdev->magic, pstream,
  334.                     pgm_print_row) );
  335. }
  336.  
  337. /* Print a color-mapped page. */
  338. private int
  339. ppgm_print_row(gx_device_printer *pdev, byte *data, int depth,
  340.   FILE *pstream, int color)
  341. {    /* If color=0, write only one value per pixel; */
  342.     /* if color=1, write 3 values per pixel. */
  343.     /* Note that depth <= 24 for raw format, depth <= 32 for plain. */
  344.     uint bpe = depth / 3;    /* bits per r/g/b element */
  345.     uint mask = (1 << bpe) - 1;
  346.     byte *bp;
  347.     uint x;
  348.     uint eol_mask = (color ? 7 : 15);
  349.     int shift;
  350.     for ( bp = data, x = 0, shift = 8 - depth;
  351.           x < pdev->width;
  352.         )
  353.     {    ulong pixel = 0;
  354.         uint r, g, b;
  355.         switch ( depth >> 3 )
  356.            {
  357.         case 4:
  358.             pixel = (ulong)*bp << 24; bp++;
  359.             /* falls through */
  360.         case 3:
  361.             pixel += (ulong)*bp << 16; bp++;
  362.             /* falls through */
  363.         case 2:
  364.             pixel += (uint)*bp << 8; bp++;
  365.             /* falls through */
  366.         case 1:
  367.             pixel += *bp; bp++;
  368.             break;
  369.         case 0:            /* bpp == 4, bpe == 1 */
  370.             pixel = *bp >> shift;
  371.             if ( (shift -= depth) < 0 )
  372.                 bp++, shift += 8;
  373.             break;
  374.            }
  375.         ++x;
  376.         b = pixel & mask;  pixel >>= bpe;
  377.         g = pixel & mask;  pixel >>= bpe;
  378.         r = pixel & mask;
  379.         if ( bdev->is_raw )
  380.         {    if ( color )
  381.             {    putc(r, pstream);
  382.                 putc(g, pstream);
  383.             }
  384.             putc(b, pstream);
  385.         }
  386.         else
  387.         {    if ( color )
  388.                 fprintf(pstream, "%d %d ", r, g);
  389.             fprintf(pstream, "%d%c", b,
  390.                 (x == pdev->width || !(x & eol_mask) ?
  391.                  '\n' : ' '));
  392.         }
  393.     }
  394.     return 0;
  395. }
  396. private int
  397. ppm_print_row(gx_device_printer *pdev, byte *data, int depth,
  398.   FILE *pstream)
  399. {    return ppgm_print_row(pdev, data, depth, pstream, 1);
  400. }
  401. private int
  402. ppm_pgm_print_row(gx_device_printer *pdev, byte *data, int depth,
  403.   FILE *pstream)
  404. {    return ppgm_print_row(pdev, data, depth, pstream, 0);
  405. }
  406. private int
  407. ppm_print_page(gx_device_printer *pdev, FILE *pstream)
  408. {    return (bdev->uses_color >= 2 || !bdev->optimize ?
  409.         pbm_print_page_loop(pdev, bdev->magic, pstream,
  410.                     ppm_print_row) :
  411.         bdev->uses_color == 1 ?
  412.         pbm_print_page_loop(pdev, bdev->magic - 1, pstream,
  413.                     ppm_pgm_print_row) :
  414.         pbm_print_page_loop(pdev, bdev->magic - 2, pstream,
  415.                     pxm_pbm_print_row) );
  416. }
  417.