vcl/headless/svpbmp.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <cstring>
  24
  25 #include <headless/svpbmp.hxx>
  26 #include <headless/svpgdi.hxx>
  27 #include <headless/svpinst.hxx>
  28
  29 #include <basegfx/vector/b2ivector.hxx>
  30 #include <basegfx/range/b2ibox.hxx>
  31 #include <o3tl/safeint.hxx>
  32 #include <vcl/salbtype.hxx>
  33 #include <vcl/bitmap.hxx>
  34
  35 using namespace basegfx;
  36
  37 SvpSalBitmap::~SvpSalBitmap()
  38 {
  39     Destroy();
  40 }
  41
  42 static std::unique_ptr<BitmapBuffer> ImplCreateDIB(
  43     const Size& rSize,
  44     sal_uInt16 nBitCount,
  45     const BitmapPalette& rPal)
  46 {
  47     assert(
  48           (nBitCount ==  0
  49         || nBitCount ==  1
  50         || nBitCount ==  4
  51         || nBitCount ==  8
  52         || nBitCount == 16
  53         || nBitCount == 24
  54         || nBitCount == 32)
  55         && "Unsupported BitCount!");
  56
  57     if (!rSize.Width() || !rSize.Height())
  58         return nullptr;
  59
  60     std::unique_ptr<BitmapBuffer> pDIB;
  61
  62     try
  63     {
  64         pDIB.reset(new BitmapBuffer);
  65     }
  66     catch (const std::bad_alloc&)
  67     {
  68         return nullptr;
  69     }
  70
  71     const sal_uInt16 nColors = ( nBitCount <= 8 ) ? ( 1 << nBitCount ) : 0;
  72
  73     switch (nBitCount)
  74     {
  75         case 1:
  76             pDIB->mnFormat = ScanlineFormat::N1BitLsbPal;
  77             break;
  78         case 4:
  79             pDIB->mnFormat = ScanlineFormat::N4BitMsnPal;
  80             break;
  81         case 8:
  82             pDIB->mnFormat = ScanlineFormat::N8BitPal;
  83             break;
  84         case 16:
  85         {
  86 #ifdef OSL_BIGENDIAN
  87             pDIB->mnFormat= ScanlineFormat::N16BitTcMsbMask;
  88 #else
  89             pDIB->mnFormat= ScanlineFormat::N16BitTcLsbMask;
  90 #endif
  91             ColorMaskElement aRedMask(0xf800);
  92             aRedMask.CalcMaskShift();
  93             ColorMaskElement aGreenMask(0x07e0);
  94             aGreenMask.CalcMaskShift();
  95             ColorMaskElement aBlueMask(0x001f);
  96             aBlueMask.CalcMaskShift();
  97             pDIB->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
  98             break;
  99         }
 100         case 24:
 101             pDIB->mnFormat = SVP_24BIT_FORMAT;
 102             break;
 103         default:
 104             nBitCount = 32;
 105             SAL_FALLTHROUGH;
 106         case 32:
 107             pDIB->mnFormat = SVP_CAIRO_FORMAT;
 108             break;
 109     }
 110
 111     pDIB->mnFormat |= ScanlineFormat::TopDown;
 112     pDIB->mnWidth = rSize.Width();
 113     pDIB->mnHeight = rSize.Height();
 114     long nScanlineBase;
 115     bool bFail = o3tl::checked_multiply<long>(pDIB->mnWidth, nBitCount, nScanlineBase);
 116     if (bFail)
 117     {
 118         SAL_WARN("vcl.gdi", "checked multiply failed");
 119         return nullptr;
 120     }
 121     pDIB->mnScanlineSize = AlignedWidth4Bytes(nScanlineBase);
 122     if (pDIB->mnScanlineSize < nScanlineBase/8)
 123     {
 124         SAL_WARN("vcl.gdi", "scanline calculation wraparound");
 125         return nullptr;
 126     }
 127     pDIB->mnBitCount = nBitCount;
 128
 129     if( nColors )
 130     {
 131         pDIB->maPalette = rPal;
 132         pDIB->maPalette.SetEntryCount( nColors );
 133     }
 134
 135     size_t size;
 136     bFail = o3tl::checked_multiply<size_t>(pDIB->mnHeight, pDIB->mnScanlineSize, size);
 137     SAL_WARN_IF(bFail, "vcl.gdi", "checked multiply failed");
 138     if (bFail || size > SAL_MAX_INT32/2)
 139     {
 140         return nullptr;
 141     }
 142
 143     try
 144     {
 145         pDIB->mpBits = new sal_uInt8[size];
 146 #ifdef __SANITIZE_ADDRESS__
 147         if (!pDIB->mpBits)
 148         {   // can only happen with ASAN allocator_may_return_null=1
 149             pDIB.reset();
 150         }
 151         else
 152 #endif
 153         {
 154             std::memset(pDIB->mpBits, 0, size);
 155         }
 156     }
 157     catch (const std::bad_alloc&)
 158     {
 159         pDIB.reset();
 160     }
 161
 162     return pDIB;
 163 }
 164
 165 void SvpSalBitmap::Create(std::unique_ptr<BitmapBuffer> pBuf)
 166 {
 167     Destroy();
 168     mpDIB = std::move(pBuf);
 169 }
 170
 171 bool SvpSalBitmap::Create(const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal)
 172 {
 173     Destroy();
 174     mpDIB = ImplCreateDIB( rSize, nBitCount, rPal );
 175     return mpDIB != nullptr;
 176 }
 177
 178 bool SvpSalBitmap::Create(const SalBitmap& rBmp)
 179 {
 180     Destroy();
 181
 182     const SvpSalBitmap& rSalBmp = static_cast<const SvpSalBitmap&>(rBmp);
 183
 184     if (rSalBmp.mpDIB)
 185     {
 186         // TODO: reference counting...
 187         mpDIB.reset(new BitmapBuffer( *rSalBmp.mpDIB ));
 188
 189         const size_t size = mpDIB->mnScanlineSize * mpDIB->mnHeight;
 190         if (size > SAL_MAX_INT32/2)
 191         {
 192             mpDIB.reset();
 193             return false;
 194         }
 195
 196         // TODO: get rid of this when BitmapBuffer gets copy constructor
 197         try
 198         {
 199             mpDIB->mpBits = new sal_uInt8[size];
 200             std::memcpy(mpDIB->mpBits, rSalBmp.mpDIB->mpBits, size);
 201         }
 202         catch (const std::bad_alloc&)
 203         {
 204             mpDIB.reset();
 205         }
 206     }
 207
 208     return !rSalBmp.mpDIB || (mpDIB != nullptr);
 209 }
 210
 211 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
 212                            SalGraphics* /*pGraphics*/ )
 213 {
 214     return false;
 215 }
 216
 217 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
 218                            sal_uInt16 /*nNewBitCount*/ )
 219 {
 220     return false;
 221 }
 222
 223 bool SvpSalBitmap::Create( const css::uno::Reference< css::rendering::XBitmapCanvas >& /*xBitmapCanvas*/, Size& /*rSize*/, bool /*bMask*/ )
 224 {
 225     return false;
 226 }
 227
 228 void SvpSalBitmap::Destroy()
 229 {
 230     if (mpDIB)
 231     {
 232         delete[] mpDIB->mpBits;
 233         mpDIB.reset();
 234     }
 235 }
 236
 237 Size SvpSalBitmap::GetSize() const
 238 {
 239     Size aSize;
 240
 241     if (mpDIB)
 242     {
 243         aSize.setWidth( mpDIB->mnWidth );
 244         aSize.setHeight( mpDIB->mnHeight );
 245     }
 246
 247     return aSize;
 248 }
 249
 250 sal_uInt16 SvpSalBitmap::GetBitCount() const
 251 {
 252     sal_uInt16 nBitCount;
 253
 254     if (mpDIB)
 255         nBitCount = mpDIB->mnBitCount;
 256     else
 257         nBitCount = 0;
 258
 259     return nBitCount;
 260 }
 261
 262 BitmapBuffer* SvpSalBitmap::AcquireBuffer(BitmapAccessMode)
 263 {
 264     return mpDIB.get();
 265 }
 266
 267 void SvpSalBitmap::ReleaseBuffer(BitmapBuffer*, BitmapAccessMode nMode)
 268 {
 269     if( nMode == BitmapAccessMode::Write )
 270         InvalidateChecksum();
 271 }
 272
 273 bool SvpSalBitmap::GetSystemData( BitmapSystemData& )
 274 {
 275     return false;
 276 }
 277
 278 bool SvpSalBitmap::ScalingSupported() const
 279 {
 280     return false;
 281 }
 282
 283 bool SvpSalBitmap::Scale( const double& /*rScaleX*/, const double& /*rScaleY*/, BmpScaleFlag /*nScaleFlag*/ )
 284 {
 285     return false;
 286 }
 287
 288 bool SvpSalBitmap::Replace( const ::Color& /*rSearchColor*/, const ::Color& /*rReplaceColor*/, sal_uInt8 /*nTol*/ )
 289 {
 290     return false;
 291 }
 292
 293 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */