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