replace use of basebmp in vcl entirely now

we're just using it to store bitmap data and to convert to
preferred destination format, so we can use the preexisting
vcl BitmapBuffer for that

Change-Id: I0e800956d95faddfafa53d2c48b09494a7a867c0

3 files changed, 187 insertions, 407 deletions

diff --git a/vcl/headless/svpbmp.cxx b/vcl/headless/svpbmp.cxx
index 05545b6757f5..2fe05d2241f0 100644
--- a/vcl/headless/svpbmp.cxx
+++ b/vcl/headless/svpbmp.cxx
@@ -20,69 +20,160 @@
 #ifndef IOS
 
 #include "headless/svpbmp.hxx"
+#include "headless/svpgdi.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()
 {
+    Destroy();
 }
 
-bool SvpSalBitmap::Create( const Size& rSize,
-                           sal_uInt16 nBitCount,
-                           const BitmapPalette& rPalette )
+BitmapBuffer* ImplCreateDIB(
+    const Size& rSize,
+    sal_uInt16 nBitCount,
+    const BitmapPalette& rPal)
 {
-    SAL_INFO( "vcl.headless", "SvpSalBitmap::Create(" << rSize.Width() << "," << rSize.Height() << "," << nBitCount << ")" );
-
-    basebmp::Format nFormat = SvpSalInstance::getBaseBmpFormatForBitCount( 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, nFormat);
-    else
+    assert(
+          (nBitCount ==  0
+        || nBitCount ==  1
+        || nBitCount ==  4
+        || nBitCount ==  8
+        || nBitCount == 16
+        || nBitCount == 24
+        || nBitCount == 32)
+        && "Unsupported BitCount!");
+
+    BitmapBuffer* pDIB = nullptr;
+
+    if( rSize.Width() && rSize.Height() )
     {
-        // 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++ )
+        try
+        {
+            pDIB = new BitmapBuffer;
+        }
+        catch (const std::bad_alloc&)
+        {
+            pDIB = nullptr;
+        }
+
+        if( pDIB )
         {
-            const BitmapColor& rCol = rPalette[i];
-            (*pPalette)[i] = basebmp::Color( rCol.GetRed(), rCol.GetGreen(), rCol.GetBlue() );
+            const sal_uInt16 nColors = ( nBitCount <= 8 ) ? ( 1 << nBitCount ) : 0;
+
+            switch (nBitCount)
+            {
+                case 1:
+                    pDIB->mnFormat = BMP_FORMAT_1BIT_MSB_PAL;
+                    break;
+                case 4:
+                    pDIB->mnFormat = BMP_FORMAT_4BIT_MSN_PAL;
+                    break;
+                case 8:
+                    pDIB->mnFormat = BMP_FORMAT_8BIT_PAL;
+                    break;
+                case 16:
+                {
+#ifdef OSL_BIGENDIAN
+                    pDIB->mnFormat= BMP_FORMAT_16BIT_TC_MSB_MASK;
+#else
+                    pDIB->mnFormat= BMP_FORMAT_16BIT_TC_LSB_MASK;
+#endif
+                    ColorMaskElement aRedMask(0xf800);
+                    aRedMask.CalcMaskShift();
+                    ColorMaskElement aGreenMask(0x07e0);
+                    aGreenMask.CalcMaskShift();
+                    ColorMaskElement aBlueMask(0x001f);
+                    aBlueMask.CalcMaskShift();
+                    pDIB->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
+                    break;
+                }
+                default:
+                    nBitCount = 32;
+                    //fall through
+                case 32:
+                {
+                    pDIB->mnFormat = SVP_CAIRO_FORMAT;
+                    break;
+                }
+            }
+
+            pDIB->mnFormat |= BMP_FORMAT_TOP_DOWN;
+            pDIB->mnWidth = rSize.Width();
+            pDIB->mnHeight = rSize.Height();
+            pDIB->mnScanlineSize = AlignedWidth4Bytes( pDIB->mnWidth * nBitCount );
+            pDIB->mnBitCount = nBitCount;
+
+            if( nColors )
+            {
+                pDIB->maPalette = rPal;
+                pDIB->maPalette.SetEntryCount( nColors );
+            }
+
+            try
+            {
+                pDIB->mpBits = new sal_uInt8[ pDIB->mnScanlineSize * pDIB->mnHeight ];
+            }
+            catch (const std::bad_alloc&)
+            {
+                delete pDIB;
+                pDIB = nullptr;
+            }
         }
-        m_aBitmap = createBitmapDevice( aSize, nFormat,
-                                        basebmp::RawMemorySharedArray(),
-                                        basebmp::PaletteMemorySharedVector(pPalette) );
     }
-    return true;
+    else
+        pDIB = nullptr;
+
+    return pDIB;
+}
+
+bool SvpSalBitmap::Create(BitmapBuffer *pBuf)
+{
+    Destroy();
+    mpDIB = pBuf;
+    return mpDIB != nullptr;
+}
+
+bool SvpSalBitmap::Create(const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal)
+{
+    Destroy();
+    mpDIB = ImplCreateDIB( rSize, nBitCount, rPal );
+    return mpDIB != nullptr;
 }
 
