home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gdevjpeg.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  8.4 KB  |  285 lines
  1. /* Copyright (C) 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gdevjpeg.c,v 1.2 2000/09/19 19:00:13 lpd Exp $ */
  20. /* JPEG output driver */
  21. #include "stdio_.h"        /* for jpeglib.h */
  22. #include "jpeglib_.h"
  23. #include "gdevprn.h"
  24. #include "stream.h"
  25. #include "strimpl.h"
  26. #include "sdct.h"
  27. #include "sjpeg.h"
  28.  
  29. /* Structure for the JPEG-writing device. */
  30. typedef struct gx_device_jpeg_s {
  31.     gx_device_common;
  32.     gx_prn_device_common;
  33.     /* Additional parameters */
  34.     int JPEGQ;            /* quality on IJG scale */
  35.     float QFactor;        /* quality per DCTEncode conventions */
  36.     /* JPEGQ overrides QFactor if both are specified. */
  37. } gx_device_jpeg;
  38.  
  39. /* The device descriptor */
  40. private dev_proc_get_params(jpeg_get_params);
  41. private dev_proc_put_params(jpeg_put_params);
  42. private dev_proc_print_page(jpeg_print_page);
  43.  
  44. /* ------ The device descriptors ------ */
  45.  
  46. /* Default X and Y resolution. */
  47. #ifndef X_DPI
  48. #  define X_DPI 72
  49. #endif
  50. #ifndef Y_DPI
  51. #  define Y_DPI 72
  52. #endif
  53.  
  54. /* 24-bit color */
  55.  
  56. private const gx_device_procs jpeg_procs =
  57. prn_color_params_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
  58.                gx_default_rgb_map_rgb_color,
  59.                gx_default_rgb_map_color_rgb,
  60.                jpeg_get_params, jpeg_put_params);
  61.  
  62. const gx_device_jpeg gs_jpeg_device =
  63. {prn_device_std_body(gx_device_jpeg, jpeg_procs, "jpeg",
  64.              DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  65.              X_DPI, Y_DPI, 0, 0, 0, 0, 24, jpeg_print_page),
  66.  0,                /* JPEGQ: 0 indicates not specified */
  67.  0.0                /* QFactor: 0 indicates not specified */
  68. };
  69.  
  70. /* 8-bit gray */
  71.  
  72. private const gx_device_procs jpeggray_procs =
  73. prn_color_params_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
  74.                gx_default_gray_map_rgb_color,
  75.                gx_default_gray_map_color_rgb,
  76.                jpeg_get_params, jpeg_put_params);
  77.  
  78. const gx_device_jpeg gs_jpeggray_device =
  79. {prn_device_body(gx_device_jpeg, jpeggray_procs, "jpeggray",
  80.          DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  81.          X_DPI, Y_DPI, 0, 0, 0, 0,
  82.          1, 8, 255, 0, 256, 0,
  83.          jpeg_print_page),
  84.  0,                /* JPEGQ: 0 indicates not specified */
  85.  0.0                /* QFactor: 0 indicates not specified */
  86. };
  87.  
  88. /* Get parameters. */
  89. private int
  90. jpeg_get_params(gx_device * dev, gs_param_list * plist)
  91. {
  92.     gx_device_jpeg *jdev = (gx_device_jpeg *) dev;
  93.     int code = gdev_prn_get_params(dev, plist);
  94.     int ecode;
  95.  
  96.     if (code < 0)
  97.     return code;
  98.  
  99.     if ((ecode = param_write_int(plist, "JPEGQ", &jdev->JPEGQ)) < 0)
  100.     code = ecode;
  101.     if ((ecode = param_write_float(plist, "QFactor", &jdev->QFactor)) < 0)
  102.     code = ecode;
  103.  
  104.     return code;
  105. }
  106.  
  107. /* Put parameters. */
  108. private int
  109. jpeg_put_params(gx_device * dev, gs_param_list * plist)
  110. {
  111.     gx_device_jpeg *jdev = (gx_device_jpeg *) dev;
  112.     int ecode = 0;
  113.     int code;
  114.     gs_param_name param_name;
  115.     int jq = jdev->JPEGQ;
  116.     float qf = jdev->QFactor;
  117.  
  118.     switch (code = param_read_int(plist, (param_name = "JPEGQ"), &jq)) {
  119.     case 0:
  120.         if (jq < 0 || jq > 100)
  121.         ecode = gs_error_limitcheck;
  122.         else
  123.         break;
  124.         goto jqe;
  125.     default:
  126.         ecode = code;
  127.       jqe:param_signal_error(plist, param_name, ecode);
  128.     case 1:
  129.         break;
  130.     }
  131.  
  132.     switch (code = param_read_float(plist, (param_name = "QFactor"), &qf)) {
  133.     case 0:
  134.         if (qf < 0.0 || qf > 1.0e6)
  135.         ecode = gs_error_limitcheck;
  136.         else
  137.         break;
  138.         goto qfe;
  139.     default:
  140.         ecode = code;
  141.       qfe:param_signal_error(plist, param_name, ecode);
  142.     case 1:
  143.         break;
  144.     }
  145.  
  146.     if (ecode < 0)
  147.     return ecode;
  148.     code = gdev_prn_put_params(dev, plist);
  149.     if (code < 0)
  150.     return code;
  151.  
  152.     jdev->JPEGQ = jq;
  153.     jdev->QFactor = qf;
  154.     return 0;
  155. }
  156.  
  157. /* Send the page to the file. */
  158. private int
  159. jpeg_print_page(gx_device_printer * pdev, FILE * prn_stream)
  160. {
  161.     gx_device_jpeg *jdev = (gx_device_jpeg *) pdev;
  162.     gs_memory_t *mem = pdev->memory;
  163.     int line_size = gdev_mem_bytes_per_scan_line((gx_device *) pdev);
  164.     byte *in = gs_alloc_bytes(mem, line_size, "jpeg_print_page(in)");
  165.     jpeg_compress_data *jcdp = (jpeg_compress_data *)
  166.     gs_alloc_bytes(mem, sizeof(*jcdp),
  167.            "jpeg_print_page(jpeg_compress_data)");
  168.     byte *fbuf = 0;
  169.     uint fbuf_size;
  170.     byte *jbuf = 0;
  171.     uint jbuf_size;
  172.     int lnum;
  173.     int code;
  174.     stream_DCT_state state;
  175.     stream fstrm, jstrm;
  176.  
  177.     if (jcdp == 0 || in == 0) {
  178.     code = gs_note_error(gs_error_VMerror);
  179.     goto fail;
  180.     }
  181.     /* Create the DCT decoder state. */
  182.     jcdp->template = s_DCTE_template;
  183.     state.template = &jcdp->template;
  184.     state.memory = 0;
  185.     if (state.template->set_defaults)
  186.     (*state.template->set_defaults) ((stream_state *) & state);
  187.     state.QFactor = 1.0;    /* disable quality adjustment in zfdcte.c */
  188.     state.ColorTransform = 1;    /* default for RGB */
  189.     /* We insert no markers, allowing the IJG library to emit */
  190.     /* the format it thinks best. */
  191.     state.NoMarker = true;    /* do not insert our own Adobe marker */
  192.     state.Markers.data = 0;
  193.     state.Markers.size = 0;
  194.     state.data.compress = jcdp;
  195.     jcdp->memory = state.jpeg_memory = mem;
  196.     if ((code = gs_jpeg_create_compress(&state)) < 0)
  197.     goto fail;
  198.     jcdp->cinfo.image_width = pdev->width;
  199.     jcdp->cinfo.image_height = pdev->height;
  200.     switch (pdev->color_info.depth) {
  201.     case 24:
  202.         jcdp->cinfo.input_components = 3;
  203.         jcdp->cinfo.in_color_space = JCS_RGB;
  204.         break;
  205.     case 8:
  206.         jcdp->cinfo.input_components = 1;
  207.         jcdp->cinfo.in_color_space = JCS_GRAYSCALE;
  208.         break;
  209.     }
  210.     /* Set compression parameters. */
  211.     if ((code = gs_jpeg_set_defaults(&state)) < 0)
  212.     goto done;
  213.     if (jdev->JPEGQ > 0) {
  214.     code = gs_jpeg_set_quality(&state, jdev->JPEGQ, TRUE);
  215.     if (code < 0)
  216.         goto done;
  217.     } else if (jdev->QFactor > 0.0) {
  218.     code = gs_jpeg_set_linear_quality(&state,
  219.                       (int)(min(jdev->QFactor, 100.0)
  220.                         * 100.0 + 0.5),
  221.                       TRUE);
  222.     if (code < 0)
  223.         goto done;
  224.     }
  225.     jcdp->cinfo.restart_interval = 0;
  226.     jcdp->cinfo.density_unit = 1;    /* dots/inch (no #define or enum) */
  227.     jcdp->cinfo.X_density = pdev->HWResolution[0];
  228.     jcdp->cinfo.Y_density = pdev->HWResolution[1];
  229.     /* Create the filter. */
  230.     /* Make sure we get at least a full scan line of input. */
  231.     state.scan_line_size = jcdp->cinfo.input_components *
  232.     jcdp->cinfo.image_width;
  233.     jcdp->template.min_in_size =
  234.     max(s_DCTE_template.min_in_size, state.scan_line_size);
  235.     /* Make sure we can write the user markers in a single go. */
  236.     jcdp->template.min_out_size =
  237.     max(s_DCTE_template.min_out_size, state.Markers.size);
  238.  
  239.     /* Set up the streams. */
  240.     fbuf_size = max(512 /* arbitrary */ , jcdp->template.min_out_size);
  241.     jbuf_size = jcdp->template.min_in_size;
  242.     if ((fbuf = gs_alloc_bytes(mem, fbuf_size, "jpeg_print_page(fbuf)")) == 0 ||
  243.     (jbuf = gs_alloc_bytes(mem, jbuf_size, "jpeg_print_page(jbuf)")) == 0
  244.     ) {
  245.     code = gs_note_error(gs_error_VMerror);
  246.     goto done;
  247.     }
  248.     swrite_file(&fstrm, prn_stream, fbuf, fbuf_size);
  249.     s_std_init(&jstrm, jbuf, jbuf_size, &s_filter_write_procs,
  250.            s_mode_write);
  251.     jstrm.memory = mem;
  252.     jstrm.state = (stream_state *) & state;
  253.     jstrm.procs.process = state.template->process;
  254.     jstrm.strm = &fstrm;
  255.     if (state.template->init)
  256.     (*state.template->init) (jstrm.state);
  257.  
  258.     /* Copy the data to the output. */
  259.     for (lnum = 0; lnum < pdev->height; ++lnum) {
  260.     byte *data;
  261.     uint ignore_used;
  262.  
  263.     gdev_prn_get_bits(pdev, lnum, in, &data);
  264.     sputs(&jstrm, data, state.scan_line_size, &ignore_used);
  265.     }
  266.  
  267.     /* Wrap up. */
  268.     sclose(&jstrm);
  269.     sflush(&fstrm);
  270.     jcdp = 0;
  271.   done:
  272.     gs_free_object(mem, jbuf, "jpeg_print_page(jbuf)");
  273.     gs_free_object(mem, fbuf, "jpeg_print_page(fbuf)");
  274.     if (jcdp)
  275.     gs_jpeg_destroy(&state);    /* frees *jcdp */
  276.     gs_free_object(mem, in, "jpeg_print_page(in)");
  277.     return code;
  278.   fail:
  279.     if (jcdp)
  280.     gs_free_object(mem, jcdp, "jpeg_print_page(jpeg_compress_data)");
  281.     gs_free_object(mem, in, "jpeg_print_page(in)");
  282.     return code;
  283. #undef jcdp
  284. }
  285.