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 <tools/helpers.hxx>
  33 #include <vcl/bitmap.hxx>
  34
  35 using namespace basegfx;
  36
  37 SvpSalBitmap::SvpSalBitmap()
  38 :   SalBitmap(),
  39     basegfx::SystemDependentDataHolder(), // MM02
  40     mpDIB()
  41 {
  42 }
  43
  44 SvpSalBitmap::~SvpSalBitmap()
  45 {
  46     Destroy();
  47 }
  48
  49 static std::unique_ptr<BitmapBuffer> ImplCreateDIB(
  50     const Size& rSize,
  51     sal_uInt16 nBitCount,
  52     const BitmapPalette& rPal)
  53 {
  54     assert(
  55           (nBitCount ==  0
  56         || nBitCount ==  1
  57         || nBitCount ==  4
  58         || nBitCount ==  8
  59         || nBitCount == 24
  60         || nBitCount == 32)
  61         && "Unsupported BitCount!");
  62
  63     if (!rSize.Width() || !rSize.Height())
  64         return nullptr;
  65
  66     std::unique_ptr<BitmapBuffer> pDIB;
  67
  68     try
  69     {
  70         pDIB.reset(new BitmapBuffer);
  71     }
  72     catch (const std::bad_alloc&)
  73     {
  74         return nullptr;
  75     }
  76
  77     const sal_uInt16 nColors = ( nBitCount <= 8 ) ? ( 1 << nBitCount ) : 0;
  78
  79     switch (nBitCount)
  80     {
  81         case 1:
  82             pDIB->mnFormat = ScanlineFormat::N1BitLsbPal;
  83             break;
  84         case 4:
  85             pDIB->mnFormat = ScanlineFormat::N4BitMsnPal;
  86             break;
  87         case 8:
  88             pDIB->mnFormat = ScanlineFormat::N8BitPal;
  89             break;
  90         case 24:
  91             pDIB->mnFormat = SVP_24BIT_FORMAT;
  92             break;
  93         default:
  94             nBitCount = 32;
  95             [[fallthrough]];
  96         case 32:
  97             pDIB->mnFormat = SVP_CAIRO_FORMAT;
  98             break;
  99     }
 100
 101     pDIB->mnFormat |= ScanlineFormat::TopDown;
 102     pDIB->mnWidth = rSize.Width();
 103     pDIB->mnHeight = rSize.Height();
 104     tools::Long nScanlineBase;
 105     bool bFail = o3tl::checked_multiply<tools::Long>(pDIB->mnWidth, nBitCount, nScanlineBase);
 106     if (bFail)
 107     {
 108         SAL_WARN("vcl.gdi", "checked multiply failed");
 109         return nullptr;
 110     }
 111     pDIB->mnScanlineSize = AlignedWidth4Bytes(nScanlineBase);
 112     if (pDIB->mnScanlineSize < nScanlineBase/8)
 113     {
 114         SAL_WARN("vcl.gdi", "scanline calculation wraparound");
 115         return nullptr;
 116     }
 117     pDIB->mnBitCount = nBitCount;
 118
 119     if( nColors )
 120     {
 121         pDIB->maPalette = rPal;
 122         pDIB->maPalette.SetEntryCount( nColors );
 123     }
 124
 125     size_t size;
 126     bFail = o3tl::checked_multiply<size_t>(pDIB->mnHeight, pDIB->mnScanlineSize, size);
 127     SAL_WARN_IF(bFail, "vcl.gdi", "checked multiply failed");
 128     if (bFail || size > SAL_MAX_INT32/2)
 129     {
 130         return nullptr;
 131     }
 132
 133     try
 134     {
 135         pDIB->mpBits = new sal_uInt8[size];
 136 #ifdef __SANITIZE_ADDRESS__
 137         if (!pDIB->mpBits)
 138         {   // can only happen with ASAN allocator_may_return_null=1
 139             pDIB.reset();
 140         }
 141         else
 142 #endif
 143         {
 144             std::memset(pDIB->mpBits, 0, size);
 145         }
 146     }
 147     catch (const std::bad_alloc&)
 148     {
 149         pDIB.reset();
 150     }
 151
 152     return pDIB;
 153 }
 154
 155 void SvpSalBitmap::Create(std::unique_ptr<BitmapBuffer> pBuf)
 156 {
 157     Destroy();
 158     mpDIB = std::move(pBuf);
 159 }
 160
 161 bool SvpSalBitmap::Create(const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal)
 162 {
 163     Destroy();
 164     mpDIB = ImplCreateDIB( rSize, nBitCount, rPal );
 165     return mpDIB != nullptr;
 166 }
 167
 168 bool SvpSalBitmap::Create(const SalBitmap& rBmp)
 169 {
 170     Destroy();
 171
 172     const SvpSalBitmap& rSalBmp = static_cast<const SvpSalBitmap&>(rBmp);
 173
 174     if (rSalBmp.mpDIB)
 175     {
 176         // TODO: reference counting...
 177         mpDIB.reset(new BitmapBuffer( *rSalBmp.mpDIB ));
 178
 179         const size_t size = mpDIB->mnScanlineSize * mpDIB->mnHeight;
 180         if (size > SAL_MAX_INT32/2)
 181         {
 182             mpDIB.reset();
 183             return false;
 184         }
 185
 186         // TODO: get rid of this when BitmapBuffer gets copy constructor
 187         try
 188         {
 189             mpDIB->mpBits = new sal_uInt8[size];
 190             std::memcpy(mpDIB->mpBits, rSalBmp.mpDIB->mpBits, size);
 191         }
 192         catch (const std::bad_alloc&)
 193         {
 194             mpDIB.reset();
 195         }
 196     }
 197
 198     return !rSalBmp.mpDIB || (mpDIB != nullptr);
 199 }
 200
 201 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
 202                            SalGraphics* /*pGraphics*/ )
 203 {
 204     return false;
 205 }
 206
 207 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
 208                            sal_uInt16 /*nNewBitCount*/ )
 209 {
 210     return false;
 211 }
 212
 213 bool SvpSalBitmap::Create( const css::uno::Reference< css::rendering::XBitmapCanvas >& /*xBitmapCanvas*/, Size& /*rSize*/, bool /*bMask*/ )
 214 {
 215     return false;
 216 }
 217
 218 void SvpSalBitmap::Destroy()
 219 {
 220     if (mpDIB)
 221     {
 222         delete[] mpDIB->mpBits;
 223         mpDIB.reset();
 224     }
 225 }
 226
 227 Size SvpSalBitmap::GetSize() const
 228 {
 229     Size aSize;
 230
 231     if (mpDIB)
 232     {
 233         aSize.setWidth( mpDIB->mnWidth );
 234         aSize.setHeight( mpDIB->mnHeight );
 235     }
 236
 237     return aSize;
 238 }
 239
 240 sal_uInt16 SvpSalBitmap::GetBitCount() const
 241 {
 242     sal_uInt16 nBitCount;
 243
 244     if (mpDIB)
 245         nBitCount = mpDIB->mnBitCount;
 246     else
 247         nBitCount = 0;
 248
 249     return nBitCount;
 250 }
 251
 252 BitmapBuffer* SvpSalBitmap::AcquireBuffer(BitmapAccessMode)
 253 {
 254     return mpDIB.get();
 255 }
 256
 257 void SvpSalBitmap::ReleaseBuffer(BitmapBuffer*, BitmapAccessMode nMode)
 258 {
 259     if( nMode == BitmapAccessMode::Write )
 260         InvalidateChecksum();
 261 }
 262
 263 bool SvpSalBitmap::GetSystemData( BitmapSystemData& )
 264 {
 265     return false;
 266 }
 267
 268 bool SvpSalBitmap::ScalingSupported() const
 269 {
 270     return false;
 271 }
 272
 273 bool SvpSalBitmap::Scale( const double& /*rScaleX*/, const double& /*rScaleY*/, BmpScaleFlag /*nScaleFlag*/ )
 274 {
 275     return false;
 276 }
 277
 278 bool SvpSalBitmap::Replace( const ::Color& /*rSearchColor*/, const ::Color& /*rReplaceColor*/, sal_uInt8 /*nTol*/ )
 279 {
 280     return false;
 281 }
 282
 283 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */