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