/* -*- 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 .
*/
#include <com/sun/star/geometry/RealSize2D.hpp>
#include <com/sun/star/geometry/IntegerSize2D.hpp>
#include <com/sun/star/geometry/IntegerPoint2D.hpp>
#include <com/sun/star/geometry/IntegerRectangle2D.hpp>
#include <com/sun/star/rendering/ColorSpaceType.hpp>
#include <com/sun/star/rendering/RenderingIntent.hpp>
#include <com/sun/star/rendering/VolatileContentDestroyedException.hpp>
#include <com/sun/star/rendering/XBitmap.hpp>
#include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
#include <com/sun/star/rendering/ColorComponentTag.hpp>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/vector/b2dsize.hxx>
#include <basegfx/range/b2drectangle.hxx>
#include <basegfx/point/b2ipoint.hxx>
#include <basegfx/range/b2irectangle.hxx>
#include <sal/log.hxx>
#include <tools/helpers.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <vcl/bitmap.hxx>
#include <canvasbitmap.hxx>
#include <vcl/canvastools.hxx>
#include <vcl/BitmapWriteAccess.hxx>
using namespace ::com::sun::star;
namespace vcl::unotools
{
uno::Reference< rendering::XBitmap > xBitmapFromBitmap(const ::Bitmap& inputBitmap )
{
SAL_INFO( "vcl.helper", "vcl::unotools::xBitmapFromBitmapEx()" );
return new vcl::unotools::VclCanvasBitmap( inputBitmap );
}
namespace
{
bool equalsLayout( const rendering::IntegerBitmapLayout& rLHS,
const rendering::IntegerBitmapLayout& rRHS )
{
return
rLHS.ScanLineBytes == rRHS.ScanLineBytes &&
rLHS.ScanLineStride == rRHS.ScanLineStride &&
rLHS.PlaneStride == rRHS.PlaneStride &&
rLHS.ColorSpace == rRHS.ColorSpace &&
rLHS.Palette == rRHS.Palette &&
rLHS.IsMsbFirst == rRHS.IsMsbFirst;
}
bool readBmp( sal_Int32 nWidth,
sal_Int32 nHeight,
const rendering::IntegerBitmapLayout& rLayout,
const uno::Reference< rendering::XIntegerReadOnlyBitmap >& xInputBitmap,
BitmapScopedWriteAccess& rWriteAcc,
bool bHasAlpha )
{
rendering::IntegerBitmapLayout aCurrLayout;
geometry::IntegerRectangle2D aRect;
uno::Sequence<sal_Int8> aPixelData;
uno::Sequence<rendering::RGBColor> aRGBColors;
uno::Sequence<rendering::ARGBColor> aARGBColors;
for( aRect.Y1=0; aRect.Y1<nHeight; ++aRect.Y1 )
{
aRect.X1 = 0; aRect.X2 = nWidth; aRect.Y2 = aRect.Y1+1;
try
{
aPixelData = xInputBitmap->getData(aCurrLayout,aRect);
}
catch( rendering::VolatileContentDestroyedException& )
{
// re-read bmp from the start
return false;
}
if( !equalsLayout(aCurrLayout, rLayout) )
return false; // re-read bmp from the start
Scanline pScanline = rWriteAcc->GetScanline( aRect.Y1 );
if( bHasAlpha )
{
// read ARGB color
aARGBColors = rLayout.ColorSpace->convertIntegerToARGB(aPixelData);
assert( !rWriteAcc->HasPalette() );
for( sal_Int32 x=0; x<nWidth; ++x )
{
const rendering::ARGBColor& rColor=aARGBColors[x];
rWriteAcc->SetPixelOnData( pScanline, x,
BitmapColor( ColorAlpha,
toByteColor(rColor.Red),
toByteColor(rColor.Green),
toByteColor(rColor.Blue),
toByteColor(rColor.Alpha) ));
}
}
else
{
// read RGB color
aRGBColors = rLayout.ColorSpace->convertIntegerToRGB(aPixelData);
if( rWriteAcc->HasPalette() )
{
for( sal_Int32 x=0; x<nWidth; ++x )
{
const rendering::RGBColor& rColor=aRGBColors[x];
rWriteAcc->SetPixelOnData( pScanline, x,
BitmapColor(static_cast<sal_uInt8>(rWriteAcc->GetBestPaletteIndex(
BitmapColor( toByteColor(rColor.Red),
toByteColor(rColor.Green),
toByteColor(rColor.Blue))))) );
}
}
else
{
for( sal_Int32 x=0; x<nWidth; ++x )
{
const rendering::RGBColor& rColor=aRGBColors[x];
rWriteAcc->SetPixelOnData( pScanline, x,
BitmapColor( toByteColor(rColor.Red),
toByteColor(rColor.Green),
toByteColor(rColor.Blue) ));
}
}
}
}
return true;
}
}
::Bitmap bitmapFromXBitmap( const uno::Reference< rendering::XIntegerReadOnlyBitmap >& xInputBitmap )
{
SAL_INFO( "vcl.helper", "vcl::unotools::bitmapExFromXBitmap()" );
if( !xInputBitmap.is() )
return ::Bitmap();
// tunnel directly for known implementation
VclCanvasBitmap* pImplBitmap = dynamic_cast<VclCanvasBitmap*>(xInputBitmap.get());
if( pImplBitmap )
return pImplBitmap->getBitmap();
// retrieve data via UNO interface
// volatile bitmaps are a bit more complicated to read
// from...
// loop a few times, until successfully read (for XVolatileBitmap)
for( int i=0; i<10; ++i )
{
sal_Int32 nDepth=0;
bool bHasAlpha = false;
const rendering::IntegerBitmapLayout aLayout(
xInputBitmap->getMemoryLayout());
OSL_ENSURE(aLayout.ColorSpace.is(),
"Cannot convert image without color space!");
if( !aLayout.ColorSpace.is() )
return ::Bitmap();
nDepth = aLayout.ColorSpace->getBitsPerPixel();
if( xInputBitmap->hasAlpha() )
{
// determine alpha channel depth
const uno::Sequence<sal_Int8> aTags(
aLayout.ColorSpace->getComponentTags() );
const sal_Int8* pStart(aTags.getConstArray());
const std::size_t nLen(aTags.getLength());
const sal_Int8* pEnd(pStart+nLen);
const std::ptrdiff_t nAlphaIndex =
std::find(pStart,pEnd,
rendering::ColorComponentTag::ALPHA) - pStart;
ENSURE_OR_THROW( nAlphaIndex < sal::static_int_cast<std::ptrdiff_t>(nLen),
"bitmap has alpha, but alphaindex not valid");
auto nAlphaBitCount = aLayout.ColorSpace->getComponentBitCounts()[nAlphaIndex];
ENSURE_OR_THROW(nAlphaBitCount == 8, "unsupported alpha bit count");
bHasAlpha = true;
nDepth -= nAlphaBitCount;
}
BitmapPalette aPalette;
if( aLayout.Palette.is() )
{
ENSURE_OR_THROW(!bHasAlpha, "unsupported");
uno::Reference< rendering::XColorSpace > xPaletteColorSpace(
aLayout.Palette->getColorSpace());
ENSURE_OR_THROW(xPaletteColorSpace.is(),
"Palette without color space");
const sal_Int32 nEntryCount( aLayout.Palette->getNumberOfEntries() );
if( nEntryCount <= 256 )
{
if( nEntryCount <= 2 )
nDepth = 1;
else
nDepth = 8;
const sal_uInt16 nPaletteEntries(
sal::static_int_cast<sal_uInt16>(
std::min(sal_Int32(255), nEntryCount)));
// copy palette entries
aPalette.SetEntryCount(nPaletteEntries);
uno::Reference<rendering::XBitmapPalette> xPalette( aLayout.Palette );
uno::Reference<rendering::XColorSpace> xPalColorSpace( xPalette->getColorSpace() );
uno::Sequence<double> aPaletteEntry;
for( sal_uInt16 j=0; j<nPaletteEntries; ++j )
{
bool b = xPalette->getIndex(aPaletteEntry,j);
ENSURE_OR_THROW(b, "transparent entry in palette unsupported");
uno::Sequence<rendering::RGBColor> aColors=xPalColorSpace->convertToRGB(aPaletteEntry);
ENSURE_OR_THROW(aColors.getLength() == 1,
"Palette returned more or less than one entry");
const rendering::RGBColor& rColor=aColors[0];
aPalette[j] = BitmapColor(toByteColor(rColor.Red),
toByteColor(rColor.Green),
toByteColor(rColor.Blue));
}
}
}
const ::Size aPixelSize(
sizeFromIntegerSize2D(xInputBitmap->getSize()));
// normalize bitcount
vcl::PixelFormat ePixelFormat;
if (bHasAlpha)
ePixelFormat = vcl::PixelFormat::N32_BPP;
else if ( nDepth <= 8 )
ePixelFormat = vcl::PixelFormat::N8_BPP;
else
ePixelFormat = vcl::PixelFormat::N24_BPP;
::Bitmap aBitmap( aPixelSize,
ePixelFormat,
aLayout.Palette.is() ? &aPalette : nullptr );
{ // limit scoped access
BitmapScopedWriteAccess pWriteAccess( aBitmap );
ENSURE_OR_THROW(pWriteAccess.get() != nullptr,
"Cannot get write access to bitmap");
const sal_Int32 nWidth(aPixelSize.Width());
const sal_Int32 nHeight(aPixelSize.Height());
if( !readBmp(nWidth,nHeight,aLayout,xInputBitmap,pWriteAccess,bHasAlpha) )
continue;
} // limit scoped access
return aBitmap;
}
// failed to read data 10 times - bail out
return ::Bitmap();
}
geometry::RealSize2D size2DFromSize( const Size& rSize )
{
return geometry::RealSize2D( rSize.Width(),
rSize.Height() );
}
Size sizeFromRealSize2D( const geometry::RealSize2D& rSize )
{
return Size( static_cast<tools::Long>(rSize.Width + .5),
static_cast<tools::Long>(rSize.Height + .5) );
}
::Size sizeFromB2DSize( const basegfx::B2DVector& rVec )
{
return ::Size(basegfx::fround<tools::Long>(rVec.getX()),
basegfx::fround<tools::Long>(rVec.getY()));
}
::Point pointFromB2DPoint( const basegfx::B2DPoint& rPoint )
{
return pointFromB2IPoint(basegfx::fround(rPoint));
}
::tools::Rectangle rectangleFromB2DRectangle( const basegfx::B2DRange& rRect )
{
return rectangleFromB2IRectangle(basegfx::fround(rRect));
}
Point pointFromB2IPoint( const basegfx::B2IPoint& rPoint )
{
return ::Point( rPoint.getX(),
rPoint.getY() );
}
basegfx::B2IPoint b2IPointFromPoint(Point const& rPoint)
{
return basegfx::B2IPoint(rPoint.X(), rPoint.Y());
}
tools::Rectangle rectangleFromB2IRectangle( const basegfx::B2IRange& rRect )
{
return ::tools::Rectangle( rRect.getMinX(),
rRect.getMinY(),
rRect.getMaxX(),
rRect.getMaxY() );
}
basegfx::B2IRectangle b2IRectangleFromRectangle(tools::Rectangle const& rRect)
{
// although B2IRange internally has separate height/width emptiness, it doesn't
// expose any API to let us set them separately, so just do the best we can.
if (rRect.IsWidthEmpty() && rRect.IsHeightEmpty())
return basegfx::B2IRange( basegfx::B2ITuple( rRect.Left(), rRect.Top() ) );
return basegfx::B2IRange( rRect.Left(),
rRect.Top(),
rRect.IsWidthEmpty() ? rRect.Left() : rRect.Right(),
rRect.IsHeightEmpty() ? rRect.Top() : rRect.Bottom() );
}
basegfx::B2DSize b2DSizeFromSize(const Size& rSize)
{
return basegfx::B2DSize(rSize.Width(), rSize.Height());
}
basegfx::B2DVector b2DVectorFromSize(const Size& rSize)
{
return basegfx::B2DVector(rSize.Width(), rSize.Height());
}
basegfx::B2DPoint b2DPointFromPoint( const ::Point& rPoint )
{
return basegfx::B2DPoint( rPoint.X(),
rPoint.Y() );
}
basegfx::B2DRange b2DRectangleFromRectangle( const ::tools::Rectangle& rRect )
{
// although B2DRange internally has separate height/width emptiness, it doesn't
// expose any API to let us set them separately, so just do the best we can.
if (rRect.IsWidthEmpty() && rRect.IsHeightEmpty())
return basegfx::B2DRange( basegfx::B2DTuple( rRect.Left(), rRect.Top() ) );
return basegfx::B2DRectangle( rRect.Left(),
rRect.Top(),
rRect.IsWidthEmpty() ? rRect.Left() : rRect.Right(),
rRect.IsHeightEmpty() ? rRect.Top() : rRect.Bottom() );
}
geometry::IntegerSize2D integerSize2DFromSize( const Size& rSize )
{
return geometry::IntegerSize2D( rSize.Width(),
rSize.Height() );
}
Size sizeFromIntegerSize2D( const geometry::IntegerSize2D& rSize )
{
return Size( rSize.Width,
rSize.Height );
}
Point pointFromIntegerPoint2D( const geometry::IntegerPoint2D& rPoint )
{
return Point( rPoint.X,
rPoint.Y );
}
tools::Rectangle rectangleFromIntegerRectangle2D( const geometry::IntegerRectangle2D& rRectangle )
{
return tools::Rectangle( rRectangle.X1, rRectangle.Y1,
rRectangle.X2, rRectangle.Y2 );
}
namespace
{
class StandardColorSpace : public cppu::WeakImplHelper< css::rendering::XColorSpace >
{
private:
uno::Sequence< sal_Int8 > m_aComponentTags;
virtual ::sal_Int8 SAL_CALL getType( ) override
{
return rendering::ColorSpaceType::RGB;
}
virtual uno::Sequence< ::sal_Int8 > SAL_CALL getComponentTags( ) override
{
return m_aComponentTags;
}
virtual ::sal_Int8 SAL_CALL getRenderingIntent( ) override
{
return rendering::RenderingIntent::PERCEPTUAL;
}
virtual uno::Sequence< beans::PropertyValue > SAL_CALL getProperties( ) override
{
return uno::Sequence< beans::PropertyValue >();
}
virtual uno::Sequence< double > SAL_CALL convertColorSpace( const uno::Sequence< double >& deviceColor,
const uno::Reference< rendering::XColorSpace >& targetColorSpace ) override
{
// TODO(P3): if we know anything about target
// colorspace, this can be greatly sped up
uno::Sequence<rendering::ARGBColor> aIntermediate(
convertToARGB(deviceColor));
return targetColorSpace->convertFromARGB(aIntermediate);
}
virtual uno::Sequence< rendering::RGBColor > SAL_CALL convertToRGB( const uno::Sequence< double >& deviceColor ) override
{
const double* pIn( deviceColor.getConstArray() );
const std::size_t nLen( deviceColor.getLength() );
ENSURE_ARG_OR_THROW2(nLen%4==0,
"number of channels no multiple of 4",
static_cast<rendering::XColorSpace*>(this), 0);
uno::Sequence< rendering::RGBColor > aRes(nLen/4);
rendering::RGBColor* pOut( aRes.getArray() );
for( std::size_t i=0; i<nLen; i+=4 )
{
*pOut++ = rendering::RGBColor(pIn[0],pIn[1],pIn[2]);
pIn += 4;
}
return aRes;
}
virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToARGB( const uno::Sequence< double >& deviceColor ) override
{
const double* pIn( deviceColor.getConstArray() );
const std::size_t nLen( deviceColor.getLength() );
ENSURE_ARG_OR_THROW2(nLen%4==0,
"number of channels no multiple of 4",
static_cast<rendering::XColorSpace*>(this), 0);
uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
rendering::ARGBColor* pOut( aRes.getArray() );
for( std::size_t i=0; i<nLen; i+=4 )
{
*pOut++ = rendering::ARGBColor(pIn[3],pIn[0],pIn[1],pIn[2]);
pIn += 4;
}
return aRes;
}
virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& deviceColor ) override
{
const double* pIn( deviceColor.getConstArray() );
const std::size_t nLen( deviceColor.getLength() );
ENSURE_ARG_OR_THROW2(nLen%4==0,
"number of channels no multiple of 4",
static_cast<rendering::XColorSpace*>(this), 0);
uno::Sequence< rendering::ARGBColor > aRes(nLen/4);
rendering::ARGBColor* pOut( aRes.getArray() );
for( std::size_t i=0; i<nLen; i+=4 )
{
*pOut++ = rendering::ARGBColor(pIn[3],pIn[3]*pIn[0],pIn[3]*pIn[1],pIn[3]*pIn[2]);
pIn += 4;
}
return aRes;
}
virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& rgbColor ) override
{
const std::size_t nLen( rgbColor.getLength() );
uno::Sequence< double > aRes(nLen*4);
double* pColors=aRes.getArray();
for( const auto& rIn : rgbColor )
{
*pColors++ = rIn.Red;
*pColors++ = rIn.Green;
*pColors++ = rIn.Blue;
*pColors++ = 1.0;
}
return aRes;
}
virtual uno::Sequence< double > SAL_CALL convertFromARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) override
{
const std::size_t nLen( rgbColor.getLength() );
uno::Sequence< double > aRes(nLen*4);
double* pColors=aRes.getArray();
for( const auto& rIn : rgbColor )
{
*pColors++ = rIn.Red;
*pColors++ = rIn.Green;
*pColors++ = rIn.Blue;
*pColors++ = rIn.Alpha;
}
return aRes;
}
virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& rgbColor ) override
{
const std::size_t nLen( rgbColor.getLength() );
uno::Sequence< double > aRes(nLen*4);
double* pColors=aRes.getArray();
for( const auto& rIn : rgbColor )
{
*pColors++ = rIn.Red/rIn.Alpha;
*pColors++ = rIn.Green/rIn.Alpha;
*pColors++ = rIn.Blue/rIn.Alpha;
*pColors++ = rIn.Alpha;
}
return aRes;
}
public:
StandardColorSpace() : m_aComponentTags(4)
{
sal_Int8* pTags = m_aComponentTags.getArray();
pTags[0] = rendering::ColorComponentTag::RGB_RED;
pTags[1] = rendering::ColorComponentTag::RGB_GREEN;
pTags[2] = rendering::ColorComponentTag::RGB_BLUE;
pTags[3] = rendering::ColorComponentTag::ALPHA;
}
};
}
uno::Reference<rendering::XColorSpace> createStandardColorSpace()
{
return new StandardColorSpace();
}
uno::Sequence< double > colorToStdColorSpaceSequence( const Color& rColor )
{
return
{
toDoubleColor(rColor.GetRed()),
toDoubleColor(rColor.GetGreen()),
toDoubleColor(rColor.GetBlue()),
toDoubleColor(rColor.GetAlpha())
};
}
Color stdColorSpaceSequenceToColor( const uno::Sequence< double >& rColor )
{
ENSURE_ARG_OR_THROW( rColor.getLength() == 4,
"color must have 4 channels" );
Color aColor;
aColor.SetRed ( toByteColor(rColor[0]) );
aColor.SetGreen( toByteColor(rColor[1]) );
aColor.SetBlue ( toByteColor(rColor[2]) );
aColor.SetAlpha( toByteColor(rColor[3]) );
return aColor;
}
uno::Sequence< double > colorToDoubleSequence(
const Color& rColor,
const uno::Reference< rendering::XColorSpace >& xColorSpace )
{
uno::Sequence<rendering::ARGBColor> aSeq
{
{
toDoubleColor(rColor.GetAlpha()),
toDoubleColor(rColor.GetRed()),
toDoubleColor(rColor.GetGreen()),
toDoubleColor(rColor.GetBlue())
}
};
return xColorSpace->convertFromARGB(aSeq);
}
Color doubleSequenceToColor(
const uno::Sequence< double >& rColor,
const uno::Reference< rendering::XColorSpace >& xColorSpace )
{
const rendering::ARGBColor aARGBColor(
xColorSpace->convertToARGB(rColor)[0]);
return Color( ColorAlpha, toByteColor(aARGBColor.Alpha),
toByteColor(aARGBColor.Red),
toByteColor(aARGBColor.Green),
toByteColor(aARGBColor.Blue) );
}
} // namespace canvas
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V547 Expression 'nLen % 4 == 0' is always false.
↑ V547 Expression 'nLen % 4 == 0' is always false.
↑ V547 Expression 'nLen % 4 == 0' is always false.
↑ V547 Expression '!bHasAlpha' is always false.