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