strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/vcl/headless/svpbmp.cxx
Andrzej Hunt cd1f3480a6 Fill the alpha channel by default for vcl 32-bit bitmaps too. 
Otherwise the alpha channel for bitmaps created directly is empty,
indicating a transparent bitmap (although we don't actually handle
transparency). This complements hardcoding of the alpha channel
in basebmp. VCL bitmaps can be copied bit-for-bit directly into
a basebmp bitmap, hence it's important to make sure we fill the
alpha channel in vcl too.

Conflicts:
	include/vcl/salbtype.hxx

Change-Id: Icb2fa417db6625a6ffa6bd82eb5773ff75be5a3c
2014-06-25 13:04:30 +01:00

385 lines
13 KiB
C++
Raw Blame History

/* -*- 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 IOS
#include "headless/svpbmp.hxx"
#include "headless/svpinst.hxx"
#include <basegfx/vector/b2ivector.hxx>
#include <basegfx/range/b2ibox.hxx>
#include <basebmp/scanlineformats.hxx>
#include <basebmp/color.hxx>
#include <vcl/salbtype.hxx>
#include <vcl/bitmap.hxx>
using namespace basebmp;
using namespace basegfx;
SvpSalBitmap::~SvpSalBitmap()
{
}
bool SvpSalBitmap::Create( const Size& rSize,
sal_uInt16 nBitCount,
const BitmapPalette& rPalette )
{
SAL_INFO( "vcl.headless", "SvpSalBitmap::Create(" << rSize.Width() << "," << rSize.Height() << "," << nBitCount << ")" );
SvpSalInstance* pInst = SvpSalInstance::s_pDefaultInstance;
assert( pInst );
basebmp::Format nFormat = pInst->getFormatForBitCount( nBitCount );
B2IVector aSize( rSize.Width(), rSize.Height() );
if( aSize.getX() == 0 )
aSize.setX( 1 );
if( aSize.getY() == 0 )
aSize.setY( 1 );
if( nBitCount > 8 )
m_aBitmap = createBitmapDevice( aSize, false, nFormat );
else
{
// prepare palette
unsigned int nEntries = 1U << nBitCount;
std::vector<basebmp::Color>* pPalette =
new std::vector<basebmp::Color>( nEntries, basebmp::Color(COL_WHITE) );
unsigned int nColors = rPalette.GetEntryCount();
for( unsigned int i = 0; i < nColors; i++ )
{
const BitmapColor& rCol = rPalette[i];
(*pPalette)[i] = basebmp::Color( rCol.GetRed(), rCol.GetGreen(), rCol.GetBlue() );
}
m_aBitmap = createBitmapDevice( aSize, false, nFormat,
basebmp::RawMemorySharedArray(),
basebmp::PaletteMemorySharedVector( pPalette )
);
}
return true;
}
bool SvpSalBitmap::Create( const SalBitmap& rSalBmp )
{
const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBmp);
const BitmapDeviceSharedPtr& rSrcBmp = rSrc.getBitmap();
if( rSrcBmp.get() )
{
B2IVector aSize = rSrcBmp->getSize();
m_aBitmap = cloneBitmapDevice( aSize, rSrcBmp );
B2IBox aRect( 0, 0, aSize.getX(), aSize.getY() );
m_aBitmap->drawBitmap( rSrcBmp, aRect, aRect, DrawMode_PAINT );
}
else
m_aBitmap.reset();
return true;
}
bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
SalGraphics* /*pGraphics*/ )
{
return false;
}
bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
sal_uInt16 /*nNewBitCount*/ )
{
return false;
}
bool SvpSalBitmap::Create( const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XBitmapCanvas > /*xBitmapCanvas*/, Size& /*rSize*/, bool /*bMask*/ )
{
return false;
}
void SvpSalBitmap::Destroy()
{
m_aBitmap.reset();
}
Size SvpSalBitmap::GetSize() const
{
Size aSize;
if( m_aBitmap.get() )
{
B2IVector aVec( m_aBitmap->getSize() );
aSize = Size( aVec.getX(), aVec.getY() );
}
return aSize;
}
sal_uInt16 SvpSalBitmap::GetBitCount() const
{
sal_uInt16 nDepth = 0;
if( m_aBitmap.get() )
nDepth = getBitCountFromScanlineFormat( m_aBitmap->getScanlineFormat() );
return nDepth;
}
BitmapBuffer* SvpSalBitmap::AcquireBuffer( bool )
{
BitmapBuffer* pBuf = NULL;
if( m_aBitmap.get() )
{
pBuf = new BitmapBuffer();
sal_uInt16 nBitCount = 1;
switch( m_aBitmap->getScanlineFormat() )
{
case FORMAT_ONE_BIT_MSB_GREY:
case FORMAT_ONE_BIT_MSB_PAL:
nBitCount = 1;
pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL;
break;
case FORMAT_ONE_BIT_LSB_GREY:
case FORMAT_ONE_BIT_LSB_PAL:
nBitCount = 1;
pBuf->mnFormat = BMP_FORMAT_1BIT_LSB_PAL;
break;
case FORMAT_FOUR_BIT_MSB_GREY:
case FORMAT_FOUR_BIT_MSB_PAL:
nBitCount = 4;
pBuf->mnFormat = BMP_FORMAT_4BIT_MSN_PAL;
break;
case FORMAT_FOUR_BIT_LSB_GREY:
case FORMAT_FOUR_BIT_LSB_PAL:
nBitCount = 4;
pBuf->mnFormat = BMP_FORMAT_4BIT_LSN_PAL;
break;
case FORMAT_EIGHT_BIT_PAL:
nBitCount = 8;
pBuf->mnFormat = BMP_FORMAT_8BIT_PAL;
break;
case FORMAT_EIGHT_BIT_GREY:
nBitCount = 8;
pBuf->mnFormat = BMP_FORMAT_8BIT_PAL;
break;
case FORMAT_SIXTEEN_BIT_LSB_TC_MASK:
nBitCount = 16;
pBuf->mnFormat = BMP_FORMAT_16BIT_TC_LSB_MASK;
pBuf->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
break;
case FORMAT_SIXTEEN_BIT_MSB_TC_MASK:
nBitCount = 16;
pBuf->mnFormat = BMP_FORMAT_16BIT_TC_MSB_MASK;
pBuf->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f );
break;
case FORMAT_TWENTYFOUR_BIT_TC_MASK:
nBitCount = 24;
pBuf->mnFormat = BMP_FORMAT_24BIT_TC_BGR;
break;
case FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA:
nBitCount = 32;
pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
#ifdef OSL_BIGENDIAN
pBuf->maColorMask = ColorMask( 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff );
#else
pBuf->maColorMask = ColorMask( 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 );
#endif
break;
case FORMAT_THIRTYTWO_BIT_TC_MASK_ARGB:
nBitCount = 32;
pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
#ifdef OSL_BIGENDIAN
pBuf->maColorMask = ColorMask( 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 );
#else
pBuf->maColorMask = ColorMask( 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff );
#endif
break;
case FORMAT_THIRTYTWO_BIT_TC_MASK_ABGR:
nBitCount = 32;
pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
#ifdef OSL_BIGENDIAN
pBuf->maColorMask = ColorMask( 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 );
#else
pBuf->maColorMask = ColorMask( 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff );
#endif
break;
case FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA:
nBitCount = 32;
pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
#ifdef OSL_BIGENDIAN
pBuf->maColorMask = ColorMask( 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff );
#else
pBuf->maColorMask = ColorMask( 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 );
#endif
break;
default:
// this is an error case !!!!!
nBitCount = 1;
pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL;
break;
}
if( m_aBitmap->isTopDown() )
pBuf->mnFormat |= BMP_FORMAT_TOP_DOWN;
B2IVector aSize = m_aBitmap->getSize();
pBuf->mnWidth = aSize.getX();
pBuf->mnHeight = aSize.getY();
pBuf->mnScanlineSize = m_aBitmap->getScanlineStride();
pBuf->mnBitCount = nBitCount;
pBuf->mpBits = (sal_uInt8*)m_aBitmap->getBuffer().get();
if( nBitCount <= 8 )
{
if( m_aBitmap->getScanlineFormat() == FORMAT_EIGHT_BIT_GREY ||
m_aBitmap->getScanlineFormat() == FORMAT_FOUR_BIT_LSB_GREY ||
m_aBitmap->getScanlineFormat() == FORMAT_FOUR_BIT_MSB_GREY ||
m_aBitmap->getScanlineFormat() == FORMAT_ONE_BIT_LSB_GREY ||
m_aBitmap->getScanlineFormat() == FORMAT_ONE_BIT_MSB_GREY
)
pBuf->maPalette = Bitmap::GetGreyPalette( 1U << nBitCount );
else
{
basebmp::PaletteMemorySharedVector aPalette = m_aBitmap->getPalette();
if( aPalette.get() )
{
unsigned int nColors = aPalette->size();
if( nColors > 0 )
{
pBuf->maPalette.SetEntryCount( nColors );
for( unsigned int i = 0; i < nColors; i++ )
{
const basebmp::Color& rCol = (*aPalette)[i];
pBuf->maPalette[i] = BitmapColor( rCol.getRed(), rCol.getGreen(), rCol.getBlue() );
}
}
}
}
}
}
return pBuf;
}
void SvpSalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, bool bReadOnly )
{
if( !bReadOnly && pBuffer->maPalette.GetEntryCount() )
{
// palette might have changed, clone device (but recycle
// memory)
sal_uInt16 nBitCount = 0;
switch( m_aBitmap->getScanlineFormat() )
{
case FORMAT_ONE_BIT_MSB_GREY:
// FALLTHROUGH intended
case FORMAT_ONE_BIT_MSB_PAL:
// FALLTHROUGH intended
case FORMAT_ONE_BIT_LSB_GREY:
// FALLTHROUGH intended
case FORMAT_ONE_BIT_LSB_PAL:
nBitCount = 1;
break;
case FORMAT_FOUR_BIT_MSB_GREY:
// FALLTHROUGH intended
case FORMAT_FOUR_BIT_MSB_PAL:
// FALLTHROUGH intended
case FORMAT_FOUR_BIT_LSB_GREY:
// FALLTHROUGH intended
case FORMAT_FOUR_BIT_LSB_PAL:
nBitCount = 4;
break;
case FORMAT_EIGHT_BIT_PAL:
// FALLTHROUGH intended
case FORMAT_EIGHT_BIT_GREY:
nBitCount = 8;
break;
default:
break;
}
if( nBitCount )
{
sal_uInt32 nEntries = 1U << nBitCount;
boost::shared_ptr< std::vector<basebmp::Color> > pPal(
new std::vector<basebmp::Color>( nEntries,
basebmp::Color(COL_WHITE)));
const sal_uInt32 nColors = std::min(
(sal_uInt32)pBuffer->maPalette.GetEntryCount(),
nEntries);
for( sal_uInt32 i = 0; i < nColors; i++ )
{
const BitmapColor& rCol = pBuffer->maPalette[i];
(*pPal)[i] = basebmp::Color( rCol.GetRed(), rCol.GetGreen(), rCol.GetBlue() );
}
m_aBitmap = basebmp::createBitmapDevice( m_aBitmap->getSize(),
m_aBitmap->isTopDown(),
m_aBitmap->getScanlineFormat(),
m_aBitmap->getBuffer(),
pPal );
}
}
delete pBuffer;
}
bool SvpSalBitmap::GetSystemData( BitmapSystemData& )
{
return false;
}
sal_uInt32 SvpSalBitmap::getBitCountFromScanlineFormat( basebmp::Format nFormat )
{
sal_uInt32 nBitCount = 1;
switch( nFormat )
{
case FORMAT_ONE_BIT_MSB_GREY:
case FORMAT_ONE_BIT_LSB_GREY:
case FORMAT_ONE_BIT_MSB_PAL:
case FORMAT_ONE_BIT_LSB_PAL:
nBitCount = 1;
break;
case FORMAT_FOUR_BIT_MSB_GREY:
case FORMAT_FOUR_BIT_LSB_GREY:
case FORMAT_FOUR_BIT_MSB_PAL:
case FORMAT_FOUR_BIT_LSB_PAL:
nBitCount = 4;
break;
case FORMAT_EIGHT_BIT_PAL:
case FORMAT_EIGHT_BIT_GREY:
nBitCount = 8;
break;
case FORMAT_SIXTEEN_BIT_LSB_TC_MASK:
case FORMAT_SIXTEEN_BIT_MSB_TC_MASK:
nBitCount = 16;
break;
case FORMAT_TWENTYFOUR_BIT_TC_MASK:
nBitCount = 24;
break;
case FORMAT_THIRTYTWO_BIT_TC_MASK_BGRA:
case FORMAT_THIRTYTWO_BIT_TC_MASK_ARGB:
case FORMAT_THIRTYTWO_BIT_TC_MASK_ABGR:
case FORMAT_THIRTYTWO_BIT_TC_MASK_RGBA:
nBitCount = 32;
break;
default:
OSL_FAIL( "unsupported basebmp format" );
break;
}
return nBitCount;
}
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink