added some log messages about fonts.
[swftools.git] / pdf2swf / SWFOutputDev.cc
1 /* pdfswf.cc
2    implements a pdf output device (OutputDev).
3
4    This file is part of swftools.
5
6    Swftools is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    Swftools is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with swftools; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stddef.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include "../config.h"
26 //xpdf header files
27 #include "config.h"
28 #include "gfile.h"
29 #include "GString.h"
30 #include "gmem.h"
31 #include "Object.h"
32 #include "Stream.h"
33 #include "Array.h"
34 #include "Dict.h"
35 #include "XRef.h"
36 #include "Catalog.h"
37 #include "Page.h"
38 #include "PDFDoc.h"
39 #include "Error.h"
40 #include "OutputDev.h"
41 #include "GfxState.h"
42 #include "GfxFont.h"
43 #include "CharCodeToUnicode.h"
44 #include "NameToUnicodeTable.h"
45 #include "FontFile.h"
46 #include "GlobalParams.h"
47 //swftools header files
48 #include "swfoutput.h"
49 #include "../lib/log.h"
50
51 #include <math.h>
52
53 static PDFDoc*doc = 0;
54 static char* swffilename = 0;
55 static int numpages;
56 static int currentpage;
57
58 static char*fonts[2048];
59 static int fontnum = 0;
60
61 // swf <-> pdf pages
62 static int*pages = 0;
63 static int pagebuflen = 0;
64 static int pagepos = 0;
65
66 static double caplinewidth = 3.0;
67
68 static void printInfoString(Dict *infoDict, char *key, char *fmt);
69 static void printInfoDate(Dict *infoDict, char *key, char *fmt);
70
71 static double fontsizes[] = 
72 {
73  0.833,0.833,0.889,0.889,
74  0.788,0.722,0.833,0.778,
75  0.600,0.600,0.600,0.600,
76  0.576,0.576,0.576,0.576,
77  0.733 //?
78 };
79 static char*fontnames[]={
80 "Helvetica",             
81 "Helvetica-Bold",        
82 "Helvetica-BoldOblique", 
83 "Helvetica-Oblique",     
84 "Times-Roman",           
85 "Times-Bold",            
86 "Times-BoldItalic",      
87 "Times-Italic",          
88 "Courier",               
89 "Courier-Bold",          
90 "Courier-BoldOblique",   
91 "Courier-Oblique",       
92 "Symbol",                
93 "Symbol",                
94 "Symbol",                
95 "Symbol",
96 "ZapfDingBats"
97 };
98
99 struct mapping {
100     char*pdffont;
101     char*filename;
102     int id;
103 } pdf2t1map[] ={
104 {"Times-Roman",           "n021003l"},
105 {"Times-Italic",          "n021023l"},
106 {"Times-Bold",            "n021004l"},
107 {"Times-BoldItalic",      "n021024l"},
108 {"Helvetica",             "n019003l"},
109 {"Helvetica-Oblique",     "n019023l"},
110 {"Helvetica-Bold",        "n019004l"},
111 {"Helvetica-BoldOblique", "n019024l"},
112 {"Courier",               "n022003l"},
113 {"Courier-Oblique",       "n022023l"},
114 {"Courier-Bold",          "n022004l"},
115 {"Courier-BoldOblique",   "n022024l"},
116 {"Symbol",                "s050000l"},
117 {"ZapfDingbats",          "d050000l"}};
118
119 class GfxState;
120 class GfxImageColorMap;
121
122 class SWFOutputDev:  public OutputDev {
123   struct swfoutput output;
124   int outputstarted;
125 public:
126
127   // Constructor.
128   SWFOutputDev();
129
130   // Destructor.
131   virtual ~SWFOutputDev() ;
132
133   //----- get info about output device
134
135   // Does this device use upside-down coordinates?
136   // (Upside-down means (0,0) is the top left corner of the page.)
137   virtual GBool upsideDown();
138
139   // Does this device use drawChar() or drawString()?
140   virtual GBool useDrawChar();
141   
142   virtual GBool interpretType3Chars() {return gTrue;}
143
144   //----- initialization and control
145
146   void startDoc(XRef *xref);
147
148   // Start a page.
149   virtual void startPage(int pageNum, GfxState *state, double x1, double y1, double x2, double y2) ;
150
151   //----- link borders
152   virtual void drawLink(Link *link, Catalog *catalog) ;
153
154   //----- save/restore graphics state
155   virtual void saveState(GfxState *state) ;
156   virtual void restoreState(GfxState *state) ;
157
158   //----- update graphics state
159
160   virtual void updateFont(GfxState *state);
161   virtual void updateFillColor(GfxState *state);
162   virtual void updateStrokeColor(GfxState *state);
163   virtual void updateLineWidth(GfxState *state);
164   virtual void updateLineJoin(GfxState *state);
165   virtual void updateLineCap(GfxState *state);
166   
167   virtual void updateAll(GfxState *state) 
168   {
169       updateFont(state);
170       updateFillColor(state);
171       updateStrokeColor(state);
172       updateLineWidth(state);
173       updateLineJoin(state);
174       updateLineCap(state);
175   };
176
177   //----- path painting
178   virtual void stroke(GfxState *state) ;
179   virtual void fill(GfxState *state) ;
180   virtual void eoFill(GfxState *state) ;
181
182   //----- path clipping
183   virtual void clip(GfxState *state) ;
184   virtual void eoClip(GfxState *state) ;
185
186   //----- text drawing
187   virtual void beginString(GfxState *state, GString *s) ;
188   virtual void endString(GfxState *state) ;
189   virtual void drawChar(GfxState *state, double x, double y,
190                         double dx, double dy,
191                         double originX, double originY,
192                         CharCode code, Unicode *u, int uLen);
193
194   //----- image drawing
195   virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
196                              int width, int height, GBool invert,
197                              GBool inlineImg);
198   virtual void drawImage(GfxState *state, Object *ref, Stream *str,
199                          int width, int height, GfxImageColorMap *colorMap,
200                          int *maskColors, GBool inlineImg);
201   
202   virtual GBool beginType3Char(GfxState *state,
203                                CharCode code, Unicode *u, int uLen);
204   virtual void endType3Char(GfxState *state);
205
206   private:
207   void drawGeneralImage(GfxState *state, Object *ref, Stream *str,
208                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
209                                    GBool inlineImg, int mask);
210   int clipping[64];
211   int clippos;
212
213   XRef*xref;
214
215   char* searchFont(char*name);
216   char* substituteFont(GfxFont*gfxFont, char*oldname);
217   char* writeEmbeddedFontToFile(XRef*ref, GfxFont*font);
218   int t1id;
219   int jpeginfo; // did we write "File contains jpegs" yet?
220   int pbminfo; // did we write "File contains jpegs" yet?
221   int linkinfo; // did we write "File contains links" yet?
222   int ttfinfo; // did we write "File contains TrueType Fonts" yet?
223
224   int type3active; // are we between beginType3()/endType3()?
225
226   GfxState *laststate;
227 };
228
229 char*getFontName(GfxFont*font)
230 {
231     GString*gstr = font->getName();
232     char* fontname = gstr==0?0:gstr->getCString();
233     if(fontname==0) {
234         char buf[32];
235         Ref*r=font->getID();
236         sprintf(buf, "UFONT%d", r->num);
237         return strdup(buf);
238     }
239     char* plus = strchr(fontname, '+');
240     if(plus && plus < &fontname[strlen(fontname)-1])
241         fontname = plus+1;
242     return fontname;
243 }
244
245 char mybuf[1024];
246 char* gfxstate2str(GfxState *state)
247 {
248   char*bufpos = mybuf;
249   GfxRGB rgb;
250   bufpos+=sprintf(bufpos,"CTM[%.3f/%.3f/%.3f/%.3f/%.3f/%.3f] ",
251                                     state->getCTM()[0],
252                                     state->getCTM()[1],
253                                     state->getCTM()[2],
254                                     state->getCTM()[3],
255                                     state->getCTM()[4],
256                                     state->getCTM()[5]);
257   if(state->getX1()!=0.0)
258   bufpos+=sprintf(bufpos,"X1-%.1f ",state->getX1());
259   if(state->getY1()!=0.0)
260   bufpos+=sprintf(bufpos,"Y1-%.1f ",state->getY1());
261   bufpos+=sprintf(bufpos,"X2-%.1f ",state->getX2());
262   bufpos+=sprintf(bufpos,"Y2-%.1f ",state->getY2());
263   bufpos+=sprintf(bufpos,"PW%.1f ",state->getPageWidth());
264   bufpos+=sprintf(bufpos,"PH%.1f ",state->getPageHeight());
265   /*bufpos+=sprintf(bufpos,"FC[%.1f/%.1f] ",
266           state->getFillColor()->c[0], state->getFillColor()->c[1]);
267   bufpos+=sprintf(bufpos,"SC[%.1f/%.1f] ",
268           state->getStrokeColor()->c[0], state->getFillColor()->c[1]);*/
269 /*  bufpos+=sprintf(bufpos,"FC[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f]",
270           state->getFillColor()->c[0], state->getFillColor()->c[1],
271           state->getFillColor()->c[2], state->getFillColor()->c[3],
272           state->getFillColor()->c[4], state->getFillColor()->c[5],
273           state->getFillColor()->c[6], state->getFillColor()->c[7]);
274   bufpos+=sprintf(bufpos,"SC[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f/%.1f]",
275           state->getStrokeColor()->c[0], state->getFillColor()->c[1],
276           state->getStrokeColor()->c[2], state->getFillColor()->c[3],
277           state->getStrokeColor()->c[4], state->getFillColor()->c[5],
278           state->getStrokeColor()->c[6], state->getFillColor()->c[7]);*/
279   state->getFillRGB(&rgb);
280   if(rgb.r || rgb.g || rgb.b)
281   bufpos+=sprintf(bufpos,"FR[%.1f/%.1f/%.1f] ", rgb.r,rgb.g,rgb.b);
282   state->getStrokeRGB(&rgb);
283   if(rgb.r || rgb.g || rgb.b)
284   bufpos+=sprintf(bufpos,"SR[%.1f/%.1f/%.1f] ", rgb.r,rgb.g,rgb.b);
285   if(state->getFillColorSpace()->getNComps()>1)
286   bufpos+=sprintf(bufpos,"CS[[%d]] ",state->getFillColorSpace()->getNComps());
287   if(state->getStrokeColorSpace()->getNComps()>1)
288   bufpos+=sprintf(bufpos,"SS[[%d]] ",state->getStrokeColorSpace()->getNComps());
289   if(state->getFillPattern())
290   bufpos+=sprintf(bufpos,"FP%08x ", state->getFillPattern());
291   if(state->getStrokePattern())
292   bufpos+=sprintf(bufpos,"SP%08x ", state->getStrokePattern());
293  
294   if(state->getFillOpacity()!=1.0)
295   bufpos+=sprintf(bufpos,"FO%.1f ", state->getFillOpacity());
296   if(state->getStrokeOpacity()!=1.0)
297   bufpos+=sprintf(bufpos,"SO%.1f ", state->getStrokeOpacity());
298
299   bufpos+=sprintf(bufpos,"LW%.1f ", state->getLineWidth());
300  
301   double * dash;
302   int length;
303   double start;
304   state->getLineDash(&dash, &length, &start);
305   int t;
306   if(length)
307   {
308       bufpos+=sprintf(bufpos,"DASH%.1f[",start);
309       for(t=0;t<length;t++) {
310           bufpos+=sprintf(bufpos,"D%.1f",dash[t]);
311       }
312       bufpos+=sprintf(bufpos,"]");
313   }
314
315   if(state->getFlatness()!=1)
316   bufpos+=sprintf(bufpos,"F%d ", state->getFlatness());
317   if(state->getLineJoin()!=0)
318   bufpos+=sprintf(bufpos,"J%d ", state->getLineJoin());
319   if(state->getLineJoin()!=0)
320   bufpos+=sprintf(bufpos,"C%d ", state->getLineCap());
321   if(state->getLineJoin()!=0)
322   bufpos+=sprintf(bufpos,"ML%d ", state->getMiterLimit());
323
324   if(state->getFont() && getFontName(state->getFont()))
325   bufpos+=sprintf(bufpos,"F\"%s\" ",getFontName(state->getFont()));
326   bufpos+=sprintf(bufpos,"FS%.1f ", state->getFontSize());
327   bufpos+=sprintf(bufpos,"MAT[%.1f/%.1f/%.1f/%.1f/%.1f/%.1f] ", state->getTextMat()[0],state->getTextMat()[1],state->getTextMat()[2],
328                                    state->getTextMat()[3],state->getTextMat()[4],state->getTextMat()[5]);
329   if(state->getCharSpace())
330   bufpos+=sprintf(bufpos,"CS%.5f ", state->getCharSpace());
331   if(state->getWordSpace())
332   bufpos+=sprintf(bufpos,"WS%.5f ", state->getWordSpace());
333   if(state->getHorizScaling()!=1.0)
334   bufpos+=sprintf(bufpos,"SC%.1f ", state->getHorizScaling());
335   if(state->getLeading())
336   bufpos+=sprintf(bufpos,"L%.1f ", state->getLeading());
337   if(state->getRise())
338   bufpos+=sprintf(bufpos,"R%.1f ", state->getRise());
339   if(state->getRender())
340   bufpos+=sprintf(bufpos,"R%d ", state->getRender());
341   bufpos+=sprintf(bufpos,"P%08x ", state->getPath());
342   bufpos+=sprintf(bufpos,"CX%.1f ", state->getCurX());
343   bufpos+=sprintf(bufpos,"CY%.1f ", state->getCurY());
344   if(state->getLineX())
345   bufpos+=sprintf(bufpos,"LX%.1f ", state->getLineX());
346   if(state->getLineY())
347   bufpos+=sprintf(bufpos,"LY%.1f ", state->getLineY());
348   bufpos+=sprintf(bufpos," ");
349   return mybuf;
350 }
351
352
353
354 void dumpFontInfo(char*loglevel, GfxFont*font);
355 int lastdumps[1024];
356 int lastdumppos = 0;
357 /* nr = 0  unknown
358    nr = 1  substituting
359    nr = 2  type 3
360  */
361 void showFontError(GfxFont*font, int nr) 
362 {  
363     Ref*r=font->getID();
364     int t;
365     for(t=0;t<lastdumppos;t++)
366         if(lastdumps[t] == r->num)
367             break;
368     if(t < lastdumppos)
369       return;
370     if(lastdumppos<sizeof(lastdumps)/sizeof(int))
371     lastdumps[lastdumppos++] = r->num;
372     if(nr == 0)
373       msg("<warning> The following font caused problems:");
374     else if(nr == 1)
375       msg("<warning> The following font caused problems (substituting):");
376     else if(nr == 2)
377       msg("<warning> The following Type 3 Font will be rendered as bitmap:");
378     dumpFontInfo("<warning>", font);
379 }
380
381 void dumpFontInfo(char*loglevel, GfxFont*font)
382 {
383   char* name = getFontName(font);
384   Ref* r=font->getID();
385   msg("%s=========== %s (ID:%d,%d) ==========\n", loglevel, name, r->num,r->gen);
386
387   GString*gstr  = font->getTag();
388    
389   msg("%s| Tag: %s\n", loglevel, name);
390   
391   if(font->isCIDFont()) msg("%s| is CID font\n", loglevel);
392
393   GfxFontType type=font->getType();
394   switch(type) {
395     case fontUnknownType:
396      msg("%s| Type: unknown\n",loglevel);
397     break;
398     case fontType1:
399      msg("%s| Type: 1\n",loglevel);
400     break;
401     case fontType1C:
402      msg("%s| Type: 1C\n",loglevel);
403     break;
404     case fontType3:
405      msg("%s| Type: 3\n",loglevel);
406     break;
407     case fontTrueType:
408      msg("%s| Type: TrueType\n",loglevel);
409     break;
410     case fontCIDType0:
411      msg("%s| Type: CIDType0\n",loglevel);
412     break;
413     case fontCIDType0C:
414      msg("%s| Type: CIDType0C\n",loglevel);
415     break;
416     case fontCIDType2:
417      msg("%s| Type: CIDType2\n",loglevel);
418     break;
419   }
420   
421   Ref embRef;
422   GBool embedded = font->getEmbeddedFontID(&embRef);
423   if(font->getEmbeddedFontName())
424     name = font->getEmbeddedFontName()->getCString();
425   if(embedded)
426    msg("%s| Embedded name: %s id: %d\n",loglevel, FIXNULL(name), embRef.num);
427
428   gstr = font->getExtFontFile();
429   if(gstr)
430    msg("%s| External Font file: %s\n", loglevel, FIXNULL(gstr->getCString()));
431
432   // Get font descriptor flags.
433   if(font->isFixedWidth()) msg("%s| is fixed width\n", loglevel);
434   if(font->isSerif()) msg("%s| is serif\n", loglevel);
435   if(font->isSymbolic()) msg("%s| is symbolic\n", loglevel);
436   if(font->isItalic()) msg("%s| is italic\n", loglevel);
437   if(font->isBold()) msg("%s| is bold\n", loglevel);
438 }
439
440 //void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) {printf("void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, GBool invert, GBool inlineImg) \n");}
441 //void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) {printf("void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, GBool inlineImg) \n");}
442
443 SWFOutputDev::SWFOutputDev() 
444 {
445     jpeginfo = 0;
446     ttfinfo = 0;
447     linkinfo = 0;
448     pbminfo = 0;
449     type3active = 0;
450     clippos = 0;
451     clipping[clippos] = 0;
452     outputstarted = 0;
453     xref = 0;
454 //    printf("SWFOutputDev::SWFOutputDev() \n");
455 };
456
457 SWF_OUTLINE* gfxPath_to_SWF_OUTLINE(GfxState*state, GfxPath*path)
458 {
459     int num = path->getNumSubpaths();
460     int s,t;
461     bezierpathsegment*start,*last=0;
462     bezierpathsegment*outline = start = new bezierpathsegment();
463     int cpos = 0;
464     double lastx=0,lasty=0;
465     if(!num) {
466         msg("<warning> empty path");
467         outline->type = SWF_PATHTYPE_MOVE;
468         outline->dest.x = 0;
469         outline->dest.y = 0;
470         outline->link = 0;
471         return (SWF_OUTLINE*)outline;
472     }
473     for(t = 0; t < num; t++) {
474         GfxSubpath *subpath = path->getSubpath(t);
475         int subnum = subpath->getNumPoints();
476
477         for(s=0;s<subnum;s++) {
478            double nx,ny;
479            state->transform(subpath->getX(s),subpath->getY(s),&nx,&ny);
480            int x = (int)((nx-lastx)*0xffff);
481            int y = (int)((ny-lasty)*0xffff);
482            if(s==0) 
483            {
484                 last = outline;
485                 outline->type = SWF_PATHTYPE_MOVE;
486                 outline->dest.x = x;
487                 outline->dest.y = y;
488                 outline->link = (SWF_OUTLINE*)new bezierpathsegment();
489                 outline = (bezierpathsegment*)outline->link;
490                 cpos = 0;
491                 lastx = nx;
492                 lasty = ny;
493            }
494            else if(subpath->getCurve(s) && !cpos)
495            {
496                 outline->B.x = x;
497                 outline->B.y = y;
498                 cpos = 1;
499            } 
500            else if(subpath->getCurve(s) && cpos)
501            {
502                 outline->C.x = x;
503                 outline->C.y = y;
504                 cpos = 2;
505            }
506            else
507            {
508                 last = outline;
509                 outline->dest.x = x;
510                 outline->dest.y = y;
511                 outline->type = cpos?SWF_PATHTYPE_BEZIER:SWF_PATHTYPE_LINE;
512                 outline->link = 0;
513                 outline->link = (SWF_OUTLINE*)new bezierpathsegment();
514                 outline = (bezierpathsegment*)outline->link;
515                 cpos = 0;
516                 lastx = nx;
517                 lasty = ny;
518            }
519         }
520     }
521     last->link = 0;
522     return (SWF_OUTLINE*)start;
523 }
524 /*----------------------------------------------------------------------------
525  * Primitive Graphic routines
526  *----------------------------------------------------------------------------*/
527
528 void SWFOutputDev::stroke(GfxState *state) 
529 {
530     msg("<debug> stroke\n");
531     GfxPath * path = state->getPath();
532     int lineCap = state->getLineCap(); // 0=butt, 1=round 2=square
533     int lineJoin = state->getLineJoin(); // 0=miter, 1=round 2=bevel
534     double miterLimit = state->getMiterLimit();
535     double width = state->getTransformedLineWidth();
536     struct swfmatrix m;
537     GfxRGB rgb;
538     double opaq = state->getStrokeOpacity();
539     state->getStrokeRGB(&rgb);
540
541     m.m11 = 1; m.m21 = 0; m.m22 = 1;
542     m.m12 = 0; m.m13 = 0; m.m23 = 0;
543     SWF_OUTLINE*outline = gfxPath_to_SWF_OUTLINE(state, path);
544
545     lineJoin = 1; // other line joins are not yet supported by the swf encoder
546                   // TODO: support bevel joints
547
548     if(((lineCap==1) && (lineJoin==1)) || width<=caplinewidth) {
549         /* FIXME- if the path is smaller than 2 segments, we could ignore
550            lineJoin */
551         swfoutput_setdrawmode(&output, DRAWMODE_STROKE);
552         swfoutput_drawpath(&output, outline, &m);
553     } else {
554         swfoutput_setfillcolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), 
555                                         (char)(rgb.b*255), (char)(opaq*255));
556
557         //swfoutput_setlinewidth(&output, 1.0); //only for debugging
558         //swfoutput_setstrokecolor(&output, 0, 255, 0, 255); //likewise, see below
559         //swfoutput_setfillcolor(&output, 255, 0, 0, 255); //likewise, see below
560
561         swfoutput_drawpath2poly(&output, outline, &m, lineJoin, lineCap, width, miterLimit);
562         updateLineWidth(state);  //reset
563         updateStrokeColor(state); //reset
564         updateFillColor(state);  //reset
565     }
566 }
567 void SWFOutputDev::fill(GfxState *state) 
568 {
569     msg("<debug> fill\n");
570     GfxPath * path = state->getPath();
571     struct swfmatrix m;
572     m.m11 = 1; m.m21 = 0; m.m22 = 1;
573     m.m12 = 0; m.m13 = 0; m.m23 = 0;
574     SWF_OUTLINE*outline = gfxPath_to_SWF_OUTLINE(state, path);
575     swfoutput_setdrawmode(&output, DRAWMODE_FILL);
576     swfoutput_drawpath(&output, outline, &m);
577 }
578 void SWFOutputDev::eoFill(GfxState *state) 
579 {
580     msg("<debug> eofill\n");
581     GfxPath * path = state->getPath();
582     struct swfmatrix m;
583     m.m11 = 1; m.m21 = 0; m.m22 = 1;
584     m.m12 = 0; m.m13 = 0; m.m23 = 0;
585     SWF_OUTLINE*outline = gfxPath_to_SWF_OUTLINE(state, path);
586     swfoutput_setdrawmode(&output, DRAWMODE_EOFILL);
587     swfoutput_drawpath(&output, outline, &m);
588 }
589 void SWFOutputDev::clip(GfxState *state) 
590 {
591     msg("<debug> clip\n");
592     GfxPath * path = state->getPath();
593     struct swfmatrix m;
594     m.m11 = 1; m.m22 = 1;
595     m.m12 = 0; m.m21 = 0; 
596     m.m13 = 0; m.m23 = 0;
597     SWF_OUTLINE*outline = gfxPath_to_SWF_OUTLINE(state, path);
598     swfoutput_startclip(&output, outline, &m);
599     clipping[clippos] ++;
600 }
601 void SWFOutputDev::eoClip(GfxState *state) 
602 {
603     msg("<debug> eoclip\n");
604     GfxPath * path = state->getPath();
605     struct swfmatrix m;
606     m.m11 = 1; m.m21 = 0; m.m22 = 1;
607     m.m12 = 0; m.m13 = 0; m.m23 = 0;
608     SWF_OUTLINE*outline = gfxPath_to_SWF_OUTLINE(state, path);
609     swfoutput_startclip(&output, outline, &m);
610     clipping[clippos] ++;
611 }
612
613 SWFOutputDev::~SWFOutputDev() 
614 {
615     swfoutput_destroy(&output);
616     outputstarted = 0;
617 };
618 GBool SWFOutputDev::upsideDown() 
619 {
620     msg("<debug> upsidedown? yes");
621     return gTrue;
622 };
623 GBool SWFOutputDev::useDrawChar() 
624 {
625     return gTrue;
626 }
627
628 void SWFOutputDev::beginString(GfxState *state, GString *s) 
629
630     double m11,m21,m12,m22;
631 //    msg("<debug> %s beginstring \"%s\"\n", gfxstate2str(state), s->getCString());
632     state->getFontTransMat(&m11, &m12, &m21, &m22);
633     m11 *= state->getHorizScaling();
634     m21 *= state->getHorizScaling();
635     swfoutput_setfontmatrix(&output, m11, -m21, m12, -m22);
636 }
637
638 void SWFOutputDev::drawChar(GfxState *state, double x, double y,
639                         double dx, double dy,
640                         double originX, double originY,
641                         CharCode c, Unicode *_u, int uLen)
642 {
643     // check for invisible text -- this is used by Acrobat Capture
644     if ((state->getRender() & 3) == 3)
645         return;
646
647     GfxFont*font = state->getFont();
648
649     if(font->getType() == fontType3) {
650         /* type 3 chars are passed as graphics */
651         return;
652     }
653     double x1,y1;
654     x1 = x;
655     y1 = y;
656     state->transform(x, y, &x1, &y1);
657         
658     Unicode u=0;
659     if(_u) 
660         u = *_u;
661     
662     /* find out the character name */
663     char*name=0;
664     if(font->isCIDFont() && u) {
665         GfxCIDFont*cfont = (GfxCIDFont*)font;
666         int t;
667         for(t=0;t<sizeof(nameToUnicodeTab)/sizeof(nameToUnicodeTab[0]);t++) {
668             /* todo: should be precomputed */
669             if(nameToUnicodeTab[t].u == u) {
670                 name = nameToUnicodeTab[t].name;
671                 break;
672             }
673         }
674     } else {
675         Gfx8BitFont*font8;
676         font8 = (Gfx8BitFont*)font;
677         char**enc=font8->getEncoding();
678         if(enc && enc[c])
679            name = enc[c];
680     }
681     
682     msg("<debug> drawChar(%f,%f,c='%c' (%d),u=%d <%d>) CID=%d name=\"%s\"\n",x1,y1,(c&127)>=32?c:'?',c,u, uLen, font->isCIDFont(), FIXNULL(name));
683
684     int ret = swfoutput_drawchar(&output, x1, y1, name, c, u);
685 }
686
687 void SWFOutputDev::endString(GfxState *state) { 
688 }    
689
690  
691 GBool SWFOutputDev::beginType3Char(GfxState *state,
692                                CharCode code, Unicode *u, int uLen)
693 {
694     msg("<debug> beginType3Char %d, %08x, %d", code, *u, uLen);
695     type3active = 1;
696     /* the character itself is going to be passed using
697        drawImageMask() */
698     return gFalse; /* gTrue= is_in_cache? */
699 }
700
701 void SWFOutputDev::endType3Char(GfxState *state)
702 {
703     type3active = 0;
704     msg("<debug> endType3Char");
705 }
706
707 void SWFOutputDev::startPage(int pageNum, GfxState *state, double crop_x1, double crop_y1, double crop_x2, double crop_y2) 
708 {
709   double x1,y1,x2,y2;
710   int rot = doc->getPageRotate(1);
711   laststate = state;
712   msg("<verbose> startPage %d (%f,%f,%f,%f)\n", pageNum, crop_x1, crop_y1, crop_x2, crop_y2);
713   if(rot!=0)
714     msg("<verbose> page is rotated %d degrees\n", rot);
715
716   msg("<notice> processing page %d", pageNum);
717
718   /* state->transform(state->getX1(),state->getY1(),&x1,&y1);
719   state->transform(state->getX2(),state->getY2(),&x2,&y2);
720   Use CropBox, not MediaBox, as page size
721   */
722   
723   /*x1 = crop_x1;
724   y1 = crop_y1;
725   x2 = crop_x2;
726   y2 = crop_y2;*/
727   state->transform(crop_x1,crop_y1,&x1,&y1);
728   state->transform(crop_x2,crop_y2,&x2,&y2);
729
730   if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
731   if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
732
733   if(!outputstarted) {
734     msg("<verbose> Bounding box is (%f,%f)-(%f,%f)", x1,y1,x2,y2);
735     swfoutput_init(&output, swffilename,(int)x1,(int)y1,(int)x2,(int)y2);
736     outputstarted = 1;
737   }
738   else
739     swfoutput_newpage(&output);
740 }
741
742 void SWFOutputDev::drawLink(Link *link, Catalog *catalog) 
743 {
744   msg("<debug> drawlink\n");
745   double x1, y1, x2, y2, w;
746   GfxRGB rgb;
747   swfcoord points[5];
748   int x, y;
749
750   link->getBorder(&x1, &y1, &x2, &y2, &w);
751 //  if (w > 0) 
752   {
753     rgb.r = 0;
754     rgb.g = 0;
755     rgb.b = 1;
756     cvtUserToDev(x1, y1, &x, &y);
757     points[0].x = points[4].x = (int)x;
758     points[0].y = points[4].y = (int)y;
759     cvtUserToDev(x2, y1, &x, &y);
760     points[1].x = (int)x;
761     points[1].y = (int)y;
762     cvtUserToDev(x2, y2, &x, &y);
763     points[2].x = (int)x;
764     points[2].y = (int)y;
765     cvtUserToDev(x1, y2, &x, &y);
766     points[3].x = (int)x;
767     points[3].y = (int)y;
768
769     LinkAction*action=link->getAction();
770     char buf[128];
771     char*s = "-?-";
772     char*type = "-?-";
773     char*url = 0;
774     char*named = 0;
775     int page = -1;
776     switch(action->getKind())
777     {
778         case actionGoTo: {
779             type = "GoTo";
780             LinkGoTo *ha=(LinkGoTo *)link->getAction();
781             LinkDest *dest=NULL;
782             if (ha->getDest()==NULL) 
783                 dest=catalog->findDest(ha->getNamedDest());
784             else dest=ha->getDest();
785             if (dest){ 
786               if (dest->isPageRef()){
787                 Ref pageref=dest->getPageRef();
788                 page=catalog->findPage(pageref.num,pageref.gen);
789               }
790               else  page=dest->getPageNum();
791               sprintf(buf, "%d", page);
792               s = buf;
793             }
794         }
795         break;
796         case actionGoToR: {
797             type = "GoToR";
798             LinkGoToR*l = (LinkGoToR*)action;
799             GString*g = l->getNamedDest();
800             if(g)
801              s = g->getCString();
802         }
803         break;
804         case actionNamed: {
805             type = "Named";
806             LinkNamed*l = (LinkNamed*)action;
807             GString*name = l->getName();
808             if(name) {
809                 s = name->lowerCase()->getCString();
810                 named = name->getCString();
811                 if(!strchr(s,':')) 
812                 {
813                     if(strstr(s, "next") || strstr(s, "forward"))
814                     {
815                         page = currentpage + 1;
816                     }
817                     else if(strstr(s, "prev") || strstr(s, "back"))
818                     {
819                         page = currentpage - 1;
820                     }
821                     else if(strstr(s, "last") || strstr(s, "end"))
822                     {
823                         page = pages[pagepos-1]; //:)
824                     }
825                     else if(strstr(s, "first") || strstr(s, "top"))
826                     {
827                         page = 1;
828                     }
829                 }
830             }
831         }
832         break;
833         case actionLaunch: {
834             type = "Launch";
835             LinkLaunch*l = (LinkLaunch*)action;
836             GString * str = new GString(l->getFileName());
837             str->append(l->getParams());
838             s = str->getCString();
839         }
840         break;
841         case actionURI: {
842             type = "URI";
843             LinkURI*l = (LinkURI*)action;
844             GString*g = l->getURI();
845             if(g) {
846              url = g->getCString();
847              s = url;
848             }
849         }
850         break;
851         case actionUnknown: {
852             type = "Unknown";
853             LinkUnknown*l = (LinkUnknown*)action;
854             s = "";
855         }
856         break;
857         default: {
858             msg("<error> Unknown link type!\n");
859             break;
860         }
861     }
862     if(!linkinfo && (page || url))
863     {
864         msg("<notice> File contains links");
865         linkinfo = 1;
866     }
867     if(page>0)
868     {
869         int t;
870         for(t=0;t<pagepos;t++)
871             if(pages[t]==page)
872                 break;
873         if(t!=pagepos)
874         swfoutput_linktopage(&output, t, points);
875     }
876     else if(url)
877     {
878         swfoutput_linktourl(&output, url, points);
879     }
880     else if(named)
881     {
882         swfoutput_namedlink(&output, named, points);
883     }
884     msg("<verbose> \"%s\" link to \"%s\" (%d)\n", type, FIXNULL(s), page);
885   }
886 }
887
888 void SWFOutputDev::saveState(GfxState *state) {
889   msg("<debug> saveState\n");
890   updateAll(state);
891   if(clippos<64)
892     clippos ++;
893   else
894     msg("<error> Too many nested states in pdf.");
895   clipping[clippos] = 0;
896 };
897
898 void SWFOutputDev::restoreState(GfxState *state) {
899   msg("<debug> restoreState\n");
900   updateAll(state);
901   while(clipping[clippos]) {
902       swfoutput_endclip(&output);
903       clipping[clippos]--;
904   }
905   clippos--;
906 }
907
908 char type3Warning=0;
909
910 char* SWFOutputDev::searchFont(char*name) 
911 {       
912     int i;
913     char*filename=0;
914         
915     msg("<verbose> SearchT1Font(%s)", name);
916
917     /* see if it is a pdf standard font */
918     for(i=0;i<sizeof(pdf2t1map)/sizeof(mapping);i++) 
919     {
920         if(!strcmp(name, pdf2t1map[i].pdffont))
921         {
922             name = pdf2t1map[i].filename;
923             break;
924         }
925     }
926     /* look in all font files */
927     for(i=0;i<fontnum;i++) 
928     {
929         if(strstr(fonts[i], name))
930         {
931             return fonts[i];
932         }
933     }
934     return 0;
935 }
936
937 void SWFOutputDev::updateLineWidth(GfxState *state)
938 {
939     double width = state->getTransformedLineWidth();
940     swfoutput_setlinewidth(&output, width);
941 }
942
943 void SWFOutputDev::updateLineCap(GfxState *state)
944 {
945     int c = state->getLineCap();
946 }
947
948 void SWFOutputDev::updateLineJoin(GfxState *state)
949 {
950     int j = state->getLineJoin();
951 }
952
953 void SWFOutputDev::updateFillColor(GfxState *state) 
954 {
955     GfxRGB rgb;
956     double opaq = state->getFillOpacity();
957     state->getFillRGB(&rgb);
958
959     swfoutput_setfillcolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), 
960                                     (char)(rgb.b*255), (char)(opaq*255));
961 }
962
963 void SWFOutputDev::updateStrokeColor(GfxState *state) 
964 {
965     GfxRGB rgb;
966     double opaq = state->getStrokeOpacity();
967     state->getStrokeRGB(&rgb);
968
969     swfoutput_setstrokecolor(&output, (char)(rgb.r*255), (char)(rgb.g*255), 
970                                       (char)(rgb.b*255), (char)(opaq*255));
971 }
972
973 char*SWFOutputDev::writeEmbeddedFontToFile(XRef*ref, GfxFont*font)
974 {
975     char*tmpFileName = NULL;
976     FILE *f;
977     int c;
978     char *fontBuf;
979     int fontLen;
980     Ref embRef;
981     Object refObj, strObj;
982     char namebuf[512];
983     tmpFileName = mktmpname(namebuf);
984     int ret;
985
986     ret = font->getEmbeddedFontID(&embRef);
987     if(!ret) {
988         msg("<verbose> Didn't get embedded font id");
989         /* not embedded- the caller should now search the font
990            directories for this font */
991         return 0;
992     }
993
994     f = fopen(tmpFileName, "wb");
995     if (!f) {
996       msg("<error> Couldn't create temporary Type 1 font file");
997         return 0;
998     }
999     if (font->getType() == fontType1C ||
1000         font->getType() == fontCIDType0C) {
1001       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1002         fclose(f);
1003         msg("<error> Couldn't read embedded font file");
1004         return 0;
1005       }
1006       Type1CFontFile *cvt = new Type1CFontFile(fontBuf, fontLen);
1007       cvt->convertToType1(f);
1008       delete cvt;
1009       gfree(fontBuf);
1010     } else if(font->getType() == fontTrueType) {
1011       msg("<verbose> writing font using TrueTypeFontFile::writeTTF");
1012       if (!(fontBuf = font->readEmbFontFile(xref, &fontLen))) {
1013         fclose(f);
1014         msg("<error> Couldn't read embedded font file");
1015         return 0;
1016       }
1017       TrueTypeFontFile *cvt = new TrueTypeFontFile(fontBuf, fontLen);
1018       cvt->writeTTF(f);
1019       delete cvt;
1020       gfree(fontBuf);
1021     } else {
1022       font->getEmbeddedFontID(&embRef);
1023       refObj.initRef(embRef.num, embRef.gen);
1024       refObj.fetch(ref, &strObj);
1025       refObj.free();
1026       strObj.streamReset();
1027       int f4[4];
1028       char f4c[4];
1029       int t;
1030       for(t=0;t<4;t++) {
1031           f4[t] = strObj.streamGetChar();
1032           f4c[t] = (char)f4[t];
1033           if(f4[t] == EOF)
1034               break;
1035       }
1036       if(t==4) {
1037           if(!strncmp(f4c, "true", 4)) {
1038               /* some weird TTF fonts don't start with 0,1,0,0 but with "true".
1039                  Change this on the fly */
1040               f4[0] = f4[2] = f4[3] = 0;
1041               f4[1] = 1;
1042           }
1043           fputc(f4[0], f);
1044           fputc(f4[1], f);
1045           fputc(f4[2], f);
1046           fputc(f4[3], f);
1047
1048           while ((c = strObj.streamGetChar()) != EOF) {
1049             fputc(c, f);
1050           }
1051       }
1052       strObj.streamClose();
1053       strObj.free();
1054     }
1055     fclose(f);
1056
1057     return strdup(tmpFileName);
1058 }
1059
1060
1061 char* substitutetarget[256];
1062 char* substitutesource[256];
1063 int substitutepos = 0;
1064
1065 char* SWFOutputDev::substituteFont(GfxFont*gfxFont, char* oldname)
1066 {
1067     char*fontname = "Times-Roman";
1068     msg("<verbose> substituteFont(,%s)", FIXNULL(oldname));
1069     char*filename = searchFont(fontname);
1070     if(substitutepos>=sizeof(substitutesource)/sizeof(char*)) {
1071         msg("<fatal> Too many fonts in file.");
1072         exit(1);
1073     }
1074     if(oldname) {
1075         substitutesource[substitutepos] = oldname;
1076         substitutetarget[substitutepos] = fontname;
1077         msg("<notice> substituting %s -> %s", FIXNULL(oldname), FIXNULL(fontname));
1078         substitutepos ++;
1079     }
1080     return filename;
1081 }
1082
1083 void unlinkfont(char* filename)
1084 {
1085     int l;
1086     if(!filename)
1087         return;
1088     l=strlen(filename);
1089     unlink(filename);
1090     if(!strncmp(&filename[l-4],".afm",4)) {
1091         memcpy(&filename[l-4],".pfb",4);
1092         unlink(filename);
1093         memcpy(&filename[l-4],".pfa",4);
1094         unlink(filename);
1095         memcpy(&filename[l-4],".afm",4);
1096         return;
1097     } else 
1098     if(!strncmp(&filename[l-4],".pfa",4)) {
1099         memcpy(&filename[l-4],".afm",4);
1100         unlink(filename);
1101         memcpy(&filename[l-4],".pfa",4);
1102         return;
1103     } else 
1104     if(!strncmp(&filename[l-4],".pfb",4)) {
1105         memcpy(&filename[l-4],".afm",4);
1106         unlink(filename);
1107         memcpy(&filename[l-4],".pfb",4);
1108         return;
1109     }
1110 }
1111
1112 void SWFOutputDev::startDoc(XRef *xref) 
1113 {
1114     this->xref = xref;
1115 }
1116
1117
1118 void SWFOutputDev::updateFont(GfxState *state) 
1119 {
1120     GfxFont*gfxFont = state->getFont();
1121       
1122     if (!gfxFont) {
1123         return;
1124     }  
1125     char * fontname = getFontName(gfxFont);
1126     
1127     int t;
1128     /* first, look if we substituted this font before-
1129        this way, we don't initialize the T1 Fonts
1130        too often */
1131     for(t=0;t<substitutepos;t++) {
1132         if(!strcmp(fontname, substitutesource[t])) {
1133             fontname = substitutetarget[t];
1134             break;
1135         }
1136     }
1137
1138     /* second, see if swfoutput already has this font
1139        cached- if so, we are done */
1140     if(swfoutput_queryfont(&output, fontname))
1141     {
1142         swfoutput_setfont(&output, fontname, 0);
1143         
1144         msg("<debug> updateFont(%s) [cached]", fontname);
1145         return;
1146     }
1147
1148     // look for Type 3 font
1149     if (!type3Warning && gfxFont->getType() == fontType3) {
1150         type3Warning = gTrue;
1151         showFontError(gfxFont, 2);
1152     }
1153
1154     /* now either load the font, or find a substitution */
1155
1156     Ref embRef;
1157     GBool embedded = gfxFont->getEmbeddedFontID(&embRef);
1158
1159     char*fileName = 0;
1160     int del = 0;
1161     if(embedded &&
1162        (gfxFont->getType() == fontType1 ||
1163         //gfxFont->getType() == fontCIDType0C ||
1164         gfxFont->getType() == fontType1C ||
1165         gfxFont->getType() == fontTrueType ||
1166         gfxFont->getType() == fontCIDType2
1167        ))
1168     {
1169       fileName = writeEmbeddedFontToFile(xref, gfxFont);
1170       if(!fileName) showFontError(gfxFont,0);
1171       else del = 1;
1172     } else {
1173       fileName = searchFont(fontname);
1174       if(!fileName) showFontError(gfxFont,0);
1175     }
1176     if(!fileName)
1177         fileName = substituteFont(gfxFont, fontname);
1178
1179     if(!fileName) {
1180         msg("<error> Couldn't set font %s\n", fontname);
1181         return;
1182     }
1183         
1184     msg("<verbose> updateFont(%s) -> %s", fontname, fileName);
1185     dumpFontInfo("<verbose>", gfxFont);
1186
1187     swfoutput_setfont(&output, fontname, fileName);
1188    
1189     if(fileName && del)
1190         unlinkfont(fileName);
1191 }
1192
1193 int pic_xids[1024];
1194 int pic_yids[1024];
1195 int pic_ids[1024];
1196 int pic_width[1024];
1197 int pic_height[1024];
1198 int picpos = 0;
1199 int pic_id = 0;
1200
1201 #define SQR(x) ((x)*(x))
1202
1203 unsigned char* antialize(unsigned char*data, int width, int height, int newwidth, int newheight, int palettesize)
1204 {
1205     if((newwidth<2 || newheight<2) ||
1206        (width<=newwidth || height<=newheight))
1207         return 0;
1208     unsigned char*newdata;
1209     int x,y;
1210     newdata= (unsigned char*)malloc(newwidth*newheight);
1211     int t;
1212     double fx = (double)(width)/newwidth;
1213     double fy = (double)(height)/newheight;
1214     double px = 0;
1215     int blocksize = (int)(8192/(fx*fy));
1216     int r = 8192*256/palettesize;
1217     for(x=0;x<newwidth;x++) {
1218         double ex = px + fx;
1219         int fromx = (int)px;
1220         int tox = (int)ex;
1221         int xweight1 = (int)(((fromx+1)-px)*256);
1222         int xweight2 = (int)((ex-tox)*256);
1223         double py =0;
1224         for(y=0;y<newheight;y++) {
1225             double ey = py + fy;
1226             int fromy = (int)py;
1227             int toy = (int)ey;
1228             int yweight1 = (int)(((fromy+1)-py)*256);
1229             int yweight2 = (int)((ey-toy)*256);
1230             int a = 0;
1231             int xx,yy;
1232             for(xx=fromx;xx<=tox;xx++)
1233             for(yy=fromy;yy<=toy;yy++) {
1234                 int b = 1-data[width*yy+xx];
1235                 int weight=256;
1236                 if(xx==fromx) weight = (weight*xweight1)/256;
1237                 if(xx==tox) weight = (weight*xweight2)/256;
1238                 if(yy==fromy) weight = (weight*yweight1)/256;
1239                 if(yy==toy) weight = (weight*yweight2)/256;
1240                 a+=b*weight;
1241             }
1242             //if(a) a=(palettesize-1)*r/blocksize;
1243             newdata[y*newwidth+x] = (a*blocksize)/r;
1244             py = ey;
1245         }
1246         px = ex;
1247     }
1248     return newdata;
1249 }
1250
1251 void SWFOutputDev::drawGeneralImage(GfxState *state, Object *ref, Stream *str,
1252                                    int width, int height, GfxImageColorMap*colorMap, GBool invert,
1253                                    GBool inlineImg, int mask)
1254 {
1255   FILE *fi;
1256   int c;
1257   char fileName[128];
1258   double x1,y1,x2,y2,x3,y3,x4,y4;
1259   ImageStream *imgStr;
1260   Guchar pixBuf[4];
1261   GfxRGB rgb;
1262   int ncomps = 1;
1263   int bits = 1;
1264                                  
1265   if(colorMap) {
1266     ncomps = colorMap->getNumPixelComps();
1267     bits = colorMap->getBits();
1268   }
1269   imgStr = new ImageStream(str, width, ncomps,bits);
1270   imgStr->reset();
1271
1272   if(!width || !height || (height<=1 && width<=1))
1273   {
1274       msg("<verbose> Ignoring %d by %d image", width, height);
1275       unsigned char buf[8];
1276       int x,y;
1277       for (y = 0; y < height; ++y)
1278       for (x = 0; x < width; ++x) {
1279           imgStr->getPixel(buf);
1280       }
1281       delete imgStr;
1282       return;
1283   }
1284   
1285   state->transform(0, 1, &x1, &y1);
1286   state->transform(0, 0, &x2, &y2);
1287   state->transform(1, 0, &x3, &y3);
1288   state->transform(1, 1, &x4, &y4);
1289
1290   if(!pbminfo && !(str->getKind()==strDCT)) {
1291       if(!type3active) {
1292           msg("<notice> file contains pbm pictures %s",mask?"(masked)":"");
1293           pbminfo = 1;
1294       }
1295       if(mask)
1296       msg("<verbose> drawing %d by %d masked picture\n", width, height);
1297   }
1298   if(!jpeginfo && (str->getKind()==strDCT)) {
1299       msg("<notice> file contains jpeg pictures");
1300       jpeginfo = 1;
1301   }
1302
1303   if(mask) {
1304       int yes=0,i,j;
1305       unsigned char buf[8];
1306       int xid = 0;
1307       int yid = 0;
1308       int x,y;
1309       unsigned char*pic = new unsigned char[width*height];
1310       RGBA pal[256];
1311       GfxRGB rgb;
1312       state->getFillRGB(&rgb);
1313       memset(pal,255,sizeof(pal));
1314       pal[0].r = (int)(rgb.r*255); pal[0].g = (int)(rgb.g*255); 
1315       pal[0].b = (int)(rgb.b*255); pal[0].a = 255;
1316       pal[1].r = 0; pal[1].g = 0; pal[1].b = 0; pal[1].a = 0;
1317       int numpalette = 2;
1318       xid += pal[1].r*3 + pal[1].g*11 + pal[1].b*17;
1319       yid += pal[1].r*7 + pal[1].g*5 + pal[1].b*23;
1320       int realwidth = (int)sqrt(SQR(x2-x3) + SQR(y2-y3));
1321       int realheight = (int)sqrt(SQR(x1-x2) + SQR(y1-y2));
1322       for (y = 0; y < height; ++y)
1323       for (x = 0; x < width; ++x)
1324       {
1325             imgStr->getPixel(buf);
1326             if(invert) 
1327                 buf[0]=1-buf[0];
1328             pic[width*y+x] = buf[0];
1329             xid+=x*buf[0]+1;
1330             yid+=y*buf[0]*3+1;
1331       }
1332       
1333       /* the size of the drawn image is added to the identifier
1334          as the same image may require different bitmaps if displayed
1335          at different sizes (due to antialiasing): */
1336       if(type3active) {
1337           xid += realwidth;
1338           yid += realheight;
1339       }
1340       int t,found = -1;
1341       for(t=0;t<picpos;t++)
1342       {
1343           if(pic_xids[t] == xid &&
1344              pic_yids[t] == yid) {
1345               /* if the image was antialiased, the size has changed: */
1346               width = pic_width[t];
1347               height = pic_height[t];
1348               found = t;break;
1349           }
1350       }
1351       if(found<0) {
1352           if(type3active) {
1353               numpalette = 16;
1354               unsigned char*pic2 = 0;
1355               
1356               pic2 = antialize(pic,width,height,realwidth,realheight, numpalette);
1357
1358               if(pic2) {
1359                   width = realwidth;
1360                   height = realheight;
1361                   free(pic);
1362                   pic = pic2;
1363                   /* make a black/white palette */
1364                   int t;
1365                   GfxRGB rgb2;
1366                   rgb2.r = 1 - rgb.r;
1367                   rgb2.g = 1 - rgb.g;
1368                   rgb2.b = 1 - rgb.b;
1369
1370                   float r = 255/(numpalette-1);
1371                   for(t=0;t<numpalette;t++) {
1372                       /*pal[t].r = (U8)(t*r*rgb.r+(numpalette-1-t)*r*rgb2.r);
1373                       pal[t].g = (U8)(t*r*rgb.g+(numpalette-1-t)*r*rgb2.g);
1374                       pal[t].b = (U8)(t*r*rgb.b+(numpalette-1-t)*r*rgb2.b);
1375                       pal[t].a = 255; */
1376                       pal[t].r = (U8)(255*rgb.r);
1377                       pal[t].g = (U8)(255*rgb.g);
1378                       pal[t].b = (U8)(255*rgb.b);
1379                       pal[t].a = (U8)(t*r);
1380                   }
1381               }
1382           }
1383           pic_ids[picpos] = swfoutput_drawimagelosslessN(&output, pic, pal, width, height, 
1384                   x1,y1,x2,y2,x3,y3,x4,y4, numpalette);
1385           pic_xids[picpos] = xid;
1386           pic_yids[picpos] = yid;
1387           pic_width[picpos] = width;
1388           pic_height[picpos] = height;
1389           if(picpos<1024)
1390               picpos++;
1391       } else {
1392           swfoutput_drawimageagain(&output, pic_ids[found], width, height,
1393                   x1,y1,x2,y2,x3,y3,x4,y4);
1394       }
1395       free(pic);
1396       delete imgStr;
1397       return;
1398   } 
1399
1400   int x,y;
1401   
1402   if(colorMap->getNumPixelComps()!=1 || str->getKind()==strDCT)
1403   {
1404       RGBA*pic=new RGBA[width*height];
1405       int xid = 0;
1406       int yid = 0;
1407       for (y = 0; y < height; ++y) {
1408         for (x = 0; x < width; ++x) {
1409           int r,g,b,a;
1410           imgStr->getPixel(pixBuf);
1411           colorMap->getRGB(pixBuf, &rgb);
1412           pic[width*y+x].r = r = (U8)(rgb.r * 255 + 0.5);
1413           pic[width*y+x].g = g = (U8)(rgb.g * 255 + 0.5);
1414           pic[width*y+x].b = b = (U8)(rgb.b * 255 + 0.5);
1415           pic[width*y+x].a = a = 255;//(U8)(rgb.a * 255 + 0.5);
1416           xid += x*r+x*b*3+x*g*7+x*a*11;
1417           yid += y*r*3+y*b*17+y*g*19+y*a*11;
1418         }
1419       }
1420       int t,found = -1;
1421       for(t=0;t<picpos;t++)
1422       {
1423           if(pic_xids[t] == xid &&
1424              pic_yids[t] == yid) {
1425               found = t;break;
1426           }
1427       }
1428       if(found<0) {
1429           if(str->getKind()==strDCT)
1430               pic_ids[picpos] = swfoutput_drawimagejpeg(&output, pic, width, height, 
1431                       x1,y1,x2,y2,x3,y3,x4,y4);
1432           else
1433               pic_ids[picpos] = swfoutput_drawimagelossless(&output, pic, width, height, 
1434                       x1,y1,x2,y2,x3,y3,x4,y4);
1435           pic_xids[picpos] = xid;
1436           pic_yids[picpos] = yid;
1437           pic_width[picpos] = width;
1438           pic_height[picpos] = height;
1439           if(picpos<1024)
1440               picpos++;
1441       } else {
1442           swfoutput_drawimageagain(&output, pic_ids[found], width, height,
1443                   x1,y1,x2,y2,x3,y3,x4,y4);
1444       }
1445       delete pic;
1446       delete imgStr;
1447       return;
1448   }
1449   else
1450   {
1451       U8*pic = new U8[width*height];
1452       RGBA pal[256];
1453       int t;
1454       int xid=0,yid=0;
1455       for(t=0;t<256;t++)
1456       {
1457           int r,g,b,a;
1458           pixBuf[0] = t;
1459           colorMap->getRGB(pixBuf, &rgb);
1460           pal[t].r = r = (U8)(rgb.r * 255 + 0.5);
1461           pal[t].g = g = (U8)(rgb.g * 255 + 0.5);
1462           pal[t].b = b = (U8)(rgb.b * 255 + 0.5);
1463           pal[t].a = a = 255;//(U8)(rgb.b * 255 + 0.5);
1464           xid += t*r+t*b*3+t*g*7+t*a*11;
1465           xid += (~t)*r+t*b*3+t*g*7+t*a*11;
1466       }
1467       for (y = 0; y < height; ++y) {
1468         for (x = 0; x < width; ++x) {
1469           imgStr->getPixel(pixBuf);
1470           pic[width*y+x] = pixBuf[0];
1471           xid += x*pixBuf[0]*7;
1472           yid += y*pixBuf[0]*3;
1473         }
1474       }
1475       int found = -1;
1476       for(t=0;t<picpos;t++)
1477       {
1478           if(pic_xids[t] == xid &&
1479              pic_yids[t] == yid) {
1480               found = t;break;
1481           }
1482       }
1483       if(found<0) {
1484           pic_ids[picpos] = swfoutput_drawimagelosslessN(&output, pic, pal, width, height, 
1485                   x1,y1,x2,y2,x3,y3,x4,y4,256);
1486           pic_xids[picpos] = xid;
1487           pic_yids[picpos] = yid;
1488           pic_width[picpos] = width;
1489           pic_height[picpos] = height;
1490           if(picpos<1024)
1491               picpos++;
1492       } else {
1493           swfoutput_drawimageagain(&output, pic_ids[found], width, height,
1494                   x1,y1,x2,y2,x3,y3,x4,y4);
1495       }
1496       delete pic;
1497       delete imgStr;
1498       return;
1499   }
1500 }
1501
1502 void SWFOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
1503                                    int width, int height, GBool invert,
1504                                    GBool inlineImg) 
1505 {
1506   msg("<verbose> drawImageMask %dx%d, invert=%d inline=%d", width, height, invert, inlineImg);
1507   drawGeneralImage(state,ref,str,width,height,0,invert,inlineImg,1);
1508 }
1509
1510 void SWFOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
1511                          int width, int height, GfxImageColorMap *colorMap,
1512                          int *maskColors, GBool inlineImg)
1513 {
1514   msg("<verbose> drawImage %dx%d, %s %s, inline=%d", width, height, 
1515           colorMap?"colorMap":"no colorMap", 
1516           maskColors?"maskColors":"no maskColors",
1517           inlineImg);
1518   if(colorMap)
1519       msg("<verbose> colorMap pixcomps:%d bits:%d mode:%d\n", colorMap->getNumPixelComps(),
1520               colorMap->getBits(),colorMap->getColorSpace()->getMode());
1521   drawGeneralImage(state,ref,str,width,height,colorMap,0,inlineImg,0);
1522 }
1523
1524 SWFOutputDev*output = 0; 
1525
1526 static void printInfoString(Dict *infoDict, char *key, char *fmt) {
1527   Object obj;
1528   GString *s1, *s2;
1529   int i;
1530
1531   if (infoDict->lookup(key, &obj)->isString()) {
1532     s1 = obj.getString();
1533     if ((s1->getChar(0) & 0xff) == 0xfe &&
1534         (s1->getChar(1) & 0xff) == 0xff) {
1535       s2 = new GString();
1536       for (i = 2; i < obj.getString()->getLength(); i += 2) {
1537         if (s1->getChar(i) == '\0') {
1538           s2->append(s1->getChar(i+1));
1539         } else {
1540           delete s2;
1541           s2 = new GString("<unicode>");
1542           break;
1543         }
1544       }
1545       printf(fmt, s2->getCString());
1546       delete s2;
1547     } else {
1548       printf(fmt, s1->getCString());
1549     }
1550   }
1551   obj.free();
1552 }
1553
1554 static void printInfoDate(Dict *infoDict, char *key, char *fmt) {
1555   Object obj;
1556   char *s;
1557
1558   if (infoDict->lookup(key, &obj)->isString()) {
1559     s = obj.getString()->getCString();
1560     if (s[0] == 'D' && s[1] == ':') {
1561       s += 2;
1562     }
1563     printf(fmt, s);
1564   }
1565   obj.free();
1566 }
1567
1568 void pdfswf_init(char*filename, char*userPassword) 
1569 {
1570   GString *fileName = new GString(filename);
1571   GString *userPW;
1572   Object info;
1573
1574   // read config file
1575   globalParams = new GlobalParams("");
1576
1577   // open PDF file
1578   if (userPassword && userPassword[0]) {
1579     userPW = new GString(userPassword);
1580   } else {
1581     userPW = NULL;
1582   }
1583   doc = new PDFDoc(fileName, userPW);
1584   if (userPW) {
1585     delete userPW;
1586   }
1587   if (!doc->isOk()) {
1588     exit(1);
1589   }
1590
1591   // print doc info
1592   doc->getDocInfo(&info);
1593   if (info.isDict() &&
1594     (screenloglevel>=LOGLEVEL_NOTICE)) {
1595     printInfoString(info.getDict(), "Title",        "Title:        %s\n");
1596     printInfoString(info.getDict(), "Subject",      "Subject:      %s\n");
1597     printInfoString(info.getDict(), "Keywords",     "Keywords:     %s\n");
1598     printInfoString(info.getDict(), "Author",       "Author:       %s\n");
1599     printInfoString(info.getDict(), "Creator",      "Creator:      %s\n");
1600     printInfoString(info.getDict(), "Producer",     "Producer:     %s\n");
1601     printInfoDate(info.getDict(),   "CreationDate", "CreationDate: %s\n");
1602     printInfoDate(info.getDict(),   "ModDate",      "ModDate:      %s\n");
1603     printf("Pages:        %d\n", doc->getNumPages());
1604     printf("Linearized:   %s\n", doc->isLinearized() ? "yes" : "no");
1605     printf("Encrypted:    ");
1606     if (doc->isEncrypted()) {
1607       printf("yes (print:%s copy:%s change:%s addNotes:%s)\n",
1608              doc->okToPrint() ? "yes" : "no",
1609              doc->okToCopy() ? "yes" : "no",
1610              doc->okToChange() ? "yes" : "no",
1611              doc->okToAddNotes() ? "yes" : "no");
1612     } else {
1613       printf("no\n");
1614     }
1615   }
1616   info.free();
1617                  
1618   numpages = doc->getNumPages();
1619   if (doc->isEncrypted()) {
1620         if(!doc->okToCopy()) {
1621             printf("PDF disallows copying. Bailing out.\n");
1622             exit(1); //bail out
1623         }
1624         if(!doc->okToChange() || !doc->okToAddNotes())
1625             swfoutput_setprotected();
1626   }
1627
1628   output = new SWFOutputDev();
1629   output->startDoc(doc->getXRef());
1630 }
1631
1632 void pdfswf_setparameter(char*name, char*value)
1633 {
1634     if(!strcmp(name, "drawonlyshapes")) {
1635         drawonlyshapes = atoi(value);
1636     } else if(!strcmp(name, "ignoredraworder")) {
1637         ignoredraworder = atoi(value);
1638     } else if(!strcmp(name, "linksopennewwindow")) {
1639         opennewwindow = atoi(value);
1640     } else if(!strcmp(name, "storeallcharacters")) {
1641         storeallcharacters = atoi(value);
1642     } else if(!strcmp(name, "enablezlib")) {
1643         enablezlib = atoi(value);
1644     } else if(!strcmp(name, "insertstop")) {
1645         insertstoptag = atoi(value);
1646     } else if(!strcmp(name, "flashversion")) {
1647         flashversion = atoi(value);
1648     } else if(!strcmp(name, "jpegquality")) {
1649         int val = atoi(value);
1650         if(val<0) val=0;
1651         if(val>100) val=100;
1652         jpegquality = val;
1653     } else if(!strcmp(name, "outputfilename")) {
1654         swffilename = value;
1655     } else if(!strcmp(name, "caplinewidth")) {
1656         caplinewidth = atof(value);
1657     } else if(!strcmp(name, "splinequality")) {
1658         int v = atoi(value);
1659         v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1660         if(v<1) v = 1;
1661         splinemaxerror = v;
1662     } else if(!strcmp(name, "fontquality")) {
1663         int v = atoi(value);
1664         v = 500-(v*5); // 100% = 0.25 pixel, 0% = 25 pixel
1665         if(v<1) v = 1;
1666         fontsplinemaxerror = v;
1667     } else {
1668         fprintf(stderr, "unknown parameter: %s (=%s)\n", name, value);
1669     }
1670 }
1671
1672 void pdfswf_addfont(char*filename)
1673 {
1674     fonts[fontnum++] = filename;
1675 }
1676
1677 void pdfswf_drawonlyshapes()
1678 {
1679     drawonlyshapes = 1;
1680 }
1681
1682 void pdfswf_ignoredraworder()
1683 {
1684     ignoredraworder = 1;
1685 }
1686
1687 void pdfswf_linksopennewwindow()
1688 {
1689     opennewwindow = 1;
1690 }
1691
1692 void pdfswf_storeallcharacters()
1693 {
1694     storeallcharacters = 1;
1695 }
1696
1697 void pdfswf_enablezlib()
1698 {
1699     enablezlib = 1;
1700 }
1701
1702 void pdfswf_jpegquality(int val)
1703 {
1704     if(val<0) val=0;
1705     if(val>100) val=100;
1706     jpegquality = val;
1707 }
1708
1709 void pdfswf_setoutputfilename(char*_filename)
1710 {
1711     swffilename = _filename;
1712 }
1713
1714 void pdfswf_insertstop()
1715 {
1716     insertstoptag = 1;
1717 }
1718
1719 void pdfswf_setversion(int n)
1720 {
1721     flashversion = n;
1722 }
1723
1724
1725 void pdfswf_convertpage(int page)
1726 {
1727     if(!pages)
1728     {
1729         pages = (int*)malloc(1024*sizeof(int));
1730         pagebuflen = 1024;
1731     } else {
1732         if(pagepos == pagebuflen)
1733         {
1734             pagebuflen+=1024;
1735             pages = (int*)realloc(pages, pagebuflen);
1736         }
1737     }
1738     pages[pagepos++] = page;
1739 }
1740
1741 void pdfswf_performconversion()
1742 {
1743     int t;
1744     for(t=0;t<pagepos;t++)
1745     {
1746        currentpage = pages[t];
1747        doc->displayPage((OutputDev*)output, currentpage, /*dpi*/72, /*rotate*/0, /*doLinks*/(int)1);
1748     }
1749 }
1750
1751 int pdfswf_numpages()
1752 {
1753   return doc->getNumPages();
1754 }
1755 int closed=0;
1756 void pdfswf_close()
1757 {
1758     msg("<debug> pdfswf.cc: pdfswf_close()");
1759     delete output;
1760     delete doc;
1761     //freeParams();
1762     // check for memory leaks
1763     Object::memCheck(stderr);
1764     gMemReport(stderr);
1765 }
1766
1767