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 :
21 : #include <bmpfast.hxx>
22 :
23 : #ifndef NO_OPTIMIZED_BITMAP_ACCESS
24 :
25 : #include <tools/debug.hxx>
26 : #include <vcl/bmpacc.hxx>
27 :
28 : #define FAST_ARGB_BGRA
29 :
30 : #include <stdlib.h>
31 :
32 : typedef unsigned char PIXBYTE;
33 :
34 : class BasePixelPtr
35 : {
36 : public:
37 222952 : BasePixelPtr( PIXBYTE* p = NULL ) : mpPixel( p ) {}
38 222952 : void SetRawPtr( PIXBYTE* pRawPtr ) { mpPixel = pRawPtr; }
39 0 : PIXBYTE* GetRawPtr( void ) const { return mpPixel; }
40 3161961 : void AddByteOffset( int nByteOffset ) { mpPixel += nByteOffset; }
41 : bool operator<( const BasePixelPtr& rCmp ) const { return (mpPixel < rCmp.mpPixel); }
42 :
43 : protected:
44 : PIXBYTE* mpPixel;
45 : };
46 :
47 : template <sal_uLong PIXFMT>
48 : class TrueColorPixelPtr : public BasePixelPtr
49 : {
50 : public:
51 : PIXBYTE GetRed() const;
52 : PIXBYTE GetGreen() const;
53 : PIXBYTE GetBlue() const;
54 : PIXBYTE GetAlpha() const;
55 :
56 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const;
57 : void SetAlpha( PIXBYTE a ) const;
58 : void operator++(int);
59 : };
60 :
61 : // template specializations for truecolor pixel formats
62 : template <>
63 111476 : class TrueColorPixelPtr<BMP_FORMAT_24BIT_TC_RGB> : public BasePixelPtr
64 : {
65 : public:
66 81110732 : void operator++() { mpPixel += 3; }
67 :
68 57138194 : PIXBYTE GetRed() const { return mpPixel[0]; }
69 57138194 : PIXBYTE GetGreen() const { return mpPixel[1]; }
70 57138194 : PIXBYTE GetBlue() const { return mpPixel[2]; }
71 10449016 : PIXBYTE GetAlpha() const { return 0; }
72 10449016 : void SetAlpha( PIXBYTE ) const {}
73 :
74 33793605 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
75 : {
76 33793605 : mpPixel[0] = r;
77 33793605 : mpPixel[1] = g;
78 33793605 : mpPixel[2] = b;
79 33793605 : }
80 : };
81 :
82 : template <>
83 55738 : class TrueColorPixelPtr<BMP_FORMAT_24BIT_TC_BGR> : public BasePixelPtr
84 : {
85 : public:
86 0 : void operator++() { mpPixel += 3; }
87 :
88 0 : PIXBYTE GetRed() const { return mpPixel[2]; }
89 0 : PIXBYTE GetGreen() const { return mpPixel[1]; }
90 0 : PIXBYTE GetBlue() const { return mpPixel[0]; }
91 0 : PIXBYTE GetAlpha() const { return 0; }
92 0 : void SetAlpha( PIXBYTE ) const {}
93 :
94 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
95 : {
96 0 : mpPixel[0] = b;
97 0 : mpPixel[1] = g;
98 0 : mpPixel[2] = r;
99 0 : }
100 : };
101 :
102 : template <>
103 0 : class TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_ARGB> : public BasePixelPtr
104 : {
105 : public:
106 0 : void operator++() { mpPixel += 4; }
107 :
108 0 : PIXBYTE GetRed() const { return mpPixel[1]; }
109 0 : PIXBYTE GetGreen() const { return mpPixel[2]; }
110 0 : PIXBYTE GetBlue() const { return mpPixel[3]; }
111 0 : PIXBYTE GetAlpha() const { return mpPixel[0]; }
112 0 : void SetAlpha( PIXBYTE a ) const { mpPixel[0] = a; }
113 :
114 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
115 : {
116 0 : mpPixel[1] = r;
117 0 : mpPixel[2] = g;
118 0 : mpPixel[3] = b;
119 0 : }
120 : };
121 :
122 : template <>
123 0 : class TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_ABGR> : public BasePixelPtr
124 : {
125 : public:
126 0 : void operator++() { mpPixel += 4; }
127 :
128 0 : PIXBYTE GetRed() const { return mpPixel[3]; }
129 0 : PIXBYTE GetGreen() const { return mpPixel[2]; }
130 0 : PIXBYTE GetBlue() const { return mpPixel[1]; }
131 0 : PIXBYTE GetAlpha() const { return mpPixel[0]; }
132 0 : void SetAlpha( PIXBYTE a ) const { mpPixel[0] = a; }
133 :
134 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
135 : {
136 0 : mpPixel[1] = b;
137 0 : mpPixel[2] = g;
138 0 : mpPixel[3] = r;
139 0 : }
140 : };
141 :
142 : template <>
143 0 : class TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_RGBA> : public BasePixelPtr
144 : {
145 : public:
146 0 : void operator++() { mpPixel += 4; }
147 :
148 0 : PIXBYTE GetRed() const { return mpPixel[0]; }
149 0 : PIXBYTE GetGreen() const { return mpPixel[1]; }
150 0 : PIXBYTE GetBlue() const { return mpPixel[2]; }
151 0 : PIXBYTE GetAlpha() const { return mpPixel[3]; }
152 0 : void SetAlpha( PIXBYTE a ) const{ mpPixel[3] = a; }
153 :
154 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
155 : {
156 0 : mpPixel[0] = r;
157 0 : mpPixel[1] = g;
158 0 : mpPixel[2] = b;
159 0 : }
160 : };
161 :
162 : template <>
163 0 : class TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_BGRA> : public BasePixelPtr
164 : {
165 : public:
166 0 : void operator++() { mpPixel += 4; }
167 :
168 0 : PIXBYTE GetRed() const { return mpPixel[2]; }
169 0 : PIXBYTE GetGreen() const { return mpPixel[1]; }
170 0 : PIXBYTE GetBlue() const { return mpPixel[0]; }
171 0 : PIXBYTE GetAlpha() const { return mpPixel[3]; }
172 0 : void SetAlpha( PIXBYTE a ) const{ mpPixel[3] = a; }
173 :
174 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
175 : {
176 0 : mpPixel[0] = b;
177 0 : mpPixel[1] = g;
178 0 : mpPixel[2] = r;
179 0 : }
180 : };
181 :
182 : template <>
183 0 : class TrueColorPixelPtr<BMP_FORMAT_16BIT_TC_MSB_MASK> : public BasePixelPtr
184 : {
185 : public:
186 0 : void operator++() { mpPixel += 2; }
187 :
188 : // TODO: non565-RGB
189 0 : PIXBYTE GetRed() const { return (mpPixel[0] & 0xF8U); }
190 0 : PIXBYTE GetGreen() const { return (mpPixel[0]<<5U) | ((mpPixel[1]>>3U)&28U); }
191 0 : PIXBYTE GetBlue() const { return (mpPixel[1]<<3U); }
192 0 : PIXBYTE GetAlpha() const { return 0; }
193 0 : void SetAlpha( PIXBYTE ) const {}
194 :
195 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
196 : {
197 0 : mpPixel[0] = ((g >> 5U) & 7U) | (r & 0xF8U);
198 0 : mpPixel[1] = ((g & 28U)<< 3U) | (b >> 3U);
199 0 : }
200 : };
201 :
202 : template <>
203 0 : class TrueColorPixelPtr<BMP_FORMAT_16BIT_TC_LSB_MASK> : public BasePixelPtr
204 : {
205 : public:
206 0 : void operator++() { mpPixel += 2; }
207 :
208 : // TODO: non565-RGB
209 0 : PIXBYTE GetRed() const { return (mpPixel[1] & 0xF8U); }
210 0 : PIXBYTE GetGreen() const { return (mpPixel[1]<<5U) | ((mpPixel[0]>>3U)&28U); }
211 0 : PIXBYTE GetBlue() const { return (mpPixel[0]<<3U); }
212 0 : PIXBYTE GetAlpha() const { return 0; }
213 0 : void SetAlpha( PIXBYTE ) const {}
214 :
215 0 : void SetColor( PIXBYTE r, PIXBYTE g, PIXBYTE b ) const
216 : {
217 0 : mpPixel[0] = ((g & 28U)<< 3U) | (b >> 3U);
218 0 : mpPixel[1] = ((g >> 5U) & 7U) | (r & 0xF8U);
219 0 : }
220 : };
221 :
222 : template <>
223 55738 : class TrueColorPixelPtr<BMP_FORMAT_8BIT_TC_MASK> : public BasePixelPtr
224 : {
225 : public:
226 40555366 : void operator++() { mpPixel += 1; }
227 40555366 : PIXBYTE GetAlpha() const { return mpPixel[0]; }
228 : void SetAlpha( PIXBYTE a ) const { mpPixel[0] = a; }
229 : void SetColor( PIXBYTE, PIXBYTE, PIXBYTE ) const {}
230 : };
231 :
232 : // TODO: for some reason many Alpha maps are BMP_FORMAT_8BIT_PAL
233 : // they should be BMP_FORMAT_8BIT_TC_MASK
234 : template <>
235 55738 : class TrueColorPixelPtr<BMP_FORMAT_8BIT_PAL>
236 : : public TrueColorPixelPtr<BMP_FORMAT_8BIT_TC_MASK>
237 : {};
238 :
239 : // converting truecolor formats
240 : template <sal_uLong SRCFMT, sal_uLong DSTFMT>
241 10449016 : inline void ImplConvertPixel( const TrueColorPixelPtr<DSTFMT>& rDst,
242 : const TrueColorPixelPtr<SRCFMT>& rSrc )
243 : {
244 10449016 : rDst.SetColor( rSrc.GetRed(), rSrc.GetGreen(), rSrc.GetBlue() );
245 10449016 : rDst.SetAlpha( rSrc.GetAlpha() );
246 10449016 : }
247 :
248 : template <>
249 0 : inline void ImplConvertPixel<BMP_FORMAT_16BIT_TC_LSB_MASK, BMP_FORMAT_16BIT_TC_MSB_MASK> (
250 : const TrueColorPixelPtr<BMP_FORMAT_16BIT_TC_MSB_MASK>& rDst,
251 : const TrueColorPixelPtr<BMP_FORMAT_16BIT_TC_LSB_MASK>& rSrc )
252 : {
253 : // byte swapping
254 0 : const PIXBYTE* pSrc = rSrc.GetRawPtr();
255 0 : PIXBYTE* pDst = rDst.GetRawPtr();
256 0 : pDst[1] = pSrc[0];
257 0 : pDst[0] = pSrc[1];
258 0 : }
259 :
260 : template <sal_uLong SRCFMT, sal_uLong DSTFMT>
261 0 : inline void ImplConvertLine( const TrueColorPixelPtr<DSTFMT>& rDst,
262 : const TrueColorPixelPtr<SRCFMT>& rSrc, int nPixelCount )
263 : {
264 0 : TrueColorPixelPtr<DSTFMT> aDst( rDst );
265 0 : TrueColorPixelPtr<SRCFMT> aSrc( rSrc );
266 0 : while( --nPixelCount >= 0 )
267 : {
268 0 : ImplConvertPixel( aDst, aSrc );
269 0 : ++aSrc;
270 0 : ++aDst;
271 : }
272 0 : }
273 :
274 : // alpha blending truecolor pixels
275 : template <unsigned ALPHABITS, sal_uLong SRCFMT, sal_uLong DSTFMT>
276 40555366 : inline void ImplBlendPixels( const TrueColorPixelPtr<DSTFMT>& rDst,
277 : const TrueColorPixelPtr<SRCFMT>& rSrc, unsigned nAlphaVal )
278 : {
279 40555366 : if( !nAlphaVal )
280 10449016 : ImplConvertPixel( rDst, rSrc );
281 30106350 : else if( nAlphaVal != ~(~0 << ALPHABITS) )
282 : {
283 : static const unsigned nAlphaShift = (ALPHABITS > 8) ? 8 : ALPHABITS;
284 : if( ALPHABITS > nAlphaShift )
285 : nAlphaVal >>= ALPHABITS - nAlphaShift;
286 :
287 23344589 : int nR = rDst.GetRed();
288 23344589 : int nS = rSrc.GetRed();
289 23344589 : nR = nS + (((nR - nS) * nAlphaVal) >> nAlphaShift);
290 :
291 23344589 : int nG = rDst.GetGreen();
292 23344589 : nS = rSrc.GetGreen();
293 23344589 : nG = nS + (((nG - nS) * nAlphaVal) >> nAlphaShift);
294 :
295 23344589 : int nB = rDst.GetBlue();
296 23344589 : nS = rSrc.GetBlue();
297 23344589 : nB = nS + (((nB - nS) * nAlphaVal) >> nAlphaShift);
298 :
299 46689178 : rDst.SetColor( sal::static_int_cast<PIXBYTE>(nR),
300 23344589 : sal::static_int_cast<PIXBYTE>(nG),
301 23344589 : sal::static_int_cast<PIXBYTE>(nB) );
302 : }
303 40555366 : }
304 :
305 : template <unsigned ALPHABITS, sal_uLong MASKFMT, sal_uLong SRCFMT, sal_uLong DSTFMT>
306 1053987 : inline void ImplBlendLines( const TrueColorPixelPtr<DSTFMT>& rDst,
307 : const TrueColorPixelPtr<SRCFMT>& rSrc, const TrueColorPixelPtr<MASKFMT>& rMsk,
308 : int nPixelCount )
309 : {
310 1053987 : TrueColorPixelPtr<MASKFMT> aMsk( rMsk );
311 1053987 : TrueColorPixelPtr<DSTFMT> aDst( rDst );
312 1053987 : TrueColorPixelPtr<SRCFMT> aSrc( rSrc );
313 42663340 : while( --nPixelCount >= 0 )
314 : {
315 40555366 : ImplBlendPixels<ALPHABITS>( aDst, aSrc, aMsk.GetAlpha() );
316 40555366 : ++aDst;
317 40555366 : ++aSrc;
318 40555366 : ++aMsk;
319 : }
320 1053987 : }
321 :
322 : template <unsigned ALPHABITS, sal_uLong SRCFMT, sal_uLong DSTFMT>
323 : inline void ImplBlendLines( const TrueColorPixelPtr<DSTFMT>& rDst,
324 : const TrueColorPixelPtr<SRCFMT>& rSrc, unsigned nAlphaVal,
325 : int nPixelCount )
326 : {
327 : if( nAlphaVal == ~(~0 << ALPHABITS) )
328 : ImplConvertLine( rDst, rSrc, nPixelCount );
329 : else if( nAlphaVal )
330 : {
331 : TrueColorPixelPtr<SRCFMT> aSrc( rSrc );
332 : TrueColorPixelPtr<DSTFMT> aDst( rDst );
333 : while( --nPixelCount >= 0 )
334 : {
335 : ImplBlendPixels<ALPHABITS>( aDst, aSrc, nAlphaVal );
336 : ++aDst;
337 : ++aSrc;
338 : }
339 : }
340 : }
341 :
342 0 : static bool ImplCopyImage( BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer )
343 : {
344 0 : const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
345 0 : int nDstLinestep = rDstBuffer.mnScanlineSize;
346 :
347 0 : const PIXBYTE* pRawSrc = rSrcBuffer.mpBits;
348 0 : PIXBYTE* pRawDst = rDstBuffer.mpBits;
349 :
350 : // source and destination don't match upside down
351 0 : if( BMP_FORMAT_TOP_DOWN & (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat) )
352 : {
353 0 : pRawDst += (rSrcBuffer.mnHeight - 1) * nDstLinestep;
354 0 : nDstLinestep = -rDstBuffer.mnScanlineSize;
355 : }
356 0 : else if( nSrcLinestep == nDstLinestep )
357 : {
358 0 : memcpy( pRawDst, pRawSrc, rSrcBuffer.mnHeight * nDstLinestep );
359 0 : return true;
360 : }
361 :
362 0 : int nByteWidth = nSrcLinestep;
363 0 : if( nByteWidth > rDstBuffer.mnScanlineSize )
364 0 : nByteWidth = rDstBuffer.mnScanlineSize;
365 :
366 0 : for( int y = rSrcBuffer.mnHeight; --y >= 0; )
367 : {
368 0 : memcpy( pRawDst, pRawSrc, nByteWidth );
369 0 : pRawSrc += nSrcLinestep;
370 0 : pRawDst += nDstLinestep;
371 : }
372 :
373 0 : return true;
374 : }
375 :
376 : template <sal_uLong DSTFMT,sal_uLong SRCFMT>
377 0 : bool ImplConvertToBitmap( TrueColorPixelPtr<SRCFMT>& rSrcLine,
378 : BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer )
379 : {
380 : // help the compiler to avoid instantiations of unneeded conversions
381 : DBG_ASSERT( SRCFMT != DSTFMT, "ImplConvertToBitmap into same format");
382 : if( SRCFMT == DSTFMT )
383 0 : return false;
384 :
385 0 : const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
386 0 : int nDstLinestep = rDstBuffer.mnScanlineSize;
387 :
388 0 : TrueColorPixelPtr<DSTFMT> aDstLine; aDstLine.SetRawPtr( rDstBuffer.mpBits );
389 :
390 : // source and destination don't match upside down
391 0 : if( BMP_FORMAT_TOP_DOWN & (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat) )
392 : {
393 0 : aDstLine.AddByteOffset( (rSrcBuffer.mnHeight - 1) * nDstLinestep );
394 0 : nDstLinestep = -nDstLinestep;
395 : }
396 :
397 0 : for( int y = rSrcBuffer.mnHeight; --y >= 0; )
398 : {
399 0 : ImplConvertLine( aDstLine, rSrcLine, rSrcBuffer.mnWidth );
400 0 : rSrcLine.AddByteOffset( nSrcLinestep );
401 0 : aDstLine.AddByteOffset( nDstLinestep );
402 : }
403 :
404 0 : return true;
405 : }
406 :
407 : template <sal_uLong SRCFMT>
408 0 : inline bool ImplConvertFromBitmap( BitmapBuffer& rDst, const BitmapBuffer& rSrc )
409 : {
410 0 : TrueColorPixelPtr<SRCFMT> aSrcType; aSrcType.SetRawPtr( rSrc.mpBits );
411 :
412 : // select the matching instantiation for the destination's bitmap format
413 0 : switch( rDst.mnFormat & ~BMP_FORMAT_TOP_DOWN )
414 : {
415 : case BMP_FORMAT_1BIT_MSB_PAL:
416 : case BMP_FORMAT_1BIT_LSB_PAL:
417 : case BMP_FORMAT_4BIT_MSN_PAL:
418 : case BMP_FORMAT_4BIT_LSN_PAL:
419 : case BMP_FORMAT_8BIT_PAL:
420 0 : break;
421 :
422 : case BMP_FORMAT_8BIT_TC_MASK:
423 : // return ImplConvertToBitmap<BMP_FORMAT_8BIT_TC_MASK>( aSrcType, rDst, rSrc );
424 : case BMP_FORMAT_24BIT_TC_MASK:
425 : // return ImplConvertToBitmap<BMP_FORMAT_24BIT_TC_MASK>( aSrcType, rDst, rSrc );
426 : case BMP_FORMAT_32BIT_TC_MASK:
427 : // return ImplConvertToBitmap<BMP_FORMAT_32BIT_TC_MASK>( aSrcType, rDst, rSrc );
428 0 : break;
429 :
430 : case BMP_FORMAT_16BIT_TC_MSB_MASK:
431 0 : return ImplConvertToBitmap<BMP_FORMAT_16BIT_TC_MSB_MASK>( aSrcType, rDst, rSrc );
432 : case BMP_FORMAT_16BIT_TC_LSB_MASK:
433 0 : return ImplConvertToBitmap<BMP_FORMAT_16BIT_TC_LSB_MASK>( aSrcType, rDst, rSrc );
434 :
435 : case BMP_FORMAT_24BIT_TC_BGR:
436 0 : return ImplConvertToBitmap<BMP_FORMAT_24BIT_TC_BGR>( aSrcType, rDst, rSrc );
437 : case BMP_FORMAT_24BIT_TC_RGB:
438 0 : return ImplConvertToBitmap<BMP_FORMAT_24BIT_TC_RGB>( aSrcType, rDst, rSrc );
439 :
440 : case BMP_FORMAT_32BIT_TC_ABGR:
441 0 : return ImplConvertToBitmap<BMP_FORMAT_32BIT_TC_ABGR>( aSrcType, rDst, rSrc );
442 : #ifdef FAST_ARGB_BGRA
443 : case BMP_FORMAT_32BIT_TC_ARGB:
444 0 : return ImplConvertToBitmap<BMP_FORMAT_32BIT_TC_ARGB>( aSrcType, rDst, rSrc );
445 : case BMP_FORMAT_32BIT_TC_BGRA:
446 0 : return ImplConvertToBitmap<BMP_FORMAT_32BIT_TC_BGRA>( aSrcType, rDst, rSrc );
447 : #endif
448 : case BMP_FORMAT_32BIT_TC_RGBA:
449 0 : return ImplConvertToBitmap<BMP_FORMAT_32BIT_TC_RGBA>( aSrcType, rDst, rSrc );
450 : }
451 :
452 : #ifdef DEBUG
453 : static int nNotAccelerated = 0;
454 : if( rSrc.mnWidth * rSrc.mnHeight >= 4000 )
455 : if( ++nNotAccelerated == 100 )
456 : {
457 : int foo = 0; (void)foo; // so no warning is created when building on pro with debug
458 : DBG_WARNING2( "ImplConvertFromBitmap for not accelerated case (0x%04X->0x%04X)",
459 : rSrc.mnFormat, rDst.mnFormat );
460 : }
461 : #endif
462 :
463 0 : return false;
464 : }
465 :
466 : // A universal stretching conversion is overkill in most common situations
467 : // => performance benefits for speeding up the non-stretching cases
468 0 : bool ImplFastBitmapConversion( BitmapBuffer& rDst, const BitmapBuffer& rSrc,
469 : const SalTwoRect& rTR )
470 : {
471 : // TODO:horizontal mirroring not implemented yet
472 0 : if( rTR.mnDestWidth < 0 )
473 0 : return false;
474 : // vertical mirroring
475 0 : if( rTR.mnDestHeight < 0 )
476 : // TODO: rDst.mnFormat ^= BMP_FORMAT_TOP_DOWN;
477 0 : return false;
478 :
479 : // offseted conversion is not implemented yet
480 0 : if( rTR.mnSrcX || rTR.mnSrcY )
481 0 : return false;
482 0 : if( rTR.mnDestX || rTR.mnDestY )
483 0 : return false;
484 :
485 : // stretched conversion is not implemented yet
486 0 : if( rTR.mnDestWidth != rTR.mnSrcWidth )
487 0 : return false;
488 0 : if( rTR.mnDestHeight!= rTR.mnSrcHeight )
489 0 : return false;
490 :
491 : // check source image size
492 0 : if( rSrc.mnWidth < rTR.mnSrcX + rTR.mnSrcWidth )
493 0 : return false;
494 0 : if( rSrc.mnHeight < rTR.mnSrcY + rTR.mnSrcHeight )
495 0 : return false;
496 :
497 : // check dest image size
498 0 : if( rDst.mnWidth < rTR.mnDestX + rTR.mnDestWidth )
499 0 : return false;
500 0 : if( rDst.mnHeight < rTR.mnDestY + rTR.mnDestHeight )
501 0 : return false;
502 :
503 0 : const sal_uLong nSrcFormat = rSrc.mnFormat & ~BMP_FORMAT_TOP_DOWN;
504 0 : const sal_uLong nDstFormat = rDst.mnFormat & ~BMP_FORMAT_TOP_DOWN;
505 :
506 : // TODO: also implement conversions for 16bit colormasks with non-565 format
507 0 : if( nSrcFormat & (BMP_FORMAT_16BIT_TC_LSB_MASK | BMP_FORMAT_16BIT_TC_MSB_MASK) )
508 0 : if( rSrc.maColorMask.GetRedMask() != 0xF800
509 0 : || rSrc.maColorMask.GetGreenMask()!= 0x07E0
510 0 : || rSrc.maColorMask.GetBlueMask() != 0x001F )
511 0 : return false;
512 0 : if( nDstFormat & (BMP_FORMAT_16BIT_TC_LSB_MASK | BMP_FORMAT_16BIT_TC_MSB_MASK) )
513 0 : if( rDst.maColorMask.GetRedMask() != 0xF800
514 0 : || rDst.maColorMask.GetGreenMask()!= 0x07E0
515 0 : || rDst.maColorMask.GetBlueMask() != 0x001F )
516 0 : return false;
517 :
518 : // special handling of trivial cases
519 0 : if( nSrcFormat == nDstFormat )
520 : {
521 : // accelerated palette conversions not yet implemented
522 0 : if( rSrc.maPalette != rDst.maPalette )
523 0 : return false;
524 0 : return ImplCopyImage( rDst, rSrc );
525 : }
526 :
527 : // select the matching instantiation for the source's bitmap format
528 0 : switch( nSrcFormat )
529 : {
530 : case BMP_FORMAT_1BIT_MSB_PAL:
531 : case BMP_FORMAT_1BIT_LSB_PAL:
532 : case BMP_FORMAT_4BIT_MSN_PAL:
533 : case BMP_FORMAT_4BIT_LSN_PAL:
534 : case BMP_FORMAT_8BIT_PAL:
535 0 : break;
536 :
537 : case BMP_FORMAT_8BIT_TC_MASK:
538 : // return ImplConvertFromBitmap<BMP_FORMAT_8BIT_TC_MASK>( rDst, rSrc );
539 : case BMP_FORMAT_24BIT_TC_MASK:
540 : // return ImplConvertFromBitmap<BMP_FORMAT_24BIT_TC_MASK>( rDst, rSrc );
541 : case BMP_FORMAT_32BIT_TC_MASK:
542 : // return ImplConvertFromBitmap<BMP_FORMAT_32BIT_TC_MASK>( rDst, rSrc );
543 0 : break;
544 :
545 : case BMP_FORMAT_16BIT_TC_MSB_MASK:
546 0 : return ImplConvertFromBitmap<BMP_FORMAT_16BIT_TC_MSB_MASK>( rDst, rSrc );
547 : case BMP_FORMAT_16BIT_TC_LSB_MASK:
548 0 : return ImplConvertFromBitmap<BMP_FORMAT_16BIT_TC_LSB_MASK>( rDst, rSrc );
549 :
550 : case BMP_FORMAT_24BIT_TC_BGR:
551 0 : return ImplConvertFromBitmap<BMP_FORMAT_24BIT_TC_BGR>( rDst, rSrc );
552 : case BMP_FORMAT_24BIT_TC_RGB:
553 0 : return ImplConvertFromBitmap<BMP_FORMAT_24BIT_TC_RGB>( rDst, rSrc );
554 :
555 : case BMP_FORMAT_32BIT_TC_ABGR:
556 0 : return ImplConvertFromBitmap<BMP_FORMAT_32BIT_TC_ABGR>( rDst, rSrc );
557 : #ifdef FAST_ARGB_BGRA
558 : case BMP_FORMAT_32BIT_TC_ARGB:
559 0 : return ImplConvertFromBitmap<BMP_FORMAT_32BIT_TC_ARGB>( rDst, rSrc );
560 : case BMP_FORMAT_32BIT_TC_BGRA:
561 0 : return ImplConvertFromBitmap<BMP_FORMAT_32BIT_TC_BGRA>( rDst, rSrc );
562 : #endif
563 : case BMP_FORMAT_32BIT_TC_RGBA:
564 0 : return ImplConvertFromBitmap<BMP_FORMAT_32BIT_TC_RGBA>( rDst, rSrc );
565 : }
566 :
567 : #ifdef DEBUG
568 : static int nNotAccelerated = 0;
569 : if( rSrc.mnWidth * rSrc.mnHeight >= 4000 )
570 : {
571 : if( ++nNotAccelerated == 100 )
572 : {
573 : int foo = 0; (void)foo; // so no warning is created when building on pro with debug
574 : DBG_WARNING2( "ImplFastBitmapConversion for not accelerated case (0x%04X->0x%04X)", rSrc.mnFormat, rDst.mnFormat );
575 : }
576 : }
577 : #endif
578 :
579 0 : return false;
580 : }
581 :
582 : template <sal_uLong DSTFMT,sal_uLong SRCFMT> //,sal_uLong MSKFMT>
583 55738 : bool ImplBlendToBitmap( TrueColorPixelPtr<SRCFMT>& rSrcLine,
584 : BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
585 : const BitmapBuffer& rMskBuffer )
586 : {
587 : DBG_ASSERT( rMskBuffer.mnFormat == BMP_FORMAT_8BIT_PAL, "FastBmp BlendImage: unusual MSKFMT" );
588 :
589 55738 : const int nSrcLinestep = rSrcBuffer.mnScanlineSize;
590 55738 : int nMskLinestep = rMskBuffer.mnScanlineSize;
591 55738 : int nDstLinestep = rDstBuffer.mnScanlineSize;
592 :
593 55738 : TrueColorPixelPtr<BMP_FORMAT_8BIT_PAL> aMskLine; aMskLine.SetRawPtr( rMskBuffer.mpBits );
594 55738 : TrueColorPixelPtr<DSTFMT> aDstLine; aDstLine.SetRawPtr( rDstBuffer.mpBits );
595 :
596 : // special case for single line masks
597 55738 : if( rMskBuffer.mnHeight == 1 )
598 0 : nMskLinestep = 0;
599 :
600 : // source and mask don't match: upside down
601 55738 : if( (rSrcBuffer.mnFormat ^ rMskBuffer.mnFormat) & BMP_FORMAT_TOP_DOWN )
602 : {
603 0 : aMskLine.AddByteOffset( (rSrcBuffer.mnHeight - 1) * nMskLinestep );
604 0 : nMskLinestep = -nMskLinestep;
605 : }
606 :
607 : // source and destination don't match: upside down
608 55738 : if( (rSrcBuffer.mnFormat ^ rDstBuffer.mnFormat) & BMP_FORMAT_TOP_DOWN )
609 : {
610 0 : aDstLine.AddByteOffset( (rSrcBuffer.mnHeight - 1) * nDstLinestep );
611 0 : nDstLinestep = -nDstLinestep;
612 : }
613 :
614 1165463 : for( int y = rSrcBuffer.mnHeight; --y >= 0; )
615 : {
616 1053987 : ImplBlendLines<8>( aDstLine, rSrcLine, aMskLine, rDstBuffer.mnWidth );
617 1053987 : aDstLine.AddByteOffset( nDstLinestep );
618 1053987 : rSrcLine.AddByteOffset( nSrcLinestep );
619 1053987 : aMskLine.AddByteOffset( nMskLinestep );
620 : }
621 :
622 55738 : return true;
623 : }
624 :
625 : // some specializations to reduce the code size
626 : template <>
627 55738 : inline bool ImplBlendToBitmap<BMP_FORMAT_24BIT_TC_BGR,BMP_FORMAT_24BIT_TC_BGR>(
628 : TrueColorPixelPtr<BMP_FORMAT_24BIT_TC_BGR>&,
629 : BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
630 : const BitmapBuffer& rMskBuffer )
631 : {
632 55738 : TrueColorPixelPtr<BMP_FORMAT_24BIT_TC_RGB> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
633 55738 : return ImplBlendToBitmap<BMP_FORMAT_24BIT_TC_RGB>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
634 : }
635 :
636 : template <>
637 0 : inline bool ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_ABGR,BMP_FORMAT_32BIT_TC_ABGR>(
638 : TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_ABGR>&,
639 : BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
640 : const BitmapBuffer& rMskBuffer )
641 : {
642 0 : TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_ARGB> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
643 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_ARGB>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
644 : }
645 :
646 : template <>
647 0 : inline bool ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_BGRA,BMP_FORMAT_32BIT_TC_BGRA>(
648 : TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_BGRA>&,
649 : BitmapBuffer& rDstBuffer, const BitmapBuffer& rSrcBuffer,
650 : const BitmapBuffer& rMskBuffer )
651 : {
652 0 : TrueColorPixelPtr<BMP_FORMAT_32BIT_TC_RGBA> aSrcType; aSrcType.SetRawPtr( rSrcBuffer.mpBits );
653 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_RGBA>( aSrcType, rDstBuffer, rSrcBuffer, rMskBuffer );
654 : }
655 :
656 : template <sal_uLong SRCFMT>
657 55738 : bool ImplBlendFromBitmap( BitmapBuffer& rDst, const BitmapBuffer& rSrc, const BitmapBuffer& rMsk )
658 : {
659 55738 : TrueColorPixelPtr<SRCFMT> aSrcType; aSrcType.SetRawPtr( rSrc.mpBits );
660 :
661 : // select the matching instantiation for the destination's bitmap format
662 55738 : switch( rDst.mnFormat & ~BMP_FORMAT_TOP_DOWN )
663 : {
664 : case BMP_FORMAT_1BIT_MSB_PAL:
665 : case BMP_FORMAT_1BIT_LSB_PAL:
666 : case BMP_FORMAT_4BIT_MSN_PAL:
667 : case BMP_FORMAT_4BIT_LSN_PAL:
668 : case BMP_FORMAT_8BIT_PAL:
669 0 : break;
670 :
671 : case BMP_FORMAT_8BIT_TC_MASK:
672 : // return ImplBlendToBitmap<BMP_FORMAT_8BIT_TC_MASK>( aSrcType, rDst, rSrc, rMsk );
673 : case BMP_FORMAT_24BIT_TC_MASK:
674 : // return ImplBlendToBitmap<BMP_FORMAT_24BIT_TC_MASK>( aSrcType, rDst, rSrc, rMsk );
675 : case BMP_FORMAT_32BIT_TC_MASK:
676 : // return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_MASK>( aSrcType, rDst, rSrc, rMsk );
677 0 : break;
678 :
679 : case BMP_FORMAT_16BIT_TC_MSB_MASK:
680 0 : return ImplBlendToBitmap<BMP_FORMAT_16BIT_TC_MSB_MASK>( aSrcType, rDst, rSrc, rMsk );
681 : case BMP_FORMAT_16BIT_TC_LSB_MASK:
682 0 : return ImplBlendToBitmap<BMP_FORMAT_16BIT_TC_LSB_MASK>( aSrcType, rDst, rSrc, rMsk );
683 :
684 : case BMP_FORMAT_24BIT_TC_BGR:
685 55738 : return ImplBlendToBitmap<BMP_FORMAT_24BIT_TC_BGR>( aSrcType, rDst, rSrc, rMsk );
686 : case BMP_FORMAT_24BIT_TC_RGB:
687 0 : return ImplBlendToBitmap<BMP_FORMAT_24BIT_TC_RGB>( aSrcType, rDst, rSrc, rMsk );
688 :
689 : case BMP_FORMAT_32BIT_TC_ABGR:
690 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_ABGR>( aSrcType, rDst, rSrc, rMsk );
691 : #ifdef FAST_ARGB_BGRA
692 : case BMP_FORMAT_32BIT_TC_ARGB:
693 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_ARGB>( aSrcType, rDst, rSrc, rMsk );
694 : case BMP_FORMAT_32BIT_TC_BGRA:
695 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_BGRA>( aSrcType, rDst, rSrc, rMsk );
696 : #endif
697 : case BMP_FORMAT_32BIT_TC_RGBA:
698 0 : return ImplBlendToBitmap<BMP_FORMAT_32BIT_TC_RGBA>( aSrcType, rDst, rSrc, rMsk );
699 : }
700 :
701 : #ifdef DEBUG
702 : static int nNotAccelerated = 0;
703 : if( rSrc.mnWidth * rSrc.mnHeight >= 4000 )
704 : if( ++nNotAccelerated == 100 )
705 : {
706 : int foo = 0; (void)foo; // so no warning is created when building on pro with debug
707 : DBG_WARNING3( "ImplBlendFromBitmap for not accelerated case (0x%04X*0x%04X->0x%04X)",
708 : rSrc.mnFormat, rMsk.mnFormat, rDst.mnFormat );
709 : }
710 : #endif
711 :
712 0 : return false;
713 : }
714 :
715 91403 : bool ImplFastBitmapBlending( BitmapWriteAccess& rDstWA,
716 : const BitmapReadAccess& rSrcRA, const BitmapReadAccess& rMskRA,
717 : const SalTwoRect& rTR )
718 : {
719 : // accelerated blending of paletted bitmaps not implemented yet
720 91403 : if( rSrcRA.HasPalette() )
721 19879 : return false;
722 71524 : if( rDstWA.HasPalette() )
723 0 : return false;
724 : // TODO: either get rid of mask's use of 8BIT_PAL or check the palette
725 :
726 : // horizontal mirroring not implemented yet
727 71524 : if( rTR.mnDestWidth < 0 )
728 0 : return false;
729 : // vertical mirroring
730 71524 : if( rTR.mnDestHeight < 0 )
731 : // TODO: rDst.mnFormat ^= BMP_FORMAT_TOP_DOWN;
732 0 : return false;
733 :
734 : // offseted blending is not implemented yet
735 71524 : if( rTR.mnSrcX || rTR.mnSrcY )
736 0 : return false;
737 71524 : if( rTR.mnDestX || rTR.mnDestY )
738 3418 : return false;
739 :
740 : // stretched blending is not implemented yet
741 68106 : if( rTR.mnDestWidth != rTR.mnSrcWidth )
742 994 : return false;
743 67112 : if( rTR.mnDestHeight!= rTR.mnSrcHeight )
744 694 : return false;
745 :
746 : // check source image size
747 66418 : if( rSrcRA.Width() < rTR.mnSrcX + rTR.mnSrcWidth )
748 0 : return false;
749 66418 : if( rSrcRA.Height() < rTR.mnSrcY + rTR.mnSrcHeight )
750 0 : return false;
751 :
752 : // check mask image size
753 66418 : if( rMskRA.Width() < rTR.mnSrcX + rTR.mnSrcWidth )
754 0 : return false;
755 66418 : if( rMskRA.Height() < rTR.mnSrcY + rTR.mnSrcHeight )
756 0 : if( rMskRA.Height() != 1 )
757 0 : return false;
758 :
759 : // check dest image size
760 66418 : if( rDstWA.Width() < rTR.mnDestX + rTR.mnDestWidth )
761 3279 : return false;
762 63139 : if( rDstWA.Height() < rTR.mnDestY + rTR.mnDestHeight )
763 7401 : return false;
764 :
765 55738 : BitmapBuffer& rDst = *rDstWA.ImplGetBitmapBuffer();
766 55738 : const BitmapBuffer& rSrc = *rSrcRA.ImplGetBitmapBuffer();
767 55738 : const BitmapBuffer& rMsk = *rMskRA.ImplGetBitmapBuffer();
768 :
769 55738 : const sal_uLong nSrcFormat = rSrc.mnFormat & ~BMP_FORMAT_TOP_DOWN;
770 55738 : const sal_uLong nDstFormat = rDst.mnFormat & ~BMP_FORMAT_TOP_DOWN;
771 :
772 : // accelerated conversions for 16bit colormasks with non-565 format are not yet implemented
773 55738 : if( nSrcFormat & (BMP_FORMAT_16BIT_TC_LSB_MASK | BMP_FORMAT_16BIT_TC_MSB_MASK) )
774 0 : if( rSrc.maColorMask.GetRedMask() != 0xF800
775 0 : || rSrc.maColorMask.GetGreenMask()!= 0x07E0
776 0 : || rSrc.maColorMask.GetBlueMask() != 0x001F)
777 0 : return false;
778 55738 : if( nDstFormat & (BMP_FORMAT_16BIT_TC_LSB_MASK | BMP_FORMAT_16BIT_TC_MSB_MASK) )
779 0 : if( rDst.maColorMask.GetRedMask() != 0xF800
780 0 : || rDst.maColorMask.GetGreenMask()!= 0x07E0
781 0 : || rDst.maColorMask.GetBlueMask() != 0x001F)
782 0 : return false;
783 :
784 : // select the matching instantiation for the source's bitmap format
785 55738 : switch( nSrcFormat )
786 : {
787 : case BMP_FORMAT_1BIT_MSB_PAL:
788 : case BMP_FORMAT_1BIT_LSB_PAL:
789 : case BMP_FORMAT_4BIT_MSN_PAL:
790 : case BMP_FORMAT_4BIT_LSN_PAL:
791 : case BMP_FORMAT_8BIT_PAL:
792 0 : break;
793 :
794 : case BMP_FORMAT_8BIT_TC_MASK:
795 : // return ImplBlendFromBitmap<BMP_FORMAT_8BIT_TC_MASK>( rDst, rSrc );
796 : case BMP_FORMAT_24BIT_TC_MASK:
797 : // return ImplBlendFromBitmap<BMP_FORMAT_24BIT_TC_MASK>( rDst, rSrc );
798 : case BMP_FORMAT_32BIT_TC_MASK:
799 : // return ImplBlendFromBitmap<BMP_FORMAT_32BIT_TC_MASK>( rDst, rSrc );
800 0 : break;
801 :
802 : case BMP_FORMAT_16BIT_TC_MSB_MASK:
803 0 : return ImplBlendFromBitmap<BMP_FORMAT_16BIT_TC_MSB_MASK>( rDst, rSrc, rMsk );
804 : case BMP_FORMAT_16BIT_TC_LSB_MASK:
805 0 : return ImplBlendFromBitmap<BMP_FORMAT_16BIT_TC_LSB_MASK>( rDst, rSrc, rMsk );
806 :
807 : case BMP_FORMAT_24BIT_TC_BGR:
808 55738 : return ImplBlendFromBitmap<BMP_FORMAT_24BIT_TC_BGR>( rDst, rSrc, rMsk );
809 : case BMP_FORMAT_24BIT_TC_RGB:
810 0 : return ImplBlendFromBitmap<BMP_FORMAT_24BIT_TC_RGB>( rDst, rSrc, rMsk );
811 :
812 : case BMP_FORMAT_32BIT_TC_ABGR:
813 0 : return ImplBlendFromBitmap<BMP_FORMAT_32BIT_TC_ABGR>( rDst, rSrc, rMsk );
814 : #ifdef FAST_ARGB_BGRA
815 : case BMP_FORMAT_32BIT_TC_ARGB:
816 0 : return ImplBlendFromBitmap<BMP_FORMAT_32BIT_TC_ARGB>( rDst, rSrc, rMsk );
817 : case BMP_FORMAT_32BIT_TC_BGRA:
818 0 : return ImplBlendFromBitmap<BMP_FORMAT_32BIT_TC_BGRA>( rDst, rSrc, rMsk );
819 : #endif
820 : case BMP_FORMAT_32BIT_TC_RGBA:
821 0 : return ImplBlendFromBitmap<BMP_FORMAT_32BIT_TC_RGBA>( rDst, rSrc, rMsk );
822 : }
823 :
824 : #ifdef DEBUG
825 : static int nNotAccelerated = 0;
826 : if( rSrc.mnWidth * rSrc.mnHeight >= 4000 )
827 : if( ++nNotAccelerated == 100 )
828 : {
829 : int foo = 0; (void)foo; // so no warning is created when building on pro with debug
830 : DBG_WARNING3( "ImplFastBlend for not accelerated case (0x%04X*0x%04X->0x%04X)",
831 : rSrc.mnFormat, rMsk.mnFormat, rDst.mnFormat );
832 : }
833 : #endif
834 :
835 0 : return false;
836 : }
837 :
838 765 : bool ImplFastEraseBitmap( BitmapBuffer& rDst, const BitmapColor& rColor )
839 : {
840 765 : const sal_uLong nDstFormat = rDst.mnFormat & ~BMP_FORMAT_TOP_DOWN;
841 :
842 : // erasing a bitmap is often just a byte-wise memory fill
843 765 : bool bByteFill = true;
844 : sal_uInt8 nFillByte;
845 :
846 765 : switch( nDstFormat )
847 : {
848 : case BMP_FORMAT_1BIT_MSB_PAL:
849 : case BMP_FORMAT_1BIT_LSB_PAL:
850 110 : nFillByte = rColor.GetIndex();
851 110 : nFillByte = static_cast<sal_uInt8>( -(nFillByte & 1) ); // 0x00 or 0xFF
852 110 : break;
853 : case BMP_FORMAT_4BIT_MSN_PAL:
854 : case BMP_FORMAT_4BIT_LSN_PAL:
855 30 : nFillByte = rColor.GetIndex();
856 30 : nFillByte &= 0x0F;
857 30 : nFillByte |= (nFillByte << 4);
858 30 : break;
859 : case BMP_FORMAT_8BIT_PAL:
860 : case BMP_FORMAT_8BIT_TC_MASK:
861 401 : nFillByte = rColor.GetIndex();
862 401 : break;
863 :
864 : case BMP_FORMAT_24BIT_TC_MASK:
865 : case BMP_FORMAT_24BIT_TC_BGR:
866 : case BMP_FORMAT_24BIT_TC_RGB:
867 224 : nFillByte = rColor.GetRed();
868 448 : if( (nFillByte != rColor.GetGreen())
869 224 : || (nFillByte != rColor.GetBlue()) )
870 30 : bByteFill = false;
871 224 : break;
872 :
873 : default:
874 0 : bByteFill = false;
875 0 : nFillByte = 0x00;
876 0 : break;
877 : }
878 :
879 765 : if( bByteFill )
880 : {
881 735 : long nByteCount = rDst.mnHeight * rDst.mnScanlineSize;
882 735 : memset( rDst.mpBits, nFillByte, nByteCount );
883 735 : return true;
884 : }
885 :
886 : // TODO: handle other bitmap formats
887 30 : switch( nDstFormat )
888 : {
889 : case BMP_FORMAT_32BIT_TC_MASK:
890 : case BMP_FORMAT_16BIT_TC_MSB_MASK:
891 : case BMP_FORMAT_16BIT_TC_LSB_MASK:
892 :
893 : case BMP_FORMAT_24BIT_TC_BGR:
894 : case BMP_FORMAT_24BIT_TC_RGB:
895 :
896 : case BMP_FORMAT_32BIT_TC_ABGR:
897 : #ifdef FAST_ARGB_BGRA
898 : case BMP_FORMAT_32BIT_TC_ARGB:
899 : case BMP_FORMAT_32BIT_TC_BGRA:
900 : #endif
901 : case BMP_FORMAT_32BIT_TC_RGBA:
902 30 : break;
903 :
904 : default:
905 0 : break;
906 : }
907 :
908 30 : return false;
909 465 : }
910 :
911 : #else // NO_OPTIMIZED_BITMAP_ACCESS
912 :
913 : bool ImplFastBitmapConversion( BitmapBuffer&, const BitmapBuffer& )
914 : {
915 : return false;
916 : }
917 :
918 : bool ImplFastBitmapBlending( BitmapWriteAccess&,
919 : const BitmapReadAccess&, const BitmapReadAccess&,
920 : const Size&, const Point& )
921 : {
922 : return false;
923 : }
924 :
925 : bool ImplFastEraseBitmap( BitmapBuffer&, const BitmapColor& )
926 : {
927 : return false;
928 : }
929 :
930 : #endif
931 :
932 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