-bool SvpSalBitmap::Create( const SalBitmap& rSalBmp )
+bool SvpSalBitmap::Create(const SalBitmap& rBmp)
 {
-    const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBmp);
-    const BitmapDeviceSharedPtr& rSrcBmp = rSrc.getBitmap();
-    if( rSrcBmp.get() )
+    Destroy();
+
+    const SvpSalBitmap& rSalBmp = static_cast<const SvpSalBitmap&>(rBmp);
+
+    if (rSalBmp.mpDIB)
     {
-        m_aBitmap = cloneBitmapDevice(rSrcBmp);
+        // TODO: reference counting...
+        mpDIB = new BitmapBuffer( *rSalBmp.mpDIB );
+        // TODO: get rid of this when BitmapBuffer gets copy constructor
+        try
+        {
+            mpDIB->mpBits = new sal_uInt8[ mpDIB->mnScanlineSize * mpDIB->mnHeight ];
+        }
+        catch (const std::bad_alloc&)
+        {
+            delete mpDIB;
+            mpDIB = nullptr;
+        }
+
+        if (mpDIB)
+            memcpy(mpDIB->mpBits, rSalBmp.mpDIB->mpBits, mpDIB->mnScanlineSize * mpDIB->mnHeight);
     }
-    else
-        m_aBitmap.reset();
 
-    return true;
+    return !rSalBmp.mpDIB || (rSalBmp.mpDIB && mpDIB != nullptr);
 }
 
 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/,
