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