home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / UsingPDF / GhostScript / source / gs5.10 / gdevpdfi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-31  |  30.7 KB  |  1,024 lines
  1. /* Copyright (C) 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevpdfi.c */
  20. /* Image handling for PDF-writing driver */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gsflip.h"
  26. #include "gdevpdfx.h"
  27. #include "gxcspace.h"
  28. #include "gscolor2.h"        /* for gscie.h */
  29. #include "gscie.h"        /* requires gscspace.h */
  30. #include "gxistate.h"
  31. #include "strimpl.h"
  32. #include "sa85x.h"
  33. #include "scfx.h"
  34. #include "srlx.h"
  35.  
  36. /* We need color space types for constructing temporary color spaces. */
  37. extern const gs_color_space_type
  38.   gs_color_space_type_DeviceGray,
  39.   gs_color_space_type_DeviceRGB,
  40.   gs_color_space_type_DeviceCMYK,
  41.   gs_color_space_type_Indexed;
  42.  
  43. /* ---------------- Utilities ---------------- */
  44.  
  45. /* ------ Binary data ------ */
  46.  
  47. /* Define the structure for the filters for writing binary data. */
  48. typedef struct pdf_binary_writer_s {
  49.     stream *strm;
  50.     stream es;        /* no state for A85E */
  51.     byte encode_buf[256];
  52.     stream cs;        /* client provides (initialized) state */
  53.     byte compress_buf[256];
  54. } pdf_binary_writer;
  55.  
  56. private const stream_procs filter_write_procs =
  57. {    s_std_noavailable, s_std_noseek, s_std_write_reset,
  58.     s_std_write_flush, s_filter_close
  59. };
  60.  
  61. /* Begin writing binary data. */
  62. /* If css is not NULL, it is the compressor stream state. */
  63. private int
  64. pdf_begin_binary(gx_device_pdf *pdev, pdf_binary_writer *pbw,
  65.   stream_state *css)
  66. {    stream *s = pdev->strm;
  67.  
  68.     /* If not binary, set up the encoding stream. */
  69.     if ( !pdev->binary_ok )
  70.       { stream *es = &pbw->es;
  71.         s_std_init(es, pbw->encode_buf, sizeof(pbw->encode_buf),
  72.                &filter_write_procs, s_mode_write);
  73.         es->template = &s_A85E_template;
  74.         es->procs.process = es->template->process;
  75.         es->strm = s;
  76.         s = es;
  77.       }
  78.     /* If compressing, set up the compression stream. */
  79.     if ( css )
  80.       { stream *cs = (stream *)&pbw->cs;
  81.         const stream_template *template = css->template;
  82.         s_std_init(cs, pbw->compress_buf, sizeof(pbw->compress_buf),
  83.                &filter_write_procs, s_mode_write);
  84.         css->memory = pdev->pdf_memory;
  85.         cs->state = css;
  86.         cs->procs.process = template->process;
  87.         if ( template->init )
  88.           (*template->init)(css);
  89.         cs->strm = s;
  90.         s = cs;
  91.       }
  92.     pbw->strm = s;
  93.     return 0;
  94. }
  95.  
  96. /* Finish writing binary data. */
  97. private int
  98. pdf_end_binary(gx_device_pdf *pdev, pdf_binary_writer *pbw)
  99. {    stream *s = pbw->strm;
  100.  
  101.     /* Close the filters in reverse order. */
  102.     /* Stop before we try to close the file stream. */
  103.     while ( s != pdev->strm )
  104.       { stream *next = s->strm;
  105.         /* We have to open-code sclose, because we want to release */
  106.         /* the stream state but not try to free it. */
  107.         stream_state *st = s->state;
  108.         stream_proc_release((*release)) = st->template->release;
  109.         (*s->procs.close)(s);
  110.         if ( release != 0 )
  111.           (*release)(st);
  112.         s = next;
  113.       }
  114.     sflush(s);    /* flush the file stream buffer */
  115.     return 0;
  116. }
  117.  
  118. /* ------ Images ------ */
  119.  
  120. /* Test whether a cached CIE procedure is the identity function. */
  121. #define cie_cache_is_identity(pc)\
  122.   ((pc)->floats.params.is_identity)
  123. #define cie_cache3_is_identity(pca)\
  124.   (cie_cache_is_identity(&(pca)[0]) &&\
  125.    cie_cache_is_identity(&(pca)[1]) &&\
  126.    cie_cache_is_identity(&(pca)[2]))
  127.  
  128. /*
  129.  * Test whether a cached CIE procedure is an exponential.  A cached
  130.  * procedure is exponential iff f(x) = k*(x^p).  We make a very cursory
  131.  * check for this: we require that f(0) = 0, set k = f(1), set p =
  132.  * log[a](f(a)/k), and then require that f(b) = k*(b^p), where a and b are
  133.  * two arbitrarily chosen values between 0 and 1.  Naturally all this is
  134.  * done with some slop.
  135.  */
  136. #define ia (gx_cie_cache_size / 3)
  137. #define ib (gx_cie_cache_size * 2 / 3)
  138. #define iv(i) ((i) / (double)(gx_cie_cache_size - 1))
  139. #define a iv(ia)
  140. #define b iv(ib)
  141.  
  142. private bool
  143. cie_values_are_exponential(floatp va, floatp vb, floatp k,
  144.   float *pexpt)
  145. {    double p;
  146.  
  147.     if ( fabs(k) < 0.001 )
  148.       return false;
  149.     if ( va == 0 || (va > 0) != (k > 0) )
  150.       return false;
  151.     p = log(va / k) / log(a);
  152.     if ( fabs(vb - k * pow(b, p)) >= 0.001 )
  153.       return false;
  154.     *pexpt = p;
  155.     return true;
  156. }
  157.  
  158. private bool
  159. cie_scalar_cache_is_exponential(const gx_cie_scalar_cache *pc, float *pexpt)
  160. {    double k, va, vb;
  161.  
  162.     if ( fabs(pc->floats.values[0]) >= 0.001 )
  163.       return false;
  164.     k = pc->floats.values[gx_cie_cache_size - 1];
  165.     va = pc->floats.values[ia];
  166.     vb = pc->floats.values[ib];
  167.     return cie_values_are_exponential(va, vb, k, pexpt);
  168. }
  169. #define cie_scalar3_cache_is_exponential(pca, expts)\
  170.   (cie_scalar_cache_is_exponential(&(pca)[0], &(expts)[0]) &&\
  171.    cie_scalar_cache_is_exponential(&(pca)[1], &(expts)[1]) &&\
  172.    cie_scalar_cache_is_exponential(&(pca)[2], &(expts)[2]))
  173.  
  174. private bool
  175. cie_vector_cache_is_exponential(const gx_cie_vector_cache *pc, float *pexpt)
  176. {    double k, va, vb;
  177.  
  178.     if ( fabs(pc->vecs.values[0].u) >= 0.001 )
  179.       return false;
  180.     k = pc->vecs.values[gx_cie_cache_size - 1].u;
  181.     va = pc->vecs.values[ia].u;
  182.     vb = pc->vecs.values[ib].u;
  183.     return cie_values_are_exponential(va, vb, k, pexpt);
  184. }
  185. #define cie_vector3_cache_is_exponential(pca, expts)\
  186.   (cie_vector_cache_is_exponential(&(pca)[0], &(expts)[0]) &&\
  187.    cie_vector_cache_is_exponential(&(pca)[1], &(expts)[1]) &&\
  188.    cie_vector_cache_is_exponential(&(pca)[2], &(expts)[2]))
  189.  
  190. #undef ia
  191. #undef ib
  192. #undef iv
  193. #undef a
  194. #undef b
  195.  
  196. /* Define the long and short versions of the keys in an image dictionary, */
  197. /* and other strings for images. */
  198. typedef struct pdf_image_names_s {
  199.   const char *ASCII85Decode;
  200.   const char *BitsPerComponent;
  201.   const char *CalCMYK;
  202.   const char *CalGray;
  203.   const char *CalRGB;
  204.   const char *CCITTFaxDecode;
  205.   const char *ColorSpace;
  206.   const char *Decode;
  207.   const char *DecodeParms;
  208.   const char *DeviceCMYK;
  209.   const char *DeviceGray;
  210.   const char *DeviceRGB;
  211.   const char *Filter;
  212.   const char *Height;
  213.   const char *ImageMask;
  214.   const char *Indexed;
  215.   const char *Interpolate;
  216.   const char *Width;
  217. } pdf_image_names;
  218. private const pdf_image_names image_names_full = {
  219.   "/ASCII85Decode", "/BitsPerComponent",
  220.   "/CalCMYK", "/CalGray", "/CalRGB", "/CCITTFaxDecode", "/ColorSpace",
  221.   "/Decode", "/DecodeParms", "/DeviceCMYK", "/DeviceGray", "/DeviceRGB",
  222.   "/Filter", "/Height", "/ImageMask", "/Indexed", "/Interpolate", "/Width",
  223. };
  224. private const pdf_image_names image_names_short = {
  225.   "/A85", "/BPC",
  226.     /* We need CalRGB to work around a bug in some Adobe products. */
  227.   "/CC", "/CG", /*"/CR"*/ "/CalRGB", "/CCF", "/CS",
  228.   "/D", "/DP", "/CMYK", "/G", "/RGB",
  229.   "/F", "/H", "/IM", "/I", "/I", "/W",
  230. };
  231.  
  232. /* Write out image parameters for either an in-line image or image resource. */
  233. /* decode_parms, if supplied, must start with /, [, or <<. */
  234. private int
  235. pdf_write_image_params(gx_device_pdf *pdev, const gs_image_t *pim,
  236.   const char *filter_name, const char *decode_parms,
  237.   const pdf_image_names *pin)
  238. {    stream *s = pdev->strm;
  239.     const gs_color_space *pcs = pim->ColorSpace;
  240.     const char *cs_name;
  241.     int num_components;
  242.     float indexed_decode[2];
  243.     const float *default_decode = NULL;
  244.     
  245.     if ( pim->ImageMask )
  246.       { pprints1(s, "%s true", pin->ImageMask);
  247.         pdev->procsets |= ImageB;
  248.         num_components = 1;
  249.       }
  250.     else
  251.       { const gs_color_space *pbcs = pcs;
  252.         const gs_indexed_params *pip = 0;
  253.         const gs_cie_common *pciec;
  254.  
  255.         pputs(s, pin->ColorSpace);
  256. csw:        switch ( gs_color_space_get_index(pbcs) )
  257.           {
  258.           case gs_color_space_index_DeviceGray:
  259.         pdev->procsets |= ImageB;
  260.         cs_name = pin->DeviceGray;
  261.         break;
  262.           case gs_color_space_index_DeviceRGB:
  263.         pdev->procsets |= ImageC;
  264.         cs_name = pin->DeviceRGB;
  265.         break;
  266.           case gs_color_space_index_DeviceCMYK:
  267.         pdev->procsets |= ImageC;
  268.         cs_name = pin->DeviceCMYK;
  269.         break;
  270.           case gs_color_space_index_CIEA:
  271.         pdev->procsets |= ImageB;
  272.         pprints1(s, "[%s<<", pin->CalGray);
  273.         { const gs_cie_a *pcie = pbcs->params.a;
  274.           float expts[3];
  275.  
  276.           if ( cie_cache3_is_identity(pcie->common.caches.DecodeLMN) )
  277.             cie_vector_cache_is_exponential(&pcie->caches.DecodeA, &expts[0]);
  278.           else
  279.             discard(cie_scalar3_cache_is_exponential(pcie->common.caches.DecodeLMN, expts));
  280.           if ( expts[0] != 1 )
  281.             pprintg1(s, "/Gamma %g", expts[0]);
  282.           pciec = (const gs_cie_common *)pcie;
  283.         }
  284. cal:        pprintg3(s, "/WhitePoint[%g %g %g]",
  285.              pciec->points.WhitePoint.u,
  286.              pciec->points.WhitePoint.v,
  287.              pciec->points.WhitePoint.w);
  288.             if ( pciec->points.BlackPoint.u != 0 ||
  289.              pciec->points.BlackPoint.v != 0 ||
  290.              pciec->points.BlackPoint.w != 0
  291.            )
  292.           pprintg3(s, "/BlackPoint[%g %g %g]",
  293.                pciec->points.BlackPoint.u,
  294.                pciec->points.BlackPoint.v,
  295.                pciec->points.BlackPoint.w);
  296.             pputs(s, ">>]");
  297.         cs_name = 0;
  298.         break;
  299.           case gs_color_space_index_CIEABC:
  300.         pdev->procsets |= ImageC;
  301.         pprints1(s, "[%s<<", pin->CalRGB);
  302.         { const gs_cie_abc *pcie = pbcs->params.abc;
  303.           const gs_matrix3 *pmat;
  304.           float expts[3];
  305.  
  306.           if ( pcie->common.MatrixLMN.is_identity &&
  307.                cie_cache3_is_identity(pcie->common.caches.DecodeLMN)
  308.              ) {
  309.             discard(cie_vector3_cache_is_exponential(pcie->caches.DecodeABC, expts));
  310.             pmat = &pcie->MatrixABC;
  311.           } else {
  312.             discard(cie_scalar3_cache_is_exponential(pcie->common.caches.DecodeLMN, expts));
  313.             pmat = &pcie->common.MatrixLMN;
  314.           }
  315.           if ( expts[0] != 1 || expts[1] != 1 || expts[2] != 1 )
  316.             pprintg3(s, "/Gamma[%g %g %g]", expts[0], expts[1],
  317.                  expts[2]);
  318.           if ( !pmat->is_identity ) {
  319.             pprintg3(s, "/Matrix[%g %g %g",
  320.                  pmat->cu.u, pmat->cu.v, pmat->cu.w);
  321.             pprintg6(s, " %g %g %g %g %g %g]",
  322.                  pmat->cv.u, pmat->cv.v, pmat->cv.w,
  323.                  pmat->cw.u, pmat->cw.v, pmat->cw.w);
  324.           }
  325.           pciec = (const gs_cie_common *)pcie;
  326.         }
  327.         goto cal;
  328.           case gs_color_space_index_Indexed:
  329.         pdev->procsets |= ImageI;
  330.         pprints1(s, "[%s", pin->Indexed);
  331.         pip = &pcs->params.indexed;
  332.         pbcs = (const gs_color_space *)&pip->base_space;
  333.         indexed_decode[0] = 0;
  334.         indexed_decode[1] = (1 << pim->BitsPerComponent) - 1;
  335.         default_decode = indexed_decode;
  336.         goto csw;
  337.           default:        /* shouldn't happen */
  338.         return_error(gs_error_rangecheck);
  339.           }
  340.         if ( cs_name )
  341.           pprints1(s, " %s", cs_name);
  342.         num_components = gs_color_space_num_components(pbcs);
  343.         if ( pip )
  344.           { register const char _ds *hex_digits = "0123456789abcdef";
  345.         int i;
  346.  
  347.         pprintd1(s, " %d\n<", pip->hival);
  348.         for ( i = 0; i < (pip->hival + 1) * num_components; ++i )
  349.           { byte b = pip->lookup.table.data[i];
  350.             pputc(s, hex_digits[b >> 4]);
  351.             pputc(s, hex_digits[b & 0xf]);
  352.           }
  353.         pputs(s, ">\n]");
  354.         num_components = 1;
  355.           }
  356.       }
  357. /* Some compilers try to substitute macro args in string literals! */
  358. #define pprintsd(strm, str, v)\
  359.   (pputs(strm, str), pprintd1(strm, " %d", v))
  360.     pprintsd(s, pin->Width, pim->Width);
  361.     pprintsd(s, pin->Height, pim->Height);
  362.     pprintsd(s, pin->BitsPerComponent, pim->BitsPerComponent);
  363. #undef pprintsd
  364.     { int i;
  365.       for ( i = 0; i < num_components * 2; ++i )
  366.         if ( pim->Decode[i] !=
  367.          (default_decode ? default_decode[i] : i & 1)
  368.            )
  369.           break;
  370.       if ( i < num_components * 2 )
  371.         { char sepr = '[';
  372.           pputs(s, pin->Decode);
  373.           for ( i = 0; i < num_components * 2; sepr = ' ', ++i )
  374.         { pputc(s, sepr);
  375.           pprintg1(s, "%g", pim->Decode[i]);
  376.         }
  377.           pputc(s, ']');
  378.         }
  379.     }
  380.     if ( pim->Interpolate )
  381.       pprints1(s, "%s true", pin->Interpolate);
  382.     if ( filter_name )
  383.       { if ( pdev->binary_ok )
  384.           pprints2(s, "%s%s", pin->Filter, filter_name);
  385.         else
  386.           pprints3(s, "%s[%s%s]", pin->Filter, pin->ASCII85Decode,
  387.                filter_name);
  388.         if ( decode_parms )
  389.           pprints2(s,
  390.                (pdev->binary_ok ? "%s%s" : "%s[null%s]"),
  391.                pin->DecodeParms, decode_parms);
  392.       }
  393.     else if ( !pdev->binary_ok )
  394.       pprints2(s, "%s%s", pin->Filter, pin->ASCII85Decode);
  395.     return 0;
  396. }
  397.  
  398. /* Fill in the image parameters for a device space bitmap. */
  399. /* PDF images are always specified top-to-bottom. */
  400. private void
  401. pdf_make_bitmap_matrix(gs_matrix *pmat, int x, int y, int w, int h)
  402. {    pmat->xx = w;
  403.     pmat->xy = 0;
  404.     pmat->yx = 0;
  405.     pmat->yy = -h;
  406.     pmat->tx = x;
  407.     pmat->ty = y + h;
  408. }
  409. private void
  410. pdf_make_bitmap_image(gs_image_t *pim, int x, int y, int w, int h)
  411. {    pim->Width = w;
  412.     pim->Height = h;
  413.     pdf_make_bitmap_matrix(&pim->ImageMatrix, x, y, w, h);
  414. }
  415.  
  416. /* Put out the gsave and matrix for an image. */
  417. private void
  418. pdf_put_image_matrix(gx_device_pdf *pdev, const gs_matrix *pmat)
  419. {    pdf_put_matrix(pdev, "q\n", pmat, "cm\n");
  420. }
  421.  
  422. /* ------ Image writing ------ */
  423.  
  424. /* Define the structure for writing an image. */
  425. typedef struct pdf_image_writer_s {
  426.   pdf_binary_writer binary;
  427.   const pdf_image_names *pin;
  428.   const char *begin_data;
  429.   pdf_resource *pres;        /* XObject resource iff not in-line */
  430.   long length_id;        /* id of length object (forward reference) */
  431.   long start_pos;        /* starting file position of data */
  432. } pdf_image_writer;
  433.  
  434. /* Begin writing an image. */
  435. private int
  436. pdf_begin_write_image(gx_device_pdf *pdev, pdf_image_writer *piw, bool in_line)
  437. {    if ( in_line )
  438.       { stream *s = pdev->strm;
  439.  
  440.         piw->pres = 0;
  441.         pputs(s, "BI\n");
  442.         piw->pin = &image_names_short;
  443.         piw->begin_data = (pdev->binary_ok ? "ID " : "ID\n");
  444.       }
  445.     else
  446.       { int code = pdf_begin_resource(pdev, resourceXObject, gs_no_id,
  447.                       &piw->pres);
  448.         stream *s = pdev->strm;
  449.  
  450.         if ( code < 0 )
  451.           return code;
  452.         piw->length_id = pdf_obj_ref(pdev);
  453.         pprintld1(s, " /Subtype /Image /Length %ld 0 R\n",
  454.               piw->length_id);
  455.         piw->pin = &image_names_full;
  456.         piw->begin_data = ">>\nstream\n";
  457.       }
  458.     return 0;
  459. }
  460.  
  461. /* Begin writing the image data. */
  462. private int
  463. pdf_begin_image_data(gx_device_pdf *pdev, pdf_image_writer *piw,
  464.   const gs_image_t *pim, const char *filter_name, const char *decode_parms)
  465. {    stream *s = pdev->strm;
  466.     int code = pdf_write_image_params(pdev, pim, filter_name, decode_parms,
  467.                       piw->pin);
  468.  
  469.     if ( code < 0 )
  470.       return code;
  471.     pprints1(s, "\n%s", piw->begin_data);
  472.     piw->start_pos = pdf_stell(pdev);
  473.     return 0;
  474. }
  475.  
  476. /* Finish writing an image. */
  477. /* Return 0 if resource, 1 if in-line, or an error code. */
  478. private int
  479. pdf_end_write_image(gx_device_pdf *pdev, pdf_image_writer *piw)
  480. {    stream *s = pdev->strm;
  481.  
  482.     if ( piw->pres )        /* image resource */
  483.       { long length;
  484.  
  485.         pputs(s, "\n");
  486.         length = pdf_stell(pdev) - piw->start_pos;
  487.         pputs(s, "endstream\n");
  488.         pdf_end_resource(pdev);
  489.         pdf_open_separate(pdev, piw->length_id);
  490.         s = pdev->strm;
  491.         pprintld1(s, "%ld\n", length);
  492.         pdf_end_separate(pdev);
  493.         return 0;
  494.       }
  495.     else        /* in-line image */
  496.       { pputs(s, "\nEI\nQ\n");
  497.         return 1;
  498.       }
  499. }
  500.  
  501. /* Put out a reference to an image resource. */
  502. private int
  503. pdf_do_image(gx_device_pdf *pdev, const pdf_resource *pres,
  504.   const gs_matrix *pimat)
  505. {    int code = pdf_open_contents(pdev, pdf_in_stream);
  506.  
  507.     if ( code < 0 )
  508.       return code;
  509.     if ( pimat )
  510.       pdf_put_image_matrix(pdev, pimat);
  511.     pprintld1(pdev->strm, "/R%ld Do\nQ\n", pres->id);
  512.     return 0;
  513. }
  514.  
  515. /* ---------------- Driver procedures ---------------- */
  516.  
  517. /* ------ Low-level calls ------ */
  518.  
  519. /* Copy a monochrome bitmap or mask. */
  520. int
  521. gdev_pdf_copy_mono(gx_device *dev,
  522.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  523.   int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
  524. {    gx_device_pdf *pdev = (gx_device_pdf *)dev;
  525.     int code;
  526.     gs_color_space cs;
  527.     byte palette[6];
  528.     gs_image_t image;
  529.     int yi;
  530.     pdf_image_writer writer;
  531.     pdf_stream_position ipos;
  532.     pdf_resource *pres = 0;
  533.     byte invert = 0;
  534.  
  535.     if ( w <= 0 || h <= 0 )
  536.       return 0;
  537.     /* Make sure we aren't being clipped. */
  538.     if ( pdf_must_put_clip_path(pdev, NULL) )
  539.       { code = pdf_open_page(pdev, pdf_in_stream);
  540.         if ( code < 0 )
  541.           return code;
  542.         pdf_put_clip_path(pdev, NULL);
  543.       }
  544.     /* We have 3 cases: mask, inverse mask, and solid. */
  545.     if ( zero == gx_no_color_index )
  546.       { if ( one == gx_no_color_index )
  547.           return 0;
  548.         /* If a mask has an id, assume it's a character. */
  549.         if ( id != gx_no_bitmap_id && sourcex == 0 )
  550.           { pdf_set_color(pdev, one, &pdev->fill_color, "rg");
  551.         pres = pdf_find_resource_by_gs_id(pdev, resourceCharProc, id);
  552.         if ( pres == 0 )
  553.           { /* Define the character in an embedded font. */
  554.             pdf_char_proc *pcp;
  555.             int y_offset;
  556.             int max_y_offset =
  557.               (pdev->open_font == 0 ? 0 :
  558.                pdev->open_font->max_y_offset);
  559.  
  560.             gs_image_t_init_mask(&image, false);
  561.             invert = 0xff;
  562.             pdf_make_bitmap_image(&image, x, y, w, h);
  563.             y_offset =
  564.               image.ImageMatrix.ty - (int)(pdev->text.current.y + 0.5);
  565.             if ( x < pdev->text.current.x ||
  566.              y_offset < -max_y_offset || y_offset > max_y_offset
  567.                )
  568.               y_offset = 0;
  569.             /*
  570.              * The Y axis of the text matrix is inverted,
  571.              * so we need to negate the Y offset appropriately.
  572.              */
  573.             code = pdf_begin_char_proc(pdev, w, h, 0, y_offset, id,
  574.                            &pcp, &ipos);
  575.             if ( code < 0 )
  576.               return code;
  577.             y_offset = -y_offset;
  578.             pprintd3(pdev->strm, "0 0 0 %d %d %d d1\n", y_offset,
  579.                  w, h + y_offset);
  580.             pprintd3(pdev->strm, "%d 0 0 %d 0 %d cm\n", w, h,
  581.                  y_offset);
  582.             code = pdf_begin_write_image(pdev, &writer, true);
  583.             if ( code < 0 )
  584.               return code;
  585.             pcp->rid = id;
  586.             pres = (pdf_resource *)pcp;
  587.             goto wr;
  588.           }
  589.         pdf_make_bitmap_matrix(&image.ImageMatrix, x, y, w, h);
  590.         goto rx;
  591.           }
  592.         pdf_set_color(pdev, one, &pdev->fill_color, "rg");
  593.         gs_image_t_init_mask(&image, false);
  594.         invert = 0xff;
  595.       }
  596.     else if ( one == gx_no_color_index )
  597.       { gs_image_t_init_mask(&image, false);
  598.         pdf_set_color(pdev, zero, &pdev->fill_color, "rg");
  599.       }
  600.     else if ( zero == 0 && one == 0xffffff )
  601.       { gs_image_t_init_gray(&image);
  602.       }
  603.     else if ( zero == 0xffffff && one == 0 )
  604.       { gs_image_t_init_gray(&image);
  605.         invert = 0xff;
  606.       }
  607.     else
  608.       { gs_image_t_init_color(&image);
  609.         cs.type = &gs_color_space_type_Indexed;
  610.         cs.params.indexed.hival = 1;
  611.         palette[0] = (byte)(zero >> 16);
  612.         palette[1] = (byte)(zero >> 8);
  613.         palette[2] = (byte)(zero);
  614.         palette[3] = (byte)(one >> 16);
  615.         palette[4] = (byte)(one >> 8);
  616.         palette[5] = (byte)(one);
  617.         cs.params.indexed.lookup.table.data = palette;
  618.         cs.params.indexed.lookup.table.size = 6;
  619.         cs.params.indexed.use_proc = false;
  620.         image.BitsPerComponent = 1;
  621.         image.ColorSpace = &cs;
  622.       }
  623.     pdf_make_bitmap_image(&image, x, y, w, h);
  624.     { ulong nbytes = (ulong)((w + 7) >> 3) * h;
  625.       bool in_line = nbytes <= 4000;
  626.  
  627.       if ( in_line )
  628.         pdf_put_image_matrix(pdev, &image.ImageMatrix);
  629.       code = pdf_open_page(pdev, pdf_in_stream);
  630.       if ( code < 0 )
  631.         return code;
  632.       code = pdf_begin_write_image(pdev, &writer, in_line);
  633.       if ( code < 0 )
  634.         return code;
  635.     }
  636. wr:    /*
  637.      * There are 3 different cases at this point:
  638.      *    - Writing an in-line image (pres == 0, writer.pres == 0);
  639.      *    - Writing an XObject image (pres == 0, writer.pres != 0);
  640.      *    - Writing the image for a CharProc (pres != 0).
  641.      * We handle them with in-line code followed by a switch,
  642.      * rather than making the shared code into a procedure,
  643.      * simply because there would be an awful lot of parameters
  644.      * that would need to be passed.
  645.      */
  646.     { char decode_parms[80];
  647.  
  648.       sprintf(decode_parms,
  649.           "<</K -1/Columns %d%s>>",
  650.           w, (invert ? "" : "/BlackIs1 true"));
  651.       pdf_begin_image_data(pdev, &writer, &image,
  652.                    writer.pin->CCITTFaxDecode, decode_parms);
  653.     }
  654.     { stream_CFE_state csstate;
  655.       csstate.template = &s_CFE_template;
  656.       (*csstate.template->set_defaults)((stream_state *)&csstate);
  657.       csstate.K = -1;
  658.       csstate.Columns = w;
  659.       csstate.Rows = h;
  660.       csstate.BlackIs1 = invert == 0;
  661.       pdf_begin_binary(pdev, &writer.binary, (stream_state *)&csstate);
  662.       for ( yi = 0; yi < h; ++yi )
  663.         { const byte *data = base + yi * raster + (sourcex >> 3);
  664.           int sbit = sourcex & 7;
  665.  
  666.           if ( sbit == 0 )
  667.         { int nbytes = (w + 7) >> 3;
  668.           int i;
  669.  
  670.           for ( i = 0; i < nbytes; ++data, ++i )
  671.             sputc(writer.binary.strm, *data ^ invert);
  672.         }
  673.           else
  674.         { int wleft = w;
  675.           int rbit = 8 - sbit;
  676.  
  677.           for ( ; wleft + sbit > 8; ++data, wleft -= 8 )
  678.             sputc(writer.binary.strm,
  679.               ((*data << sbit) + (data[1] >> rbit)) ^ invert);
  680.           if ( wleft > 0 )
  681.             sputc(writer.binary.strm,
  682.               ((*data << sbit) ^ invert) &
  683.                 (byte)(0xff00 >> wleft));
  684.         }
  685.         }
  686.       pdf_end_binary(pdev, &writer.binary);
  687.     }
  688.     if ( !pres )
  689.       { switch ( pdf_end_write_image(pdev, &writer) )
  690.           {
  691.           default:        /* error */
  692.         return code;
  693.           case 1:
  694.         return 0;
  695.           case 0:
  696.         return pdf_do_image(pdev, writer.pres, &image.ImageMatrix);
  697.           }
  698.       }
  699.     pputs(pdev->strm, "\nEI\n");
  700.     code = pdf_end_char_proc(pdev, &ipos);
  701.     if ( code < 0 )
  702.       return code;
  703. rx:    { gs_matrix imat;
  704.  
  705.       imat = image.ImageMatrix;
  706.       imat.xx /= w;
  707.       imat.xy /= h;
  708.       imat.yx /= w;
  709.       imat.yy /= h;
  710.       return pdf_do_char_image(pdev, (const pdf_char_proc *)pres, &imat);
  711.     }
  712. }
  713.  
  714. /* Copy a color bitmap. */
  715. int
  716. gdev_pdf_copy_color(gx_device *dev,
  717.   const byte *base, int sourcex, int raster, gx_bitmap_id id,
  718.   int x, int y, int w, int h)
  719. {    gx_device_pdf *pdev = (gx_device_pdf *)dev;
  720.     int depth = dev->color_info.depth;
  721.     int bytes_per_pixel = depth >> 3;
  722.     int code = pdf_open_page(pdev, pdf_in_stream);
  723.     int yi;
  724.     gs_image_t image;
  725.     gs_color_space cs;
  726.     pdf_image_writer writer;
  727.     ulong nbytes;
  728.  
  729.     if ( code < 0 )
  730.       return code;
  731.     if ( w <= 0 || h <= 0 )
  732.       return 0;
  733.     /* Make sure we aren't being clipped. */
  734.     pdf_put_clip_path(pdev, NULL);
  735.     gs_image_t_init_color(&image);
  736.     pdf_make_bitmap_image(&image, x, y, w, h);
  737.     image.BitsPerComponent = 8;
  738.     cs.type = (bytes_per_pixel == 3 ? &gs_color_space_type_DeviceRGB :
  739.            bytes_per_pixel == 4 ? &gs_color_space_type_DeviceCMYK :
  740.            &gs_color_space_type_DeviceGray);
  741.     image.ColorSpace = &cs;
  742.     nbytes = (ulong)w * bytes_per_pixel * h;
  743.     pdf_put_image_matrix(pdev, &image.ImageMatrix);
  744.     code = pdf_begin_write_image(pdev, &writer, nbytes <= 4000);
  745.     if ( code < 0 )
  746.       return code;
  747.     code = pdf_begin_image_data(pdev, &writer, &image, NULL, NULL);
  748.     if ( code < 0 )
  749.       return code;
  750.     pdf_begin_binary(pdev, &writer.binary, NULL);
  751.     for ( yi = 0; yi < h; ++yi )
  752.       { uint ignore;
  753.         sputs(writer.binary.strm,
  754.           base + sourcex * bytes_per_pixel + yi * raster,
  755.           w * bytes_per_pixel, &ignore);
  756.       }
  757.     pdf_end_binary(pdev, &writer.binary);
  758.     code = pdf_end_write_image(pdev, &writer);
  759.     switch ( code )
  760.       {
  761.       default: return code;        /* error */
  762.       case 1: return 0;
  763.       case 0: ;
  764.       }
  765.     return pdf_do_image(pdev, writer.pres, &image.ImageMatrix);
  766. }
  767.  
  768. /* Fill a mask. */
  769. int
  770. gdev_pdf_fill_mask(gx_device *dev,
  771.   const byte *data, int data_x, int raster, gx_bitmap_id id,
  772.   int x, int y, int width, int height,
  773.   const gx_drawing_color *pdcolor, int depth,
  774.   gs_logical_operation_t lop, const gx_clip_path *pcpath)
  775. {    gx_device_pdf *pdev = (gx_device_pdf *)dev;
  776.     int code;
  777.  
  778.     if ( width <= 0 || height <= 0 )
  779.       return 0;
  780.     if ( depth > 1 || !gx_dc_is_pure(pdcolor) != 0 )
  781.       return gx_default_fill_mask(dev, data, data_x, raster, id,
  782.                       x, y, width, height, pdcolor, depth, lop,
  783.                       pcpath);
  784.     if ( pdf_must_put_clip_path(pdev, pcpath) )
  785.       { code = pdf_open_page(pdev, pdf_in_stream);
  786.         if ( code < 0 )
  787.           return code;
  788.         pdf_put_clip_path(pdev, pcpath);
  789.       }
  790.     return gdev_pdf_copy_mono(dev, data, data_x, raster, id,
  791.                   x, y, width, height,
  792.                   gx_no_color_index,
  793.                   gx_dc_pure_color(pdcolor));
  794. }
  795.  
  796. /* ------ High-level calls ------ */
  797.  
  798. /* Define the structure for keeping track of progress through an image. */
  799. typedef struct pdf_image_enum_s {
  800.     gs_memory_t *memory;
  801.     void *default_info;
  802.     int width;
  803.     int num_planes;
  804.     int bits_per_pixel;    /* bits per pixel (per plane) */
  805.     int rows_left;
  806.     pdf_image_writer writer;
  807. } pdf_image_enum;
  808. /* We can disregard the pointers in the writer by allocating */
  809. /* the image enumerator as immovable.  This is a hack, of course. */
  810. gs_private_st_ptrs1(st_pdf_image_enum, pdf_image_enum, "pdf_image_enum",
  811.   pdf_image_enum_enum_ptrs, pdf_image_enum_reloc_ptrs, default_info);
  812.  
  813. /* Test whether we can handle a given color space. */
  814. private bool
  815. pdf_can_handle_color_space(const gs_color_space *pcs)
  816. {    gs_color_space_index index = gs_color_space_get_index(pcs);
  817.  
  818.     if ( index == gs_color_space_index_Indexed )
  819.       { if ( pcs->params.indexed.use_proc )
  820.           return false;
  821.         index =
  822.           gs_color_space_get_index(gs_color_space_indexed_base_space(pcs));
  823.       }
  824.     switch ( index ) {
  825.       case gs_color_space_index_DeviceGray:
  826.       case gs_color_space_index_DeviceRGB:
  827.       case gs_color_space_index_DeviceCMYK:
  828.         return true;
  829.       case gs_color_space_index_Separation:
  830.       case gs_color_space_index_Pattern:
  831.         return false;    /****** OK in PDF 1.2 ******/
  832.       case gs_color_space_index_CIEA:
  833.         { /* Check that we can represent this as a CalGray space. */
  834.           const gs_cie_a *pcie = pcs->params.a;
  835.           float expts[3];
  836.  
  837.           return (pcie->MatrixA.u == 1 && pcie->MatrixA.v == 1 &&
  838.               pcie->MatrixA.w == 1 &&
  839.               pcie->common.MatrixLMN.is_identity &&
  840.               ((cie_cache_is_identity(&pcie->caches.DecodeA) &&
  841.             cie_scalar3_cache_is_exponential(pcie->common.caches.DecodeLMN, expts) &&
  842.             expts[1] == expts[0] && expts[2] == expts[0]) ||
  843.                (cie_vector_cache_is_exponential(&pcie->caches.DecodeA, &expts[0]) &&
  844.             cie_cache3_is_identity(pcie->common.caches.DecodeLMN)))
  845.              );
  846.         }
  847.        case gs_color_space_index_CIEABC:
  848.         { /* Check that we can represent this as a CalRGB space. */
  849.           const gs_cie_abc *pcie = pcs->params.abc;
  850.           float expts[3];
  851.  
  852.           return ((cie_cache3_is_identity(pcie->caches.DecodeABC) &&
  853.                pcie->MatrixABC.is_identity &&
  854.                cie_scalar3_cache_is_exponential(pcie->common.caches.DecodeLMN, expts)) ||
  855.               (cie_vector3_cache_is_exponential(pcie->caches.DecodeABC, expts) &&
  856.                cie_cache3_is_identity(pcie->common.caches.DecodeLMN) &&
  857.                pcie->common.MatrixLMN.is_identity)
  858.              );
  859.         }
  860.       default:        /* CIEBasedDEF[G], LL3 spaces */
  861.         return false;
  862.     }
  863. }
  864.  
  865. /* Start processing an image. */
  866. int
  867. gdev_pdf_begin_image(gx_device *dev,
  868.   const gs_imager_state *pis, const gs_image_t *pim,
  869.   gs_image_format_t format, const gs_int_rect *prect,
  870.   const gx_drawing_color *pdcolor, const gx_clip_path *pcpath,
  871.   gs_memory_t *mem, void **pinfo)
  872. {    gx_device_pdf *pdev = (gx_device_pdf *)dev;
  873.     int code = pdf_open_page(pdev, pdf_in_stream);
  874.     pdf_image_enum *pie;
  875.     const gs_color_space *pcs = pim->ColorSpace;
  876.     int num_components =
  877.       (pim->ImageMask ? 1 : gs_color_space_num_components(pcs));
  878.     gs_int_rect rect;
  879.     ulong nbytes;
  880.  
  881.     if ( code < 0 )
  882.       return code;
  883.     if ( prect )
  884.       rect = *prect;
  885.     else
  886.       { rect.p.x = rect.p.y = 0;
  887.         rect.q.x = pim->Width, rect.q.y = pim->Height;
  888.       }
  889.     /* See above for why we allocate the enumerator as immovable. */
  890.     pie = gs_alloc_struct_immovable(mem, pdf_image_enum,
  891.                     &st_pdf_image_enum,
  892.                     "pdf_begin_image");
  893.     if ( pie == 0 )
  894.       return_error(gs_error_VMerror);
  895.     pie->memory = mem;
  896.     *pinfo = pie;
  897.     if ( (pim->ImageMask ?
  898.           (!gx_dc_is_pure(pdcolor) || pim->CombineWithColor) :
  899.           !pdf_can_handle_color_space(pim->ColorSpace)) ||
  900.          prect
  901.        )
  902.         { int code = gx_default_begin_image(dev, pis, pim, format, prect,
  903.                         pdcolor, pcpath, mem,
  904.                         &pie->default_info);
  905.           if ( code < 0 )
  906.         gs_free_object(mem, pie, "pdf_begin_image");
  907.           return code;
  908.         }
  909.     pie->default_info = 0;
  910.     pie->width = rect.q.x - rect.p.x;
  911.     switch ( format )
  912.       {
  913.       case gs_image_format_chunky:
  914.         pie->num_planes = 1; break;
  915.       case gs_image_format_component_planar:
  916.         pie->num_planes = num_components; break;
  917.       case gs_image_format_bit_planar:
  918.         pie->num_planes = num_components * pim->BitsPerComponent; break;
  919.       }
  920.     pie->bits_per_pixel =
  921.       pim->BitsPerComponent * num_components / pie->num_planes;
  922.     pie->rows_left = rect.q.y - rect.p.y;
  923.     pdf_put_clip_path(pdev, pcpath);
  924.     if ( pim->ImageMask )
  925.       pdf_set_color(pdev, gx_dc_pure_color(pdcolor), &pdev->fill_color,
  926.             "rg");
  927.     /****** DOESN'T DO COMPRESSION YET ******/
  928.     { gs_matrix mat;
  929.       gs_matrix bmat;
  930.       int code;
  931.  
  932.       pdf_make_bitmap_matrix(&bmat, -rect.p.x, -rect.p.y,
  933.                  pim->Width, pim->Height);
  934.       if ( (code = gs_matrix_invert(&pim->ImageMatrix, &mat)) < 0 ||
  935.            (code = gs_matrix_multiply(&bmat, &mat, &mat)) < 0 ||
  936.            (code = gs_matrix_multiply(&mat, &ctm_only(pis), &mat)) < 0
  937.          )
  938.         { gs_free_object(mem, pie, "pdf_begin_image");
  939.           return code;
  940.         }
  941.       pdf_put_image_matrix(pdev, &mat);
  942.     }
  943.     nbytes = (((ulong)pie->width * pie->bits_per_pixel + 7) >> 3) *
  944.       pie->rows_left;
  945.     code = pdf_begin_write_image(pdev, &pie->writer, nbytes <= 4000);
  946.     if ( code < 0 )
  947.       return code;
  948.     code = pdf_begin_image_data(pdev, &pie->writer, pim, NULL, NULL);
  949.     if ( code < 0 )
  950.       return code;
  951.     pdf_begin_binary(pdev, &pie->writer.binary, NULL);
  952.     return 0;
  953. }
  954.  
  955. /* Process the next piece of an image. */
  956. int
  957. gdev_pdf_image_data(gx_device *dev,
  958.   void *info, const byte **planes, int data_x, uint raster, int height)
  959. {    pdf_image_enum *pie = info;
  960.     int h = height;
  961.     uint y_offset = 0;
  962.     uint bcount;
  963.     uint ignore;
  964.     int nplanes = pie->num_planes;
  965. #define row_bytes 180        /* must be 0 mod 3, 4, 6, 9 */
  966.     byte row[row_bytes];
  967.  
  968.     if ( pie->default_info )
  969.       return gx_default_image_data(dev, pie->default_info, planes, data_x,
  970.                        raster, height);
  971.     if ( h > pie->rows_left )
  972.       h = pie->rows_left;
  973.     pie->rows_left -= h;
  974.     bcount = ((data_x + pie->width) * pie->bits_per_pixel + 7) >> 3;
  975.     for ( ; h > 0; y_offset += raster, --h )
  976.       { if ( nplanes > 1 )
  977.           { /* Flip the data in blocks before writing. */
  978.         uint offset = y_offset;
  979.         uint count = bcount;
  980.  
  981.         while ( count )
  982.           { uint flip_count = min(count, row_bytes / nplanes);
  983.             image_flip_planes(row, planes, offset, flip_count, nplanes,
  984.                       pie->bits_per_pixel);
  985.             sputs(pie->writer.binary.strm, row, flip_count * nplanes,
  986.               &ignore);
  987.             count -= flip_count;
  988.             offset += flip_count;
  989.           }
  990.           }
  991.         else
  992.           sputs(pie->writer.binary.strm, planes[0] + y_offset, bcount,
  993.             &ignore);
  994.       }
  995.     return !pie->rows_left;
  996. #undef row_bytes
  997. }
  998.  
  999. /* Clean up by releasing the buffers. */
  1000. int
  1001. gdev_pdf_end_image(gx_device *dev, void *info, bool draw_last)
  1002. {    gx_device_pdf *pdev = (gx_device_pdf *)dev;
  1003.     pdf_image_enum *pie = info;
  1004.     int code;
  1005.  
  1006.     if ( pie->default_info )
  1007.       code = gx_default_end_image(dev, pie->default_info, draw_last);
  1008.     else
  1009.       { code = pdf_end_binary(pdev, &pie->writer.binary);
  1010.         if ( code < 0 )
  1011.           return code;
  1012.         code = pdf_end_write_image(pdev, &pie->writer);
  1013.         switch ( code )
  1014.           {
  1015.           default: return code;        /* error */
  1016.           case 1: return 0;
  1017.           case 0: ;
  1018.           }
  1019.         code = pdf_do_image(pdev, pie->writer.pres, NULL);
  1020.       }
  1021.     gs_free_object(pie->memory, pie, "pdf_end_image");
  1022.     return code;
  1023. }
  1024.