@@ -104,262 +195,42 @@ bool SvpSalBitmap::Create( const css::uno::Reference< css::rendering::XBitmapCan
 
 void SvpSalBitmap::Destroy()
 {
-    m_aBitmap.reset();
+    if (mpDIB)
+    {
+        delete[] mpDIB->mpBits;
+        delete mpDIB, mpDIB = nullptr;
+    }
 }
 
 Size SvpSalBitmap::GetSize() const
 {
     Size aSize;
-    if( m_aBitmap.get() )
-    {
-        B2IVector aVec( m_aBitmap->getSize() );
-        aSize = Size( aVec.getX(), aVec.getY() );
-    }
+
+    if (mpDIB)
+        aSize.Width() = mpDIB->mnWidth, aSize.Height() = mpDIB->mnHeight;
 
     return aSize;
 }
 
 sal_uInt16 SvpSalBitmap::GetBitCount() const
 {
-    sal_uInt16 nDepth = 0;
-    if( m_aBitmap.get() )
-        nDepth = getBitCountFromScanlineFormat( m_aBitmap->getScanlineFormat() );
-    return nDepth;
-}
+    sal_uInt16 nBitCount;
 
-BitmapBuffer* SvpSalBitmap::AcquireBuffer( BitmapAccessMode )
-{
-    BitmapBuffer* pBuf = nullptr;
-    if( m_aBitmap.get() )
-    {
-        pBuf = new BitmapBuffer();
-        sal_uInt16 nBitCount = 1;
-        switch( m_aBitmap->getScanlineFormat() )
-        {
-            case Format::OneBitMsbGrey:
-            case Format::OneBitMsbPal:
-                nBitCount = 1;
-                pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL;
-                break;
-            case Format::OneBitLsbGrey:
-            case Format::OneBitLsbPal:
-                nBitCount = 1;
-                pBuf->mnFormat = BMP_FORMAT_1BIT_LSB_PAL;
-                break;
-            case Format::FourBitMsbGrey:
-            case Format::FourBitMsbPal:
-                nBitCount = 4;
-                pBuf->mnFormat = BMP_FORMAT_4BIT_MSN_PAL;
-                break;
-            case Format::FourBitLsbGrey:
-            case Format::FourBitLsbPal:
-                nBitCount = 4;
-                pBuf->mnFormat = BMP_FORMAT_4BIT_LSN_PAL;
-                break;
-            case Format::EightBitPal:
-                nBitCount = 8;
-                pBuf->mnFormat = BMP_FORMAT_8BIT_PAL;
-                break;
-            case Format::EightBitGrey:
-                nBitCount = 8;
-                pBuf->mnFormat = BMP_FORMAT_8BIT_PAL;
-                break;
-            case Format::SixteenBitLsbTcMask:
-            {
-                nBitCount = 16;
-                pBuf->mnFormat = BMP_FORMAT_16BIT_TC_LSB_MASK;
-                ColorMaskElement aRedMask(0xf800);
-                aRedMask.CalcMaskShift();
-                ColorMaskElement aGreenMask(0x07e0);
-                aGreenMask.CalcMaskShift();
-                ColorMaskElement aBlueMask(0x001f);
-                aBlueMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
-                break;
-            }
-            case Format::SixteenBitMsbTcMask:
-            {
-                nBitCount = 16;
-                pBuf->mnFormat = BMP_FORMAT_16BIT_TC_MSB_MASK;
-                ColorMaskElement aRedMask(0xf800);
-                aRedMask.CalcMaskShift();
-                ColorMaskElement aGreenMask(0x07e0);
-                aGreenMask.CalcMaskShift();
-                ColorMaskElement aBlueMask(0x001f);
-                aBlueMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
-                break;
-            }
-            case Format::TwentyFourBitTcMask:
-                nBitCount = 24;
-                pBuf->mnFormat = BMP_FORMAT_24BIT_TC_BGR;
-                break;
-            case Format::ThirtyTwoBitTcMaskBGRA:
-            {
-                nBitCount = 32;
-                pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
-                ColorMaskElement aRedMask(0x00ff0000);
-                ColorMaskElement aGreenMask(0x0000ff00);
-                ColorMaskElement aBlueMask(0x000000ff);
-                sal_uInt32 nAlphaChannel(0xff000000);
-                aBlueMask.CalcMaskShift();
-                aRedMask.CalcMaskShift();
-                aGreenMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask, nAlphaChannel);
-                break;
-            }
-            case Format::ThirtyTwoBitTcMaskARGB:
-            {
-                nBitCount = 32;
-                pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
-                ColorMaskElement aRedMask(0x0000ff00);
-                ColorMaskElement aGreenMask(0x00ff0000);
-                ColorMaskElement aBlueMask(0xff000000);
-                sal_uInt32 nAlphaChannel(0x000000ff);
-                aBlueMask.CalcMaskShift();
-                aRedMask.CalcMaskShift();
-                aGreenMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask, nAlphaChannel);
-                break;
-            }
-            case Format::ThirtyTwoBitTcMaskABGR:
-            {
-                nBitCount = 32;
-                pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
-                ColorMaskElement aRedMask(0xff000000);
-                ColorMaskElement aGreenMask(0x00ff0000);
-                ColorMaskElement aBlueMask(0x0000ff00);
-                sal_uInt32 nAlphaChannel(0x000000ff);
-                aBlueMask.CalcMaskShift();
-                aRedMask.CalcMaskShift();
-                aGreenMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask, nAlphaChannel);
-                break;
-            }
-            case Format::ThirtyTwoBitTcMaskRGBA:
-            {
-                nBitCount = 32;
-                pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK;
-                ColorMaskElement aRedMask(0x000000ff);
-                ColorMaskElement aGreenMask(0x0000ff00);
-                ColorMaskElement aBlueMask(0x00ff0000);
-                sal_uInt32 nAlphaChannel(0xff000000);
-                aBlueMask.CalcMaskShift();
-                aRedMask.CalcMaskShift();
-                aGreenMask.CalcMaskShift();
-                pBuf->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask, nAlphaChannel);
-                break;
-            }
-            default:
-                // this is an error case !!!!!
-                nBitCount = 1;
-                pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL;
-                break;
-        }
-
-        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            = m_aBitmap->getBuffer().get();
-        if( nBitCount <= 8 )
-        {
-            if( m_aBitmap->getScanlineFormat() == Format::EightBitGrey ||
-                m_aBitmap->getScanlineFormat() == Format::FourBitLsbGrey ||
-                m_aBitmap->getScanlineFormat() == Format::FourBitMsbGrey ||
-                m_aBitmap->getScanlineFormat() == Format::OneBitLsbGrey ||
-                m_aBitmap->getScanlineFormat() == Format::OneBitMsbGrey
-                )
-                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() );
-                        }
-                    }
-                }
-            }
-        }
-    }
+    if (mpDIB)
+        nBitCount = mpDIB->mnBitCount;
+    else
+        nBitCount = 0;
 
-    return pBuf;
+    return nBitCount;
 }
 
-void SvpSalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, BitmapAccessMode nMode )
+BitmapBuffer* SvpSalBitmap::AcquireBuffer(BitmapAccessMode)
 {
-    if( nMode == BITMAP_WRITE_ACCESS && pBuffer->maPalette.GetEntryCount() )
-    {
-        // palette might have changed, clone device (but recycle
-        // memory)
-        sal_uInt16 nBitCount = 0;
-        switch( m_aBitmap->getScanlineFormat() )
-        {
-            case Format::OneBitMsbGrey:
-                // FALLTHROUGH intended
-            case Format::OneBitMsbPal:
-                // FALLTHROUGH intended
-            case Format::OneBitLsbGrey:
-                // FALLTHROUGH intended
-            case Format::OneBitLsbPal:
-                nBitCount = 1;
-                break;
-
-            case Format::FourBitMsbGrey:
-                // FALLTHROUGH intended
-            case Format::FourBitMsbPal:
-                // FALLTHROUGH intended
-            case Format::FourBitLsbGrey:
-                // FALLTHROUGH intended
-            case Format::FourBitLsbPal:
-                nBitCount = 4;
-                break;
-
-            case Format::EightBitPal:
-                // FALLTHROUGH intended
-            case Format::EightBitGrey:
-                nBitCount = 8;
-                break;
-
-            default:
-                break;
-        }
-
-        if( nBitCount )
-        {
-            sal_uInt32 nEntries = 1U << nBitCount;
-
-            std::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->getScanlineFormat(),
-                                                     m_aBitmap->getBuffer(),
-                                                     pPal );
-        }
-    }
+    return mpDIB;
+}
 
-    delete pBuffer;
+void SvpSalBitmap::ReleaseBuffer(BitmapBuffer*, BitmapAccessMode)
+{
 }
 
 bool SvpSalBitmap::GetSystemData( BitmapSystemData& )
@@ -377,47 +248,6 @@ bool SvpSalBitmap::Replace( const ::Color& /*rSearchColor*/, const ::Color& /*rR
     return false;
 }
 
-sal_uInt32 SvpSalBitmap::getBitCountFromScanlineFormat( basebmp::Format nFormat )
-{
-    sal_uInt32 nBitCount = 1;
-    switch( nFormat )
-    {
-        case Format::OneBitMsbGrey:
-        case Format::OneBitLsbGrey:
-        case Format::OneBitMsbPal:
-        case Format::OneBitLsbPal:
-            nBitCount = 1;
-            break;
-        case Format::FourBitMsbGrey:
-        case Format::FourBitLsbGrey:
-        case Format::FourBitMsbPal:
-        case Format::FourBitLsbPal:
-            nBitCount = 4;
-            break;
-        case Format::EightBitPal:
-        case Format::EightBitGrey:
-            nBitCount = 8;
-            break;
-        case Format::SixteenBitLsbTcMask:
-        case Format::SixteenBitMsbTcMask:
-            nBitCount = 16;
-            break;
-        case Format::TwentyFourBitTcMask:
-            nBitCount = 24;
-            break;
-        case Format::ThirtyTwoBitTcMaskBGRA:
-        case Format::ThirtyTwoBitTcMaskARGB:
-        case Format::ThirtyTwoBitTcMaskABGR:
-        case Format::ThirtyTwoBitTcMaskRGBA:
-            nBitCount = 32;
-            break;
-        default:
-        OSL_FAIL( "unsupported basebmp format" );
-        break;
-    }
-    return nBitCount;
-}
-
 #endif
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/headless/svpgdi.cxx b/vcl/headless/svpgdi.cxx
index 59e8947ed8f0..9af7bc292d0a 100644
--- a/vcl/headless/svpgdi.cxx
+++ b/vcl/headless/svpgdi.cxx
@@ -33,7 +33,6 @@
 #include <basegfx/polygon/b2dpolypolygontools.hxx>
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolygontools.hxx>
-#include <basebmp/scanlineformats.hxx>
 
 #include <cairo.h>
 
@@ -118,24 +117,26 @@ namespace
     public:
         SourceHelper(const SalBitmap& rSourceBitmap)
         {
-            const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSourceBitmap);
-            const basebmp::BitmapDeviceSharedPtr& rSrcBmp = rSrc.getBitmap();
+            const SvpSalBitmap& rSrcBmp = static_cast<const SvpSalBitmap&>(rSourceBitmap);
 
-            if (rSourceBitmap.GetBitCount() != 32)
+            if (rSrcBmp.GetBitCount() != 32)
             {
                 //big stupid copy here
                 static bool bWarnedOnce;
                 SAL_WARN_IF(!bWarnedOnce, "vcl.gdi", "non default depth bitmap, slow convert, upscale the input");
                 bWarnedOnce = true;
-                Size aSize = rSourceBitmap.GetSize();
-                aTmpBmp.Create(aSize, 0, BitmapPalette());
+
+                const BitmapBuffer* pSrc = rSrcBmp.GetBuffer();
+                const SalTwoRect aTwoRect = { 0, 0, pSrc->mnWidth, pSrc->mnHeight,
+                                              0, 0, pSrc->mnWidth, pSrc->mnHeight };
+                aTmpBmp.Create(StretchAndConvert(*pSrc, aTwoRect, SVP_CAIRO_FORMAT));
+
+
                 assert(aTmpBmp.GetBitCount() == 32);
-                const basebmp::BitmapDeviceSharedPtr& rTmpSrc = aTmpBmp.getBitmap();
-                rTmpSrc->convertBitmap(rSrcBmp);
-                source = SvpSalGraphics::createCairoSurface(rTmpSrc);
+                source = SvpSalGraphics::createCairoSurface(aTmpBmp.GetBuffer());
             }
             else
-                source = SvpSalGraphics::createCairoSurface(rSrcBmp);
+                source = SvpSalGraphics::createCairoSurface(rSrcBmp.GetBuffer());
         }
         ~SourceHelper()
         {
@@ -156,20 +157,15 @@ namespace
         MaskHelper(const SalBitmap& rAlphaBitmap)
         {
             const SvpSalBitmap& rMask = static_cast<const SvpSalBitmap&>(rAlphaBitmap);
-            const basebmp::BitmapDeviceSharedPtr& rMaskBmp = rMask.getBitmap();
-
-            basegfx::B2IVector size = rMaskBmp->getSize();
-            sal_Int32 nStride = rMaskBmp->getScanlineStride();
-            basebmp::RawMemorySharedArray data = rMaskBmp->getBuffer();
+            const BitmapBuffer* pMaskBuf = rMask.GetBuffer();
 
             if (rAlphaBitmap.GetBitCount() == 8)
             {
                 // the alpha values need to be inverted for Cairo
                 // so big stupid copy and invert here
-                const int nImageSize = size.getY() * nStride;
-                const unsigned char* pSrcBits = data.get();
+                const int nImageSize = pMaskBuf->mnHeight * pMaskBuf->mnScanlineSize;
                 pAlphaBits = new unsigned char[nImageSize];
-                memcpy(pAlphaBits, pSrcBits, nImageSize);
+                memcpy(pAlphaBits, pMaskBuf->mpBits, nImageSize);
 
                 // TODO: make upper layers use standard alpha
                 sal_uInt32* pLDst = reinterpret_cast<sal_uInt32*>(pAlphaBits);
@@ -179,17 +175,18 @@ namespace
 
                 mask = cairo_image_surface_create_for_data(pAlphaBits,
                                                 CAIRO_FORMAT_A8,
-                                                size.getX(), size.getY(),
-                                                nStride);
+                                                pMaskBuf->mnWidth, pMaskBuf->mnHeight,
+                                                pMaskBuf->mnScanlineSize);
             }
             else
             {
                 // the alpha values need to be inverted for Cairo
                 // so big stupid copy and invert here
-                const int nImageSize = size.getY() * nStride;
-                const unsigned char* pSrcBits = data.get();
+                const int nImageSize = pMaskBuf->mnHeight * pMaskBuf->mnScanlineSize;
+                pAlphaBits = new unsigned char[nImageSize];
+                memcpy(pAlphaBits, pMaskBuf->mpBits, nImageSize);
                 pAlphaBits = new unsigned char[nImageSize];
-                memcpy(pAlphaBits, pSrcBits, nImageSize);
+                memcpy(pAlphaBits, pMaskBuf->mpBits, nImageSize);
 
                 // TODO: make upper layers use standard alpha
                 unsigned char* pDst = pAlphaBits;
@@ -198,8 +195,8 @@ namespace
 
                 mask = cairo_image_surface_create_for_data(pAlphaBits,
                                                 CAIRO_FORMAT_A1,
-                                                size.getX(), size.getY(),
-                                                nStride);
+                                                pMaskBuf->mnWidth, pMaskBuf->mnHeight,
+                                                pMaskBuf->mnScanlineSize);
             }
         }
         ~MaskHelper()
@@ -1077,10 +1074,10 @@ void SvpSalGraphics::drawMask( const SalTwoRect& rTR,
 
 SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeight )
 {
-    basegfx::B2IVector aSize(nWidth, nHeight);
-    basebmp::BitmapDeviceSharedPtr aCopy = createBitmapDevice(aSize, SVP_CAIRO_FORMAT);
+    SvpSalBitmap* pBitmap = new SvpSalBitmap();
+    pBitmap->Create(Size(nWidth, nHeight), 32, BitmapPalette());
 
-    cairo_surface_t* target = SvpSalGraphics::createCairoSurface(aCopy);
+    cairo_surface_t* target = SvpSalGraphics::createCairoSurface(pBitmap->GetBuffer());
     cairo_t* cr = cairo_create(target);
 
     SalTwoRect aTR(nX, nY, nWidth, nHeight, 0, 0, nWidth, nHeight);
@@ -1089,9 +1086,6 @@ SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeigh
     cairo_destroy(cr);
     cairo_surface_destroy(target);
 
-    SvpSalBitmap* pBitmap = new SvpSalBitmap();
-    pBitmap->setBitmap(aCopy);
-
     return pBitmap;
 }
 
@@ -1206,47 +1200,41 @@ bool SvpSalGraphics::drawEPS( long, long, long, long, void*, sal_uLong )
 
 namespace
 {
-    cairo_format_t getCairoFormat(const basebmp::BitmapDeviceSharedPtr &rBuffer)
+    cairo_format_t getCairoFormat(const BitmapBuffer& rBuffer)
     {
         cairo_format_t nFormat;
-        if (rBuffer->getScanlineFormat() == SVP_CAIRO_FORMAT)
+        assert(rBuffer.mnBitCount == 32 || rBuffer.mnBitCount == 1);
+        if (rBuffer.mnBitCount == 32)
             nFormat = CAIRO_FORMAT_ARGB32;
         else
             nFormat = CAIRO_FORMAT_A1;
         return nFormat;
     }
 
-    bool isCairoCompatible(const basebmp::BitmapDeviceSharedPtr &rBuffer)
+    bool isCairoCompatible(const BitmapBuffer* pBuffer)
     {
-        if (!rBuffer)
+        if (!pBuffer)
             return false;
 
-        if (rBuffer->getScanlineFormat() != SVP_CAIRO_FORMAT &&
-            rBuffer->getScanlineFormat() != basebmp::Format::OneBitMsbPal)
+        if (pBuffer->mnBitCount != 32 && pBuffer->mnBitCount != 1)
             return false;
 
-        basegfx::B2IVector size = rBuffer->getSize();
-        sal_Int32 nStride = rBuffer->getScanlineStride();
-        cairo_format_t nFormat = getCairoFormat(rBuffer);
-        return (cairo_format_stride_for_width(nFormat, size.getX()) == nStride);
+        cairo_format_t nFormat = getCairoFormat(*pBuffer);
+        return (cairo_format_stride_for_width(nFormat, pBuffer->mnWidth) == pBuffer->mnScanlineSize);
     }
 }
 
-cairo_surface_t* SvpSalGraphics::createCairoSurface(const basebmp::BitmapDeviceSharedPtr &rBuffer)
+cairo_surface_t* SvpSalGraphics::createCairoSurface(const BitmapBuffer *pBuffer)
 {
-    if (!isCairoCompatible(rBuffer))
+    if (!isCairoCompatible(pBuffer))
         return nullptr;
 
-    basegfx::B2IVector size = rBuffer->getSize();
-    sal_Int32 nStride = rBuffer->getScanlineStride();
-
-    basebmp::RawMemorySharedArray data = rBuffer->getBuffer();
-    cairo_format_t nFormat = getCairoFormat(rBuffer);
+    cairo_format_t nFormat = getCairoFormat(*pBuffer);
     cairo_surface_t *target =
-        cairo_image_surface_create_for_data(data.get(),
+        cairo_image_surface_create_for_data(pBuffer->mpBits,
                                         nFormat,
-                                        size.getX(), size.getY(),
-                                        nStride);
+                                        pBuffer->mnWidth, pBuffer->mnHeight,
+                                        pBuffer->mnScanlineSize);
     return target;
 }
 
diff --git a/vcl/headless/svpinst.cxx b/vcl/headless/svpinst.cxx
index f45b813f7dd8..5e3ffdfb771f 100644
--- a/vcl/headless/svpinst.cxx
+++ b/vcl/headless/svpinst.cxx
@@ -41,12 +41,9 @@
 #include <salframe.hxx>
 #include <svdata.hxx>
 #include <unx/gendata.hxx>
-#include <basebmp/scanlineformats.hxx>
 // FIXME: remove when we re-work the svp mainloop
 #include <unx/salunxtime.h>
 
-using namespace basebmp;
-
 bool SvpSalInstance::isFrameAlive( const SalFrame* pFrame ) const
 {
     for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin();
@@ -417,39 +414,4 @@ void SvpSalTimer::Start( sal_uLong nMS )
     m_pInstance->StartTimer( nMS );
 }
 
-Format SvpSalInstance::getBaseBmpFormatForBitCount( sal_uInt16 nBitCount )
-{
-    switch( nBitCount )
-    {
-        case 1:
-            return Format::OneBitMsbPal;
-        case 4:
-            return Format::FourBitMsbPal;
-        case 8:
-            return Format::EightBitPal;
-        case 16:
-#ifdef OSL_BIGENDIAN
-            return Format::SixteenBitMsbTcMask;
-#else
-            return Format::SixteenBitLsbTcMask;
-#endif
-        case 32:
-            return Format::ThirtyTwoBitTcMaskBGRA;
-        default:
-            return SVP_CAIRO_FORMAT;
-     }
-
-}
-
-Format SvpSalInstance::getBaseBmpFormatForDeviceFormat(DeviceFormat eFormat)
-{
-    switch (eFormat)
-    {
-        case DeviceFormat::BITMASK:
-            return Format::OneBitMsbPal;
-        default:
-            return SVP_CAIRO_FORMAT;
-    }
-}
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */