| /************************************************************** |
| * |
| * 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 <vcl/salbtype.hxx> |
| #include <vcl/bitmap.hxx> |
| #include <vcl/bmpacc.hxx> |
| |
| #include <impbmp.hxx> |
| |
| #include <string.h> |
| |
| // -------------------- |
| // - 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<sal_uInt8>(0xffU << (nLeftOverBits & 3UL)); |
| else |
| nMask = static_cast<sal_uInt8>(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 ); |
| } |
