Line data Source code
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 : #ifndef INCLUDED_VCL_SALBTYPE_HXX
21 : #define INCLUDED_VCL_SALBTYPE_HXX
22 : #include <stdio.h>
23 : #include <string.h>
24 : #include <stdlib.h>
25 : #include <tools/debug.hxx>
26 : #include <vcl/salgtype.hxx>
27 : #include <tools/color.hxx>
28 : #include <tools/helpers.hxx>
29 : #include <tools/solar.h>
30 : #include <vcl/dllapi.h>
31 :
32 :
33 : // - Memory -
34 :
35 :
36 : typedef sal_uInt8* HPBYTE;
37 : typedef HPBYTE Scanline;
38 : typedef const sal_uInt8* ConstHPBYTE;
39 : typedef ConstHPBYTE ConstScanline;
40 :
41 :
42 : // - Bitmap formats -
43 :
44 :
45 : #define BMP_FORMAT_BOTTOM_UP 0x00000000UL
46 : #define BMP_FORMAT_TOP_DOWN 0x80000000UL
47 :
48 : #define BMP_FORMAT_1BIT_MSB_PAL 0x00000001UL
49 : #define BMP_FORMAT_1BIT_LSB_PAL 0x00000002UL
50 :
51 : #define BMP_FORMAT_4BIT_MSN_PAL 0x00000004UL
52 : #define BMP_FORMAT_4BIT_LSN_PAL 0x00000008UL
53 :
54 : #define BMP_FORMAT_8BIT_PAL 0x00000010UL
55 : #define BMP_FORMAT_8BIT_TC_MASK 0x00000020UL
56 :
57 : // #define BMP_FORMAT_16BIT_TC_MASK 0x00000040UL
58 :
59 : #define BMP_FORMAT_24BIT_TC_BGR 0x00000080UL
60 : #define BMP_FORMAT_24BIT_TC_RGB 0x00000100UL
61 : #define BMP_FORMAT_24BIT_TC_MASK 0x00000200UL
62 :
63 : #define BMP_FORMAT_32BIT_TC_ABGR 0x00000400UL
64 : #define BMP_FORMAT_32BIT_TC_ARGB 0x00000800UL
65 : #define BMP_FORMAT_32BIT_TC_BGRA 0x00001000UL
66 : #define BMP_FORMAT_32BIT_TC_RGBA 0x00002000UL
67 : #define BMP_FORMAT_32BIT_TC_MASK 0x00004000UL
68 :
69 : #define BMP_FORMAT_16BIT_TC_MSB_MASK 0x00008000UL
70 : #define BMP_FORMAT_16BIT_TC_LSB_MASK 0x00010000UL
71 :
72 : #define BMP_SCANLINE_ADJUSTMENT( Mac_nBmpFormat ) ( (Mac_nBmpFormat) & 0x80000000UL )
73 : #define BMP_SCANLINE_FORMAT( Mac_nBmpFormat ) ( (Mac_nBmpFormat) & 0x7FFFFFFFUL )
74 :
75 :
76 :
77 : #define MASK_TO_COLOR( d_nVal, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_Col ) \
78 : sal_uLong _def_cR = (sal_uInt8) ( d_RS < 0L ? ( (d_nVal) & d_RM ) << -d_RS : ( (d_nVal) & d_RM ) >> d_RS ); \
79 : sal_uLong _def_cG = (sal_uInt8) ( d_GS < 0L ? ( (d_nVal) & d_GM ) << -d_GS : ( (d_nVal) & d_GM ) >> d_GS ); \
80 : sal_uLong _def_cB = (sal_uInt8) ( d_BS < 0L ? ( (d_nVal) & d_BM ) << -d_BS : ( (d_nVal) & d_BM ) >> d_BS ); \
81 : d_Col = BitmapColor( (sal_uInt8) ( _def_cR | ( ( _def_cR & mnROr ) >> mnROrShift ) ), \
82 : (sal_uInt8) ( _def_cG | ( ( _def_cG & mnGOr ) >> mnGOrShift ) ), \
83 : (sal_uInt8) ( _def_cB | ( ( _def_cB & mnBOr ) >> mnBOrShift ) ) );
84 :
85 :
86 :
87 : #define COLOR_TO_MASK( d_rCol, d_RM, d_GM, d_BM, d_RS, d_GS, d_BS, d_ALPHA ) \
88 : ( ( ( ( d_RS < 0L ) ? ( (sal_uInt32) (d_rCol).GetRed() >> -d_RS ) : \
89 : ( (sal_uInt32) (d_rCol).GetRed() << d_RS ) ) & d_RM ) | \
90 : ( ( ( d_GS < 0L ) ? ( (sal_uInt32) (d_rCol).GetGreen() >> -d_GS ) : \
91 : ( (sal_uInt32) (d_rCol).GetGreen() << d_GS ) ) & d_GM ) | \
92 : ( ( ( d_BS < 0L ) ? ( (sal_uInt32) (d_rCol).GetBlue() >> -d_BS ) : \
93 : ( (sal_uInt32) (d_rCol).GetBlue() << d_BS ) ) & d_BM ) | \
94 : d_ALPHA )
95 :
96 :
97 : // - BitmapColor -
98 :
99 :
100 : class Color;
101 :
102 : class VCL_DLLPUBLIC BitmapColor
103 : {
104 : private:
105 :
106 : // ATTENTION:
107 : // Because the members of this class are accessed via memcpy,
108 : // you MUST NOT CHANGE the order of the members or the size of this class!
109 : sal_uInt8 mcBlueOrIndex;
110 : sal_uInt8 mcGreen;
111 : sal_uInt8 mcRed;
112 : sal_uInt8 mbIndex;
113 :
114 : public:
115 :
116 : inline BitmapColor();
117 : inline BitmapColor( const BitmapColor& rBitmapColor );
118 : inline BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue );
119 : inline BitmapColor( const Color& rColor );
120 : explicit inline BitmapColor( sal_uInt8 cIndex );
121 :
122 2246383431 : inline ~BitmapColor() {};
123 :
124 : inline bool operator==( const BitmapColor& rBitmapColor ) const;
125 : inline bool operator!=( const BitmapColor& rBitmapColor ) const;
126 : inline BitmapColor& operator=( const BitmapColor& rBitmapColor );
127 :
128 : inline bool IsIndex() const;
129 :
130 : inline sal_uInt8 GetRed() const;
131 : inline void SetRed( sal_uInt8 cRed );
132 :
133 : inline sal_uInt8 GetGreen() const;
134 : inline void SetGreen( sal_uInt8 cGreen );
135 :
136 : inline sal_uInt8 GetBlue() const;
137 : inline void SetBlue( sal_uInt8 cBlue );
138 :
139 : inline sal_uInt8 GetIndex() const;
140 : inline void SetIndex( sal_uInt8 cIndex );
141 :
142 : operator Color() const;
143 :
144 : inline sal_uInt8 GetBlueOrIndex() const;
145 :
146 : inline BitmapColor& Invert();
147 :
148 : inline sal_uInt8 GetLuminance() const;
149 : inline BitmapColor& IncreaseLuminance( sal_uInt8 cGreyInc );
150 : inline BitmapColor& DecreaseLuminance( sal_uInt8 cGreyDec );
151 :
152 : inline BitmapColor& Merge( const BitmapColor& rColor, sal_uInt8 cTransparency );
153 : inline BitmapColor& Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency );
154 :
155 : inline sal_uLong GetColorError( const BitmapColor& rBitmapColor ) const;
156 : };
157 :
158 :
159 : // - BitmapPalette -
160 :
161 :
162 : class Palette;
163 :
164 : class VCL_DLLPUBLIC BitmapPalette
165 : {
166 : friend class SalBitmap;
167 : friend class BitmapAccess;
168 :
169 : private:
170 :
171 : BitmapColor* mpBitmapColor;
172 : sal_uInt16 mnCount;
173 :
174 : public:
175 :
176 : SAL_DLLPRIVATE inline BitmapColor* ImplGetColorBuffer() const;
177 :
178 :
179 : public:
180 :
181 : inline BitmapPalette();
182 : inline BitmapPalette( const BitmapPalette& rBitmapPalette );
183 : inline BitmapPalette( sal_uInt16 nCount );
184 : inline ~BitmapPalette();
185 :
186 : inline BitmapPalette& operator=( const BitmapPalette& rBitmapPalette );
187 : inline bool operator==( const BitmapPalette& rBitmapPalette ) const;
188 : inline bool operator!=( const BitmapPalette& rBitmapPalette ) const;
189 : inline bool operator!();
190 :
191 : inline sal_uInt16 GetEntryCount() const;
192 : inline void SetEntryCount( sal_uInt16 nCount );
193 :
194 : inline const BitmapColor& operator[]( sal_uInt16 nIndex ) const;
195 : inline BitmapColor& operator[]( sal_uInt16 nIndex );
196 :
197 : inline sal_uInt16 GetBestIndex( const BitmapColor& rCol ) const;
198 : bool IsGreyPalette() const;
199 : };
200 :
201 :
202 : // - ColorMask -
203 :
204 :
205 : class VCL_DLLPUBLIC ColorMask
206 : {
207 : sal_uLong mnRMask;
208 : sal_uLong mnGMask;
209 : sal_uLong mnBMask;
210 : long mnRShift;
211 : long mnGShift;
212 : long mnBShift;
213 : sal_uLong mnROrShift;
214 : sal_uLong mnGOrShift;
215 : sal_uLong mnBOrShift;
216 : sal_uLong mnROr;
217 : sal_uLong mnGOr;
218 : sal_uLong mnBOr;
219 : sal_uLong mnAlphaChannel;
220 :
221 : SAL_DLLPRIVATE inline long ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const;
222 :
223 : public:
224 :
225 : inline ColorMask( sal_uLong nRedMask = 0UL,
226 : sal_uLong nGreenMask = 0UL,
227 : sal_uLong nBlueMask = 0UL,
228 : sal_uLong nAlphaChannel = 0UL );
229 2336650 : inline ~ColorMask() {}
230 :
231 : inline sal_uLong GetRedMask() const;
232 : inline sal_uLong GetGreenMask() const;
233 : inline sal_uLong GetBlueMask() const;
234 :
235 : inline void GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
236 : inline void SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
237 :
238 : inline void GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
239 : inline void SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
240 : inline void GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
241 : inline void SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const;
242 :
243 : inline void GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
244 : inline void SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
245 :
246 : inline void GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const;
247 : inline void GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const;
248 : inline void SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const;
249 : };
250 :
251 :
252 : // - BitmapBuffer -
253 :
254 :
255 0 : struct VCL_DLLPUBLIC BitmapBuffer
256 : {
257 : sal_uLong mnFormat;
258 : long mnWidth;
259 : long mnHeight;
260 : long mnScanlineSize;
261 : sal_uInt16 mnBitCount;
262 : ColorMask maColorMask;
263 : BitmapPalette maPalette;
264 : sal_uInt8* mpBits;
265 :
266 1168260 : BitmapBuffer(){}
267 1168260 : ~BitmapBuffer() {}
268 : };
269 :
270 :
271 : // - StretchAndConvert -
272 :
273 :
274 : VCL_DLLPUBLIC BitmapBuffer* StretchAndConvert(
275 : const BitmapBuffer& rSrcBuffer, const SalTwoRect& rTwoRect,
276 : sal_uLong nDstBitmapFormat, const BitmapPalette* pDstPal = NULL, const ColorMask* pDstMask = NULL );
277 :
278 :
279 :
280 1489234423 : inline BitmapColor::BitmapColor() :
281 : mcBlueOrIndex ( 0 ),
282 : mcGreen ( 0 ),
283 : mcRed ( 0 ),
284 1489234423 : mbIndex ( false )
285 : {
286 1489234423 : }
287 :
288 :
289 :
290 289574471 : inline BitmapColor::BitmapColor( sal_uInt8 cRed, sal_uInt8 cGreen, sal_uInt8 cBlue ) :
291 : mcBlueOrIndex ( cBlue ),
292 : mcGreen ( cGreen ),
293 : mcRed ( cRed ),
294 289574471 : mbIndex ( false )
295 : {
296 289574471 : }
297 :
298 :
299 :
300 9678243 : inline BitmapColor::BitmapColor( const BitmapColor& rBitmapColor ) :
301 : mcBlueOrIndex ( rBitmapColor.mcBlueOrIndex ),
302 : mcGreen ( rBitmapColor.mcGreen ),
303 : mcRed ( rBitmapColor.mcRed ),
304 9678243 : mbIndex ( rBitmapColor.mbIndex )
305 : {
306 9678243 : }
307 :
308 :
309 :
310 4178791 : inline BitmapColor::BitmapColor( const Color& rColor ) :
311 4178791 : mcBlueOrIndex ( rColor.GetBlue() ),
312 4178791 : mcGreen ( rColor.GetGreen() ),
313 4178791 : mcRed ( rColor.GetRed() ),
314 12536373 : mbIndex ( 0 )
315 : {
316 4178791 : }
317 :
318 :
319 :
320 453717503 : inline BitmapColor::BitmapColor( sal_uInt8 cIndex ) :
321 : mcBlueOrIndex ( cIndex ),
322 : mcGreen ( 0 ),
323 : mcRed ( 0 ),
324 453717503 : mbIndex ( true )
325 : {
326 453717503 : }
327 :
328 :
329 :
330 364485652 : inline bool BitmapColor::operator==( const BitmapColor& rBitmapColor ) const
331 : {
332 438771323 : return( ( mcBlueOrIndex == rBitmapColor.mcBlueOrIndex ) &&
333 : ( mbIndex ? rBitmapColor.mbIndex :
334 438964122 : ( mcGreen == rBitmapColor.mcGreen && mcRed == rBitmapColor.mcRed ) ) );
335 : }
336 :
337 :
338 :
339 72669242 : inline bool BitmapColor::operator!=( const BitmapColor& rBitmapColor ) const
340 : {
341 72669242 : return !( *this == rBitmapColor );
342 : }
343 :
344 :
345 :
346 1208490756 : inline BitmapColor& BitmapColor::operator=( const BitmapColor& rBitmapColor )
347 : {
348 1208490756 : mcBlueOrIndex = rBitmapColor.mcBlueOrIndex;
349 1208490756 : mcGreen = rBitmapColor.mcGreen;
350 1208490756 : mcRed = rBitmapColor.mcRed;
351 1208490756 : mbIndex = rBitmapColor.mbIndex;
352 :
353 1208490756 : return *this;
354 : }
355 :
356 :
357 :
358 0 : inline bool BitmapColor::IsIndex() const
359 : {
360 0 : return mbIndex;
361 : }
362 :
363 :
364 :
365 1211707638 : inline sal_uInt8 BitmapColor::GetRed() const
366 : {
367 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
368 1211707638 : return mcRed;
369 : }
370 :
371 :
372 :
373 673122738 : inline void BitmapColor::SetRed( sal_uInt8 cRed )
374 : {
375 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
376 673122738 : mcRed = cRed;
377 673122738 : }
378 :
379 :
380 :
381 1210047618 : inline sal_uInt8 BitmapColor::GetGreen() const
382 : {
383 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
384 1210047618 : return mcGreen;
385 : }
386 :
387 :
388 :
389 673122738 : inline void BitmapColor::SetGreen( sal_uInt8 cGreen )
390 : {
391 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
392 673122738 : mcGreen = cGreen;
393 673122738 : }
394 :
395 :
396 :
397 1210047198 : inline sal_uInt8 BitmapColor::GetBlue() const
398 : {
399 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
400 1210047198 : return mcBlueOrIndex;
401 : }
402 :
403 :
404 :
405 673122738 : inline void BitmapColor::SetBlue( sal_uInt8 cBlue )
406 : {
407 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
408 673122738 : mcBlueOrIndex = cBlue;
409 673122738 : }
410 :
411 :
412 :
413 103864283 : inline sal_uInt8 BitmapColor::GetIndex() const
414 : {
415 : DBG_ASSERT( mbIndex, "Pixel represents color values!" );
416 103864283 : return mcBlueOrIndex;
417 : }
418 :
419 :
420 :
421 4061698 : inline void BitmapColor::SetIndex( sal_uInt8 cIndex )
422 : {
423 : DBG_ASSERT( mbIndex, "Pixel represents color values!" );
424 4061698 : mcBlueOrIndex = cIndex;
425 4061698 : }
426 :
427 :
428 :
429 313 : inline BitmapColor::operator Color() const
430 : {
431 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
432 313 : return Color( mcRed, mcGreen, mcBlueOrIndex );
433 : }
434 :
435 :
436 :
437 356248764 : inline sal_uInt8 BitmapColor::GetBlueOrIndex() const
438 : {
439 : // #i47518# Yield a value regardless of mbIndex
440 356248764 : return mcBlueOrIndex;
441 : }
442 :
443 :
444 :
445 10296 : inline BitmapColor& BitmapColor::Invert()
446 : {
447 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
448 10296 : mcBlueOrIndex = ~mcBlueOrIndex, mcGreen = ~mcGreen, mcRed = ~mcRed;
449 :
450 10296 : return *this;
451 : }
452 :
453 :
454 :
455 5050935 : inline sal_uInt8 BitmapColor::GetLuminance() const
456 : {
457 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
458 5050935 : return( (sal_uInt8) ( ( mcBlueOrIndex * 28UL + mcGreen * 151UL + mcRed * 77UL ) >> 8UL ) );
459 : }
460 :
461 :
462 :
463 : inline BitmapColor& BitmapColor::IncreaseLuminance( sal_uInt8 cGreyInc )
464 : {
465 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
466 : mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex + cGreyInc, 0L, 255L );
467 : mcGreen = (sal_uInt8) MinMax( (long) mcGreen + cGreyInc, 0L, 255L );
468 : mcRed = (sal_uInt8) MinMax( (long) mcRed + cGreyInc, 0L, 255L );
469 :
470 : return *this;
471 : }
472 :
473 :
474 :
475 : inline BitmapColor& BitmapColor::DecreaseLuminance( sal_uInt8 cGreyDec )
476 : {
477 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
478 : mcBlueOrIndex = (sal_uInt8) MinMax( (long) mcBlueOrIndex - cGreyDec, 0L, 255L );
479 : mcGreen = (sal_uInt8) MinMax( (long) mcGreen - cGreyDec, 0L, 255L );
480 : mcRed = (sal_uInt8) MinMax( (long) mcRed - cGreyDec, 0L, 255L );
481 :
482 : return *this;
483 : }
484 :
485 :
486 :
487 26084628 : inline BitmapColor& BitmapColor::Merge( const BitmapColor& rBitmapColor, sal_uInt8 cTransparency )
488 : {
489 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
490 : DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
491 26084628 : mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, rBitmapColor.mcBlueOrIndex, cTransparency );
492 26084628 : mcGreen = COLOR_CHANNEL_MERGE( mcGreen, rBitmapColor.mcGreen, cTransparency );
493 26084628 : mcRed = COLOR_CHANNEL_MERGE( mcRed, rBitmapColor.mcRed, cTransparency );
494 :
495 26084628 : return *this;
496 : }
497 :
498 :
499 :
500 140750943 : inline BitmapColor& BitmapColor::Merge( sal_uInt8 cR, sal_uInt8 cG, sal_uInt8 cB, sal_uInt8 cTransparency )
501 : {
502 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
503 140750943 : mcBlueOrIndex = COLOR_CHANNEL_MERGE( mcBlueOrIndex, cB, cTransparency );
504 140750943 : mcGreen = COLOR_CHANNEL_MERGE( mcGreen, cG, cTransparency );
505 140750943 : mcRed = COLOR_CHANNEL_MERGE( mcRed, cR, cTransparency );
506 :
507 140750943 : return *this;
508 : }
509 :
510 :
511 :
512 72932 : inline sal_uLong BitmapColor::GetColorError( const BitmapColor& rBitmapColor ) const
513 : {
514 : DBG_ASSERT( !mbIndex, "Pixel represents index into colortable!" );
515 : DBG_ASSERT( !rBitmapColor.mbIndex, "Pixel represents index into colortable!" );
516 145864 : return( (sal_uLong) ( labs( mcBlueOrIndex - rBitmapColor.mcBlueOrIndex ) +
517 145864 : labs( mcGreen - rBitmapColor.mcGreen ) +
518 145864 : labs( mcRed - rBitmapColor.mcRed ) ) );
519 : }
520 :
521 :
522 :
523 1282643 : inline BitmapPalette::BitmapPalette() :
524 : mpBitmapColor ( NULL ),
525 1282643 : mnCount ( 0 )
526 : {
527 1282643 : }
528 :
529 :
530 :
531 34 : inline BitmapPalette::BitmapPalette( const BitmapPalette& rBitmapPalette ) :
532 34 : mnCount( rBitmapPalette.mnCount )
533 : {
534 34 : if( mnCount )
535 : {
536 34 : const sal_uLong nSize = mnCount * sizeof( BitmapColor );
537 34 : mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
538 34 : memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
539 : }
540 : else
541 0 : mpBitmapColor = NULL;
542 34 : }
543 :
544 :
545 :
546 332 : inline BitmapPalette::BitmapPalette( sal_uInt16 nCount ) :
547 332 : mnCount( nCount )
548 : {
549 332 : if( mnCount )
550 : {
551 332 : const sal_uLong nSize = mnCount * sizeof( BitmapColor );
552 332 : mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
553 332 : memset( mpBitmapColor, 0, nSize );
554 : }
555 : else
556 0 : mpBitmapColor = NULL;
557 332 : }
558 :
559 :
560 :
561 1283009 : inline BitmapPalette::~BitmapPalette()
562 : {
563 1283009 : delete[] (sal_uInt8*) mpBitmapColor;
564 1283009 : }
565 :
566 :
567 :
568 1136 : inline BitmapPalette& BitmapPalette::operator=( const BitmapPalette& rBitmapPalette )
569 : {
570 1136 : delete[] (sal_uInt8*) mpBitmapColor;
571 1136 : mnCount = rBitmapPalette.mnCount;
572 :
573 1136 : if( mnCount )
574 : {
575 1136 : const sal_uLong nSize = mnCount * sizeof( BitmapColor );
576 1136 : mpBitmapColor = (BitmapColor*) new sal_uInt8[ nSize ];
577 1136 : memcpy( mpBitmapColor, rBitmapPalette.mpBitmapColor, nSize );
578 : }
579 : else
580 0 : mpBitmapColor = NULL;
581 :
582 1136 : return *this;
583 : }
584 :
585 :
586 :
587 266563 : inline bool BitmapPalette::operator==( const BitmapPalette& rBitmapPalette ) const
588 : {
589 266563 : bool bRet = false;
590 :
591 266563 : if( rBitmapPalette.mnCount == mnCount )
592 : {
593 266563 : bRet = true;
594 :
595 68502611 : for( sal_uInt16 i = 0; i < mnCount; i++ )
596 : {
597 68236064 : if( mpBitmapColor[ i ] != rBitmapPalette.mpBitmapColor[ i ] )
598 : {
599 16 : bRet = false;
600 16 : break;
601 : }
602 : }
603 : }
604 :
605 266563 : return bRet;
606 : }
607 :
608 :
609 :
610 265994 : inline bool BitmapPalette::operator!=( const BitmapPalette& rBitmapPalette ) const
611 : {
612 265994 : return !( *this == rBitmapPalette );
613 : }
614 :
615 :
616 :
617 850206208 : inline bool BitmapPalette::operator!()
618 : {
619 850206208 : return( !mnCount || !mpBitmapColor );
620 : }
621 :
622 :
623 :
624 1500825 : inline sal_uInt16 BitmapPalette::GetEntryCount() const
625 : {
626 1500825 : return mnCount;
627 : }
628 :
629 :
630 :
631 805299 : inline void BitmapPalette::SetEntryCount( sal_uInt16 nCount )
632 : {
633 805299 : if( !nCount )
634 : {
635 0 : delete[] (sal_uInt8*) mpBitmapColor;
636 0 : mpBitmapColor = NULL;
637 0 : mnCount = 0;
638 : }
639 805299 : else if( nCount != mnCount )
640 : {
641 793256 : const sal_uLong nNewSize = nCount * sizeof( BitmapColor );
642 793256 : const sal_uLong nMinSize = std::min( mnCount, nCount ) * sizeof( BitmapColor );
643 793256 : sal_uInt8* pNewColor = new sal_uInt8[ nNewSize ];
644 :
645 793256 : if ( nMinSize && mpBitmapColor )
646 6025 : memcpy( pNewColor, mpBitmapColor, nMinSize );
647 793256 : delete[] (sal_uInt8*) mpBitmapColor;
648 793256 : memset( pNewColor + nMinSize, 0, nNewSize - nMinSize );
649 793256 : mpBitmapColor = (BitmapColor*) pNewColor;
650 793256 : mnCount = nCount;
651 : }
652 805299 : }
653 :
654 :
655 :
656 21121737 : inline const BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex ) const
657 : {
658 : DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
659 21121737 : return mpBitmapColor[ nIndex ];
660 : }
661 :
662 :
663 :
664 614675292 : inline BitmapColor& BitmapPalette::operator[]( sal_uInt16 nIndex )
665 : {
666 : DBG_ASSERT( nIndex < mnCount, "Palette index is out of range!" );
667 614675292 : return mpBitmapColor[ nIndex ];
668 : }
669 :
670 :
671 :
672 1236 : inline BitmapColor* BitmapPalette::ImplGetColorBuffer() const
673 : {
674 : DBG_ASSERT( mpBitmapColor, "No color buffer available!" );
675 1236 : return mpBitmapColor;
676 : }
677 :
678 :
679 2305881 : inline sal_uInt16 BitmapPalette::GetBestIndex( const BitmapColor& rCol ) const
680 : {
681 2305881 : sal_uInt16 nRetIndex = 0;
682 :
683 2305881 : if( mpBitmapColor && mnCount )
684 : {
685 2305881 : bool bFound = false;
686 :
687 291208493 : for( long j = 0L; ( j < mnCount ) && !bFound; j++ )
688 288902612 : if( rCol == mpBitmapColor[ j ] )
689 2305461 : nRetIndex = ( (sal_uInt16) j ), bFound = true;
690 :
691 2305881 : if( !bFound )
692 : {
693 420 : long nActErr, nLastErr = rCol.GetColorError( mpBitmapColor[ nRetIndex = mnCount - 1 ] );
694 :
695 72932 : for( long i = nRetIndex - 1; i >= 0L; i-- )
696 72512 : if ( ( nActErr = rCol.GetColorError( mpBitmapColor[ i ] ) ) < nLastErr )
697 248 : nLastErr = nActErr, nRetIndex = (sal_uInt16) i;
698 : }
699 : }
700 :
701 2305881 : return nRetIndex;
702 : }
703 :
704 :
705 :
706 2336650 : inline ColorMask::ColorMask( sal_uLong nRedMask,
707 : sal_uLong nGreenMask,
708 : sal_uLong nBlueMask,
709 : sal_uLong nAlphaChannel ) :
710 : mnRMask( nRedMask ),
711 : mnGMask( nGreenMask ),
712 : mnBMask( nBlueMask ),
713 : mnROrShift( 0L ),
714 : mnGOrShift( 0L ),
715 : mnBOrShift( 0L ),
716 : mnROr( 0L ),
717 : mnGOr( 0L ),
718 : mnBOr( 0L ),
719 2336650 : mnAlphaChannel( nAlphaChannel )
720 : {
721 2336650 : mnRShift = ( mnRMask ? ImplCalcMaskShift( mnRMask, mnROr, mnROrShift ) : 0L );
722 2336650 : mnGShift = ( mnGMask ? ImplCalcMaskShift( mnGMask, mnGOr, mnGOrShift ) : 0L );
723 2336650 : mnBShift = ( mnBMask ? ImplCalcMaskShift( mnBMask, mnBOr, mnBOrShift ) : 0L );
724 2336650 : }
725 :
726 :
727 :
728 372 : inline long ColorMask::ImplCalcMaskShift( sal_uLong nMask, sal_uLong& rOr, sal_uLong& rOrShift ) const
729 : {
730 : long nShift;
731 : long nRet;
732 372 : sal_uLong nLen = 0UL;
733 :
734 : // from which bit starts the mask?
735 372 : for( nShift = 31L; ( nShift >= 0L ) && !( nMask & ( 1 << (sal_uLong) nShift ) ); nShift-- )
736 : {}
737 :
738 372 : nRet = nShift;
739 :
740 : // XXX determine number of bits set => walk right until null
741 3544 : while( ( nShift >= 0L ) && ( nMask & ( 1 << (sal_uLong) nShift ) ) )
742 : {
743 2800 : nShift--;
744 2800 : nLen++;
745 : }
746 :
747 372 : rOrShift = 8L - nLen;
748 372 : rOr = (sal_uInt8) ( ( 0xffUL >> nLen ) << rOrShift );
749 :
750 372 : return( nRet -= 7 );
751 : }
752 :
753 :
754 :
755 2292 : inline sal_uLong ColorMask::GetRedMask() const
756 : {
757 2292 : return mnRMask;
758 : }
759 :
760 :
761 :
762 2292 : inline sal_uLong ColorMask::GetGreenMask() const
763 : {
764 2292 : return mnGMask;
765 : }
766 :
767 :
768 :
769 2292 : inline sal_uLong ColorMask::GetBlueMask() const
770 : {
771 2292 : return mnBMask;
772 : }
773 :
774 :
775 :
776 0 : inline void ColorMask::GetColorFor8Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
777 : {
778 0 : const sal_uInt32 nVal = *pPixel;
779 0 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
780 0 : }
781 :
782 :
783 :
784 0 : inline void ColorMask::SetColorFor8Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
785 : {
786 0 : *pPixel = (sal_uInt8) COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
787 0 : }
788 :
789 :
790 :
791 0 : inline void ColorMask::GetColorFor16BitMSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
792 : {
793 0 : const sal_uInt32 nVal = pPixel[ 1 ] | ( (sal_uInt32) pPixel[ 0 ] << 8UL );
794 :
795 0 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
796 0 : }
797 :
798 :
799 :
800 0 : inline void ColorMask::SetColorFor16BitMSB( const BitmapColor& rColor, HPBYTE pPixel ) const
801 : {
802 0 : const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
803 :
804 0 : pPixel[ 0 ] = (sal_uInt8)(nVal >> 8U);
805 0 : pPixel[ 1 ] = (sal_uInt8) nVal;
806 0 : }
807 :
808 :
809 :
810 3002400 : inline void ColorMask::GetColorFor16BitLSB( BitmapColor& rColor, ConstHPBYTE pPixel ) const
811 : {
812 3002400 : const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL );
813 :
814 3002400 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
815 3002400 : }
816 :
817 :
818 :
819 100416 : inline void ColorMask::SetColorFor16BitLSB( const BitmapColor& rColor, HPBYTE pPixel ) const
820 : {
821 100416 : const sal_uInt16 nVal = (sal_uInt16)COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
822 :
823 100416 : pPixel[ 0 ] = (sal_uInt8) nVal;
824 100416 : pPixel[ 1 ] = (sal_uInt8)(nVal >> 8U);
825 100416 : }
826 :
827 :
828 :
829 :
830 0 : inline void ColorMask::GetColorFor24Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
831 : {
832 0 : const sal_uInt32 nVal = pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) | ( (sal_uInt32) pPixel[ 2 ] << 16UL );
833 0 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
834 0 : }
835 :
836 :
837 :
838 0 : inline void ColorMask::SetColorFor24Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
839 : {
840 0 : const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
841 0 : pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL ); pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL );
842 0 : }
843 :
844 :
845 :
846 1057634 : inline void ColorMask::GetColorFor32Bit( BitmapColor& rColor, ConstHPBYTE pPixel ) const
847 : {
848 2115268 : const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
849 2115268 : ( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
850 :
851 1057634 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
852 1057634 : }
853 :
854 :
855 :
856 0 : inline void ColorMask::GetColorAndAlphaFor32Bit( BitmapColor& rColor, sal_uInt8& rAlpha, ConstHPBYTE pPixel ) const
857 : {
858 0 : const sal_uInt32 nVal = (sal_uInt32) pPixel[ 0 ] | ( (sal_uInt32) pPixel[ 1 ] << 8UL ) |
859 0 : ( (sal_uInt32) pPixel[ 2 ] << 16UL ) | ( (sal_uInt32) pPixel[ 3 ] << 24UL );
860 0 : rAlpha = (sal_uInt8)(nVal >> 24);
861 :
862 0 : MASK_TO_COLOR( nVal, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, rColor );
863 0 : }
864 :
865 :
866 :
867 0 : inline void ColorMask::SetColorFor32Bit( const BitmapColor& rColor, HPBYTE pPixel ) const
868 : {
869 0 : const sal_uInt32 nVal = COLOR_TO_MASK( rColor, mnRMask, mnGMask, mnBMask, mnRShift, mnGShift, mnBShift, mnAlphaChannel );
870 0 : pPixel[ 0 ] = (sal_uInt8) nVal; pPixel[ 1 ] = (sal_uInt8) ( nVal >> 8UL );
871 0 : pPixel[ 2 ] = (sal_uInt8) ( nVal >> 16UL ); pPixel[ 3 ] = (sal_uInt8) ( nVal >> 24UL );
872 0 : }
873 :
874 : #endif // INCLUDED_VCL_SALBTYPE_HXX
875 :
876 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
