vcl/source/bitmap/BitmapTools.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  */
  10
  11 #include <sal/config.h>
  12
  13 #include <array>
  14 #include <utility>
  15
  16 #include <vcl/BitmapTools.hxx>
  17
  18 #include <sal/log.hxx>
  19 #include <comphelper/processfactory.hxx>
  20 #include <comphelper/seqstream.hxx>
  21 #include <vcl/canvastools.hxx>
  22 #include <basegfx/matrix/b2dhommatrix.hxx>
  23
  24 #include <com/sun/star/graphic/SvgTools.hpp>
  25 #include <com/sun/star/graphic/Primitive2DTools.hpp>
  26
  27 #include <drawinglayer/primitive2d/baseprimitive2d.hxx>
  28
  29 #include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
  30
  31 #include <vcl/dibtools.hxx>
  32 #include <vcl/settings.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/virdev.hxx>
  35 #if ENABLE_CAIRO_CANVAS
  36 #include <cairo.h>
  37 #endif
  38 #include <tools/diagnose_ex.h>
  39 #include <tools/fract.hxx>
  40 #include <tools/stream.hxx>
  41 #include <bitmap/BitmapWriteAccess.hxx>
  42
  43 using namespace css;
  44
  45 using drawinglayer::primitive2d::Primitive2DSequence;
  46 using drawinglayer::primitive2d::Primitive2DReference;
  47
  48 namespace vcl::bitmap
  49 {
  50
  51 BitmapEx loadFromName(const OUString& rFileName, const ImageLoadFlags eFlags)
  52 {
  53     bool bSuccess = true;
  54     OUString aIconTheme;
  55     BitmapEx aBitmapEx;
  56     try
  57     {
  58         aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme();
  59         ImageTree::get().loadImage(rFileName, aIconTheme, aBitmapEx, true, eFlags);
  60     }
  61     catch (...)
  62     {
  63         bSuccess = false;
  64     }
  65
  66     SAL_WARN_IF(!bSuccess, "vcl", "vcl::bitmap::loadFromName : could not load image " << rFileName << " via icon theme " << aIconTheme);
  67
  68     return aBitmapEx;
  69 }
  70
  71 void loadFromSvg(SvStream& rStream, const OUString& sPath, BitmapEx& rBitmapEx, double fScalingFactor)
  72 {
  73     uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
  74     const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
  75
  76     std::size_t nSize = rStream.remainingSize();
  77     std::vector<sal_Int8> aBuffer(nSize + 1);
  78     rStream.ReadBytes(aBuffer.data(), nSize);
  79     aBuffer[nSize] = 0;
  80
  81     uno::Sequence<sal_Int8> aData(aBuffer.data(), nSize + 1);
  82     uno::Reference<io::XInputStream> aInputStream(new comphelper::SequenceInputStream(aData));
  83
  84     const Primitive2DSequence aPrimitiveSequence = xSvgParser->getDecomposition(aInputStream, sPath);
  85
  86     if (!aPrimitiveSequence.hasElements())
  87         return;
  88
  89     uno::Sequence<beans::PropertyValue> aViewParameters;
  90
  91     geometry::RealRectangle2D aRealRect;
  92     basegfx::B2DRange aRange;
  93     for (Primitive2DReference const & xReference : aPrimitiveSequence)
  94     {
  95         if (xReference.is())
  96         {
  97             aRealRect = xReference->getRange(aViewParameters);
  98             aRange.expand(basegfx::B2DRange(aRealRect.X1, aRealRect.Y1, aRealRect.X2, aRealRect.Y2));
  99         }
 100     }
 101
 102     aRealRect.X1 = aRange.getMinX();
 103     aRealRect.Y1 = aRange.getMinY();
 104     aRealRect.X2 = aRange.getMaxX();
 105     aRealRect.Y2 = aRange.getMaxY();
 106
 107     double nDPI = 96 * fScalingFactor;
 108
 109     const css::uno::Reference<css::graphic::XPrimitive2DRenderer> xPrimitive2DRenderer = css::graphic::Primitive2DTools::create(xContext);
 110     const css::uno::Reference<css::rendering::XBitmap> xBitmap(
 111         xPrimitive2DRenderer->rasterize(aPrimitiveSequence, aViewParameters, nDPI, nDPI, aRealRect, 256*256));
 112
 113     if (xBitmap.is())
 114     {
 115         const css::uno::Reference<css::rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap, uno::UNO_QUERY_THROW);
 116         rBitmapEx = vcl::unotools::bitmapExFromXBitmap(xIntBmp);
 117     }
 118
 119 }
 120
 121 /** Copy block of image data into the bitmap.
 122     Assumes that the Bitmap has been constructed with the desired size.
 123
 124     @param pData
 125     The block of data to copy
 126     @param nStride
 127     The number of bytes in a scanline, must >= (width * nBitCount / 8)
 128     @param bReversColors
 129     In case the endianness of pData is wrong, you could reverse colors
 130 */
 131 BitmapEx CreateFromData( sal_uInt8 const *pData, sal_Int32 nWidth, sal_Int32 nHeight, sal_Int32 nStride, vcl::PixelFormat ePixelFormat, bool bReversColors )
 132 {
 133     auto nBitCount = sal_uInt16(ePixelFormat);
 134
 135     assert(nStride >= (nWidth * nBitCount / 8));
 136     assert(nBitCount == 1 || nBitCount == 24 || nBitCount == 32);
 137
 138     Bitmap aBmp(Size(nWidth, nHeight), ePixelFormat);
 139
 140     BitmapScopedWriteAccess pWrite(aBmp);
 141     assert(pWrite.get());
 142     if( !pWrite )
 143         return BitmapEx();
 144     std::unique_ptr<AlphaMask> pAlphaMask;
 145     AlphaScopedWriteAccess xMaskAcc;
 146     if (nBitCount == 32)
 147     {
 148         pAlphaMask.reset( new AlphaMask( Size(nWidth, nHeight) ) );
 149         xMaskAcc = AlphaScopedWriteAccess(*pAlphaMask);
 150     }
 151     if (nBitCount == 1)
 152     {
 153         for( tools::Long y = 0; y < nHeight; ++y )
 154         {
 155             sal_uInt8 const *p = pData + y * nStride / 8;
 156             Scanline pScanline = pWrite->GetScanline(y);
 157             for (tools::Long x = 0; x < nWidth; ++x)
 158             {
 159                 int bitIndex = (y * nStride + x) % 8;
 160
 161                 pWrite->SetPixelOnData(pScanline, x, BitmapColor((*p >> bitIndex) & 1));
 162             }
 163         }
 164     }
 165     else
 166     {
 167         for( tools::Long y = 0; y < nHeight; ++y )
 168         {
 169             sal_uInt8 const *p = pData + (y * nStride);
 170             Scanline pScanline = pWrite->GetScanline(y);
 171             for (tools::Long x = 0; x < nWidth; ++x)
 172             {
 173                 BitmapColor col;
 174                 if ( bReversColors )
 175                     col = BitmapColor( p[2], p[1], p[0] );
 176                 else
 177                     col = BitmapColor( p[0], p[1], p[2] );
 178                 pWrite->SetPixelOnData(pScanline, x, col);
 179                 p += nBitCount/8;
 180             }
 181             if (nBitCount == 32)
 182             {
 183                 p = pData + (y * nStride) + 3;
 184                 Scanline pMaskScanLine = xMaskAcc->GetScanline(y);
 185                 for (tools::Long x = 0; x < nWidth; ++x)
 186                 {
 187                     xMaskAcc->SetPixelOnData(pMaskScanLine, x, BitmapColor(*p));
 188                     p += 4;
 189                 }
 190              }
 191         }
 192     }
 193     if (nBitCount == 32)
 194         return BitmapEx(aBmp, *pAlphaMask);
 195     else
 196         return BitmapEx(aBmp);
 197 }
 198
 199 /** Copy block of image data into the bitmap.
 200     Assumes that the Bitmap has been constructed with the desired size.
 201 */
 202 BitmapEx CreateFromData( RawBitmap&& rawBitmap )
 203 {
 204     auto nBitCount = rawBitmap.GetBitCount();
 205     assert( nBitCount == 24 || nBitCount == 32);
 206
 207     auto ePixelFormat = vcl::PixelFormat::INVALID;
 208
 209     if (nBitCount == 24)
 210         ePixelFormat = vcl::PixelFormat::N24_BPP;
 211     else if (nBitCount == 32)
 212         ePixelFormat = vcl::PixelFormat::N32_BPP;
 213
 214     assert(ePixelFormat != vcl::PixelFormat::INVALID);
 215
 216     Bitmap aBmp(rawBitmap.maSize, ePixelFormat);
 217
 218     BitmapScopedWriteAccess pWrite(aBmp);
 219     assert(pWrite.get());
 220     if( !pWrite )
 221         return BitmapEx();
 222     std::unique_ptr<AlphaMask> pAlphaMask;
 223     AlphaScopedWriteAccess xMaskAcc;
 224     if (nBitCount == 32)
 225     {
 226         pAlphaMask.reset( new AlphaMask( rawBitmap.maSize ) );
 227         xMaskAcc = AlphaScopedWriteAccess(*pAlphaMask);
 228     }
 229
 230     auto nHeight = rawBitmap.maSize.getHeight();
 231     auto nWidth = rawBitmap.maSize.getWidth();
 232     auto nStride = nWidth * nBitCount / 8;
 233     for( tools::Long y = 0; y < nHeight; ++y )
 234     {
 235         sal_uInt8 const *p = rawBitmap.mpData.get() + (y * nStride);
 236         Scanline pScanline = pWrite->GetScanline(y);
 237         for (tools::Long x = 0; x < nWidth; ++x)
 238         {
 239             BitmapColor col(p[0], p[1], p[2]);
 240             pWrite->SetPixelOnData(pScanline, x, col);
 241             p += nBitCount/8;
 242         }
 243         if (nBitCount == 32)
 244         {
 245             p = rawBitmap.mpData.get() + (y * nStride) + 3;
 246             Scanline pMaskScanLine = xMaskAcc->GetScanline(y);
 247             for (tools::Long x = 0; x < nWidth; ++x)
 248             {
 249                 xMaskAcc->SetPixelOnData(pMaskScanLine, x, BitmapColor(255 - *p));
 250                 p += 4;
 251             }
 252         }
 253     }
 254     if (nBitCount == 32)
 255         return BitmapEx(aBmp, *pAlphaMask);
 256     else
 257         return BitmapEx(aBmp);
 258 }
 259
 260 #if ENABLE_CAIRO_CANVAS
 261 BitmapEx* CreateFromCairoSurface(Size aSize, cairo_surface_t * pSurface)
 262 {
 263     // FIXME: if we could teach VCL/ about cairo handles, life could
 264     // be significantly better here perhaps.
 265
 266 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
 267     cairo_surface_t *pPixels = cairo_surface_create_similar_image(pSurface,
 268 #else
 269     cairo_surface_t *pPixels = cairo_image_surface_create(
 270 #endif
 271             CAIRO_FORMAT_ARGB32, aSize.Width(), aSize.Height());
 272     cairo_t *pCairo = cairo_create( pPixels );
 273     if( !pPixels || !pCairo || cairo_status(pCairo) != CAIRO_STATUS_SUCCESS )
 274         return nullptr;
 275
 276     // suck ourselves from the X server to this buffer so then we can fiddle with
 277     // Alpha to turn it into the ultra-lame vcl required format and then push it
 278     // all back again later at vast expense [ urgh ]
 279     cairo_set_source_surface( pCairo, pSurface, 0, 0 );
 280     cairo_set_operator( pCairo, CAIRO_OPERATOR_SOURCE );
 281     cairo_paint( pCairo );
 282
 283     Bitmap aRGB(aSize, vcl::PixelFormat::N24_BPP);
 284     ::AlphaMask aMask( aSize );
 285
 286     BitmapScopedWriteAccess pRGBWrite(aRGB);
 287     assert(pRGBWrite);
 288     if (!pRGBWrite)
 289         return nullptr;
 290
 291     AlphaScopedWriteAccess pMaskWrite(aMask);
 292     assert(pMaskWrite);
 293     if (!pMaskWrite)
 294         return nullptr;
 295
 296     cairo_surface_flush(pPixels);
 297     unsigned char *pSrc = cairo_image_surface_get_data( pPixels );
 298     unsigned int nStride = cairo_image_surface_get_stride( pPixels );
 299     vcl::bitmap::lookup_table const & unpremultiply_table = vcl::bitmap::get_unpremultiply_table();
 300     for( tools::Long y = 0; y < aSize.Height(); y++ )
 301     {
 302         sal_uInt32 *pPix = reinterpret_cast<sal_uInt32 *>(pSrc + nStride * y);
 303         for( tools::Long x = 0; x < aSize.Width(); x++ )
 304         {
 305 #if defined OSL_BIGENDIAN
 306             sal_uInt8 nB = (*pPix >> 24);
 307             sal_uInt8 nG = (*pPix >> 16) & 0xff;
 308             sal_uInt8 nR = (*pPix >> 8) & 0xff;
 309             sal_uInt8 nAlpha = *pPix & 0xff;
 310 #else
 311             sal_uInt8 nAlpha = (*pPix >> 24);
 312             sal_uInt8 nR = (*pPix >> 16) & 0xff;
 313             sal_uInt8 nG = (*pPix >> 8) & 0xff;
 314             sal_uInt8 nB = *pPix & 0xff;
 315 #endif
 316             if( nAlpha != 0 && nAlpha != 255 )
 317             {
 318                 // Cairo uses pre-multiplied alpha - we do not => re-multiply
 319                 nR = unpremultiply_table[nAlpha][nR];
 320                 nG = unpremultiply_table[nAlpha][nG];
 321                 nB = unpremultiply_table[nAlpha][nB];
 322             }
 323             pRGBWrite->SetPixel( y, x, BitmapColor( nR, nG, nB ) );
 324             pMaskWrite->SetPixelIndex( y, x, 255 - nAlpha );
 325             pPix++;
 326         }
 327     }
 328
 329     // ignore potential errors above. will get caller a
 330     // uniformly white bitmap, but not that there would
 331     // be error handling in calling code ...
 332     ::BitmapEx *pBitmapEx = new ::BitmapEx( aRGB, aMask );
 333
 334     cairo_destroy( pCairo );
 335     cairo_surface_destroy( pPixels );
 336     return pBitmapEx;
 337 }
 338 #endif
 339
 340 BitmapEx CanvasTransformBitmap( const BitmapEx&                 rBitmap,
 341                                 const ::basegfx::B2DHomMatrix&  rTransform,
 342                                 ::basegfx::B2DRectangle const & rDestRect,
 343                                 ::basegfx::B2DHomMatrix const & rLocalTransform )
 344 {
 345     const Size aBmpSize( rBitmap.GetSizePixel() );
 346     Bitmap aSrcBitmap( rBitmap.GetBitmap() );
 347     Bitmap aSrcAlpha;
 348
 349     // differentiate mask and alpha channel (on-off
 350     // vs. multi-level transparency)
 351     if( rBitmap.IsAlpha() )
 352     {
 353         aSrcAlpha = rBitmap.GetAlpha().GetBitmap();
 354     }
 355
 356     Bitmap::ScopedReadAccess pReadAccess( aSrcBitmap );
 357     Bitmap::ScopedReadAccess pAlphaReadAccess( rBitmap.IsAlpha() ?
 358                                              aSrcAlpha.AcquireReadAccess() :
 359                                              nullptr,
 360                                              aSrcAlpha );
 361
 362     if( pReadAccess.get() == nullptr ||
 363         (pAlphaReadAccess.get() == nullptr && rBitmap.IsAlpha()) )
 364     {
 365         // TODO(E2): Error handling!
 366         ENSURE_OR_THROW( false,
 367                           "transformBitmap(): could not access source bitmap" );
 368     }
 369
 370     // mapping table, to translate pAlphaReadAccess' pixel
 371     // values into destination alpha values (needed e.g. for
 372     // paletted 1-bit masks).
 373     sal_uInt8 aAlphaMap[256];
 374
 375     if( rBitmap.IsAlpha() )
 376     {
 377         // source already has alpha channel - 1:1 mapping,
 378         // i.e. aAlphaMap[0]=0,...,aAlphaMap[255]=255.
 379         sal_uInt8  val=0;
 380         sal_uInt8* pCur=aAlphaMap;
 381         sal_uInt8* const pEnd=&aAlphaMap[256];
 382         while(pCur != pEnd)
 383             *pCur++ = val++;
 384     }
 385     // else: mapping table is not used
 386
 387     const Size aDestBmpSize( ::basegfx::fround( rDestRect.getWidth() ),
 388                              ::basegfx::fround( rDestRect.getHeight() ) );
 389
 390     if( aDestBmpSize.IsEmpty() )
 391         return BitmapEx();
 392
 393     Bitmap aDstBitmap(aDestBmpSize, aSrcBitmap.getPixelFormat(), &pReadAccess->GetPalette());
 394     Bitmap aDstAlpha( AlphaMask( aDestBmpSize ).GetBitmap() );
 395
 396     {
 397         // just to be on the safe side: let the
 398         // ScopedAccessors get destructed before
 399         // copy-constructing the resulting bitmap. This will
 400         // rule out the possibility that cached accessor data
 401         // is not yet written back.
 402         BitmapScopedWriteAccess pWriteAccess( aDstBitmap );
 403         BitmapScopedWriteAccess pAlphaWriteAccess( aDstAlpha );
 404
 405
 406         if( pWriteAccess.get() != nullptr &&
 407             pAlphaWriteAccess.get() != nullptr &&
 408             rTransform.isInvertible() )
 409         {
 410             // we're doing inverse mapping here, i.e. mapping
 411             // points from the destination bitmap back to the
 412             // source
 413             ::basegfx::B2DHomMatrix aTransform( rLocalTransform );
 414             aTransform.invert();
 415
 416             // for the time being, always read as ARGB
 417             for( tools::Long y=0; y<aDestBmpSize.Height(); ++y )
 418             {
 419                 // differentiate mask and alpha channel (on-off
 420                 // vs. multi-level transparency)
 421                 if( rBitmap.IsAlpha() )
 422                 {
 423                     Scanline pScan = pWriteAccess->GetScanline( y );
 424                     Scanline pScanAlpha = pAlphaWriteAccess->GetScanline( y );
 425                     // Handling alpha and mask just the same...
 426                     for( tools::Long x=0; x<aDestBmpSize.Width(); ++x )
 427                     {
 428                         ::basegfx::B2DPoint aPoint(x,y);
 429                         aPoint *= aTransform;
 430
 431                         const int nSrcX( ::basegfx::fround( aPoint.getX() ) );
 432                         const int nSrcY( ::basegfx::fround( aPoint.getY() ) );
 433                         if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
 434                             nSrcY < 0 || nSrcY >= aBmpSize.Height() )
 435                         {
 436                             pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(255) );
 437                         }
 438                         else
 439                         {
 440                             const sal_uInt8 cAlphaIdx = pAlphaReadAccess->GetPixelIndex( nSrcY, nSrcX );
 441                             pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(aAlphaMap[ cAlphaIdx ]) );
 442                             pWriteAccess->SetPixelOnData( pScan, x, pReadAccess->GetPixel( nSrcY, nSrcX ) );
 443                         }
 444                     }
 445                 }
 446                 else
 447                 {
 448                     Scanline pScan = pWriteAccess->GetScanline( y );
 449                     Scanline pScanAlpha = pAlphaWriteAccess->GetScanline( y );
 450                     for( tools::Long x=0; x<aDestBmpSize.Width(); ++x )
 451                     {
 452                         ::basegfx::B2DPoint aPoint(x,y);
 453                         aPoint *= aTransform;
 454
 455                         const int nSrcX( ::basegfx::fround( aPoint.getX() ) );
 456                         const int nSrcY( ::basegfx::fround( aPoint.getY() ) );
 457                         if( nSrcX < 0 || nSrcX >= aBmpSize.Width() ||
 458                             nSrcY < 0 || nSrcY >= aBmpSize.Height() )
 459                         {
 460                             pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(255) );
 461                         }
 462                         else
 463                         {
 464                             pAlphaWriteAccess->SetPixelOnData( pScanAlpha, x, BitmapColor(0) );
 465                             pWriteAccess->SetPixelOnData( pScan, x, pReadAccess->GetPixel( nSrcY,
 466                                                                                  nSrcX ) );
 467                         }
 468                     }
 469                 }
 470             }
 471         }
 472         else
 473         {
 474             // TODO(E2): Error handling!
 475             ENSURE_OR_THROW( false,
 476                               "transformBitmap(): could not access bitmap" );
 477         }
 478     }
 479
 480     return BitmapEx(aDstBitmap, AlphaMask(aDstAlpha));
 481 }
 482
 483
 484 void DrawAlphaBitmapAndAlphaGradient(BitmapEx & rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask & rNewMask)
 485 {
 486     // mix existing and new alpha mask
 487     AlphaMask aOldMask;
 488
 489     if(rBitmapEx.IsAlpha())
 490     {
 491         aOldMask = rBitmapEx.GetAlpha();
 492     }
 493
 494     {
 495         AlphaScopedWriteAccess pOld(aOldMask);
 496
 497         assert(pOld && "Got no access to old alpha mask (!)");
 498
 499         const double fFactor(1.0 / 255.0);
 500
 501         if(bFixedTransparence)
 502         {
 503             const double fOpNew(1.0 - fTransparence);
 504
 505             for(tools::Long y(0); y < pOld->Height(); y++)
 506             {
 507                 Scanline pScanline = pOld->GetScanline( y );
 508                 for(tools::Long x(0); x < pOld->Width(); x++)
 509                 {
 510                     const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline, x) * fFactor));
 511                     const sal_uInt8 aCol(basegfx::fround((1.0 - (fOpOld * fOpNew)) * 255.0));
 512
 513                     pOld->SetPixelOnData(pScanline, x, BitmapColor(aCol));
 514                 }
 515             }
 516         }
 517         else
 518         {
 519             AlphaMask::ScopedReadAccess pNew(rNewMask);
 520
 521             assert(pNew && "Got no access to new alpha mask (!)");
 522
 523             assert(pOld->Width() == pNew->Width() && pOld->Height() == pNew->Height() &&
 524                     "Alpha masks have different sizes (!)");
 525
 526             for(tools::Long y(0); y < pOld->Height(); y++)
 527             {
 528                 Scanline pScanline = pOld->GetScanline( y );
 529                 for(tools::Long x(0); x < pOld->Width(); x++)
 530                 {
 531                     const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline, x) * fFactor));
 532                     const double fOpNew(1.0 - (pNew->GetIndexFromData(pScanline, x) * fFactor));
 533                     const sal_uInt8 aCol(basegfx::fround((1.0 - (fOpOld * fOpNew)) * 255.0));
 534
 535                     pOld->SetPixelOnData(pScanline, x, BitmapColor(aCol));
 536                 }
 537             }
 538         }
 539
 540     }
 541
 542     // apply combined bitmap as mask
 543     rBitmapEx = BitmapEx(rBitmapEx.GetBitmap(), aOldMask);
 544 }
 545
 546
 547 void DrawAndClipBitmap(const Point& rPos, const Size& rSize, const BitmapEx& rBitmap, BitmapEx & aBmpEx, basegfx::B2DPolyPolygon const & rClipPath)
 548 {
 549     ScopedVclPtrInstance< VirtualDevice > pVDev;
 550     MapMode aMapMode( MapUnit::Map100thMM );
 551     aMapMode.SetOrigin( Point( -rPos.X(), -rPos.Y() ) );
 552     const Size aOutputSizePixel( pVDev->LogicToPixel( rSize, aMapMode ) );
 553     const Size aSizePixel( rBitmap.GetSizePixel() );
 554     if ( aOutputSizePixel.Width() && aOutputSizePixel.Height() )
 555     {
 556         aMapMode.SetScaleX( Fraction( aSizePixel.Width(), aOutputSizePixel.Width() ) );
 557         aMapMode.SetScaleY( Fraction( aSizePixel.Height(), aOutputSizePixel.Height() ) );
 558     }
 559     pVDev->SetMapMode( aMapMode );
 560     pVDev->SetOutputSizePixel( aSizePixel );
 561     pVDev->SetFillColor( COL_BLACK );
 562     const tools::PolyPolygon aClip( rClipPath );
 563     pVDev->DrawPolyPolygon( aClip );
 564
 565     // #i50672# Extract whole VDev content (to match size of rBitmap)
 566     pVDev->EnableMapMode( false );
 567     const Bitmap aVDevMask(pVDev->GetBitmap(Point(), aSizePixel));
 568
 569     if(aBmpEx.IsAlpha())
 570     {
 571         // bitmap already uses a Mask or Alpha, we need to blend that with
 572         // the new masking in pVDev.
 573         // need to blend in AlphaMask quality (8Bit)
 574         AlphaMask fromVDev(aVDevMask);
 575         AlphaMask fromBmpEx(aBmpEx.GetAlpha());
 576         AlphaMask::ScopedReadAccess pR(fromVDev);
 577         AlphaScopedWriteAccess pW(fromBmpEx);
 578
 579         if(pR && pW)
 580         {
 581             const tools::Long nWidth(std::min(pR->Width(), pW->Width()));
 582             const tools::Long nHeight(std::min(pR->Height(), pW->Height()));
 583
 584             for(tools::Long nY(0); nY < nHeight; nY++)
 585             {
 586                 Scanline pScanlineR = pR->GetScanline( nY );
 587                 Scanline pScanlineW = pW->GetScanline( nY );
 588                 for(tools::Long nX(0); nX < nWidth; nX++)
 589                 {
 590                     const sal_uInt8 nIndR(pR->GetIndexFromData(pScanlineR, nX));
 591                     const sal_uInt8 nIndW(pW->GetIndexFromData(pScanlineW, nX));
 592
 593                     // these values represent transparency (0 == no, 255 == fully transparent),
 594                     // so to blend these we have to multiply the inverse (opacity)
 595                     // and re-invert the result to transparence
 596                     const sal_uInt8 nCombined(0x00ff - (((0x00ff - nIndR) * (0x00ff - nIndW)) >> 8));
 597
 598                     pW->SetPixelOnData(pScanlineW, nX, BitmapColor(nCombined));
 599                 }
 600             }
 601         }
 602
 603         pR.reset();
 604         pW.reset();
 605         aBmpEx = BitmapEx(aBmpEx.GetBitmap(), fromBmpEx);
 606     }
 607     else
 608     {
 609         // no mask yet, create and add new mask. For better quality, use Alpha,
 610         // this allows the drawn mask being processed with AntiAliasing (AAed)
 611         aBmpEx = BitmapEx(rBitmap.GetBitmap(), aVDevMask);
 612     }
 613 }
 614
 615
 616 css::uno::Sequence< sal_Int8 > GetMaskDIB(BitmapEx const & aBmpEx)
 617 {
 618     if ( aBmpEx.IsAlpha() )
 619     {
 620         SvMemoryStream aMem;
 621         WriteDIB(aBmpEx.GetAlpha().GetBitmap(), aMem, false, true);
 622         return css::uno::Sequence< sal_Int8 >( static_cast<sal_Int8 const *>(aMem.GetData()), aMem.Tell() );
 623     }
 624
 625     return css::uno::Sequence< sal_Int8 >();
 626 }
 627
 628 static bool readAlpha( BitmapReadAccess const * pAlphaReadAcc, tools::Long nY, const tools::Long nWidth, unsigned char* data, tools::Long nOff )
 629 {
 630     bool bIsAlpha = false;
 631     tools::Long nX;
 632     int nAlpha;
 633     Scanline pReadScan;
 634
 635     nOff += 3;
 636
 637     switch( pAlphaReadAcc->GetScanlineFormat() )
 638     {
 639         case ScanlineFormat::N8BitPal:
 640             pReadScan = pAlphaReadAcc->GetScanline( nY );
 641             for( nX = 0; nX < nWidth; nX++ )
 642             {
 643                 BitmapColor const& rColor(
 644                     pAlphaReadAcc->GetPaletteColor(*pReadScan));
 645                 pReadScan++;
 646                 nAlpha = data[ nOff ] = 255 - rColor.GetIndex();
 647                 if( nAlpha != 255 )
 648                     bIsAlpha = true;
 649                 nOff += 4;
 650             }
 651             break;
 652         default:
 653             SAL_INFO( "canvas.cairo", "fallback to GetColor for alpha - slow, format: " << static_cast<int>(pAlphaReadAcc->GetScanlineFormat()) );
 654             for( nX = 0; nX < nWidth; nX++ )
 655             {
 656                 nAlpha = data[ nOff ] = 255 - pAlphaReadAcc->GetColor( nY, nX ).GetIndex();
 657                 if( nAlpha != 255 )
 658                     bIsAlpha = true;
 659                 nOff += 4;
 660             }
 661     }
 662
 663     return bIsAlpha;
 664 }
 665
 666
 667
 668 /**
 669  * @param data will be filled with alpha data, if xBitmap is alpha/transparent image
 670  * @param bHasAlpha will be set to true if resulting surface has alpha
 671  **/
 672 void CanvasCairoExtractBitmapData( BitmapEx const & aBmpEx, Bitmap & aBitmap, unsigned char*& data, bool& bHasAlpha, tools::Long& rnWidth, tools::Long& rnHeight )
 673 {
 674     AlphaMask aAlpha = aBmpEx.GetAlpha();
 675
 676     ::BitmapReadAccess* pBitmapReadAcc = aBitmap.AcquireReadAccess();
 677     ::BitmapReadAccess* pAlphaReadAcc = nullptr;
 678     const tools::Long      nWidth = rnWidth = pBitmapReadAcc->Width();
 679     const tools::Long      nHeight = rnHeight = pBitmapReadAcc->Height();
 680     tools::Long nX, nY;
 681     bool bIsAlpha = false;
 682
 683     if( aBmpEx.IsAlpha() )
 684         pAlphaReadAcc = aAlpha.AcquireReadAccess();
 685
 686     data = static_cast<unsigned char*>(malloc( nWidth*nHeight*4 ));
 687
 688     tools::Long nOff = 0;
 689     ::Color aColor;
 690     unsigned int nAlpha = 255;
 691
 692     vcl::bitmap::lookup_table const & premultiply_table = vcl::bitmap::get_premultiply_table();
 693     for( nY = 0; nY < nHeight; nY++ )
 694     {
 695         ::Scanline pReadScan;
 696
 697         switch( pBitmapReadAcc->GetScanlineFormat() )
 698         {
 699         case ScanlineFormat::N8BitPal:
 700             pReadScan = pBitmapReadAcc->GetScanline( nY );
 701             if( pAlphaReadAcc )
 702                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 703                     bIsAlpha = true;
 704
 705             for( nX = 0; nX < nWidth; nX++ )
 706             {
 707 #ifdef OSL_BIGENDIAN
 708                 if( pAlphaReadAcc )
 709                     nAlpha = data[ nOff++ ];
 710                 else
 711                     nAlpha = data[ nOff++ ] = 255;
 712 #else
 713                 if( pAlphaReadAcc )
 714                     nAlpha = data[ nOff + 3 ];
 715                 else
 716                     nAlpha = data[ nOff + 3 ] = 255;
 717 #endif
 718                 aColor = pBitmapReadAcc->GetPaletteColor(*pReadScan++);
 719
 720 #ifdef OSL_BIGENDIAN
 721                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
 722                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
 723                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
 724 #else
 725                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
 726                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
 727                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
 728                 nOff++;
 729 #endif
 730             }
 731             break;
 732         case ScanlineFormat::N24BitTcBgr:
 733             pReadScan = pBitmapReadAcc->GetScanline( nY );
 734             if( pAlphaReadAcc )
 735                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 736                     bIsAlpha = true;
 737
 738             for( nX = 0; nX < nWidth; nX++ )
 739             {
 740 #ifdef OSL_BIGENDIAN
 741                 if( pAlphaReadAcc )
 742                     nAlpha = data[ nOff ];
 743                 else
 744                     nAlpha = data[ nOff ] = 255;
 745                 data[ nOff + 3 ] = premultiply_table[nAlpha][*pReadScan++];
 746                 data[ nOff + 2 ] = premultiply_table[nAlpha][*pReadScan++];
 747                 data[ nOff + 1 ] = premultiply_table[nAlpha][*pReadScan++];
 748                 nOff += 4;
 749 #else
 750                 if( pAlphaReadAcc )
 751                     nAlpha = data[ nOff + 3 ];
 752                 else
 753                     nAlpha = data[ nOff + 3 ] = 255;
 754                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 755                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 756                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 757                 nOff++;
 758 #endif
 759             }
 760             break;
 761         case ScanlineFormat::N24BitTcRgb:
 762             pReadScan = pBitmapReadAcc->GetScanline( nY );
 763             if( pAlphaReadAcc )
 764                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 765                     bIsAlpha = true;
 766
 767             for( nX = 0; nX < nWidth; nX++ )
 768             {
 769 #ifdef OSL_BIGENDIAN
 770                 if( pAlphaReadAcc )
 771                     nAlpha = data[ nOff++ ];
 772                 else
 773                     nAlpha = data[ nOff++ ] = 255;
 774                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 775                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 776                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 777 #else
 778                 if( pAlphaReadAcc )
 779                     nAlpha = data[ nOff + 3 ];
 780                 else
 781                     nAlpha = data[ nOff + 3 ] = 255;
 782                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
 783                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
 784                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
 785                 pReadScan += 3;
 786                 nOff++;
 787 #endif
 788             }
 789             break;
 790         case ScanlineFormat::N32BitTcBgra:
 791             pReadScan = pBitmapReadAcc->GetScanline( nY );
 792             if( pAlphaReadAcc )
 793                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 794                     bIsAlpha = true;
 795
 796             for( nX = 0; nX < nWidth; nX++ )
 797             {
 798 #ifdef OSL_BIGENDIAN
 799                 if( pAlphaReadAcc )
 800                     nAlpha = data[ nOff++ ];
 801                 else
 802                     nAlpha = data[ nOff++ ] = 255;
 803                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
 804                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
 805                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
 806                 pReadScan += 4;
 807 #else
 808                 if( pAlphaReadAcc )
 809                     nAlpha = data[ nOff + 3 ];
 810                 else
 811                     nAlpha = data[ nOff + 3 ] = 255;
 812                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 813                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 814                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 815                 pReadScan++;
 816                 nOff++;
 817 #endif
 818             }
 819             break;
 820         case ScanlineFormat::N32BitTcRgba:
 821             pReadScan = pBitmapReadAcc->GetScanline( nY );
 822             if( pAlphaReadAcc )
 823                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 824                     bIsAlpha = true;
 825
 826             for( nX = 0; nX < nWidth; nX++ )
 827             {
 828 #ifdef OSL_BIGENDIAN
 829                 if( pAlphaReadAcc )
 830                     nAlpha = data[ nOff ++ ];
 831                 else
 832                     nAlpha = data[ nOff ++ ] = 255;
 833                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 834                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 835                 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
 836                 pReadScan++;
 837 #else
 838                 if( pAlphaReadAcc )
 839                     nAlpha = data[ nOff + 3 ];
 840                 else
 841                     nAlpha = data[ nOff + 3 ] = 255;
 842                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
 843                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
 844                 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
 845                 pReadScan += 4;
 846                 nOff++;
 847 #endif
 848             }
 849             break;
 850         default:
 851             SAL_INFO( "canvas.cairo", "fallback to GetColor - slow, format: " << static_cast<int>(pBitmapReadAcc->GetScanlineFormat()) );
 852
 853             if( pAlphaReadAcc )
 854                 if( readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
 855                     bIsAlpha = true;
 856
 857             for( nX = 0; nX < nWidth; nX++ )
 858             {
 859                 aColor = pBitmapReadAcc->GetColor( nY, nX );
 860
 861                 // cairo need premultiplied color values
 862                 // TODO(rodo) handle endianness
 863 #ifdef OSL_BIGENDIAN
 864                 if( pAlphaReadAcc )
 865                     nAlpha = data[ nOff++ ];
 866                 else
 867                     nAlpha = data[ nOff++ ] = 255;
 868                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
 869                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
 870                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
 871 #else
 872                 if( pAlphaReadAcc )
 873                     nAlpha = data[ nOff + 3 ];
 874                 else
 875                     nAlpha = data[ nOff + 3 ] = 255;
 876                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetBlue()];
 877                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetGreen()];
 878                 data[ nOff++ ] = premultiply_table[nAlpha][aColor.GetRed()];
 879                 nOff ++;
 880 #endif
 881             }
 882         }
 883     }
 884
 885     ::Bitmap::ReleaseAccess( pBitmapReadAcc );
 886     if( pAlphaReadAcc )
 887         aAlpha.ReleaseAccess( pAlphaReadAcc );
 888
 889     bHasAlpha = bIsAlpha;
 890
 891 }
 892
 893     uno::Sequence< sal_Int8 > CanvasExtractBitmapData(BitmapEx const & rBitmapEx, const geometry::IntegerRectangle2D& rect)
 894     {
 895         Bitmap aBitmap( rBitmapEx.GetBitmap() );
 896         Bitmap aAlpha( rBitmapEx.GetAlpha().GetBitmap() );
 897
 898         Bitmap::ScopedReadAccess pReadAccess( aBitmap );
 899         Bitmap::ScopedReadAccess pAlphaReadAccess( aAlpha.IsEmpty() ?
 900                                                  nullptr : aAlpha.AcquireReadAccess(),
 901                                                  aAlpha );
 902
 903         assert( pReadAccess );
 904
 905         // TODO(F1): Support more formats.
 906         const Size aBmpSize( aBitmap.GetSizePixel() );
 907
 908         // for the time being, always return as BGRA
 909         uno::Sequence< sal_Int8 > aRes( 4*aBmpSize.Width()*aBmpSize.Height() );
 910         sal_Int8* pRes = aRes.getArray();
 911
 912         int nCurrPos(0);
 913         for( tools::Long y=rect.Y1;
 914              y<aBmpSize.Height() && y<rect.Y2;
 915              ++y )
 916         {
 917             if( pAlphaReadAccess.get() != nullptr )
 918             {
 919                 Scanline pScanlineReadAlpha = pAlphaReadAccess->GetScanline( y );
 920                 for( tools::Long x=rect.X1;
 921                      x<aBmpSize.Width() && x<rect.X2;
 922                      ++x )
 923                 {
 924                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetRed();
 925                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetGreen();
 926                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetBlue();
 927                     pRes[ nCurrPos++ ] = pAlphaReadAccess->GetIndexFromData( pScanlineReadAlpha, x );
 928                 }
 929             }
 930             else
 931             {
 932                 for( tools::Long x=rect.X1;
 933                      x<aBmpSize.Width() && x<rect.X2;
 934                      ++x )
 935                 {
 936                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetRed();
 937                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetGreen();
 938                     pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetBlue();
 939                     pRes[ nCurrPos++ ] = sal_uInt8(255);
 940                 }
 941             }
 942         }
 943         return aRes;
 944     }
 945
 946     BitmapEx createHistorical8x8FromArray(std::array<sal_uInt8,64> const & pArray, Color aColorPix, Color aColorBack)
 947     {
 948         BitmapPalette aPalette(2);
 949
 950         aPalette[0] = BitmapColor(aColorBack);
 951         aPalette[1] = BitmapColor(aColorPix);
 952
 953         Bitmap aBitmap(Size(8, 8), vcl::PixelFormat::N1_BPP, &aPalette);
 954         BitmapScopedWriteAccess pContent(aBitmap);
 955
 956         for(sal_uInt16 a(0); a < 8; a++)
 957         {
 958             for(sal_uInt16 b(0); b < 8; b++)
 959             {
 960                 if(pArray[(a * 8) + b])
 961                 {
 962                     pContent->SetPixelIndex(a, b, 1);
 963                 }
 964                 else
 965                 {
 966                     pContent->SetPixelIndex(a, b, 0);
 967                 }
 968             }
 969         }
 970
 971         return BitmapEx(aBitmap);
 972     }
 973
 974     bool isHistorical8x8(const BitmapEx& rBitmapEx, Color& o_rBack, Color& o_rFront)
 975     {
 976         bool bRet(false);
 977
 978         if(!rBitmapEx.IsAlpha())
 979         {
 980             Bitmap aBitmap(rBitmapEx.GetBitmap());
 981
 982             if(8 == aBitmap.GetSizePixel().Width() && 8 == aBitmap.GetSizePixel().Height())
 983             {
 984                 if (aBitmap.getPixelFormat() == vcl::PixelFormat::N1_BPP)
 985                 {
 986                     BitmapReadAccess* pRead = aBitmap.AcquireReadAccess();
 987
 988                     if(pRead)
 989                     {
 990                         if(pRead->HasPalette() && 2 == pRead->GetPaletteEntryCount())
 991                         {
 992                             const BitmapPalette& rPalette = pRead->GetPalette();
 993                             o_rFront = rPalette[1];
 994                             o_rBack = rPalette[0];
 995
 996                             bRet = true;
 997                         }
 998
 999                         Bitmap::ReleaseAccess(pRead);
1000                     }
1001                 }
1002                 else
1003                 {
1004                     // Historical 1bpp images are getting really historical,
1005                     // even to the point that e.g. the png loader actually loads
1006                     // them as RGB. But the pattern code in svx relies on this
1007                     // assumption that any 2-color 1bpp bitmap is a pattern, and so it would
1008                     // get confused by RGB. Try to detect if this image is really
1009                     // just two colors and say it's a pattern bitmap if so.
1010                     Bitmap::ScopedReadAccess access(aBitmap);
1011                     o_rBack = access->GetColor(0,0);
1012                     bool foundSecondColor = false;;
1013                     for(tools::Long y = 0; y < access->Height(); ++y)
1014                         for(tools::Long x = 0; x < access->Width(); ++x)
1015                         {
1016                             if(!foundSecondColor)
1017                             {
1018                                 if( access->GetColor(y,x) != o_rBack )
1019                                 {
1020                                     o_rFront = access->GetColor(y,x);
1021                                     foundSecondColor = true;
1022                                     // Hard to know which of the two colors is the background,
1023                                     // select the lighter one.
1024                                     if( o_rFront.GetLuminance() > o_rBack.GetLuminance())
1025                                         std::swap( o_rFront, o_rBack );
1026                                 }
1027                             }
1028                             else
1029                             {
1030                                 if( access->GetColor(y,x) != o_rBack && access->GetColor(y,x) != o_rFront)
1031                                     return false;
1032                             }
1033                         }
1034                     return true;
1035                 }
1036             }
1037         }
1038
1039         return bRet;
1040     }
1041
1042     sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a)
1043     {
1044         return get_unpremultiply_table()[a][c];
1045     }
1046
1047     static constexpr sal_uInt8 unpremultiplyImpl(sal_uInt8 c, sal_uInt8 a)
1048     {
1049         return (a == 0) ? 0 : (c * 255 + a / 2) / a;
1050     }
1051
1052     sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a)
1053     {
1054         return get_premultiply_table()[a][c];
1055     }
1056
1057     static constexpr sal_uInt8 premultiplyImpl(sal_uInt8 c, sal_uInt8 a)
1058     {
1059         return (c * a + 127) / 255;
1060     }
1061
1062     template<int... Is> static constexpr std::array<sal_uInt8, 256> make_unpremultiply_table_row_(
1063         int a, std::integer_sequence<int, Is...>)
1064     {
1065         return {unpremultiplyImpl(Is, a)...};
1066     }
1067
1068     template<int... Is> static constexpr lookup_table make_unpremultiply_table_(
1069         std::integer_sequence<int, Is...>)
1070     {
1071         return {make_unpremultiply_table_row_(Is, std::make_integer_sequence<int, 256>{})...};
1072     }
1073
1074     lookup_table const & get_unpremultiply_table()
1075     {
1076         static constexpr auto unpremultiply_table = make_unpremultiply_table_(
1077             std::make_integer_sequence<int, 256>{});
1078         return unpremultiply_table;
1079     }
1080
1081     template<int... Is> static constexpr std::array<sal_uInt8, 256> make_premultiply_table_row_(
1082         int a, std::integer_sequence<int, Is...>)
1083     {
1084         return {premultiplyImpl(Is, a)...};
1085     }
1086
1087     template<int... Is> static constexpr lookup_table make_premultiply_table_(
1088         std::integer_sequence<int, Is...>)
1089     {
1090         return {make_premultiply_table_row_(Is, std::make_integer_sequence<int, 256>{})...};
1091     }
1092
1093     lookup_table const & get_premultiply_table()
1094     {
1095         static constexpr auto premultiply_table = make_premultiply_table_(
1096             std::make_integer_sequence<int, 256>{});
1097         return premultiply_table;
1098     }
1099
1100 bool convertBitmap32To24Plus8(BitmapEx const & rInput, BitmapEx & rResult)
1101 {
1102     Bitmap aBitmap(rInput.GetBitmap());
1103     if (aBitmap.getPixelFormat() != vcl::PixelFormat::N32_BPP)
1104         return false;
1105
1106     Size aSize = aBitmap.GetSizePixel();
1107     Bitmap aResultBitmap(aSize, vcl::PixelFormat::N24_BPP);
1108     AlphaMask aResultAlpha(aSize);
1109     {
1110         BitmapScopedWriteAccess pResultBitmapAccess(aResultBitmap);
1111         AlphaScopedWriteAccess pResultAlphaAccess(aResultAlpha);
1112
1113         Bitmap::ScopedReadAccess pReadAccess(aBitmap);
1114
1115         for (tools::Long nY = 0; nY < aSize.Height(); ++nY)
1116         {
1117             Scanline aResultScan = pResultBitmapAccess->GetScanline(nY);
1118             Scanline aResultScanAlpha = pResultAlphaAccess->GetScanline(nY);
1119
1120             Scanline aReadScan = pReadAccess->GetScanline(nY);
1121
1122             for (tools::Long nX = 0; nX < aSize.Width(); ++nX)
1123             {
1124                 const BitmapColor aColor = pReadAccess->GetPixelFromData(aReadScan, nX);
1125                 BitmapColor aResultColor(aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue());
1126                 BitmapColor aResultColorAlpha(255 - aColor.GetAlpha(), 255 - aColor.GetAlpha(), 255 - aColor.GetAlpha());
1127
1128                 pResultBitmapAccess->SetPixelOnData(aResultScan, nX, aResultColor);
1129                 pResultAlphaAccess->SetPixelOnData(aResultScanAlpha, nX, aResultColorAlpha);
1130             }
1131         }
1132     }
1133     if (rInput.IsAlpha())
1134         rResult = BitmapEx(aResultBitmap, rInput.GetAlpha());
1135     else
1136         rResult = BitmapEx(aResultBitmap, aResultAlpha);
1137     return true;
1138 }
1139
1140 } // end vcl::bitmap
1141
1142 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */