25#include <com/sun/star/graphic/SvgTools.hpp>
26#include <com/sun/star/graphic/Primitive2DTools.hpp>
30#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
36#if ENABLE_CAIRO_CANVAS
67 SAL_WARN_IF(!bSuccess,
"vcl",
"vcl::bitmap::loadFromName : could not load image " << rFileName <<
" via icon theme " << aIconTheme);
75 const uno::Reference<graphic::XSvgParser> xSvgParser = graphic::SvgTools::create(xContext);
78 std::vector<sal_Int8>
aBuffer(nSize + 1);
82 uno::Sequence<sal_Int8>
aData(
aBuffer.data(), nSize + 1);
85 const Primitive2DSequence aPrimitiveSequence = xSvgParser->getDecomposition(aInputStream, sPath);
87 if (!aPrimitiveSequence.hasElements())
90 uno::Sequence<beans::PropertyValue> aViewParameters;
92 geometry::RealRectangle2D aRealRect;
94 for (css::uno::Reference<css::graphic::XPrimitive2D>
const & xReference : aPrimitiveSequence)
98 aRealRect = xReference->
getRange(aViewParameters);
103 aRealRect.X1 = aRange.
getMinX();
104 aRealRect.Y1 = aRange.
getMinY();
105 aRealRect.X2 = aRange.
getMaxX();
106 aRealRect.Y2 = aRange.
getMaxY();
108 double nDPI = 96 * fScalingFactor;
110 const css::uno::Reference<css::graphic::XPrimitive2DRenderer> xPrimitive2DRenderer = css::graphic::Primitive2DTools::create(xContext);
111 const css::uno::Reference<css::rendering::XBitmap> xBitmap(
112 xPrimitive2DRenderer->rasterize(aPrimitiveSequence, aViewParameters, nDPI, nDPI, aRealRect, 256*256));
116 const css::uno::Reference<css::rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap, uno::UNO_QUERY_THROW);
134 bool bReversColors,
bool bReverseAlpha)
136 auto nBitCount = sal_uInt16(ePixelFormat);
138 assert(nStride >= (nWidth *
nBitCount / 8));
141 Bitmap aBmp(
Size(nWidth, nHeight), ePixelFormat);
144 assert(pWrite.
get());
147 std::unique_ptr<AlphaMask> pAlphaMask;
159 Scanline pScanline = pWrite->GetScanline(
y);
162 int bitIndex = (
y * nStride +
x) % 8;
164 pWrite->SetPixelOnData(pScanline,
x,
BitmapColor((*
p >> bitIndex) & 1));
173 Scanline pScanline = pWrite->GetScanline(
y);
181 pWrite->SetPixelOnData(pScanline,
x, col);
187 Scanline pMaskScanLine = xMaskAcc->GetScanline(
y);
208 auto nBitCount = rawBitmap.GetBitCount();
220 Bitmap aBmp(rawBitmap.maSize, ePixelFormat);
223 assert(pWrite.
get());
226 std::unique_ptr<AlphaMask> pAlphaMask;
234 auto nHeight = rawBitmap.maSize.getHeight();
235 auto nWidth = rawBitmap.maSize.getWidth();
239 sal_uInt8 const *
p = rawBitmap.mpData.get() + (
y * nStride);
240 Scanline pScanline = pWrite->GetScanline(
y);
244 pWrite->SetPixelOnData(pScanline,
x, col);
249 p = rawBitmap.mpData.get() + (
y * nStride) + 3;
250 Scanline pMaskScanLine = xMaskAcc->GetScanline(
y);
253 xMaskAcc->SetPixelOnData(pMaskScanLine,
x,
BitmapColor(255 - *
p));
264#if ENABLE_CAIRO_CANVAS
270#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
271 cairo_surface_t *pPixels = cairo_surface_create_similar_image(pSurface,
275 CAIRO_FORMAT_ARGB32, aSize.
Width(), aSize.
Height());
276 cairo_t *pCairo = cairo_create( pPixels );
277 if( !pPixels || !pCairo || cairo_status(pCairo) != CAIRO_STATUS_SUCCESS )
283 cairo_set_source_surface( pCairo, pSurface, 0, 0 );
284 cairo_set_operator( pCairo, CAIRO_OPERATOR_SOURCE );
285 cairo_paint( pCairo );
300 cairo_surface_flush(pPixels);
301 unsigned char *pSrc = cairo_image_surface_get_data( pPixels );
302 unsigned int nStride = cairo_image_surface_get_stride( pPixels );
303#if !ENABLE_WASM_STRIP_PREMULTIPLY
308 sal_uInt32 *pPix =
reinterpret_cast<sal_uInt32 *
>(pSrc + nStride *
y);
311#if defined OSL_BIGENDIAN
322 if( nAlpha != 0 && nAlpha != 255 )
325#if ENABLE_WASM_STRIP_PREMULTIPLY
330 nR = unpremultiply_table[nAlpha][nR];
331 nG = unpremultiply_table[nAlpha][nG];
332 nB = unpremultiply_table[nAlpha][nB];
335 pRGBWrite->SetPixel( y, x,
BitmapColor( nR, nG, nB ) );
336 pMaskWrite->SetPixelIndex( y, x, 255 - nAlpha );
344 ::BitmapEx *pBitmapEx = new ::BitmapEx( aRGB, aMask );
346 cairo_destroy( pCairo );
347 cairo_surface_destroy( pPixels );
353 const ::basegfx::B2DHomMatrix& rTransform,
374 if( pReadAccess.
get() ==
nullptr ||
375 (pAlphaReadAccess.
get() ==
nullptr && rBitmap.
IsAlpha()) )
379 "transformBitmap(): could not access source bitmap" );
399 const Size aDestBmpSize( ::basegfx::fround( rDestRect.
getWidth() ),
400 ::basegfx::fround( rDestRect.
getHeight() ) );
418 if( pWriteAccess.
get() !=
nullptr &&
419 pAlphaWriteAccess.
get() !=
nullptr &&
420 rTransform.isInvertible() )
435 Scanline pScan = pWriteAccess->GetScanline(
y );
436 Scanline pScanAlpha = pAlphaWriteAccess->GetScanline(
y );
441 aPoint *= aTransform;
443 const int nSrcX( ::basegfx::fround( aPoint.
getX() ) );
444 const int nSrcY( ::basegfx::fround( aPoint.
getY() ) );
445 if( nSrcX < 0 || nSrcX >= aBmpSize.
Width() ||
446 nSrcY < 0 || nSrcY >= aBmpSize.
Height() )
448 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(255) );
453 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(aAlphaMap[ cAlphaIdx ]) );
454 pWriteAccess->SetPixelOnData( pScan,
x, pReadAccess->
GetPixel( nSrcY, nSrcX ) );
460 Scanline pScan = pWriteAccess->GetScanline(
y );
461 Scanline pScanAlpha = pAlphaWriteAccess->GetScanline(
y );
465 aPoint *= aTransform;
467 const int nSrcX( ::basegfx::fround( aPoint.
getX() ) );
468 const int nSrcY( ::basegfx::fround( aPoint.
getY() ) );
469 if( nSrcX < 0 || nSrcX >= aBmpSize.
Width() ||
470 nSrcY < 0 || nSrcY >= aBmpSize.
Height() )
472 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(255) );
476 pAlphaWriteAccess->SetPixelOnData( pScanAlpha,
x,
BitmapColor(0) );
477 pWriteAccess->SetPixelOnData( pScan,
x, pReadAccess->
GetPixel( nSrcY,
488 "transformBitmap(): could not access bitmap" );
509 assert(pOld &&
"Got no access to old alpha mask (!)");
511 const double fFactor(1.0 / 255.0);
513 if(bFixedTransparence)
515 const double fOpNew(1.0 - fTransparence);
519 Scanline pScanline = pOld->GetScanline(
y );
522 const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline,
x) * fFactor));
533 assert(pNew &&
"Got no access to new alpha mask (!)");
535 assert(pOld->Width() == pNew->Width() && pOld->Height() == pNew->Height() &&
536 "Alpha masks have different sizes (!)");
540 Scanline pScanline = pOld->GetScanline(
y );
543 const double fOpOld(1.0 - (pOld->GetIndexFromData(pScanline,
x) * fFactor));
544 const double fOpNew(1.0 - (pNew->GetIndexFromData(pScanline,
x) * fFactor));
562 MapMode aMapMode( MapUnit::Map100thMM );
564 const Size aOutputSizePixel( pVDev->LogicToPixel( rSize, aMapMode ) );
566 if ( aOutputSizePixel.
Width() && aOutputSizePixel.
Height() )
571 pVDev->SetMapMode( aMapMode );
572 pVDev->SetOutputSizePixel( aSizePixel );
575 pVDev->DrawPolyPolygon( aClip );
578 pVDev->EnableMapMode(
false );
579 const Bitmap aVDevMask(pVDev->GetBitmap(
Point(), aSizePixel));
593 const tools::Long nWidth(std::min(pR->Width(), pW->Width()));
594 const tools::Long nHeight(std::min(pR->Height(), pW->Height()));
598 Scanline pScanlineR = pR->GetScanline( nY );
599 Scanline pScanlineW = pW->GetScanline( nY );
602 const sal_uInt8 nIndR(pR->GetIndexFromData(pScanlineR, nX));
603 const sal_uInt8 nIndW(pW->GetIndexFromData(pScanlineW, nX));
608 const sal_uInt8 nCombined(0x00ff - (((0x00ff - nIndR) * (0x00ff - nIndW)) >> 8));
610 pW->SetPixelOnData(pScanlineW, nX,
BitmapColor(nCombined));
634 return css::uno::Sequence< sal_Int8 >(
static_cast<sal_Int8 const *
>(aMem.
GetData()), aMem.
Tell() );
637 return css::uno::Sequence< sal_Int8 >();
642 bool bIsAlpha =
false;
653 for( nX = 0; nX < nWidth; nX++ )
658 nAlpha = data[ nOff ] = 255 - rColor.
GetIndex();
665 SAL_INFO(
"canvas.cairo",
"fallback to GetColor for alpha - slow, format: " <<
static_cast<int>(pAlphaReadAcc->
GetScanlineFormat()) );
666 for( nX = 0; nX < nWidth; nX++ )
693 bool bIsAlpha =
false;
698 data =
static_cast<unsigned char*
>(malloc( nWidth*nHeight*4 ));
702 unsigned int nAlpha = 255;
704#if !ENABLE_WASM_STRIP_PREMULTIPLY
707 for( nY = 0; nY < nHeight; nY++ )
716 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
719 for( nX = 0; nX < nWidth; nX++ )
723 nAlpha = data[ nOff++ ];
725 nAlpha = data[ nOff++ ] = 255;
728 nAlpha = data[ nOff + 3 ];
730 nAlpha = data[ nOff + 3 ] = 255;
735#if ENABLE_WASM_STRIP_PREMULTIPLY
740 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
741 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
742 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
745#if ENABLE_WASM_STRIP_PREMULTIPLY
750 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
751 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
752 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
761 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
764 for( nX = 0; nX < nWidth; nX++ )
768 nAlpha = data[ nOff ];
770 nAlpha = data[ nOff ] = 255;
771#if ENABLE_WASM_STRIP_PREMULTIPLY
776 data[ nOff + 3 ] = premultiply_table[nAlpha][*pReadScan++];
777 data[ nOff + 2 ] = premultiply_table[nAlpha][*pReadScan++];
778 data[ nOff + 1 ] = premultiply_table[nAlpha][*pReadScan++];
783 nAlpha = data[ nOff + 3 ];
785 nAlpha = data[ nOff + 3 ] = 255;
786#if ENABLE_WASM_STRIP_PREMULTIPLY
791 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
792 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
793 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
802 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
805 for( nX = 0; nX < nWidth; nX++ )
809 nAlpha = data[ nOff++ ];
811 nAlpha = data[ nOff++ ] = 255;
812#if ENABLE_WASM_STRIP_PREMULTIPLY
817 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
818 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
819 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
823 nAlpha = data[ nOff + 3 ];
825 nAlpha = data[ nOff + 3 ] = 255;
826#if ENABLE_WASM_STRIP_PREMULTIPLY
831 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
832 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
833 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
843 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
846 for( nX = 0; nX < nWidth; nX++ )
850 nAlpha = data[ nOff++ ];
852 nAlpha = data[ nOff++ ] = 255;
853#if ENABLE_WASM_STRIP_PREMULTIPLY
858 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
859 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
860 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
865 nAlpha = data[ nOff + 3 ];
867 nAlpha = data[ nOff + 3 ] = 255;
868#if ENABLE_WASM_STRIP_PREMULTIPLY
873 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
874 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
875 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
885 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
888 for( nX = 0; nX < nWidth; nX++ )
892 nAlpha = data[ nOff ++ ];
894 nAlpha = data[ nOff ++ ] = 255;
895#if ENABLE_WASM_STRIP_PREMULTIPLY
900 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
901 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
902 data[ nOff++ ] = premultiply_table[nAlpha][*pReadScan++];
907 nAlpha = data[ nOff + 3 ];
909 nAlpha = data[ nOff + 3 ] = 255;
910#if ENABLE_WASM_STRIP_PREMULTIPLY
915 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 2 ]];
916 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 1 ]];
917 data[ nOff++ ] = premultiply_table[nAlpha][pReadScan[ 0 ]];
925 SAL_INFO(
"canvas.cairo",
"fallback to GetColor - slow, format: " <<
static_cast<int>(pBitmapReadAcc->
GetScanlineFormat()) );
928 if(
readAlpha( pAlphaReadAcc, nY, nWidth, data, nOff ) )
931 for( nX = 0; nX < nWidth; nX++ )
933 aColor = pBitmapReadAcc->
GetColor( nY, nX );
939 nAlpha = data[ nOff++ ];
941 nAlpha = data[ nOff++ ] = 255;
942#if ENABLE_WASM_STRIP_PREMULTIPLY
947 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
948 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
949 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
953 nAlpha = data[ nOff + 3 ];
955 nAlpha = data[ nOff + 3 ] = 255;
956#if ENABLE_WASM_STRIP_PREMULTIPLY
961 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetBlue()];
962 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetGreen()];
963 data[ nOff++ ] = premultiply_table[nAlpha][aColor.
GetRed()];
975 bHasAlpha = bIsAlpha;
989 assert( pReadAccess );
995 uno::Sequence< sal_Int8 > aRes( 4*aBmpSize.
Width()*aBmpSize.
Height() );
1003 if( pAlphaReadAccess.
get() !=
nullptr )
1007 x<aBmpSize.
Width() &&
x<rect.X2;
1013 pRes[ nCurrPos++ ] = pAlphaReadAccess->
GetIndexFromData( pScanlineReadAlpha,
x );
1019 x<aBmpSize.
Width() &&
x<rect.X2;
1042 for(sal_uInt16
a(0);
a < 8;
a++)
1044 for(sal_uInt16 b(0); b < 8; b++)
1046 if(pArray[(
a * 8) + b])
1048 pContent->SetPixelIndex(
a, b, 1);
1052 pContent->SetPixelIndex(
a, b, 0);
1079 o_rFront = rPalette[1];
1080 o_rBack = rPalette[0];
1098 bool foundSecondColor =
false;;
1102 if(!foundSecondColor)
1107 foundSecondColor =
true;
1111 std::swap( o_rFront, o_rBack );
1128#if ENABLE_WASM_STRIP_PREMULTIPLY
1131 return (a == 0) ? 0 : (c * 255 +
a / 2) / a;
1136 return (c * a + 127) / 255;
1146 return (
a == 0) ? 0 : (c * 255 +
a / 2) /
a;
1156 return (c *
a + 127) / 255;
1160 int a, std::integer_sequence<int, Is...>)
1166 std::integer_sequence<int, Is...>)
1174 std::make_integer_sequence<int, 256>{});
1175 return unpremultiply_table;
1179 int a, std::integer_sequence<int, Is...>)
1185 std::integer_sequence<int, Is...>)
1193 std::make_integer_sequence<int, 256>{});
1194 return premultiply_table;
1215 Scanline aResultScan = pResultBitmapAccess->GetScanline(nY);
1216 Scanline aResultScanAlpha = pResultAlphaAccess->GetScanline(nY);
1226 pResultBitmapAccess->SetPixelOnData(aResultScan, nX, aResultColor);
1227 pResultAlphaAccess->SetPixelOnData(aResultScanAlpha, nX, aResultColorAlpha);
1234 rResult =
BitmapEx(aResultBitmap, aResultAlpha);
1252 aBmp.
Crop( aSrcRect );
1261 Size aDstSizeTwip(std::abs(rDstSizeTwip.
Width()), std::abs(rDstSizeTwip.
Height()));
1264 const double fBmpPixelX = aBmpSize.
Width();
1265 const double fBmpPixelY = aBmpSize.
Height();
1266 const double fMaxPixelX
1269 const double fMaxPixelY
1274 if (((fBmpPixelX > (fMaxPixelX + 4)) ||
1275 (fBmpPixelY > (fMaxPixelY + 4))) &&
1276 (fBmpPixelY > 0.0) && (fMaxPixelY > 0.0))
1280 const double fBmpWH = fBmpPixelX / fBmpPixelY;
1281 const double fMaxWH = fMaxPixelX / fMaxPixelY;
1283 if (fBmpWH < fMaxWH)
1288 else if (fBmpWH > 0.0)
1295 aBmp.
Scale(aNewBmpSize);
vcl::ScopedBitmapAccess< BitmapWriteAccess, AlphaMask, &AlphaMask::AcquireAlphaWriteAccess > AlphaScopedWriteAccess
struct _cairo_surface cairo_surface_t
const StyleSettings & GetStyleSettings() const
Bitmap const & GetBitmap() const
void ReleaseAccess(BitmapReadAccess *pAccess)
static const AllSettings & GetSettings()
Gets the application's settings.
sal_uInt8 GetIndex() const
AlphaMask GetAlpha() const
Bitmap GetBitmap(Color aTransparentReplaceColor) const
const Size & GetSizePixel() const
tools::Long Height() const
tools::Long Width() const
const BitmapPalette & GetPalette() const
ScanlineFormat GetScanlineFormat() const
sal_uInt16 GetPaletteEntryCount() const
const BitmapColor & GetPaletteColor(sal_uInt16 nColor) const
sal_uInt8 GetPixelIndex(tools::Long nY, tools::Long nX) const
BitmapColor GetPixel(tools::Long nY, tools::Long nX) const
BitmapColor GetColor(tools::Long nY, tools::Long nX) const
BitmapColor GetPixelFromData(const sal_uInt8 *pData, tools::Long nX) const
sal_uInt8 GetIndexFromData(const sal_uInt8 *pData, tools::Long nX) const
Scanline GetScanline(tools::Long nY) const
bool Crop(const tools::Rectangle &rRectPixel)
Crop the bitmap.
Size GetSizePixel() const
static void ReleaseAccess(BitmapInfoAccess *pAccess)
bool Scale(const Size &rNewSize, BmpScaleFlag nScaleFlag=BmpScaleFlag::Default)
Scale the bitmap.
BitmapReadAccess * AcquireReadAccess()
vcl::PixelFormat getPixelFormat() const
sal_uInt8 GetLuminance() const
sal_uInt8 GetBlue() const
sal_uInt8 GetAlpha() const
sal_uInt8 GetGreen() const
static VCL_DLLPUBLIC ImageTree & get()
VCL_DLLPUBLIC bool loadImage(OUString const &name, OUString const &style, BitmapEx &bitmap, bool localized, const ImageLoadFlags eFlags=ImageLoadFlags::NONE)
void SetOrigin(const Point &rOrigin)
void SetScaleY(const Fraction &rScaleY)
void SetScaleX(const Fraction &rScaleX)
constexpr tools::Long Height() const
void setWidth(tools::Long nWidth)
void setHeight(tools::Long nHeight)
constexpr tools::Long Width() const
OUString DetermineIconTheme() const
Determine which icon theme should be used.
std::size_t ReadBytes(void *pData, std::size_t nSize)
sal_uInt64 remainingSize()
B2DVector getRange() const
void expand(const Tuple2D< TYPE > &rTuple)
This template handles BitmapAccess the RAII way.
Intended to be used to feed into CreateFromData to create a BitmapEx.
constexpr ::Color COL_BLACK(0x00, 0x00, 0x00)
#define ENSURE_OR_THROW(c, m)
tools::Long FRound(double fVal)
#define SAL_WARN_IF(condition, area, stream)
#define SAL_INFO(area, stream)
std::unique_ptr< sal_Int32[]> pData
constexpr OUStringLiteral aData
B2IRange fround(const B2DRange &rRange)
Reference< XComponentContext > getProcessComponentContext()
rtl::Reference< BasePrimitive2D > Primitive2DReference
css::uno::Sequence< css::uno::Reference< css::graphic::XPrimitive2D > > Primitive2DSequence
void CanvasCairoExtractBitmapData(BitmapEx const &aBmpEx, Bitmap &aBitmap, unsigned char *&data, bool &bHasAlpha, tools::Long &rnWidth, tools::Long &rnHeight)
bool isHistorical8x8(const BitmapEx &rBitmapEx, Color &o_rBack, Color &o_rFront)
BitmapEx loadFromName(const OUString &rFileName, const ImageLoadFlags eFlags)
lookup_table const & get_unpremultiply_table()
static constexpr lookup_table make_unpremultiply_table_(std::integer_sequence< int, Is... >)
Bitmap GetDownsampledBitmap(Size const &rDstSizeTwip, Point const &rSrcPt, Size const &rSrcSz, Bitmap const &rBmp, tools::Long nMaxBmpDPIX, tools::Long nMaxBmpDPIY)
Retrieve downsampled and cropped bitmap.
static constexpr std::array< sal_uInt8, 256 > make_premultiply_table_row_(int a, std::integer_sequence< int, Is... >)
BitmapEx CanvasTransformBitmap(const BitmapEx &rBitmap, const ::basegfx::B2DHomMatrix &rTransform, ::basegfx::B2DRectangle const &rDestRect, ::basegfx::B2DHomMatrix const &rLocalTransform)
void DrawAlphaBitmapAndAlphaGradient(BitmapEx &rBitmapEx, bool bFixedTransparence, float fTransparence, AlphaMask &rNewMask)
void loadFromSvg(SvStream &rStream, const OUString &sPath, BitmapEx &rBitmapEx, double fScalingFactor)
static constexpr std::array< sal_uInt8, 256 > make_unpremultiply_table_row_(int a, std::integer_sequence< int, Is... >)
void DrawAndClipBitmap(const Point &rPos, const Size &rSize, const BitmapEx &rBitmap, BitmapEx &aBmpEx, basegfx::B2DPolyPolygon const &rClipPath)
sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a)
static constexpr sal_uInt8 premultiplyImpl(sal_uInt8 c, sal_uInt8 a)
BitmapEx CreateFromData(sal_uInt8 const *pData, sal_Int32 nWidth, sal_Int32 nHeight, sal_Int32 nStride, vcl::PixelFormat ePixelFormat, bool bReversColors, bool bReverseAlpha)
Copy block of image data into the bitmap.
BitmapEx createHistorical8x8FromArray(std::array< sal_uInt8, 64 > const &pArray, Color aColorPix, Color aColorBack)
sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a)
static bool readAlpha(BitmapReadAccess const *pAlphaReadAcc, tools::Long nY, const tools::Long nWidth, unsigned char *data, tools::Long nOff)
css::uno::Sequence< sal_Int8 > GetMaskDIB(BitmapEx const &aBmpEx)
uno::Sequence< sal_Int8 > CanvasExtractBitmapData(BitmapEx const &rBitmapEx, const geometry::IntegerRectangle2D &rect)
lookup_table const & get_premultiply_table()
std::array< std::array< sal_uInt8, 256 >, 256 > lookup_table
bool convertBitmap32To24Plus8(BitmapEx const &rInput, BitmapEx &rResult)
static constexpr lookup_table make_premultiply_table_(std::integer_sequence< int, Is... >)
static constexpr sal_uInt8 unpremultiplyImpl(sal_uInt8 c, sal_uInt8 a)
PixelFormat
Pixel format of the bitmap in bits per pixel.
std::unique_ptr< char[]> aBuffer