poppler: fix drawImage*() parameters
[swftools.git] / lib / pdf / FullBitmapOutputDev.cc
1 /* FullBitmapOutputDev.cc
2
3    Output Device which creates a bitmap.
4
5    Swftools is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9
10    Swftools is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with swftools; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <memory.h>
22 #include "FullBitmapOutputDev.h"
23 #include "GFXOutputDev.h"
24
25 #ifdef HAVE_POPPLER
26   #include "splash/SplashBitmap.h"
27   #include "splash/SplashPattern.h"
28   #include "splash/Splash.h"
29 #else
30   #include "xpdf/config.h"
31   #include "SplashBitmap.h"
32   #include "SplashPattern.h"
33   #include "Splash.h"
34 #endif
35
36 #include "../log.h"
37 #include "../png.h"
38 #include "../devices/record.h"
39
40 static SplashColor splash_white = {255,255,255};
41 static SplashColor splash_black = {0,0,0};
42     
43 FullBitmapOutputDev::FullBitmapOutputDev(InfoOutputDev*info, PDFDoc*doc)
44 {
45     this->doc = doc;
46     this->xref = doc->getXRef();
47     
48     msg("<verbose> Rendering everything to a bitmap");
49     
50     /* color graphic output device, for creating bitmaps */
51     this->rgbdev = new SplashOutputDev(splashModeRGB8, 1, gFalse, splash_white, gTrue, gTrue);
52   
53     /* device for handling links */
54     this->gfxdev = new GFXOutputDev(info, this->doc);
55
56     this->rgbdev->startDoc(this->xref);
57 }
58 FullBitmapOutputDev::~FullBitmapOutputDev()
59 {
60     if(this->rgbdev) {
61         delete this->rgbdev;this->rgbdev = 0;
62     }
63     if(this->gfxdev) {
64         delete this->gfxdev;this->gfxdev= 0;
65     }
66 }
67
68 GBool FullBitmapOutputDev::getVectorAntialias()
69 {
70     return this->rgbdev->getVectorAntialias();
71 }
72 void FullBitmapOutputDev::setVectorAntialias(GBool vaa)
73 {
74     this->rgbdev->setVectorAntialias(vaa);
75 }
76 void FullBitmapOutputDev::setDevice(gfxdevice_t*dev)
77 {
78     this->dev = dev;
79     gfxdev->setDevice(dev);
80 }
81 void FullBitmapOutputDev::setMove(int x,int y)
82 {
83     this->user_movex = x;
84     this->user_movey = y;
85     gfxdev->setMove(x,y);
86 }
87 void FullBitmapOutputDev::setClip(int x1,int y1,int x2,int y2)
88 {
89     this->user_clipx1 = x1;
90     this->user_clipy1 = y1;
91     this->user_clipx2 = x2;
92     this->user_clipy2 = y2;
93     gfxdev->setClip(x1,y1,x2,y2);
94 }
95 void FullBitmapOutputDev::setParameter(const char*key, const char*value)
96 {
97 }
98 void FullBitmapOutputDev::setPageMap(int*pagemap, int pagemap_len)
99 {
100     gfxdev->setPageMap(pagemap, pagemap_len);
101 }
102
103 static void getBitmapBBox(Guchar*alpha, int width, int height, int*xmin, int*ymin, int*xmax, int*ymax)
104 {
105     *ymin = -1;
106     *xmin = width;
107     *xmax = 0;
108     int x,y;
109     for(y=0;y<height;y++) {
110         Guchar*a = &alpha[y*width];
111         for(x=0;x<width;x++) {
112             if(a[x]) break;
113         }
114         int left = x; //first occupied pixel from left
115         int right = x+1; //last non-occupied pixel from right
116         for(;x<width;x++) {
117             if(a[x]) right=x+1;
118         }
119
120         if(left!=width) {
121             if(*ymin<0) 
122                 *ymin=y;
123             *ymax=y+1;
124             if(left<*xmin) *xmin = left;
125             if(right>*xmax) *xmax = right;
126         }
127     }
128     if(*xmin>=*xmax || *ymin>=*ymax) {
129         *xmin = 0;
130         *ymin = 0;
131         *xmax = 0;
132         *ymax = 0;
133     }
134 }
135
136 void FullBitmapOutputDev::flushBitmap()
137 {
138     int width = rgbdev->getBitmapWidth();
139     int height = rgbdev->getBitmapHeight();
140     
141     SplashColorPtr rgb = rgbdev->getBitmap()->getDataPtr();
142     Guchar*alpha = rgbdev->getBitmap()->getAlphaPtr();
143
144     int xmin,ymin,xmax,ymax;
145     getBitmapBBox(alpha, width, height, &xmin,&ymin,&xmax,&ymax);
146
147     /* clip against (-movex, -movey, -movex+width, -movey+height) */
148     if(xmin < -this->movex) xmin = -this->movex;
149     if(ymin < -this->movey) ymin = -this->movey;
150     if(xmax > -this->movex + width) xmax = -this->movex+this->width;
151     if(ymax > -this->movey + height) ymax = -this->movey+this->height;
152
153     msg("<verbose> Flushing bitmap (bbox: %d,%d,%d,%d)", xmin,ymin,xmax,ymax);
154     
155     if((xmax-xmin)<=0 || (ymax-ymin)<=0) // no bitmap, nothing to do
156         return;
157
158     if(sizeof(SplashColor)!=3) {
159         msg("<error> sizeof(SplashColor)!=3");
160         return;
161     }
162     //xmin = ymin = 0;
163     //xmax = width;
164     //ymax = height;
165
166     int rangex = xmax-xmin;
167     int rangey = ymax-ymin;
168     gfximage_t*img = (gfximage_t*)malloc(sizeof(gfximage_t)); 
169     img->data = (gfxcolor_t*)malloc(rangex * rangey * 4);
170     img->width = rangex;
171     img->height = rangey;
172     int x,y;
173     for(y=0;y<rangey;y++) {
174         SplashColorPtr in=&rgb[((y+ymin)*width+xmin)*sizeof(SplashColor)];
175         gfxcolor_t*out = &img->data[y*rangex];
176         Guchar*ain = &alpha[(y+ymin)*width+xmin];
177         for(x=0;x<rangex;x++) {
178             // blend against a white background
179             out[x].r = (in[x*3+0]*ain[x])/255 + 255-ain[x];
180             out[x].g = (in[x*3+1]*ain[x])/255 + 255-ain[x];
181             out[x].b = (in[x*3+2]*ain[x])/255 + 255-ain[x];
182             out[x].a = 255;//ain[x];
183         }
184     }
185     /* transform bitmap rectangle to "device space" */
186     xmin += movex;
187     ymin += movey;
188     xmax += movex;
189     ymax += movey;
190
191     gfxmatrix_t m;
192     m.tx = xmin;
193     m.ty = ymin;
194     m.m00 = m.m11 = 1;
195     m.m10 = m.m01 = 0;
196
197     gfxline_t* line = gfxline_makerectangle(xmin, ymin, xmax, ymax);
198     dev->fillbitmap(dev, line, img, &m, 0);
199     gfxline_free(line);
200
201     free(img->data);img->data=0;free(img);img=0;
202 }
203
204 GBool FullBitmapOutputDev::checkPageSlice(Page *page, double hDPI, double vDPI,
205              int rotate, GBool useMediaBox, GBool crop,
206              int sliceX, int sliceY, int sliceW, int sliceH,
207              GBool printing, Catalog *catalog,
208              GBool (*abortCheckCbk)(void *data),
209              void *abortCheckCbkData)
210 {
211     this->setPage(page);
212     gfxdev->setPage(page);
213     return gTrue;
214 }
215
216 void FullBitmapOutputDev::startPage(int pageNum, GfxState *state)
217 {
218     double x1,y1,x2,y2;
219     PDFRectangle *r = page->getCropBox();
220     state->transform(r->x1,r->y1,&x1,&y1);
221     state->transform(r->x2,r->y2,&x2,&y2);
222     if(x2<x1) {double x3=x1;x1=x2;x2=x3;}
223     if(y2<y1) {double y3=y1;y1=y2;y2=y3;}
224     
225     this->movex = -(int)x1 - user_movex;
226     this->movey = -(int)y1 - user_movey;
227     
228     if(user_clipx1|user_clipy1|user_clipx2|user_clipy2) {
229         x1 = user_clipx1;
230         x2 = user_clipx2;
231         y1 = user_clipy1;
232         y2 = user_clipy2;
233     }
234     this->width = (int)(x2-x1);
235     this->height = (int)(y2-y1);
236
237     msg("<debug> startPage");
238     rgbdev->startPage(pageNum, state);
239     gfxdev->startPage(pageNum, state);
240 }
241
242 void FullBitmapOutputDev::endPage()
243 {
244     msg("<verbose> endPage (FullBitmapOutputDev)");
245     flushBitmap();
246     rgbdev->endPage();
247     gfxdev->endPage();
248 }
249 GBool FullBitmapOutputDev::upsideDown()
250 {
251     return rgbdev->upsideDown();
252 }
253 GBool FullBitmapOutputDev::useDrawChar()
254 {
255     return rgbdev->useDrawChar();
256 }
257 GBool FullBitmapOutputDev::useTilingPatternFill()
258 {
259     return rgbdev->useTilingPatternFill();
260 }
261 GBool FullBitmapOutputDev::useShadedFills()
262 {
263     return rgbdev->useShadedFills();
264 }
265 GBool FullBitmapOutputDev::useDrawForm()
266 {
267     return rgbdev->useDrawForm();
268 }
269 GBool FullBitmapOutputDev::interpretType3Chars()
270 {
271     return rgbdev->interpretType3Chars();
272 }
273 GBool FullBitmapOutputDev::needNonText() 
274 {
275     return rgbdev->needNonText();
276 }
277 void FullBitmapOutputDev::setDefaultCTM(double *ctm) 
278 {
279     rgbdev->setDefaultCTM(ctm);
280     gfxdev->setDefaultCTM(ctm);
281 }
282 void FullBitmapOutputDev::saveState(GfxState *state) 
283 {
284     rgbdev->saveState(state);
285 }
286 void FullBitmapOutputDev::restoreState(GfxState *state) 
287 {
288     rgbdev->restoreState(state);
289 }
290 void FullBitmapOutputDev::updateAll(GfxState *state)
291 {
292     rgbdev->updateAll(state);
293 }
294 void FullBitmapOutputDev::updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32)
295 {
296     rgbdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
297     gfxdev->updateCTM(state,m11,m12,m21,m22,m31,m32);
298 }
299 void FullBitmapOutputDev::updateLineDash(GfxState *state)
300 {
301     rgbdev->updateLineDash(state);
302 }
303 void FullBitmapOutputDev::updateFlatness(GfxState *state)
304 {
305     rgbdev->updateFlatness(state);
306 }
307 void FullBitmapOutputDev::updateLineJoin(GfxState *state)
308 {
309     rgbdev->updateLineJoin(state);
310 }
311 void FullBitmapOutputDev::updateLineCap(GfxState *state)
312 {
313     rgbdev->updateLineCap(state);
314 }
315 void FullBitmapOutputDev::updateMiterLimit(GfxState *state)
316 {
317     rgbdev->updateMiterLimit(state);
318 }
319 void FullBitmapOutputDev::updateLineWidth(GfxState *state)
320 {
321     rgbdev->updateLineWidth(state);
322 }
323 void FullBitmapOutputDev::updateStrokeAdjust(GfxState *state)
324 {
325     rgbdev->updateStrokeAdjust(state);
326 }
327 void FullBitmapOutputDev::updateFillColorSpace(GfxState *state)
328 {
329     rgbdev->updateFillColorSpace(state);
330 }
331 void FullBitmapOutputDev::updateStrokeColorSpace(GfxState *state)
332 {
333     rgbdev->updateStrokeColorSpace(state);
334 }
335 void FullBitmapOutputDev::updateFillColor(GfxState *state)
336 {
337     rgbdev->updateFillColor(state);
338 }
339 void FullBitmapOutputDev::updateStrokeColor(GfxState *state)
340 {
341     rgbdev->updateStrokeColor(state);
342 }
343 void FullBitmapOutputDev::updateBlendMode(GfxState *state)
344 {
345     rgbdev->updateBlendMode(state);
346 }
347 void FullBitmapOutputDev::updateFillOpacity(GfxState *state)
348 {
349     rgbdev->updateFillOpacity(state);
350 }
351 void FullBitmapOutputDev::updateStrokeOpacity(GfxState *state)
352 {
353     rgbdev->updateStrokeOpacity(state);
354 }
355 void FullBitmapOutputDev::updateFillOverprint(GfxState *state)
356 {
357     rgbdev->updateFillOverprint(state);
358 }
359 void FullBitmapOutputDev::updateStrokeOverprint(GfxState *state)
360 {
361     rgbdev->updateStrokeOverprint(state);
362 }
363 void FullBitmapOutputDev::updateTransfer(GfxState *state)
364 {
365     rgbdev->updateTransfer(state);
366 }
367 void FullBitmapOutputDev::updateFont(GfxState *state)
368 {
369     rgbdev->updateFont(state);
370 }
371 void FullBitmapOutputDev::updateTextMat(GfxState *state)
372 {
373     rgbdev->updateTextMat(state);
374 }
375 void FullBitmapOutputDev::updateCharSpace(GfxState *state)
376 {
377     rgbdev->updateCharSpace(state);
378 }
379 void FullBitmapOutputDev::updateRender(GfxState *state)
380 {
381     rgbdev->updateRender(state);
382 }
383 void FullBitmapOutputDev::updateRise(GfxState *state)
384 {
385     rgbdev->updateRise(state);
386 }
387 void FullBitmapOutputDev::updateWordSpace(GfxState *state)
388 {
389     rgbdev->updateWordSpace(state);
390 }
391 void FullBitmapOutputDev::updateHorizScaling(GfxState *state)
392 {
393     rgbdev->updateHorizScaling(state);
394 }
395 void FullBitmapOutputDev::updateTextPos(GfxState *state)
396 {
397     rgbdev->updateTextPos(state);
398 }
399 void FullBitmapOutputDev::updateTextShift(GfxState *state, double shift)
400 {
401     rgbdev->updateTextShift(state, shift);
402 }
403
404 void FullBitmapOutputDev::stroke(GfxState *state)
405 {
406     msg("<debug> stroke");
407     rgbdev->stroke(state);
408 }
409 void FullBitmapOutputDev::fill(GfxState *state)
410 {
411     msg("<debug> fill");
412     rgbdev->fill(state);
413 }
414 void FullBitmapOutputDev::eoFill(GfxState *state)
415 {
416     msg("<debug> eoFill");
417     rgbdev->eoFill(state);
418 }
419 POPPLER_TILING_PATERN_RETURN FullBitmapOutputDev::tilingPatternFill(GfxState *state, POPPLER_TILING_PATERN_GFX
420              Object *str,
421                                int paintType, Dict *resDict,
422                                double *mat, double *bbox,
423                                int x0, int y0, int x1, int y1,
424                                double xStep, double yStep)
425 {
426     msg("<debug> tilingPatternFill");
427 #ifdef HAVE_POPPLER
428     return
429 #endif
430     rgbdev->tilingPatternFill(state, POPPLER_TILING_PATERN_GFX_ARG str, paintType, resDict, mat, bbox, x0, y0, x1, y1, xStep, yStep);
431 }
432
433 GBool FullBitmapOutputDev::functionShadedFill(GfxState *state, GfxFunctionShading *shading) 
434 {
435     msg("<debug> functionShadedFill");
436     return rgbdev->functionShadedFill(state, shading);
437 }
438 GBool FullBitmapOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading)
439 {
440     msg("<debug> axialShadedFill");
441     return rgbdev->axialShadedFill(state, shading);
442 }
443 GBool FullBitmapOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading)
444 {
445     msg("<debug> radialShadedFill");
446     return rgbdev->radialShadedFill(state, shading);
447 }
448
449 void FullBitmapOutputDev::clip(GfxState *state)
450 {
451     msg("<debug> clip");
452     rgbdev->clip(state);
453 }
454 void FullBitmapOutputDev::eoClip(GfxState *state)
455 {
456     msg("<debug> eoClip");
457     rgbdev->eoClip(state);
458 }
459 void FullBitmapOutputDev::clipToStrokePath(GfxState *state)
460 {
461     msg("<debug> clipToStrokePath");
462     rgbdev->clipToStrokePath(state);
463 }
464
465 void FullBitmapOutputDev::beginStringOp(GfxState *state)
466 {
467     msg("<debug> beginStringOp");
468     rgbdev->beginStringOp(state);
469 }
470 void FullBitmapOutputDev::endStringOp(GfxState *state)
471 {
472     msg("<debug> endStringOp");
473     rgbdev->endStringOp(state);
474 }
475 void FullBitmapOutputDev::beginString(GfxState *state, GString *s)
476 {
477     msg("<debug> beginString");
478     rgbdev->beginString(state, s);
479 }
480 void FullBitmapOutputDev::endString(GfxState *state)
481 {
482     msg("<debug> endString");
483     rgbdev->endString(state);
484 }
485 void FullBitmapOutputDev::drawChar(GfxState *state, double x, double y,
486                       double dx, double dy,
487                       double originX, double originY,
488                       CharCode code, int nBytes, Unicode *u, int uLen)
489 {
490     msg("<debug> drawChar");
491     rgbdev->drawChar(state, x, y, dx, dy, originX, originY, code, nBytes, u, uLen);
492 }
493 void FullBitmapOutputDev::drawString(GfxState *state, GString *s)
494 {
495     msg("<error> internal error: drawString not implemented");
496     rgbdev->drawString(state, s);
497 }
498 void FullBitmapOutputDev::endTextObject(GfxState *state)
499 {
500     /* FIXME: the below might render things (stroke outlines etc.) to gfxdev which
501               might end up unflushed- should be handled similarily as
502               drawChar() above
503      */
504     msg("<debug> endTextObject");
505     rgbdev->endTextObject(state);
506 }
507
508 /* TODO: these four operations below *should* do nothing, as type3
509          chars are drawn using operations like fill() */
510 GBool FullBitmapOutputDev::beginType3Char(GfxState *state, double x, double y,
511                              double dx, double dy,
512                              CharCode code, Unicode *u, int uLen)
513 {
514     msg("<debug> beginType3Char");
515     return rgbdev->beginType3Char(state, x, y, dx, dy, code, u, uLen);
516 }
517 void FullBitmapOutputDev::type3D0(GfxState *state, double wx, double wy)
518 {
519     msg("<debug> type3D0");
520     rgbdev->type3D0(state, wx, wy);
521 }
522 void FullBitmapOutputDev::type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury)
523 {
524     msg("<debug> type3D1");
525     rgbdev->type3D1(state, wx, wy, llx, lly, urx, ury);
526 }
527 void FullBitmapOutputDev::endType3Char(GfxState *state)
528 {
529     msg("<debug> endType3Char");
530     rgbdev->endType3Char(state);
531 }
532 void FullBitmapOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
533                            int width, int height, GBool invert, POPPLER_INTERPOLATE
534                            GBool inlineImg)
535 {
536     msg("<debug> drawImageMask");
537     rgbdev->drawImageMask(state, ref, str, width, height, invert, POPPLER_INTERPOLATE_ARG inlineImg);
538 }
539 void FullBitmapOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
540                        int width, int height, GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
541                        int *maskColors, GBool inlineImg)
542 {
543     msg("<debug> drawImage");
544     rgbdev->drawImage(state, ref, str, width, height, colorMap,
545       POPPLER_INTERPOLATE_ARG maskColors, inlineImg);
546 }
547 void FullBitmapOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
548                              int width, int height,
549                              GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
550                              Stream *maskStr, int maskWidth, int maskHeight,
551                              GBool maskInvert POPPLER_MASK_INTERPOLATE)
552 {
553     msg("<debug> drawMaskedImage");
554     rgbdev->drawMaskedImage(state, ref, str, width, height, colorMap,
555       POPPLER_INTERPOLATE_ARG maskStr, maskWidth, maskHeight,
556       maskInvert POPPLER_MASK_INTERPOLATE_ARG);
557 }
558 void FullBitmapOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
559                                  int width, int height,
560                                  GfxImageColorMap *colorMap, POPPLER_INTERPOLATE
561                                  Stream *maskStr, int maskWidth, int maskHeight,
562                                  GfxImageColorMap *maskColorMap POPPLER_MASK_INTERPOLATE)
563 {
564     msg("<debug> drawSoftMaskedImage");
565     rgbdev->drawSoftMaskedImage(state, ref, str, width, height, colorMap,
566       POPPLER_INTERPOLATE_ARG maskStr, maskWidth, maskHeight,
567       maskColorMap POPPLER_MASK_INTERPOLATE_ARG);
568 }
569 void FullBitmapOutputDev::drawForm(Ref id)
570 {
571     msg("<debug> drawForm");
572     rgbdev->drawForm(id);
573 }
574
575 void FullBitmapOutputDev::processLink(Link *link, Catalog *catalog)
576 {
577     msg("<debug> processLink");
578     gfxdev->processLink(link, catalog);
579 }
580
581 void FullBitmapOutputDev::beginTransparencyGroup(GfxState *state, double *bbox,
582                                     GfxColorSpace *blendingColorSpace,
583                                     GBool isolated, GBool knockout,
584                                     GBool forSoftMask)
585 {
586     msg("<debug> beginTransparencyGroup");
587     rgbdev->beginTransparencyGroup(state, bbox, blendingColorSpace, isolated, knockout, forSoftMask);
588 }
589 void FullBitmapOutputDev::endTransparencyGroup(GfxState *state)
590 {
591     msg("<debug> endTransparencyGroup");
592     rgbdev->endTransparencyGroup(state);
593 }
594 void FullBitmapOutputDev::paintTransparencyGroup(GfxState *state, double *bbox)
595 {
596     msg("<debug> paintTransparencyGroup");
597     rgbdev->paintTransparencyGroup(state,bbox);
598 }
599 void FullBitmapOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Function *transferFunc, GfxColor *backdropColor)
600 {
601     msg("<debug> setSoftMask");
602     rgbdev->setSoftMask(state, bbox, alpha, transferFunc, backdropColor);
603 }
604 void FullBitmapOutputDev::clearSoftMask(GfxState *state)
605 {
606     msg("<debug> clearSoftMask");
607     rgbdev->clearSoftMask(state);
608 }
609
610
611