1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include "svpbmp.hxx" 25 26 #include <basegfx/vector/b2ivector.hxx> 27 #include <basegfx/range/b2irange.hxx> 28 #include <basebmp/scanlineformats.hxx> 29 #include <basebmp/color.hxx> 30 31 #include <vcl/salbtype.hxx> 32 #include <vcl/bitmap.hxx> 33 34 using namespace basebmp; 35 using namespace basegfx; 36 37 SvpSalBitmap::~SvpSalBitmap() 38 { 39 } 40 41 bool SvpSalBitmap::Create( const Size& rSize, 42 sal_uInt16 nBitCount, 43 const BitmapPalette& rPalette ) 44 { 45 sal_uInt32 nFormat = SVP_DEFAULT_BITMAP_FORMAT; 46 switch( nBitCount ) 47 { 48 case 1: nFormat = Format::ONE_BIT_MSB_PAL; break; 49 case 4: nFormat = Format::FOUR_BIT_MSB_PAL; break; 50 case 8: nFormat = Format::EIGHT_BIT_PAL; break; 51 #ifdef OSL_BIGENDIAN 52 case 16: nFormat = Format::SIXTEEN_BIT_MSB_TC_MASK; break; 53 #else 54 case 16: nFormat = Format::SIXTEEN_BIT_LSB_TC_MASK; break; 55 #endif 56 case 24: nFormat = Format::TWENTYFOUR_BIT_TC_MASK; break; 57 case 32: nFormat = Format::THIRTYTWO_BIT_TC_MASK; break; 58 } 59 B2IVector aSize( rSize.Width(), rSize.Height() ); 60 if( aSize.getX() == 0 ) 61 aSize.setX( 1 ); 62 if( aSize.getY() == 0 ) 63 aSize.setY( 1 ); 64 if( nBitCount > 8 ) 65 m_aBitmap = createBitmapDevice( aSize, false, nFormat ); 66 else 67 { 68 // prepare palette 69 unsigned int nEntries = 1U << nBitCount; 70 std::vector<basebmp::Color>* pPalette = 71 new std::vector<basebmp::Color>( nEntries, basebmp::Color(COL_WHITE) ); 72 unsigned int nColors = rPalette.GetEntryCount(); 73 for( unsigned int i = 0; i < nColors; i++ ) 74 { 75 const BitmapColor& rCol = rPalette[i]; 76 (*pPalette)[i] = basebmp::Color( rCol.GetRed(), rCol.GetGreen(), rCol.GetBlue() ); 77 } 78 m_aBitmap = createBitmapDevice( aSize, false, nFormat, 79 basebmp::RawMemorySharedArray(), 80 basebmp::PaletteMemorySharedVector( pPalette ) 81 ); 82 } 83 return true; 84 } 85 86 bool SvpSalBitmap::Create( const SalBitmap& rSalBmp ) 87 { 88 const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBmp); 89 const BitmapDeviceSharedPtr& rSrcBmp = rSrc.getBitmap(); 90 if( rSrcBmp.get() ) 91 { 92 B2IVector aSize = rSrcBmp->getSize(); 93 m_aBitmap = cloneBitmapDevice( aSize, rSrcBmp ); 94 B2IRange aRect( 0, 0, aSize.getX(), aSize.getY() ); 95 m_aBitmap->drawBitmap( rSrcBmp, aRect, aRect, DrawMode_PAINT ); 96 } 97 else 98 m_aBitmap.reset(); 99 100 return true; 101 } 102 103 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/, 104 SalGraphics* /*pGraphics*/ ) 105 { 106 return false; 107 } 108 109 bool SvpSalBitmap::Create( const SalBitmap& /*rSalBmp*/, 110 sal_uInt16 /*nNewBitCount*/ ) 111 { 112 return false; 113 } 114 115 void SvpSalBitmap::Destroy() 116 { 117 m_aBitmap.reset(); 118 } 119 120 Size SvpSalBitmap::GetSize() const 121 { 122 Size aSize; 123 if( m_aBitmap.get() ) 124 { 125 B2IVector aVec( m_aBitmap->getSize() ); 126 aSize = Size( aVec.getX(), aVec.getY() ); 127 } 128 129 return aSize; 130 } 131 132 sal_uInt16 SvpSalBitmap::GetBitCount() const 133 { 134 sal_uInt16 nDepth = 0; 135 if( m_aBitmap.get() ) 136 nDepth = getBitCountFromScanlineFormat( m_aBitmap->getScanlineFormat() ); 137 return nDepth; 138 } 139 140 BitmapBuffer* SvpSalBitmap::AcquireBuffer( bool ) 141 { 142 BitmapBuffer* pBuf = NULL; 143 if( m_aBitmap.get() ) 144 { 145 pBuf = new BitmapBuffer(); 146 sal_uInt16 nBitCount = 1; 147 switch( m_aBitmap->getScanlineFormat() ) 148 { 149 case Format::ONE_BIT_MSB_GREY: 150 case Format::ONE_BIT_MSB_PAL: 151 nBitCount = 1; 152 pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL; 153 break; 154 case Format::ONE_BIT_LSB_GREY: 155 case Format::ONE_BIT_LSB_PAL: 156 nBitCount = 1; 157 pBuf->mnFormat = BMP_FORMAT_1BIT_LSB_PAL; 158 break; 159 case Format::FOUR_BIT_MSB_GREY: 160 case Format::FOUR_BIT_MSB_PAL: 161 nBitCount = 4; 162 pBuf->mnFormat = BMP_FORMAT_4BIT_MSN_PAL; 163 break; 164 case Format::FOUR_BIT_LSB_GREY: 165 case Format::FOUR_BIT_LSB_PAL: 166 nBitCount = 4; 167 pBuf->mnFormat = BMP_FORMAT_4BIT_LSN_PAL; 168 break; 169 case Format::EIGHT_BIT_PAL: 170 nBitCount = 8; 171 pBuf->mnFormat = BMP_FORMAT_8BIT_PAL; 172 break; 173 case Format::EIGHT_BIT_GREY: 174 nBitCount = 8; 175 pBuf->mnFormat = BMP_FORMAT_8BIT_PAL; 176 break; 177 case Format::SIXTEEN_BIT_LSB_TC_MASK: 178 nBitCount = 16; 179 pBuf->mnFormat = BMP_FORMAT_16BIT_TC_LSB_MASK; 180 pBuf->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f ); 181 break; 182 case Format::SIXTEEN_BIT_MSB_TC_MASK: 183 nBitCount = 16; 184 pBuf->mnFormat = BMP_FORMAT_16BIT_TC_MSB_MASK; 185 pBuf->maColorMask = ColorMask( 0xf800, 0x07e0, 0x001f ); 186 break; 187 case Format::TWENTYFOUR_BIT_TC_MASK: 188 nBitCount = 24; 189 pBuf->mnFormat = BMP_FORMAT_24BIT_TC_BGR; 190 break; 191 case Format::THIRTYTWO_BIT_TC_MASK: 192 nBitCount = 32; 193 pBuf->mnFormat = BMP_FORMAT_32BIT_TC_MASK; 194 #ifdef OSL_BIGENDIAN 195 pBuf->maColorMask = ColorMask( 0x0000ff, 0x00ff00, 0xff0000 ); 196 #else 197 pBuf->maColorMask = ColorMask( 0xff0000, 0x00ff00, 0x0000ff ); 198 #endif 199 break; 200 201 default: 202 // this is an error case !!!!! 203 nBitCount = 1; 204 pBuf->mnFormat = BMP_FORMAT_1BIT_MSB_PAL; 205 break; 206 } 207 if( m_aBitmap->isTopDown() ) 208 pBuf->mnFormat |= BMP_FORMAT_TOP_DOWN; 209 210 B2IVector aSize = m_aBitmap->getSize(); 211 pBuf->mnWidth = aSize.getX(); 212 pBuf->mnHeight = aSize.getY(); 213 pBuf->mnScanlineSize = m_aBitmap->getScanlineStride(); 214 pBuf->mnBitCount = nBitCount; 215 pBuf->mpBits = (sal_uInt8*)m_aBitmap->getBuffer().get(); 216 if( nBitCount <= 8 ) 217 { 218 if( m_aBitmap->getScanlineFormat() == Format::EIGHT_BIT_GREY || 219 m_aBitmap->getScanlineFormat() == Format::FOUR_BIT_LSB_GREY || 220 m_aBitmap->getScanlineFormat() == Format::FOUR_BIT_MSB_GREY || 221 m_aBitmap->getScanlineFormat() == Format::ONE_BIT_LSB_GREY || 222 m_aBitmap->getScanlineFormat() == Format::ONE_BIT_MSB_GREY 223 ) 224 pBuf->maPalette = Bitmap::GetGreyPalette( 1U << nBitCount ); 225 else 226 { 227 basebmp::PaletteMemorySharedVector aPalette = m_aBitmap->getPalette(); 228 if( aPalette.get() ) 229 { 230 unsigned int nColors = aPalette->size(); 231 if( nColors > 0 ) 232 { 233 pBuf->maPalette.SetEntryCount( nColors ); 234 for( unsigned int i = 0; i < nColors; i++ ) 235 { 236 const basebmp::Color& rCol = (*aPalette)[i]; 237 pBuf->maPalette[i] = BitmapColor( rCol.getRed(), rCol.getGreen(), rCol.getBlue() ); 238 } 239 } 240 } 241 } 242 } 243 } 244 245 return pBuf; 246 } 247 248 void SvpSalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, bool bReadOnly ) 249 { 250 if( !bReadOnly && pBuffer->maPalette.GetEntryCount() ) 251 { 252 // palette might have changed, clone device (but recycle 253 // memory) 254 sal_uInt16 nBitCount = 0; 255 switch( m_aBitmap->getScanlineFormat() ) 256 { 257 case Format::ONE_BIT_MSB_GREY: 258 // FALLTHROUGH intended 259 case Format::ONE_BIT_MSB_PAL: 260 // FALLTHROUGH intended 261 case Format::ONE_BIT_LSB_GREY: 262 // FALLTHROUGH intended 263 case Format::ONE_BIT_LSB_PAL: 264 nBitCount = 1; 265 break; 266 267 case Format::FOUR_BIT_MSB_GREY: 268 // FALLTHROUGH intended 269 case Format::FOUR_BIT_MSB_PAL: 270 // FALLTHROUGH intended 271 case Format::FOUR_BIT_LSB_GREY: 272 // FALLTHROUGH intended 273 case Format::FOUR_BIT_LSB_PAL: 274 nBitCount = 4; 275 break; 276 277 case Format::EIGHT_BIT_PAL: 278 // FALLTHROUGH intended 279 case Format::EIGHT_BIT_GREY: 280 nBitCount = 8; 281 break; 282 283 default: 284 break; 285 } 286 287 if( nBitCount ) 288 { 289 sal_uInt32 nEntries = 1U << nBitCount; 290 291 boost::shared_ptr< std::vector<basebmp::Color> > pPal( 292 new std::vector<basebmp::Color>( nEntries, 293 basebmp::Color(COL_WHITE))); 294 const sal_uInt32 nColors = std::min( 295 (sal_uInt32)pBuffer->maPalette.GetEntryCount(), 296 nEntries); 297 for( sal_uInt32 i = 0; i < nColors; i++ ) 298 { 299 const BitmapColor& rCol = pBuffer->maPalette[i]; 300 (*pPal)[i] = basebmp::Color( rCol.GetRed(), rCol.GetGreen(), rCol.GetBlue() ); 301 } 302 303 m_aBitmap = basebmp::createBitmapDevice( m_aBitmap->getSize(), 304 m_aBitmap->isTopDown(), 305 m_aBitmap->getScanlineFormat(), 306 m_aBitmap->getBuffer(), 307 pPal ); 308 } 309 } 310 311 delete pBuffer; 312 } 313 314 bool SvpSalBitmap::GetSystemData( BitmapSystemData& ) 315 { 316 return false; 317 } 318 319 320