xref: /aoo41x/main/vcl/source/helper/canvasbitmap.cxx (revision 37ab0f2d)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"

#include <com/sun/star/util/Endianness.hpp>
#include <com/sun/star/rendering/ColorComponentTag.hpp>
#include <com/sun/star/rendering/ColorSpaceType.hpp>
#include <com/sun/star/rendering/RenderingIntent.hpp>

#include <rtl/instance.hxx>
#include <vos/mutex.hxx>

#include <tools/diagnose_ex.h>
#include <canvasbitmap.hxx>
#include <vcl/canvastools.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/svapp.hxx>

#include <algorithm>


using namespace ::vcl::unotools;
using namespace ::com::sun::star;

namespace
{
    // TODO(Q3): move to o3tl bithacks or somesuch. A similar method is in canvas/canvastools.hxx

    // Good ole HAKMEM tradition. Calc number of 1 bits in 32bit word,
    // unrolled loop. See e.g. Hackers Delight, p. 66
    inline sal_Int32 bitcount( sal_uInt32 val )
    {
        val = val - ((val >> 1) & 0x55555555);
        val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
        val = (val + (val >> 4)) & 0x0F0F0F0F;
        val = val + (val >> 8);
        val = val + (val >> 16);
        return sal_Int32(val & 0x0000003F);
    }
}

void VclCanvasBitmap::setComponentInfo( sal_uLong redShift, sal_uLong greenShift, sal_uLong blueShift )
{
    // sort channels in increasing order of appearance in the pixel
    // (starting with the least significant bits)
    sal_Int8 redPos(0);
    sal_Int8 greenPos(1);
    sal_Int8 bluePos(2);

    if( redShift > greenShift )
    {
        std::swap(redPos,greenPos);
        if( redShift > blueShift )
        {
            std::swap(redPos,bluePos);
            if( greenShift > blueShift )
                std::swap(greenPos,bluePos);
        }
    }
    else
    {
        if( greenShift > blueShift )
        {
            std::swap(greenPos,bluePos);
            if( redShift > blueShift )
                std::swap(redPos,bluePos);
        }
    }

    m_aComponentTags.realloc(3);
    sal_Int8* pTags = m_aComponentTags.getArray();
    pTags[redPos]   = rendering::ColorComponentTag::RGB_RED;
    pTags[greenPos] = rendering::ColorComponentTag::RGB_GREEN;
    pTags[bluePos]  = rendering::ColorComponentTag::RGB_BLUE;

    m_aComponentBitCounts.realloc(3);
    sal_Int32* pCounts = m_aComponentBitCounts.getArray();
    pCounts[redPos]    = bitcount(sal::static_int_cast<sal_uInt32>(redShift));
    pCounts[greenPos]  = bitcount(sal::static_int_cast<sal_uInt32>(greenShift));
    pCounts[bluePos]   = bitcount(sal::static_int_cast<sal_uInt32>(blueShift));
}

