/************************************************************** * * 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 #include #include #include #include // -------------------- // - BitmapReadAccess - // -------------------- BitmapReadAccess::BitmapReadAccess( Bitmap& rBitmap, sal_Bool bModify ) : mpBuffer ( NULL ), mpScanBuf ( NULL ), mFncGetPixel ( NULL ), mFncSetPixel ( NULL ), mbModify ( bModify ) { ImplCreate( rBitmap ); } // ------------------------------------------------------------------ BitmapReadAccess::BitmapReadAccess( Bitmap& rBitmap ) : mpBuffer ( NULL ), mpScanBuf ( NULL ), mFncGetPixel ( NULL ), mFncSetPixel ( NULL ), mbModify ( sal_False ) { ImplCreate( rBitmap ); } // ------------------------------------------------------------------ BitmapReadAccess::~BitmapReadAccess() { ImplDestroy(); } // ------------------------------------------------------------------ void BitmapReadAccess::ImplCreate( Bitmap& rBitmap ) { ImpBitmap* pImpBmp = rBitmap.ImplGetImpBitmap(); DBG_ASSERT( pImpBmp, "Forbidden Access to empty bitmap!" ); if( pImpBmp ) { if( mbModify && !maBitmap.ImplGetImpBitmap() ) { rBitmap.ImplMakeUnique(); pImpBmp = rBitmap.ImplGetImpBitmap(); } else { DBG_ASSERT( !mbModify || pImpBmp->ImplGetRefCount() == 2, "Unpredictable results: bitmap is referenced more than once!" ); } mpBuffer = pImpBmp->ImplAcquireBuffer( !mbModify ); if( !mpBuffer ) { ImpBitmap* pNewImpBmp = new ImpBitmap; if( pNewImpBmp->ImplCreate( *pImpBmp, rBitmap.GetBitCount() ) ) { pImpBmp = pNewImpBmp; rBitmap.ImplSetImpBitmap( pImpBmp ); mpBuffer = pImpBmp->ImplAcquireBuffer( !mbModify ); } else delete pNewImpBmp; } if( mpBuffer ) { const long nHeight = mpBuffer->mnHeight; Scanline pTmpLine = mpBuffer->mpBits; try { mpScanBuf = new Scanline[ nHeight ]; } catch (std::bad_alloc &) { mpScanBuf = NULL; } if (mpScanBuf) { maColorMask = mpBuffer->maColorMask; if( BMP_SCANLINE_ADJUSTMENT( mpBuffer->mnFormat ) == BMP_FORMAT_TOP_DOWN ) { for( long nY = 0L; nY < nHeight; nY++, pTmpLine += mpBuffer->mnScanlineSize ) mpScanBuf[ nY ] = pTmpLine; } else { for( long nY = nHeight - 1; nY >= 0; nY--, pTmpLine += mpBuffer->mnScanlineSize ) mpScanBuf[ nY ] = pTmpLine; } if( !ImplSetAccessPointers( BMP_SCANLINE_FORMAT( mpBuffer->mnFormat ) ) ) { delete[] mpScanBuf; mpScanBuf = NULL; pImpBmp->ImplReleaseBuffer( mpBuffer, !mbModify ); mpBuffer = NULL; } else maBitmap = rBitmap; } else { pImpBmp->ImplReleaseBuffer( mpBuffer, !mbModify ); mpBuffer = NULL; } } } } // ------------------------------------------------------------------ void BitmapReadAccess::ImplDestroy() { ImpBitmap* pImpBmp = maBitmap.ImplGetImpBitmap(); delete[] mpScanBuf; mpScanBuf = NULL; if( mpBuffer && pImpBmp ) { pImpBmp->ImplReleaseBuffer( mpBuffer, !mbModify ); mpBuffer = NULL; } } // ------------------------------------------------------------------ sal_Bool BitmapReadAccess::ImplSetAccessPointers( sal_uLong nFormat ) { sal_Bool bRet = sal_True; switch( nFormat ) { CASE_FORMAT( _1BIT_MSB_PAL ) CASE_FORMAT( _1BIT_LSB_PAL ) CASE_FORMAT( _4BIT_MSN_PAL ) CASE_FORMAT( _4BIT_LSN_PAL ) CASE_FORMAT( _8BIT_PAL ) CASE_FORMAT( _8BIT_TC_MASK ) CASE_FORMAT( _16BIT_TC_MSB_MASK ) CASE_FORMAT( _16BIT_TC_LSB_MASK ) CASE_FORMAT( _24BIT_TC_BGR ) CASE_FORMAT( _24BIT_TC_RGB ) CASE_FORMAT( _24BIT_TC_MASK ) CASE_FORMAT( _32BIT_TC_ABGR ) CASE_FORMAT( _32BIT_TC_ARGB ) CASE_FORMAT( _32BIT_TC_BGRA ) CASE_FORMAT( _32BIT_TC_RGBA ) CASE_FORMAT( _32BIT_TC_MASK ) default: bRet = sal_False; break; } return bRet; } // ------------------------------------------------------------------ void BitmapReadAccess::ImplZeroInitUnusedBits() { const sal_uInt32 nWidth = Width(), nHeight = Height(), nScanSize = GetScanlineSize(); if( nWidth && nHeight && nScanSize && GetBuffer() ) { sal_uInt32 nBits; bool bMsb; const sal_uLong nScanlineFormat = GetScanlineFormat(); switch( nScanlineFormat ) { case( BMP_FORMAT_1BIT_MSB_PAL ): nBits = 1; bMsb = true; break; case( BMP_FORMAT_1BIT_LSB_PAL ): nBits = 1; bMsb = false; break; case( BMP_FORMAT_4BIT_MSN_PAL ): nBits = 4; bMsb = true; break; case( BMP_FORMAT_4BIT_LSN_PAL ): nBits = 4; bMsb = false; break; case( BMP_FORMAT_8BIT_PAL ): case( BMP_FORMAT_8BIT_TC_MASK ): bMsb = true; nBits = 8; break; case( BMP_FORMAT_16BIT_TC_MSB_MASK ): case( BMP_FORMAT_16BIT_TC_LSB_MASK ): bMsb = true; nBits = 16; break; case( BMP_FORMAT_24BIT_TC_BGR ): case( BMP_FORMAT_24BIT_TC_RGB ): case( BMP_FORMAT_24BIT_TC_MASK ): bMsb = true; nBits = 24; break; case( BMP_FORMAT_32BIT_TC_ABGR ): case( BMP_FORMAT_32BIT_TC_ARGB ): case( BMP_FORMAT_32BIT_TC_BGRA ): case( BMP_FORMAT_32BIT_TC_RGBA ): case( BMP_FORMAT_32BIT_TC_MASK ): bMsb = true; nBits = 32; break; default: { DBG_ERROR( "BitmapWriteAccess::ZeroInitUnusedBits: Unsupported pixel format"); nBits = 0; bMsb = true; } break; } nBits *= nWidth; if( nScanSize % 4 || !bMsb ) { DBG_ASSERT( 8*nScanSize >= nBits, "BitmapWriteAccess::ZeroInitUnusedBits: span size smaller than width?!"); const sal_uInt32 nLeftOverBits = 8*sizeof(sal_uInt8)*nScanSize - nBits; if( nLeftOverBits != 0 ) // else there is really nothing to do { const sal_uInt32 nBytes = (nLeftOverBits + 7U) >> 3U; sal_uInt8 nMask; if( bMsb ) nMask = static_cast(0xffU << (nLeftOverBits & 3UL)); else nMask = static_cast(0xffU >> (nLeftOverBits & 3UL)); sal_uInt8* pLastBytes = (sal_uInt8*)GetBuffer() + ( nScanSize - nBytes ); for( sal_uInt32 i = 0; i < nHeight; i++, pLastBytes += nScanSize ) { *pLastBytes &= nMask; for( sal_uInt32 j = 1; j < nBytes; j++ ) pLastBytes[j] = 0; } } } else if( nBits & 0x1f ) { sal_uInt32 nMask = 0xffffffff << ( ( nScanSize << 3 ) - nBits ); sal_uInt8* pLast4Bytes = (sal_uInt8*) GetBuffer() + ( nScanSize - 4 ); #ifdef OSL_LITENDIAN nMask = SWAPLONG( nMask ); #endif for( sal_uInt32 i = 0; i < nHeight; i++, pLast4Bytes += nScanSize ) ( *(sal_uInt32*) pLast4Bytes ) &= nMask; } } } // ------------------------------------------------------------------ void BitmapReadAccess::Flush() { ImplDestroy(); } // ------------------------------------------------------------------ void BitmapReadAccess::ReAccess( sal_Bool bModify ) { const ImpBitmap* pImpBmp = maBitmap.ImplGetImpBitmap(); DBG_ASSERT( !mpBuffer, "No ReAccess possible while bitmap is being accessed!" ); DBG_ASSERT( pImpBmp && ( pImpBmp->ImplGetRefCount() > 1UL ), "Accessed bitmap does not exist anymore!" ); if( !mpBuffer && pImpBmp && ( pImpBmp->ImplGetRefCount() > 1UL ) ) { mbModify = bModify; ImplCreate( maBitmap ); } } // ------------------------------------------------------------------ sal_uInt16 BitmapReadAccess::GetBestPaletteIndex( const BitmapColor& rBitmapColor ) const { return( HasPalette() ? mpBuffer->maPalette.GetBestIndex( rBitmapColor ) : 0 ); } BitmapColor BitmapReadAccess::GetInterpolatedColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const { // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!) if(mpBuffer && fX >= 0.0 && fY >= 0.0) { const sal_Int32 nX(static_cast< sal_Int32 >(fX)); const sal_Int32 nY(static_cast< sal_Int32 >(fY)); if(nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight) { // get base-return value from inside pixel BitmapColor aRetval(GetColor(nY, nX)); // calculate deltas and indices for neighbour accesses sal_Int16 nDeltaX((fX - (nX + 0.5)) * 255.0); // [-255 .. 255] sal_Int16 nDeltaY((fY - (nY + 0.5)) * 255.0); // [-255 .. 255] sal_Int16 nIndX(0); sal_Int16 nIndY(0); if(nDeltaX > 0) { nIndX = nX + 1; } else { nIndX = nX - 1; nDeltaX = -nDeltaX; } if(nDeltaY > 0) { nIndY = nY + 1; } else { nIndY = nY - 1; nDeltaY = -nDeltaY; } // get right/left neighbour BitmapColor aXCol(rFallback); if(nDeltaX && nIndX >= 0 && nIndX < mpBuffer->mnWidth) { aXCol = GetColor(nY, nIndX); } // get top/bottom neighbour BitmapColor aYCol(rFallback); if(nDeltaY && nIndY >= 0 && nIndY < mpBuffer->mnHeight) { aYCol = GetColor(nIndY, nX); } // get one of four edge neighbours BitmapColor aXYCol(rFallback); if(nDeltaX && nDeltaY && nIndX >=0 && nIndY >= 0 && nIndX < mpBuffer->mnWidth && nIndY < mpBuffer->mnHeight) { aXYCol = GetColor(nIndY, nIndX); } // merge return value with right/left neighbour if(aXCol != aRetval) { aRetval.Merge(aXCol, 255 - nDeltaX); } // merge top/bottom neighbour with edge if(aYCol != aXYCol) { aYCol.Merge(aXYCol, 255 - nDeltaX); } // merge return value with already merged top/bottom neighbour if(aRetval != aYCol) { aRetval.Merge(aYCol, 255 - nDeltaY); } return aRetval; } } return rFallback; } BitmapColor BitmapReadAccess::GetColorWithFallback( double fY, double fX, const BitmapColor& rFallback ) const { // ask directly doubles >= 0.0 here to avoid rounded values of 0 at small negative // double values, e.g. static_cast< sal_Int32 >(-0.25) is 0, not -1, but *has* to be outside (!) if(mpBuffer && fX >= 0.0 && fY >= 0.0) { const sal_Int32 nX(static_cast< sal_Int32 >(fX)); const sal_Int32 nY(static_cast< sal_Int32 >(fY)); if(nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight) { return GetColor(nY, nX); } } return rFallback; } BitmapColor BitmapReadAccess::GetColorWithFallback( long nY, long nX, const BitmapColor& rFallback ) const { if(mpBuffer) { if(nX >= 0 && nY >= 0 && nX < mpBuffer->mnWidth && nY < mpBuffer->mnHeight) { return GetColor(nY, nX); } } return rFallback; } // --------------------- // - BitmapWriteAccess - // --------------------- BitmapWriteAccess::BitmapWriteAccess( Bitmap& rBitmap ) : BitmapReadAccess( rBitmap, sal_True ), mpLineColor ( NULL ), mpFillColor ( NULL ) { } // ------------------------------------------------------------------ BitmapWriteAccess::~BitmapWriteAccess() { delete mpLineColor; delete mpFillColor; } // ------------------------------------------------------------------ void BitmapWriteAccess::CopyScanline( long nY, const BitmapReadAccess& rReadAcc ) { DBG_ASSERT( ( nY >= 0 ) && ( nY < mpBuffer->mnHeight ), "y-coordinate in destination out of range!" ); DBG_ASSERT( nY < rReadAcc.Height(), "y-coordinate in source out of range!" ); DBG_ASSERT( ( HasPalette() && rReadAcc.HasPalette() ) || ( !HasPalette() && !rReadAcc.HasPalette() ), "No copying possible between palette bitmap and TC bitmap!" ); if( ( GetScanlineFormat() == rReadAcc.GetScanlineFormat() ) && ( GetScanlineSize() >= rReadAcc.GetScanlineSize() ) ) { memcpy( mpScanBuf[ nY ], rReadAcc.GetScanline( nY ), rReadAcc.GetScanlineSize() ); } else // TODO: use fastbmp infrastructure for( long nX = 0L, nWidth = Min( mpBuffer->mnWidth, rReadAcc.Width() ); nX < nWidth; nX++ ) SetPixel( nY, nX, rReadAcc.GetPixel( nY, nX ) ); } // ------------------------------------------------------------------ void BitmapWriteAccess::CopyScanline( long nY, ConstScanline aSrcScanline, sal_uLong nSrcScanlineFormat, sal_uLong nSrcScanlineSize ) { const sal_uLong nFormat = BMP_SCANLINE_FORMAT( nSrcScanlineFormat ); DBG_ASSERT( ( nY >= 0 ) && ( nY < mpBuffer->mnHeight ), "y-coordinate in destination out of range!" ); DBG_ASSERT( ( HasPalette() && nFormat <= BMP_FORMAT_8BIT_PAL ) || ( !HasPalette() && nFormat > BMP_FORMAT_8BIT_PAL ), "No copying possible between palette and non palette scanlines!" ); const sal_uLong nCount = Min( GetScanlineSize(), nSrcScanlineSize ); if( nCount ) { if( GetScanlineFormat() == BMP_SCANLINE_FORMAT( nSrcScanlineFormat ) ) memcpy( mpScanBuf[ nY ], aSrcScanline, nCount ); else { DBG_ASSERT( nFormat != BMP_FORMAT_8BIT_TC_MASK && nFormat != BMP_FORMAT_16BIT_TC_MSB_MASK && nFormat != BMP_FORMAT_16BIT_TC_LSB_MASK && nFormat != BMP_FORMAT_24BIT_TC_MASK && nFormat != BMP_FORMAT_32BIT_TC_MASK, "No support for pixel formats with color masks yet!" ); // TODO: use fastbmp infrastructure FncGetPixel pFncGetPixel; switch( nFormat ) { case( BMP_FORMAT_1BIT_MSB_PAL ): pFncGetPixel = GetPixelFor_1BIT_MSB_PAL; break; case( BMP_FORMAT_1BIT_LSB_PAL ): pFncGetPixel = GetPixelFor_1BIT_LSB_PAL; break; case( BMP_FORMAT_4BIT_MSN_PAL ): pFncGetPixel = GetPixelFor_4BIT_MSN_PAL; break; case( BMP_FORMAT_4BIT_LSN_PAL ): pFncGetPixel = GetPixelFor_4BIT_LSN_PAL; break; case( BMP_FORMAT_8BIT_PAL ): pFncGetPixel = GetPixelFor_8BIT_PAL; break; case( BMP_FORMAT_8BIT_TC_MASK ): pFncGetPixel = GetPixelFor_8BIT_TC_MASK; break; case( BMP_FORMAT_16BIT_TC_MSB_MASK ): pFncGetPixel = GetPixelFor_16BIT_TC_MSB_MASK; break; case( BMP_FORMAT_16BIT_TC_LSB_MASK ): pFncGetPixel = GetPixelFor_16BIT_TC_LSB_MASK; break; case( BMP_FORMAT_24BIT_TC_BGR ): pFncGetPixel = GetPixelFor_24BIT_TC_BGR; break; case( BMP_FORMAT_24BIT_TC_RGB ): pFncGetPixel = GetPixelFor_24BIT_TC_RGB; break; case( BMP_FORMAT_24BIT_TC_MASK ): pFncGetPixel = GetPixelFor_24BIT_TC_MASK; break; case( BMP_FORMAT_32BIT_TC_ABGR ): pFncGetPixel = GetPixelFor_32BIT_TC_ABGR; break; case( BMP_FORMAT_32BIT_TC_ARGB ): pFncGetPixel = GetPixelFor_32BIT_TC_ARGB; break; case( BMP_FORMAT_32BIT_TC_BGRA ): pFncGetPixel = GetPixelFor_32BIT_TC_BGRA; break; case( BMP_FORMAT_32BIT_TC_RGBA ): pFncGetPixel = GetPixelFor_32BIT_TC_RGBA; break; case( BMP_FORMAT_32BIT_TC_MASK ): pFncGetPixel = GetPixelFor_32BIT_TC_MASK; break; default: pFncGetPixel = NULL; break; } if( pFncGetPixel ) { const ColorMask aDummyMask; for( long nX = 0L, nWidth = mpBuffer->mnWidth; nX < nWidth; nX++ ) SetPixel( nY, nX, pFncGetPixel( aSrcScanline, nX, aDummyMask ) ); } } } } // ------------------------------------------------------------------ void BitmapWriteAccess::CopyBuffer( const BitmapReadAccess& rReadAcc ) { DBG_ASSERT( ( HasPalette() && rReadAcc.HasPalette() ) || ( !HasPalette() && !rReadAcc.HasPalette() ), "No copying possible between palette bitmap and TC bitmap!" ); if( ( GetScanlineFormat() == rReadAcc.GetScanlineFormat() ) && ( GetScanlineSize() == rReadAcc.GetScanlineSize() ) ) { const long nHeight = Min( mpBuffer->mnHeight, rReadAcc.Height() ); const sal_uLong nCount = nHeight * mpBuffer->mnScanlineSize; memcpy( mpBuffer->mpBits, rReadAcc.GetBuffer(), nCount ); } else for( long nY = 0L, nHeight = Min( mpBuffer->mnHeight, rReadAcc.Height() ); nY < nHeight; nY++ ) CopyScanline( nY, rReadAcc ); }