xref: /aoo42x/main/vcl/source/helper/canvasbitmap.cxx (revision 37ab0f2d)
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 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26 
27 #include <com/sun/star/util/Endianness.hpp>
28 #include <com/sun/star/rendering/ColorComponentTag.hpp>
29 #include <com/sun/star/rendering/ColorSpaceType.hpp>
30 #include <com/sun/star/rendering/RenderingIntent.hpp>
31 
32 #include <rtl/instance.hxx>
33 #include <vos/mutex.hxx>
34 
35 #include <tools/diagnose_ex.h>
36 #include <canvasbitmap.hxx>
37 #include <vcl/canvastools.hxx>
38 #include <vcl/bmpacc.hxx>
39 #include <vcl/svapp.hxx>
40 
41 #include <algorithm>
42 
43 
44 using namespace ::vcl::unotools;
45 using namespace ::com::sun::star;
46 
47 namespace
48 {
49     // TODO(Q3): move to o3tl bithacks or somesuch. A similar method is in canvas/canvastools.hxx
50 
51     // Good ole HAKMEM tradition. Calc number of 1 bits in 32bit word,
52     // unrolled loop. See e.g. Hackers Delight, p. 66
bitcount(sal_uInt32 val)53     inline sal_Int32 bitcount( sal_uInt32 val )
54     {
55         val = val - ((val >> 1) & 0x55555555);
56         val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
57         val = (val + (val >> 4)) & 0x0F0F0F0F;
58         val = val + (val >> 8);
59         val = val + (val >> 16);
60         return sal_Int32(val & 0x0000003F);
61     }
62 }
63 
setComponentInfo(sal_uLong redShift,sal_uLong greenShift,sal_uLong blueShift)64 void VclCanvasBitmap::setComponentInfo( sal_uLong redShift, sal_uLong greenShift, sal_uLong blueShift )
65 {
66     // sort channels in increasing order of appearance in the pixel
67     // (starting with the least significant bits)
68     sal_Int8 redPos(0);
69     sal_Int8 greenPos(1);
70     sal_Int8 bluePos(2);
71 
72     if( redShift > greenShift )
73     {
74         std::swap(redPos,greenPos);
75         if( redShift > blueShift )
76         {
77             std::swap(redPos,bluePos);
78             if( greenShift > blueShift )
79                 std::swap(greenPos,bluePos);
80         }
81     }
82     else
83     {
84         if( greenShift > blueShift )
85         {
86             std::swap(greenPos,bluePos);
87             if( redShift > blueShift )
88                 std::swap(redPos,bluePos);
89         }
90     }
91 
92     m_aComponentTags.realloc(3);
93     sal_Int8* pTags = m_aComponentTags.getArray();
94     pTags[redPos]   = rendering::ColorComponentTag::RGB_RED;
95     pTags[greenPos] = rendering::ColorComponentTag::RGB_GREEN;
96     pTags[bluePos]  = rendering::ColorComponentTag::RGB_BLUE;
97 
98     m_aComponentBitCounts.realloc(3);
99     sal_Int32* pCounts = m_aComponentBitCounts.getArray();
100     pCounts[redPos]    = bitcount(sal::static_int_cast<sal_uInt32>(redShift));
101     pCounts[greenPos]  = bitcount(sal::static_int_cast<sal_uInt32>(greenShift));
102     pCounts[bluePos]   = bitcount(sal::static_int_cast<sal_uInt32>(blueShift));
103 }
104 
VclCanvasBitmap(const BitmapEx & rBitmap)105 VclCanvasBitmap::VclCanvasBitmap( const BitmapEx& rBitmap ) :
106     m_aBmpEx( rBitmap ),
107     m_aBitmap( rBitmap.GetBitmap() ),
108     m_aAlpha(),
109     m_pBmpAcc( m_aBitmap.AcquireReadAccess() ),
110     m_pAlphaAcc( NULL ),
111     m_aComponentTags(),
112     m_aComponentBitCounts(),
113     m_aLayout(),
114     m_nBitsPerInputPixel(0),
115     m_nBitsPerOutputPixel(0),
116     m_nRedIndex(-1),
117     m_nGreenIndex(-1),
118     m_nBlueIndex(-1),
119     m_nAlphaIndex(-1),
120     m_nIndexIndex(-1),
121     m_nEndianness(0),
122     m_bSwap(false),
123     m_bPalette(false)
124 {
125     if( m_aBmpEx.IsTransparent() )
126     {
127         m_aAlpha = m_aBmpEx.IsAlpha() ? m_aBmpEx.GetAlpha().GetBitmap() : m_aBmpEx.GetMask();
128         m_pAlphaAcc = m_aAlpha.AcquireReadAccess();
129     }
130 
131     m_aLayout.ScanLines      = 0;
132     m_aLayout.ScanLineBytes  = 0;
133     m_aLayout.ScanLineStride = 0;
134     m_aLayout.PlaneStride    = 0;
135     m_aLayout.ColorSpace.clear();
136     m_aLayout.Palette.clear();
137     m_aLayout.IsMsbFirst     = sal_False;
138 
139     if( m_pBmpAcc )
140     {
141         m_aLayout.ScanLines      = m_pBmpAcc->Height();
142         m_aLayout.ScanLineBytes  = (m_pBmpAcc->GetBitCount()*m_pBmpAcc->Width() + 7) / 8;
143         m_aLayout.ScanLineStride = m_pBmpAcc->GetScanlineSize();
144         m_aLayout.PlaneStride    = 0;
145 
146         switch( m_pBmpAcc->GetScanlineFormat() )
147         {
148             case BMP_FORMAT_1BIT_MSB_PAL:
149                 m_bPalette           = true;
150                 m_nBitsPerInputPixel = 1;
151                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
152                 m_aLayout.IsMsbFirst = sal_True;
153                 break;
154 
155             case BMP_FORMAT_1BIT_LSB_PAL:
156                 m_bPalette           = true;
157                 m_nBitsPerInputPixel = 1;
158                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
159                 m_aLayout.IsMsbFirst = sal_False;
160                 break;
161 
162             case BMP_FORMAT_4BIT_MSN_PAL:
163                 m_bPalette           = true;
164                 m_nBitsPerInputPixel = 4;
165                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
166                 m_aLayout.IsMsbFirst = sal_True;
167                 break;
168 
169             case BMP_FORMAT_4BIT_LSN_PAL:
170                 m_bPalette           = true;
171                 m_nBitsPerInputPixel = 4;
172                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
173                 m_aLayout.IsMsbFirst = sal_False;
174                 break;
175 
176             case BMP_FORMAT_8BIT_PAL:
177                 m_bPalette           = true;
178                 m_nBitsPerInputPixel = 8;
179                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
180                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
181                 break;
182 
183             case BMP_FORMAT_8BIT_TC_MASK:
184                 m_bPalette           = false;
185                 m_nBitsPerInputPixel = 8;
186                 m_nEndianness        = util::Endianness::LITTLE; // doesn't matter
187                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
188                 setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
189                                   m_pBmpAcc->GetColorMask().GetGreenMask(),
190                                   m_pBmpAcc->GetColorMask().GetBlueMask() );
191                 break;
192 
193             case BMP_FORMAT_16BIT_TC_MSB_MASK:
194                 m_bPalette           = false;
195                 m_nBitsPerInputPixel = 16;
196                 m_nEndianness        = util::Endianness::BIG;
197                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
198                 setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
199                                   m_pBmpAcc->GetColorMask().GetGreenMask(),
200                                   m_pBmpAcc->GetColorMask().GetBlueMask() );
201                 break;
202 
203             case BMP_FORMAT_16BIT_TC_LSB_MASK:
204                 m_bPalette           = false;
205                 m_nBitsPerInputPixel = 16;
206                 m_nEndianness        = util::Endianness::LITTLE;
207                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
208                 setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
209                                   m_pBmpAcc->GetColorMask().GetGreenMask(),
210                                   m_pBmpAcc->GetColorMask().GetBlueMask() );
211                 break;
212 
213             case BMP_FORMAT_24BIT_TC_BGR:
214                 m_bPalette           = false;
215                 m_nBitsPerInputPixel = 24;
216                 m_nEndianness        = util::Endianness::LITTLE;
217                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
218                 setComponentInfo( 0xff0000LL,
219                                   0x00ff00LL,
220                                   0x0000ffLL );
221                 break;
222 
223             case BMP_FORMAT_24BIT_TC_RGB:
224                 m_bPalette           = false;
225                 m_nBitsPerInputPixel = 24;
226                 m_nEndianness        = util::Endianness::LITTLE;
227                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
228                 setComponentInfo( 0x0000ffLL,
229                                   0x00ff00LL,
230                                   0xff0000LL );
231                 break;
232 
233             case BMP_FORMAT_24BIT_TC_MASK:
234                 m_bPalette           = false;
235                 m_nBitsPerInputPixel = 24;
236                 m_nEndianness        = util::Endianness::LITTLE;
237                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
238                 setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
239                                   m_pBmpAcc->GetColorMask().GetGreenMask(),
240                                   m_pBmpAcc->GetColorMask().GetBlueMask() );
241                 break;
242 
243             case BMP_FORMAT_32BIT_TC_ABGR:
244             {
245                 m_bPalette           = false;
246                 m_nBitsPerInputPixel = 32;
247                 m_nEndianness        = util::Endianness::LITTLE;
248                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
249 
250                 m_aComponentTags.realloc(4);
251                 sal_Int8* pTags = m_aComponentTags.getArray();
252                 pTags[0]        = rendering::ColorComponentTag::ALPHA;
253                 pTags[1]        = rendering::ColorComponentTag::RGB_BLUE;
254                 pTags[2]        = rendering::ColorComponentTag::RGB_GREEN;
255                 pTags[3]        = rendering::ColorComponentTag::RGB_RED;
256 
257                 m_aComponentBitCounts.realloc(4);
258                 sal_Int32* pCounts = m_aComponentBitCounts.getArray();
259                 pCounts[0]         = 8;
260                 pCounts[1]         = 8;
261                 pCounts[2]         = 8;
262                 pCounts[3]         = 8;
263 
264                 m_nRedIndex   = 3;
265                 m_nGreenIndex = 2;
266                 m_nBlueIndex  = 1;
267                 m_nAlphaIndex = 0;
268             }
269             break;
270 
271             case BMP_FORMAT_32BIT_TC_ARGB:
272             {
273                 m_bPalette           = false;
274                 m_nBitsPerInputPixel = 32;
275                 m_nEndianness        = util::Endianness::LITTLE;
276                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
277 
278                 m_aComponentTags.realloc(4);
279                 sal_Int8* pTags = m_aComponentTags.getArray();
280                 pTags[0]        = rendering::ColorComponentTag::ALPHA;
281                 pTags[1]        = rendering::ColorComponentTag::RGB_RED;
282                 pTags[2]        = rendering::ColorComponentTag::RGB_GREEN;
283                 pTags[3]        = rendering::ColorComponentTag::RGB_BLUE;
284 
285                 m_aComponentBitCounts.realloc(4);
286                 sal_Int32* pCounts = m_aComponentBitCounts.getArray();
287                 pCounts[0]         = 8;
288                 pCounts[1]         = 8;
289                 pCounts[2]         = 8;
290                 pCounts[3]         = 8;
291 
292                 m_nRedIndex   = 1;
293                 m_nGreenIndex = 2;
294                 m_nBlueIndex  = 3;
295                 m_nAlphaIndex = 0;
296             }
297             break;
298 
299             case BMP_FORMAT_32BIT_TC_BGRA:
300             {
301                 m_bPalette           = false;
302                 m_nBitsPerInputPixel = 32;
303                 m_nEndianness        = util::Endianness::LITTLE;
304                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
305 
306                 m_aComponentTags.realloc(4);
307                 sal_Int8* pTags = m_aComponentTags.getArray();
308                 pTags[0]        = rendering::ColorComponentTag::RGB_BLUE;
309                 pTags[1]        = rendering::ColorComponentTag::RGB_GREEN;
310                 pTags[2]        = rendering::ColorComponentTag::RGB_RED;
311                 pTags[3]        = rendering::ColorComponentTag::ALPHA;
312 
313                 m_aComponentBitCounts.realloc(4);
314                 sal_Int32* pCounts = m_aComponentBitCounts.getArray();
315                 pCounts[0]         = 8;
316                 pCounts[1]         = 8;
317                 pCounts[2]         = 8;
318                 pCounts[3]         = 8;
319 
320                 m_nRedIndex   = 2;
321                 m_nGreenIndex = 1;
322                 m_nBlueIndex  = 0;
323                 m_nAlphaIndex = 3;
324             }
325             break;
326 
327             case BMP_FORMAT_32BIT_TC_RGBA:
328             {
329                 m_bPalette           = false;
330                 m_nBitsPerInputPixel = 32;
331                 m_nEndianness        = util::Endianness::LITTLE;
332                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
333 
334                 m_aComponentTags.realloc(4);
335                 sal_Int8* pTags = m_aComponentTags.getArray();
336                 pTags[0]        = rendering::ColorComponentTag::RGB_RED;
337                 pTags[1]        = rendering::ColorComponentTag::RGB_GREEN;
338                 pTags[2]        = rendering::ColorComponentTag::RGB_BLUE;
339                 pTags[3]        = rendering::ColorComponentTag::ALPHA;
340 
341                 m_aComponentBitCounts.realloc(4);
342                 sal_Int32* pCounts = m_aComponentBitCounts.getArray();
343                 pCounts[0]         = 8;
344                 pCounts[1]         = 8;
345                 pCounts[2]         = 8;
346                 pCounts[3]         = 8;
347 
348                 m_nRedIndex   = 0;
349                 m_nGreenIndex = 1;
350                 m_nBlueIndex  = 2;
351                 m_nAlphaIndex = 3;
352             }
353             break;
354 
355             case BMP_FORMAT_32BIT_TC_MASK:
356                 m_bPalette           = false;
357                 m_nBitsPerInputPixel = 32;
358                 m_nEndianness        = util::Endianness::LITTLE;
359                 m_aLayout.IsMsbFirst = sal_False; // doesn't matter
360                 setComponentInfo( m_pBmpAcc->GetColorMask().GetRedMask(),
361                                   m_pBmpAcc->GetColorMask().GetGreenMask(),
362                                   m_pBmpAcc->GetColorMask().GetBlueMask() );
363                 break;
364 
365             default:
366                 DBG_ERROR( "unsupported bitmap format" );
367                 break;
368         }
369 
370         if( m_bPalette )
371         {
372             m_aComponentTags.realloc(1);
373             m_aComponentTags[0] = rendering::ColorComponentTag::INDEX;
374 
375             m_aComponentBitCounts.realloc(1);
376             m_aComponentBitCounts[0] = m_nBitsPerInputPixel;
377 
378             m_nIndexIndex = 0;
379         }
380 
381         m_nBitsPerOutputPixel = m_nBitsPerInputPixel;
382         if( m_aBmpEx.IsTransparent() )
383         {
384             // TODO(P1): need to interleave alpha with bitmap data -
385             // won't fuss with less-than-8 bit for now
386             m_nBitsPerOutputPixel = std::max(sal_Int32(8),m_nBitsPerInputPixel);
387 
388             // check whether alpha goes in front or behind the
389             // bitcount sequence. If pixel format is little endian,
390             // put it behind all the other channels. If it's big
391             // endian, put it in front (because later, the actual data
392             // always gets written after the pixel data)
393 
394             // TODO(Q1): slight catch - in the case of the
395             // BMP_FORMAT_32BIT_XX_ARGB formats, duplicate alpha
396             // channels might happen!
397             m_aComponentTags.realloc(m_aComponentTags.getLength()+1);
398             m_aComponentTags[m_aComponentTags.getLength()-1] = rendering::ColorComponentTag::ALPHA;
399 
400             m_aComponentBitCounts.realloc(m_aComponentBitCounts.getLength()+1);
401             m_aComponentBitCounts[m_aComponentBitCounts.getLength()-1] = m_aBmpEx.IsAlpha() ? 8 : 1;
402 
403             if( m_nEndianness == util::Endianness::BIG )
404             {
405                 // put alpha in front of all the color channels
406                 sal_Int8*  pTags  =m_aComponentTags.getArray();
407                 sal_Int32* pCounts=m_aComponentBitCounts.getArray();
408                 std::rotate(pTags,
409                             pTags+m_aComponentTags.getLength()-1,
410                             pTags+m_aComponentTags.getLength());
411                 std::rotate(pCounts,
412                             pCounts+m_aComponentBitCounts.getLength()-1,
413                             pCounts+m_aComponentBitCounts.getLength());
414                 ++m_nRedIndex;
415                 ++m_nGreenIndex;
416                 ++m_nBlueIndex;
417                 ++m_nIndexIndex;
418                 m_nAlphaIndex=0;
419             }
420 
421             // always add a full byte to the pixel size, otherwise
422             // pixel packing hell breaks loose.
423             m_nBitsPerOutputPixel += 8;
424 
425             // adapt scanline parameters
426             const Size aSize = m_aBitmap.GetSizePixel();
427             m_aLayout.ScanLineBytes  =
428             m_aLayout.ScanLineStride = (aSize.Width()*m_nBitsPerOutputPixel + 7)/8;
429         }
430     }
431 }
432 
~VclCanvasBitmap()433 VclCanvasBitmap::~VclCanvasBitmap()
434 {
435     if( m_pAlphaAcc )
436         m_aAlpha.ReleaseAccess(m_pAlphaAcc);
437     if( m_pBmpAcc )
438         m_aBitmap.ReleaseAccess(m_pBmpAcc);
439 }
440 
441 // XBitmap
getSize()442 geometry::IntegerSize2D SAL_CALL VclCanvasBitmap::getSize() throw (uno::RuntimeException)
443 {
444     vos::OGuard aGuard( Application::GetSolarMutex() );
445     return integerSize2DFromSize( m_aBitmap.GetSizePixel() );
446 }
447 
hasAlpha()448 ::sal_Bool SAL_CALL VclCanvasBitmap::hasAlpha() throw (uno::RuntimeException)
449 {
450     vos::OGuard aGuard( Application::GetSolarMutex() );
451     return m_aBmpEx.IsTransparent();
452 }
453 
getScaledBitmap(const geometry::RealSize2D & newSize,sal_Bool beFast)454 uno::Reference< rendering::XBitmap > SAL_CALL VclCanvasBitmap::getScaledBitmap( const geometry::RealSize2D& newSize,
455                                                                                 sal_Bool beFast ) throw (uno::RuntimeException)
456 {
457     vos::OGuard aGuard( Application::GetSolarMutex() );
458 
459     BitmapEx aNewBmp( m_aBitmap );
460     aNewBmp.Scale( sizeFromRealSize2D( newSize ), beFast ? BMP_SCALE_FASTESTINTERPOLATE : BMP_SCALE_INTERPOLATE );
461     return uno::Reference<rendering::XBitmap>( new VclCanvasBitmap( aNewBmp ) );
462 }
463 
464 // XIntegerReadOnlyBitmap
getData(rendering::IntegerBitmapLayout & bitmapLayout,const geometry::IntegerRectangle2D & rect)465 uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getData( rendering::IntegerBitmapLayout& 	 bitmapLayout,
466                                                              const geometry::IntegerRectangle2D& rect ) throw( lang::IndexOutOfBoundsException,
467                                                                                                                rendering::VolatileContentDestroyedException,
468                                                                                                                uno::RuntimeException)
469 {
470     vos::OGuard aGuard( Application::GetSolarMutex() );
471 
472     bitmapLayout = getMemoryLayout();
473 
474     const ::Rectangle aRequestedArea( vcl::unotools::rectangleFromIntegerRectangle2D(rect) );
475     if( aRequestedArea.IsEmpty() )
476         return uno::Sequence< sal_Int8 >();
477 
478     // Invalid/empty bitmap: no data available
479     if( !m_pBmpAcc )
480         throw lang::IndexOutOfBoundsException();
481     if( m_aBmpEx.IsTransparent() && !m_pAlphaAcc )
482         throw lang::IndexOutOfBoundsException();
483 
484     if( aRequestedArea.Left() < 0 || aRequestedArea.Top() < 0 ||
485         aRequestedArea.Right() > m_pBmpAcc->Width() ||
486         aRequestedArea.Bottom() > m_pBmpAcc->Height() )
487     {
488         throw lang::IndexOutOfBoundsException();
489     }
490 
491     uno::Sequence< sal_Int8 > aRet;
492     Rectangle aRequestedBytes( aRequestedArea );
493 
494     // adapt to byte boundaries
495     aRequestedBytes.Left()  = aRequestedArea.Left()*m_nBitsPerOutputPixel/8;
496     aRequestedBytes.Right() = (aRequestedArea.Right()*m_nBitsPerOutputPixel + 7)/8;
497 
498     // copy stuff to output sequence
499     aRet.realloc(aRequestedBytes.getWidth()*aRequestedBytes.getHeight());
500     sal_Int8* pOutBuf = aRet.getArray();
501 
502     bitmapLayout.ScanLines     = aRequestedBytes.getHeight();
503     bitmapLayout.ScanLineBytes =
504     bitmapLayout.ScanLineStride= aRequestedBytes.getWidth();
505 
506     sal_Int32 nScanlineStride=bitmapLayout.ScanLineStride;
507     if( !(m_pBmpAcc->GetScanlineFormat() & BMP_FORMAT_TOP_DOWN) )
508     {
509         pOutBuf += bitmapLayout.ScanLineStride*(aRequestedBytes.getHeight()-1);
510         nScanlineStride *= -1;
511     }
512 
513     if( !m_aBmpEx.IsTransparent() )
514     {
515         OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
516 
517         // can return bitmap data as-is
518         for( long y=aRequestedBytes.Top(); y<aRequestedBytes.Bottom(); ++y )
519         {
520             Scanline pScan = m_pBmpAcc->GetScanline(y);
521             rtl_copyMemory(pOutBuf, pScan+aRequestedBytes.Left(), aRequestedBytes.getWidth());
522             pOutBuf += nScanlineStride;
523         }
524     }
525     else
526     {
527         OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
528         OSL_ENSURE(m_pAlphaAcc,"Invalid alpha read access");
529 
530         // interleave alpha with bitmap data - note, bitcount is
531         // always integer multiple of 8
532         OSL_ENSURE((m_nBitsPerOutputPixel & 0x07) == 0,
533                    "Transparent bitmap bitcount not integer multiple of 8" );
534 
535         for( long y=aRequestedArea.Top(); y<aRequestedArea.Bottom(); ++y )
536         {
537             sal_Int8* pOutScan = pOutBuf;
538 
539             if( m_nBitsPerInputPixel < 8 )
540             {
541                 // input less than a byte - copy via GetPixel()
542                 for( long x=aRequestedArea.Left(); x<aRequestedArea.Right(); ++x )
543                 {
544                     *pOutScan++ = m_pBmpAcc->GetPixelIndex(y,x);
545                     *pOutScan++ = m_pAlphaAcc->GetPixelIndex(y,x);
546                 }
547             }
548             else
549             {
550                 const long nNonAlphaBytes( m_nBitsPerInputPixel/8 );
551                 const long nScanlineOffsetLeft(aRequestedArea.Left()*nNonAlphaBytes);
552                 Scanline  pScan = m_pBmpAcc->GetScanline(y) + nScanlineOffsetLeft;
553 
554                 // input integer multiple of byte - copy directly
555                 for( long x=aRequestedArea.Left(); x<aRequestedArea.Right(); ++x )
556                 {
557                     for( long i=0; i<nNonAlphaBytes; ++i )
558                         *pOutScan++ = *pScan++;
559                     *pOutScan++ = m_pAlphaAcc->GetPixelIndex( y, x );
560                 }
561             }
562 
563             pOutBuf += nScanlineStride;
564         }
565     }
566 
567     return aRet;
568 }
569 
getPixel(rendering::IntegerBitmapLayout & bitmapLayout,const geometry::IntegerPoint2D & pos)570 uno::Sequence< sal_Int8 > SAL_CALL VclCanvasBitmap::getPixel( rendering::IntegerBitmapLayout&	bitmapLayout,
571                                                               const geometry::IntegerPoint2D&	pos ) throw (lang::IndexOutOfBoundsException,
572                                                                                                              rendering::VolatileContentDestroyedException,
573                                                                                                              uno::RuntimeException)
574 {
575     vos::OGuard aGuard( Application::GetSolarMutex() );
576 
577     bitmapLayout = getMemoryLayout();
578 
579     // Invalid/empty bitmap: no data available
580     if( !m_pBmpAcc )
581         throw lang::IndexOutOfBoundsException();
582     if( m_aBmpEx.IsTransparent() && !m_pAlphaAcc )
583         throw lang::IndexOutOfBoundsException();
584 
585     if( pos.X < 0 || pos.Y < 0 ||
586         pos.X > m_pBmpAcc->Width() || pos.Y > m_pBmpAcc->Height() )
587     {
588         throw lang::IndexOutOfBoundsException();
589     }
590 
591     uno::Sequence< sal_Int8 > aRet((m_nBitsPerOutputPixel + 7)/8);
592     sal_Int8* pOutBuf = aRet.getArray();
593 
594     // copy stuff to output sequence
595     bitmapLayout.ScanLines     = 1;
596     bitmapLayout.ScanLineBytes =
597     bitmapLayout.ScanLineStride= aRet.getLength();
598 
599     const long nScanlineLeftOffset( pos.X*m_nBitsPerInputPixel/8 );
600     if( !m_aBmpEx.IsTransparent() )
601     {
602         OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
603 
604         // can return bitmap data as-is
605         Scanline pScan = m_pBmpAcc->GetScanline(pos.Y);
606         rtl_copyMemory(pOutBuf, pScan+nScanlineLeftOffset, aRet.getLength() );
607     }
608     else
609     {
610         OSL_ENSURE(m_pBmpAcc,"Invalid bmp read access");
611         OSL_ENSURE(m_pAlphaAcc,"Invalid alpha read access");
612 
613         // interleave alpha with bitmap data - note, bitcount is
614         // always integer multiple of 8
615         OSL_ENSURE((m_nBitsPerOutputPixel & 0x07) == 0,
616                    "Transparent bitmap bitcount not integer multiple of 8" );
617 
618         if( m_nBitsPerInputPixel < 8 )
619         {
620             // input less than a byte - copy via GetPixel()
621             *pOutBuf++ = m_pBmpAcc->GetPixelIndex(pos.Y,pos.X);
622             *pOutBuf   = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
623         }
624         else
625         {
626             const long nNonAlphaBytes( m_nBitsPerInputPixel/8 );
627             Scanline  pScan = m_pBmpAcc->GetScanline(pos.Y);
628 
629             // input integer multiple of byte - copy directly
630             rtl_copyMemory(pOutBuf, pScan+nScanlineLeftOffset, nNonAlphaBytes );
631             pOutBuf += nNonAlphaBytes;
632             *pOutBuf++ = m_pAlphaAcc->GetPixelIndex(pos.Y,pos.X);
633         }
634     }
635 
636     return aRet;
637 }
638 
getPalette()639 uno::Reference< rendering::XBitmapPalette > SAL_CALL VclCanvasBitmap::getPalette() throw (uno::RuntimeException)
640 {
641     vos::OGuard aGuard( Application::GetSolarMutex() );
642 
643     uno::Reference< XBitmapPalette > aRet;
644     if( m_bPalette )
645         aRet.set(this);
646 
647     return aRet;
648 }
649 
getMemoryLayout()650 rendering::IntegerBitmapLayout SAL_CALL VclCanvasBitmap::getMemoryLayout() throw (uno::RuntimeException)
651 {
652     vos::OGuard aGuard( Application::GetSolarMutex() );
653 
654     rendering::IntegerBitmapLayout aLayout( m_aLayout );
655 
656     // only set references to self on separate copy of
657     // IntegerBitmapLayout - if we'd set that on m_aLayout, we'd have
658     // a circular reference!
659     if( m_bPalette )
660         aLayout.Palette.set( this );
661 
662     aLayout.ColorSpace.set( this );
663 
664     return aLayout;
665 }
666 
getNumberOfEntries()667 sal_Int32 SAL_CALL VclCanvasBitmap::getNumberOfEntries() throw (uno::RuntimeException)
668 {
669     vos::OGuard aGuard( Application::GetSolarMutex() );
670 
671     if( !m_pBmpAcc )
672         return 0;
673 
674     return m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ;
675 }
676 
getIndex(uno::Sequence<double> & o_entry,sal_Int32 nIndex)677 sal_Bool SAL_CALL VclCanvasBitmap::getIndex( uno::Sequence< double >& o_entry, sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException)
678 {
679     vos::OGuard aGuard( Application::GetSolarMutex() );
680 
681     const sal_uInt16 nCount( m_pBmpAcc ?
682                          (m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ) : 0 );
683     OSL_ENSURE(nIndex >= 0 && nIndex < nCount,"Palette index out of range");
684     if( nIndex < 0 || nIndex >= nCount )
685         throw lang::IndexOutOfBoundsException(::rtl::OUString::createFromAscii("Palette index out of range"),
686                                               static_cast<rendering::XBitmapPalette*>(this));
687 
688     const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(sal::static_int_cast<sal_uInt16>(nIndex));
689     o_entry.realloc(3);
690     double* pColor=o_entry.getArray();
691     pColor[0] = aCol.GetRed();
692     pColor[1] = aCol.GetGreen();
693     pColor[2] = aCol.GetBlue();
694 
695     return sal_True; // no palette transparency here.
696 }
697 
setIndex(const uno::Sequence<double> &,sal_Bool,sal_Int32 nIndex)698 sal_Bool SAL_CALL VclCanvasBitmap::setIndex( const uno::Sequence< double >&, sal_Bool, sal_Int32 nIndex ) throw (lang::IndexOutOfBoundsException, lang::IllegalArgumentException, uno::RuntimeException)
699 {
700     vos::OGuard aGuard( Application::GetSolarMutex() );
701 
702     const sal_uInt16 nCount( m_pBmpAcc ?
703                          (m_pBmpAcc->HasPalette() ? m_pBmpAcc->GetPaletteEntryCount() : 0 ) : 0 );
704 
705     OSL_ENSURE(nIndex >= 0 && nIndex < nCount,"Palette index out of range");
706     if( nIndex < 0 || nIndex >= nCount )
707         throw lang::IndexOutOfBoundsException(::rtl::OUString::createFromAscii("Palette index out of range"),
708                                               static_cast<rendering::XBitmapPalette*>(this));
709 
710     return sal_False; // read-only implementation
711 }
712 
713 namespace
714 {
715     struct PaletteColorSpaceHolder: public rtl::StaticWithInit<uno::Reference<rendering::XColorSpace>,
716                                                                PaletteColorSpaceHolder>
717     {
operator ()__anonc5bfbaf40211::PaletteColorSpaceHolder718         uno::Reference<rendering::XColorSpace> operator()()
719         {
720             return vcl::unotools::createStandardColorSpace();
721         }
722     };
723 }
724 
getColorSpace()725 uno::Reference< rendering::XColorSpace > SAL_CALL VclCanvasBitmap::getColorSpace(  ) throw (uno::RuntimeException)
726 {
727     // this is the method from XBitmapPalette. Return palette color
728     // space here
729     return PaletteColorSpaceHolder::get();
730 }
731 
getType()732 sal_Int8 SAL_CALL VclCanvasBitmap::getType(  ) throw (uno::RuntimeException)
733 {
734     return rendering::ColorSpaceType::RGB;
735 }
736 
getComponentTags()737 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::getComponentTags(  ) throw (uno::RuntimeException)
738 {
739     vos::OGuard aGuard( Application::GetSolarMutex() );
740     return m_aComponentTags;
741 }
742 
getRenderingIntent()743 sal_Int8 SAL_CALL VclCanvasBitmap::getRenderingIntent(  ) throw (uno::RuntimeException)
744 {
745     return rendering::RenderingIntent::PERCEPTUAL;
746 }
747 
getProperties()748 uno::Sequence< ::beans::PropertyValue > SAL_CALL VclCanvasBitmap::getProperties(  ) throw (uno::RuntimeException)
749 {
750     return uno::Sequence< ::beans::PropertyValue >();
751 }
752 
convertColorSpace(const uno::Sequence<double> & deviceColor,const uno::Reference<::rendering::XColorSpace> & targetColorSpace)753 uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertColorSpace( const uno::Sequence< double >& deviceColor,
754                                                                      const uno::Reference< ::rendering::XColorSpace >& targetColorSpace ) throw (uno::RuntimeException)
755 {
756     // TODO(P3): if we know anything about target
757     // colorspace, this can be greatly sped up
758     uno::Sequence<rendering::ARGBColor> aIntermediate(
759         convertToARGB(deviceColor));
760     return targetColorSpace->convertFromARGB(aIntermediate);
761 }
762 
convertToRGB(const uno::Sequence<double> & deviceColor)763 uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertToRGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
764 {
765     vos::OGuard aGuard( Application::GetSolarMutex() );
766 
767     const sal_Size  nLen( deviceColor.getLength() );
768     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
769     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
770                          "number of channels no multiple of pixel element count",
771                          static_cast<rendering::XBitmapPalette*>(this), 01);
772 
773     uno::Sequence< rendering::RGBColor > aRes(nLen/nComponentsPerPixel);
774     rendering::RGBColor* pOut( aRes.getArray() );
775 
776     if( m_bPalette )
777     {
778         OSL_ENSURE(m_nIndexIndex != -1,
779                    "Invalid color channel indices");
780         ENSURE_OR_THROW(m_pBmpAcc,
781                         "Unable to get BitmapAccess");
782 
783         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
784         {
785             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
786                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
787 
788             // TODO(F3): Convert result to sRGB color space
789             *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
790                                           toDoubleColor(aCol.GetGreen()),
791                                           toDoubleColor(aCol.GetBlue()));
792         }
793     }
794     else
795     {
796         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
797                    "Invalid color channel indices");
798 
799         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
800         {
801             // TODO(F3): Convert result to sRGB color space
802             *pOut++ = rendering::RGBColor(
803                 deviceColor[i+m_nRedIndex],
804                 deviceColor[i+m_nGreenIndex],
805                 deviceColor[i+m_nBlueIndex]);
806         }
807     }
808 
809     return aRes;
810 }
811 
convertToARGB(const uno::Sequence<double> & deviceColor)812 uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
813 {
814     vos::OGuard aGuard( Application::GetSolarMutex() );
815 
816     const sal_Size  nLen( deviceColor.getLength() );
817     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
818     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
819                          "number of channels no multiple of pixel element count",
820                          static_cast<rendering::XBitmapPalette*>(this), 01);
821 
822     uno::Sequence< rendering::ARGBColor > aRes(nLen/nComponentsPerPixel);
823     rendering::ARGBColor* pOut( aRes.getArray() );
824 
825     if( m_bPalette )
826     {
827         OSL_ENSURE(m_nIndexIndex != -1,
828                    "Invalid color channel indices");
829         ENSURE_OR_THROW(m_pBmpAcc,
830                         "Unable to get BitmapAccess");
831 
832         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
833         {
834             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
835                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
836 
837             // TODO(F3): Convert result to sRGB color space
838             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
839             *pOut++ = rendering::ARGBColor(nAlpha,
840                                            toDoubleColor(aCol.GetRed()),
841                                            toDoubleColor(aCol.GetGreen()),
842                                            toDoubleColor(aCol.GetBlue()));
843         }
844     }
845     else
846     {
847         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
848                    "Invalid color channel indices");
849 
850         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
851         {
852             // TODO(F3): Convert result to sRGB color space
853             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
854             *pOut++ = rendering::ARGBColor(
855                 nAlpha,
856                 deviceColor[i+m_nRedIndex],
857                 deviceColor[i+m_nGreenIndex],
858                 deviceColor[i+m_nBlueIndex]);
859         }
860     }
861 
862     return aRes;
863 }
864 
convertToPARGB(const uno::Sequence<double> & deviceColor)865 uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertToPARGB( const uno::Sequence< double >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
866 {
867     vos::OGuard aGuard( Application::GetSolarMutex() );
868 
869     const sal_Size  nLen( deviceColor.getLength() );
870     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
871     ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
872                          "number of channels no multiple of pixel element count",
873                          static_cast<rendering::XBitmapPalette*>(this), 01);
874 
875     uno::Sequence< rendering::ARGBColor > aRes(nLen/nComponentsPerPixel);
876     rendering::ARGBColor* pOut( aRes.getArray() );
877 
878     if( m_bPalette )
879     {
880         OSL_ENSURE(m_nIndexIndex != -1,
881                    "Invalid color channel indices");
882         ENSURE_OR_THROW(m_pBmpAcc,
883                         "Unable to get BitmapAccess");
884 
885         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
886         {
887             const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
888                 sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
889 
890             // TODO(F3): Convert result to sRGB color space
891             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
892             *pOut++ = rendering::ARGBColor(nAlpha,
893                                            nAlpha*toDoubleColor(aCol.GetRed()),
894                                            nAlpha*toDoubleColor(aCol.GetGreen()),
895                                            nAlpha*toDoubleColor(aCol.GetBlue()));
896         }
897     }
898     else
899     {
900         OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
901                    "Invalid color channel indices");
902 
903         for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
904         {
905             // TODO(F3): Convert result to sRGB color space
906             const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
907             *pOut++ = rendering::ARGBColor(
908                 nAlpha,
909                 nAlpha*deviceColor[i+m_nRedIndex],
910                 nAlpha*deviceColor[i+m_nGreenIndex],
911                 nAlpha*deviceColor[i+m_nBlueIndex]);
912         }
913     }
914 
915     return aRes;
916 }
917 
convertFromRGB(const uno::Sequence<rendering::RGBColor> & rgbColor)918 uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
919 {
920     vos::OGuard aGuard( Application::GetSolarMutex() );
921 
922     const sal_Size  nLen( rgbColor.getLength() );
923     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
924 
925     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
926     double* pColors=aRes.getArray();
927 
928     if( m_bPalette )
929     {
930         for( sal_Size i=0; i<nLen; ++i )
931         {
932             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
933                     BitmapColor(toByteColor(rgbColor[i].Red),
934                                 toByteColor(rgbColor[i].Green),
935                                 toByteColor(rgbColor[i].Blue)));
936             if( m_nAlphaIndex != -1 )
937                 pColors[m_nAlphaIndex] = 1.0;
938 
939             pColors += nComponentsPerPixel;
940         }
941     }
942     else
943     {
944         for( sal_Size i=0; i<nLen; ++i )
945         {
946             pColors[m_nRedIndex]   = rgbColor[i].Red;
947             pColors[m_nGreenIndex] = rgbColor[i].Green;
948             pColors[m_nBlueIndex]  = rgbColor[i].Blue;
949             if( m_nAlphaIndex != -1 )
950                 pColors[m_nAlphaIndex] = 1.0;
951 
952             pColors += nComponentsPerPixel;
953         }
954     }
955     return aRes;
956 }
957 
convertFromARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)958 uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
959 {
960     vos::OGuard aGuard( Application::GetSolarMutex() );
961 
962     const sal_Size  nLen( rgbColor.getLength() );
963     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
964 
965     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
966     double* pColors=aRes.getArray();
967 
968     if( m_bPalette )
969     {
970         for( sal_Size i=0; i<nLen; ++i )
971         {
972             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
973                     BitmapColor(toByteColor(rgbColor[i].Red),
974                                 toByteColor(rgbColor[i].Green),
975                                 toByteColor(rgbColor[i].Blue)));
976             if( m_nAlphaIndex != -1 )
977                 pColors[m_nAlphaIndex] = rgbColor[i].Alpha;
978 
979             pColors += nComponentsPerPixel;
980         }
981     }
982     else
983     {
984         for( sal_Size i=0; i<nLen; ++i )
985         {
986             pColors[m_nRedIndex]   = rgbColor[i].Red;
987             pColors[m_nGreenIndex] = rgbColor[i].Green;
988             pColors[m_nBlueIndex]  = rgbColor[i].Blue;
989             if( m_nAlphaIndex != -1 )
990                 pColors[m_nAlphaIndex] = rgbColor[i].Alpha;
991 
992             pColors += nComponentsPerPixel;
993         }
994     }
995     return aRes;
996 }
997 
convertFromPARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)998 uno::Sequence< double > SAL_CALL VclCanvasBitmap::convertFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
999 {
1000     vos::OGuard aGuard( Application::GetSolarMutex() );
1001 
1002     const sal_Size  nLen( rgbColor.getLength() );
1003     const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
1004 
1005     uno::Sequence< double > aRes(nLen*nComponentsPerPixel);
1006     double* pColors=aRes.getArray();
1007 
1008     if( m_bPalette )
1009     {
1010         for( sal_Size i=0; i<nLen; ++i )
1011         {
1012             const double nAlpha( rgbColor[i].Alpha );
1013             pColors[m_nIndexIndex] = m_pBmpAcc->GetBestPaletteIndex(
1014                     BitmapColor(toByteColor(rgbColor[i].Red / nAlpha),
1015                                 toByteColor(rgbColor[i].Green / nAlpha),
1016                                 toByteColor(rgbColor[i].Blue / nAlpha)));
1017             if( m_nAlphaIndex != -1 )
1018                 pColors[m_nAlphaIndex] = nAlpha;
1019 
1020             pColors += nComponentsPerPixel;
1021         }
1022     }
1023     else
1024     {
1025         for( sal_Size i=0; i<nLen; ++i )
1026         {
1027             const double nAlpha( rgbColor[i].Alpha );
1028             pColors[m_nRedIndex]   = rgbColor[i].Red / nAlpha;
1029             pColors[m_nGreenIndex] = rgbColor[i].Green / nAlpha;
1030             pColors[m_nBlueIndex]  = rgbColor[i].Blue / nAlpha;
1031             if( m_nAlphaIndex != -1 )
1032                 pColors[m_nAlphaIndex] = nAlpha;
1033 
1034             pColors += nComponentsPerPixel;
1035         }
1036     }
1037     return aRes;
1038 }
1039 
getBitsPerPixel()1040 sal_Int32 SAL_CALL VclCanvasBitmap::getBitsPerPixel(  ) throw (uno::RuntimeException)
1041 {
1042     vos::OGuard aGuard( Application::GetSolarMutex() );
1043     return m_nBitsPerOutputPixel;
1044 }
1045 
getComponentBitCounts()1046 uno::Sequence< ::sal_Int32 > SAL_CALL VclCanvasBitmap::getComponentBitCounts(  ) throw (uno::RuntimeException)
1047 {
1048     vos::OGuard aGuard( Application::GetSolarMutex() );
1049     return m_aComponentBitCounts;
1050 }
1051 
getEndianness()1052 sal_Int8 SAL_CALL VclCanvasBitmap::getEndianness(  ) throw (uno::RuntimeException)
1053 {
1054     vos::OGuard aGuard( Application::GetSolarMutex() );
1055     return m_nEndianness;
1056 }
1057 
convertFromIntegerColorSpace(const uno::Sequence<::sal_Int8> & deviceColor,const uno::Reference<::rendering::XColorSpace> & targetColorSpace)1058 uno::Sequence<double> SAL_CALL VclCanvasBitmap::convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
1059                                                                               const uno::Reference< ::rendering::XColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1060 {
1061     if( dynamic_cast<VclCanvasBitmap*>(targetColorSpace.get()) )
1062     {
1063         vos::OGuard aGuard( Application::GetSolarMutex() );
1064 
1065         const sal_Size  nLen( deviceColor.getLength() );
1066         const sal_Int32 nComponentsPerPixel(m_aComponentTags.getLength());
1067         ENSURE_ARG_OR_THROW2(nLen%nComponentsPerPixel==0,
1068                              "number of channels no multiple of pixel element count",
1069                              static_cast<rendering::XBitmapPalette*>(this), 01);
1070 
1071         uno::Sequence<double> aRes(nLen);
1072         double* pOut( aRes.getArray() );
1073 
1074         if( m_bPalette )
1075         {
1076             OSL_ENSURE(m_nIndexIndex != -1,
1077                        "Invalid color channel indices");
1078             ENSURE_OR_THROW(m_pBmpAcc,
1079                             "Unable to get BitmapAccess");
1080 
1081             for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
1082             {
1083                 const BitmapColor aCol = m_pBmpAcc->GetPaletteColor(
1084                     sal::static_int_cast<sal_uInt16>(deviceColor[i+m_nIndexIndex]));
1085 
1086                 // TODO(F3): Convert result to sRGB color space
1087                 const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
1088                 *pOut++ = toDoubleColor(aCol.GetRed());
1089                 *pOut++ = toDoubleColor(aCol.GetGreen());
1090                 *pOut++ = toDoubleColor(aCol.GetBlue());
1091                 *pOut++ = nAlpha;
1092             }
1093         }
1094         else
1095         {
1096             OSL_ENSURE(m_nRedIndex != -1 && m_nGreenIndex != -1 && m_nBlueIndex != -1,
1097                        "Invalid color channel indices");
1098 
1099             for( sal_Size i=0; i<nLen; i+=nComponentsPerPixel )
1100             {
1101                 // TODO(F3): Convert result to sRGB color space
1102                 const double nAlpha( m_nAlphaIndex != -1 ? 1.0 - deviceColor[i+m_nAlphaIndex] : 1.0 );
1103                 *pOut++ = deviceColor[i+m_nRedIndex];
1104                 *pOut++ = deviceColor[i+m_nGreenIndex];
1105                 *pOut++ = deviceColor[i+m_nBlueIndex];
1106                 *pOut++ = nAlpha;
1107             }
1108         }
1109 
1110         return aRes;
1111     }
1112     else
1113     {
1114         // TODO(P3): if we know anything about target
1115         // colorspace, this can be greatly sped up
1116         uno::Sequence<rendering::ARGBColor> aIntermediate(
1117             convertIntegerToARGB(deviceColor));
1118         return targetColorSpace->convertFromARGB(aIntermediate);
1119     }
1120 }
1121 
convertToIntegerColorSpace(const uno::Sequence<::sal_Int8> & deviceColor,const uno::Reference<::rendering::XIntegerBitmapColorSpace> & targetColorSpace)1122 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& deviceColor,
1123                                                                                   const uno::Reference< ::rendering::XIntegerBitmapColorSpace >& targetColorSpace ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1124 {
1125     if( dynamic_cast<VclCanvasBitmap*>(targetColorSpace.get()) )
1126     {
1127         // it's us, so simply pass-through the data
1128         return deviceColor;
1129     }
1130     else
1131     {
1132         // TODO(P3): if we know anything about target
1133         // colorspace, this can be greatly sped up
1134         uno::Sequence<rendering::ARGBColor> aIntermediate(
1135             convertIntegerToARGB(deviceColor));
1136         return targetColorSpace->convertIntegerFromARGB(aIntermediate);
1137     }
1138 }
1139 
convertIntegerToRGB(const uno::Sequence<::sal_Int8> & deviceColor)1140 uno::Sequence<rendering::RGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToRGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1141 {
1142     vos::OGuard aGuard( Application::GetSolarMutex() );
1143 
1144     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
1145     const sal_Size  nLen( deviceColor.getLength() );
1146     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
1147 
1148     uno::Sequence< rendering::RGBColor > aRes(nNumColors);
1149     rendering::RGBColor* pOut( aRes.getArray() );
1150 
1151     ENSURE_OR_THROW(m_pBmpAcc,
1152                     "Unable to get BitmapAccess");
1153 
1154     if( m_aBmpEx.IsTransparent() )
1155     {
1156         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
1157         for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
1158         {
1159             // if palette, index is guaranteed to be 8 bit
1160             const BitmapColor aCol =
1161                 m_bPalette ?
1162                 m_pBmpAcc->GetPaletteColor(*pIn) :
1163                 m_pBmpAcc->GetPixelFromData(pIn,0);
1164 
1165             // TODO(F3): Convert result to sRGB color space
1166             *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
1167                                           toDoubleColor(aCol.GetGreen()),
1168                                           toDoubleColor(aCol.GetBlue()));
1169             // skips alpha
1170             pIn += nBytesPerPixel;
1171         }
1172     }
1173     else
1174     {
1175         for( sal_Int32 i=0; i<nNumColors; ++i )
1176         {
1177             const BitmapColor aCol =
1178                 m_bPalette ?
1179                 m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex()) :
1180                 m_pBmpAcc->GetPixelFromData(pIn, i);
1181 
1182             // TODO(F3): Convert result to sRGB color space
1183             *pOut++ = rendering::RGBColor(toDoubleColor(aCol.GetRed()),
1184                                           toDoubleColor(aCol.GetGreen()),
1185                                           toDoubleColor(aCol.GetBlue()));
1186         }
1187     }
1188 
1189     return aRes;
1190 }
1191 
convertIntegerToARGB(const uno::Sequence<::sal_Int8> & deviceColor)1192 uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1193 {
1194     vos::OGuard aGuard( Application::GetSolarMutex() );
1195 
1196     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
1197     const sal_Size  nLen( deviceColor.getLength() );
1198     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
1199 
1200     uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
1201     rendering::ARGBColor* pOut( aRes.getArray() );
1202 
1203     ENSURE_OR_THROW(m_pBmpAcc,
1204                     "Unable to get BitmapAccess");
1205 
1206     if( m_aBmpEx.IsTransparent() )
1207     {
1208         const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
1209         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
1210         const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
1211         for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
1212         {
1213             // if palette, index is guaranteed to be 8 bit
1214             const BitmapColor aCol =
1215                 m_bPalette ?
1216                 m_pBmpAcc->GetPaletteColor(*pIn) :
1217                 m_pBmpAcc->GetPixelFromData(pIn,0);
1218 
1219             // TODO(F3): Convert result to sRGB color space
1220             *pOut++ = rendering::ARGBColor(1.0 - toDoubleColor(nAlphaFactor*pIn[nNonAlphaBytes]),
1221                                            toDoubleColor(aCol.GetRed()),
1222                                            toDoubleColor(aCol.GetGreen()),
1223                                            toDoubleColor(aCol.GetBlue()));
1224             pIn += nBytesPerPixel;
1225         }
1226     }
1227     else
1228     {
1229         for( sal_Int32 i=0; i<nNumColors; ++i )
1230         {
1231             const BitmapColor aCol =
1232                 m_bPalette ?
1233                 m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
1234                 m_pBmpAcc->GetPixelFromData(pIn, i);
1235 
1236             // TODO(F3): Convert result to sRGB color space
1237             *pOut++ = rendering::ARGBColor(1.0,
1238                                            toDoubleColor(aCol.GetRed()),
1239                                            toDoubleColor(aCol.GetGreen()),
1240                                            toDoubleColor(aCol.GetBlue()));
1241         }
1242     }
1243 
1244     return aRes;
1245 }
1246 
convertIntegerToPARGB(const uno::Sequence<::sal_Int8> & deviceColor)1247 uno::Sequence<rendering::ARGBColor> SAL_CALL VclCanvasBitmap::convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1248 {
1249     vos::OGuard aGuard( Application::GetSolarMutex() );
1250 
1251     const sal_uInt8*     pIn( reinterpret_cast<const sal_uInt8*>(deviceColor.getConstArray()) );
1252     const sal_Size  nLen( deviceColor.getLength() );
1253     const sal_Int32 nNumColors((nLen*8 + m_nBitsPerOutputPixel-1)/m_nBitsPerOutputPixel);
1254 
1255     uno::Sequence< rendering::ARGBColor > aRes(nNumColors);
1256     rendering::ARGBColor* pOut( aRes.getArray() );
1257 
1258     ENSURE_OR_THROW(m_pBmpAcc,
1259                     "Unable to get BitmapAccess");
1260 
1261     if( m_aBmpEx.IsTransparent() )
1262     {
1263         const long      nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
1264         const sal_Int32 nBytesPerPixel((m_nBitsPerOutputPixel+7)/8);
1265         const sal_uInt8 nAlphaFactor( m_aBmpEx.IsAlpha() ? 1 : 255 );
1266         for( sal_Size i=0; i<nLen; i+=nBytesPerPixel )
1267         {
1268             // if palette, index is guaranteed to be 8 bit
1269             const BitmapColor aCol =
1270                 m_bPalette ?
1271                 m_pBmpAcc->GetPaletteColor(*pIn) :
1272                 m_pBmpAcc->GetPixelFromData(pIn,0);
1273 
1274             // TODO(F3): Convert result to sRGB color space
1275             const double nAlpha( 1.0 - toDoubleColor(nAlphaFactor*pIn[nNonAlphaBytes]) );
1276             *pOut++ = rendering::ARGBColor(nAlpha,
1277                                            nAlpha*toDoubleColor(aCol.GetRed()),
1278                                            nAlpha*toDoubleColor(aCol.GetGreen()),
1279                                            nAlpha*toDoubleColor(aCol.GetBlue()));
1280             pIn += nBytesPerPixel;
1281         }
1282     }
1283     else
1284     {
1285         for( sal_Int32 i=0; i<nNumColors; ++i )
1286         {
1287             const BitmapColor aCol =
1288                 m_bPalette ?
1289                 m_pBmpAcc->GetPaletteColor( m_pBmpAcc->GetPixelFromData( pIn, i ).GetIndex() ) :
1290                 m_pBmpAcc->GetPixelFromData(pIn, i);
1291 
1292             // TODO(F3): Convert result to sRGB color space
1293             *pOut++ = rendering::ARGBColor(1.0,
1294                                            toDoubleColor(aCol.GetRed()),
1295                                            toDoubleColor(aCol.GetGreen()),
1296                                            toDoubleColor(aCol.GetBlue()));
1297         }
1298     }
1299 
1300     return aRes;
1301 }
1302 
convertIntegerFromRGB(const uno::Sequence<rendering::RGBColor> & rgbColor)1303 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromRGB( const uno::Sequence<rendering::RGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1304 {
1305     vos::OGuard aGuard( Application::GetSolarMutex() );
1306 
1307     const sal_Size  nLen( rgbColor.getLength() );
1308     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
1309 
1310     uno::Sequence< sal_Int8 > aRes(nNumBytes);
1311     sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());
1312 
1313     if( m_aBmpEx.IsTransparent() )
1314     {
1315         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
1316         for( sal_Size i=0; i<nLen; ++i )
1317         {
1318             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
1319                                    toByteColor(rgbColor[i].Green),
1320                                    toByteColor(rgbColor[i].Blue));
1321             const BitmapColor aCol2 =
1322                 m_bPalette ?
1323                 BitmapColor(
1324                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1325                 aCol;
1326 
1327             m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
1328             pColors   += nNonAlphaBytes;
1329             *pColors++ = sal_uInt8(255);
1330         }
1331     }
1332     else
1333     {
1334         for( sal_Size i=0; i<nLen; ++i )
1335         {
1336             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
1337                                    toByteColor(rgbColor[i].Green),
1338                                    toByteColor(rgbColor[i].Blue));
1339             const BitmapColor aCol2 =
1340                 m_bPalette ?
1341                 BitmapColor(
1342                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1343                 aCol;
1344 
1345             m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
1346         }
1347     }
1348 
1349     return aRes;
1350 }
1351 
convertIntegerFromARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)1352 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1353 {
1354     vos::OGuard aGuard( Application::GetSolarMutex() );
1355 
1356     const sal_Size  nLen( rgbColor.getLength() );
1357     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
1358 
1359     uno::Sequence< sal_Int8 > aRes(nNumBytes);
1360     sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());
1361 
1362     if( m_aBmpEx.IsTransparent() )
1363     {
1364         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
1365         for( sal_Size i=0; i<nLen; ++i )
1366         {
1367             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
1368                                    toByteColor(rgbColor[i].Green),
1369                                    toByteColor(rgbColor[i].Blue));
1370             const BitmapColor aCol2 =
1371                 m_bPalette ?
1372                 BitmapColor(
1373                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1374                 aCol;
1375 
1376             m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
1377             pColors   += nNonAlphaBytes;
1378             *pColors++ = 255 - toByteColor(rgbColor[i].Alpha);
1379         }
1380     }
1381     else
1382     {
1383         for( sal_Size i=0; i<nLen; ++i )
1384         {
1385             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
1386                                    toByteColor(rgbColor[i].Green),
1387                                    toByteColor(rgbColor[i].Blue));
1388             const BitmapColor aCol2 =
1389                 m_bPalette ?
1390                 BitmapColor(
1391                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1392                 aCol;
1393 
1394             m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
1395         }
1396     }
1397 
1398     return aRes;
1399 }
1400 
convertIntegerFromPARGB(const uno::Sequence<rendering::ARGBColor> & rgbColor)1401 uno::Sequence< ::sal_Int8 > SAL_CALL VclCanvasBitmap::convertIntegerFromPARGB( const uno::Sequence<rendering::ARGBColor>& rgbColor ) throw (lang::IllegalArgumentException,uno::RuntimeException)
1402 {
1403     vos::OGuard aGuard( Application::GetSolarMutex() );
1404 
1405     const sal_Size  nLen( rgbColor.getLength() );
1406     const sal_Int32 nNumBytes((nLen*m_nBitsPerOutputPixel+7)/8);
1407 
1408     uno::Sequence< sal_Int8 > aRes(nNumBytes);
1409     sal_uInt8* pColors=reinterpret_cast<sal_uInt8*>(aRes.getArray());
1410 
1411     if( m_aBmpEx.IsTransparent() )
1412     {
1413         const long nNonAlphaBytes( (m_nBitsPerInputPixel+7)/8 );
1414         for( sal_Size i=0; i<nLen; ++i )
1415         {
1416             const double nAlpha( rgbColor[i].Alpha );
1417             const BitmapColor aCol(toByteColor(rgbColor[i].Red / nAlpha),
1418                                    toByteColor(rgbColor[i].Green / nAlpha),
1419                                    toByteColor(rgbColor[i].Blue / nAlpha));
1420             const BitmapColor aCol2 =
1421                 m_bPalette ?
1422                 BitmapColor(
1423                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1424                 aCol;
1425 
1426             m_pBmpAcc->SetPixelOnData(pColors,0,aCol2);
1427             pColors   += nNonAlphaBytes;
1428             *pColors++ = 255 - toByteColor(nAlpha);
1429         }
1430     }
1431     else
1432     {
1433         for( sal_Size i=0; i<nLen; ++i )
1434         {
1435             const BitmapColor aCol(toByteColor(rgbColor[i].Red),
1436                                    toByteColor(rgbColor[i].Green),
1437                                    toByteColor(rgbColor[i].Blue));
1438             const BitmapColor aCol2 =
1439                 m_bPalette ?
1440                 BitmapColor(
1441                     sal::static_int_cast<sal_uInt8>(m_pBmpAcc->GetBestPaletteIndex( aCol ))) :
1442                 aCol;
1443 
1444             m_pBmpAcc->SetPixelOnData(pColors,i,aCol2);
1445         }
1446     }
1447 
1448     return aRes;
1449 }
1450 
getBitmapEx() const1451 BitmapEx VclCanvasBitmap::getBitmapEx() const
1452 {
1453     return m_aBmpEx;
1454 }
1455