VclCanvasBitmap::VclCanvasBitmap( const BitmapEx& rBitmap ) :
    m_aBmpEx( rBitmap ),
    m_aBitmap( rBitmap.GetBitmap() ),
    m_aAlpha(),
    m_pBmpAcc( m_aBitmap.AcquireReadAccess() ),
    m_pAlphaAcc( NULL ),
    m_aComponentTags(),
    m_aComponentBitCounts(),
    m_aLayout(),
    m_nBitsPerInputPixel(0),
    m_nBitsPerOutputPixel(0),
    m_nRedIndex(-1),
    m_nGreenIndex(-1),
    m_nBlueIndex(-1),
    m_nAlphaIndex(-1),
    m_nIndexIndex(-1),
    m_nEndianness(0),
    m_bSwap(false),
    m_bPalette(false)
{
    if( m_aBmpEx.IsTransparent() )
    {
        m_aAlpha = m_aBmpEx.IsAlpha() ? m_aBmpEx.GetAlpha().GetBitmap() : m_aBmpEx.GetMask();
        m_pAlphaAcc = m_aAlpha.AcquireReadAccess();
    }

    m_aLayout.ScanLines      = 0;
    m_aLayout.ScanLineBytes  = 0;
    m_aLayout.ScanLineStride = 0;
    m_aLayout.PlaneStride    = 0;
    m_aLayout.ColorSpace.clear();
    m_aLayout.Palette.clear();
    m_aLayout.IsMsbFirst     = sal_False;

    if( m_pBmpAcc )
    {
        m_aLayout.ScanLines      = m_pBmpAcc->Height();
        m_aLayout.ScanLineBytes  = (m_pBmpAcc->GetBitCount()*m_pBmpAcc->Width() + 7) / 8;
        m_aLayout.ScanLineStride = m_pBmpAcc->GetScanlineSize();
        m_aLayout.PlaneStride    = 0;

        switch( m_pBmpAcc->GetScanlineFormat() )
        {
            case BMP_FORMAT_1BIT_MSB_PAL:
                m_bPalette           = true;
                m_nBitsPerInputPixel = 1;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_True;
                break;

            case BMP_FORMAT_1BIT_LSB_PAL:
                m_bPalette           = true;
                m_nBitsPerInputPixel = 1;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_False;
                break;

            case BMP_FORMAT_4BIT_MSN_PAL:
                m_bPalette           = true;
                m_nBitsPerInputPixel = 4;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_True;
                break;

            case BMP_FORMAT_4BIT_LSN_PAL:
                m_bPalette           = true;
                m_nBitsPerInputPixel = 4;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_False;
                break;

            case BMP_FORMAT_8BIT_PAL:
                m_bPalette           = true;
                m_nBitsPerInputPixel = 8;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                break;

            case BMP_FORMAT_8BIT_TC_MASK:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 8;
                m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
                                  m_pBmpAcc->GetColorMask().GetGreenMask(),
                                  m_pBmpAcc->GetColorMask().GetBlueMask() );
                break;

            case BMP_FORMAT_16BIT_TC_MSB_MASK:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 16;
                m_nEndianness        = util::Endianness::BIG;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
                                  m_pBmpAcc->GetColorMask().GetGreenMask(),
                                  m_pBmpAcc->GetColorMask().GetBlueMask() );
                break;

            case BMP_FORMAT_16BIT_TC_LSB_MASK:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 16;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
                                  m_pBmpAcc->GetColorMask().GetGreenMask(),
                                  m_pBmpAcc->GetColorMask().GetBlueMask() );
                break;

            case BMP_FORMAT_24BIT_TC_BGR:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 24;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( 0xff0000LL,
                                  0x00ff00LL,
                                  0x0000ffLL );
                break;

            case BMP_FORMAT_24BIT_TC_RGB:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 24;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( 0x0000ffLL,
                                  0x00ff00LL,
                                  0xff0000LL );
                break;

            case BMP_FORMAT_24BIT_TC_MASK:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 24;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
                                  m_pBmpAcc->GetColorMask().GetGreenMask(),
                                  m_pBmpAcc->GetColorMask().GetBlueMask() );
                break;

            case BMP_FORMAT_32BIT_TC_ABGR:
            {
                m_bPalette           = false;
                m_nBitsPerInputPixel = 32;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter

                m_aComponentTags.realloc(4);
                sal_Int8* pTags = m_aComponentTags.getArray();
                pTags[0]        = rendering::ColorComponentTag::ALPHA;
                pTags[1]        = rendering::ColorComponentTag::RGB_BLUE;
                pTags[2]        = rendering::ColorComponentTag::RGB_GREEN;
                pTags[3]        = rendering::ColorComponentTag::RGB_RED;

                m_aComponentBitCounts.realloc(4);
                sal_Int32* pCounts = m_aComponentBitCounts.getArray();
                pCounts[0]         = 8;
                pCounts[1]         = 8;
                pCounts[2]         = 8;
                pCounts[3]         = 8;

                m_nRedIndex   = 3;
                m_nGreenIndex = 2;
                m_nBlueIndex  = 1;
                m_nAlphaIndex = 0;
            }
            break;

            case BMP_FORMAT_32BIT_TC_ARGB:
            {
                m_bPalette           = false;
                m_nBitsPerInputPixel = 32;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter

                m_aComponentTags.realloc(4);
                sal_Int8* pTags = m_aComponentTags.getArray();
                pTags[0]        = rendering::ColorComponentTag::ALPHA;
                pTags[1]        = rendering::ColorComponentTag::RGB_RED;
                pTags[2]        = rendering::ColorComponentTag::RGB_GREEN;
                pTags[3]        = rendering::ColorComponentTag::RGB_BLUE;

                m_aComponentBitCounts.realloc(4);
                sal_Int32* pCounts = m_aComponentBitCounts.getArray();
                pCounts[0]         = 8;
                pCounts[1]         = 8;
                pCounts[2]         = 8;
                pCounts[3]         = 8;

                m_nRedIndex   = 1;
                m_nGreenIndex = 2;
                m_nBlueIndex  = 3;
                m_nAlphaIndex = 0;
            }
            break;

            case BMP_FORMAT_32BIT_TC_BGRA:
            {
                m_bPalette           = false;
                m_nBitsPerInputPixel = 32;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter

                m_aComponentTags.realloc(4);
                sal_Int8* pTags = m_aComponentTags.getArray();
                pTags[0]        = rendering::ColorComponentTag::RGB_BLUE;
                pTags[1]        = rendering::ColorComponentTag::RGB_GREEN;
                pTags[2]        = rendering::ColorComponentTag::RGB_RED;
                pTags[3]        = rendering::ColorComponentTag::ALPHA;

                m_aComponentBitCounts.realloc(4);
                sal_Int32* pCounts = m_aComponentBitCounts.getArray();
                pCounts[0]         = 8;
                pCounts[1]         = 8;
                pCounts[2]         = 8;
                pCounts[3]         = 8;

                m_nRedIndex   = 2;
                m_nGreenIndex = 1;
                m_nBlueIndex  = 0;
                m_nAlphaIndex = 3;
            }
            break;

            case BMP_FORMAT_32BIT_TC_RGBA:
            {
                m_bPalette           = false;
                m_nBitsPerInputPixel = 32;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter

                m_aComponentTags.realloc(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;

                m_aComponentBitCounts.realloc(4);
                sal_Int32* pCounts = m_aComponentBitCounts.getArray();
                pCounts[0]         = 8;
                pCounts[1]         = 8;
                pCounts[2]         = 8;
                pCounts[3]         = 8;

                m_nRedIndex   = 0;
                m_nGreenIndex = 1;
                m_nBlueIndex  = 2;
                m_nAlphaIndex = 3;
            }
            break;

            case BMP_FORMAT_32BIT_TC_MASK:
                m_bPalette           = false;
                m_nBitsPerInputPixel = 32;
                m_nEndianness        = util::Endianness::LITTLE;
                m_aLayout.IsMsbFirst = sal_False; // doesn't matter
                setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
                                  m_pBmpAcc->GetColorMask().GetGreenMask(),
                                  m_pBmpAcc->GetColorMask().GetBlueMask() );
                break;

            default:
                DBG_ERROR( "unsupported bitmap format" );
                break;
        }

        if( m_bPalette )
        {
            m_aComponentTags.realloc(1);
            m_aComponentTags[0] = rendering::ColorComponentTag::INDEX;

            m_aComponentBitCounts.realloc(1);
            m_aComponentBitCounts[0] = m_nBitsPerInputPixel;

            m_nIndexIndex = 0;
        }

        m_nBitsPerOutputPixel = m_nBitsPerInputPixel;
        if( m_aBmpEx.IsTransparent() )
        {
            // TODO(P1): need to interleave alpha with bitmap data -
            // won't fuss with less-than-8 bit for now
            m_nBitsPerOutputPixel = std::max(sal_Int32(8),m_nBitsPerInputPixel);

            // check whether alpha goes in front or behind the
            // bitcount sequence. If pixel format is little endian,
            // put it behind all the other channels. If it's big
            // endian, put it in front (because later, the actual data
            // always gets written after the pixel data)

            // TODO(Q1): slight catch - in the case of the
            // BMP_FORMAT_32BIT_XX_ARGB formats, duplicate alpha
            // channels might happen!
            m_aComponentTags.realloc(m_aComponentTags.getLength()+1);
            m_aComponentTags[m_aComponentTags.getLength()-1] = rendering::ColorComponentTag::ALPHA;

            m_aComponentBitCounts.realloc(m_aComponentBitCounts.getLength()+1);
            m_aComponentBitCounts[m_aComponentBitCounts.getLength()-1] = m_aBmpEx.IsAlpha() ? 8 : 1;

            if( m_nEndianness == util::Endianness::BIG )
            {
                // put alpha in front of all the color channels
                sal_Int8*  pTags  =m_aComponentTags.getArray();
                sal_Int32* pCounts=m_aComponentBitCounts.getArray();
                std::rotate(pTags,
                            pTags+m_aComponentTags.getLength()-1,
                            pTags+m_aComponentTags.getLength());
                std::rotate(pCounts,
                            pCounts+m_aComponentBitCounts.getLength()-1,
                            pCounts+m_aComponentBitCounts.getLength());
                ++m_nRedIndex;
                ++m_nGreenIndex;
                ++m_nBlueIndex;
                ++m_nIndexIndex;
                m_nAlphaIndex=0;
            }

            // always add a full byte to the pixel size, otherwise
            // pixel packing hell breaks loose.
            m_nBitsPerOutputPixel += 8;

            // adapt scanline parameters
            const Size aSize = m_aBitmap.GetSizePixel();
            m_aLayout.ScanLineBytes  =
            m_aLayout.ScanLineStride = (aSize.Width()*m_nBitsPerOutputPixel + 7)/8;
        }
    }
}

VclCanvasBitmap::~VclCanvasBitmap()
{
    if( m_pAlphaAcc )
        m_aAlpha.ReleaseAccess(m_pAlphaAcc);
    if( m_pBmpAcc )
        m_aBitmap.ReleaseAccess(m_pBmpAcc);
}

// XBitmap
geometry::IntegerSize2D SAL_CALL VclCanvasBitmap::getSize() throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return integerSize2DFromSize( m_aBitmap.GetSizePixel() );
}

::sal_Bool SAL_CALL VclCanvasBitmap::hasAlpha() throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return m_aBmpEx.IsTransparent();
}

uno::Reference< rendering::XBitmap > SAL_CALL VclCanvasBitmap::getScaledBitmap( const geometry::RealSize2D& newSize,
                                                                                sal_Bool beFast ) throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    BitmapEx aNewBmp( m_aBitmap );
    aNewBmp.Scale( sizeFromRealSize2D( newSize ), beFast ? BMP_SCALE_FASTESTINTERPOLATE : BMP_SCALE_INTERPOLATE );
    return uno::Reference<rendering::XBitmap>( new VclCanvasBitmap( aNewBmp ) );
}

// XIntegerReadOnlyBitmap
uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerBitmapLayout& 	 bitmapLayout,
                                                             const geometry::IntegerRectangle2D& rect ) throw( lang::IndexOutOfBoundsException,
                                                                                                               rendering::VolatileContentDestroyedException,
                                                                                                               uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    bitmapLayout = getMemoryLayout();

    const ::Rectangle aRequestedArea( vcl::unotools::rectangleFromIntegerRectangle2D(rect) );
    if( aRequestedArea.IsEmpty() )
        return uno::Sequence< sal_Int8 >();

    // Invalid/empty bitmap: no data available
    if( !m_pBmpAcc )
        throw lang::IndexOutOfBoundsException();
    if( m_aBmpEx.IsTransparent() && !m_pAlphaAcc )
        throw lang::IndexOutOfBoundsException();

    if( aRequestedArea.Left() < 0 || aRequestedArea.Top() < 0 ||
        aRequestedArea.Right() > m_pBmpAcc->Width() ||
        aRequestedArea.Bottom() > m_pBmpAcc->Height() )
    {
        throw lang::IndexOutOfBoundsException();
    }

    uno::Sequence< sal_Int8 > aRet;
    Rectangle aRequestedBytes( aRequestedArea );

    // adapt to byte boundaries
    aRequestedBytes.Left()  = aRequestedArea.Left()*m_nBitsPerOutputPixel/8;
    aRequestedBytes.Right() = (aRequestedArea.Right()*m_nBitsPerOutputPixel + 7)/8;

    // copy stuff to output sequence
    aRet.realloc(aRequestedBytes.getWidth()*aRequestedBytes.getHeight());
    sal_Int8* pOutBuf = aRet.getArray();

    bitmapLayout.ScanLines     = aRequestedBytes.getHeight();
    bitmapLayout.ScanLineBytes =
    bitmapLayout.ScanLineStride= aRequestedBytes.getWidth();

    sal_Int32 nScanlineStride=bitmapLayout.ScanLineStride;
    if( !(m_pBmpAcc->GetScanlineFormat() & BMP_FORMAT_TOP_DOWN) )
    {
        pOutBuf += bitmapLayout.ScanLineStride*(aRequestedBytes.getHeight()-1);
        nScanlineStride *= -1;
    }

    if( !m_aBmpEx.IsTransparent() )
    {
        OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");

        // can return bitmap data as-is
        for( long y=aRequestedBytes.Top(); y<aRequestedBytes.Bottom(); ++y )
        {
            Scanline pScan = m_pBmpAcc->GetScanline(y);
            rtl_copyMemory(pOutBuf, pScan+aRequestedBytes.Left(), aRequestedBytes.getWidth());
            pOutBuf += nScanlineStride;
        }
    }
    else
    {
        OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
        OSL_ENSURE(m_pAlphaAcc,"Invalid alpha read access");

        // interleave alpha with bitmap data - note, bitcount is
        // always integer multiple of 8
        OSL_ENSURE((m_nBitsPerOutputPixel & 0x07) == 0,
                   "Transparent bitmap bitcount not integer multiple of 8" );

        for( long y=aRequestedArea.Top(); y<aRequestedArea.Bottom(); ++y )
        {
            sal_Int8* pOutScan = pOutBuf;

            if( m_nBitsPerInputPixel < 8 )
            {
                // input less than a byte - copy via GetPixel()
                for( long x=aRequestedArea.Left(); x<aRequestedArea.Right(); ++x )
                {
                    *pOutScan++ = m_pBmpAcc->GetPixelIndex(y,x);
                    *pOutScan++ = m_pAlphaAcc->GetPixelIndex(y,x);
                }
            }
            else
            {
                const long nNonAlphaBytes( m_nBitsPerInputPixel/8 );
                const long nScanlineOffsetLeft(aRequestedArea.Left()*nNonAlphaBytes);
                Scanline  pScan = m_pBmpAcc->GetScanline(y) + nScanlineOffsetLeft;

                // input integer multiple of byte - copy directly
                for( long x=aRequestedArea.Left(); x<aRequestedArea.Right(); ++x )
                {
                    for( long i=0; i<nNonAlphaBytes; ++i )
                        *pOutScan++ = *pScan++;
                    *pOutScan++ = m_pAlphaAcc->GetPixelIndex( y, x );
                }
            }

            pOutBuf += nScanlineStride;
        }
    }

    return aRet;
}

uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getPixel( rendering::IntegerBitmapLayout&	bitmapLayout,
                                                              const geometry::IntegerPoint2D&	pos ) throw (lang::IndexOutOfBoundsException,
                                                                                                             rendering::VolatileContentDestroyedException,
                                                                                                             uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    bitmapLayout = getMemoryLayout();

    // Invalid/empty bitmap: no data available
    if( !m_pBmpAcc )
        throw lang::IndexOutOfBoundsException();
    if( m_aBmpEx.IsTransparent() && !m_pAlphaAcc )
        throw lang::IndexOutOfBoundsException();

    if( pos.X < 0 || pos.Y < 0 ||
        pos.X > m_pBmpAcc->Width() || pos.Y > m_pBmpAcc->Height() )
    {
        throw lang::IndexOutOfBoundsException();
    }

    uno::Sequence< sal_Int8 > aRet((m_nBitsPerOutputPixel + 7)/8);
    sal_Int8* pOutBuf = aRet.getArray();

    // copy stuff to output sequence
    bitmapLayout.ScanLines     = 1;
    bitmapLayout.ScanLineBytes =
    bitmapLayout.ScanLineStride= aRet.getLength();

    const long nScanlineLeftOffset( pos.X*m_nBitsPerInputPixel/8 );
    if( !m_aBmpEx.IsTransparent() )
    {
        OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");

        // can return bitmap data as-is
        Scanline pScan = m_pBmpAcc->GetScanline(pos.Y);
        rtl_copyMemory(pOutBuf, pScan+nScanlineLeftOffset, aRet.getLength() );
    }
    else
    {
        OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
        OSL_ENSURE(m_pAlphaAcc,"Invalid alpha read access");

        // interleave alpha with bitmap data - note, bitcount is
        // always integer multiple of 8
        OSL_ENSURE((m_nBitsPerOutputPixel & 0x07) == 0,
                   "Transparent bitmap bitcount not integer multiple of 8" );

        if( m_nBitsPerInputPixel < 8 )
        {
            // input less than a byte - copy via GetPixel()
            *pOutBuf++ = m_pBmpAcc->GetPixelIndex(pos.Y,pos.X);
            *pOutBuf   = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
        }
        else
        {
            const long nNonAlphaBytes( m_nBitsPerInputPixel/8 );
            Scanline  pScan = m_pBmpAcc->GetScanline(pos.Y);

            // input integer multiple of byte - copy directly
            rtl_copyMemory(pOutBuf, pScan+nScanlineLeftOffset, nNonAlphaBytes );
            pOutBuf += nNonAlphaBytes;
            *pOutBuf++ = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
        }
    }

    return aRet;
}

uno::Reference< rendering::XBitmapPalette > SAL_CALL VclCanvasBitmap::getPalette() throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    uno::Reference< XBitmapPalette > aRet;
    if( m_bPalette )
        aRet.set(this);

    return aRet;
}

rendering::IntegerBitmapLayout SAL_CALL VclCanvasBitmap::getMemoryLayout() throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    rendering::IntegerBitmapLayout aLayout( m_aLayout );

    // only set references to self on separate copy of
    // IntegerBitmapLayout - if we'd set that on m_aLayout, we'd have
    // a circular reference!
    if( m_bPalette )
        aLayout.Palette.set( this );

    aLayout.ColorSpace.set( this );

    return aLayout;
}

sal_Int32 SAL_CALL VclCanvasBitmap::getNumberOfEntries() throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    if( !m_pBmpAcc )
        return 0;

    return m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ;
}

sal_Bool SAL_CALL VclCanvasBitmap::getIndex( uno::Sequence< double >& o_entry, sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_uInt16 nCount( m_pBmpAcc ?
                         (m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ) : 0 );
    OSL_ENSURE(nIndex >= 0 && nIndex < nCount,"Palette index out of range");
    if( nIndex < 0 || nIndex >= nCount )
        throw lang::IndexOutOfBoundsException(::rtl::OUString::createFromAscii("Palette index out of range"),
                                              static_cast<rendering::XBitmapPalette*>(this));

    const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(sal::static_int_cast<sal_uInt16>(nIndex));
    o_entry.realloc(3);
    double* pColor=o_entry.getArray();
    pColor[0] = aCol.GetRed();
    pColor[1] = aCol.GetGreen();
    pColor[2] = aCol.GetBlue();

    return sal_True; // no palette transparency here.
}

sal_Bool SAL_CALL VclCanvasBitmap::setIndex( const uno::Sequence< double >&, sal_Bool, sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, lang::IllegalArgumentException, uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_uInt16 nCount( m_pBmpAcc ?
                         (m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ) : 0 );

    OSL_ENSURE(nIndex >= 0 && nIndex < nCount,"Palette index out of range");
    if( nIndex < 0 || nIndex >= nCount )
        throw lang::IndexOutOfBoundsException(::rtl::OUString::createFromAscii("Palette index out of range"),
                                              static_cast<rendering::XBitmapPalette*>(this));

    return sal_False; // read-only implementation
}

namespace
{
    struct PaletteColorSpaceHolder: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
                                                               PaletteColorSpaceHolder>
    {
        uno::Reference<rendering::XColorSpace> operator()()
        {
            return vcl::unotools::createStandardColorSpace();
        }
    };
}

uno::Reference< rendering::XColorSpace > SAL_CALL VclCanvasBitmap::getColorSpace(  ) throw (uno::RuntimeException)
{
    // this is the method from XBitmapPalette. Return palette color
    // space here
    return PaletteColorSpaceHolder::get();
}

sal_Int8 SAL_CALL VclCanvasBitmap::getType(  ) throw (uno::RuntimeException)
{
    return rendering::ColorSpaceType::RGB;
}

uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::getComponentTags(  ) throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return m_aComponentTags;
}

sal_Int8 SAL_CALL VclCanvasBitmap::getRenderingIntent(  ) throw (uno::RuntimeException)
{
    return rendering::RenderingIntent::PERCEPTUAL;
}

uno::Sequence< ::beans::PropertyValue > SAL_CALL VclCanvasBitmap::getProperties(  ) throw (uno::RuntimeException)
{
    return uno::Sequence< ::beans::PropertyValue >();
}

uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertColorSpace( const uno::Sequence< double >& deviceColor,
                                                                     const uno::Reference< ::rendering::XColorSpace >& targetColorSpace ) throw (uno::RuntimeException)
{
    // 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);
}

uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
    ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                         "number of channels no multiple of pixel element count",
                         static_cast<rendering::XBitmapPalette*>(this), 01);

    uno::Sequence< rendering::RGBColor > aRes(nLen/nComponentsPerPixel);
    rendering::RGBColor* pOut( aRes.getArray() );

    if( m_bPalette )
    {
        OSL_ENSURE(m_nIndexIndex != -1,
                   "Invalid color channel indices");
        ENSURE_OR_THROW(m_pBmpAcc,
                        "Unable to get BitmapAccess");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
                                          toDoubleColor(aCol.GetGreen()),
                                          toDoubleColor(aCol.GetBlue()));
        }
    }
    else
    {
        OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                   "Invalid color channel indices");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::RGBColor(
                deviceColor[i+m_nRedIndex],
                deviceColor[i+m_nGreenIndex],
                deviceColor[i+m_nBlueIndex]);
        }
    }

    return aRes;
}

uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
    ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                         "number of channels no multiple of pixel element count",
                         static_cast<rendering::XBitmapPalette*>(this), 01);

    uno::Sequence< rendering::ARGBColor > aRes(nLen/nComponentsPerPixel);
    rendering::ARGBColor* pOut( aRes.getArray() );

    if( m_bPalette )
    {
        OSL_ENSURE(m_nIndexIndex != -1,
                   "Invalid color channel indices");
        ENSURE_OR_THROW(m_pBmpAcc,
                        "Unable to get BitmapAccess");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));

            // TODO(F3): Convert result to sRGB color space
            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
            *pOut++ = rendering::ARGBColor(nAlpha,
                                           toDoubleColor(aCol.GetRed()),
                                           toDoubleColor(aCol.GetGreen()),
                                           toDoubleColor(aCol.GetBlue()));
        }
    }
    else
    {
        OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                   "Invalid color channel indices");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            // TODO(F3): Convert result to sRGB color space
            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
            *pOut++ = rendering::ARGBColor(
                nAlpha,
                deviceColor[i+m_nRedIndex],
                deviceColor[i+m_nGreenIndex],
                deviceColor[i+m_nBlueIndex]);
        }
    }

    return aRes;
}

uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
    ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                         "number of channels no multiple of pixel element count",
                         static_cast<rendering::XBitmapPalette*>(this), 01);

    uno::Sequence< rendering::ARGBColor > aRes(nLen/nComponentsPerPixel);
    rendering::ARGBColor* pOut( aRes.getArray() );

    if( m_bPalette )
    {
        OSL_ENSURE(m_nIndexIndex != -1,
                   "Invalid color channel indices");
        ENSURE_OR_THROW(m_pBmpAcc,
                        "Unable to get BitmapAccess");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));

            // TODO(F3): Convert result to sRGB color space
            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
            *pOut++ = rendering::ARGBColor(nAlpha,
                                           nAlpha*toDoubleColor(aCol.GetRed()),
                                           nAlpha*toDoubleColor(aCol.GetGreen()),
                                           nAlpha*toDoubleColor(aCol.GetBlue()));
        }
    }
    else
    {
        OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                   "Invalid color channel indices");

        for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
        {
            // TODO(F3): Convert result to sRGB color space
            const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
            *pOut++ = rendering::ARGBColor(
                nAlpha,
                nAlpha*deviceColor[i+m_nRedIndex],
                nAlpha*deviceColor[i+m_nGreenIndex],
                nAlpha*deviceColor[i+m_nBlueIndex]);
        }
    }

    return aRes;
}

uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());

    uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
    double* pColors=aRes.getArray();

    if( m_bPalette )
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
                    BitmapColor(toByteColor(rgbColor[i].Red),
                                toByteColor(rgbColor[i].Green),
                                toByteColor(rgbColor[i].Blue)));
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = 1.0;

            pColors += nComponentsPerPixel;
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            pColors[m_nRedIndex]   = rgbColor[i].Red;
            pColors[m_nGreenIndex] = rgbColor[i].Green;
            pColors[m_nBlueIndex]  = rgbColor[i].Blue;
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = 1.0;

            pColors += nComponentsPerPixel;
        }
    }
    return aRes;
}

uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());

    uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
    double* pColors=aRes.getArray();

    if( m_bPalette )
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
                    BitmapColor(toByteColor(rgbColor[i].Red),
                                toByteColor(rgbColor[i].Green),
                                toByteColor(rgbColor[i].Blue)));
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = rgbColor[i].Alpha;

            pColors += nComponentsPerPixel;
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            pColors[m_nRedIndex]   = rgbColor[i].Red;
            pColors[m_nGreenIndex] = rgbColor[i].Green;
            pColors[m_nBlueIndex]  = rgbColor[i].Blue;
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = rgbColor[i].Alpha;

            pColors += nComponentsPerPixel;
        }
    }
    return aRes;
}

uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());

    uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
    double* pColors=aRes.getArray();

    if( m_bPalette )
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            const double nAlpha( rgbColor[i].Alpha );
            pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
                    BitmapColor(toByteColor(rgbColor[i].Red / nAlpha),
                                toByteColor(rgbColor[i].Green / nAlpha),
                                toByteColor(rgbColor[i].Blue / nAlpha)));
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = nAlpha;

            pColors += nComponentsPerPixel;
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            const double nAlpha( rgbColor[i].Alpha );
            pColors[m_nRedIndex]   = rgbColor[i].Red / nAlpha;
            pColors[m_nGreenIndex] = rgbColor[i].Green / nAlpha;
            pColors[m_nBlueIndex]  = rgbColor[i].Blue / nAlpha;
            if( m_nAlphaIndex != -1 )
                pColors[m_nAlphaIndex] = nAlpha;

            pColors += nComponentsPerPixel;
        }
    }
    return aRes;
}

sal_Int32 SAL_CALL VclCanvasBitmap::getBitsPerPixel(  ) throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return m_nBitsPerOutputPixel;
}

uno::Sequence< ::sal_Int32 > SAL_CALL VclCanvasBitmap::getComponentBitCounts(  ) throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return m_aComponentBitCounts;
}

sal_Int8 SAL_CALL VclCanvasBitmap::getEndianness(  ) throw (uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );
    return m_nEndianness;
}

uno::Sequence<double> SAL_CALL VclCanvasBitmap::convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
                                                                              const uno::Reference< ::rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    if( dynamic_cast<VclCanvasBitmap*>(targetColorSpace.get()) )
    {
        vos::OGuard aGuard( Application::GetSolarMutex() );

        const sal_Size  nLen( deviceColor.getLength() );
        const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
        ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
                             "number of channels no multiple of pixel element count",
                             static_cast<rendering::XBitmapPalette*>(this), 01);

        uno::Sequence<double> aRes(nLen);
        double* pOut( aRes.getArray() );

        if( m_bPalette )
        {
            OSL_ENSURE(m_nIndexIndex != -1,
                       "Invalid color channel indices");
            ENSURE_OR_THROW(m_pBmpAcc,
                            "Unable to get BitmapAccess");

            for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
            {
                const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
                    sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));

                // TODO(F3): Convert result to sRGB color space
                const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
                *pOut++ = toDoubleColor(aCol.GetRed());
                *pOut++ = toDoubleColor(aCol.GetGreen());
                *pOut++ = toDoubleColor(aCol.GetBlue());
                *pOut++ = nAlpha;
            }
        }
        else
        {
            OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
                       "Invalid color channel indices");

            for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
            {
                // TODO(F3): Convert result to sRGB color space
                const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
                *pOut++ = deviceColor[i+m_nRedIndex];
                *pOut++ = deviceColor[i+m_nGreenIndex];
                *pOut++ = deviceColor[i+m_nBlueIndex];
                *pOut++ = nAlpha;
            }
        }

        return aRes;
    }
    else
    {
        // TODO(P3): if we know anything about target
        // colorspace, this can be greatly sped up
        uno::Sequence<rendering::ARGBColor> aIntermediate(
            convertIntegerToARGB(deviceColor));
        return targetColorSpace->convertFromARGB(aIntermediate);
    }
}

uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
                                                                                  const uno::Reference< ::rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    if( dynamic_cast<VclCanvasBitmap*>(targetColorSpace.get()) )
    {
        // it's us, so simply pass-through the data
        return deviceColor;
    }
    else
    {
        // TODO(P3): if we know anything about target
        // colorspace, this can be greatly sped up
        uno::Sequence<rendering::ARGBColor> aIntermediate(
            convertIntegerToARGB(deviceColor));
        return targetColorSpace->convertIntegerFromARGB(aIntermediate);
    }
}

uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);

    uno::Sequence< rendering::RGBColor > aRes(nNumColors);
    rendering::RGBColor* pOut( aRes.getArray() );

    ENSURE_OR_THROW(m_pBmpAcc,
                    "Unable to get BitmapAccess");

    if( m_aBmpEx.IsTransparent() )
    {
        const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
        {
            // if palette, index is guaranteed to be 8 bit
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor(*pIn) :
                m_pBmpAcc->GetPixelFromData(pIn,0);

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
                                          toDoubleColor(aCol.GetGreen()),
                                          toDoubleColor(aCol.GetBlue()));
            // skips alpha
            pIn += nBytesPerPixel;
        }
    }
    else
    {
        for( sal_Int32 i=0; i<nNumColors; ++i )
        {
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex()) :
                m_pBmpAcc->GetPixelFromData(pIn, i);

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
                                          toDoubleColor(aCol.GetGreen()),
                                          toDoubleColor(aCol.GetBlue()));
        }
    }

    return aRes;
}

uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);

    uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
    rendering::ARGBColor* pOut( aRes.getArray() );

    ENSURE_OR_THROW(m_pBmpAcc,
                    "Unable to get BitmapAccess");

    if( m_aBmpEx.IsTransparent() )
    {
        const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
        const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
        const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
        {
            // if palette, index is guaranteed to be 8 bit
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor(*pIn) :
                m_pBmpAcc->GetPixelFromData(pIn,0);

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::ARGBColor(1.0 - toDoubleColor(nAlphaFactor*pIn[nNonAlphaBytes]),
                                           toDoubleColor(aCol.GetRed()),
                                           toDoubleColor(aCol.GetGreen()),
                                           toDoubleColor(aCol.GetBlue()));
            pIn += nBytesPerPixel;
        }
    }
    else
    {
        for( sal_Int32 i=0; i<nNumColors; ++i )
        {
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
                m_pBmpAcc->GetPixelFromData(pIn, i);

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::ARGBColor(1.0,
                                           toDoubleColor(aCol.GetRed()),
                                           toDoubleColor(aCol.GetGreen()),
                                           toDoubleColor(aCol.GetBlue()));
        }
    }

    return aRes;
}

uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
    const sal_Size  nLen( deviceColor.getLength() );
    const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);

    uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
    rendering::ARGBColor* pOut( aRes.getArray() );

    ENSURE_OR_THROW(m_pBmpAcc,
                    "Unable to get BitmapAccess");

    if( m_aBmpEx.IsTransparent() )
    {
        const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
        const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
        const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
        for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
        {
            // if palette, index is guaranteed to be 8 bit
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor(*pIn) :
                m_pBmpAcc->GetPixelFromData(pIn,0);

            // TODO(F3): Convert result to sRGB color space
            const double nAlpha( 1.0 - toDoubleColor(nAlphaFactor*pIn[nNonAlphaBytes]) );
            *pOut++ = rendering::ARGBColor(nAlpha,
                                           nAlpha*toDoubleColor(aCol.GetRed()),
                                           nAlpha*toDoubleColor(aCol.GetGreen()),
                                           nAlpha*toDoubleColor(aCol.GetBlue()));
            pIn += nBytesPerPixel;
        }
    }
    else
    {
        for( sal_Int32 i=0; i<nNumColors; ++i )
        {
            const BitmapColor aCol =
                m_bPalette ?
                m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
                m_pBmpAcc->GetPixelFromData(pIn, i);

            // TODO(F3): Convert result to sRGB color space
            *pOut++ = rendering::ARGBColor(1.0,
                                           toDoubleColor(aCol.GetRed()),
                                           toDoubleColor(aCol.GetGreen()),
                                           toDoubleColor(aCol.GetBlue()));
        }
    }

    return aRes;
}

uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);

    uno::Sequence< sal_Int8 > aRes(nNumBytes);
    sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());

    if( m_aBmpEx.IsTransparent() )
    {
        const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
        for( sal_Size i=0; i<nLen; ++i )
        {
            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                   toByteColor(rgbColor[i].Green),
                                   toByteColor(rgbColor[i].Blue));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
            pColors   += nNonAlphaBytes;
            *pColors++ = sal_uInt8(255);
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                   toByteColor(rgbColor[i].Green),
                                   toByteColor(rgbColor[i].Blue));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
        }
    }

    return aRes;
}

uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);

    uno::Sequence< sal_Int8 > aRes(nNumBytes);
    sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());

    if( m_aBmpEx.IsTransparent() )
    {
        const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
        for( sal_Size i=0; i<nLen; ++i )
        {
            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                   toByteColor(rgbColor[i].Green),
                                   toByteColor(rgbColor[i].Blue));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
            pColors   += nNonAlphaBytes;
            *pColors++ = 255 - toByteColor(rgbColor[i].Alpha);
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                   toByteColor(rgbColor[i].Green),
                                   toByteColor(rgbColor[i].Blue));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
        }
    }

    return aRes;
}

uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
{
    vos::OGuard aGuard( Application::GetSolarMutex() );

    const sal_Size  nLen( rgbColor.getLength() );
    const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);

    uno::Sequence< sal_Int8 > aRes(nNumBytes);
    sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());

    if( m_aBmpEx.IsTransparent() )
    {
        const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
        for( sal_Size i=0; i<nLen; ++i )
        {
            const double nAlpha( rgbColor[i].Alpha );
            const BitmapColor aCol(toByteColor(rgbColor[i].Red / nAlpha),
                                   toByteColor(rgbColor[i].Green / nAlpha),
                                   toByteColor(rgbColor[i].Blue / nAlpha));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
            pColors   += nNonAlphaBytes;
            *pColors++ = 255 - toByteColor(nAlpha);
        }
    }
    else
    {
        for( sal_Size i=0; i<nLen; ++i )
        {
            const BitmapColor aCol(toByteColor(rgbColor[i].Red),
                                   toByteColor(rgbColor[i].Green),
                                   toByteColor(rgbColor[i].Blue));
            const BitmapColor aCol2 =
                m_bPalette ?
                BitmapColor(
                    sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
                aCol;

            m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
        }
    }

    return aRes;
}

BitmapEx VclCanvasBitmap::getBitmapEx() const
{
    return m_aBmpEx;
}