1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski #include "pdfioutdev_gpl.hxx"
23*b1cdbd2cSJim Jagielski #include "pnghelper.hxx"
24*b1cdbd2cSJim Jagielski
25*b1cdbd2cSJim Jagielski #include <stdlib.h>
26*b1cdbd2cSJim Jagielski #include <stdio.h>
27*b1cdbd2cSJim Jagielski #include <assert.h>
28*b1cdbd2cSJim Jagielski #include <math.h>
29*b1cdbd2cSJim Jagielski #include <vector>
30*b1cdbd2cSJim Jagielski
31*b1cdbd2cSJim Jagielski #include <boost/shared_array.hpp>
32*b1cdbd2cSJim Jagielski
33*b1cdbd2cSJim Jagielski #if defined __SUNPRO_CC
34*b1cdbd2cSJim Jagielski #pragma disable_warn
35*b1cdbd2cSJim Jagielski #elif defined _MSC_VER
36*b1cdbd2cSJim Jagielski #pragma warning(push, 1)
37*b1cdbd2cSJim Jagielski #endif
38*b1cdbd2cSJim Jagielski
39*b1cdbd2cSJim Jagielski #include "UTF8.h"
40*b1cdbd2cSJim Jagielski
41*b1cdbd2cSJim Jagielski #if defined __SUNPRO_CC
42*b1cdbd2cSJim Jagielski #pragma enable_warn
43*b1cdbd2cSJim Jagielski #elif defined _MSC_VER
44*b1cdbd2cSJim Jagielski #pragma warning(pop)
45*b1cdbd2cSJim Jagielski #endif
46*b1cdbd2cSJim Jagielski
47*b1cdbd2cSJim Jagielski #ifdef WNT
48*b1cdbd2cSJim Jagielski # define snprintf _snprintf
49*b1cdbd2cSJim Jagielski #endif
50*b1cdbd2cSJim Jagielski
51*b1cdbd2cSJim Jagielski
52*b1cdbd2cSJim Jagielski /* SYNC STREAMS
53*b1cdbd2cSJim Jagielski ============
54*b1cdbd2cSJim Jagielski
55*b1cdbd2cSJim Jagielski We stream human-readble tokens to stdout, and binary data (fonts,
56*b1cdbd2cSJim Jagielski bitmaps) to g_binary_out. Another process reads from those pipes, and
57*b1cdbd2cSJim Jagielski there lies the rub: things can deadlock, if the two involved
58*b1cdbd2cSJim Jagielski processes access the pipes in different order. At any point in
59*b1cdbd2cSJim Jagielski time, both processes must access the same pipe. To ensure this,
60*b1cdbd2cSJim Jagielski data must be flushed to the OS before writing to a different pipe,
61*b1cdbd2cSJim Jagielski otherwise not-yet-written data will leave the reading process
62*b1cdbd2cSJim Jagielski waiting on the wrong pipe.
63*b1cdbd2cSJim Jagielski */
64*b1cdbd2cSJim Jagielski
65*b1cdbd2cSJim Jagielski namespace pdfi
66*b1cdbd2cSJim Jagielski {
67*b1cdbd2cSJim Jagielski
68*b1cdbd2cSJim Jagielski /// cut off very small numbers & clamp value to zero
normalize(double val)69*b1cdbd2cSJim Jagielski inline double normalize( double val )
70*b1cdbd2cSJim Jagielski {
71*b1cdbd2cSJim Jagielski return fabs(val) < 0.0000001 ? 0.0 : val;
72*b1cdbd2cSJim Jagielski }
73*b1cdbd2cSJim Jagielski
74*b1cdbd2cSJim Jagielski namespace
75*b1cdbd2cSJim Jagielski {
76*b1cdbd2cSJim Jagielski
77*b1cdbd2cSJim Jagielski /** Escapes line-ending characters (\n and \r) in input string.
78*b1cdbd2cSJim Jagielski */
lcl_escapeLineFeeds(const char * const i_pStr)79*b1cdbd2cSJim Jagielski boost::shared_array<char> lcl_escapeLineFeeds(const char* const i_pStr)
80*b1cdbd2cSJim Jagielski {
81*b1cdbd2cSJim Jagielski size_t nLength(strlen(i_pStr));
82*b1cdbd2cSJim Jagielski char* pBuffer = new char[2*nLength+1];
83*b1cdbd2cSJim Jagielski
84*b1cdbd2cSJim Jagielski const char* pRead = i_pStr;
85*b1cdbd2cSJim Jagielski char* pWrite = pBuffer;
86*b1cdbd2cSJim Jagielski while( nLength-- )
87*b1cdbd2cSJim Jagielski {
88*b1cdbd2cSJim Jagielski if( *pRead == '\r' )
89*b1cdbd2cSJim Jagielski {
90*b1cdbd2cSJim Jagielski *pWrite++ = '\\';
91*b1cdbd2cSJim Jagielski *pWrite++ = 'r';
92*b1cdbd2cSJim Jagielski }
93*b1cdbd2cSJim Jagielski else if( *pRead == '\n' )
94*b1cdbd2cSJim Jagielski {
95*b1cdbd2cSJim Jagielski *pWrite++ = '\\';
96*b1cdbd2cSJim Jagielski *pWrite++ = 'n';
97*b1cdbd2cSJim Jagielski }
98*b1cdbd2cSJim Jagielski else if( *pRead == '\\' )
99*b1cdbd2cSJim Jagielski {
100*b1cdbd2cSJim Jagielski *pWrite++ = '\\';
101*b1cdbd2cSJim Jagielski *pWrite++ = '\\';
102*b1cdbd2cSJim Jagielski }
103*b1cdbd2cSJim Jagielski else
104*b1cdbd2cSJim Jagielski *pWrite++ = *pRead;
105*b1cdbd2cSJim Jagielski pRead++;
106*b1cdbd2cSJim Jagielski }
107*b1cdbd2cSJim Jagielski *pWrite++ = 0;
108*b1cdbd2cSJim Jagielski
109*b1cdbd2cSJim Jagielski return boost::shared_array<char>(pBuffer);
110*b1cdbd2cSJim Jagielski }
111*b1cdbd2cSJim Jagielski
112*b1cdbd2cSJim Jagielski }
113*b1cdbd2cSJim Jagielski
114*b1cdbd2cSJim Jagielski /// for the temp char buffer the header gets snprintfed in
115*b1cdbd2cSJim Jagielski #define WRITE_BUFFER_SIZE 1024
116*b1cdbd2cSJim Jagielski
117*b1cdbd2cSJim Jagielski /// for the initial std::vector capacity when copying stream from xpdf
118*b1cdbd2cSJim Jagielski #define WRITE_BUFFER_INITIAL_CAPACITY (1024*100)
119*b1cdbd2cSJim Jagielski
initBuf(OutputBuffer & io_rBuffer)120*b1cdbd2cSJim Jagielski void initBuf(OutputBuffer& io_rBuffer)
121*b1cdbd2cSJim Jagielski {
122*b1cdbd2cSJim Jagielski io_rBuffer.reserve(WRITE_BUFFER_INITIAL_CAPACITY);
123*b1cdbd2cSJim Jagielski }
124*b1cdbd2cSJim Jagielski
writeBinaryBuffer(const OutputBuffer & rBuffer)125*b1cdbd2cSJim Jagielski void writeBinaryBuffer( const OutputBuffer& rBuffer )
126*b1cdbd2cSJim Jagielski {
127*b1cdbd2cSJim Jagielski // ---sync point--- see SYNC STREAMS above
128*b1cdbd2cSJim Jagielski fflush(stdout);
129*b1cdbd2cSJim Jagielski
130*b1cdbd2cSJim Jagielski // put buffer to stderr
131*b1cdbd2cSJim Jagielski if( !rBuffer.empty() )
132*b1cdbd2cSJim Jagielski if( fwrite(&rBuffer[0], sizeof(char),
133*b1cdbd2cSJim Jagielski rBuffer.size(), g_binary_out) != (size_t)rBuffer.size() )
134*b1cdbd2cSJim Jagielski exit(1); // error
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski // ---sync point--- see SYNC STREAMS above
137*b1cdbd2cSJim Jagielski fflush(g_binary_out);
138*b1cdbd2cSJim Jagielski }
139*b1cdbd2cSJim Jagielski
writeJpeg_(OutputBuffer & o_rOutputBuf,Stream * str,bool bWithLinefeed)140*b1cdbd2cSJim Jagielski void writeJpeg_( OutputBuffer& o_rOutputBuf, Stream* str, bool bWithLinefeed )
141*b1cdbd2cSJim Jagielski {
142*b1cdbd2cSJim Jagielski // dump JPEG file as-is
143*b1cdbd2cSJim Jagielski str = ((DCTStream *)str)->getRawStream();
144*b1cdbd2cSJim Jagielski str->reset();
145*b1cdbd2cSJim Jagielski
146*b1cdbd2cSJim Jagielski int c;
147*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
148*b1cdbd2cSJim Jagielski while((c=str->getChar()) != EOF)
149*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(static_cast<char>(c));
150*b1cdbd2cSJim Jagielski
151*b1cdbd2cSJim Jagielski printf( " JPEG %d", (int)o_rOutputBuf.size() );
152*b1cdbd2cSJim Jagielski if( bWithLinefeed )
153*b1cdbd2cSJim Jagielski printf("\n");
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski str->close();
156*b1cdbd2cSJim Jagielski }
157*b1cdbd2cSJim Jagielski
writePbm_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,bool bWithLinefeed,bool bInvert)158*b1cdbd2cSJim Jagielski void writePbm_(OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bWithLinefeed, bool bInvert )
159*b1cdbd2cSJim Jagielski {
160*b1cdbd2cSJim Jagielski // write as PBM (char by char, to avoid stdlib lineend messing)
161*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
162*b1cdbd2cSJim Jagielski o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
163*b1cdbd2cSJim Jagielski o_rOutputBuf[0] = 'P';
164*b1cdbd2cSJim Jagielski o_rOutputBuf[1] = '4';
165*b1cdbd2cSJim Jagielski o_rOutputBuf[2] = 0x0A;
166*b1cdbd2cSJim Jagielski int nOutLen = snprintf(&o_rOutputBuf[3], WRITE_BUFFER_SIZE-10, "%d %d", width, height);
167*b1cdbd2cSJim Jagielski if( nOutLen < 0 )
168*b1cdbd2cSJim Jagielski nOutLen = WRITE_BUFFER_SIZE-10;
169*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen] =0x0A;
170*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+1]=0;
171*b1cdbd2cSJim Jagielski
172*b1cdbd2cSJim Jagielski const int header_size = 3+nOutLen+1;
173*b1cdbd2cSJim Jagielski const int size = height * ((width + 7) / 8);
174*b1cdbd2cSJim Jagielski
175*b1cdbd2cSJim Jagielski printf( " PBM %d", size + header_size );
176*b1cdbd2cSJim Jagielski if( bWithLinefeed )
177*b1cdbd2cSJim Jagielski printf("\n");
178*b1cdbd2cSJim Jagielski
179*b1cdbd2cSJim Jagielski // trim buffer to exact header length
180*b1cdbd2cSJim Jagielski o_rOutputBuf.resize(header_size);
181*b1cdbd2cSJim Jagielski
182*b1cdbd2cSJim Jagielski // initialize stream
183*b1cdbd2cSJim Jagielski str->reset();
184*b1cdbd2cSJim Jagielski
185*b1cdbd2cSJim Jagielski // copy the raw stream
186*b1cdbd2cSJim Jagielski if( bInvert )
187*b1cdbd2cSJim Jagielski {
188*b1cdbd2cSJim Jagielski for( int i=0; i<size; ++i)
189*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(static_cast<char>(str->getChar() ^ 0xff));
190*b1cdbd2cSJim Jagielski }
191*b1cdbd2cSJim Jagielski else
192*b1cdbd2cSJim Jagielski {
193*b1cdbd2cSJim Jagielski for( int i=0; i<size; ++i)
194*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(static_cast<char>(str->getChar()));
195*b1cdbd2cSJim Jagielski }
196*b1cdbd2cSJim Jagielski
197*b1cdbd2cSJim Jagielski str->close();
198*b1cdbd2cSJim Jagielski }
199*b1cdbd2cSJim Jagielski
writePpm_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap,bool bWithLinefeed)200*b1cdbd2cSJim Jagielski void writePpm_( OutputBuffer& o_rOutputBuf,
201*b1cdbd2cSJim Jagielski Stream* str,
202*b1cdbd2cSJim Jagielski int width,
203*b1cdbd2cSJim Jagielski int height,
204*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap,
205*b1cdbd2cSJim Jagielski bool bWithLinefeed )
206*b1cdbd2cSJim Jagielski {
207*b1cdbd2cSJim Jagielski // write as PPM (char by char, to avoid stdlib lineend messing)
208*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
209*b1cdbd2cSJim Jagielski o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
210*b1cdbd2cSJim Jagielski o_rOutputBuf[0] = 'P';
211*b1cdbd2cSJim Jagielski o_rOutputBuf[1] = '6';
212*b1cdbd2cSJim Jagielski o_rOutputBuf[2] = '\n';
213*b1cdbd2cSJim Jagielski int nOutLen = snprintf(&o_rOutputBuf[3], WRITE_BUFFER_SIZE-10, "%d %d", width, height);
214*b1cdbd2cSJim Jagielski if( nOutLen < 0 )
215*b1cdbd2cSJim Jagielski nOutLen = WRITE_BUFFER_SIZE-10;
216*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen] ='\n';
217*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+1]='2';
218*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+2]='5';
219*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+3]='5';
220*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+4]='\n';
221*b1cdbd2cSJim Jagielski o_rOutputBuf[3+nOutLen+5]=0;
222*b1cdbd2cSJim Jagielski
223*b1cdbd2cSJim Jagielski const int header_size = 3+nOutLen+5;
224*b1cdbd2cSJim Jagielski const int size = width*height*3 + header_size;
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski printf( " PPM %d", size );
227*b1cdbd2cSJim Jagielski if( bWithLinefeed )
228*b1cdbd2cSJim Jagielski printf("\n");
229*b1cdbd2cSJim Jagielski
230*b1cdbd2cSJim Jagielski // trim buffer to exact header size
231*b1cdbd2cSJim Jagielski o_rOutputBuf.resize(header_size);
232*b1cdbd2cSJim Jagielski
233*b1cdbd2cSJim Jagielski // initialize stream
234*b1cdbd2cSJim Jagielski Guchar *p;
235*b1cdbd2cSJim Jagielski GfxRGB rgb;
236*b1cdbd2cSJim Jagielski ImageStream* imgStr =
237*b1cdbd2cSJim Jagielski new ImageStream(str,
238*b1cdbd2cSJim Jagielski width,
239*b1cdbd2cSJim Jagielski colorMap->getNumPixelComps(),
240*b1cdbd2cSJim Jagielski colorMap->getBits());
241*b1cdbd2cSJim Jagielski imgStr->reset();
242*b1cdbd2cSJim Jagielski
243*b1cdbd2cSJim Jagielski for( int y=0; y<height; ++y)
244*b1cdbd2cSJim Jagielski {
245*b1cdbd2cSJim Jagielski p = imgStr->getLine();
246*b1cdbd2cSJim Jagielski for( int x=0; x<width; ++x)
247*b1cdbd2cSJim Jagielski {
248*b1cdbd2cSJim Jagielski colorMap->getRGB(p, &rgb);
249*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(colToByte(rgb.r));
250*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(colToByte(rgb.g));
251*b1cdbd2cSJim Jagielski o_rOutputBuf.push_back(colToByte(rgb.b));
252*b1cdbd2cSJim Jagielski
253*b1cdbd2cSJim Jagielski p +=colorMap->getNumPixelComps();
254*b1cdbd2cSJim Jagielski }
255*b1cdbd2cSJim Jagielski }
256*b1cdbd2cSJim Jagielski
257*b1cdbd2cSJim Jagielski delete imgStr;
258*b1cdbd2cSJim Jagielski
259*b1cdbd2cSJim Jagielski }
260*b1cdbd2cSJim Jagielski
261*b1cdbd2cSJim Jagielski // call this only for 1 bit image streams !
writePng_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxRGB & zeroColor,GfxRGB & oneColor,bool bIsMask,bool bWithLinefeed)262*b1cdbd2cSJim Jagielski void writePng_( OutputBuffer& o_rOutputBuf,
263*b1cdbd2cSJim Jagielski Stream* str,
264*b1cdbd2cSJim Jagielski int width,
265*b1cdbd2cSJim Jagielski int height,
266*b1cdbd2cSJim Jagielski GfxRGB& zeroColor,
267*b1cdbd2cSJim Jagielski GfxRGB& oneColor,
268*b1cdbd2cSJim Jagielski bool bIsMask,
269*b1cdbd2cSJim Jagielski bool bWithLinefeed )
270*b1cdbd2cSJim Jagielski {
271*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
272*b1cdbd2cSJim Jagielski
273*b1cdbd2cSJim Jagielski // get png image
274*b1cdbd2cSJim Jagielski PngHelper::createPng( o_rOutputBuf, str, width, height, zeroColor, oneColor, bIsMask );
275*b1cdbd2cSJim Jagielski
276*b1cdbd2cSJim Jagielski printf( " PNG %d", (int)o_rOutputBuf.size() );
277*b1cdbd2cSJim Jagielski if( bWithLinefeed )
278*b1cdbd2cSJim Jagielski printf("\n");
279*b1cdbd2cSJim Jagielski }
280*b1cdbd2cSJim Jagielski
writePng_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap,Stream * maskStr,int maskWidth,int maskHeight,GfxImageColorMap * maskColorMap,bool bWithLinefeed)281*b1cdbd2cSJim Jagielski void writePng_( OutputBuffer& o_rOutputBuf,
282*b1cdbd2cSJim Jagielski Stream* str,
283*b1cdbd2cSJim Jagielski int width, int height, GfxImageColorMap* colorMap,
284*b1cdbd2cSJim Jagielski Stream* maskStr,
285*b1cdbd2cSJim Jagielski int maskWidth, int maskHeight, GfxImageColorMap* maskColorMap,
286*b1cdbd2cSJim Jagielski bool bWithLinefeed )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
289*b1cdbd2cSJim Jagielski
290*b1cdbd2cSJim Jagielski // get png image
291*b1cdbd2cSJim Jagielski PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap );
292*b1cdbd2cSJim Jagielski
293*b1cdbd2cSJim Jagielski printf( " PNG %d", (int)o_rOutputBuf.size() );
294*b1cdbd2cSJim Jagielski if( bWithLinefeed )
295*b1cdbd2cSJim Jagielski printf("\n");
296*b1cdbd2cSJim Jagielski }
297*b1cdbd2cSJim Jagielski
writePng_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap,Stream * maskStr,int maskWidth,int maskHeight,bool maskInvert,bool bWithLinefeed)298*b1cdbd2cSJim Jagielski void writePng_( OutputBuffer& o_rOutputBuf,
299*b1cdbd2cSJim Jagielski Stream* str,
300*b1cdbd2cSJim Jagielski int width, int height, GfxImageColorMap* colorMap,
301*b1cdbd2cSJim Jagielski Stream* maskStr,
302*b1cdbd2cSJim Jagielski int maskWidth, int maskHeight, bool maskInvert,
303*b1cdbd2cSJim Jagielski bool bWithLinefeed )
304*b1cdbd2cSJim Jagielski {
305*b1cdbd2cSJim Jagielski o_rOutputBuf.clear();
306*b1cdbd2cSJim Jagielski
307*b1cdbd2cSJim Jagielski // get png image
308*b1cdbd2cSJim Jagielski PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert );
309*b1cdbd2cSJim Jagielski
310*b1cdbd2cSJim Jagielski printf( " PNG %d", (int)o_rOutputBuf.size() );
311*b1cdbd2cSJim Jagielski if( bWithLinefeed )
312*b1cdbd2cSJim Jagielski printf("\n");
313*b1cdbd2cSJim Jagielski }
314*b1cdbd2cSJim Jagielski
315*b1cdbd2cSJim Jagielski // stolen from ImageOutputDev.cc
writeMask_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,bool bWithLinefeed,bool bInvert)316*b1cdbd2cSJim Jagielski void writeMask_( OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bWithLinefeed, bool bInvert )
317*b1cdbd2cSJim Jagielski {
318*b1cdbd2cSJim Jagielski if( str->getKind() == strDCT )
319*b1cdbd2cSJim Jagielski writeJpeg_(o_rOutputBuf, str, bWithLinefeed);
320*b1cdbd2cSJim Jagielski else
321*b1cdbd2cSJim Jagielski writePbm_(o_rOutputBuf, str, width, height, bWithLinefeed, bInvert );
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
writeImage_(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap,bool bWithLinefeed)324*b1cdbd2cSJim Jagielski void writeImage_( OutputBuffer& o_rOutputBuf,
325*b1cdbd2cSJim Jagielski Stream* str,
326*b1cdbd2cSJim Jagielski int width,
327*b1cdbd2cSJim Jagielski int height,
328*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap,
329*b1cdbd2cSJim Jagielski bool bWithLinefeed )
330*b1cdbd2cSJim Jagielski {
331*b1cdbd2cSJim Jagielski // dump JPEG file
332*b1cdbd2cSJim Jagielski if( str->getKind() == strDCT &&
333*b1cdbd2cSJim Jagielski (colorMap->getNumPixelComps() == 1 ||
334*b1cdbd2cSJim Jagielski colorMap->getNumPixelComps() == 3) )
335*b1cdbd2cSJim Jagielski {
336*b1cdbd2cSJim Jagielski writeJpeg_(o_rOutputBuf, str, bWithLinefeed);
337*b1cdbd2cSJim Jagielski }
338*b1cdbd2cSJim Jagielski else if (colorMap->getNumPixelComps() == 1 &&
339*b1cdbd2cSJim Jagielski colorMap->getBits() == 1)
340*b1cdbd2cSJim Jagielski {
341*b1cdbd2cSJim Jagielski // this is a two color bitmap, write a png
342*b1cdbd2cSJim Jagielski // provide default colors
343*b1cdbd2cSJim Jagielski GfxRGB zeroColor = { 0, 0, 0 },
344*b1cdbd2cSJim Jagielski oneColor = { byteToCol( 0xff ), byteToCol( 0xff ), byteToCol( 0xff ) };
345*b1cdbd2cSJim Jagielski if( colorMap->getColorSpace()->getMode() == csIndexed || colorMap->getColorSpace()->getMode() == csDeviceGray )
346*b1cdbd2cSJim Jagielski {
347*b1cdbd2cSJim Jagielski Guchar nIndex = 0;
348*b1cdbd2cSJim Jagielski colorMap->getRGB( &nIndex, &zeroColor );
349*b1cdbd2cSJim Jagielski nIndex = 1;
350*b1cdbd2cSJim Jagielski colorMap->getRGB( &nIndex, &oneColor );
351*b1cdbd2cSJim Jagielski }
352*b1cdbd2cSJim Jagielski writePng_( o_rOutputBuf, str, width, height, zeroColor, oneColor, false, bWithLinefeed );
353*b1cdbd2cSJim Jagielski }
354*b1cdbd2cSJim Jagielski else
355*b1cdbd2cSJim Jagielski writePpm_( o_rOutputBuf, str, width, height, colorMap, bWithLinefeed );
356*b1cdbd2cSJim Jagielski }
357*b1cdbd2cSJim Jagielski
358*b1cdbd2cSJim Jagielski // forwarders
359*b1cdbd2cSJim Jagielski // ------------------------------------------------------------------
360*b1cdbd2cSJim Jagielski
writeImage(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap)361*b1cdbd2cSJim Jagielski inline void writeImage( OutputBuffer& o_rOutputBuf,
362*b1cdbd2cSJim Jagielski Stream* str,
363*b1cdbd2cSJim Jagielski int width,
364*b1cdbd2cSJim Jagielski int height,
365*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap ) { writeImage_(o_rOutputBuf,str,width,height,colorMap,false); }
writeImageLF(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,GfxImageColorMap * colorMap)366*b1cdbd2cSJim Jagielski inline void writeImageLF( OutputBuffer& o_rOutputBuf,
367*b1cdbd2cSJim Jagielski Stream* str,
368*b1cdbd2cSJim Jagielski int width,
369*b1cdbd2cSJim Jagielski int height,
370*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap ) { writeImage_(o_rOutputBuf,str,width,height,colorMap,true); }
writeMask(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,bool bInvert)371*b1cdbd2cSJim Jagielski inline void writeMask( OutputBuffer& o_rOutputBuf,
372*b1cdbd2cSJim Jagielski Stream* str,
373*b1cdbd2cSJim Jagielski int width,
374*b1cdbd2cSJim Jagielski int height,
375*b1cdbd2cSJim Jagielski bool bInvert ) { writeMask_(o_rOutputBuf,str,width,height,false,bInvert); }
writeMaskLF(OutputBuffer & o_rOutputBuf,Stream * str,int width,int height,bool bInvert)376*b1cdbd2cSJim Jagielski inline void writeMaskLF( OutputBuffer& o_rOutputBuf,
377*b1cdbd2cSJim Jagielski Stream* str,
378*b1cdbd2cSJim Jagielski int width,
379*b1cdbd2cSJim Jagielski int height,
380*b1cdbd2cSJim Jagielski bool bInvert ) { writeMask_(o_rOutputBuf,str,width,height,true,bInvert); }
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski // ------------------------------------------------------------------
383*b1cdbd2cSJim Jagielski
384*b1cdbd2cSJim Jagielski
parseFont(long long nNewId,GfxFont * gfxFont,GfxState * state) const385*b1cdbd2cSJim Jagielski int PDFOutDev::parseFont( long long nNewId, GfxFont* gfxFont, GfxState* state ) const
386*b1cdbd2cSJim Jagielski {
387*b1cdbd2cSJim Jagielski FontAttributes aNewFont;
388*b1cdbd2cSJim Jagielski int nSize = 0;
389*b1cdbd2cSJim Jagielski
390*b1cdbd2cSJim Jagielski GooString* pFamily = gfxFont->getName();
391*b1cdbd2cSJim Jagielski if( ! pFamily )
392*b1cdbd2cSJim Jagielski pFamily = gfxFont->getOrigName();
393*b1cdbd2cSJim Jagielski if( pFamily )
394*b1cdbd2cSJim Jagielski {
395*b1cdbd2cSJim Jagielski aNewFont.familyName.clear();
396*b1cdbd2cSJim Jagielski aNewFont.familyName.append( gfxFont->getName() );
397*b1cdbd2cSJim Jagielski }
398*b1cdbd2cSJim Jagielski else
399*b1cdbd2cSJim Jagielski {
400*b1cdbd2cSJim Jagielski aNewFont.familyName.clear();
401*b1cdbd2cSJim Jagielski aNewFont.familyName.append( "Arial" );
402*b1cdbd2cSJim Jagielski }
403*b1cdbd2cSJim Jagielski
404*b1cdbd2cSJim Jagielski aNewFont.isBold = gfxFont->isBold();
405*b1cdbd2cSJim Jagielski aNewFont.isItalic = gfxFont->isItalic();
406*b1cdbd2cSJim Jagielski aNewFont.size = state->getTransformedFontSize();
407*b1cdbd2cSJim Jagielski aNewFont.isUnderline = false;
408*b1cdbd2cSJim Jagielski
409*b1cdbd2cSJim Jagielski if( gfxFont->getType() == fontTrueType || gfxFont->getType() == fontType1 )
410*b1cdbd2cSJim Jagielski {
411*b1cdbd2cSJim Jagielski // TODO(P3): Unfortunately, need to read stream twice, since
412*b1cdbd2cSJim Jagielski // we must write byte count to stdout before
413*b1cdbd2cSJim Jagielski char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
414*b1cdbd2cSJim Jagielski if( pBuf )
415*b1cdbd2cSJim Jagielski aNewFont.isEmbedded = true;
416*b1cdbd2cSJim Jagielski }
417*b1cdbd2cSJim Jagielski
418*b1cdbd2cSJim Jagielski m_aFontMap[ nNewId ] = aNewFont;
419*b1cdbd2cSJim Jagielski return nSize;
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski
writeFontFile(GfxFont * gfxFont) const422*b1cdbd2cSJim Jagielski void PDFOutDev::writeFontFile( GfxFont* gfxFont ) const
423*b1cdbd2cSJim Jagielski {
424*b1cdbd2cSJim Jagielski if( gfxFont->getType() != fontTrueType && gfxFont->getType() != fontType1 )
425*b1cdbd2cSJim Jagielski return;
426*b1cdbd2cSJim Jagielski
427*b1cdbd2cSJim Jagielski int nSize = 0;
428*b1cdbd2cSJim Jagielski char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
429*b1cdbd2cSJim Jagielski if( !pBuf )
430*b1cdbd2cSJim Jagielski return;
431*b1cdbd2cSJim Jagielski
432*b1cdbd2cSJim Jagielski // ---sync point--- see SYNC STREAMS above
433*b1cdbd2cSJim Jagielski fflush(stdout);
434*b1cdbd2cSJim Jagielski
435*b1cdbd2cSJim Jagielski if( fwrite(pBuf, sizeof(char), nSize, g_binary_out) != (size_t)nSize )
436*b1cdbd2cSJim Jagielski exit(1); // error
437*b1cdbd2cSJim Jagielski
438*b1cdbd2cSJim Jagielski // ---sync point--- see SYNC STREAMS above
439*b1cdbd2cSJim Jagielski fflush(g_binary_out);
440*b1cdbd2cSJim Jagielski }
441*b1cdbd2cSJim Jagielski
printPath(GfxPath * pPath) const442*b1cdbd2cSJim Jagielski void PDFOutDev::printPath( GfxPath* pPath ) const
443*b1cdbd2cSJim Jagielski {
444*b1cdbd2cSJim Jagielski int nSubPaths = pPath ? pPath->getNumSubpaths() : 0;
445*b1cdbd2cSJim Jagielski for( int i=0; i<nSubPaths; i++ )
446*b1cdbd2cSJim Jagielski {
447*b1cdbd2cSJim Jagielski GfxSubpath* pSub = pPath->getSubpath( i );
448*b1cdbd2cSJim Jagielski const int nPoints = pSub->getNumPoints();
449*b1cdbd2cSJim Jagielski
450*b1cdbd2cSJim Jagielski printf( " subpath %d", pSub->isClosed() );
451*b1cdbd2cSJim Jagielski
452*b1cdbd2cSJim Jagielski for( int n=0; n<nPoints; ++n )
453*b1cdbd2cSJim Jagielski {
454*b1cdbd2cSJim Jagielski printf( " %f %f %d",
455*b1cdbd2cSJim Jagielski normalize(pSub->getX(n)),
456*b1cdbd2cSJim Jagielski normalize(pSub->getY(n)),
457*b1cdbd2cSJim Jagielski pSub->getCurve(n) );
458*b1cdbd2cSJim Jagielski }
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski }
461*b1cdbd2cSJim Jagielski
PDFOutDev(PDFDoc * pDoc)462*b1cdbd2cSJim Jagielski PDFOutDev::PDFOutDev( PDFDoc* pDoc ) :
463*b1cdbd2cSJim Jagielski m_pDoc( pDoc ),
464*b1cdbd2cSJim Jagielski m_aFontMap(),
465*b1cdbd2cSJim Jagielski m_pUtf8Map( new UnicodeMap((char*)"UTF-8", gTrue, &mapUTF8) )
466*b1cdbd2cSJim Jagielski {
467*b1cdbd2cSJim Jagielski }
468*b1cdbd2cSJim Jagielski
startPage(int,GfxState * state)469*b1cdbd2cSJim Jagielski void PDFOutDev::startPage(int /*pageNum*/, GfxState* state)
470*b1cdbd2cSJim Jagielski {
471*b1cdbd2cSJim Jagielski assert(state);
472*b1cdbd2cSJim Jagielski printf("startPage %f %f\n",
473*b1cdbd2cSJim Jagielski normalize(state->getPageWidth()),
474*b1cdbd2cSJim Jagielski normalize(state->getPageHeight()));
475*b1cdbd2cSJim Jagielski }
476*b1cdbd2cSJim Jagielski
endPage()477*b1cdbd2cSJim Jagielski void PDFOutDev::endPage()
478*b1cdbd2cSJim Jagielski {
479*b1cdbd2cSJim Jagielski printf("endPage\n");
480*b1cdbd2cSJim Jagielski }
481*b1cdbd2cSJim Jagielski
processLink(Link * link,Catalog *)482*b1cdbd2cSJim Jagielski void PDFOutDev::processLink(Link* link, Catalog*)
483*b1cdbd2cSJim Jagielski {
484*b1cdbd2cSJim Jagielski assert(link);
485*b1cdbd2cSJim Jagielski
486*b1cdbd2cSJim Jagielski double x1,x2,y1,y2;
487*b1cdbd2cSJim Jagielski link->getRect( &x1, &y1, &x2, &y2 );
488*b1cdbd2cSJim Jagielski
489*b1cdbd2cSJim Jagielski LinkAction* pAction = link->getAction();
490*b1cdbd2cSJim Jagielski if( pAction->getKind() == actionURI )
491*b1cdbd2cSJim Jagielski {
492*b1cdbd2cSJim Jagielski const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->getCString();
493*b1cdbd2cSJim Jagielski
494*b1cdbd2cSJim Jagielski boost::shared_array<char> pEsc( lcl_escapeLineFeeds(pURI) );
495*b1cdbd2cSJim Jagielski
496*b1cdbd2cSJim Jagielski printf( "drawLink %f %f %f %f %s\n",
497*b1cdbd2cSJim Jagielski normalize(x1),
498*b1cdbd2cSJim Jagielski normalize(y1),
499*b1cdbd2cSJim Jagielski normalize(x2),
500*b1cdbd2cSJim Jagielski normalize(y2),
501*b1cdbd2cSJim Jagielski pEsc.get() );
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski }
504*b1cdbd2cSJim Jagielski
saveState(GfxState *)505*b1cdbd2cSJim Jagielski void PDFOutDev::saveState(GfxState*)
506*b1cdbd2cSJim Jagielski {
507*b1cdbd2cSJim Jagielski printf( "saveState\n" );
508*b1cdbd2cSJim Jagielski }
509*b1cdbd2cSJim Jagielski
restoreState(GfxState *)510*b1cdbd2cSJim Jagielski void PDFOutDev::restoreState(GfxState*)
511*b1cdbd2cSJim Jagielski {
512*b1cdbd2cSJim Jagielski printf( "restoreState\n" );
513*b1cdbd2cSJim Jagielski }
514*b1cdbd2cSJim Jagielski
setDefaultCTM(double * pMat)515*b1cdbd2cSJim Jagielski void PDFOutDev::setDefaultCTM(double *pMat)
516*b1cdbd2cSJim Jagielski {
517*b1cdbd2cSJim Jagielski assert(pMat);
518*b1cdbd2cSJim Jagielski
519*b1cdbd2cSJim Jagielski OutputDev::setDefaultCTM(pMat);
520*b1cdbd2cSJim Jagielski
521*b1cdbd2cSJim Jagielski printf( "updateCtm %f %f %f %f %f %f\n",
522*b1cdbd2cSJim Jagielski normalize(pMat[0]),
523*b1cdbd2cSJim Jagielski normalize(pMat[2]),
524*b1cdbd2cSJim Jagielski normalize(pMat[1]),
525*b1cdbd2cSJim Jagielski normalize(pMat[3]),
526*b1cdbd2cSJim Jagielski normalize(pMat[4]),
527*b1cdbd2cSJim Jagielski normalize(pMat[5]) );
528*b1cdbd2cSJim Jagielski }
529*b1cdbd2cSJim Jagielski
updateCTM(GfxState * state,double,double,double,double,double,double)530*b1cdbd2cSJim Jagielski void PDFOutDev::updateCTM(GfxState* state,
531*b1cdbd2cSJim Jagielski double, double,
532*b1cdbd2cSJim Jagielski double, double,
533*b1cdbd2cSJim Jagielski double, double)
534*b1cdbd2cSJim Jagielski {
535*b1cdbd2cSJim Jagielski assert(state);
536*b1cdbd2cSJim Jagielski
537*b1cdbd2cSJim Jagielski const double* const pMat = state->getCTM();
538*b1cdbd2cSJim Jagielski assert(pMat);
539*b1cdbd2cSJim Jagielski
540*b1cdbd2cSJim Jagielski printf( "updateCtm %f %f %f %f %f %f\n",
541*b1cdbd2cSJim Jagielski normalize(pMat[0]),
542*b1cdbd2cSJim Jagielski normalize(pMat[2]),
543*b1cdbd2cSJim Jagielski normalize(pMat[1]),
544*b1cdbd2cSJim Jagielski normalize(pMat[3]),
545*b1cdbd2cSJim Jagielski normalize(pMat[4]),
546*b1cdbd2cSJim Jagielski normalize(pMat[5]) );
547*b1cdbd2cSJim Jagielski }
548*b1cdbd2cSJim Jagielski
updateLineDash(GfxState * state)549*b1cdbd2cSJim Jagielski void PDFOutDev::updateLineDash(GfxState *state)
550*b1cdbd2cSJim Jagielski {
551*b1cdbd2cSJim Jagielski assert(state);
552*b1cdbd2cSJim Jagielski
553*b1cdbd2cSJim Jagielski double* dashArray; int arrayLen; double startOffset;
554*b1cdbd2cSJim Jagielski state->getLineDash(&dashArray, &arrayLen, &startOffset);
555*b1cdbd2cSJim Jagielski
556*b1cdbd2cSJim Jagielski printf( "updateLineDash" );
557*b1cdbd2cSJim Jagielski if( arrayLen && dashArray )
558*b1cdbd2cSJim Jagielski {
559*b1cdbd2cSJim Jagielski printf( " %f %d", normalize(startOffset), arrayLen );
560*b1cdbd2cSJim Jagielski for( int i=0; i<arrayLen; ++i )
561*b1cdbd2cSJim Jagielski printf( " %f", normalize(*dashArray++) );
562*b1cdbd2cSJim Jagielski }
563*b1cdbd2cSJim Jagielski printf( "\n" );
564*b1cdbd2cSJim Jagielski }
565*b1cdbd2cSJim Jagielski
updateFlatness(GfxState * state)566*b1cdbd2cSJim Jagielski void PDFOutDev::updateFlatness(GfxState *state)
567*b1cdbd2cSJim Jagielski {
568*b1cdbd2cSJim Jagielski assert(state);
569*b1cdbd2cSJim Jagielski printf( "updateFlatness %d\n", state->getFlatness() );
570*b1cdbd2cSJim Jagielski }
571*b1cdbd2cSJim Jagielski
updateLineJoin(GfxState * state)572*b1cdbd2cSJim Jagielski void PDFOutDev::updateLineJoin(GfxState *state)
573*b1cdbd2cSJim Jagielski {
574*b1cdbd2cSJim Jagielski assert(state);
575*b1cdbd2cSJim Jagielski printf( "updateLineJoin %d\n", state->getLineJoin() );
576*b1cdbd2cSJim Jagielski }
577*b1cdbd2cSJim Jagielski
updateLineCap(GfxState * state)578*b1cdbd2cSJim Jagielski void PDFOutDev::updateLineCap(GfxState *state)
579*b1cdbd2cSJim Jagielski {
580*b1cdbd2cSJim Jagielski assert(state);
581*b1cdbd2cSJim Jagielski printf( "updateLineCap %d\n", state->getLineCap() );
582*b1cdbd2cSJim Jagielski }
583*b1cdbd2cSJim Jagielski
updateMiterLimit(GfxState * state)584*b1cdbd2cSJim Jagielski void PDFOutDev::updateMiterLimit(GfxState *state)
585*b1cdbd2cSJim Jagielski {
586*b1cdbd2cSJim Jagielski assert(state);
587*b1cdbd2cSJim Jagielski printf( "updateMiterLimit %f\n", normalize(state->getMiterLimit()) );
588*b1cdbd2cSJim Jagielski }
589*b1cdbd2cSJim Jagielski
updateLineWidth(GfxState * state)590*b1cdbd2cSJim Jagielski void PDFOutDev::updateLineWidth(GfxState *state)
591*b1cdbd2cSJim Jagielski {
592*b1cdbd2cSJim Jagielski assert(state);
593*b1cdbd2cSJim Jagielski printf( "updateLineWidth %f\n", normalize(state->getLineWidth()) );
594*b1cdbd2cSJim Jagielski }
595*b1cdbd2cSJim Jagielski
updateFillColor(GfxState * state)596*b1cdbd2cSJim Jagielski void PDFOutDev::updateFillColor(GfxState *state)
597*b1cdbd2cSJim Jagielski {
598*b1cdbd2cSJim Jagielski assert(state);
599*b1cdbd2cSJim Jagielski
600*b1cdbd2cSJim Jagielski GfxRGB aRGB;
601*b1cdbd2cSJim Jagielski state->getFillRGB( &aRGB );
602*b1cdbd2cSJim Jagielski
603*b1cdbd2cSJim Jagielski printf( "updateFillColor %f %f %f %f\n",
604*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.r)),
605*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.g)),
606*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.b)),
607*b1cdbd2cSJim Jagielski normalize(state->getFillOpacity()) );
608*b1cdbd2cSJim Jagielski }
609*b1cdbd2cSJim Jagielski
updateStrokeColor(GfxState * state)610*b1cdbd2cSJim Jagielski void PDFOutDev::updateStrokeColor(GfxState *state)
611*b1cdbd2cSJim Jagielski {
612*b1cdbd2cSJim Jagielski assert(state);
613*b1cdbd2cSJim Jagielski
614*b1cdbd2cSJim Jagielski GfxRGB aRGB;
615*b1cdbd2cSJim Jagielski state->getStrokeRGB( &aRGB );
616*b1cdbd2cSJim Jagielski
617*b1cdbd2cSJim Jagielski printf( "updateStrokeColor %f %f %f %f\n",
618*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.r)),
619*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.g)),
620*b1cdbd2cSJim Jagielski normalize(colToDbl(aRGB.b)),
621*b1cdbd2cSJim Jagielski normalize(state->getFillOpacity()) );
622*b1cdbd2cSJim Jagielski }
623*b1cdbd2cSJim Jagielski
updateFillOpacity(GfxState * state)624*b1cdbd2cSJim Jagielski void PDFOutDev::updateFillOpacity(GfxState *state)
625*b1cdbd2cSJim Jagielski {
626*b1cdbd2cSJim Jagielski updateFillColor(state);
627*b1cdbd2cSJim Jagielski }
628*b1cdbd2cSJim Jagielski
updateStrokeOpacity(GfxState * state)629*b1cdbd2cSJim Jagielski void PDFOutDev::updateStrokeOpacity(GfxState *state)
630*b1cdbd2cSJim Jagielski {
631*b1cdbd2cSJim Jagielski updateStrokeColor(state);
632*b1cdbd2cSJim Jagielski }
633*b1cdbd2cSJim Jagielski
updateBlendMode(GfxState *)634*b1cdbd2cSJim Jagielski void PDFOutDev::updateBlendMode(GfxState*)
635*b1cdbd2cSJim Jagielski {
636*b1cdbd2cSJim Jagielski }
637*b1cdbd2cSJim Jagielski
updateFont(GfxState * state)638*b1cdbd2cSJim Jagielski void PDFOutDev::updateFont(GfxState *state)
639*b1cdbd2cSJim Jagielski {
640*b1cdbd2cSJim Jagielski assert(state);
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski GfxFont *gfxFont = state->getFont();
643*b1cdbd2cSJim Jagielski if( gfxFont )
644*b1cdbd2cSJim Jagielski {
645*b1cdbd2cSJim Jagielski FontAttributes aFont;
646*b1cdbd2cSJim Jagielski int nEmbedSize=0;
647*b1cdbd2cSJim Jagielski
648*b1cdbd2cSJim Jagielski Ref* pID = gfxFont->getID();
649*b1cdbd2cSJim Jagielski // TODO(Q3): Portability problem
650*b1cdbd2cSJim Jagielski long long fontID = (long long)pID->gen << 32 | (long long)pID->num;
651*b1cdbd2cSJim Jagielski std::hash_map< long long, FontAttributes >::const_iterator it =
652*b1cdbd2cSJim Jagielski m_aFontMap.find( fontID );
653*b1cdbd2cSJim Jagielski if( it == m_aFontMap.end() )
654*b1cdbd2cSJim Jagielski {
655*b1cdbd2cSJim Jagielski nEmbedSize = parseFont( fontID, gfxFont, state );
656*b1cdbd2cSJim Jagielski it = m_aFontMap.find( fontID );
657*b1cdbd2cSJim Jagielski }
658*b1cdbd2cSJim Jagielski
659*b1cdbd2cSJim Jagielski printf( "updateFont" );
660*b1cdbd2cSJim Jagielski if( it != m_aFontMap.end() )
661*b1cdbd2cSJim Jagielski {
662*b1cdbd2cSJim Jagielski // conflating this with printf below crashes under Windoze
663*b1cdbd2cSJim Jagielski printf( " %lld", fontID );
664*b1cdbd2cSJim Jagielski
665*b1cdbd2cSJim Jagielski aFont = it->second;
666*b1cdbd2cSJim Jagielski
667*b1cdbd2cSJim Jagielski boost::shared_array<char> pEsc( lcl_escapeLineFeeds(aFont.familyName.getCString()) );
668*b1cdbd2cSJim Jagielski printf( " %d %d %d %d %f %d %s",
669*b1cdbd2cSJim Jagielski aFont.isEmbedded,
670*b1cdbd2cSJim Jagielski aFont.isBold,
671*b1cdbd2cSJim Jagielski aFont.isItalic,
672*b1cdbd2cSJim Jagielski aFont.isUnderline,
673*b1cdbd2cSJim Jagielski normalize(state->getTransformedFontSize()),
674*b1cdbd2cSJim Jagielski nEmbedSize,
675*b1cdbd2cSJim Jagielski pEsc.get() );
676*b1cdbd2cSJim Jagielski }
677*b1cdbd2cSJim Jagielski printf( "\n" );
678*b1cdbd2cSJim Jagielski
679*b1cdbd2cSJim Jagielski if( nEmbedSize )
680*b1cdbd2cSJim Jagielski writeFontFile(gfxFont);
681*b1cdbd2cSJim Jagielski }
682*b1cdbd2cSJim Jagielski }
683*b1cdbd2cSJim Jagielski
updateRender(GfxState * state)684*b1cdbd2cSJim Jagielski void PDFOutDev::updateRender(GfxState *state)
685*b1cdbd2cSJim Jagielski {
686*b1cdbd2cSJim Jagielski assert(state);
687*b1cdbd2cSJim Jagielski
688*b1cdbd2cSJim Jagielski printf( "setTextRenderMode %d\n", state->getRender() );
689*b1cdbd2cSJim Jagielski }
690*b1cdbd2cSJim Jagielski
stroke(GfxState * state)691*b1cdbd2cSJim Jagielski void PDFOutDev::stroke(GfxState *state)
692*b1cdbd2cSJim Jagielski {
693*b1cdbd2cSJim Jagielski assert(state);
694*b1cdbd2cSJim Jagielski
695*b1cdbd2cSJim Jagielski printf( "strokePath" );
696*b1cdbd2cSJim Jagielski printPath( state->getPath() );
697*b1cdbd2cSJim Jagielski printf( "\n" );
698*b1cdbd2cSJim Jagielski }
699*b1cdbd2cSJim Jagielski
fill(GfxState * state)700*b1cdbd2cSJim Jagielski void PDFOutDev::fill(GfxState *state)
701*b1cdbd2cSJim Jagielski {
702*b1cdbd2cSJim Jagielski assert(state);
703*b1cdbd2cSJim Jagielski
704*b1cdbd2cSJim Jagielski printf( "fillPath" );
705*b1cdbd2cSJim Jagielski printPath( state->getPath() );
706*b1cdbd2cSJim Jagielski printf( "\n" );
707*b1cdbd2cSJim Jagielski }
708*b1cdbd2cSJim Jagielski
eoFill(GfxState * state)709*b1cdbd2cSJim Jagielski void PDFOutDev::eoFill(GfxState *state)
710*b1cdbd2cSJim Jagielski {
711*b1cdbd2cSJim Jagielski assert(state);
712*b1cdbd2cSJim Jagielski
713*b1cdbd2cSJim Jagielski printf( "eoFillPath" );
714*b1cdbd2cSJim Jagielski printPath( state->getPath() );
715*b1cdbd2cSJim Jagielski printf( "\n" );
716*b1cdbd2cSJim Jagielski }
717*b1cdbd2cSJim Jagielski
clip(GfxState * state)718*b1cdbd2cSJim Jagielski void PDFOutDev::clip(GfxState *state)
719*b1cdbd2cSJim Jagielski {
720*b1cdbd2cSJim Jagielski assert(state);
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski printf( "clipPath" );
723*b1cdbd2cSJim Jagielski printPath( state->getPath() );
724*b1cdbd2cSJim Jagielski printf( "\n" );
725*b1cdbd2cSJim Jagielski }
726*b1cdbd2cSJim Jagielski
eoClip(GfxState * state)727*b1cdbd2cSJim Jagielski void PDFOutDev::eoClip(GfxState *state)
728*b1cdbd2cSJim Jagielski {
729*b1cdbd2cSJim Jagielski assert(state);
730*b1cdbd2cSJim Jagielski
731*b1cdbd2cSJim Jagielski printf( "eoClipPath" );
732*b1cdbd2cSJim Jagielski printPath( state->getPath() );
733*b1cdbd2cSJim Jagielski printf( "\n" );
734*b1cdbd2cSJim Jagielski }
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski /** Output one glyph
737*b1cdbd2cSJim Jagielski
738*b1cdbd2cSJim Jagielski
739*b1cdbd2cSJim Jagielski @param dx
740*b1cdbd2cSJim Jagielski horizontal skip for character (already scaled with font size) +
741*b1cdbd2cSJim Jagielski inter-char space: cursor is shifted by this amount for next char
742*b1cdbd2cSJim Jagielski
743*b1cdbd2cSJim Jagielski @param dy
744*b1cdbd2cSJim Jagielski vertical skip for character (zero for horizontal writing mode):
745*b1cdbd2cSJim Jagielski cursor is shifted by this amount for next char
746*b1cdbd2cSJim Jagielski
747*b1cdbd2cSJim Jagielski @param originX
748*b1cdbd2cSJim Jagielski local offset of character (zero for horizontal writing mode). not
749*b1cdbd2cSJim Jagielski taken into account for output pos updates. Used for vertical writing.
750*b1cdbd2cSJim Jagielski
751*b1cdbd2cSJim Jagielski @param originY
752*b1cdbd2cSJim Jagielski local offset of character (zero for horizontal writing mode). not
753*b1cdbd2cSJim Jagielski taken into account for output pos updates. Used for vertical writing.
754*b1cdbd2cSJim Jagielski */
drawChar(GfxState * state,double x,double y,double dx,double dy,double originX,double originY,CharCode,int,Unicode * u,int uLen)755*b1cdbd2cSJim Jagielski void PDFOutDev::drawChar(GfxState *state, double x, double y,
756*b1cdbd2cSJim Jagielski double dx, double dy,
757*b1cdbd2cSJim Jagielski double originX, double originY,
758*b1cdbd2cSJim Jagielski CharCode, int /*nBytes*/, Unicode *u, int uLen)
759*b1cdbd2cSJim Jagielski {
760*b1cdbd2cSJim Jagielski assert(state);
761*b1cdbd2cSJim Jagielski
762*b1cdbd2cSJim Jagielski if( u == NULL )
763*b1cdbd2cSJim Jagielski return;
764*b1cdbd2cSJim Jagielski
765*b1cdbd2cSJim Jagielski // normalize coordinates: correct from baseline-relative to upper
766*b1cdbd2cSJim Jagielski // left corner of glyphs
767*b1cdbd2cSJim Jagielski double x2(0.0), y2(0.0);
768*b1cdbd2cSJim Jagielski state->textTransformDelta( 0.0,
769*b1cdbd2cSJim Jagielski state->getFont()->getAscent(),
770*b1cdbd2cSJim Jagielski &x2, &y2 );
771*b1cdbd2cSJim Jagielski const double fFontSize(state->getFontSize());
772*b1cdbd2cSJim Jagielski x += x2*fFontSize;
773*b1cdbd2cSJim Jagielski y += y2*fFontSize;
774*b1cdbd2cSJim Jagielski
775*b1cdbd2cSJim Jagielski const double aPositionX(x-originX);
776*b1cdbd2cSJim Jagielski const double aPositionY(y-originY);
777*b1cdbd2cSJim Jagielski // TODO(F2): use leading here, when set
778*b1cdbd2cSJim Jagielski const double nWidth(dx != 0.0 ? dx : fFontSize);
779*b1cdbd2cSJim Jagielski const double nHeight(dy != 0.0 ? dy : fFontSize);
780*b1cdbd2cSJim Jagielski
781*b1cdbd2cSJim Jagielski const double* pTextMat=state->getTextMat();
782*b1cdbd2cSJim Jagielski printf( "drawChar %f %f %f %f %f %f %f %f ",
783*b1cdbd2cSJim Jagielski normalize(aPositionX),
784*b1cdbd2cSJim Jagielski normalize(aPositionY),
785*b1cdbd2cSJim Jagielski normalize(aPositionX+nWidth),
786*b1cdbd2cSJim Jagielski normalize(aPositionY-nHeight),
787*b1cdbd2cSJim Jagielski normalize(pTextMat[0]),
788*b1cdbd2cSJim Jagielski normalize(pTextMat[2]),
789*b1cdbd2cSJim Jagielski normalize(pTextMat[1]),
790*b1cdbd2cSJim Jagielski normalize(pTextMat[3]) );
791*b1cdbd2cSJim Jagielski
792*b1cdbd2cSJim Jagielski // silence spurious warning
793*b1cdbd2cSJim Jagielski (void)&mapUCS2;
794*b1cdbd2cSJim Jagielski
795*b1cdbd2cSJim Jagielski char buf[9];
796*b1cdbd2cSJim Jagielski for( int i=0; i<uLen; ++i )
797*b1cdbd2cSJim Jagielski {
798*b1cdbd2cSJim Jagielski buf[ m_pUtf8Map->mapUnicode(u[i], buf, sizeof(buf)-1) ] = 0;
799*b1cdbd2cSJim Jagielski boost::shared_array<char> pEsc( lcl_escapeLineFeeds(buf) );
800*b1cdbd2cSJim Jagielski printf( "%s", pEsc.get() );
801*b1cdbd2cSJim Jagielski }
802*b1cdbd2cSJim Jagielski
803*b1cdbd2cSJim Jagielski printf( "\n" );
804*b1cdbd2cSJim Jagielski }
805*b1cdbd2cSJim Jagielski
drawString(GfxState *,GooString *)806*b1cdbd2cSJim Jagielski void PDFOutDev::drawString(GfxState*, GooString* /*s*/)
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski // TODO(F3): NYI
809*b1cdbd2cSJim Jagielski }
810*b1cdbd2cSJim Jagielski
endTextObject(GfxState *)811*b1cdbd2cSJim Jagielski void PDFOutDev::endTextObject(GfxState*)
812*b1cdbd2cSJim Jagielski {
813*b1cdbd2cSJim Jagielski printf( "endTextObject\n" );
814*b1cdbd2cSJim Jagielski }
815*b1cdbd2cSJim Jagielski
drawImageMask(GfxState * pState,Object *,Stream * str,int width,int height,GBool invert,GBool)816*b1cdbd2cSJim Jagielski void PDFOutDev::drawImageMask(GfxState* pState, Object*, Stream* str,
817*b1cdbd2cSJim Jagielski int width, int height, GBool invert,
818*b1cdbd2cSJim Jagielski GBool /*inlineImg*/ )
819*b1cdbd2cSJim Jagielski {
820*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
821*b1cdbd2cSJim Jagielski
822*b1cdbd2cSJim Jagielski printf( "drawMask %d %d %d", width, height, invert );
823*b1cdbd2cSJim Jagielski
824*b1cdbd2cSJim Jagielski int bitsPerComponent = 1;
825*b1cdbd2cSJim Jagielski StreamColorSpaceMode csMode = streamCSNone;
826*b1cdbd2cSJim Jagielski str->getImageParams( &bitsPerComponent, &csMode );
827*b1cdbd2cSJim Jagielski if( bitsPerComponent == 1 && (csMode == streamCSNone || csMode == streamCSDeviceGray) )
828*b1cdbd2cSJim Jagielski {
829*b1cdbd2cSJim Jagielski GfxRGB oneColor = { dblToCol( 1.0 ), dblToCol( 1.0 ), dblToCol( 1.0 ) };
830*b1cdbd2cSJim Jagielski GfxRGB zeroColor = { dblToCol( 0.0 ), dblToCol( 0.0 ), dblToCol( 0.0 ) };
831*b1cdbd2cSJim Jagielski pState->getFillColorSpace()->getRGB( pState->getFillColor(), &zeroColor );
832*b1cdbd2cSJim Jagielski if( invert )
833*b1cdbd2cSJim Jagielski writePng_( aBuf, str, width, height, oneColor, zeroColor, true, true );
834*b1cdbd2cSJim Jagielski else
835*b1cdbd2cSJim Jagielski writePng_( aBuf, str, width, height, zeroColor, oneColor, true, true );
836*b1cdbd2cSJim Jagielski }
837*b1cdbd2cSJim Jagielski else
838*b1cdbd2cSJim Jagielski writeMaskLF(aBuf, str, width, height, invert != 0);
839*b1cdbd2cSJim Jagielski writeBinaryBuffer(aBuf);
840*b1cdbd2cSJim Jagielski }
841*b1cdbd2cSJim Jagielski
drawImage(GfxState *,Object *,Stream * str,int width,int height,GfxImageColorMap * colorMap,int * maskColors,GBool)842*b1cdbd2cSJim Jagielski void PDFOutDev::drawImage(GfxState*, Object*, Stream* str,
843*b1cdbd2cSJim Jagielski int width, int height, GfxImageColorMap* colorMap,
844*b1cdbd2cSJim Jagielski int* maskColors, GBool /*inlineImg*/ )
845*b1cdbd2cSJim Jagielski {
846*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
847*b1cdbd2cSJim Jagielski OutputBuffer aMaskBuf;
848*b1cdbd2cSJim Jagielski
849*b1cdbd2cSJim Jagielski printf( "drawImage %d %d", width, height );
850*b1cdbd2cSJim Jagielski
851*b1cdbd2cSJim Jagielski if( maskColors )
852*b1cdbd2cSJim Jagielski {
853*b1cdbd2cSJim Jagielski // write mask colors. nBytes must be even - first half is
854*b1cdbd2cSJim Jagielski // lower bound values, second half upper bound values
855*b1cdbd2cSJim Jagielski if( colorMap->getColorSpace()->getMode() == csIndexed )
856*b1cdbd2cSJim Jagielski {
857*b1cdbd2cSJim Jagielski aMaskBuf.push_back( (char)maskColors[0] );
858*b1cdbd2cSJim Jagielski aMaskBuf.push_back( (char)maskColors[gfxColorMaxComps] );
859*b1cdbd2cSJim Jagielski }
860*b1cdbd2cSJim Jagielski else
861*b1cdbd2cSJim Jagielski {
862*b1cdbd2cSJim Jagielski GfxRGB aMinRGB;
863*b1cdbd2cSJim Jagielski colorMap->getColorSpace()->getRGB(
864*b1cdbd2cSJim Jagielski (GfxColor*)maskColors,
865*b1cdbd2cSJim Jagielski &aMinRGB );
866*b1cdbd2cSJim Jagielski
867*b1cdbd2cSJim Jagielski GfxRGB aMaxRGB;
868*b1cdbd2cSJim Jagielski colorMap->getColorSpace()->getRGB(
869*b1cdbd2cSJim Jagielski (GfxColor*)maskColors+gfxColorMaxComps,
870*b1cdbd2cSJim Jagielski &aMaxRGB );
871*b1cdbd2cSJim Jagielski
872*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMinRGB.r) );
873*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMinRGB.g) );
874*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMinRGB.b) );
875*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMaxRGB.r) );
876*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMaxRGB.g) );
877*b1cdbd2cSJim Jagielski aMaskBuf.push_back( colToByte(aMaxRGB.b) );
878*b1cdbd2cSJim Jagielski }
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski
881*b1cdbd2cSJim Jagielski printf( " %d", (int)aMaskBuf.size() );
882*b1cdbd2cSJim Jagielski writeImageLF( aBuf, str, width, height, colorMap );
883*b1cdbd2cSJim Jagielski writeBinaryBuffer(aBuf);
884*b1cdbd2cSJim Jagielski writeBinaryBuffer(aMaskBuf);
885*b1cdbd2cSJim Jagielski }
886*b1cdbd2cSJim Jagielski
drawMaskedImage(GfxState *,Object *,Stream * str,int width,int height,GfxImageColorMap * colorMap,Stream * maskStr,int maskWidth,int maskHeight,GBool maskInvert)887*b1cdbd2cSJim Jagielski void PDFOutDev::drawMaskedImage(GfxState*, Object*, Stream* str,
888*b1cdbd2cSJim Jagielski int width, int height,
889*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap,
890*b1cdbd2cSJim Jagielski Stream* maskStr,
891*b1cdbd2cSJim Jagielski int maskWidth, int maskHeight,
892*b1cdbd2cSJim Jagielski GBool maskInvert)
893*b1cdbd2cSJim Jagielski {
894*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
895*b1cdbd2cSJim Jagielski printf( "drawImage %d %d 0", width, height );
896*b1cdbd2cSJim Jagielski writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert, true );
897*b1cdbd2cSJim Jagielski writeBinaryBuffer( aBuf );
898*b1cdbd2cSJim Jagielski #if 0
899*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
900*b1cdbd2cSJim Jagielski OutputBuffer aMaskBuf; initBuf(aMaskBuf);
901*b1cdbd2cSJim Jagielski
902*b1cdbd2cSJim Jagielski printf( "drawMaskedImage %d %d %d %d %d", width, height, maskWidth, maskHeight, 0 /*maskInvert note: currently we do inversion here*/ );
903*b1cdbd2cSJim Jagielski writeImage( aBuf, str, width, height, colorMap );
904*b1cdbd2cSJim Jagielski writeMaskLF( aMaskBuf, maskStr, width, height, maskInvert );
905*b1cdbd2cSJim Jagielski writeBinaryBuffer(aBuf);
906*b1cdbd2cSJim Jagielski writeBinaryBuffer(aMaskBuf);
907*b1cdbd2cSJim Jagielski #endif
908*b1cdbd2cSJim Jagielski }
909*b1cdbd2cSJim Jagielski
drawSoftMaskedImage(GfxState *,Object *,Stream * str,int width,int height,GfxImageColorMap * colorMap,Stream * maskStr,int maskWidth,int maskHeight,GfxImageColorMap * maskColorMap)910*b1cdbd2cSJim Jagielski void PDFOutDev::drawSoftMaskedImage(GfxState*, Object*, Stream* str,
911*b1cdbd2cSJim Jagielski int width, int height,
912*b1cdbd2cSJim Jagielski GfxImageColorMap* colorMap,
913*b1cdbd2cSJim Jagielski Stream* maskStr,
914*b1cdbd2cSJim Jagielski int maskWidth, int maskHeight,
915*b1cdbd2cSJim Jagielski GfxImageColorMap* maskColorMap )
916*b1cdbd2cSJim Jagielski {
917*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
918*b1cdbd2cSJim Jagielski printf( "drawImage %d %d 0", width, height );
919*b1cdbd2cSJim Jagielski writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap, true );
920*b1cdbd2cSJim Jagielski writeBinaryBuffer( aBuf );
921*b1cdbd2cSJim Jagielski #if 0
922*b1cdbd2cSJim Jagielski OutputBuffer aBuf; initBuf(aBuf);
923*b1cdbd2cSJim Jagielski OutputBuffer aMaskBuf; initBuf(aMaskBuf);
924*b1cdbd2cSJim Jagielski
925*b1cdbd2cSJim Jagielski printf( "drawSoftMaskedImage %d %d %d %d", width, height, maskWidth, maskHeight );
926*b1cdbd2cSJim Jagielski writeImage( aBuf, str, width, height, colorMap );
927*b1cdbd2cSJim Jagielski writeImageLF( aMaskBuf, maskStr, maskWidth, maskHeight, maskColorMap );
928*b1cdbd2cSJim Jagielski writeBinaryBuffer(aBuf);
929*b1cdbd2cSJim Jagielski writeBinaryBuffer(aMaskBuf);
930*b1cdbd2cSJim Jagielski #endif
931*b1cdbd2cSJim Jagielski }
932*b1cdbd2cSJim Jagielski
setPageNum(int nNumPages)933*b1cdbd2cSJim Jagielski void PDFOutDev::setPageNum( int nNumPages )
934*b1cdbd2cSJim Jagielski {
935*b1cdbd2cSJim Jagielski // TODO(F3): printf might format int locale-dependent!
936*b1cdbd2cSJim Jagielski printf("setPageNum %d\n", nNumPages);
937*b1cdbd2cSJim Jagielski }
938*b1cdbd2cSJim Jagielski
939*b1cdbd2cSJim Jagielski }
940