This is an automated email from the ASF dual-hosted git repository. mseidel pushed a commit to branch trunk in repository https://gitbox.apache.org/repos/asf/openoffice.git
The following commit(s) were added to refs/heads/trunk by this push: new 0399a9fdaf Fixed typos, removed whitespace 0399a9fdaf is described below commit 0399a9fdaf9a50397f1c64f11d2eab3459cab875 Author: mseidel <msei...@apache.org> AuthorDate: Sun Aug 13 16:55:38 2023 +0200 Fixed typos, removed whitespace --- main/vcl/source/gdi/bitmap.cxx | 228 +++--- main/vcl/source/gdi/bitmap3.cxx | 1522 +++++++++++++++++++------------------- main/vcl/source/gdi/bitmap4.cxx | 95 ++- main/vcl/source/gdi/bitmapex.cxx | 1235 ++++++++++++++++--------------- 4 files changed, 1542 insertions(+), 1538 deletions(-) diff --git a/main/vcl/source/gdi/bitmap.cxx b/main/vcl/source/gdi/bitmap.cxx index 4325b513b1..7f529d053d 100644 --- a/main/vcl/source/gdi/bitmap.cxx +++ b/main/vcl/source/gdi/bitmap.cxx @@ -1,5 +1,5 @@ /************************************************************** - * + * * 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 @@ -7,16 +7,16 @@ * 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. - * + * *************************************************************/ @@ -55,9 +55,9 @@ Bitmap::Bitmap( const ResId& rResId ) : mpImpBmp( NULL ) { const BitmapEx aBmpEx( rResId ); - + if( !aBmpEx.IsEmpty() ) - *this = aBmpEx.GetBitmap(); + *this = aBmpEx.GetBitmap(); } // ------------------------------------------------------------------ @@ -76,10 +76,10 @@ Bitmap::Bitmap( const Bitmap& rBitmap ) : Bitmap::Bitmap( SalBitmap* pSalBitmap ) { - mpImpBmp = new ImpBitmap(); - mpImpBmp->ImplSetSalBitmap( pSalBitmap ); - maPrefMapMode = MapMode( MAP_PIXEL ); - maPrefSize = mpImpBmp->ImplGetSize(); + mpImpBmp = new ImpBitmap(); + mpImpBmp->ImplSetSalBitmap( pSalBitmap ); + maPrefMapMode = MapMode( MAP_PIXEL ); + maPrefSize = mpImpBmp->ImplGetSize(); } // ------------------------------------------------------------------ @@ -236,10 +236,10 @@ bool BitmapPalette::IsGreyPalette() const // see above: only certain entry values will result in a valid call to GetGreyPalette if( nEntryCount == 2 || nEntryCount == 4 || nEntryCount == 16 || nEntryCount == 256 ) { - const BitmapPalette& rGreyPalette = Bitmap::GetGreyPalette( nEntryCount ); - if( rGreyPalette == *this ) - return true; - } + const BitmapPalette& rGreyPalette = Bitmap::GetGreyPalette( nEntryCount ); + if( rGreyPalette == *this ) + return true; + } // TODO: is it worth to compare the entries? return false; } @@ -291,10 +291,10 @@ Size Bitmap::GetSizePixel() const void Bitmap::SetSizePixel( const Size& rNewSize, sal_uInt32 nScaleFlag ) { - if(GetSizePixel() != rNewSize) - { - Scale( rNewSize, nScaleFlag ); - } + if(GetSizePixel() != rNewSize) + { + Scale( rNewSize, nScaleFlag ); + } } // ------------------------------------------------------------------ @@ -332,17 +332,17 @@ sal_Bool Bitmap::HasGreyPalette() const if( pRAcc ) { - const BitmapColor& rCol0( pRAcc->GetPaletteColor( 0 ) ); - const BitmapColor& rCol1( pRAcc->GetPaletteColor( 1 ) ); - if( rCol0.GetRed() == rCol0.GetGreen() && rCol0.GetRed() == rCol0.GetBlue() && - rCol1.GetRed() == rCol1.GetGreen() && rCol1.GetRed() == rCol1.GetBlue() ) - { - bRet = sal_True; - } + const BitmapColor& rCol0( pRAcc->GetPaletteColor( 0 ) ); + const BitmapColor& rCol1( pRAcc->GetPaletteColor( 1 ) ); + if( rCol0.GetRed() == rCol0.GetGreen() && rCol0.GetRed() == rCol0.GetBlue() && + rCol1.GetRed() == rCol1.GetGreen() && rCol1.GetRed() == rCol1.GetBlue() ) + { + bRet = sal_True; + } ( (Bitmap*) this )->ReleaseAccess( pRAcc ); } else - bRet = sal_True; + bRet = sal_True; } else if( 4 == nBitCount || 8 == nBitCount ) { @@ -352,7 +352,7 @@ sal_Bool Bitmap::HasGreyPalette() const { if( pRAcc->HasPalette() && ( (BitmapPalette&) pRAcc->GetPalette() == GetGreyPalette( 1 << nBitCount ) ) ) bRet = sal_True; - + ( (Bitmap*) this )->ReleaseAccess( pRAcc ); } } @@ -398,7 +398,7 @@ sal_uLong Bitmap::GetChecksum() const UInt32ToSVBT32( pRAcc->GetColorMask().GetBlueMask(), aBT32 ); nCrc = rtl_crc32( nCrc, aBT32, 4 ); - + if( pRAcc->HasPalette() ) { nCrc = rtl_crc32( nCrc, pRAcc->GetPalette().ImplGetColorBuffer(), @@ -406,7 +406,7 @@ sal_uLong Bitmap::GetChecksum() const } nCrc = rtl_crc32( nCrc, pRAcc->GetBuffer(), pRAcc->GetScanlineSize() * pRAcc->Height() ); - + mpImpBmp->ImplSetChecksum( nRet = nCrc ); } @@ -532,7 +532,7 @@ sal_Bool Bitmap::Erase( const Color& rFillColor ) { if( !(*this) ) return sal_True; - + BitmapWriteAccess* pWriteAcc = AcquireWriteAccess(); sal_Bool bRet = sal_False; @@ -1394,17 +1394,17 @@ Region Bitmap::CreateRegion( const Color& rColor, const Rectangle& rRect ) const const long nBottom = aRect.Bottom(); const BitmapColor aMatch( pReadAcc->GetBestMatchingColor( rColor ) ); - //RectangleVector aRectangles; + //RectangleVector aRectangles; //aRegion.ImplBeginAddRect(); - std::vector< long > aLine; - long nYStart(nTop); - long nY(nTop); + std::vector< long > aLine; + long nYStart(nTop); + long nY(nTop); for( ; nY <= nBottom; nY++ ) { //aSubRect.Top() = aSubRect.Bottom() = nY; - std::vector< long > aNewLine; - long nX(nLeft); + std::vector< long > aNewLine; + long nX(nLeft); for( ; nX <= nRight; ) { @@ -1413,65 +1413,65 @@ Region Bitmap::CreateRegion( const Color& rColor, const Rectangle& rRect ) const if( nX <= nRight ) { - aNewLine.push_back(nX); + aNewLine.push_back(nX); //aSubRect.Left() = nX; while( ( nX <= nRight ) && ( aMatch == pReadAcc->GetPixel( nY, nX ) ) ) nX++; //aSubRect.Right() = nX - 1L; - aNewLine.push_back(nX - 1); + aNewLine.push_back(nX - 1); //aRegion.ImplAddRect( aSubRect ); - //aRectangles.push_back(aSubRect); - //aRegion.Union(aSubRect); + //aRectangles.push_back(aSubRect); + //aRegion.Union(aSubRect); } } - if(aNewLine != aLine) - { - // need to write aLine, it's different from the next line - if(aLine.size()) - { - Rectangle aSubRect; - - // enter y values and proceed ystart - aSubRect.Top() = nYStart; - aSubRect.Bottom() = nY ? nY - 1 : 0; - - for(sal_uInt32 a(0); a < aLine.size();) - { - aSubRect.Left() = aLine[a++]; - aSubRect.Right() = aLine[a++]; - aRegion.Union(aSubRect); - } - } - - // copy line as new line - aLine = aNewLine; - nYStart = nY; - } + if(aNewLine != aLine) + { + // need to write aLine, it's different from the next line + if(aLine.size()) + { + Rectangle aSubRect; + + // enter y values and proceed ystart + aSubRect.Top() = nYStart; + aSubRect.Bottom() = nY ? nY - 1 : 0; + + for(sal_uInt32 a(0); a < aLine.size();) + { + aSubRect.Left() = aLine[a++]; + aSubRect.Right() = aLine[a++]; + aRegion.Union(aSubRect); + } + } + + // copy line as new line + aLine = aNewLine; + nYStart = nY; + } } - // write last line if used - if(aLine.size()) - { - Rectangle aSubRect; + // write last line if used + if(aLine.size()) + { + Rectangle aSubRect; - // enter y values - aSubRect.Top() = nYStart; - aSubRect.Bottom() = nY ? nY - 1 : 0; + // enter y values + aSubRect.Top() = nYStart; + aSubRect.Bottom() = nY ? nY - 1 : 0; - for(sal_uInt32 a(0); a < aLine.size();) - { - aSubRect.Left() = aLine[a++]; - aSubRect.Right() = aLine[a++]; - aRegion.Union(aSubRect); - } - } + for(sal_uInt32 a(0); a < aLine.size();) + { + aSubRect.Left() = aLine[a++]; + aSubRect.Right() = aLine[a++]; + aRegion.Union(aSubRect); + } + } //aRegion.ImplEndAddRect(); - //aRegion.SetRegionRectangles(aRectangles); + //aRegion.SetRegionRectangles(aRectangles); ( (Bitmap*) this )->ReleaseAccess( pReadAcc ); } @@ -1504,7 +1504,7 @@ sal_Bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor ) // default to the nearest color aReplace = pAcc->GetBestMatchingColor( rReplaceColor ); - // for paletted images without a matching palette entry + // for paletted images without a matching palette entry // look for an unused palette entry (NOTE: expensive!) if( pAcc->GetPaletteColor( aReplace.GetIndex() ) != BitmapColor( rReplaceColor ) ) { @@ -1548,7 +1548,7 @@ sal_Bool Bitmap::Replace( const Bitmap& rMask, const Color& rReplaceColor ) if( pMaskAcc->GetPixel( nY, nX ) == aMaskWhite ) pAcc->SetPixel( nY, nX, aReplace ); - bRet = sal_True; + bRet = sal_True; } ( (Bitmap&) rMask ).ReleaseAccess( pMaskAcc ); @@ -1798,23 +1798,23 @@ Bitmap Bitmap::CreateDisplayBitmap( OutputDevice* pDisplay ) Bitmap Bitmap::GetColorTransformedBitmap( BmpColorMode eColorMode ) const { - Bitmap aRet; - + Bitmap aRet; + if( BMP_COLOR_HIGHCONTRAST == eColorMode ) { - Color* pSrcColors = NULL; - Color* pDstColors = NULL; - sal_uLong nColorCount = 0; - + Color* pSrcColors = NULL; + Color* pDstColors = NULL; + sal_uLong nColorCount = 0; + aRet = *this; - Image::GetColorTransformArrays( (ImageColorTransform) eColorMode, pSrcColors, pDstColors, nColorCount ); + Image::GetColorTransformArrays( (ImageColorTransform) eColorMode, pSrcColors, pDstColors, nColorCount ); - if( nColorCount && pSrcColors && pDstColors ) - aRet.Replace( pSrcColors, pDstColors, nColorCount ); + if( nColorCount && pSrcColors && pDstColors ) + aRet.Replace( pSrcColors, pDstColors, nColorCount ); - delete[] pSrcColors; - delete[] pDstColors; + delete[] pSrcColors; + delete[] pDstColors; } else if( BMP_COLOR_MONOCHROME_BLACK == eColorMode || BMP_COLOR_MONOCHROME_WHITE == eColorMode ) @@ -1822,8 +1822,8 @@ Bitmap Bitmap::GetColorTransformedBitmap( BmpColorMode eColorMode ) const aRet = *this; aRet.MakeMono( BMP_COLOR_MONOCHROME_THRESHOLD ); } - - return aRet; + + return aRet; } // ------------------------------------------------------------------ @@ -1956,7 +1956,7 @@ sal_Bool Bitmap::CombineSimple( const Bitmap& rMask, BmpCombine eCombine ) break; } - bRet = sal_True; + bRet = sal_True; } ( (Bitmap&) rMask ).ReleaseAccess( pMaskAcc ); @@ -1969,13 +1969,13 @@ sal_Bool Bitmap::CombineSimple( const Bitmap& rMask, BmpCombine eCombine ) sal_Bool Bitmap::Blend( const AlphaMask& rAlpha, const Color& rBackgroundColor ) { - // TODO: Have a look at OutputDevice::ImplDrawAlpha() for some - // optimizations. Might even consolidate the code here and there. + // TODO: Have a look at OutputDevice::ImplDrawAlpha() for some + // optimizations. Might even consolidate the code here and there. - // convert to a truecolor bitmap, if we're a paletted one. There's - // room for tradeoff decision here, maybe later for an overload (or a flag) - if( GetBitCount() <= 8 ) - Convert( BMP_CONVERSION_24BIT ); + // convert to a truecolor bitmap, if we're a paletted one. There's + // room for tradeoff decision here, maybe later for an overload (or a flag) + if( GetBitCount() <= 8 ) + Convert( BMP_CONVERSION_24BIT ); BitmapReadAccess* pAlphaAcc = const_cast<AlphaMask&>(rAlpha).AcquireReadAccess(); BitmapWriteAccess* pAcc = AcquireWriteAccess(); @@ -1988,11 +1988,11 @@ sal_Bool Bitmap::Blend( const AlphaMask& rAlpha, const Color& rBackgroundColor ) for( long nY = 0L; nY < nHeight; ++nY ) for( long nX = 0L; nX < nWidth; ++nX ) - pAcc->SetPixel( nY, nX, - pAcc->GetPixel( nY, nX ).Merge( rBackgroundColor, - 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) ); + pAcc->SetPixel( nY, nX, + pAcc->GetPixel( nY, nX ).Merge( rBackgroundColor, + 255 - pAlphaAcc->GetPixelIndex( nY, nX ) ) ); - bRet = sal_True; + bRet = sal_True; } const_cast<AlphaMask&>(rAlpha).ReleaseAccess( pAlphaAcc ); @@ -2012,13 +2012,15 @@ sal_Bool Bitmap::MakeMono( sal_uInt8 cThreshold ) bool Bitmap::GetSystemData( BitmapSystemData& rData ) const { - bool bRet = false; - if( mpImpBmp ) - { - SalBitmap* pSalBitmap = mpImpBmp->ImplGetSalBitmap(); - if( pSalBitmap ) - bRet = pSalBitmap->GetSystemData( rData ); - } - - return bRet; + bool bRet = false; + if( mpImpBmp ) + { + SalBitmap* pSalBitmap = mpImpBmp->ImplGetSalBitmap(); + if( pSalBitmap ) + bRet = pSalBitmap->GetSystemData( rData ); + } + + return bRet; } + +/* vim: set noet sw=4 ts=4: */ diff --git a/main/vcl/source/gdi/bitmap3.cxx b/main/vcl/source/gdi/bitmap3.cxx index 99f0af6e8b..c1121cf6f5 100644 --- a/main/vcl/source/gdi/bitmap3.cxx +++ b/main/vcl/source/gdi/bitmap3.cxx @@ -1,5 +1,5 @@ /************************************************************** - * + * * 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 @@ -7,16 +7,16 @@ * 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. - * + * *************************************************************/ @@ -234,7 +234,7 @@ long FloydError7[61] = long FloydIndexMap[6] = { - -30, 21, 72, 123, 174, 225 + -30, 21, 72, 123, 174, 225 }; // -------------------------- @@ -255,8 +255,8 @@ void ImplCreateDitherMatrix( sal_uInt8 (*pDitherMatrix)[16][16] ) // MagicSquare aufbauen for ( i = 0; i < 4; i++ ) - for ( j = 0; j < 4; j++ ) - for ( k = 0; k < 4; k++ ) + for ( j = 0; j < 4; j++ ) + for ( k = 0; k < 4; k++ ) for ( l = 0; l < 4; l++ ) nMax = Max ( pMtx[ (k<<2) + i][(l<<2 ) + j] = (sal_uInt16) ( 0.5 + pMagic[i][j]*fVal + pMagic[k][l]*fVal16 ), nMax ); @@ -479,7 +479,7 @@ sal_Bool Bitmap::ImplMakeMonoDither() for( long nX = 0L, nModY = nY % 16; nX < nWidth; nX++ ) { if( pReadAcc->GetPixel( nY, nX ).GetLuminance() > - pDitherMatrix[ nModY ][ nX % 16 ] ) + pDitherMatrix[ nModY ][ nX % 16 ] ) { pWriteAcc->SetPixel( nY, nX, aWhite ); } @@ -514,7 +514,7 @@ sal_Bool Bitmap::ImplMakeMonoDither() sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys ) { - DBG_ASSERT( nGreys == 16 || nGreys == 256, "Only 16 or 256 greyscales are supported!" ); + DBG_ASSERT( nGreys == 16 || nGreys == 256, "Only 16 or 256 grayscales are supported!" ); BitmapReadAccess* pReadAcc = AcquireReadAccess(); sal_Bool bRet = sal_False; @@ -565,7 +565,7 @@ sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys ) const sal_uLong nB = *pReadScan++; const sal_uLong nG = *pReadScan++; const sal_uLong nR = *pReadScan++; - + *pWriteScan++ = (sal_uInt8) ( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift ); } } @@ -585,7 +585,7 @@ sal_Bool Bitmap::ImplMakeGreyscales( sal_uInt16 nGreys ) const sal_uLong nR = *pReadScan++; const sal_uLong nG = *pReadScan++; const sal_uLong nB = *pReadScan++; - + *pWriteScan++ = (sal_uInt8) ( ( nB * 28UL + nG * 151UL + nR * 77UL ) >> nShift ); } } @@ -704,7 +704,7 @@ sal_Bool Bitmap::ImplConvertUp( sal_uInt16 nBitCount, Color* pExtColor ) sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor ) { - DBG_ASSERT( nBitCount <= GetBitCount(), "New BitCount must be lower ( or equal when pExtColor is set )!" ); + DBG_ASSERT( nBitCount <= GetBitCount(), "New BitCount must be lower (or equal when pExtColor is set)!" ); BitmapReadAccess* pReadAcc = AcquireReadAccess(); sal_Bool bRet = sal_False; @@ -779,11 +779,11 @@ sal_Bool Bitmap::ImplConvertDown( sal_uInt16 nBitCount, Color* pExtColor ) } // letztes ZeilenPixel - if( nX < nWidth ) - { - cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ nWidth1 ].ImplGetColor() ); - pWriteAcc->SetPixelIndex( nY, nX, cIndex ); - } + if( nX < nWidth ) + { + cIndex = (sal_uInt8) aColorMap.GetBestPaletteIndex( pQLine1[ nWidth1 ].ImplGetColor() ); + pWriteAcc->SetPixelIndex( nY, nX, cIndex ); + } // Zeilenpuffer neu fuellen/kopieren pQLine1 = pQLine2; @@ -873,7 +873,7 @@ sal_Bool Bitmap::ImplConvertGhosted() for( long nX = 0; nX < nWidth; nX++ ) { const BitmapColor aOld( pR->GetPixel( nY, nX ) ); - pW->SetPixel( nY, nX, BitmapColor( ( aOld.GetRed() >> 1 ) | 0x80, + pW->SetPixel( nY, nX, BitmapColor( ( aOld.GetRed() >> 1 ) | 0x80, ( aOld.GetGreen() >> 1 ) | 0x80, ( aOld.GetBlue() >> 1 ) | 0x80 ) ); @@ -906,122 +906,122 @@ sal_Bool Bitmap::ImplConvertGhosted() sal_Bool Bitmap::Scale( const double& rScaleX, const double& rScaleY, sal_uInt32 nScaleFlag ) { - if(basegfx::fTools::equalZero(rScaleX) || basegfx::fTools::equalZero(rScaleY)) - { - // no scale - return true; - } - - if(basegfx::fTools::equal(rScaleX, 1.0) && basegfx::fTools::equal(rScaleY, 1.0)) - { - // no scale - return true; - } + if(basegfx::fTools::equalZero(rScaleX) || basegfx::fTools::equalZero(rScaleY)) + { + // no scale + return true; + } + + if(basegfx::fTools::equal(rScaleX, 1.0) && basegfx::fTools::equal(rScaleY, 1.0)) + { + // no scale + return true; + } #ifdef DBG_UTIL - // #121233# allow to test the different scalers in debug build with source - // level debugger (change nNumber to desired action) - static sal_uInt16 nNumber(0); - const sal_uInt16 nStartCount(GetBitCount()); - - switch(nNumber) - { - case 0 : break; - case 1: nScaleFlag = BMP_SCALE_FAST; break; - case 2: nScaleFlag = BMP_SCALE_INTERPOLATE; break; - case 3: nScaleFlag = BMP_SCALE_SUPER; break; - case 4: nScaleFlag = BMP_SCALE_LANCZOS; break; - case 5: nScaleFlag = BMP_SCALE_BICUBIC; break; - case 6: nScaleFlag = BMP_SCALE_BILINEAR; break; - case 7: nScaleFlag = BMP_SCALE_BOX; break; - case 8: nScaleFlag = BMP_SCALE_BESTQUALITY; break; - case 9: nScaleFlag = BMP_SCALE_FASTESTINTERPOLATE; break; - } + // #121233# allow to test the different scalers in debug build with source + // level debugger (change nNumber to desired action) + static sal_uInt16 nNumber(0); + const sal_uInt16 nStartCount(GetBitCount()); + + switch(nNumber) + { + case 0 : break; + case 1: nScaleFlag = BMP_SCALE_FAST; break; + case 2: nScaleFlag = BMP_SCALE_INTERPOLATE; break; + case 3: nScaleFlag = BMP_SCALE_SUPER; break; + case 4: nScaleFlag = BMP_SCALE_LANCZOS; break; + case 5: nScaleFlag = BMP_SCALE_BICUBIC; break; + case 6: nScaleFlag = BMP_SCALE_BILINEAR; break; + case 7: nScaleFlag = BMP_SCALE_BOX; break; + case 8: nScaleFlag = BMP_SCALE_BESTQUALITY; break; + case 9: nScaleFlag = BMP_SCALE_FASTESTINTERPOLATE; break; + } #endif // DBG_UTIL - bool bRetval(false); - - if(BMP_SCALE_BESTQUALITY == nScaleFlag) - { - // Use LANCZOS when best quality is requested - nScaleFlag = BMP_SCALE_LANCZOS; - } - else if(BMP_SCALE_FASTESTINTERPOLATE == nScaleFlag) - { - // Use BMP_SCALE_SUPER when speed is requested, but not worst quality - nScaleFlag = BMP_SCALE_SUPER; - } - - switch(nScaleFlag) - { - default: - case BMP_SCALE_NONE : - { - bRetval = false; - break; - } - case BMP_SCALE_FAST : - { - bRetval = ImplScaleFast( rScaleX, rScaleY ); - break; - } - case BMP_SCALE_INTERPOLATE : - { - bRetval = ImplScaleInterpolate( rScaleX, rScaleY ); - break; - } - case BMP_SCALE_SUPER : - { - if(GetSizePixel().Width() < 2 || GetSizePixel().Height() < 2) - { - // fallback to ImplScaleFast - bRetval = ImplScaleFast( rScaleX, rScaleY ); - } - else - { - // #121233# use method from symphony - bRetval = ImplScaleSuper( rScaleX, rScaleY ); - } - break; - } - case BMP_SCALE_LANCZOS : - { - const Lanczos3Kernel kernel; - - bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel); - break; - } - case BMP_SCALE_BICUBIC : - { - const BicubicKernel kernel; - - bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); - break; - } - case BMP_SCALE_BILINEAR : - { - const BilinearKernel kernel; - - bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); - break; - } - case BMP_SCALE_BOX : - { - const BoxKernel kernel; - - bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); - break; - } - } + bool bRetval(false); + + if(BMP_SCALE_BESTQUALITY == nScaleFlag) + { + // Use LANCZOS when best quality is requested + nScaleFlag = BMP_SCALE_LANCZOS; + } + else if(BMP_SCALE_FASTESTINTERPOLATE == nScaleFlag) + { + // Use BMP_SCALE_SUPER when speed is requested, but not worst quality + nScaleFlag = BMP_SCALE_SUPER; + } + + switch(nScaleFlag) + { + default: + case BMP_SCALE_NONE : + { + bRetval = false; + break; + } + case BMP_SCALE_FAST : + { + bRetval = ImplScaleFast( rScaleX, rScaleY ); + break; + } + case BMP_SCALE_INTERPOLATE : + { + bRetval = ImplScaleInterpolate( rScaleX, rScaleY ); + break; + } + case BMP_SCALE_SUPER : + { + if(GetSizePixel().Width() < 2 || GetSizePixel().Height() < 2) + { + // fallback to ImplScaleFast + bRetval = ImplScaleFast( rScaleX, rScaleY ); + } + else + { + // #121233# use method from symphony + bRetval = ImplScaleSuper( rScaleX, rScaleY ); + } + break; + } + case BMP_SCALE_LANCZOS : + { + const Lanczos3Kernel kernel; + + bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel); + break; + } + case BMP_SCALE_BICUBIC : + { + const BicubicKernel kernel; + + bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); + break; + } + case BMP_SCALE_BILINEAR : + { + const BilinearKernel kernel; + + bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); + break; + } + case BMP_SCALE_BOX : + { + const BoxKernel kernel; + + bRetval = ImplScaleConvolution( rScaleX, rScaleY, kernel ); + break; + } + } #ifdef DBG_UTIL - if(bRetval && nStartCount != GetBitCount()) - { - OSL_ENSURE(false, "Bitmap::Scale has changed the ColorDepth, this should *not* happen (!)"); - } + if(bRetval && nStartCount != GetBitCount()) + { + OSL_ENSURE(false, "Bitmap::Scale has changed the ColorDepth, this should *not* happen (!)"); + } #endif - return bRetval; + return bRetval; } // ------------------------------------------------------------------------ @@ -1047,59 +1047,59 @@ sal_Bool Bitmap::Scale( const Size& rNewSize, sal_uInt32 nScaleFlag ) void Bitmap::AdaptBitCount(Bitmap& rNew) const { - ImplAdaptBitCount(rNew); + ImplAdaptBitCount(rNew); } // ------------------------------------------------------------------------ void Bitmap::ImplAdaptBitCount(Bitmap& rNew) const { - // aNew is the result of some operation; adapt it's BitCount to the original (this) - if(GetBitCount() != rNew.GetBitCount()) - { - switch(GetBitCount()) - { - case 1: - { - rNew.Convert(BMP_CONVERSION_1BIT_THRESHOLD); - break; - } - case 4: - { - if(HasGreyPalette()) - { - rNew.Convert(BMP_CONVERSION_4BIT_GREYS); - } - else - { - rNew.Convert(BMP_CONVERSION_4BIT_COLORS); - } - break; - } - case 8: - { - if(HasGreyPalette()) - { - rNew.Convert(BMP_CONVERSION_8BIT_GREYS); - } - else - { - rNew.Convert(BMP_CONVERSION_8BIT_COLORS); - } - break; - } - case 24: - { - rNew.Convert(BMP_CONVERSION_24BIT); - break; - } - default: - { - OSL_ENSURE(false, "BitDepth adaption failed (!)"); - break; - } - } - } + // aNew is the result of some operation; adapt its BitCount to the original (this) + if(GetBitCount() != rNew.GetBitCount()) + { + switch(GetBitCount()) + { + case 1: + { + rNew.Convert(BMP_CONVERSION_1BIT_THRESHOLD); + break; + } + case 4: + { + if(HasGreyPalette()) + { + rNew.Convert(BMP_CONVERSION_4BIT_GREYS); + } + else + { + rNew.Convert(BMP_CONVERSION_4BIT_COLORS); + } + break; + } + case 8: + { + if(HasGreyPalette()) + { + rNew.Convert(BMP_CONVERSION_8BIT_GREYS); + } + else + { + rNew.Convert(BMP_CONVERSION_8BIT_COLORS); + } + break; + } + case 24: + { + rNew.Convert(BMP_CONVERSION_24BIT); + break; + } + default: + { + OSL_ENSURE(false, "BitDepth adaption failed (!)"); + break; + } + } + } } // ------------------------------------------------------------------------ @@ -1114,8 +1114,8 @@ sal_Bool Bitmap::ImplScaleFast( const double& rScaleX, const double& rScaleY ) if( nNewWidth && nNewHeight ) { BitmapReadAccess* pReadAcc = AcquireReadAccess(); - if ( !pReadAcc ) - return sal_False; + if ( !pReadAcc ) + return sal_False; Bitmap aNewBmp( Size( nNewWidth, nNewHeight ), GetBitCount(), &pReadAcc->GetPalette() ); BitmapWriteAccess* pWriteAcc = aNewBmp.AcquireWriteAccess(); @@ -1219,19 +1219,19 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca { if( 1 == nWidth ) { - if( pReadAcc->HasPalette() ) - { - aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) ); - } - else - { - aCol0 = pReadAcc->GetPixel( nY, 0 ); - } + if( pReadAcc->HasPalette() ) + { + aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, 0 ) ); + } + else + { + aCol0 = pReadAcc->GetPixel( nY, 0 ); + } for( nX = 0L; nX < nNewWidth; nX++ ) - { + { pWriteAcc->SetPixel( nY, nX, aCol0 ); - } + } } else { @@ -1239,16 +1239,16 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca { nTemp = pLutInt[ nX ]; - if( pReadAcc->HasPalette() ) - { + if( pReadAcc->HasPalette() ) + { aCol0 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp++ ) ); aCol1 = pReadAcc->GetPaletteColor( pReadAcc->GetPixelIndex( nY, nTemp ) ); - } - else - { + } + else + { aCol0 = pReadAcc->GetPixel( nY, nTemp++ ); aCol1 = pReadAcc->GetPixel( nY, nTemp ); - } + } nTemp = pLutFrac[ nX ]; @@ -1276,8 +1276,8 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca if( bRet ) { bRet = sal_False; - const Bitmap aOriginal(*this); - *this = aNewBmp; + const Bitmap aOriginal(*this); + *this = aNewBmp; aNewBmp = Bitmap( Size( nNewWidth, nNewHeight ), 24 ); pReadAcc = AcquireReadAccess(); pWriteAcc = aNewBmp.AcquireWriteAccess(); @@ -1299,7 +1299,7 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca pLutFrac[ nY ] = (long) ( fTemp * 1024. ); } - // after 1st step, bitmap *is* 24bit format (see above) + // after 1st step, bitmap *is* 24bit format (see above) OSL_ENSURE(!pReadAcc->HasPalette(), "OOps, somehow ImplScaleInterpolate in-between format has palette, should not happen (!)"); for( nX = 0L; nX < nNewWidth; nX++ ) @@ -1309,9 +1309,9 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca aCol0 = pReadAcc->GetPixel( 0, nX ); for( nY = 0L; nY < nNewHeight; nY++ ) - { + { pWriteAcc->SetPixel( nY, nX, aCol0 ); - } + } } else { @@ -1346,17 +1346,17 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca aNewBmp.ReleaseAccess( pWriteAcc ); if( bRet ) - { - aOriginal.ImplAdaptBitCount(aNewBmp); + { + aOriginal.ImplAdaptBitCount(aNewBmp); *this = aNewBmp; - } + } } } if( !bRet ) - { + { bRet = ImplScaleFast( rScaleX, rScaleY ); - } + } return bRet; } @@ -1364,20 +1364,20 @@ sal_Bool Bitmap::ImplScaleInterpolate( const double& rScaleX, const double& rSca // ------------------------------------------------------------------------ // #121233# Added BMP_SCALE_SUPER from symphony code -sal_Bool Bitmap::ImplScaleSuper( - const double& rScaleX, - const double& rScaleY ) +sal_Bool Bitmap::ImplScaleSuper( + const double& rScaleX, + const double& rScaleY ) { const Size aSizePix( GetSizePixel() ); bool bHMirr = ( rScaleX < 0 ); - bool bVMirr = ( rScaleY < 0 ); - double scaleX = bHMirr ? -rScaleX : rScaleX; - double scaleY = bVMirr ? -rScaleY : rScaleY; + bool bVMirr = ( rScaleY < 0 ); + double scaleX = bHMirr ? -rScaleX : rScaleX; + double scaleY = bVMirr ? -rScaleY : rScaleY; const long nDstW = FRound( aSizePix.Width() * scaleX ); const long nDstH = FRound( aSizePix.Height() * scaleY ); const double fScaleThresh = 0.6; bool bRet = false; - + if( ( nDstW > 1L ) && ( nDstH > 1L ) ) { BitmapColor aCol0, aCol1, aColRes; @@ -1386,46 +1386,46 @@ sal_Bool Bitmap::ImplScaleSuper( long nH = pAcc->Height() ; Bitmap aOutBmp( Size( nDstW, nDstH ), 24 ); BitmapWriteAccess* pWAcc = aOutBmp.AcquireWriteAccess(); - long* pMapIX = new long[ nDstW ]; - long* pMapIY = new long[ nDstH ]; - long* pMapFX = new long[ nDstW ]; - long* pMapFY = new long[ nDstH ]; + long* pMapIX = new long[ nDstW ]; + long* pMapIY = new long[ nDstH ]; + long* pMapFX = new long[ nDstW ]; + long* pMapFY = new long[ nDstH ]; long nX, nY, nXDst, nYDst;; double fTemp; long nTemp , nTempX, nTempY, nTempFX, nTempFY; - sal_uInt8 cR0, cG0, cB0, cR1, cG1, cB1; - long nStartX = 0 , nStartY = 0; - long nEndX = nDstW - 1L; - long nEndY = nDstH - 1L; - long nMax = 1 << 7L; - + sal_uInt8 cR0, cG0, cB0, cR1, cG1, cB1; + long nStartX = 0 , nStartY = 0; + long nEndX = nDstW - 1L; + long nEndY = nDstH - 1L; + long nMax = 1 << 7L; + if( pAcc && pWAcc ) { - const double fRevScaleX = ( nDstW > 1L ) ? ( (double) ( nW - 1 ) / ( nDstW - 1 ) ) : 0.0; - const double fRevScaleY = ( nDstH > 1L ) ? ( (double) ( nH - 1 ) / ( nDstH - 1 ) ) : 0.0; - - // create horizontal mapping table - for( nX = 0L, nTempX = nW - 1L, nTemp = nW - 2L; nX < nDstW; nX++ ) - { - fTemp = nX * fRevScaleX; - - if( bHMirr ) - fTemp = nTempX - fTemp; - - pMapFX[ nX ] = (long) ( ( fTemp - ( pMapIX[ nX ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); - } - - // create vertical mapping table - for( nY = 0L, nTempY = nH - 1L, nTemp = nH - 2L; nY < nDstH; nY++ ) - { - fTemp = nY * fRevScaleY; - - if( bVMirr ) - fTemp = nTempY - fTemp; - - pMapFY[ nY ] = (long) ( ( fTemp - ( pMapIY[ nY ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); - } - + const double fRevScaleX = ( nDstW > 1L ) ? ( (double) ( nW - 1 ) / ( nDstW - 1 ) ) : 0.0; + const double fRevScaleY = ( nDstH > 1L ) ? ( (double) ( nH - 1 ) / ( nDstH - 1 ) ) : 0.0; + + // create horizontal mapping table + for( nX = 0L, nTempX = nW - 1L, nTemp = nW - 2L; nX < nDstW; nX++ ) + { + fTemp = nX * fRevScaleX; + + if( bHMirr ) + fTemp = nTempX - fTemp; + + pMapFX[ nX ] = (long) ( ( fTemp - ( pMapIX[ nX ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); + } + + // create vertical mapping table + for( nY = 0L, nTempY = nH - 1L, nTemp = nH - 2L; nY < nDstH; nY++ ) + { + fTemp = nY * fRevScaleY; + + if( bVMirr ) + fTemp = nTempY - fTemp; + + pMapFY[ nY ] = (long) ( ( fTemp - ( pMapIY[ nY ] = MinMax( (long) fTemp, 0, nTemp ) ) ) * 128. ); + } + if( pAcc->HasPalette() ) { if( pAcc->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ) @@ -1433,30 +1433,30 @@ sal_Bool Bitmap::ImplScaleSuper( if( scaleX >= fScaleThresh && scaleY >= fScaleThresh ) { Scanline pLine0, pLine1; - + for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; pLine0 = pAcc->GetScanline( nTempY ); pLine1 = pAcc->GetScanline( ++nTempY ); - + for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) { nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; - + const BitmapColor& rCol0 = pAcc->GetPaletteColor( pLine0[ nTempX ] ); const BitmapColor& rCol2 = pAcc->GetPaletteColor( pLine1[ nTempX ] ); const BitmapColor& rCol1 = pAcc->GetPaletteColor( pLine0[ ++nTempX ] ); const BitmapColor& rCol3 = pAcc->GetPaletteColor( pLine1[ nTempX ] ); - + cR0 = MAP( rCol0.GetRed(), rCol1.GetRed(), nTempFX ); cG0 = MAP( rCol0.GetGreen(), rCol1.GetGreen(), nTempFX ); cB0 = MAP( rCol0.GetBlue(), rCol1.GetBlue(), nTempFX ); - + cR1 = MAP( rCol2.GetRed(), rCol3.GetRed(), nTempFX ); cG1 = MAP( rCol2.GetGreen(), rCol3.GetGreen(), nTempFX ); cB1 = MAP( rCol2.GetBlue(), rCol3.GetBlue(), nTempFX ); - + aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); @@ -1470,14 +1470,14 @@ sal_Bool Bitmap::ImplScaleSuper( long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; - + for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTop = bVMirr ? ( nY + 1 ) : nY; nBottom = bVMirr ? nY : ( nY + 1 ) ; - + if( nY ==nEndY ) - { + { nLineStart = pMapIY[ nY ]; nLineRange = 0; } @@ -1486,14 +1486,14 @@ sal_Bool Bitmap::ImplScaleSuper( nLineStart = pMapIY[ nTop ] ; nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); } - + for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) { nLeft = bHMirr ? ( nX + 1 ) : nX; nRight = bHMirr ? nX : ( nX + 1 ) ; - + if( nX == nEndX ) - { + { nRowStart = pMapIX[ nX ]; nRowRange = 0; } @@ -1502,29 +1502,29 @@ sal_Bool Bitmap::ImplScaleSuper( nRowStart = pMapIX[ nLeft ]; nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); } - + nSumR = nSumG = nSumB = 0; nTotalWeightY = 0; - + for(int i = 0; i<= nLineRange; i++) { pTmpY = pAcc->GetScanline( nLineStart + i ); nSumRowR = nSumRowG = nSumRowB = 0; nTotalWeightX = 0; - + for(int j = 0; j <= nRowRange; j++) { const BitmapColor& rCol = pAcc->GetPaletteColor( pTmpY[ nRowStart + j ] ); - + if(nX == nEndX ) - { + { nSumRowB += rCol.GetBlue() << 7L; nSumRowG += rCol.GetGreen() << 7L; nSumRowR += rCol.GetRed() << 7L; nTotalWeightX += 1 << 7L; } else if( j == 0 ) - { + { nWeightX = (nMax- pMapFX[ nLeft ]) ; nSumRowB += ( nWeightX *rCol.GetBlue()) ; nSumRowG += ( nWeightX *rCol.GetGreen()) ; @@ -1532,7 +1532,7 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else if ( nRowRange == j ) - { + { nWeightX = pMapFX[ nRight ] ; nSumRowB += ( nWeightX *rCol.GetBlue() ); nSumRowG += ( nWeightX *rCol.GetGreen() ); @@ -1540,14 +1540,14 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else - { + { nSumRowB += rCol.GetBlue() << 7L; nSumRowG += rCol.GetGreen() << 7L; nSumRowR += rCol.GetRed() << 7L; nTotalWeightX += 1 << 7L; } } - + if( nY == nEndY ) nWeightY = nMax; else if( i == 0 ) @@ -1558,20 +1558,20 @@ sal_Bool Bitmap::ImplScaleSuper( nWeightY = pMapFY[ nBottom ]; else nWeightY = nMax; - + nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); nTotalWeightY += nWeightY; } - + aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); - + } - } + } } } else @@ -1581,44 +1581,44 @@ sal_Bool Bitmap::ImplScaleSuper( for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTempY = pMapIY[ nY ], nTempFY = pMapFY[ nY ]; - + for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) { nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; - + aCol0 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY, nTempX ) ); aCol1 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY, ++nTempX ) ); cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); - + aCol1 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( ++nTempY, nTempX ) ); aCol0 = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nTempY--, --nTempX ) ); cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); - + aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); } } - + } else { long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; - + for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTop = bVMirr ? ( nY + 1 ) : nY; nBottom = bVMirr ? nY : ( nY + 1 ) ; - + if( nY ==nEndY ) - { + { nLineStart = pMapIY[ nY ]; nLineRange = 0; } @@ -1627,14 +1627,14 @@ sal_Bool Bitmap::ImplScaleSuper( nLineStart = pMapIY[ nTop ] ; nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); } - + for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) { nLeft = bHMirr ? ( nX + 1 ) : nX; nRight = bHMirr ? nX : ( nX + 1 ) ; - + if( nX == nEndX ) - { + { nRowStart = pMapIX[ nX ]; nRowRange = 0; } @@ -1643,30 +1643,30 @@ sal_Bool Bitmap::ImplScaleSuper( nRowStart = pMapIX[ nLeft ]; nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); } - + nSumR = nSumG = nSumB = 0; nTotalWeightY = 0; - + for(int i = 0; i<= nLineRange; i++) { nSumRowR = nSumRowG = nSumRowB = 0; nTotalWeightX = 0; - + for(int j = 0; j <= nRowRange; j++) { aCol0 = pAcc->GetPaletteColor ( pAcc->GetPixelIndex( nLineStart + i, nRowStart + j ) ); - - if(nX == nEndX ) - { - + + if(nX == nEndX ) + { + nSumRowB += aCol0.GetBlue() << 7L; nSumRowG += aCol0.GetGreen() << 7L; nSumRowR += aCol0.GetRed() << 7L; nTotalWeightX += 1 << 7L; } else if( j == 0 ) - { - + { + nWeightX = (nMax- pMapFX[ nLeft ]) ; nSumRowB += ( nWeightX *aCol0.GetBlue()) ; nSumRowG += ( nWeightX *aCol0.GetGreen()) ; @@ -1674,8 +1674,8 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else if ( nRowRange == j ) - { - + { + nWeightX = pMapFX[ nRight ] ; nSumRowB += ( nWeightX *aCol0.GetBlue() ); nSumRowG += ( nWeightX *aCol0.GetGreen() ); @@ -1683,15 +1683,15 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else - { - + { + nSumRowB += aCol0.GetBlue() << 7L; nSumRowG += aCol0.GetGreen() << 7L; nSumRowR += aCol0.GetRed() << 7L; nTotalWeightX += 1 << 7L; } } - + if( nY == nEndY ) nWeightY = nMax; else if( i == 0 ) @@ -1702,19 +1702,19 @@ sal_Bool Bitmap::ImplScaleSuper( nWeightY = pMapFY[ nBottom ]; else nWeightY = nMax; - + nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); nTotalWeightY += nWeightY; } - + aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); } - } + } } } } @@ -1726,28 +1726,28 @@ sal_Bool Bitmap::ImplScaleSuper( { Scanline pLine0, pLine1, pTmp0, pTmp1; long nOff; - + for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; pLine0 = pAcc->GetScanline( nTempY ); pLine1 = pAcc->GetScanline( ++nTempY ); - - for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) + + for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) { nOff = 3L * ( nTempX = pMapIX[ nX ] ); nTempFX = pMapFX[ nX ]; - + pTmp1 = ( pTmp0 = pLine0 + nOff ) + 3L; cB0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cG0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cR0 = MAP( *pTmp0, *pTmp1, nTempFX ); - + pTmp1 = ( pTmp0 = pLine1 + nOff ) + 3L; cB1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cG1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cR1 = MAP( *pTmp0, *pTmp1, nTempFX ); - + aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); @@ -1761,14 +1761,14 @@ sal_Bool Bitmap::ImplScaleSuper( long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; - + for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTop = bVMirr ? ( nY + 1 ) : nY; nBottom = bVMirr ? nY : ( nY + 1 ) ; - + if( nY ==nEndY ) - { + { nLineStart = pMapIY[ nY ]; nLineRange = 0; } @@ -1777,14 +1777,14 @@ sal_Bool Bitmap::ImplScaleSuper( nLineStart = pMapIY[ nTop ] ; nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); } - + for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) { nLeft = bHMirr ? ( nX + 1 ) : nX; nRight = bHMirr ? nX : ( nX + 1 ) ; - - if( nX == nEndX ) - { + + if( nX == nEndX ) + { nRowStart = pMapIX[ nX ]; nRowRange = 0; } @@ -1793,28 +1793,28 @@ sal_Bool Bitmap::ImplScaleSuper( nRowStart = pMapIX[ nLeft ]; nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); } - + nSumR = nSumG = nSumB = 0; nTotalWeightY = 0; - + for(int i = 0; i<= nLineRange; i++) { pTmpY = pAcc->GetScanline( nLineStart + i ); pTmpX = pTmpY + 3L * nRowStart; nSumRowR = nSumRowG = nSumRowB = 0; nTotalWeightX = 0; - + for(int j = 0; j <= nRowRange; j++) { if(nX == nEndX ) - { - nSumRowB += ( *pTmpX ) << 7L;pTmpX++; - nSumRowG += ( *pTmpX ) << 7L;pTmpX++; - nSumRowR += ( *pTmpX ) << 7L;pTmpX++; + { + nSumRowB += ( *pTmpX ) << 7L;pTmpX++; + nSumRowG += ( *pTmpX ) << 7L;pTmpX++; + nSumRowR += ( *pTmpX ) << 7L;pTmpX++; nTotalWeightX += 1 << 7L; } else if( j == 0 ) - { + { nWeightX = (nMax- pMapFX[ nLeft ]) ; nSumRowB += ( nWeightX *( *pTmpX )) ;pTmpX++; nSumRowG += ( nWeightX *( *pTmpX )) ;pTmpX++; @@ -1822,7 +1822,7 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else if ( nRowRange == j ) - { + { nWeightX = pMapFX[ nRight ] ; nSumRowB += ( nWeightX *( *pTmpX ) );pTmpX++; nSumRowG += ( nWeightX *( *pTmpX ) );pTmpX++; @@ -1831,13 +1831,13 @@ sal_Bool Bitmap::ImplScaleSuper( } else { - nSumRowB += ( *pTmpX ) << 7L;pTmpX++; + nSumRowB += ( *pTmpX ) << 7L;pTmpX++; nSumRowG += ( *pTmpX ) << 7L;pTmpX++; nSumRowR += ( *pTmpX ) << 7L;pTmpX++; nTotalWeightX += 1 << 7L; } } - + if( nY == nEndY ) nWeightY = nMax; else if( i == 0 ) @@ -1848,20 +1848,20 @@ sal_Bool Bitmap::ImplScaleSuper( nWeightY = pMapFY[ nBottom ]; else nWeightY = nMax; - + nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); nTotalWeightY += nWeightY; } - + aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); - + } - } + } } } else if( pAcc->GetScanlineFormat() == BMP_FORMAT_24BIT_TC_RGB ) @@ -1870,28 +1870,28 @@ sal_Bool Bitmap::ImplScaleSuper( { Scanline pLine0, pLine1, pTmp0, pTmp1; long nOff; - + for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; pLine0 = pAcc->GetScanline( nTempY ); pLine1 = pAcc->GetScanline( ++nTempY ); - + for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) { nOff = 3L * ( nTempX = pMapIX[ nX ] ); nTempFX = pMapFX[ nX ]; - + pTmp1 = ( pTmp0 = pLine0 + nOff ) + 3L; cR0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cG0 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cB0 = MAP( *pTmp0, *pTmp1, nTempFX ); - + pTmp1 = ( pTmp0 = pLine1 + nOff ) + 3L; cR1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cG1 = MAP( *pTmp0, *pTmp1, nTempFX ); pTmp0++; pTmp1++; cB1 = MAP( *pTmp0, *pTmp1, nTempFX ); - + aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); @@ -1905,14 +1905,14 @@ sal_Bool Bitmap::ImplScaleSuper( long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; - + for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTop = bVMirr ? ( nY + 1 ) : nY; nBottom = bVMirr ? nY : ( nY + 1 ) ; - + if( nY ==nEndY ) - { + { nLineStart = pMapIY[ nY ]; nLineRange = 0; } @@ -1921,14 +1921,14 @@ sal_Bool Bitmap::ImplScaleSuper( nLineStart = pMapIY[ nTop ] ; nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); } - + for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) { nLeft = bHMirr ? ( nX + 1 ) : nX; nRight = bHMirr ? nX : ( nX + 1 ) ; - + if( nX == nEndX ) - { + { nRowStart = pMapIX[ nX ]; nRowRange = 0; } @@ -1937,28 +1937,28 @@ sal_Bool Bitmap::ImplScaleSuper( nRowStart = pMapIX[ nLeft ]; nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); } - + nSumR = nSumG = nSumB = 0; nTotalWeightY = 0; - + for(int i = 0; i<= nLineRange; i++) { pTmpY = pAcc->GetScanline( nLineStart + i ); pTmpX = pTmpY + 3L * nRowStart; nSumRowR = nSumRowG = nSumRowB = 0; nTotalWeightX = 0; - + for(int j = 0; j <= nRowRange; j++) { if(nX == nEndX ) - { - nSumRowR += ( *pTmpX ) << 7L;pTmpX++; - nSumRowG += ( *pTmpX ) << 7L;pTmpX++; - nSumRowB += ( *pTmpX ) << 7L;pTmpX++; + { + nSumRowR += ( *pTmpX ) << 7L;pTmpX++; + nSumRowG += ( *pTmpX ) << 7L;pTmpX++; + nSumRowB += ( *pTmpX ) << 7L;pTmpX++; nTotalWeightX += 1 << 7L; } else if( j == 0 ) - { + { nWeightX = (nMax- pMapFX[ nLeft ]) ; nSumRowR += ( nWeightX *( *pTmpX )) ;pTmpX++; nSumRowG += ( nWeightX *( *pTmpX )) ;pTmpX++; @@ -1966,7 +1966,7 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else if ( nRowRange == j ) - { + { nWeightX = pMapFX[ nRight ] ; nSumRowR += ( nWeightX *( *pTmpX ) );pTmpX++; nSumRowG += ( nWeightX *( *pTmpX ) );pTmpX++; @@ -1974,14 +1974,14 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else - { - nSumRowR += ( *pTmpX ) << 7L;pTmpX++; + { + nSumRowR += ( *pTmpX ) << 7L;pTmpX++; nSumRowG += ( *pTmpX ) << 7L;pTmpX++; nSumRowB += ( *pTmpX ) << 7L;pTmpX++; nTotalWeightX += 1 << 7L; } } - + if( nY == nEndY ) nWeightY = nMax; else if( i == 0 ) @@ -1992,20 +1992,20 @@ sal_Bool Bitmap::ImplScaleSuper( nWeightY = pMapFY[ nBottom ]; else nWeightY = nMax; - + nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); nTotalWeightY += nWeightY; } - + aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); - + } - } + } } } else @@ -2015,23 +2015,23 @@ sal_Bool Bitmap::ImplScaleSuper( for( nY = nStartY, nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTempY = pMapIY[ nY ]; nTempFY = pMapFY[ nY ]; - + for( nX = nStartX, nXDst = 0L; nX <= nEndX; nX++ ) { nTempX = pMapIX[ nX ]; nTempFX = pMapFX[ nX ]; - + aCol0 = pAcc->GetPixel( nTempY, nTempX ); aCol1 = pAcc->GetPixel( nTempY, ++nTempX ); cR0 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); cG0 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); cB0 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); - + aCol1 = pAcc->GetPixel( ++nTempY, nTempX ); aCol0 = pAcc->GetPixel( nTempY--, --nTempX ); cR1 = MAP( aCol0.GetRed(), aCol1.GetRed(), nTempFX ); cG1 = MAP( aCol0.GetGreen(), aCol1.GetGreen(), nTempFX ); cB1 = MAP( aCol0.GetBlue(), aCol1.GetBlue(), nTempFX ); - + aColRes.SetRed( MAP( cR0, cR1, nTempFY ) ); aColRes.SetGreen( MAP( cG0, cG1, nTempFY ) ); aColRes.SetBlue( MAP( cB0, cB1, nTempFY ) ); @@ -2044,14 +2044,14 @@ sal_Bool Bitmap::ImplScaleSuper( long nSumR, nSumG, nSumB,nLineStart , nLineRange, nRowStart , nRowRange ; long nLeft, nRight, nTop, nBottom, nWeightX, nWeightY ; long nSumRowR ,nSumRowG,nSumRowB, nTotalWeightX, nTotalWeightY; - + for( nY = nStartY , nYDst = 0L; nY <= nEndY; nY++, nYDst++ ) { nTop = bVMirr ? ( nY + 1 ) : nY; nBottom = bVMirr ? nY : ( nY + 1 ) ; - + if( nY ==nEndY ) - { + { nLineStart = pMapIY[ nY ]; nLineRange = 0; } @@ -2060,14 +2060,14 @@ sal_Bool Bitmap::ImplScaleSuper( nLineStart = pMapIY[ nTop ] ; nLineRange = ( pMapIY[ nBottom ] == pMapIY[ nTop ] ) ? 1 :( pMapIY[ nBottom ] - pMapIY[ nTop ] ); } - + for( nX = nStartX , nXDst = 0L; nX <= nEndX; nX++ ) { nLeft = bHMirr ? ( nX + 1 ) : nX; nRight = bHMirr ? nX : ( nX + 1 ) ; - + if( nX == nEndX ) - { + { nRowStart = pMapIX[ nX ]; nRowRange = 0; } @@ -2076,30 +2076,30 @@ sal_Bool Bitmap::ImplScaleSuper( nRowStart = pMapIX[ nLeft ]; nRowRange = ( pMapIX[ nRight ] == pMapIX[ nLeft ] )? 1 : ( pMapIX[ nRight ] - pMapIX[ nLeft ] ); } - + nSumR = nSumG = nSumB = 0; nTotalWeightY = 0; - + for(int i = 0; i<= nLineRange; i++) { nSumRowR = nSumRowG = nSumRowB = 0; nTotalWeightX = 0; - + for(int j = 0; j <= nRowRange; j++) { aCol0 = pAcc->GetPixel( nLineStart + i, nRowStart + j ); - - if(nX == nEndX ) - { - + + if(nX == nEndX ) + { + nSumRowB += aCol0.GetBlue() << 7L; nSumRowG += aCol0.GetGreen() << 7L; nSumRowR += aCol0.GetRed() << 7L; nTotalWeightX += 1 << 7L; } else if( j == 0 ) - { - + { + nWeightX = (nMax- pMapFX[ nLeft ]) ; nSumRowB += ( nWeightX *aCol0.GetBlue()) ; nSumRowG += ( nWeightX *aCol0.GetGreen()) ; @@ -2107,8 +2107,8 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else if ( nRowRange == j ) - { - + { + nWeightX = pMapFX[ nRight ] ; nSumRowB += ( nWeightX *aCol0.GetBlue() ); nSumRowG += ( nWeightX *aCol0.GetGreen() ); @@ -2116,14 +2116,14 @@ sal_Bool Bitmap::ImplScaleSuper( nTotalWeightX += nWeightX; } else - { + { nSumRowB += aCol0.GetBlue() << 7L; nSumRowG += aCol0.GetGreen() << 7L; nSumRowR += aCol0.GetRed() << 7L; nTotalWeightX += 1 << 7L; } } - + if( nY == nEndY ) nWeightY = nMax; else if( i == 0 ) @@ -2134,43 +2134,43 @@ sal_Bool Bitmap::ImplScaleSuper( nWeightY = pMapFY[ nBottom ]; else nWeightY = nMax; - + nSumB += nWeightY * ( nSumRowB / nTotalWeightX ); nSumG += nWeightY * ( nSumRowG / nTotalWeightX ); nSumR += nWeightY * ( nSumRowR / nTotalWeightX ); nTotalWeightY += nWeightY; } - + aColRes.SetRed( ( sal_uInt8 ) (( nSumR / nTotalWeightY ) )); aColRes.SetGreen( ( sal_uInt8 ) (( nSumG / nTotalWeightY) )); aColRes.SetBlue( ( sal_uInt8 ) (( nSumB / nTotalWeightY ) )); pWAcc->SetPixel( nYDst, nXDst++, aColRes ); - + } - } + } } } - } - - bRet = true; + } + + bRet = true; } - + delete[] pMapIX; delete[] pMapIY; delete[] pMapFX; delete[] pMapFY; - + ReleaseAccess( pAcc ); aOutBmp.ReleaseAccess( pWAcc ); - + if( bRet ) - { - ImplAdaptBitCount(aOutBmp); + { + ImplAdaptBitCount(aOutBmp); ImplAssignWithSize(aOutBmp); - } - + } + if( !bRet ) - bRet = ImplScaleFast( scaleX, scaleY ); + bRet = ImplScaleFast( scaleX, scaleY ); } return bRet; @@ -2180,358 +2180,358 @@ sal_Bool Bitmap::ImplScaleSuper( namespace { - void ImplCalculateContributions( - const sal_uInt32 aSourceSize, - const sal_uInt32 aDestinationSize, - sal_uInt32& aNumberOfContributions, - double*& pWeights, - sal_uInt32*& pPixels, - sal_uInt32*& pCount, - const Kernel& aKernel) - { - const double fSamplingRadius(aKernel.GetWidth()); - const double fScale(aDestinationSize / static_cast< double >(aSourceSize)); - const double fScaledRadius((fScale < 1.0) ? fSamplingRadius / fScale : fSamplingRadius); - const double fFilterFactor((fScale < 1.0) ? fScale : 1.0); - - aNumberOfContributions = (static_cast< sal_uInt32 >(fabs(ceil(fScaledRadius))) * 2) + 1; - const sal_uInt32 nAllocSize(aDestinationSize * aNumberOfContributions); - pWeights = new double[nAllocSize]; - pPixels = new sal_uInt32[nAllocSize]; - pCount = new sal_uInt32[aDestinationSize]; - - for(sal_uInt32 i(0); i < aDestinationSize; i++) - { - const sal_uInt32 aIndex(i * aNumberOfContributions); - const double aCenter(i / fScale); - const sal_Int32 aLeft(static_cast< sal_Int32 >(floor(aCenter - fScaledRadius))); - const sal_Int32 aRight(static_cast< sal_Int32 >(ceil(aCenter + fScaledRadius))); - sal_uInt32 aCurrentCount(0); - - for(sal_Int32 j(aLeft); j <= aRight; j++) - { - const double aWeight(aKernel.Calculate(fFilterFactor * (aCenter - static_cast< double>(j)))); - - // Reduce calculations with ignoring weights of 0.0 - if(fabs(aWeight) < 0.0001) - { - continue; - } - - // Handling on edges - const sal_uInt32 aPixelIndex(MinMax(j, 0, aSourceSize - 1)); - const sal_uInt32 nIndex(aIndex + aCurrentCount); - - pWeights[nIndex] = aWeight; - pPixels[nIndex] = aPixelIndex; - - aCurrentCount++; - } - - pCount[i] = aCurrentCount; - } - } - - sal_Bool ImplScaleConvolutionHor( - Bitmap& rSource, - Bitmap& rTarget, - const double& rScaleX, - const Kernel& aKernel) - { - // Do horizontal filtering - OSL_ENSURE(rScaleX > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); - const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); - const sal_uInt32 nNewWidth(FRound(nWidth * rScaleX)); - - if(nWidth == nNewWidth) - { - return true; - } - - BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); - - if(pReadAcc) - { - double* pWeights = 0; - sal_uInt32* pPixels = 0; - sal_uInt32* pCount = 0; - sal_uInt32 aNumberOfContributions(0); - - const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); - ImplCalculateContributions(nWidth, nNewWidth, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); - rTarget = Bitmap(Size(nNewWidth, nHeight), 24); - BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); - bool bResult(0 != pWriteAcc); - - if(bResult) - { - for(sal_uInt32 y(0); y < nHeight; y++) - { - for(sal_uInt32 x(0); x < nNewWidth; x++) - { - const sal_uInt32 aBaseIndex(x * aNumberOfContributions); - double aSum(0.0); - double aValueRed(0.0); - double aValueGreen(0.0); - double aValueBlue(0.0); - - for(sal_uInt32 j(0); j < pCount[x]; j++) - { - const sal_uInt32 aIndex(aBaseIndex + j); - const double aWeight(pWeights[aIndex]); - BitmapColor aColor; - - aSum += aWeight; - - if(pReadAcc->HasPalette()) - { - aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(y, pPixels[aIndex])); - } - else - { - aColor = pReadAcc->GetPixel(y, pPixels[aIndex]); - } - - aValueRed += aWeight * aColor.GetRed(); - aValueGreen += aWeight * aColor.GetGreen(); - aValueBlue += aWeight * aColor.GetBlue(); - } - - const BitmapColor aResultColor( - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); - - pWriteAcc->SetPixel(y, x, aResultColor); - } - } - - rTarget.ReleaseAccess(pWriteAcc); - } - - rSource.ReleaseAccess(pReadAcc); - delete[] pWeights; - delete[] pCount; - delete[] pPixels; - - if(bResult) - { - return true; - } - } - - return false; - } - - bool ImplScaleConvolutionVer( - Bitmap& rSource, - Bitmap& rTarget, - const double& rScaleY, - const Kernel& aKernel) - { - // Do vertical filtering - OSL_ENSURE(rScaleY > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); - const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); - const sal_uInt32 nNewHeight(FRound(nHeight * rScaleY)); - - if(nHeight == nNewHeight) - { - return true; - } - - BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); - - if(pReadAcc) - { - double* pWeights = 0; - sal_uInt32* pPixels = 0; - sal_uInt32* pCount = 0; - sal_uInt32 aNumberOfContributions(0); - - const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); - ImplCalculateContributions(nHeight, nNewHeight, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); - rTarget = Bitmap(Size(nWidth, nNewHeight), 24); - BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); - bool bResult(0 != pWriteAcc); - - if(pWriteAcc) - { - for(sal_uInt32 x(0); x < nWidth; x++) - { - for(sal_uInt32 y(0); y < nNewHeight; y++) - { - const sal_uInt32 aBaseIndex(y * aNumberOfContributions); - double aSum(0.0); - double aValueRed(0.0); - double aValueGreen(0.0); - double aValueBlue(0.0); - - for(sal_uInt32 j(0); j < pCount[y]; j++) - { - const sal_uInt32 aIndex(aBaseIndex + j); - const double aWeight(pWeights[aIndex]); - BitmapColor aColor; - - aSum += aWeight; - - if(pReadAcc->HasPalette()) - { - aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(pPixels[aIndex], x)); - } - else - { - aColor = pReadAcc->GetPixel(pPixels[aIndex], x); - } - - aValueRed += aWeight * aColor.GetRed(); - aValueGreen += aWeight * aColor.GetGreen(); - aValueBlue += aWeight * aColor.GetBlue(); - } - - const BitmapColor aResultColor( - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), - static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); - - if(pWriteAcc->HasPalette()) - { - pWriteAcc->SetPixelIndex(y, x, static_cast< sal_uInt8 >(pWriteAcc->GetBestPaletteIndex(aResultColor))); - } - else - { - pWriteAcc->SetPixel(y, x, aResultColor); - } - } - } - } - - rTarget.ReleaseAccess(pWriteAcc); - rSource.ReleaseAccess(pReadAcc); - - delete[] pWeights; - delete[] pCount; - delete[] pPixels; - - if(bResult) - { - return true; - } - } - - return false; - } + void ImplCalculateContributions( + const sal_uInt32 aSourceSize, + const sal_uInt32 aDestinationSize, + sal_uInt32& aNumberOfContributions, + double*& pWeights, + sal_uInt32*& pPixels, + sal_uInt32*& pCount, + const Kernel& aKernel) + { + const double fSamplingRadius(aKernel.GetWidth()); + const double fScale(aDestinationSize / static_cast< double >(aSourceSize)); + const double fScaledRadius((fScale < 1.0) ? fSamplingRadius / fScale : fSamplingRadius); + const double fFilterFactor((fScale < 1.0) ? fScale : 1.0); + + aNumberOfContributions = (static_cast< sal_uInt32 >(fabs(ceil(fScaledRadius))) * 2) + 1; + const sal_uInt32 nAllocSize(aDestinationSize * aNumberOfContributions); + pWeights = new double[nAllocSize]; + pPixels = new sal_uInt32[nAllocSize]; + pCount = new sal_uInt32[aDestinationSize]; + + for(sal_uInt32 i(0); i < aDestinationSize; i++) + { + const sal_uInt32 aIndex(i * aNumberOfContributions); + const double aCenter(i / fScale); + const sal_Int32 aLeft(static_cast< sal_Int32 >(floor(aCenter - fScaledRadius))); + const sal_Int32 aRight(static_cast< sal_Int32 >(ceil(aCenter + fScaledRadius))); + sal_uInt32 aCurrentCount(0); + + for(sal_Int32 j(aLeft); j <= aRight; j++) + { + const double aWeight(aKernel.Calculate(fFilterFactor * (aCenter - static_cast< double>(j)))); + + // Reduce calculations with ignoring weights of 0.0 + if(fabs(aWeight) < 0.0001) + { + continue; + } + + // Handling on edges + const sal_uInt32 aPixelIndex(MinMax(j, 0, aSourceSize - 1)); + const sal_uInt32 nIndex(aIndex + aCurrentCount); + + pWeights[nIndex] = aWeight; + pPixels[nIndex] = aPixelIndex; + + aCurrentCount++; + } + + pCount[i] = aCurrentCount; + } + } + + sal_Bool ImplScaleConvolutionHor( + Bitmap& rSource, + Bitmap& rTarget, + const double& rScaleX, + const Kernel& aKernel) + { + // Do horizontal filtering + OSL_ENSURE(rScaleX > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); + const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); + const sal_uInt32 nNewWidth(FRound(nWidth * rScaleX)); + + if(nWidth == nNewWidth) + { + return true; + } + + BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); + + if(pReadAcc) + { + double* pWeights = 0; + sal_uInt32* pPixels = 0; + sal_uInt32* pCount = 0; + sal_uInt32 aNumberOfContributions(0); + + const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); + ImplCalculateContributions(nWidth, nNewWidth, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); + rTarget = Bitmap(Size(nNewWidth, nHeight), 24); + BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); + bool bResult(0 != pWriteAcc); + + if(bResult) + { + for(sal_uInt32 y(0); y < nHeight; y++) + { + for(sal_uInt32 x(0); x < nNewWidth; x++) + { + const sal_uInt32 aBaseIndex(x * aNumberOfContributions); + double aSum(0.0); + double aValueRed(0.0); + double aValueGreen(0.0); + double aValueBlue(0.0); + + for(sal_uInt32 j(0); j < pCount[x]; j++) + { + const sal_uInt32 aIndex(aBaseIndex + j); + const double aWeight(pWeights[aIndex]); + BitmapColor aColor; + + aSum += aWeight; + + if(pReadAcc->HasPalette()) + { + aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(y, pPixels[aIndex])); + } + else + { + aColor = pReadAcc->GetPixel(y, pPixels[aIndex]); + } + + aValueRed += aWeight * aColor.GetRed(); + aValueGreen += aWeight * aColor.GetGreen(); + aValueBlue += aWeight * aColor.GetBlue(); + } + + const BitmapColor aResultColor( + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); + + pWriteAcc->SetPixel(y, x, aResultColor); + } + } + + rTarget.ReleaseAccess(pWriteAcc); + } + + rSource.ReleaseAccess(pReadAcc); + delete[] pWeights; + delete[] pCount; + delete[] pPixels; + + if(bResult) + { + return true; + } + } + + return false; + } + + bool ImplScaleConvolutionVer( + Bitmap& rSource, + Bitmap& rTarget, + const double& rScaleY, + const Kernel& aKernel) + { + // Do vertical filtering + OSL_ENSURE(rScaleY > 0.0, "Error in scaling: Mirror given in non-mirror-capable method (!)"); + const sal_uInt32 nHeight(rSource.GetSizePixel().Height()); + const sal_uInt32 nNewHeight(FRound(nHeight * rScaleY)); + + if(nHeight == nNewHeight) + { + return true; + } + + BitmapReadAccess* pReadAcc = rSource.AcquireReadAccess(); + + if(pReadAcc) + { + double* pWeights = 0; + sal_uInt32* pPixels = 0; + sal_uInt32* pCount = 0; + sal_uInt32 aNumberOfContributions(0); + + const sal_uInt32 nWidth(rSource.GetSizePixel().Width()); + ImplCalculateContributions(nHeight, nNewHeight, aNumberOfContributions, pWeights, pPixels, pCount, aKernel); + rTarget = Bitmap(Size(nWidth, nNewHeight), 24); + BitmapWriteAccess* pWriteAcc = rTarget.AcquireWriteAccess(); + bool bResult(0 != pWriteAcc); + + if(pWriteAcc) + { + for(sal_uInt32 x(0); x < nWidth; x++) + { + for(sal_uInt32 y(0); y < nNewHeight; y++) + { + const sal_uInt32 aBaseIndex(y * aNumberOfContributions); + double aSum(0.0); + double aValueRed(0.0); + double aValueGreen(0.0); + double aValueBlue(0.0); + + for(sal_uInt32 j(0); j < pCount[y]; j++) + { + const sal_uInt32 aIndex(aBaseIndex + j); + const double aWeight(pWeights[aIndex]); + BitmapColor aColor; + + aSum += aWeight; + + if(pReadAcc->HasPalette()) + { + aColor = pReadAcc->GetPaletteColor(pReadAcc->GetPixelIndex(pPixels[aIndex], x)); + } + else + { + aColor = pReadAcc->GetPixel(pPixels[aIndex], x); + } + + aValueRed += aWeight * aColor.GetRed(); + aValueGreen += aWeight * aColor.GetGreen(); + aValueBlue += aWeight * aColor.GetBlue(); + } + + const BitmapColor aResultColor( + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueRed / aSum), 0, 255)), + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueGreen / aSum), 0, 255)), + static_cast< sal_uInt8 >(MinMax(static_cast< sal_Int32 >(aValueBlue / aSum), 0, 255))); + + if(pWriteAcc->HasPalette()) + { + pWriteAcc->SetPixelIndex(y, x, static_cast< sal_uInt8 >(pWriteAcc->GetBestPaletteIndex(aResultColor))); + } + else + { + pWriteAcc->SetPixel(y, x, aResultColor); + } + } + } + } + + rTarget.ReleaseAccess(pWriteAcc); + rSource.ReleaseAccess(pReadAcc); + + delete[] pWeights; + delete[] pCount; + delete[] pPixels; + + if(bResult) + { + return true; + } + } + + return false; + } } // #121233# Added BMP_SCALE_LANCZOS, BMP_SCALE_BICUBIC, BMP_SCALE_BILINEAR and -// BMP_SCALE_BOX derived from the original commit from Toma� Vajngerl (see -// bugzilla task for deitails) Thanks! -sal_Bool Bitmap::ImplScaleConvolution( - const double& rScaleX, - const double& rScaleY, - const Kernel& aKernel) +// BMP_SCALE_BOX derived from the original commit from Tomaž Vajngerl (see +// Bugzilla task for details) Thanks! +sal_Bool Bitmap::ImplScaleConvolution( + const double& rScaleX, + const double& rScaleY, + const Kernel& aKernel) { - const bool bMirrorHor(rScaleX < 0.0); - const bool bMirrorVer(rScaleY < 0.0); - const double fScaleX(bMirrorHor ? -rScaleX : rScaleX); - const double fScaleY(bMirrorVer ? -rScaleY : rScaleY); - const sal_uInt32 nWidth(GetSizePixel().Width()); - const sal_uInt32 nHeight(GetSizePixel().Height()); - const sal_uInt32 nNewWidth(FRound(nWidth * fScaleX)); - const sal_uInt32 nNewHeight(FRound(nHeight * fScaleY)); - const bool bScaleHor(nWidth != nNewWidth); - const bool bScaleVer(nHeight != nNewHeight); - const bool bMirror(bMirrorHor || bMirrorVer); - - if(!bMirror && !bScaleHor && !bScaleVer) - { - return true; - } - - bool bResult(true); - sal_uInt32 nMirrorFlags(BMP_MIRROR_NONE); - bool bMirrorAfter(false); - - if(bMirror) - { - if(bMirrorHor) - { - nMirrorFlags |= BMP_MIRROR_HORZ; - } - - if(bMirrorVer) - { - nMirrorFlags |= BMP_MIRROR_VERT; - } - - const sal_uInt32 nStartSize(nWidth * nHeight); - const sal_uInt32 nEndSize(nNewWidth * nNewHeight); - - bMirrorAfter = nStartSize > nEndSize; - - if(!bMirrorAfter) - { - bResult = Mirror(nMirrorFlags); - } - } - - Bitmap aResult; - - if(bResult) - { - const sal_uInt32 nInBetweenSizeHorFirst(nHeight * nNewWidth); - const sal_uInt32 nInBetweenSizeVerFirst(nNewHeight * nWidth); - Bitmap aSource(*this); - - if(nInBetweenSizeHorFirst < nInBetweenSizeVerFirst) - { - if(bScaleHor) - { - bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); - } - - if(bResult && bScaleVer) - { - if(bScaleHor) - { - // copy partial result, independent of color depth - aSource = aResult; - } - - bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); - } - } - else - { - if(bScaleVer) - { - bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); - } - - if(bResult && bScaleHor) - { - if(bScaleVer) - { - // copy partial result, independent of color depth - aSource = aResult; - } - - bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); - } - } - } - - if(bResult && bMirrorAfter) - { - bResult = aResult.Mirror(nMirrorFlags); - } - - if(bResult) - { - ImplAdaptBitCount(aResult); - *this = aResult; - } - - return bResult; + const bool bMirrorHor(rScaleX < 0.0); + const bool bMirrorVer(rScaleY < 0.0); + const double fScaleX(bMirrorHor ? -rScaleX : rScaleX); + const double fScaleY(bMirrorVer ? -rScaleY : rScaleY); + const sal_uInt32 nWidth(GetSizePixel().Width()); + const sal_uInt32 nHeight(GetSizePixel().Height()); + const sal_uInt32 nNewWidth(FRound(nWidth * fScaleX)); + const sal_uInt32 nNewHeight(FRound(nHeight * fScaleY)); + const bool bScaleHor(nWidth != nNewWidth); + const bool bScaleVer(nHeight != nNewHeight); + const bool bMirror(bMirrorHor || bMirrorVer); + + if(!bMirror && !bScaleHor && !bScaleVer) + { + return true; + } + + bool bResult(true); + sal_uInt32 nMirrorFlags(BMP_MIRROR_NONE); + bool bMirrorAfter(false); + + if(bMirror) + { + if(bMirrorHor) + { + nMirrorFlags |= BMP_MIRROR_HORZ; + } + + if(bMirrorVer) + { + nMirrorFlags |= BMP_MIRROR_VERT; + } + + const sal_uInt32 nStartSize(nWidth * nHeight); + const sal_uInt32 nEndSize(nNewWidth * nNewHeight); + + bMirrorAfter = nStartSize > nEndSize; + + if(!bMirrorAfter) + { + bResult = Mirror(nMirrorFlags); + } + } + + Bitmap aResult; + + if(bResult) + { + const sal_uInt32 nInBetweenSizeHorFirst(nHeight * nNewWidth); + const sal_uInt32 nInBetweenSizeVerFirst(nNewHeight * nWidth); + Bitmap aSource(*this); + + if(nInBetweenSizeHorFirst < nInBetweenSizeVerFirst) + { + if(bScaleHor) + { + bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); + } + + if(bResult && bScaleVer) + { + if(bScaleHor) + { + // copy partial result, independent of color depth + aSource = aResult; + } + + bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); + } + } + else + { + if(bScaleVer) + { + bResult = ImplScaleConvolutionVer(aSource, aResult, fScaleY, aKernel); + } + + if(bResult && bScaleHor) + { + if(bScaleVer) + { + // copy partial result, independent of color depth + aSource = aResult; + } + + bResult = ImplScaleConvolutionHor(aSource, aResult, fScaleX, aKernel); + } + } + } + + if(bResult && bMirrorAfter) + { + bResult = aResult.Mirror(nMirrorFlags); + } + + if(bResult) + { + ImplAdaptBitCount(aResult); + *this = aResult; + } + + return bResult; } // ------------------------------------------------------------------------ @@ -2959,11 +2959,11 @@ extern "C" int __LOADONCALLAPI ImplPopularCmpFnc( const void* p1, const void* p2 if( ( (PopularColorCount*) p1 )->mnCount < ( (PopularColorCount*) p2 )->mnCount ) nRet = 1; - else if( ( (PopularColorCount*) p1 )->mnCount == ( (PopularColorCount*) p2 )->mnCount ) + else if( ( (PopularColorCount*) p1 )->mnCount == ( (PopularColorCount*) p2 )->mnCount ) nRet = 0; else nRet = -1; - + return nRet; } @@ -3000,16 +3000,16 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) rtl_zeroMemory( pCountTable, nTotalColors * sizeof( PopularColorCount ) ); for( nR = 0, nIndex = 0; nR < 256; nR += nColorOffset ) - { + { for( nG = 0; nG < 256; nG += nColorOffset ) - { + { for( nB = 0; nB < 256; nB += nColorOffset ) - { + { pCountTable[ nIndex ].mnIndex = nIndex; - nIndex++; - } - } - } + nIndex++; + } + } + } if( pRAcc->HasPalette() ) { @@ -3019,7 +3019,7 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) { const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ); pCountTable[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | - ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | + ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++; } } @@ -3032,8 +3032,8 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) { const BitmapColor aCol( pRAcc->GetPixel( nY, nX ) ); pCountTable[ ( ( ( (sal_uInt32) aCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | - ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | - ( ( (sal_uInt32) aCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++; + ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | + ( ( (sal_uInt32) aCol.GetBlue() ) >> nRightShiftBits ) ].mnCount++; } } } @@ -3041,11 +3041,11 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) BitmapPalette aNewPal( nColCount ); qsort( pCountTable, nTotalColors, sizeof( PopularColorCount ), ImplPopularCmpFnc ); - + for( sal_uInt16 n = 0; n < nColCount; n++ ) { const PopularColorCount& rPop = pCountTable[ n ]; - aNewPal[ n ] = BitmapColor( (sal_uInt8) ( ( rPop.mnIndex >> nLeftShiftBits2 ) << nRightShiftBits ), + aNewPal[ n ] = BitmapColor( (sal_uInt8) ( ( rPop.mnIndex >> nLeftShiftBits2 ) << nRightShiftBits ), (sal_uInt8) ( ( ( rPop.mnIndex >> nLeftShiftBits1 ) & ( nColorsPerComponent - 1 ) ) << nRightShiftBits ), (sal_uInt8) ( ( rPop.mnIndex & ( nColorsPerComponent - 1 ) ) << nRightShiftBits ) ); } @@ -3071,7 +3071,7 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) { const BitmapColor& rCol = pRAcc->GetPaletteColor( pRAcc->GetPixelIndex( nY, nX ) ); aDstCol.SetIndex( pIndexMap[ ( ( ( (sal_uInt32) rCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | - ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | + ( ( ( (sal_uInt32) rCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | ( ( (sal_uInt32) rCol.GetBlue() ) >> nRightShiftBits ) ] ); pWAcc->SetPixel( nY, nX, aDstCol ); } @@ -3085,7 +3085,7 @@ sal_Bool Bitmap::ImplReducePopular( sal_uInt16 nColCount ) { const BitmapColor aCol( pRAcc->GetPixel( nY, nX ) ); aDstCol.SetIndex( pIndexMap[ ( ( ( (sal_uInt32) aCol.GetRed() ) >> nRightShiftBits ) << nLeftShiftBits2 ) | - ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | + ( ( ( (sal_uInt32) aCol.GetGreen() ) >> nRightShiftBits ) << nLeftShiftBits1 ) | ( ( (sal_uInt32) aCol.GetBlue() ) >> nRightShiftBits ) ] ); pWAcc->SetPixel( nY, nX, aDstCol ); } @@ -3174,7 +3174,7 @@ sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount ) // create palette via median cut BitmapPalette aPal( pWAcc->GetPaletteEntryCount() ); - ImplMedianCut( pColBuf, aPal, 0, 31, 0, 31, 0, 31, + ImplMedianCut( pColBuf, aPal, 0, 31, 0, 31, 0, 31, nColCount, nWidth * nHeight, nIndex ); // do mapping of colors to palette @@ -3207,7 +3207,7 @@ sal_Bool Bitmap::ImplReduceMedian( sal_uInt16 nColCount ) // ------------------------------------------------------------------------ -void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal, +void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal, long nR1, long nR2, long nG1, long nG2, long nB1, long nB2, long nColors, long nPixels, long& rIndex ) { @@ -3216,7 +3216,7 @@ void Bitmap::ImplMedianCut( sal_uLong* pColBuf, BitmapPalette& rPal, BitmapColor aCol; const long nRLen = nR2 - nR1; - const long nGLen = nG2 - nG1; + const long nGLen = nG2 - nG1; const long nBLen = nB2 - nB1; long nR, nG, nB; sal_uLong* pBuf = pColBuf; @@ -3362,7 +3362,7 @@ sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, sal_Bool bRet = sal_False; // nothing to do => return quickly - if( !nLuminancePercent && !nContrastPercent && + if( !nLuminancePercent && !nContrastPercent && !nChannelRPercent && !nChannelGPercent && !nChannelBPercent && ( fGamma == 1.0 ) && !bInvert ) { @@ -3382,7 +3382,7 @@ sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, sal_uInt8* cMapB = new sal_uInt8[ 256 ]; long nX, nY; double fM, fROff, fGOff, fBOff, fOff; - + // calculate slope if( nContrastPercent >= 0 ) fM = 128.0 / ( 128.0 - 1.27 * MinMax( nContrastPercent, 0L, 100L ) ); @@ -3392,7 +3392,7 @@ sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, // total offset = luminance offset + contrast offset fOff = MinMax( nLuminancePercent, -100L, 100L ) * 2.55 + 128.0 - fM * 128.0; - // channel offset = channel offset + total offset + // channel offset = channel offset + total offset fROff = nChannelRPercent * 2.55 + fOff; fGOff = nChannelGPercent * 2.55 + fOff; fBOff = nChannelBPercent * 2.55 + fOff; @@ -3430,7 +3430,7 @@ sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, for( sal_uInt16 i = 0, nCount = pAcc->GetPaletteEntryCount(); i < nCount; i++ ) { - const BitmapColor& rCol = pAcc->GetPaletteColor( i ); + const BitmapColor& rCol = pAcc->GetPaletteColor( i ); aNewCol.SetRed( cMapR[ rCol.GetRed() ] ); aNewCol.SetGreen( cMapG[ rCol.GetGreen() ] ); aNewCol.SetBlue( cMapB[ rCol.GetBlue() ] ); @@ -3490,3 +3490,5 @@ sal_Bool Bitmap::Adjust( short nLuminancePercent, short nContrastPercent, return bRet; } + +/* vim: set noet sw=4 ts=4: */ diff --git a/main/vcl/source/gdi/bitmap4.cxx b/main/vcl/source/gdi/bitmap4.cxx index d06aa637c0..407a2e5439 100644 --- a/main/vcl/source/gdi/bitmap4.cxx +++ b/main/vcl/source/gdi/bitmap4.cxx @@ -1,5 +1,5 @@ /************************************************************** - * + * * 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 @@ -7,16 +7,16 @@ * 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. - * + * *************************************************************/ @@ -139,13 +139,13 @@ sal_Bool Bitmap::ImplConvolute3( const long* pMatrix, long nDivisor, // create column LUT for( i = 0; i < nWidth2; i++ ) pColm[ i ] = ( i > 0 ) ? ( i - 1 ) : 0; - + pColm[ nWidth + 1 ] = pColm[ nWidth ]; // create row LUT for( i = 0; i < nHeight2; i++ ) pRows[ i ] = ( i > 0 ) ? ( i - 1 ) : 0; - + pRows[ nHeight + 1 ] = pRows[ nHeight ]; // read first three rows of bitmap color @@ -282,24 +282,24 @@ sal_Bool Bitmap::ImplMedianFilter( const BmpFilterParam* /*pFilterParam*/, const // create column LUT for( i = 0; i < nWidth2; i++ ) pColm[ i ] = ( i > 0 ) ? ( i - 1 ) : 0; - + pColm[ nWidth + 1 ] = pColm[ nWidth ]; // create row LUT for( i = 0; i < nHeight2; i++ ) pRows[ i ] = ( i > 0 ) ? ( i - 1 ) : 0; - + pRows[ nHeight + 1 ] = pRows[ nHeight ]; // read first three rows of bitmap color if (nHeight2 > 2) { - for( i = 0; i < nWidth2; i++ ) - { - pColRow1[ i ] = pReadAcc->GetColor( pRows[ 0 ], pColm[ i ] ); - pColRow2[ i ] = pReadAcc->GetColor( pRows[ 1 ], pColm[ i ] ); - pColRow3[ i ] = pReadAcc->GetColor( pRows[ 2 ], pColm[ i ] ); - } + for( i = 0; i < nWidth2; i++ ) + { + pColRow1[ i ] = pReadAcc->GetColor( pRows[ 0 ], pColm[ i ] ); + pColRow2[ i ] = pReadAcc->GetColor( pRows[ 1 ], pColm[ i ] ); + pColRow3[ i ] = pReadAcc->GetColor( pRows[ 2 ], pColm[ i ] ); + } } // do median filtering @@ -310,7 +310,7 @@ sal_Bool Bitmap::ImplMedianFilter( const BmpFilterParam* /*pFilterParam*/, const nR1 = ( pColor = pRowTmp1 + nX )->GetRed(), nG1 = pColor->GetGreen(), nB1 = pColor->GetBlue(); nR2 = ( ++pColor )->GetRed(), nG2 = pColor->GetGreen(), nB2 = pColor->GetBlue(); nR3 = ( ++pColor )->GetRed(), nG3 = pColor->GetGreen(), nB3 = pColor->GetBlue(); - + nR4 = ( pColor = pRowTmp2 + nX )->GetRed(), nG4 = pColor->GetGreen(), nB4 = pColor->GetBlue(); nR5 = ( ++pColor )->GetRed(), nG5 = pColor->GetGreen(), nB5 = pColor->GetBlue(); nR6 = ( ++pColor )->GetRed(), nG6 = pColor->GetGreen(), nB6 = pColor->GetBlue(); @@ -318,22 +318,22 @@ sal_Bool Bitmap::ImplMedianFilter( const BmpFilterParam* /*pFilterParam*/, const nR7 = ( pColor = pRowTmp3 + nX )->GetRed(), nG7 = pColor->GetGreen(), nB7 = pColor->GetBlue(); nR8 = ( ++pColor )->GetRed(), nG8 = pColor->GetGreen(), nB8 = pColor->GetBlue(); nR9 = ( ++pColor )->GetRed(), nG9 = pColor->GetGreen(), nB9 = pColor->GetBlue(); - + MNMX6( nR1, nR2, nR3, nR4, nR5, nR6 ); - MNMX5( nR7, nR2, nR3, nR4, nR5 ); - MNMX4( nR8, nR2, nR3, nR4 ); - MNMX3( nR9, nR2, nR3 ); + MNMX5( nR7, nR2, nR3, nR4, nR5 ); + MNMX4( nR8, nR2, nR3, nR4 ); + MNMX3( nR9, nR2, nR3 ); MNMX6( nG1, nG2, nG3, nG4, nG5, nG6 ); - MNMX5( nG7, nG2, nG3, nG4, nG5 ); - MNMX4( nG8, nG2, nG3, nG4 ); - MNMX3( nG9, nG2, nG3 ); + MNMX5( nG7, nG2, nG3, nG4, nG5 ); + MNMX4( nG8, nG2, nG3, nG4 ); + MNMX3( nG9, nG2, nG3 ); MNMX6( nB1, nB2, nB3, nB4, nB5, nB6 ); - MNMX5( nB7, nB2, nB3, nB4, nB5 ); - MNMX4( nB8, nB2, nB3, nB4 ); - MNMX3( nB9, nB2, nB3 ); - + MNMX5( nB7, nB2, nB3, nB4, nB5 ); + MNMX4( nB8, nB2, nB3, nB4 ); + MNMX3( nB9, nB2, nB3 ); + // set destination color pWriteAcc->SetPixel( nY, nX, BitmapColor( (sal_uInt8) nR2, (sal_uInt8) nG2, (sal_uInt8) nB2 ) ); } @@ -391,7 +391,7 @@ sal_Bool Bitmap::ImplSobelGrey( const BmpFilterParam* /*pFilterParam*/, const Li bRet = sal_False; BitmapReadAccess* pReadAcc = AcquireReadAccess(); - + if( pReadAcc ) { Bitmap aNewBmp( GetSizePixel(), 8, &pReadAcc->GetPalette() ); @@ -519,7 +519,7 @@ sal_Bool Bitmap::ImplEmbossGrey( const BmpFilterParam* pFilterParam, const Link* bRet = sal_False; BitmapReadAccess* pReadAcc = AcquireReadAccess(); - + if( pReadAcc ) { Bitmap aNewBmp( GetSizePixel(), 8, &pReadAcc->GetPalette() ); @@ -584,7 +584,7 @@ sal_Bool Bitmap::ImplEmbossGrey( const BmpFilterParam* pFilterParam, const Link* const double fGrey = nDotL / sqrt( (double)(nNx * nNx + nNy * nNy + nZ2) ); aGrey.SetIndex( (sal_uInt8) VOS_BOUND( fGrey, 0, 255 ) ); } - + pWriteAcc->SetPixel( nY, nX, aGrey ); if( nX < ( nWidth - 1 ) ) @@ -628,10 +628,10 @@ sal_Bool Bitmap::ImplSolarize( const BmpFilterParam* pFilterParam, const Link* / { sal_Bool bRet = sal_False; BitmapWriteAccess* pWriteAcc = AcquireWriteAccess(); - + if( pWriteAcc ) { - const sal_uInt8 cThreshold = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_SOLARIZE ) ? + const sal_uInt8 cThreshold = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_SOLARIZE ) ? pFilterParam->mcSolarGreyThreshold : 128; if( pWriteAcc->HasPalette() ) @@ -658,7 +658,7 @@ sal_Bool Bitmap::ImplSolarize( const BmpFilterParam* pFilterParam, const Link* / for( long nX = 0; nX < nWidth; nX++ ) { aCol = pWriteAcc->GetPixel( nY, nX ); - + if( aCol.GetLuminance() >= cThreshold ) pWriteAcc->SetPixel( nY, nX, aCol.Invert() ); } @@ -678,11 +678,11 @@ sal_Bool Bitmap::ImplSepia( const BmpFilterParam* pFilterParam, const Link* /*pP { BitmapReadAccess* pReadAcc = AcquireReadAccess(); sal_Bool bRet = sal_False; - + if( pReadAcc ) { - long nSepiaPercent = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_SEPIA ) ? - pFilterParam->mcSolarGreyThreshold : 10; + long nSepiaPercent = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_SEPIA ) ? + pFilterParam->mcSolarGreyThreshold : 10; const long nSepia = 10000 - 100 * VOS_BOUND( nSepiaPercent, 0, 100 ); BitmapPalette aSepiaPal( 256 ); @@ -763,10 +763,10 @@ sal_Bool Bitmap::ImplSepia( const BmpFilterParam* pFilterParam, const Link* /*pP sal_Bool Bitmap::ImplMosaic( const BmpFilterParam* pFilterParam, const Link* /*pProgress*/ ) { - sal_uLong nTileWidth = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_MOSAIC ) ? - pFilterParam->maMosaicTileSize.mnTileWidth : 4; - sal_uLong nTileHeight = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_MOSAIC ) ? - pFilterParam->maMosaicTileSize.mnTileHeight : 4; + sal_uLong nTileWidth = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_MOSAIC ) ? + pFilterParam->maMosaicTileSize.mnTileWidth : 4; + sal_uLong nTileHeight = ( pFilterParam && pFilterParam->meFilter == BMP_FILTER_MOSAIC ) ? + pFilterParam->maMosaicTileSize.mnTileHeight : 4; sal_Bool bRet = sal_False; if( !nTileWidth ) @@ -792,7 +792,7 @@ sal_Bool Bitmap::ImplMosaic( const BmpFilterParam* pFilterParam, const Link* /*p pReadAcc = AcquireReadAccess(); pWriteAcc = pNewBmp->AcquireWriteAccess(); } - + if( pReadAcc && pWriteAcc ) { BitmapColor aCol; @@ -812,7 +812,7 @@ sal_Bool Bitmap::ImplMosaic( const BmpFilterParam* pFilterParam, const Link* /*p if( nX2 >= nWidth ) nX2 = nWidth - 1; - + fArea_1 = 1.0 / ( ( nX2 - nX1 + 1 ) * ( nY2 - nY1 + 1 ) ); if( !pNewBmp ) @@ -914,7 +914,7 @@ sal_Bool Bitmap::ImplMosaic( const BmpFilterParam* pFilterParam, const Link* /*p } else bRet = sal_True; - + return bRet; } @@ -934,11 +934,11 @@ extern "C" int __LOADONCALLAPI ImplPopArtCmpFnc( const void* p1, const void* p2 if( ( (PopArtEntry*) p1 )->mnCount < ( (PopArtEntry*) p2 )->mnCount ) nRet = 1; - else if( ( (PopArtEntry*) p1 )->mnCount == ( (PopArtEntry*) p2 )->mnCount ) + else if( ( (PopArtEntry*) p1 )->mnCount == ( (PopArtEntry*) p2 )->mnCount ) nRet = 0; else nRet = -1; - + return nRet; } @@ -976,7 +976,7 @@ sal_Bool Bitmap::ImplPopArt( const BmpFilterParam* /*pFilterParam*/, const Link* // sort table qsort( pPopArtTable, nEntryCount, sizeof( PopArtEntry ), ImplPopArtCmpFnc ); - + // get last used entry sal_uLong nFirstEntry; sal_uLong nLastEntry = 0; @@ -989,7 +989,7 @@ sal_Bool Bitmap::ImplPopArt( const BmpFilterParam* /*pFilterParam*/, const Link* const BitmapColor aFirstCol( pWriteAcc->GetPaletteColor( sal::static_int_cast<sal_uInt16>(pPopArtTable[ 0 ].mnIndex) ) ); for( nFirstEntry = 0; nFirstEntry < nLastEntry; nFirstEntry++ ) { - pWriteAcc->SetPaletteColor( sal::static_int_cast<sal_uInt16>(pPopArtTable[ nFirstEntry ].mnIndex), + pWriteAcc->SetPaletteColor( sal::static_int_cast<sal_uInt16>(pPopArtTable[ nFirstEntry ].mnIndex), pWriteAcc->GetPaletteColor( sal::static_int_cast<sal_uInt16>(pPopArtTable[ nFirstEntry + 1 ].mnIndex) ) ); } pWriteAcc->SetPaletteColor( sal::static_int_cast<sal_uInt16>(pPopArtTable[ nLastEntry ].mnIndex), aFirstCol ); @@ -1004,5 +1004,4 @@ sal_Bool Bitmap::ImplPopArt( const BmpFilterParam* /*pFilterParam*/, const Link* return bRet; } -// ----------------------------------------------------------------------------- -// eof +/* vim: set noet sw=4 ts=4: */ diff --git a/main/vcl/source/gdi/bitmapex.cxx b/main/vcl/source/gdi/bitmapex.cxx index 4150e8e06c..fff95c4fa8 100644 --- a/main/vcl/source/gdi/bitmapex.cxx +++ b/main/vcl/source/gdi/bitmapex.cxx @@ -1,5 +1,5 @@ /************************************************************** - * + * * 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 @@ -7,18 +7,20 @@ * 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" @@ -77,7 +79,7 @@ BitmapEx::BitmapEx( const BitmapEx& rBitmapEx, Point aSrc, Size aSize ) : } else if( rBitmapEx.IsTransparent() ) aMask = Bitmap( aSize, rBitmapEx.aMask.GetBitCount() ); - + Rectangle aDestRect( Point( 0, 0 ), aSize ); Rectangle aSrcRect( aSrc, aSize ); CopyPixel( aDestRect, aSrcRect, &rBitmapEx ); @@ -95,13 +97,13 @@ BitmapEx::BitmapEx( const ResId& rResId ) : ResMgr::GetResourceSkipHeader( rResId.SetRT( RSC_BITMAP ), &pResMgr ); pResMgr->ReadLong(); pResMgr->ReadLong(); - + const String aFileName( pResMgr->ReadString() ); ::rtl::OUString aCurrentSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyleName(); - + if( !aImageTree->loadImage( aFileName, aCurrentSymbolsStyle, *this ) ) { -#ifdef DBG_UTIL +#ifdef DBG_UTIL ByteString aErrorStr( "BitmapEx::BitmapEx( const ResId& rResId ): could not load image <" ); DBG_ERROR( ( ( aErrorStr += ByteString( aFileName, RTL_TEXTENCODING_ASCII_US ) ) += '>' ).GetBuffer() ); #endif @@ -127,18 +129,18 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const Bitmap& rMask ) : eTransparent ( !rMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ), bAlpha ( sal_False ) { - if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel()) - { - OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)"); - aMask.Scale(aBitmap.GetSizePixel()); - } - - // #105489# Ensure a mask is exactly one bit deep - if( !!aMask && aMask.GetBitCount() != 1 ) - { - OSL_TRACE("BitmapEx: forced mask to monochrome"); - aMask.ImplMakeMono( 255 ); - } + if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel()) + { + OSL_ENSURE(false, "Mask size differs from Bitmap size, corrected Mask (!)"); + aMask.Scale(aBitmap.GetSizePixel()); + } + + // #105489# Ensure a mask is exactly one bit deep + if( !!aMask && aMask.GetBitCount() != 1 ) + { + OSL_TRACE("BitmapEx: forced mask to monochrome"); + aMask.ImplMakeMono( 255 ); + } } // ------------------------------------------------------------------ @@ -150,17 +152,17 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const AlphaMask& rAlphaMask ) : eTransparent ( !rAlphaMask ? TRANSPARENT_NONE : TRANSPARENT_BITMAP ), bAlpha ( !rAlphaMask ? sal_False : sal_True ) { - if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel()) - { - OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)"); - aMask.Scale(rBmp.GetSizePixel()); - } - - // #i75531# the workaround below can go when - // X11SalGraphics::drawAlphaBitmap()'s render acceleration - // can handle the bitmap depth mismatch directly - if( aBitmap.GetBitCount() < aMask.GetBitCount() ) - aBitmap.Convert( BMP_CONVERSION_24BIT ); + if(!!aBitmap && !!aMask && aBitmap.GetSizePixel() != aMask.GetSizePixel()) + { + OSL_ENSURE(false, "Alpha size differs from Bitmap size, corrected Mask (!)"); + aMask.Scale(rBmp.GetSizePixel()); + } + + // #i75531# the workaround below can go when + // X11SalGraphics::drawAlphaBitmap()'s render acceleration + // can handle the bitmap depth mismatch directly + if( aBitmap.GetBitCount() < aMask.GetBitCount() ) + aBitmap.Convert( BMP_CONVERSION_24BIT ); } // ------------------------------------------------------------------ @@ -174,8 +176,8 @@ BitmapEx::BitmapEx( const Bitmap& rBmp, const Color& rTransparentColor ) : { aMask = aBitmap.CreateMask( aTransparentColor ); - DBG_ASSERT( rBmp.GetSizePixel() == aMask.GetSizePixel(), - "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( rBmp.GetSizePixel() == aMask.GetSizePixel(), + "BitmapEx::BitmapEx(): size mismatch for bitmap and alpha mask." ); } // ------------------------------------------------------------------ @@ -302,7 +304,7 @@ Bitmap BitmapEx::GetBitmap( const Color* pTransReplaceColor ) const BitmapEx BitmapEx::GetColorTransformedBitmapEx( BmpColorMode eColorMode ) const { BitmapEx aRet; - + if( BMP_COLOR_HIGHCONTRAST == eColorMode ) { aRet = *this; @@ -313,14 +315,14 @@ BitmapEx BitmapEx::GetColorTransformedBitmapEx( BmpColorMode eColorMode ) const { aRet = *this; aRet.aBitmap = aRet.aBitmap.GetColorTransformedBitmap( eColorMode ); - + if( !aRet.aMask.IsEmpty() ) { aRet.aMask.CombineSimple( aRet.aBitmap, BMP_COMBINE_OR ); aRet.aBitmap.Erase( ( BMP_COLOR_MONOCHROME_BLACK == eColorMode ) ? COL_BLACK : COL_WHITE ); - DBG_ASSERT( aRet.aBitmap.GetSizePixel() == aRet.aMask.GetSizePixel(), - "BitmapEx::GetColorTransformedBitmapEx(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( aRet.aBitmap.GetSizePixel() == aRet.aMask.GetSizePixel(), + "BitmapEx::GetColorTransformedBitmapEx(): size mismatch for bitmap and alpha mask." ); } } @@ -391,10 +393,10 @@ sal_uLong BitmapEx::GetChecksum() const void BitmapEx::SetSizePixel( const Size& rNewSize, sal_uInt32 nScaleFlag ) { - if(GetSizePixel() != rNewSize) - { - Scale( rNewSize, nScaleFlag ); - } + if(GetSizePixel() != rNewSize) + { + Scale( rNewSize, nScaleFlag ); + } } // ------------------------------------------------------------------ @@ -442,14 +444,14 @@ sal_Bool BitmapEx::Scale( const double& rScaleX, const double& rScaleY, sal_uInt bRet = aBitmap.Scale( rScaleX, rScaleY, nScaleFlag ); if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask ) - { + { aMask.Scale( rScaleX, rScaleY, nScaleFlag ); - } + } aBitmapSize = aBitmap.GetSizePixel(); - DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), - "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), + "BitmapEx::Scale(): size mismatch for bitmap and alpha mask." ); } return bRet; @@ -512,8 +514,8 @@ sal_Bool BitmapEx::Rotate( long nAngle10, const Color& rFillColor ) aBitmapSize = aBitmap.GetSizePixel(); - DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), - "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), + "BitmapEx::Rotate(): size mismatch for bitmap and alpha mask." ); } return bRet; @@ -534,8 +536,8 @@ sal_Bool BitmapEx::Crop( const Rectangle& rRectPixel ) aBitmapSize = aBitmap.GetSizePixel(); - DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), - "BitmapEx::Crop(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), + "BitmapEx::Crop(): size mismatch for bitmap and alpha mask." ); } return bRet; @@ -573,8 +575,8 @@ sal_Bool BitmapEx::Expand( sal_uLong nDX, sal_uLong nDY, const Color* pInitColor aBitmapSize = aBitmap.GetSizePixel(); - DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), - "BitmapEx::Expand(): size mismatch for bitmap and alpha mask." ); + DBG_ASSERT( !aMask || aBitmap.GetSizePixel() == aMask.GetSizePixel(), + "BitmapEx::Expand(): size mismatch for bitmap and alpha mask." ); } return bRet; @@ -608,7 +610,7 @@ sal_Bool BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectS if( pBmpExSrc->IsAlpha() ) { if( IsAlpha() ) - // cast to use the optimized AlphaMask::CopyPixel + // cast to use the optimized AlphaMask::CopyPixel ((AlphaMask*) &aMask)->CopyPixel( rRectDst, rRectSrc, (AlphaMask*)&pBmpExSrc->aMask ); else if( IsTransparent() ) { @@ -648,20 +650,20 @@ sal_Bool BitmapEx::CopyPixel( const Rectangle& rRectDst, const Rectangle& rRectS aMask.CopyPixel( rRectDst, rRectSrc, &pBmpExSrc->aMask ); } } - else if( IsAlpha() ) - { - sal_uInt8 cBlack = 0; - const AlphaMask aAlphaSrc( pBmpExSrc->GetSizePixel(), &cBlack ); - - aMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() ); - } - else if( IsTransparent() ) - { - Bitmap aMaskSrc( pBmpExSrc->GetSizePixel(), 1 ); - - aMaskSrc.Erase( Color( COL_BLACK ) ); - aMask.CopyPixel( rRectDst, rRectSrc, &aMaskSrc ); - } + else if( IsAlpha() ) + { + sal_uInt8 cBlack = 0; + const AlphaMask aAlphaSrc( pBmpExSrc->GetSizePixel(), &cBlack ); + + aMask.CopyPixel( rRectDst, rRectSrc, &aAlphaSrc.ImplGetBitmap() ); + } + else if( IsTransparent() ) + { + Bitmap aMaskSrc( pBmpExSrc->GetSizePixel(), 1 ); + + aMaskSrc.Erase( Color( COL_BLACK ) ); + aMask.CopyPixel( rRectDst, rRectSrc, &aMaskSrc ); + } } } } @@ -681,17 +683,17 @@ sal_Bool BitmapEx::Erase( const Color& rFillColor ) if( bRet && ( eTransparent == TRANSPARENT_BITMAP ) && !!aMask ) { - // #104416# Respect transparency on fill color - if( rFillColor.GetTransparency() ) - { - const Color aFill( rFillColor.GetTransparency(), rFillColor.GetTransparency(), rFillColor.GetTransparency() ); - aMask.Erase( aFill ); - } - else - { - const Color aBlack( COL_BLACK ); - aMask.Erase( aBlack ); - } + // #104416# Respect transparency on fill color + if( rFillColor.GetTransparency() ) + { + const Color aFill( rFillColor.GetTransparency(), rFillColor.GetTransparency(), rFillColor.GetTransparency() ); + aMask.Erase( aFill ); + } + else + { + const Color aBlack( COL_BLACK ); + aMask.Erase( aBlack ); + } } } @@ -765,581 +767,580 @@ void BitmapEx::Draw( OutputDevice* pOutDev, sal_uInt8 BitmapEx::GetTransparency(sal_Int32 nX, sal_Int32 nY) const { - sal_uInt8 nTransparency(0xff); - - if(!aBitmap.IsEmpty()) - { - if(nX >= 0 && nX < aBitmapSize.Width() && nY >= 0 && nY < aBitmapSize.Height()) - { - switch(eTransparent) - { - case TRANSPARENT_NONE: - { - // not transparent, ergo all covered - nTransparency = 0x00; - break; - } - case TRANSPARENT_COLOR: - { - Bitmap aTestBitmap(aBitmap); - BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess(); - - if(pRead) - { - const Color aColor = pRead->GetColor(nY, nX); - - // if color is not equal to TransparentColor, we are not transparent - if(aColor != aTransparentColor) - { - nTransparency = 0x00; - } - - aTestBitmap.ReleaseAccess(pRead); - } - break; - } - case TRANSPARENT_BITMAP: - { - if(!aMask.IsEmpty()) - { - Bitmap aTestBitmap(aMask); - BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess(); - - if(pRead) - { - const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX)); - - if(bAlpha) - { - nTransparency = aBitmapColor.GetIndex(); - } - else - { - if(0x00 == aBitmapColor.GetIndex()) - { - nTransparency = 0x00; - } - } - - aTestBitmap.ReleaseAccess(pRead); - } - } - break; - } - } - } - } - - return nTransparency; + sal_uInt8 nTransparency(0xff); + + if(!aBitmap.IsEmpty()) + { + if(nX >= 0 && nX < aBitmapSize.Width() && nY >= 0 && nY < aBitmapSize.Height()) + { + switch(eTransparent) + { + case TRANSPARENT_NONE: + { + // not transparent, ergo all covered + nTransparency = 0x00; + break; + } + case TRANSPARENT_COLOR: + { + Bitmap aTestBitmap(aBitmap); + BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess(); + + if(pRead) + { + const Color aColor = pRead->GetColor(nY, nX); + + // if color is not equal to TransparentColor, we are not transparent + if(aColor != aTransparentColor) + { + nTransparency = 0x00; + } + + aTestBitmap.ReleaseAccess(pRead); + } + break; + } + case TRANSPARENT_BITMAP: + { + if(!aMask.IsEmpty()) + { + Bitmap aTestBitmap(aMask); + BitmapReadAccess* pRead = aTestBitmap.AcquireReadAccess(); + + if(pRead) + { + const BitmapColor aBitmapColor(pRead->GetPixel(nY, nX)); + + if(bAlpha) + { + nTransparency = aBitmapColor.GetIndex(); + } + else + { + if(0x00 == aBitmapColor.GetIndex()) + { + nTransparency = 0x00; + } + } + + aTestBitmap.ReleaseAccess(pRead); + } + } + break; + } + } + } + } + + return nTransparency; } // ------------------------------------------------------------------ namespace { - Bitmap impTransformBitmap( - const Bitmap& rSource, - const Size aDestinationSize, - const basegfx::B2DHomMatrix& rTransform, - bool bSmooth) - { - Bitmap aDestination(aDestinationSize, 24); - BitmapWriteAccess* pWrite = aDestination.AcquireWriteAccess(); - - if(pWrite) - { - //const Size aContentSizePixel(rSource.GetSizePixel()); - BitmapReadAccess* pRead = (const_cast< Bitmap& >(rSource)).AcquireReadAccess(); - - if(pRead) - { - const Size aDestinationSizePixel(aDestination.GetSizePixel()); - const BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff)); - - for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++) - { - for(sal_Int32 x(0L); x < aDestinationSizePixel.getWidth(); x++) - { - const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y)); - - if(bSmooth) - { - pWrite->SetPixel( - y, - x, - pRead->GetInterpolatedColorWithFallback( - aSourceCoor.getY(), - aSourceCoor.getX(), - aOutside)); - } - else - { - // this version does the correct <= 0.0 checks, so no need - // to do the static_cast< sal_Int32 > self and make an error - pWrite->SetPixel( - y, - x, - pRead->GetColorWithFallback( - aSourceCoor.getY(), - aSourceCoor.getX(), - aOutside)); - } - } - } - - delete pRead; - } - - delete pWrite; - } - - rSource.AdaptBitCount(aDestination); - - return aDestination; - } + Bitmap impTransformBitmap( + const Bitmap& rSource, + const Size aDestinationSize, + const basegfx::B2DHomMatrix& rTransform, + bool bSmooth) + { + Bitmap aDestination(aDestinationSize, 24); + BitmapWriteAccess* pWrite = aDestination.AcquireWriteAccess(); + + if(pWrite) + { + //const Size aContentSizePixel(rSource.GetSizePixel()); + BitmapReadAccess* pRead = (const_cast< Bitmap& >(rSource)).AcquireReadAccess(); + + if(pRead) + { + const Size aDestinationSizePixel(aDestination.GetSizePixel()); + const BitmapColor aOutside(BitmapColor(0xff, 0xff, 0xff)); + + for(sal_Int32 y(0L); y < aDestinationSizePixel.getHeight(); y++) + { + for(sal_Int32 x(0L); x < aDestinationSizePixel.getWidth(); x++) + { + const basegfx::B2DPoint aSourceCoor(rTransform * basegfx::B2DPoint(x, y)); + + if(bSmooth) + { + pWrite->SetPixel( + y, + x, + pRead->GetInterpolatedColorWithFallback( + aSourceCoor.getY(), + aSourceCoor.getX(), + aOutside)); + } + else + { + // this version does the correct <= 0.0 checks, so no need + // to do the static_cast< sal_Int32 > self and make an error + pWrite->SetPixel( + y, + x, + pRead->GetColorWithFallback( + aSourceCoor.getY(), + aSourceCoor.getX(), + aOutside)); + } + } + } + + delete pRead; + } + + delete pWrite; + } + + rSource.AdaptBitCount(aDestination); + + return aDestination; + } } // end of anonymous namespace BitmapEx BitmapEx::TransformBitmapEx( - double fWidth, - double fHeight, - const basegfx::B2DHomMatrix& rTransformation, - bool bSmooth) const + double fWidth, + double fHeight, + const basegfx::B2DHomMatrix& rTransformation, + bool bSmooth) const { - if(fWidth <= 1 || fHeight <= 1) - return BitmapEx(); - - // force destination to 24 bit, we want to smooth output - const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight)); - const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth)); - - // create mask - if(IsTransparent()) - { - if(IsAlpha()) - { - const Bitmap aAlpha(impTransformBitmap(GetAlpha().GetBitmap(), aDestinationSize, rTransformation, bSmooth)); - return BitmapEx(aDestination, AlphaMask(aAlpha)); - } - else - { - const Bitmap aMask(impTransformBitmap(GetMask(), aDestinationSize, rTransformation, false)); - return BitmapEx(aDestination, aMask); - } - } - - return BitmapEx(aDestination); + if(fWidth <= 1 || fHeight <= 1) + return BitmapEx(); + + // force destination to 24 bit, we want to smooth output + const Size aDestinationSize(basegfx::fround(fWidth), basegfx::fround(fHeight)); + const Bitmap aDestination(impTransformBitmap(GetBitmap(), aDestinationSize, rTransformation, bSmooth)); + + // create mask + if(IsTransparent()) + { + if(IsAlpha()) + { + const Bitmap aAlpha(impTransformBitmap(GetAlpha().GetBitmap(), aDestinationSize, rTransformation, bSmooth)); + return BitmapEx(aDestination, AlphaMask(aAlpha)); + } + else + { + const Bitmap aMask(impTransformBitmap(GetMask(), aDestinationSize, rTransformation, false)); + return BitmapEx(aDestination, aMask); + } + } + + return BitmapEx(aDestination); } // ------------------------------------------------------------------ BitmapEx BitmapEx::getTransformed( - const basegfx::B2DHomMatrix& rTransformation, - const basegfx::B2DRange& rVisibleRange, - double fMaximumArea, - bool bSmooth) const + const basegfx::B2DHomMatrix& rTransformation, + const basegfx::B2DRange& rVisibleRange, + double fMaximumArea, + bool bSmooth) const { - BitmapEx aRetval; - - if(IsEmpty()) - return aRetval; - - const sal_uInt32 nSourceWidth(GetSizePixel().Width()); - const sal_uInt32 nSourceHeight(GetSizePixel().Height()); - - if(!nSourceWidth || !nSourceHeight) - return aRetval; - - // Get aOutlineRange - basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0); - - aOutlineRange.transform(rTransformation); - - // create visible range from it by moving from relative to absolute - basegfx::B2DRange aVisibleRange(rVisibleRange); - - aVisibleRange.transform( - basegfx::tools::createScaleTranslateB2DHomMatrix( - aOutlineRange.getRange(), - aOutlineRange.getMinimum())); - - // get target size (which is visible range's size) - double fWidth(aVisibleRange.getWidth()); - double fHeight(aVisibleRange.getHeight()); - - if(fWidth < 1.0 || fHeight < 1.0) - { - return aRetval; - } - - // test if discrete size (pixel) maybe too big and limit it - const double fArea(fWidth * fHeight); - const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea)); - double fReduceFactor(1.0); - - if(bNeedToReduce) - { - fReduceFactor = sqrt(fMaximumArea / fArea); - fWidth *= fReduceFactor; - fHeight *= fReduceFactor; - } - - // Build complete transform from source pixels to target pixels. - // Start by scaling from source pixel size to unit coordinates - basegfx::B2DHomMatrix aTransform( - basegfx::tools::createScaleB2DHomMatrix( - 1.0 / nSourceWidth, - 1.0 / nSourceHeight)); - - // multiply with given transform which leads from unit coordinates inside - // aOutlineRange - aTransform = rTransformation * aTransform; - - // subtract top-left of absolute VisibleRange - aTransform.translate( - -aVisibleRange.getMinX(), - -aVisibleRange.getMinY()); - - // scale to target pixels (if needed) - if(bNeedToReduce) - { - aTransform.scale(fReduceFactor, fReduceFactor); - } - - // invert to get transformation from target pixel coordiates to source pixels - aTransform.invert(); - - // create bitmap using source, destination and linear back-transformation - aRetval = TransformBitmapEx(fWidth, fHeight, aTransform, bSmooth); - - return aRetval; + BitmapEx aRetval; + + if(IsEmpty()) + return aRetval; + + const sal_uInt32 nSourceWidth(GetSizePixel().Width()); + const sal_uInt32 nSourceHeight(GetSizePixel().Height()); + + if(!nSourceWidth || !nSourceHeight) + return aRetval; + + // Get aOutlineRange + basegfx::B2DRange aOutlineRange(0.0, 0.0, 1.0, 1.0); + + aOutlineRange.transform(rTransformation); + + // create visible range from it by moving from relative to absolute + basegfx::B2DRange aVisibleRange(rVisibleRange); + + aVisibleRange.transform( + basegfx::tools::createScaleTranslateB2DHomMatrix( + aOutlineRange.getRange(), + aOutlineRange.getMinimum())); + + // get target size (which is visible range's size) + double fWidth(aVisibleRange.getWidth()); + double fHeight(aVisibleRange.getHeight()); + + if(fWidth < 1.0 || fHeight < 1.0) + { + return aRetval; + } + + // test if discrete size (pixel) maybe too big and limit it + const double fArea(fWidth * fHeight); + const bool bNeedToReduce(basegfx::fTools::more(fArea, fMaximumArea)); + double fReduceFactor(1.0); + + if(bNeedToReduce) + { + fReduceFactor = sqrt(fMaximumArea / fArea); + fWidth *= fReduceFactor; + fHeight *= fReduceFactor; + } + + // Build complete transform from source pixels to target pixels. + // Start by scaling from source pixel size to unit coordinates + basegfx::B2DHomMatrix aTransform( + basegfx::tools::createScaleB2DHomMatrix( + 1.0 / nSourceWidth, + 1.0 / nSourceHeight)); + + // multiply with given transform which leads from unit coordinates inside + // aOutlineRange + aTransform = rTransformation * aTransform; + + // subtract top-left of absolute VisibleRange + aTransform.translate( + -aVisibleRange.getMinX(), + -aVisibleRange.getMinY()); + + // scale to target pixels (if needed) + if(bNeedToReduce) + { + aTransform.scale(fReduceFactor, fReduceFactor); + } + + // invert to get transformation from target pixel coordinates to source pixels + aTransform.invert(); + + // create bitmap using source, destination and linear back-transformation + aRetval = TransformBitmapEx(fWidth, fHeight, aTransform, bSmooth); + + return aRetval; } // ------------------------------------------------------------------ BitmapEx BitmapEx::ModifyBitmapEx(const basegfx::BColorModifierStack& rBColorModifierStack) const { - Bitmap aChangedBitmap(GetBitmap()); - bool bDone(false); - - for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; ) - { - const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a); - const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get()); - - if(pReplace) - { - // complete replace - if(IsTransparent()) - { - // clear bitmap with dest color - if(aChangedBitmap.GetBitCount() <= 8) - { - // do NOT use erase; for e.g. 8bit Bitmaps, the nearest color to the given - // erase color is determined and used -> this may be different from what is - // wanted here. Better create a new bitmap with the needed color explicitly - BitmapReadAccess* pReadAccess = aChangedBitmap.AcquireReadAccess(); - OSL_ENSURE(pReadAccess, "Got no Bitmap ReadAccess ?!?"); - - if(pReadAccess) - { - BitmapPalette aNewPalette(pReadAccess->GetPalette()); - aNewPalette[0] = BitmapColor(Color(pReplace->getBColor())); - aChangedBitmap = Bitmap( - aChangedBitmap.GetSizePixel(), - aChangedBitmap.GetBitCount(), - &aNewPalette); - delete pReadAccess; - } - } - else - { - aChangedBitmap.Erase(Color(pReplace->getBColor())); - } - } - else - { - // erase bitmap, caller will know to paint direct - aChangedBitmap.SetEmpty(); - } - - bDone = true; - } - else - { - BitmapWriteAccess* pContent = aChangedBitmap.AcquireWriteAccess(); - - if(pContent) - { - const double fConvertColor(1.0 / 255.0); - - if(pContent->HasPalette()) - { - const sal_uInt16 nCount(pContent->GetPaletteEntryCount()); - - for(sal_uInt16 a(0); a < nCount; a++) - { - const BitmapColor& rCol = pContent->GetPaletteColor(a); - const basegfx::BColor aBSource( - rCol.GetRed() * fConvertColor, - rCol.GetGreen() * fConvertColor, - rCol.GetBlue() * fConvertColor); - const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); - pContent->SetPaletteColor(a, BitmapColor(Color(aBDest))); - } - } - else if(BMP_FORMAT_24BIT_TC_BGR == pContent->GetScanlineFormat()) - { - for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) - { - Scanline pScan = pContent->GetScanline(y); - - for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) - { - const basegfx::BColor aBSource( - *(pScan + 2)* fConvertColor, - *(pScan + 1) * fConvertColor, - *pScan * fConvertColor); - const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0); - } - } - } - else if(BMP_FORMAT_24BIT_TC_RGB == pContent->GetScanlineFormat()) - { - for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) - { - Scanline pScan = pContent->GetScanline(y); - - for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) - { - const basegfx::BColor aBSource( - *pScan * fConvertColor, - *(pScan + 1) * fConvertColor, - *(pScan + 2) * fConvertColor); - const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0); - *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0); - } - } - } - else - { - for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) - { - for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) - { - const BitmapColor aBMCol(pContent->GetColor(y, x)); - const basegfx::BColor aBSource( - (double)aBMCol.GetRed() * fConvertColor, - (double)aBMCol.GetGreen() * fConvertColor, - (double)aBMCol.GetBlue() * fConvertColor); - const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); - - pContent->SetPixel(y, x, BitmapColor(Color(aBDest))); - } - } - } - - delete pContent; - } - } - } - - if(aChangedBitmap.IsEmpty()) - { - return BitmapEx(); - } - else - { - if(IsTransparent()) - { - if(IsAlpha()) - { - return BitmapEx(aChangedBitmap, GetAlpha()); - } - else - { - return BitmapEx(aChangedBitmap, GetMask()); - } - } - else - { - return BitmapEx(aChangedBitmap); - } - } + Bitmap aChangedBitmap(GetBitmap()); + bool bDone(false); + + for(sal_uInt32 a(rBColorModifierStack.count()); a && !bDone; ) + { + const basegfx::BColorModifierSharedPtr& rModifier = rBColorModifierStack.getBColorModifier(--a); + const basegfx::BColorModifier_replace* pReplace = dynamic_cast< const basegfx::BColorModifier_replace* >(rModifier.get()); + + if(pReplace) + { + // complete replace + if(IsTransparent()) + { + // clear bitmap with dest color + if(aChangedBitmap.GetBitCount() <= 8) + { + // do NOT use erase; for e.g. 8bit Bitmaps, the nearest color to the given + // erase color is determined and used -> this may be different from what is + // wanted here. Better create a new bitmap with the needed color explicitly + BitmapReadAccess* pReadAccess = aChangedBitmap.AcquireReadAccess(); + OSL_ENSURE(pReadAccess, "Got no Bitmap ReadAccess ?!?"); + + if(pReadAccess) + { + BitmapPalette aNewPalette(pReadAccess->GetPalette()); + aNewPalette[0] = BitmapColor(Color(pReplace->getBColor())); + aChangedBitmap = Bitmap( + aChangedBitmap.GetSizePixel(), + aChangedBitmap.GetBitCount(), + &aNewPalette); + delete pReadAccess; + } + } + else + { + aChangedBitmap.Erase(Color(pReplace->getBColor())); + } + } + else + { + // erase bitmap, caller will know to paint direct + aChangedBitmap.SetEmpty(); + } + + bDone = true; + } + else + { + BitmapWriteAccess* pContent = aChangedBitmap.AcquireWriteAccess(); + + if(pContent) + { + const double fConvertColor(1.0 / 255.0); + + if(pContent->HasPalette()) + { + const sal_uInt16 nCount(pContent->GetPaletteEntryCount()); + + for(sal_uInt16 a(0); a < nCount; a++) + { + const BitmapColor& rCol = pContent->GetPaletteColor(a); + const basegfx::BColor aBSource( + rCol.GetRed() * fConvertColor, + rCol.GetGreen() * fConvertColor, + rCol.GetBlue() * fConvertColor); + const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); + pContent->SetPaletteColor(a, BitmapColor(Color(aBDest))); + } + } + else if(BMP_FORMAT_24BIT_TC_BGR == pContent->GetScanlineFormat()) + { + for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) + { + Scanline pScan = pContent->GetScanline(y); + + for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) + { + const basegfx::BColor aBSource( + *(pScan + 2)* fConvertColor, + *(pScan + 1) * fConvertColor, + *pScan * fConvertColor); + const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0); + } + } + } + else if(BMP_FORMAT_24BIT_TC_RGB == pContent->GetScanlineFormat()) + { + for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) + { + Scanline pScan = pContent->GetScanline(y); + + for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) + { + const basegfx::BColor aBSource( + *pScan * fConvertColor, + *(pScan + 1) * fConvertColor, + *(pScan + 2) * fConvertColor); + const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getRed() * 255.0); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getGreen() * 255.0); + *pScan++ = static_cast< sal_uInt8 >(aBDest.getBlue() * 255.0); + } + } + } + else + { + for(sal_uInt32 y(0L); y < (sal_uInt32)pContent->Height(); y++) + { + for(sal_uInt32 x(0L); x < (sal_uInt32)pContent->Width(); x++) + { + const BitmapColor aBMCol(pContent->GetColor(y, x)); + const basegfx::BColor aBSource( + (double)aBMCol.GetRed() * fConvertColor, + (double)aBMCol.GetGreen() * fConvertColor, + (double)aBMCol.GetBlue() * fConvertColor); + const basegfx::BColor aBDest(rModifier->getModifiedColor(aBSource)); + + pContent->SetPixel(y, x, BitmapColor(Color(aBDest))); + } + } + } + + delete pContent; + } + } + } + + if(aChangedBitmap.IsEmpty()) + { + return BitmapEx(); + } + else + { + if(IsTransparent()) + { + if(IsAlpha()) + { + return BitmapEx(aChangedBitmap, GetAlpha()); + } + else + { + return BitmapEx(aChangedBitmap, GetMask()); + } + } + else + { + return BitmapEx(aChangedBitmap); + } + } } // ----------------------------------------------------------------------------- BitmapEx VCL_DLLPUBLIC createBlendFrame( - const Size& rSize, - sal_uInt8 nAlpha, - Color aColorTopLeft, - Color aColorBottomRight) + const Size& rSize, + sal_uInt8 nAlpha, + Color aColorTopLeft, + Color aColorBottomRight) { - const sal_uInt32 nW(rSize.Width()); - const sal_uInt32 nH(rSize.Height()); + const sal_uInt32 nW(rSize.Width()); + const sal_uInt32 nH(rSize.Height()); - if(nW || nH) - { - Color aColTopRight(aColorTopLeft); - Color aColBottomLeft(aColorTopLeft); - const sal_uInt32 nDE(nW + nH); + if(nW || nH) + { + Color aColTopRight(aColorTopLeft); + Color aColBottomLeft(aColorTopLeft); + const sal_uInt32 nDE(nW + nH); - aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE)); - aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE)); + aColTopRight.Merge(aColorBottomRight, 255 - sal_uInt8((nW * 255) / nDE)); + aColBottomLeft.Merge(aColorBottomRight, 255 - sal_uInt8((nH * 255) / nDE)); - return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft); - } + return createBlendFrame(rSize, nAlpha, aColorTopLeft, aColTopRight, aColorBottomRight, aColBottomLeft); + } - return BitmapEx(); + return BitmapEx(); } BitmapEx VCL_DLLPUBLIC createBlendFrame( - const Size& rSize, - sal_uInt8 nAlpha, - Color aColorTopLeft, - Color aColorTopRight, - Color aColorBottomRight, - Color aColorBottomLeft) + const Size& rSize, + sal_uInt8 nAlpha, + Color aColorTopLeft, + Color aColorTopRight, + Color aColorBottomRight, + Color aColorBottomLeft) { - static Size aLastSize(0, 0); - static sal_uInt8 nLastAlpha(0); - static Color aLastColorTopLeft(COL_BLACK); - static Color aLastColorTopRight(COL_BLACK); - static Color aLastColorBottomRight(COL_BLACK); - static Color aLastColorBottomLeft(COL_BLACK); - static BitmapEx aLastResult; - - if(aLastSize == rSize - && nLastAlpha == nAlpha - && aLastColorTopLeft == aColorTopLeft - && aLastColorTopRight == aColorTopRight - && aLastColorBottomRight == aColorBottomRight - && aLastColorBottomLeft == aColorBottomLeft) - { - return aLastResult; - } - - aLastSize = rSize; - nLastAlpha = nAlpha; - aLastColorTopLeft = aColorTopLeft; - aLastColorTopRight = aColorTopRight; - aLastColorBottomRight = aColorBottomRight; - aLastColorBottomLeft = aColorBottomLeft; - aLastResult.Clear(); - - const long nW(rSize.Width()); - const long nH(rSize.Height()); - - if(nW && nH) - { - sal_uInt8 aEraseTrans(0xff); - Bitmap aContent(rSize, 24); - AlphaMask aAlpha(rSize, &aEraseTrans); - - aContent.Erase(COL_BLACK); - - BitmapWriteAccess* pContent = aContent.AcquireWriteAccess(); - BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess(); - - if(pContent && pAlpha) - { - long x(0); - long y(0); - - // x == 0, y == 0, top-left corner - pContent->SetPixel(0, 0, aColorTopLeft); - pAlpha->SetPixelIndex(0, 0, nAlpha); - - // y == 0, top line left to right - for(x = 1; x < nW - 1; x++) - { - Color aMix(aColorTopLeft); - - aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW)); - pContent->SetPixel(0, x, aMix); - pAlpha->SetPixelIndex(0, x, nAlpha); - } - - // x == nW - 1, y == 0, top-right corner - // #123690# Caution! When nW is 1, x == nW is possible (!) - if(x < nW) - { - pContent->SetPixel(0, x, aColorTopRight); - pAlpha->SetPixelIndex(0, x, nAlpha); - } - - // x == 0 and nW - 1, left and right line top-down - for(y = 1; y < nH - 1; y++) - { - Color aMixA(aColorTopLeft); - - aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH)); - pContent->SetPixel(y, 0, aMixA); - pAlpha->SetPixelIndex(y, 0, nAlpha); - - // #123690# Caution! When nW is 1, x == nW is possible (!) - if(x < nW) - { - Color aMixB(aColorTopRight); - - aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH)); - pContent->SetPixel(y, x, aMixB); - pAlpha->SetPixelIndex(y, x, nAlpha); - } - } - - // #123690# Caution! When nH is 1, y == nH is possible (!) - if(y < nH) - { - // x == 0, y == nH - 1, bottom-left corner - pContent->SetPixel(y, 0, aColorBottomLeft); - pAlpha->SetPixelIndex(y, 0, nAlpha); - - // y == nH - 1, bottom line left to right - for(x = 1; x < nW - 1; x++) - { - Color aMix(aColorBottomLeft); - - aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW)); - pContent->SetPixel(y, x, aMix); - pAlpha->SetPixelIndex(y, x, nAlpha); - } - - // x == nW - 1, y == nH - 1, bottom-right corner - // #123690# Caution! When nW is 1, x == nW is possible (!) - if(x < nW) - { - pContent->SetPixel(y, x, aColorBottomRight); - pAlpha->SetPixelIndex(y, x, nAlpha); - } - } - - aContent.ReleaseAccess(pContent); - aAlpha.ReleaseAccess(pAlpha); - - aLastResult = BitmapEx(aContent, aAlpha); - } - else - { - if(pContent) - { - aContent.ReleaseAccess(pContent); - } - - if(pAlpha) - { - aAlpha.ReleaseAccess(pAlpha); - } - } - } - - return aLastResult; + static Size aLastSize(0, 0); + static sal_uInt8 nLastAlpha(0); + static Color aLastColorTopLeft(COL_BLACK); + static Color aLastColorTopRight(COL_BLACK); + static Color aLastColorBottomRight(COL_BLACK); + static Color aLastColorBottomLeft(COL_BLACK); + static BitmapEx aLastResult; + + if(aLastSize == rSize + && nLastAlpha == nAlpha + && aLastColorTopLeft == aColorTopLeft + && aLastColorTopRight == aColorTopRight + && aLastColorBottomRight == aColorBottomRight + && aLastColorBottomLeft == aColorBottomLeft) + { + return aLastResult; + } + + aLastSize = rSize; + nLastAlpha = nAlpha; + aLastColorTopLeft = aColorTopLeft; + aLastColorTopRight = aColorTopRight; + aLastColorBottomRight = aColorBottomRight; + aLastColorBottomLeft = aColorBottomLeft; + aLastResult.Clear(); + + const long nW(rSize.Width()); + const long nH(rSize.Height()); + + if(nW && nH) + { + sal_uInt8 aEraseTrans(0xff); + Bitmap aContent(rSize, 24); + AlphaMask aAlpha(rSize, &aEraseTrans); + + aContent.Erase(COL_BLACK); + + BitmapWriteAccess* pContent = aContent.AcquireWriteAccess(); + BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess(); + + if(pContent && pAlpha) + { + long x(0); + long y(0); + + // x == 0, y == 0, top-left corner + pContent->SetPixel(0, 0, aColorTopLeft); + pAlpha->SetPixelIndex(0, 0, nAlpha); + + // y == 0, top line left to right + for(x = 1; x < nW - 1; x++) + { + Color aMix(aColorTopLeft); + + aMix.Merge(aColorTopRight, 255 - sal_uInt8((x * 255) / nW)); + pContent->SetPixel(0, x, aMix); + pAlpha->SetPixelIndex(0, x, nAlpha); + } + + // x == nW - 1, y == 0, top-right corner + // #123690# Caution! When nW is 1, x == nW is possible (!) + if(x < nW) + { + pContent->SetPixel(0, x, aColorTopRight); + pAlpha->SetPixelIndex(0, x, nAlpha); + } + + // x == 0 and nW - 1, left and right line top-down + for(y = 1; y < nH - 1; y++) + { + Color aMixA(aColorTopLeft); + + aMixA.Merge(aColorBottomLeft, 255 - sal_uInt8((y * 255) / nH)); + pContent->SetPixel(y, 0, aMixA); + pAlpha->SetPixelIndex(y, 0, nAlpha); + + // #123690# Caution! When nW is 1, x == nW is possible (!) + if(x < nW) + { + Color aMixB(aColorTopRight); + + aMixB.Merge(aColorBottomRight, 255 - sal_uInt8((y * 255) / nH)); + pContent->SetPixel(y, x, aMixB); + pAlpha->SetPixelIndex(y, x, nAlpha); + } + } + + // #123690# Caution! When nH is 1, y == nH is possible (!) + if(y < nH) + { + // x == 0, y == nH - 1, bottom-left corner + pContent->SetPixel(y, 0, aColorBottomLeft); + pAlpha->SetPixelIndex(y, 0, nAlpha); + + // y == nH - 1, bottom line left to right + for(x = 1; x < nW - 1; x++) + { + Color aMix(aColorBottomLeft); + + aMix.Merge(aColorBottomRight, 255 - sal_uInt8(((x - 0)* 255) / nW)); + pContent->SetPixel(y, x, aMix); + pAlpha->SetPixelIndex(y, x, nAlpha); + } + + // x == nW - 1, y == nH - 1, bottom-right corner + // #123690# Caution! When nW is 1, x == nW is possible (!) + if(x < nW) + { + pContent->SetPixel(y, x, aColorBottomRight); + pAlpha->SetPixelIndex(y, x, nAlpha); + } + } + + aContent.ReleaseAccess(pContent); + aAlpha.ReleaseAccess(pAlpha); + + aLastResult = BitmapEx(aContent, aAlpha); + } + else + { + if(pContent) + { + aContent.ReleaseAccess(pContent); + } + + if(pAlpha) + { + aAlpha.ReleaseAccess(pAlpha); + } + } + } + + return aLastResult; } -// ------------------------------------------------------------------ -// eof +/* vim: set noet sw=4 ts=4: */