Ignore:
Timestamp:
Dec 30, 2009, 7:13:45 PM (12 years ago)
Author:
rbri
Message:

PDF plugin: Poppler library updated to version 0.12.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/SplashOutputDev.cc

    r257 r277  
    1616// Copyright (C) 2005 Takashi Iwai <tiwai@suse.de>
    1717// Copyright (C) 2006 Stefan Schweizer <genstef@gentoo.org>
    18 // Copyright (C) 2006-2008 Albert Astals Cid <aacid@kde.org>
     18// Copyright (C) 2006-2009 Albert Astals Cid <aacid@kde.org>
    1919// Copyright (C) 2006 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
    2020// Copyright (C) 2006 Scott Turner <scotty1024@mac.com>
    2121// Copyright (C) 2007 Koji Otani <sho@bbr.jp>
     22// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com>
     23// Copyright (C) 2009 Thomas Freitag <Thomas.Freitag@alfa.de>
     24// Copyright (C) 2009 Carlos Garcia Campos <carlosgc@gnome.org>
     25// Copyright (C) 2009 William Bader <williambader@hotmail.com>
    2226//
    2327// To see a description of the changes please see the Changelog file that
     
    7074}
    7175
     76#if SPLASH_CMYK
     77
     78#include "GfxState_helpers.h"
     79
     80//-------------------------------------------------------------------------
     81// helper for Blend functions (convert CMYK to RGB, do blend, convert back)
     82//-------------------------------------------------------------------------
     83
     84// based in GfxState.cc
     85
     86static void cmykToRGB(SplashColorPtr cmyk, SplashColor rgb) {
     87  double c, m, y, k, c1, m1, y1, k1, r, g, b;
     88
     89  c = colToDbl(byteToCol(cmyk[0]));
     90  m = colToDbl(byteToCol(cmyk[1]));
     91  y = colToDbl(byteToCol(cmyk[2]));
     92  k = colToDbl(byteToCol(cmyk[3]));
     93  c1 = 1 - c;
     94  m1 = 1 - m;
     95  y1 = 1 - y;
     96  k1 = 1 - k;
     97  cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
     98  rgb[0] = colToByte(clip01(dblToCol(r)));
     99  rgb[1] = colToByte(clip01(dblToCol(g)));
     100  rgb[2] = colToByte(clip01(dblToCol(b)));
     101}
     102
     103static void rgbToCMYK(SplashColor rgb, SplashColorPtr cmyk) {
     104  GfxColorComp c, m, y, k;
     105
     106  c = clip01(gfxColorComp1 - byteToCol(rgb[0]));
     107  m = clip01(gfxColorComp1 - byteToCol(rgb[1]));
     108  y = clip01(gfxColorComp1 - byteToCol(rgb[2]));
     109  k = c;
     110  if (m < k) {
     111    k = m;
     112  }
     113  if (y < k) {
     114    k = y;
     115  }
     116  cmyk[0] = colToByte(c - k);
     117  cmyk[1] = colToByte(m - k);
     118  cmyk[2] = colToByte(y - k);
     119  cmyk[3] = colToByte(k);
     120}
     121
     122#endif
     123
    72124//------------------------------------------------------------------------
    73125// Blend functions
     
    78130  int i;
    79131
    80   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    81     blend[i] = (dest[i] * src[i]) / 255;
     132#ifdef SPLASH_CMYK
     133  if (cm == splashModeCMYK8) {
     134    SplashColor rgbSrc;
     135    SplashColor rgbDest;
     136    SplashColor rgbBlend;
     137    cmykToRGB(src, rgbSrc);
     138    cmykToRGB(dest, rgbDest);
     139    for (i = 0; i < 3; ++i) {
     140      rgbBlend[i] = (rgbDest[i] * rgbSrc[i]) / 255;
     141    }
     142    rgbToCMYK(rgbBlend, blend);
     143  } else
     144#endif
     145  {
     146    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     147      blend[i] = (dest[i] * src[i]) / 255;
     148    }
    82149  }
    83150}
     
    87154  int i;
    88155
    89   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    90     blend[i] = dest[i] + src[i] - (dest[i] * src[i]) / 255;
     156#ifdef SPLASH_CMYK
     157  if (cm == splashModeCMYK8) {
     158    SplashColor rgbSrc;
     159    SplashColor rgbDest;
     160    SplashColor rgbBlend;
     161    cmykToRGB(src, rgbSrc);
     162    cmykToRGB(dest, rgbDest);
     163    for (i = 0; i < 3; ++i) {
     164      rgbBlend[i] = rgbDest[i] + rgbSrc[i] - (rgbDest[i] * rgbSrc[i]) / 255;
     165    }
     166    rgbToCMYK(rgbBlend, blend);
     167  } else
     168#endif
     169  {
     170    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     171      blend[i] = dest[i] + src[i] - (dest[i] * src[i]) / 255;
     172    }
    91173  }
    92174}
     
    96178  int i;
    97179
    98   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    99     blend[i] = dest[i] < 0x80
    100                  ? (src[i] * 2 * dest[i]) / 255
    101                  : 255 - 2 * ((255 - src[i]) * (255 - dest[i])) / 255;
     180#ifdef SPLASH_CMYK
     181  if (cm == splashModeCMYK8) {
     182    SplashColor rgbSrc;
     183    SplashColor rgbDest;
     184    SplashColor rgbBlend;
     185    cmykToRGB(src, rgbSrc);
     186    cmykToRGB(dest, rgbDest);
     187    for (i = 0; i < 3; ++i) {
     188      rgbBlend[i] = rgbDest[i] < 0x80
     189                      ? (rgbSrc[i] * 2 * rgbDest[i]) / 255
     190                      : 255 - 2 * ((255 - rgbSrc[i]) * (255 - rgbDest[i])) / 255;
     191    }
     192    rgbToCMYK(rgbBlend, blend);
     193  } else
     194#endif
     195  {
     196    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     197      blend[i] = dest[i] < 0x80
     198                   ? (src[i] * 2 * dest[i]) / 255
     199                   : 255 - 2 * ((255 - src[i]) * (255 - dest[i])) / 255;
     200    }
    102201  }
    103202}
     
    107206  int i;
    108207
    109   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    110     blend[i] = dest[i] < src[i] ? dest[i] : src[i];
     208#ifdef SPLASH_CMYK
     209  if (cm == splashModeCMYK8) {
     210    SplashColor rgbSrc;
     211    SplashColor rgbDest;
     212    SplashColor rgbBlend;
     213    cmykToRGB(src, rgbSrc);
     214    cmykToRGB(dest, rgbDest);
     215    for (i = 0; i < 3; ++i) {
     216      rgbBlend[i] = rgbDest[i] < rgbSrc[i] ? rgbDest[i] : rgbSrc[i];
     217    }
     218    rgbToCMYK(rgbBlend, blend);
     219  } else
     220#endif
     221  {
     222    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     223      blend[i] = dest[i] < src[i] ? dest[i] : src[i];
     224    }
    111225  }
    112226}
     
    116230  int i;
    117231
    118   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    119     blend[i] = dest[i] > src[i] ? dest[i] : src[i];
     232#ifdef SPLASH_CMYK
     233  if (cm == splashModeCMYK8) {
     234    SplashColor rgbSrc;
     235    SplashColor rgbDest;
     236    SplashColor rgbBlend;
     237    cmykToRGB(src, rgbSrc);
     238    cmykToRGB(dest, rgbDest);
     239    for (i = 0; i < 3; ++i) {
     240      rgbBlend[i] = rgbDest[i] > rgbSrc[i] ? rgbDest[i] : rgbSrc[i];
     241    }
     242    rgbToCMYK(rgbBlend, blend);
     243  } else
     244#endif
     245  {
     246    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     247      blend[i] = dest[i] > src[i] ? dest[i] : src[i];
     248    }
    120249  }
    121250}
     
    126255  int i, x;
    127256
    128   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    129     if (src[i] == 255) {
    130       blend[i] = 255;
    131     } else {
    132       x = (dest[i] * 255) / (255 - src[i]);
    133       blend[i] = x <= 255 ? x : 255;
     257#ifdef SPLASH_CMYK
     258  if (cm == splashModeCMYK8) {
     259    SplashColor rgbSrc;
     260    SplashColor rgbDest;
     261    SplashColor rgbBlend;
     262    cmykToRGB(src, rgbSrc);
     263    cmykToRGB(dest, rgbDest);
     264    for (i = 0; i < 3; ++i) {
     265      if (rgbSrc[i] == 255) {
     266        rgbBlend[i] = 255;
     267      } else {
     268        x = (rgbDest[i] * 255) / (255 - rgbSrc[i]);
     269        rgbBlend[i] = x <= 255 ? x : 255;
     270      }
     271    }
     272    rgbToCMYK(rgbBlend, blend);
     273  } else
     274#endif
     275  {
     276    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     277      if (src[i] == 255) {
     278        blend[i] = 255;
     279      } else {
     280        x = (dest[i] * 255) / (255 - src[i]);
     281        blend[i] = x <= 255 ? x : 255;
     282      }
    134283    }
    135284  }
     
    140289  int i, x;
    141290
    142   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    143     if (src[i] == 0) {
    144       blend[i] = 0;
    145     } else {
    146       x = ((255 - dest[i]) * 255) / src[i];
    147       blend[i] = x <= 255 ? 255 - x : 0;
     291#ifdef SPLASH_CMYK
     292  if (cm == splashModeCMYK8) {
     293    SplashColor rgbSrc;
     294    SplashColor rgbDest;
     295    SplashColor rgbBlend;
     296    cmykToRGB(src, rgbSrc);
     297    cmykToRGB(dest, rgbDest);
     298    for (i = 0; i < 3; ++i) {
     299      if (rgbSrc[i] == 0) {
     300        rgbBlend[i] = 0;
     301      } else {
     302        x = ((255 - rgbDest[i]) * 255) / rgbSrc[i];
     303        rgbBlend[i] = x <= 255 ? 255 - x : 0;
     304      }
     305    }
     306    rgbToCMYK(rgbBlend, blend);
     307  } else
     308#endif
     309  {
     310    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     311      if (src[i] == 0) {
     312        blend[i] = 0;
     313      } else {
     314        x = ((255 - dest[i]) * 255) / src[i];
     315        blend[i] = x <= 255 ? 255 - x : 0;
     316      }
    148317    }
    149318  }
     
    154323  int i;
    155324
    156   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    157     blend[i] = src[i] < 0x80
    158                  ? (dest[i] * 2 * src[i]) / 255
    159                  : 255 - 2 * ((255 - dest[i]) * (255 - src[i])) / 255;
     325#ifdef SPLASH_CMYK
     326  if (cm == splashModeCMYK8) {
     327    SplashColor rgbSrc;
     328    SplashColor rgbDest;
     329    SplashColor rgbBlend;
     330    cmykToRGB(src, rgbSrc);
     331    cmykToRGB(dest, rgbDest);
     332    for (i = 0; i < 3; ++i) {
     333      rgbBlend[i] = rgbSrc[i] < 0x80
     334                      ? (rgbDest[i] * 2 * rgbSrc[i]) / 255
     335                      : 255 - 2 * ((255 - rgbDest[i]) * (255 - rgbSrc[i])) / 255;
     336    }
     337    rgbToCMYK(rgbBlend, blend);
     338  } else
     339#endif
     340  {
     341    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     342      blend[i] = src[i] < 0x80
     343                   ? (dest[i] * 2 * src[i]) / 255
     344                   : 255 - 2 * ((255 - dest[i]) * (255 - src[i])) / 255;
     345    }
    160346  }
    161347}
     
    165351  int i, x;
    166352
    167   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    168     if (src[i] < 0x80) {
    169       blend[i] = dest[i] - (255 - 2 * src[i]) * dest[i] * (255 - dest[i]) /
    170                  (255 * 255);
    171     } else {
    172       if (dest[i] < 0x40) {
    173         x = (((((16 * dest[i] - 12 * 255) * dest[i]) / 255)
    174               + 4 * 255) * dest[i]) / 255;
     353#ifdef SPLASH_CMYK
     354  if (cm == splashModeCMYK8) {
     355    SplashColor rgbSrc;
     356    SplashColor rgbDest;
     357    SplashColor rgbBlend;
     358    cmykToRGB(src, rgbSrc);
     359    cmykToRGB(dest, rgbDest);
     360    for (i = 0; i < 3; ++i) {
     361      if (rgbSrc[i] < 0x80) {
     362        rgbBlend[i] = rgbDest[i] - (255 - 2 * rgbSrc[i]) * rgbDest[i] * (255 - rgbDest[i]) / (255 * 255);
    175363      } else {
    176         x = (int)sqrt(255.0 * dest[i]);
    177       }
    178       blend[i] = dest[i] + (2 * src[i] - 255) * (x - dest[i]) / 255;
     364        if (rgbDest[i] < 0x40) {
     365          x = (((((16 * rgbDest[i] - 12 * 255) * rgbDest[i]) / 255) + 4 * 255) * rgbDest[i]) / 255;
     366        } else {
     367          x = (int)sqrt(255.0 * rgbDest[i]);
     368        }
     369        rgbBlend[i] = rgbDest[i] + (2 * rgbSrc[i] - 255) * (x - rgbDest[i]) / 255;
     370      }
     371    }
     372    rgbToCMYK(rgbBlend, blend);
     373  } else
     374#endif
     375  {
     376    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     377      if (src[i] < 0x80) {
     378        blend[i] = dest[i] - (255 - 2 * src[i]) * dest[i] * (255 - dest[i]) / (255 * 255);
     379      } else {
     380        if (dest[i] < 0x40) {
     381          x = (((((16 * dest[i] - 12 * 255) * dest[i]) / 255) + 4 * 255) * dest[i]) / 255;
     382        } else {
     383          x = (int)sqrt(255.0 * dest[i]);
     384        }
     385        blend[i] = dest[i] + (2 * src[i] - 255) * (x - dest[i]) / 255;
     386      }
    179387    }
    180388  }
     
    187395
    188396  for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    189     blend[i] = dest[i] < src[i] ? src[i] - dest[i] : dest[i] - src[i];
     397#ifdef SPLASH_CMYK
     398    if (cm == splashModeCMYK8)
     399    {
     400      blend[i] = dest[i] < src[i] ? 255 - (src[i] - dest[i]) : 255 - (dest[i] - src[i]);
     401    }
     402    else
     403#endif
     404    {
     405      blend[i] = dest[i] < src[i] ? src[i] - dest[i] : dest[i] - src[i];
     406    }
    190407  }
    191408}
     
    195412  int i;
    196413
    197   for (i = 0; i < splashColorModeNComps[cm]; ++i) {
    198     blend[i] = dest[i] + src[i] - (2 * dest[i] * src[i]) / 255;
     414#ifdef SPLASH_CMYK
     415  if (cm == splashModeCMYK8) {
     416    SplashColor rgbSrc;
     417    SplashColor rgbDest;
     418    SplashColor rgbBlend;
     419    cmykToRGB(src, rgbSrc);
     420    cmykToRGB(dest, rgbDest);
     421    for (i = 0; i < 3; ++i) {
     422      rgbBlend[i] = rgbDest[i] + rgbSrc[i] - (2 * rgbDest[i] * rgbSrc[i]) / 255;
     423    }
     424    rgbToCMYK(rgbBlend, blend);
     425  } else
     426#endif
     427  {
     428    for (i = 0; i < splashColorModeNComps[cm]; ++i) {
     429      blend[i] = dest[i] + src[i] - (2 * dest[i] * src[i]) / 255;
     430    }
    199431  }
    200432}
     
    336568                                SplashColorPtr blend, SplashColorMode cm) {
    337569  int hs, ss, vs, hd, sd, vd;
    338 #if SPLASH_CMYK
    339   Guchar r, g, b;
    340 #endif
    341570
    342571  switch (cm) {
     
    355584#if SPLASH_CMYK
    356585  case splashModeCMYK8:
    357     //~ (0xff - ...) should be clipped
    358     cvtRGBToHSV(0xff - (src[0] + src[3]),
    359                 0xff - (src[1] + src[3]),
    360                 0xff - (src[2] + src[3]), &hs, &ss, &vs);
    361     cvtRGBToHSV(0xff - (dest[0] + dest[3]),
    362                 0xff - (dest[1] + dest[3]),
    363                 0xff - (dest[2] + dest[3]), &hd, &sd, &vd);
    364     cvtHSVToRGB(hs, ss, vd, &r, &g, &b);
    365     //~ should do black generation
    366     blend[0] = 0xff - r;
    367     blend[1] = 0xff - g;
    368     blend[2] = 0xff - b;
    369     blend[3] = 0;
     586    SplashColor rgbSrc;
     587    SplashColor rgbDest;
     588    SplashColor rgbBlend;
     589    cmykToRGB(src, rgbSrc);
     590    cmykToRGB(dest, rgbDest);
     591    cvtRGBToHSV(rgbSrc[0], rgbSrc[1], rgbSrc[2], &hs, &ss, &vs);
     592    cvtRGBToHSV(rgbDest[0], rgbDest[1], rgbDest[2], &hd, &sd, &vd);
     593    cvtHSVToRGB(hs, ss, vd, &rgbBlend[0], &rgbBlend[1], &rgbBlend[2]);
     594        rgbToCMYK(rgbBlend, blend);
    370595    break;
    371596#endif
     
    605830                      globalParams->getVectorAntialias() &&
    606831                      colorMode != splashModeMono1;
     832  enableFreeTypeHinting = gFalse;
    607833  setupScreenParams(72.0, 72.0);
    608834  reverseVideo = reverseVideoA;
    609   splashColorCopy(paperColor, paperColorA);
     835  if (paperColorA != NULL) {
     836    splashColorCopy(paperColor, paperColorA);
     837  } else {
     838    splashClearColor(paperColor);
     839  }
     840  keepAlphaChannel = paperColorA == NULL;
    610841
    611842  xref = NULL;
     
    624855  needFontUpdate = gFalse;
    625856  textClipPath = NULL;
    626 
     857  haveCSPattern = gFalse;
    627858  transpGroupStack = NULL;
    628859}
     
    709940#if HAVE_FREETYPE_FREETYPE_H || HAVE_FREETYPE_H
    710941                                    globalParams->getEnableFreeType(),
     942                                    enableFreeTypeHinting,
    711943#endif
    712944                                    allowAntialias &&
     
    7901022
    7911023void SplashOutputDev::endPage() {
    792   if (colorMode != splashModeMono1) {
     1024  if (colorMode != splashModeMono1 && !keepAlphaChannel) {
    7931025    splash->compositeBackground(paperColor);
    7941026  }
     
    9791211void SplashOutputDev::updateFont(GfxState * /*state*/) {
    9801212  needFontUpdate = gTrue;
     1213}
     1214
     1215void SplashOutputDev::updateRender(GfxState *state) {
     1216  int rm;
     1217  rm = state->getRender();
     1218  if (rm == 7 && haveCSPattern) {
     1219    haveCSPattern = gFalse;
     1220    restoreState(state);
     1221  }
    9811222}
    9821223
     
    16731914}
    16741915
     1916void SplashOutputDev::beginTextObject(GfxState *state) {
     1917  if (state->getFillColorSpace()->getMode() == csPattern) {
     1918    haveCSPattern = gTrue;
     1919    saveState(state);
     1920    savedRender = state->getRender();
     1921    state->setRender(7);
     1922  }
     1923}
     1924
    16751925void SplashOutputDev::endTextObject(GfxState *state) {
     1926  if (haveCSPattern) {
     1927    state->setRender(savedRender);
     1928    haveCSPattern = gFalse;
     1929    if (state->getFillColorSpace()->getMode() != csPattern) {
     1930      if (textClipPath) {
     1931        splash->fill(textClipPath, gTrue);
     1932        delete textClipPath;
     1933        textClipPath = NULL;
     1934      }
     1935      restoreState(state);
     1936      updateFillColor(state);
     1937    }
     1938  }
    16761939  if (textClipPath) {
    16771940    splash->clipToPath(textClipPath, gFalse);
     
    17051968}
    17061969
     1970void SplashOutputDev::endMaskClip(GfxState * state) {
     1971        splash->setSoftMask(NULL);
     1972}
     1973
    17071974void SplashOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
    17081975                                    int width, int height, GBool invert,
    1709                                     GBool inlineImg) {
     1976                                    GBool interpolate, GBool inlineImg) {
    17101977  double *ctm;
    17111978  SplashCoord mat[6];
     
    17311998  imgMaskData.y = 0;
    17321999
    1733   splash->fillImageMask(&imageMaskSrc, &imgMaskData, width, height, mat,
    1734                         t3GlyphStack != NULL);
    1735   if (inlineImg) {
    1736     while (imgMaskData.y < height) {
    1737       imgMaskData.imgStr->getLine();
    1738       ++imgMaskData.y;
     2000  if (state->getFillColorSpace()->getMode() == csPattern) {
     2001    SplashBitmap *maskBitmap;
     2002    Splash *maskSplash;
     2003    SplashColor maskColor;
     2004   
     2005    maskBitmap = new SplashBitmap(bitmap->getWidth(), bitmap->getHeight(), 1, splashModeMono8, gFalse);
     2006    maskSplash = new Splash(maskBitmap, vectorAntialias);
     2007    maskColor[0] = 0;
     2008    maskSplash->clear(maskColor);
     2009    maskColor[0] = 0xff;
     2010    maskSplash->setFillPattern(new SplashSolidColor(maskColor));
     2011    maskSplash->fillImageMask(&imageMaskSrc, &imgMaskData,  width, height, mat, t3GlyphStack != NULL);
     2012    delete maskSplash;
     2013    splash->setSoftMask(maskBitmap);
     2014  } else {
     2015    splash->fillImageMask(&imageMaskSrc, &imgMaskData, width, height, mat, t3GlyphStack != NULL);
     2016    if (inlineImg) {
     2017      while (imgMaskData.y < height) {
     2018        imgMaskData.imgStr->getLine();
     2019        ++imgMaskData.y;
     2020      }
    17392021    }
    17402022  }
     
    19642246                                int width, int height,
    19652247                                GfxImageColorMap *colorMap,
     2248                                GBool interpolate,
    19662249                                int *maskColors, GBool inlineImg) {
    19672250  double *ctm;
     
    20142297    case splashModeRGB8:
    20152298    case splashModeBGR8:
    2016       imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
     2299      imgData.lookup = (SplashColorPtr)gmallocn(n, 3);
    20172300      for (i = 0; i < n; ++i) {
    20182301        pix = (Guchar)i;
     
    20242307      break;
    20252308    case splashModeXBGR8:
    2026       imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2309      imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    20272310      for (i = 0; i < n; ++i) {
    20282311        pix = (Guchar)i;
     
    20362319#if SPLASH_CMYK
    20372320    case splashModeCMYK8:
    2038       imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2321      imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    20392322      for (i = 0; i < n; ++i) {
    20402323        pix = (Guchar)i;
     
    21782461                                      Stream *str, int width, int height,
    21792462                                      GfxImageColorMap *colorMap,
     2463                                      GBool interpolate,
    21802464                                      Stream *maskStr, int maskWidth,
    2181                                       int maskHeight, GBool maskInvert) {
     2465                                      int maskHeight, GBool maskInvert,
     2466                                      GBool maskInterpolate) {
    21822467  GfxImageColorMap *maskColorMap;
    21832468  Object maskDecode, decodeLow, decodeHigh;
     
    22092494                                        new GfxDeviceGrayColorSpace());
    22102495    maskDecode.free();
    2211     drawSoftMaskedImage(state, ref, str, width, height, colorMap,
    2212                         maskStr, maskWidth, maskHeight, maskColorMap);
     2496    drawSoftMaskedImage(state, ref, str, width, height, colorMap, interpolate,
     2497                        maskStr, maskWidth, maskHeight, maskColorMap, maskInterpolate);
    22132498    delete maskColorMap;
    22142499
     
    22792564      case splashModeRGB8:
    22802565      case splashModeBGR8:
    2281         imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
     2566        imgData.lookup = (SplashColorPtr)gmallocn(n, 3);
    22822567        for (i = 0; i < n; ++i) {
    22832568          pix = (Guchar)i;
     
    22892574        break;
    22902575      case splashModeXBGR8:
    2291         imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2576        imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    22922577        for (i = 0; i < n; ++i) {
    22932578          pix = (Guchar)i;
     
    23012586#if SPLASH_CMYK
    23022587      case splashModeCMYK8:
    2303         imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2588        imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    23042589        for (i = 0; i < n; ++i) {
    23052590          pix = (Guchar)i;
     
    23332618                                          Stream *str, int width, int height,
    23342619                                          GfxImageColorMap *colorMap,
     2620                                          GBool interpolate,
    23352621                                          Stream *maskStr,
    23362622                                          int maskWidth, int maskHeight,
    2337                                           GfxImageColorMap *maskColorMap) {
     2623                                          GfxImageColorMap *maskColorMap,
     2624                                          GBool maskInterpolate) {
    23382625  double *ctm;
    23392626  SplashCoord mat[6];
     
    24222709    case splashModeRGB8:
    24232710    case splashModeBGR8:
    2424       imgData.lookup = (SplashColorPtr)gmalloc(3 * n);
     2711      imgData.lookup = (SplashColorPtr)gmallocn(n, 3);
    24252712      for (i = 0; i < n; ++i) {
    24262713        pix = (Guchar)i;
     
    24322719      break;
    24332720    case splashModeXBGR8:
    2434       imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2721      imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    24352722      for (i = 0; i < n; ++i) {
    24362723        pix = (Guchar)i;
     
    24442731#if SPLASH_CMYK
    24452732    case splashModeCMYK8:
    2446       imgData.lookup = (SplashColorPtr)gmalloc(4 * n);
     2733      imgData.lookup = (SplashColorPtr)gmallocn(n, 4);
    24472734      for (i = 0; i < n; ++i) {
    24482735        pix = (Guchar)i;
     
    27042991  for (y = 0; y < yMax; ++y) {
    27052992    for (x = 0; x < xMax; ++x) {
    2706       tBitmap->getPixel(x, y, color);
    27072993      if (alpha) {
    2708         //~ unimplemented
     2994        p[x] = tBitmap->getAlpha(x, y);
    27092995      } else {
     2996        tBitmap->getPixel(x, y, color);
    27102997        // convert to luminosity
    27112998        switch (colorMode) {
     
    27233010#if SPLASH_CMYK
    27243011        case splashModeCMYK8:
    2725           lum = (1 - color[4] / 255.0)
     3012          lum = (1 - color[3] / 255.0)
    27263013                - (0.3 / 255.0) * color[0]
    27273014                - (0.59 / 255.0) * color[1]
     
    28213108}
    28223109#endif
     3110
     3111void SplashOutputDev::setFreeTypeHinting(GBool enable)
     3112{
     3113  enableFreeTypeHinting = enable;
     3114}
Note: See TracChangeset for help on using the changeset viewer.