include/vcl/bitmap.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_VCL_BITMAP_HXX
#define INCLUDED_VCL_BITMAP_HXX
 
#include <tools/degree.hxx>
#include <vcl/checksum.hxx>
#include <vcl/dllapi.h>
#include <vcl/mapmod.hxx>
#include <vcl/region.hxx>
#include <vcl/scopedbitmapaccess.hxx>
#include <vcl/bitmap/BitmapTypes.hxx>
 
#include <o3tl/typed_flags_set.hxx>
 
#include <memory>
 
#define GAMMA( _def_cVal, _def_InvGamma )   (static_cast<sal_uInt8>(MinMax(FRound(pow( _def_cVal/255.0,_def_InvGamma)*255.0),0,255)))
 
class Color;
 
template <typename Arg, typename Ret> class Link;
 
enum class BmpMirrorFlags
{
    NONE             = 0x00,
    Horizontal       = 0x01,
    Vertical         = 0x02,
};
 
namespace o3tl
{
    template<> struct typed_flags<BmpMirrorFlags> : is_typed_flags<BmpMirrorFlags, 0x03> {};
}
 
enum class BmpScaleFlag
{
// Try to preferably use these.
    Default,
    Fast,
    BestQuality,
// Specific algorithms, use only if you really need to (mainly used for tests)
    NearestNeighbor,
    Interpolate, // fast, integer bilinear
    Lanczos,
    BiCubic,
    BiLinear
};
 
#define BMP_COL_TRANS               Color( 252, 3, 251 )
 
enum class BmpConversion
{
    NNONE,
    N1BitThreshold,
    N8BitGreys,
    N8BitColors,
    N24Bit,
    N32Bit,
    N8BitTrans,
    N8BitNoConversion // make 8bit without color conversion (e.g. take the red channel)
};
 
class   BitmapInfoAccess;
class   BitmapReadAccess;
class   BitmapWriteAccess;
class   BitmapPalette;
class   GDIMetaFile;
class   AlphaMask;
class   OutputDevice;
class   SalBitmap;
 
namespace basegfx { class SystemDependentDataHolder; }
 
struct BitmapSystemData
{
    #if defined(_WIN32)
    void* pDIB; // device independent byte buffer
    #elif defined( MACOSX ) || defined( IOS )
    // Nothing needed, apparently
    #else
    void* aPixmap;
    #endif
    int mnWidth;
    int mnHeight;
};
 
class SAL_WARN_UNUSED VCL_DLLPUBLIC Bitmap
{
public:
 
                            Bitmap();
                            Bitmap( const Bitmap& rBitmap );
                            Bitmap( const Size& rSizePixel, vcl::PixelFormat ePixelFormat, const BitmapPalette* pPal = nullptr );
    explicit                Bitmap( std::shared_ptr<SalBitmap> xSalBitmap );
    virtual                 ~Bitmap();
 
    Bitmap&                 operator=( const Bitmap& rBitmap );
    Bitmap&                 operator=( Bitmap&& rBitmap ) noexcept;
    bool                    operator==( const Bitmap& rBitmap ) const;
    bool                    operator!=( const Bitmap& rBitmap ) const { return !operator==(rBitmap); }
 
    inline bool             IsEmpty() const;
    void                    SetEmpty();
 
    inline const MapMode&   GetPrefMapMode() const;
    inline void             SetPrefMapMode( const MapMode& rMapMode );
 
    inline const Size&      GetPrefSize() const;
    inline void             SetPrefSize( const Size& rSize );
 
    Size                    GetSizePixel() const;
 
    vcl::PixelFormat getPixelFormat() const;
    inline sal_Int64        GetSizeBytes() const;
    bool                    HasGreyPalette8Bit() const;
    bool                    HasGreyPaletteAny() const;
    bool                    GetSystemData( BitmapSystemData& rData ) const;
 
    BitmapChecksum          GetChecksum() const;
 
    Bitmap                  CreateDisplayBitmap( OutputDevice* pDisplay ) const;
 
    static const BitmapPalette&
                            GetGreyPalette( int nEntries );
 
public:
 
    bool                    Convert( BmpConversion eConversion );
 
    bool                    Dither();
 
    bool                    Crop( const tools::Rectangle& rRectPixel );
 
    bool                    Expand(
                                sal_Int32 nDX, sal_Int32 nDY,
                                const Color* pInitColor = nullptr );
 
    bool                    CopyPixel(
                                const tools::Rectangle& rRectDst,
                                const tools::Rectangle& rRectSrc,
                                const Bitmap* pBmpSrc = nullptr );
 
    bool                    CopyPixel_AlphaOptimized(
                                const tools::Rectangle& rRectDst,
                                const tools::Rectangle& rRectSrc,
                                const Bitmap* pBmpSrc );
 
    bool                    CombineOr( const Bitmap& rMask );
 
    bool                    Blend(
                                const AlphaMask& rAlpha,
                                const Color& rBackgroundColor );
 
    bool                    Erase( const Color& rFillColor );
 
    bool                    Invert();
 
    bool                    Mirror( BmpMirrorFlags nMirrorFlags );
 
    bool                    Scale( const Size& rNewSize, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );
 
    bool                    Scale( const double& rScaleX, const double& rScaleY, BmpScaleFlag nScaleFlag = BmpScaleFlag::Default );
 
    static bool HasFastScale();
 
    // Adapt the BitCount of rNew to BitCount of total, including grey or color palette
    // Can be used to create alpha/mask bitmaps after their processing in 24bit
    void AdaptBitCount(Bitmap& rNew) const;
 
    bool                    Rotate( Degree10 nAngle10, const Color& rFillColor );
 
    Bitmap                  CreateMask( const Color& rTransColor ) const;
 
    Bitmap                  CreateMask( const Color& rTransColor, sal_uInt8 nTol ) const;
 
    AlphaMask              CreateAlphaMask( const Color& rTransColor ) const;
 
    AlphaMask             CreateAlphaMask( const Color& rTransColor, sal_uInt8 nTol ) const;
 
    vcl::Region                  CreateRegion( const Color& rColor, const tools::Rectangle& rRect ) const;
 
    bool                    Replace( const AlphaMask& rAlpha, const Color& rMergeColor );
 
    bool                    Replace( const Color& rSearchColor, const Color& rReplaceColor, sal_uInt8 nTol = 0 );
 
    bool                    Replace(
                                const Color* pSearchColors,
                                const Color* rReplaceColors,
                                size_t nColorCount,
                                sal_uInt8 const * pTols );
 
    void                    Vectorize(
                                GDIMetaFile& rMtf,
                                sal_uInt8 cReduce,
                                const Link<tools::Long,void>* pProgress );
 
    bool                    Adjust(
                                short nLuminancePercent,
                                short nContrastPercent = 0,
                                short nChannelRPercent = 0,
                                short nChannelGPercent = 0,
                                short nChannelBPercent = 0,
                                double fGamma = 1.0,
                                bool bInvert = false,
                                bool msoBrightness = false );
 
    void                    RemoveBlendedStartColor(
                                const Color& rColor,
                                const AlphaMask& rAlphaMask);
 
    // access to SystemDependentDataHolder, to support overload in derived class(es)
    const basegfx::SystemDependentDataHolder* accessSystemDependentDataHolder() const;
 
public:
    SAL_DLLPRIVATE void     ReassignWithSize(const Bitmap& rBitmap);
 
    SAL_DLLPRIVATE void     ImplMakeUnique();
    const std::shared_ptr<SalBitmap>& ImplGetSalBitmap() const { return mxSalBmp; }
    SAL_DLLPRIVATE void     ImplSetSalBitmap( const std::shared_ptr<SalBitmap>& xImpBmp );
 
    SAL_DLLPRIVATE bool     ImplMakeGreyscales();
 
public:
 
    BitmapInfoAccess*       AcquireInfoAccess();
    BitmapReadAccess*       AcquireReadAccess();
    BitmapWriteAccess*      AcquireWriteAccess();
    static void             ReleaseAccess( BitmapInfoAccess* pAccess );
 
    typedef vcl::ScopedBitmapAccess<BitmapReadAccess, Bitmap, &Bitmap::AcquireReadAccess> ScopedReadAccess;
    typedef vcl::ScopedBitmapAccess<BitmapInfoAccess, Bitmap, &Bitmap::AcquireInfoAccess> ScopedInfoAccess;
 
private:
    SAL_DLLPRIVATE bool ImplConvertUp(vcl::PixelFormat ePixelFormat, Color const* pExtColor = nullptr);
    SAL_DLLPRIVATE bool ImplConvertDown8BPP(Color const* pExtColor = nullptr);
 
private:
    std::shared_ptr<SalBitmap> mxSalBmp;
    MapMode maPrefMapMode;
    Size maPrefSize;
};
 
inline bool Bitmap::IsEmpty() const
{
    return( mxSalBmp == nullptr );
}
 
inline const MapMode& Bitmap::GetPrefMapMode() const
{
    return maPrefMapMode;
}
 
inline void Bitmap::SetPrefMapMode( const MapMode& rMapMode )
{
    maPrefMapMode = rMapMode;
}
 
inline const Size& Bitmap::GetPrefSize() const
{
    return maPrefSize;
}
 
inline void Bitmap::SetPrefSize( const Size& rSize )
{
    maPrefSize = rSize;
}
 
inline sal_Int64 Bitmap::GetSizeBytes() const
{
    const auto aSizePixel = GetSizePixel();
    const sal_Int64 aBitCount = vcl::pixelFormatBitCount(getPixelFormat());
    sal_Int64 aSizeInBytes = (aSizePixel.Width() * aSizePixel.Height() * aBitCount) / 8;
    return aSizeInBytes;
}
 
#endif // INCLUDED_VCL_BITMAP_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */