?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Branch libreoffice-5-0-4
[LibreOffice.git] / canvas / source / directx / dx_vcltools.cxx
blob727008049e68ae4c387a456d09fba71d11c2111f
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 <vcl/canvastools.hxx>
22
23 #include <vcl/bitmap.hxx>
24 #include <vcl/bitmapex.hxx>
25 #include <vcl/bmpacc.hxx>
26 #include <tools/diagnose_ex.h>
27
28 #include "dx_impltools.hxx"
29 #include <basegfx/numeric/ftools.hxx>
30
31 #include <canvas/debug.hxx>
32 #include <canvas/verbosetrace.hxx>
33
34 #include <com/sun/star/lang/XServiceInfo.hpp>
35 #include <com/sun/star/rendering/XIntegerBitmap.hpp>
36
37 #include <boost/scoped_array.hpp>
38
39 #include "dx_vcltools.hxx"
40
41 using namespace ::com::sun::star;
42
43 namespace dxcanvas
44 {
45 namespace tools
46 {
47 namespace
48 {
49 /// Calc number of colors in given BitmapInfoHeader
50 sal_Int32 calcDIBColorCount( const BITMAPINFOHEADER& rBIH )
51 {
52 if( rBIH.biSize != sizeof( BITMAPCOREHEADER ) )
53 {
54 if( rBIH.biBitCount <= 8 )
55 {
56 if( rBIH.biClrUsed )
57 return rBIH.biClrUsed;
58 else
59 return 1L << rBIH.biBitCount;
60 }
61 }
62 else
63 {
64 BITMAPCOREHEADER* pCoreHeader = (BITMAPCOREHEADER*)&rBIH;
65
66 if( pCoreHeader->bcBitCount <= 8 )
67 return 1L << pCoreHeader->bcBitCount;
68 }
69
70 return 0; // nothing known
71 }
72
73 /// Draw DI bits to given Graphics
74 bool drawDIBits( const ::boost::shared_ptr< Gdiplus::Graphics >& rGraphics,
75 const void* hDIB )
76 {
77 bool bRet( false );
78 BitmapSharedPtr pBitmap;
79
80 const BITMAPINFO* pBI = (BITMAPINFO*)GlobalLock( (HGLOBAL)hDIB );
81
82 if( pBI )
83 {
84 const BITMAPINFOHEADER* pBIH = (BITMAPINFOHEADER*)pBI;
85 const BYTE* pBits = (BYTE*) pBI + *(DWORD*)pBI +
86 calcDIBColorCount( *pBIH ) * sizeof( RGBQUAD );
87
88 // forward to outsourced GDI+ rendering method
89 // (header clashes)
90 bRet = tools::drawDIBits( rGraphics, *pBI, (void*)pBits );
91
92 GlobalUnlock( (HGLOBAL)hDIB );
93 }
94
95 return bRet;
96 }
97
98 /** Draw VCL bitmap to given Graphics
99
100 @param rBmp
101 Reference to bitmap. Might get modified, in such a way
102 that it will hold a DIB after a successful function call.
103 */
104 bool drawVCLBitmap( const ::boost::shared_ptr< Gdiplus::Graphics >& rGraphics,
105 ::Bitmap& rBmp )
106 {
107 BitmapSystemData aBmpSysData;
108
109 if( !rBmp.GetSystemData( aBmpSysData ) ||
110 !aBmpSysData.pDIB )
111 {
112 // first of all, ensure that Bitmap contains a DIB, by
113 // acquiring a read access
114 BitmapReadAccess* pReadAcc = rBmp.AcquireReadAccess();
115
116 // TODO(P2): Acquiring a read access can actually
117 // force a read from VRAM, thus, avoiding this
118 // step somehow will increase performance
119 // here.
120 if( pReadAcc )
121 {
122 // try again: now, WinSalBitmap must have
123 // generated a DIB
124 if( rBmp.GetSystemData( aBmpSysData ) &&
125 aBmpSysData.pDIB )
126 {
127 return drawDIBits( rGraphics,
128 aBmpSysData.pDIB );
129 }
130
131 rBmp.ReleaseAccess( pReadAcc );
132 }
133 }
134 else
135 {
136 return drawDIBits( rGraphics,
137 aBmpSysData.pDIB );
138 }
139
140 // failed to generate DIBits from vcl bitmap
141 return false;
142 }
143
144 /** Create a chunk of raw RGBA data GDI+ Bitmap from VCL BbitmapEX
145 */
146 RawRGBABitmap bitmapFromVCLBitmapEx( const ::BitmapEx& rBmpEx )
147 {
148 // TODO(P2): Avoid temporary bitmap generation, maybe
149 // even ensure that created DIBs are copied back to
150 // BmpEx (currently, every AcquireReadAccess() will
151 // make the local bitmap copy unique, effectively
152 // duplicating the memory used)
153
154 ENSURE_OR_THROW( rBmpEx.IsTransparent(),
155 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
156 "BmpEx not transparent" );
157
158 // convert transparent bitmap to 32bit RGBA
159 // ========================================
160
161 const ::Size aBmpSize( rBmpEx.GetSizePixel() );
162
163 RawRGBABitmap aBmpData;
164 aBmpData.mnWidth = aBmpSize.Width();
165 aBmpData.mnHeight = aBmpSize.Height();
166 aBmpData.mpBitmapData.reset( new sal_uInt8[ 4*aBmpData.mnWidth*aBmpData.mnHeight ] );
167
168 Bitmap aBitmap( rBmpEx.GetBitmap() );
169
170 Bitmap::ScopedReadAccess pReadAccess( aBitmap );
171
172 const sal_Int32 nWidth( aBmpSize.Width() );
173 const sal_Int32 nHeight( aBmpSize.Height() );
174
175 ENSURE_OR_THROW( pReadAccess.get() != NULL,
176 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
177 "Unable to acquire read access to bitmap" );
178
179 if( rBmpEx.IsAlpha() )
180 {
181 Bitmap aAlpha( rBmpEx.GetAlpha().GetBitmap() );
182
183 Bitmap::ScopedReadAccess pAlphaReadAccess( aAlpha );
184
185 // By convention, the access buffer always has
186 // one of the following formats:
187
188 // BMP_FORMAT_1BIT_MSB_PAL
189 // BMP_FORMAT_4BIT_MSN_PAL
190 // BMP_FORMAT_8BIT_PAL
191 // BMP_FORMAT_16BIT_TC_LSB_MASK
192 // BMP_FORMAT_24BIT_TC_BGR
193 // BMP_FORMAT_32BIT_TC_MASK
194
195 // and is always BMP_FORMAT_BOTTOM_UP
196
197 // This is the way
198 // WinSalBitmap::AcquireBuffer() sets up the
199 // buffer
200
201 ENSURE_OR_THROW( pAlphaReadAccess.get() != NULL,
202 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
203 "Unable to acquire read access to alpha" );
204
205 ENSURE_OR_THROW( pAlphaReadAccess->GetScanlineFormat() == BMP_FORMAT_8BIT_PAL ||
206 pAlphaReadAccess->GetScanlineFormat() == BMP_FORMAT_8BIT_TC_MASK,
207 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
208 "Unsupported alpha scanline format" );
209
210 BitmapColor aCol;
211 const sal_Int32 nWidth( aBmpSize.Width() );
212 const sal_Int32 nHeight( aBmpSize.Height() );
213 sal_uInt8* pCurrOutput( aBmpData.mpBitmapData.get() );
214 int x, y;
215
216 for( y=0; y<nHeight; ++y )
217 {
218 switch( pReadAccess->GetScanlineFormat() )
219 {
220 case BMP_FORMAT_8BIT_PAL:
221 {
222 Scanline pScan = pReadAccess->GetScanline( y );
223 Scanline pAScan = pAlphaReadAccess->GetScanline( y );
224
225 for( x=0; x<nWidth; ++x )
226 {
227 aCol = pReadAccess->GetPaletteColor( *pScan++ );
228
229 *pCurrOutput++ = aCol.GetBlue();
230 *pCurrOutput++ = aCol.GetGreen();
231 *pCurrOutput++ = aCol.GetRed();
232
233 // out notion of alpha is
234 // different from the rest
235 // of the world's
236 *pCurrOutput++ = 255 - (BYTE)*pAScan++;
237 }
238 }
239 break;
240
241 case BMP_FORMAT_24BIT_TC_BGR:
242 {
243 Scanline pScan = pReadAccess->GetScanline( y );
244 Scanline pAScan = pAlphaReadAccess->GetScanline( y );
245
246 for( x=0; x<nWidth; ++x )
247 {
248 // store as RGBA
249 *pCurrOutput++ = *pScan++;
250 *pCurrOutput++ = *pScan++;
251 *pCurrOutput++ = *pScan++;
252
253 // out notion of alpha is
254 // different from the rest
255 // of the world's
256 *pCurrOutput++ = 255 - (BYTE)*pAScan++;
257 }
258 }
259 break;
260
261 // TODO(P2): Might be advantageous
262 // to hand-formulate the following
263 // formats, too.
264 case BMP_FORMAT_1BIT_MSB_PAL:
265 // FALLTHROUGH intended
266 case BMP_FORMAT_4BIT_MSN_PAL:
267 // FALLTHROUGH intended
268 case BMP_FORMAT_16BIT_TC_LSB_MASK:
269 // FALLTHROUGH intended
270 case BMP_FORMAT_32BIT_TC_MASK:
271 {
272 Scanline pAScan = pAlphaReadAccess->GetScanline( y );
273
274 // using fallback for those
275 // seldom formats
276 for( x=0; x<nWidth; ++x )
277 {
278 // yes. x and y are swapped on Get/SetPixel
279 aCol = pReadAccess->GetColor(y,x);
280
281 *pCurrOutput++ = aCol.GetBlue();
282 *pCurrOutput++ = aCol.GetGreen();
283 *pCurrOutput++ = aCol.GetRed();
284
285 // out notion of alpha is
286 // different from the rest
287 // of the world's
288 *pCurrOutput++ = 255 - (BYTE)*pAScan++;
289 }
290 }
291 break;
292
293 case BMP_FORMAT_1BIT_LSB_PAL:
294 // FALLTHROUGH intended
295 case BMP_FORMAT_4BIT_LSN_PAL:
296 // FALLTHROUGH intended
297 case BMP_FORMAT_8BIT_TC_MASK:
298 // FALLTHROUGH intended
299 case BMP_FORMAT_24BIT_TC_RGB:
300 // FALLTHROUGH intended
301 case BMP_FORMAT_24BIT_TC_MASK:
302 // FALLTHROUGH intended
303 case BMP_FORMAT_16BIT_TC_MSB_MASK:
304 // FALLTHROUGH intended
305 case BMP_FORMAT_32BIT_TC_ABGR:
306 // FALLTHROUGH intended
307 case BMP_FORMAT_32BIT_TC_ARGB:
308 // FALLTHROUGH intended
309 case BMP_FORMAT_32BIT_TC_BGRA:
310 // FALLTHROUGH intended
311 case BMP_FORMAT_32BIT_TC_RGBA:
312 // FALLTHROUGH intended
313 default:
314 ENSURE_OR_THROW( false,
315 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
316 "Unexpected scanline format - has "
317 "WinSalBitmap::AcquireBuffer() changed?" );
318 }
319 }
320 }
321 else
322 {
323 Bitmap aMask( rBmpEx.GetMask() );
324
325 Bitmap::ScopedReadAccess pMaskReadAccess( aMask );
326
327 // By convention, the access buffer always has
328 // one of the following formats:
329
330 // BMP_FORMAT_1BIT_MSB_PAL
331 // BMP_FORMAT_4BIT_MSN_PAL
332 // BMP_FORMAT_8BIT_PAL
333 // BMP_FORMAT_16BIT_TC_LSB_MASK
334 // BMP_FORMAT_24BIT_TC_BGR
335 // BMP_FORMAT_32BIT_TC_MASK
336
337 // and is always BMP_FORMAT_BOTTOM_UP
338
339 // This is the way
340 // WinSalBitmap::AcquireBuffer() sets up the
341 // buffer
342
343 ENSURE_OR_THROW( pMaskReadAccess.get() != NULL,
344 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
345 "Unable to acquire read access to mask" );
346
347 ENSURE_OR_THROW( pMaskReadAccess->GetScanlineFormat() == BMP_FORMAT_1BIT_MSB_PAL,
348 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
349 "Unsupported mask scanline format" );
350
351 BitmapColor aCol;
352 int nCurrBit;
353 const int nMask( 1L );
354 const int nInitialBit(7);
355 sal_uInt8* pCurrOutput( aBmpData.mpBitmapData.get() );
356 int x, y;
357
358 // mapping table, to get from mask index color to
359 // alpha value (which depends on the mask's palette)
360 sal_uInt8 aColorMap[2];
361
362 const BitmapColor& rCol0( pMaskReadAccess->GetPaletteColor( 0 ) );
363 const BitmapColor& rCol1( pMaskReadAccess->GetPaletteColor( 1 ) );
364
365 // shortcut for true luminance calculation
366 // (assumes that palette is grey-level). Note the
367 // swapped the indices here, to account for the
368 // fact that VCL's notion of alpha is inverted to
369 // the rest of the world's.
370 aColorMap[0] = rCol1.GetRed();
371 aColorMap[1] = rCol0.GetRed();
372
373 for( y=0; y<nHeight; ++y )
374 {
375 switch( pReadAccess->GetScanlineFormat() )
376 {
377 case BMP_FORMAT_8BIT_PAL:
378 {
379 Scanline pScan = pReadAccess->GetScanline( y );
380 Scanline pMScan = pMaskReadAccess->GetScanline( y );
381
382 for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
383 {
384 aCol = pReadAccess->GetPaletteColor( *pScan++ );
385
386 *pCurrOutput++ = aCol.GetBlue();
387 *pCurrOutput++ = aCol.GetGreen();
388 *pCurrOutput++ = aCol.GetRed();
389
390 *pCurrOutput++ = aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ];
391 nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
392 }
393 }
394 break;
395
396 case BMP_FORMAT_24BIT_TC_BGR:
397 {
398 Scanline pScan = pReadAccess->GetScanline( y );
399 Scanline pMScan = pMaskReadAccess->GetScanline( y );
400
401 for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
402 {
403 // store as RGBA
404 *pCurrOutput++ = *pScan++;
405 *pCurrOutput++ = *pScan++;
406 *pCurrOutput++ = *pScan++;
407
408 *pCurrOutput++ = aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ];
409 nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
410 }
411 }
412 break;
413
414 // TODO(P2): Might be advantageous
415 // to hand-formulate the following
416 // formats, too.
417 case BMP_FORMAT_1BIT_MSB_PAL:
418 // FALLTHROUGH intended
419 case BMP_FORMAT_4BIT_MSN_PAL:
420 // FALLTHROUGH intended
421 case BMP_FORMAT_16BIT_TC_LSB_MASK:
422 // FALLTHROUGH intended
423 case BMP_FORMAT_32BIT_TC_MASK:
424 {
425 Scanline pMScan = pMaskReadAccess->GetScanline( y );
426
427 // using fallback for those
428 // seldom formats
429 for( x=0, nCurrBit=nInitialBit; x<nWidth; ++x )
430 {
431 // yes. x and y are swapped on Get/SetPixel
432 aCol = pReadAccess->GetColor(y,x);
433
434 // store as RGBA
435 *pCurrOutput++ = aCol.GetBlue();
436 *pCurrOutput++ = aCol.GetGreen();
437 *pCurrOutput++ = aCol.GetRed();
438
439 *pCurrOutput++ = aColorMap[ (pMScan[ (x & ~7L) >> 3L ] >> nCurrBit ) & nMask ];
440 nCurrBit = ((nCurrBit - 1) % 8L) & 7L;
441 }
442 }
443 break;
444
445 case BMP_FORMAT_1BIT_LSB_PAL:
446 // FALLTHROUGH intended
447 case BMP_FORMAT_4BIT_LSN_PAL:
448 // FALLTHROUGH intended
449 case BMP_FORMAT_8BIT_TC_MASK:
450 // FALLTHROUGH intended
451 case BMP_FORMAT_24BIT_TC_RGB:
452 // FALLTHROUGH intended
453 case BMP_FORMAT_24BIT_TC_MASK:
454 // FALLTHROUGH intended
455 case BMP_FORMAT_16BIT_TC_MSB_MASK:
456 // FALLTHROUGH intended
457 case BMP_FORMAT_32BIT_TC_ABGR:
458 // FALLTHROUGH intended
459 case BMP_FORMAT_32BIT_TC_ARGB:
460 // FALLTHROUGH intended
461 case BMP_FORMAT_32BIT_TC_BGRA:
462 // FALLTHROUGH intended
463 case BMP_FORMAT_32BIT_TC_RGBA:
464 // FALLTHROUGH intended
465 default:
466 ENSURE_OR_THROW( false,
467 "::dxcanvas::tools::bitmapFromVCLBitmapEx(): "
468 "Unexpected scanline format - has "
469 "WinSalBitmap::AcquireBuffer() changed?" );
470 }
471 }
472 }
473
474 return aBmpData;
475 }
476
477 bool drawVCLBitmapEx( const ::boost::shared_ptr< Gdiplus::Graphics >& rGraphics,
478 const ::BitmapEx& rBmpEx )
479 {
480 if( !rBmpEx.IsTransparent() )
481 {
482 Bitmap aBmp( rBmpEx.GetBitmap() );
483 return drawVCLBitmap( rGraphics, aBmp );
484 }
485 else
486 {
487 return drawRGBABits( rGraphics,
488 bitmapFromVCLBitmapEx( rBmpEx ) );
489 }
490 }
491 }
492
493 bool drawVCLBitmapFromXBitmap( const ::boost::shared_ptr< Gdiplus::Graphics >& rGraphics,
494 const uno::Reference< rendering::XBitmap >& xBitmap )
495 {
496 // TODO(F2): add support for floating point bitmap formats
497 uno::Reference< rendering::XIntegerReadOnlyBitmap > xIntBmp(
498 xBitmap, uno::UNO_QUERY );
499
500 if( !xIntBmp.is() )
501 return false;
502
503 ::BitmapEx aBmpEx = vcl::unotools::bitmapExFromXBitmap( xIntBmp );
504 if( !aBmpEx )
505 return false;
506
507 return drawVCLBitmapEx( rGraphics, aBmpEx );
508 }
509 }
510 }
511
512 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE