vcl/win/gdi/salbmp.cxx

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 #include <svsys.h>
  20 #include <vcl/bitmap.hxx>
  21 #include <vcl/salbtype.hxx>
  22 #include <com/sun/star/beans/XFastPropertySet.hpp>
  23 #include <win/wincomp.hxx>
  24 #include <win/salgdi.h>
  25 #include <win/saldata.hxx>
  26 #include <win/salbmp.h>
  27 #include <string.h>
  28 #include <vcl/timer.hxx>
  29 #include <cppuhelper/basemutex.hxx>
  30 #include <map>
  31
  32 #if defined _MSC_VER
  33 #ifndef min
  34 #define min(a,b)    (((a) < (b)) ? (a) : (b))
  35 #endif
  36 #ifndef max
  37 #define max(a,b)    (((a) > (b)) ? (a) : (b))
  38 #endif
  39 #endif
  40
  41 #include "prewin.h"
  42 #include <gdiplus.h>
  43 #include "postwin.h"
  44
  45
  46 inline void ImplSetPixel4( sal_uInt8* pScanline, long nX, const BYTE cIndex )
  47 {
  48     BYTE& rByte = pScanline[ nX >> 1 ];
  49
  50     if ( nX & 1 )
  51     {
  52         rByte &= 0xf0;
  53         rByte |= cIndex & 0x0f;
  54     }
  55     else
  56     {
  57         rByte &= 0x0f;
  58         rByte |= cIndex << 4;
  59     }
  60 }
  61
  62 // Helper class to manage Gdiplus::Bitmap instances inside of
  63 // WinSalBitmap
  64
  65 typedef ::std::map< WinSalBitmap*, sal_uInt32 > EntryMap;
  66 static const sal_uInt32 nDefaultCycles(60);
  67
  68 class GdiPlusBuffer : protected cppu::BaseMutex, public Timer
  69 {
  70 private:
  71     EntryMap        maEntries;
  72
  73 public:
  74     GdiPlusBuffer()
  75     :   Timer(),
  76         maEntries()
  77     {
  78         SetTimeout(1000);
  79         Stop();
  80     }
  81
  82     ~GdiPlusBuffer() override
  83     {
  84         Stop();
  85     }
  86
  87     void addEntry(WinSalBitmap& rEntry)
  88     {
  89         ::osl::MutexGuard aGuard(m_aMutex);
  90         EntryMap::iterator aFound = maEntries.find(&rEntry);
  91
  92         if(aFound == maEntries.end())
  93         {
  94             if(maEntries.empty())
  95             {
  96                 Start();
  97             }
  98
  99             maEntries[&rEntry] = nDefaultCycles;
 100         }
 101     }
 102
 103     void remEntry(WinSalBitmap& rEntry)
 104     {
 105         ::osl::MutexGuard aGuard(m_aMutex);
 106         EntryMap::iterator aFound = maEntries.find(&rEntry);
 107
 108         if(aFound != maEntries.end())
 109         {
 110             maEntries.erase(aFound);
 111
 112             if(maEntries.empty())
 113             {
 114                 Stop();
 115             }
 116         }
 117     }
 118
 119     void touchEntry(WinSalBitmap& rEntry)
 120     {
 121         ::osl::MutexGuard aGuard(m_aMutex);
 122         EntryMap::iterator aFound = maEntries.find(&rEntry);
 123
 124         if(aFound != maEntries.end())
 125         {
 126             aFound->second = nDefaultCycles;
 127         }
 128     }
 129
 130     // from parent Timer
 131     virtual void Invoke() override
 132     {
 133         ::osl::MutexGuard aGuard(m_aMutex);
 134         EntryMap::iterator aIter(maEntries.begin());
 135
 136         while(aIter != maEntries.end())
 137         {
 138             if(aIter->second)
 139             {
 140                 aIter->second--;
 141                 ++aIter;
 142             }
 143             else
 144             {
 145                 EntryMap::iterator aDelete(aIter);
 146                 WinSalBitmap* pSource = aDelete->first;
 147                 ++aIter;
 148                 maEntries.erase(aDelete);
 149
 150                 if(maEntries.empty())
 151                 {
 152                     Stop();
 153                 }
 154
 155                 // delete at WinSalBitmap after entry is removed; this
 156                 // way it would not hurt to call remEntry from there, too
 157                 if(pSource->maGdiPlusBitmap.get())
 158                 {
 159                     pSource->maGdiPlusBitmap.reset();
 160                     pSource->mpAssociatedAlpha = nullptr;
 161                 }
 162             }
 163         }
 164
 165         if(!maEntries.empty())
 166         {
 167             Start();
 168         }
 169     }
 170 };
 171
 172 // Global instance of GdiPlusBuffer which manages Gdiplus::Bitmap
 173 // instances
 174
 175 static GdiPlusBuffer aGdiPlusBuffer;
 176
 177
 178 WinSalBitmap::WinSalBitmap()
 179 :   maSize(),
 180     mhDIB(nullptr),
 181     mhDDB(nullptr),
 182     maGdiPlusBitmap(),
 183     mpAssociatedAlpha(nullptr),
 184     mnBitCount(0)
 185 {
 186 }
 187
 188 WinSalBitmap::~WinSalBitmap()
 189 {
 190     Destroy();
 191 }
 192
 193 void WinSalBitmap::Destroy()
 194 {
 195     if(maGdiPlusBitmap.get())
 196     {
 197         aGdiPlusBuffer.remEntry(*this);
 198     }
 199
 200     if( mhDIB )
 201         GlobalFree( mhDIB );
 202     else if( mhDDB )
 203         DeleteObject( mhDDB );
 204
 205     maSize = Size();
 206     mnBitCount = 0;
 207 }
 208
 209 std::shared_ptr< Gdiplus::Bitmap > WinSalBitmap::ImplGetGdiPlusBitmap(const WinSalBitmap* pAlphaSource) const
 210 {
 211     WinSalBitmap* pThat = const_cast< WinSalBitmap* >(this);
 212
 213     if(maGdiPlusBitmap.get() && pAlphaSource != mpAssociatedAlpha)
 214     {
 215         // #122350# if associated alpha with which the GDIPlus was constructed has changed
 216         // it is necessary to remove it from buffer, reset reference to it and reconstruct
 217         pThat->maGdiPlusBitmap.reset();
 218         aGdiPlusBuffer.remEntry(const_cast< WinSalBitmap& >(*this));
 219     }
 220
 221     if(maGdiPlusBitmap.get())
 222     {
 223         aGdiPlusBuffer.touchEntry(const_cast< WinSalBitmap& >(*this));
 224     }
 225     else
 226     {
 227         if(maSize.Width() > 0 && maSize.Height() > 0)
 228         {
 229             if(pAlphaSource)
 230             {
 231                 pThat->maGdiPlusBitmap.reset(pThat->ImplCreateGdiPlusBitmap(*pAlphaSource));
 232                 pThat->mpAssociatedAlpha = pAlphaSource;
 233             }
 234             else
 235             {
 236                 pThat->maGdiPlusBitmap.reset(pThat->ImplCreateGdiPlusBitmap());
 237                 pThat->mpAssociatedAlpha = nullptr;
 238             }
 239
 240             if(maGdiPlusBitmap.get())
 241             {
 242                 aGdiPlusBuffer.addEntry(*pThat);
 243             }
 244         }
 245     }
 246
 247     return maGdiPlusBitmap;
 248 }
 249
 250 Gdiplus::Bitmap* WinSalBitmap::ImplCreateGdiPlusBitmap()
 251 {
 252     Gdiplus::Bitmap* pRetval(nullptr);
 253     WinSalBitmap* pSalRGB = this;
 254     WinSalBitmap* pExtraWinSalRGB = nullptr;
 255
 256     if(!pSalRGB->ImplGethDIB())
 257     {
 258         // we need DIB for success with AcquireBuffer, create a replacement WinSalBitmap
 259         pExtraWinSalRGB = new WinSalBitmap();
 260         pExtraWinSalRGB->Create(*pSalRGB, pSalRGB->GetBitCount());
 261         pSalRGB = pExtraWinSalRGB;
 262     }
 263
 264     BitmapBuffer* pRGB = pSalRGB->AcquireBuffer(BitmapAccessMode::Read);
 265     BitmapBuffer* pExtraRGB = nullptr;
 266
 267     if(pRGB && ScanlineFormat::N24BitTcBgr != (pRGB->mnFormat & ~ScanlineFormat::TopDown))
 268     {
 269         // convert source bitmap to BMP_FORMAT_24BIT_TC_BGR format if not yet in that format
 270         SalTwoRect aSalTwoRect(0, 0, pRGB->mnWidth, pRGB->mnHeight, 0, 0, pRGB->mnWidth, pRGB->mnHeight);
 271         pExtraRGB = StretchAndConvert(
 272             *pRGB,
 273             aSalTwoRect,
 274             ScanlineFormat::N24BitTcBgr);
 275
 276         pSalRGB->ReleaseBuffer(pRGB, BitmapAccessMode::Write);
 277         pRGB = pExtraRGB;
 278     }
 279
 280     if(pRGB
 281         && pRGB->mnWidth > 0
 282         && pRGB->mnHeight > 0
 283         && ScanlineFormat::N24BitTcBgr == (pRGB->mnFormat & ~ScanlineFormat::TopDown))
 284     {
 285         const sal_uInt32 nW(pRGB->mnWidth);
 286         const sal_uInt32 nH(pRGB->mnHeight);
 287
 288         pRetval = new Gdiplus::Bitmap(nW, nH, PixelFormat24bppRGB);
 289
 290         if ( pRetval->GetLastStatus() == Gdiplus::Ok )
 291         {
 292             sal_uInt8* pSrcRGB(pRGB->mpBits);
 293             const sal_uInt32 nExtraRGB(pRGB->mnScanlineSize - (nW * 3));
 294             const bool bTopDown(pRGB->mnFormat & ScanlineFormat::TopDown);
 295             const Gdiplus::Rect aAllRect(0, 0, nW, nH);
 296             Gdiplus::BitmapData aGdiPlusBitmapData;
 297             pRetval->LockBits(&aAllRect, Gdiplus::ImageLockModeWrite, PixelFormat24bppRGB, &aGdiPlusBitmapData);
 298
 299             // copy data to Gdiplus::Bitmap; format is BGR here in both cases, so memcpy is possible
 300             for(sal_uInt32 y(0); y < nH; y++)
 301             {
 302                 const sal_uInt32 nYInsert(bTopDown ? y : nH - y - 1);
 303                 sal_uInt8* targetPixels = static_cast<sal_uInt8*>(aGdiPlusBitmapData.Scan0) + (nYInsert * aGdiPlusBitmapData.Stride);
 304
 305                 memcpy(targetPixels, pSrcRGB, nW * 3);
 306                 pSrcRGB += nW * 3 + nExtraRGB;
 307             }
 308
 309             pRetval->UnlockBits(&aGdiPlusBitmapData);
 310         }
 311         else
 312         {
 313             delete pRetval;
 314             pRetval = nullptr;
 315         }
 316     }
 317
 318     if(pExtraRGB)
 319     {
 320         // #i123478# shockingly, BitmapBuffer does not free the memory it is controlling
 321         // in its destructor, this *has to be done handish*. Doing it here now
 322         delete[] pExtraRGB->mpBits;
 323         delete pExtraRGB;
 324     }
 325     else
 326     {
 327         pSalRGB->ReleaseBuffer(pRGB, BitmapAccessMode::Read);
 328     }
 329
 330     if(pExtraWinSalRGB)
 331     {
 332         delete pExtraWinSalRGB;
 333     }
 334
 335     return pRetval;
 336 }
 337
 338 Gdiplus::Bitmap* WinSalBitmap::ImplCreateGdiPlusBitmap(const WinSalBitmap& rAlphaSource)
 339 {
 340     Gdiplus::Bitmap* pRetval(nullptr);
 341     WinSalBitmap* pSalRGB = this;
 342     WinSalBitmap* pExtraWinSalRGB = nullptr;
 343
 344     if(!pSalRGB->ImplGethDIB())
 345     {
 346         // we need DIB for success with AcquireBuffer, create a replacement WinSalBitmap
 347         pExtraWinSalRGB = new WinSalBitmap();
 348         pExtraWinSalRGB->Create(*pSalRGB, pSalRGB->GetBitCount());
 349         pSalRGB = pExtraWinSalRGB;
 350     }
 351
 352     BitmapBuffer* pRGB = pSalRGB->AcquireBuffer(BitmapAccessMode::Read);
 353     BitmapBuffer* pExtraRGB = nullptr;
 354
 355     if(pRGB && ScanlineFormat::N24BitTcBgr != (pRGB->mnFormat & ~ScanlineFormat::TopDown))
 356     {
 357         // convert source bitmap to canlineFormat::N24BitTcBgr format if not yet in that format
 358         SalTwoRect aSalTwoRect(0, 0, pRGB->mnWidth, pRGB->mnHeight, 0, 0, pRGB->mnWidth, pRGB->mnHeight);
 359         pExtraRGB = StretchAndConvert(
 360             *pRGB,
 361             aSalTwoRect,
 362             ScanlineFormat::N24BitTcBgr);
 363
 364         pSalRGB->ReleaseBuffer(pRGB, BitmapAccessMode::Read);
 365         pRGB = pExtraRGB;
 366     }
 367
 368     WinSalBitmap* pSalA = const_cast< WinSalBitmap* >(&rAlphaSource);
 369     WinSalBitmap* pExtraWinSalA = nullptr;
 370
 371     if(!pSalA->ImplGethDIB())
 372     {
 373         // we need DIB for success with AcquireBuffer, create a replacement WinSalBitmap
 374         pExtraWinSalA = new WinSalBitmap();
 375         pExtraWinSalA->Create(*pSalA, pSalA->GetBitCount());
 376         pSalA = pExtraWinSalA;
 377     }
 378
 379     BitmapBuffer* pA = pSalA->AcquireBuffer(BitmapAccessMode::Read);
 380     BitmapBuffer* pExtraA = nullptr;
 381
 382     if(pA && ScanlineFormat::N8BitPal != (pA->mnFormat & ~ScanlineFormat::TopDown))
 383     {
 384         // convert alpha bitmap to ScanlineFormat::N8BitPal format if not yet in that format
 385         SalTwoRect aSalTwoRect(0, 0, pA->mnWidth, pA->mnHeight, 0, 0, pA->mnWidth, pA->mnHeight);
 386         const BitmapPalette& rTargetPalette = Bitmap::GetGreyPalette(256);
 387
 388         pExtraA = StretchAndConvert(
 389             *pA,
 390             aSalTwoRect,
 391             ScanlineFormat::N8BitPal,
 392             &rTargetPalette);
 393
 394         pSalA->ReleaseBuffer(pA, BitmapAccessMode::Read);
 395         pA = pExtraA;
 396     }
 397
 398     if(pRGB
 399         && pA
 400         && pRGB->mnWidth > 0
 401         && pRGB->mnHeight > 0
 402         && pRGB->mnWidth == pA->mnWidth
 403         && pRGB->mnHeight == pA->mnHeight
 404         && ScanlineFormat::N24BitTcBgr == (pRGB->mnFormat & ~ScanlineFormat::TopDown)
 405         && ScanlineFormat::N8BitPal == (pA->mnFormat & ~ScanlineFormat::TopDown))
 406     {
 407         // we have alpha and bitmap in known formats, create GdiPlus Bitmap as 32bit ARGB
 408         const sal_uInt32 nW(pRGB->mnWidth);
 409         const sal_uInt32 nH(pRGB->mnHeight);
 410
 411         pRetval = new Gdiplus::Bitmap(nW, nH, PixelFormat32bppARGB);
 412
 413         if ( pRetval->GetLastStatus() == Gdiplus::Ok ) // 2nd place to secure with new Gdiplus::Bitmap
 414         {
 415             sal_uInt8* pSrcRGB(pRGB->mpBits);
 416             sal_uInt8* pSrcA(pA->mpBits);
 417             const sal_uInt32 nExtraRGB(pRGB->mnScanlineSize - (nW * 3));
 418             const sal_uInt32 nExtraA(pA->mnScanlineSize - nW);
 419             const bool bTopDown(pRGB->mnFormat & ScanlineFormat::TopDown);
 420             const Gdiplus::Rect aAllRect(0, 0, nW, nH);
 421             Gdiplus::BitmapData aGdiPlusBitmapData;
 422             pRetval->LockBits(&aAllRect, Gdiplus::ImageLockModeWrite, PixelFormat32bppARGB, &aGdiPlusBitmapData);
 423
 424             // copy data to Gdiplus::Bitmap; format is BGRA; need to mix BGR from Bitmap and
 425             // A from alpha, so inner loop is needed (who invented BitmapEx..?)
 426             for(sal_uInt32 y(0); y < nH; y++)
 427             {
 428                 const sal_uInt32 nYInsert(bTopDown ? y : nH - y - 1);
 429                 sal_uInt8* targetPixels = static_cast<sal_uInt8*>(aGdiPlusBitmapData.Scan0) + (nYInsert * aGdiPlusBitmapData.Stride);
 430
 431                 for(sal_uInt32 x(0); x < nW; x++)
 432                 {
 433                     *targetPixels++ = *pSrcRGB++;
 434                     *targetPixels++ = *pSrcRGB++;
 435                     *targetPixels++ = *pSrcRGB++;
 436                     *targetPixels++ = 0xff - *pSrcA++;
 437                 }
 438
 439                 pSrcRGB += nExtraRGB;
 440                 pSrcA += nExtraA;
 441             }
 442
 443             pRetval->UnlockBits(&aGdiPlusBitmapData);
 444         }
 445         else
 446         {
 447             delete pRetval;
 448             pRetval = nullptr;
 449         }
 450     }
 451
 452     if(pExtraA)
 453     {
 454         // #i123478# shockingly, BitmapBuffer does not free the memory it is controlling
 455         // in its destructor, this *has to be done handish*. Doing it here now
 456         delete[] pExtraA->mpBits;
 457         delete pExtraA;
 458     }
 459     else
 460     {
 461         pSalA->ReleaseBuffer(pA, BitmapAccessMode::Read);
 462     }
 463
 464     if(pExtraWinSalA)
 465     {
 466         delete pExtraWinSalA;
 467     }
 468
 469     if(pExtraRGB)
 470     {
 471         // #i123478# shockingly, BitmapBuffer does not free the memory it is controlling
 472         // in its destructor, this *has to be done handish*. Doing it here now
 473         delete[] pExtraRGB->mpBits;
 474         delete pExtraRGB;
 475     }
 476     else
 477     {
 478         pSalRGB->ReleaseBuffer(pRGB, BitmapAccessMode::Read);
 479     }
 480
 481     if(pExtraWinSalRGB)
 482     {
 483         delete pExtraWinSalRGB;
 484     }
 485
 486     return pRetval;
 487 }
 488
 489 bool WinSalBitmap::Create( HANDLE hBitmap, bool bDIB, bool bCopyHandle )
 490 {
 491     bool bRet = TRUE;
 492
 493     if( bDIB )
 494         mhDIB = static_cast<HGLOBAL>( bCopyHandle ? ImplCopyDIBOrDDB( hBitmap, true ) : hBitmap );
 495     else
 496         mhDDB = static_cast<HBITMAP>( bCopyHandle ? ImplCopyDIBOrDDB( hBitmap, false ) : hBitmap );
 497
 498     if( mhDIB )
 499     {
 500         PBITMAPINFOHEADER pBIH = static_cast<PBITMAPINFOHEADER>(GlobalLock( mhDIB ));
 501
 502         maSize = Size( pBIH->biWidth, pBIH->biHeight );
 503         mnBitCount = pBIH->biBitCount;
 504
 505         if( mnBitCount )
 506             mnBitCount = ( mnBitCount <= 1 ) ? 1 : ( mnBitCount <= 4 ) ? 4 : ( mnBitCount <= 8 ) ? 8 : 24;
 507
 508         GlobalUnlock( mhDIB );
 509     }
 510     else if( mhDDB )
 511     {
 512         BITMAP  aDDBInfo;
 513
 514         if( GetObjectA( mhDDB, sizeof( BITMAP ), &aDDBInfo ) )
 515         {
 516             maSize = Size( aDDBInfo.bmWidth, aDDBInfo.bmHeight );
 517             mnBitCount = aDDBInfo.bmPlanes * aDDBInfo.bmBitsPixel;
 518
 519             if( mnBitCount )
 520             {
 521                 mnBitCount = ( mnBitCount <= 1 ) ? 1 :
 522                              ( mnBitCount <= 4 ) ? 4 :
 523                              ( mnBitCount <= 8 ) ? 8 : 24;
 524             }
 525         }
 526         else
 527         {
 528             mhDDB = nullptr;
 529             bRet = FALSE;
 530         }
 531     }
 532     else
 533         bRet = FALSE;
 534
 535     return bRet;
 536 }
 537
 538 bool WinSalBitmap::Create( const Size& rSize, sal_uInt16 nBitCount, const BitmapPalette& rPal )
 539 {
 540     bool bRet = FALSE;
 541
 542     mhDIB = ImplCreateDIB( rSize, nBitCount, rPal );
 543
 544     if( mhDIB )
 545     {
 546         maSize = rSize;
 547         mnBitCount = nBitCount;
 548         bRet = TRUE;
 549     }
 550
 551     return bRet;
 552 }
 553
 554 bool WinSalBitmap::Create( const SalBitmap& rSSalBitmap )
 555 {
 556     bool bRet = FALSE;
 557     const WinSalBitmap& rSalBitmap = static_cast<const WinSalBitmap&>(rSSalBitmap);
 558
 559     if ( rSalBitmap.mhDIB || rSalBitmap.mhDDB )
 560     {
 561         HANDLE hNewHdl = ImplCopyDIBOrDDB( rSalBitmap.mhDIB ? rSalBitmap.mhDIB : rSalBitmap.mhDDB,
 562                                            rSalBitmap.mhDIB != nullptr );
 563
 564         if ( hNewHdl )
 565         {
 566             if( rSalBitmap.mhDIB )
 567                 mhDIB = static_cast<HGLOBAL>(hNewHdl);
 568             else if( rSalBitmap.mhDDB )
 569                 mhDDB = static_cast<HBITMAP>(hNewHdl);
 570
 571             maSize = rSalBitmap.maSize;
 572             mnBitCount = rSalBitmap.mnBitCount;
 573
 574             bRet = TRUE;
 575         }
 576     }
 577
 578     return bRet;
 579 }
 580
 581 bool WinSalBitmap::Create( const SalBitmap& rSSalBmp, SalGraphics* pSGraphics )
 582 {
 583     bool bRet = FALSE;
 584
 585     const WinSalBitmap& rSalBmp = static_cast<const WinSalBitmap&>(rSSalBmp);
 586     WinSalGraphics* pGraphics = static_cast<WinSalGraphics*>(pSGraphics);
 587
 588     if( rSalBmp.mhDIB )
 589     {
 590         PBITMAPINFO         pBI = static_cast<PBITMAPINFO>(GlobalLock( rSalBmp.mhDIB ));
 591         HDC                 hDC  = pGraphics->getHDC();
 592         HBITMAP             hNewDDB;
 593         BITMAP              aDDBInfo;
 594         PBYTE               pBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize +
 595                             ImplGetDIBColorCount( rSalBmp.mhDIB ) * sizeof( RGBQUAD );
 596
 597         if( pBI->bmiHeader.biBitCount == 1 )
 598         {
 599             hNewDDB = CreateBitmap( pBI->bmiHeader.biWidth, pBI->bmiHeader.biHeight, 1, 1, nullptr );
 600
 601             if( hNewDDB )
 602                 SetDIBits( hDC, hNewDDB, 0, pBI->bmiHeader.biHeight, pBits, pBI, DIB_RGB_COLORS );
 603         }
 604         else
 605             hNewDDB = CreateDIBitmap( hDC, &pBI->bmiHeader, CBM_INIT, pBits, pBI, DIB_RGB_COLORS );
 606
 607         GlobalUnlock( rSalBmp.mhDIB );
 608
 609         if( hNewDDB && GetObjectA( hNewDDB, sizeof( BITMAP ), &aDDBInfo ) )
 610         {
 611             mhDDB = hNewDDB;
 612             maSize = Size( aDDBInfo.bmWidth, aDDBInfo.bmHeight );
 613             mnBitCount = aDDBInfo.bmPlanes * aDDBInfo.bmBitsPixel;
 614
 615             bRet = TRUE;
 616         }
 617         else if( hNewDDB )
 618             DeleteObject( hNewDDB );
 619     }
 620
 621     return bRet;
 622 }
 623
 624 bool WinSalBitmap::Create( const SalBitmap& rSSalBmp, sal_uInt16 nNewBitCount )
 625 {
 626     bool bRet = FALSE;
 627
 628     const WinSalBitmap& rSalBmp = static_cast<const WinSalBitmap&>(rSSalBmp);
 629
 630     if( rSalBmp.mhDDB )
 631     {
 632         mhDIB = ImplCreateDIB( rSalBmp.maSize, nNewBitCount, BitmapPalette() );
 633
 634         if( mhDIB )
 635         {
 636             PBITMAPINFO pBI = static_cast<PBITMAPINFO>(GlobalLock( mhDIB ));
 637             const int   nLines = (int) rSalBmp.maSize.Height();
 638             HDC         hDC = GetDC( nullptr );
 639             PBYTE       pBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize +
 640                                 ImplGetDIBColorCount( mhDIB ) * sizeof( RGBQUAD );
 641             SalData*    pSalData = GetSalData();
 642             HPALETTE    hOldPal = nullptr;
 643
 644             if ( pSalData->mhDitherPal )
 645             {
 646                 hOldPal = SelectPalette( hDC, pSalData->mhDitherPal, TRUE );
 647                 RealizePalette( hDC );
 648             }
 649
 650             if( GetDIBits( hDC, rSalBmp.mhDDB, 0, nLines, pBits, pBI, DIB_RGB_COLORS ) == nLines )
 651             {
 652                 GlobalUnlock( mhDIB );
 653                 maSize = rSalBmp.maSize;
 654                 mnBitCount = nNewBitCount;
 655                 bRet = TRUE;
 656             }
 657             else
 658             {
 659                 GlobalUnlock( mhDIB );
 660                 GlobalFree( mhDIB );
 661                 mhDIB = nullptr;
 662             }
 663
 664             if( hOldPal )
 665                 SelectPalette( hDC, hOldPal, TRUE );
 666
 667             ReleaseDC( nullptr, hDC );
 668         }
 669     }
 670
 671     return bRet;
 672 }
 673
 674 bool WinSalBitmap::Create( const css::uno::Reference< css::rendering::XBitmapCanvas >& rBitmapCanvas, Size& /*rSize*/, bool bMask )
 675 {
 676     css::uno::Reference< css::beans::XFastPropertySet >
 677         xFastPropertySet( rBitmapCanvas, css::uno::UNO_QUERY );
 678
 679     if( xFastPropertySet.get() ) {
 680         css::uno::Sequence< css::uno::Any > args;
 681
 682         if( xFastPropertySet->getFastPropertyValue(bMask ? 2 : 1) >>= args ) {
 683             sal_Int64 aHBmp64;
 684
 685             if( args[0] >>= aHBmp64 ) {
 686                 return Create( HBITMAP(aHBmp64), false, false );
 687             }
 688         }
 689     }
 690     return false;
 691 }
 692
 693 sal_uInt16 WinSalBitmap::ImplGetDIBColorCount( HGLOBAL hDIB )
 694 {
 695     sal_uInt16 nColors = 0;
 696
 697     if( hDIB )
 698     {
 699         PBITMAPINFO         pBI = static_cast<PBITMAPINFO>(GlobalLock( hDIB ));
 700
 701         if ( pBI->bmiHeader.biSize != sizeof( BITMAPCOREHEADER ) )
 702         {
 703             if( pBI->bmiHeader.biBitCount <= 8 )
 704             {
 705                 if ( pBI->bmiHeader.biClrUsed )
 706                     nColors = (sal_uInt16) pBI->bmiHeader.biClrUsed;
 707                 else
 708                     nColors = 1 << pBI->bmiHeader.biBitCount;
 709             }
 710         }
 711         else if( reinterpret_cast<PBITMAPCOREHEADER>(pBI)->bcBitCount <= 8 )
 712             nColors = 1 << reinterpret_cast<PBITMAPCOREHEADER>(pBI)->bcBitCount;
 713
 714         GlobalUnlock( hDIB );
 715     }
 716
 717     return nColors;
 718 }
 719
 720 HGLOBAL WinSalBitmap::ImplCreateDIB( const Size& rSize, sal_uInt16 nBits, const BitmapPalette& rPal )
 721 {
 722     SAL_WARN_IF( nBits != 1 && nBits != 4 && nBits != 8 && nBits != 16 && nBits != 24, "vcl", "Unsupported BitCount!" );
 723
 724     HGLOBAL hDIB = nullptr;
 725
 726     if( rSize.Width() <= 0 || rSize.Height() <= 0 )
 727         return hDIB;
 728
 729     // calculate bitmap size in Bytes
 730     const sal_uLong nAlignedWidth4Bytes = AlignedWidth4Bytes( nBits * rSize.Width() );
 731     const sal_uLong nImageSize = nAlignedWidth4Bytes * rSize.Height();
 732     bool bOverflow = (nImageSize / nAlignedWidth4Bytes) != (sal_uLong) rSize.Height();
 733     if( bOverflow )
 734         return hDIB;
 735
 736     // allocate bitmap memory including header and palette
 737     const sal_uInt16 nColors = (nBits <= 8) ? (1 << nBits) : 0;
 738     const sal_uLong nHeaderSize = sizeof( BITMAPINFOHEADER ) + nColors * sizeof( RGBQUAD );
 739     bOverflow = (nHeaderSize + nImageSize) < nImageSize;
 740     if( bOverflow )
 741         return hDIB;
 742
 743     hDIB = GlobalAlloc( GHND, nHeaderSize + nImageSize );
 744     if( !hDIB )
 745         return hDIB;
 746
 747     PBITMAPINFO pBI = static_cast<PBITMAPINFO>( GlobalLock( hDIB ) );
 748     PBITMAPINFOHEADER pBIH = reinterpret_cast<PBITMAPINFOHEADER>( pBI );
 749
 750     pBIH->biSize = sizeof( BITMAPINFOHEADER );
 751     pBIH->biWidth = rSize.Width();
 752     pBIH->biHeight = rSize.Height();
 753     pBIH->biPlanes = 1;
 754     pBIH->biBitCount = nBits;
 755     pBIH->biCompression = BI_RGB;
 756     pBIH->biSizeImage = nImageSize;
 757     pBIH->biXPelsPerMeter = 0;
 758     pBIH->biYPelsPerMeter = 0;
 759     pBIH->biClrUsed = 0;
 760     pBIH->biClrImportant = 0;
 761
 762     if( nColors )
 763     {
 764         // copy the palette entries if any
 765         const sal_uInt16 nMinCount = (std::min)( nColors, rPal.GetEntryCount() );
 766         if( nMinCount )
 767             memcpy( pBI->bmiColors, rPal.ImplGetColorBuffer(), nMinCount * sizeof(RGBQUAD) );
 768     }
 769
 770     GlobalUnlock( hDIB );
 771
 772     return hDIB;
 773 }
 774
 775 HANDLE WinSalBitmap::ImplCopyDIBOrDDB( HANDLE hHdl, bool bDIB )
 776 {
 777     HANDLE  hCopy = nullptr;
 778
 779     if ( bDIB && hHdl )
 780     {
 781         const sal_uLong nSize = GlobalSize( hHdl );
 782
 783         if ( (hCopy = GlobalAlloc( GHND, nSize  )) != nullptr )
 784         {
 785             memcpy( GlobalLock( hCopy ), GlobalLock( hHdl ), nSize );
 786
 787             GlobalUnlock( hCopy );
 788             GlobalUnlock( hHdl );
 789         }
 790     }
 791     else if ( hHdl )
 792     {
 793         BITMAP aBmp;
 794
 795         // find out size of source bitmap
 796         GetObjectA( hHdl, sizeof( BITMAP ), &aBmp );
 797
 798         // create destination bitmap
 799         if ( (hCopy = CreateBitmapIndirect( &aBmp )) != nullptr )
 800         {
 801             HDC     hBmpDC = CreateCompatibleDC( nullptr );
 802             HBITMAP hBmpOld = static_cast<HBITMAP>(SelectObject( hBmpDC, hHdl ));
 803             HDC     hCopyDC = CreateCompatibleDC( hBmpDC );
 804             HBITMAP hCopyOld = static_cast<HBITMAP>(SelectObject( hCopyDC, hCopy ));
 805
 806             BitBlt( hCopyDC, 0, 0, aBmp.bmWidth, aBmp.bmHeight, hBmpDC, 0, 0, SRCCOPY );
 807
 808             SelectObject( hCopyDC, hCopyOld );
 809             DeleteDC( hCopyDC );
 810
 811             SelectObject( hBmpDC, hBmpOld );
 812             DeleteDC( hBmpDC );
 813         }
 814     }
 815
 816     return hCopy;
 817 }
 818
 819 BitmapBuffer* WinSalBitmap::AcquireBuffer( BitmapAccessMode /*nMode*/ )
 820 {
 821     BitmapBuffer* pBuffer = nullptr;
 822
 823     if( mhDIB )
 824     {
 825         PBITMAPINFO         pBI = static_cast<PBITMAPINFO>(GlobalLock( mhDIB ));
 826         PBITMAPINFOHEADER   pBIH = &pBI->bmiHeader;
 827
 828         if( ( pBIH->biCompression == BI_RLE4 ) || ( pBIH->biCompression == BI_RLE8 ) )
 829         {
 830             Size    aSizePix( pBIH->biWidth, pBIH->biHeight );
 831             HGLOBAL hNewDIB = ImplCreateDIB( aSizePix, pBIH->biBitCount, BitmapPalette() );
 832
 833             if( hNewDIB )
 834             {
 835                 PBITMAPINFO         pNewBI = static_cast<PBITMAPINFO>(GlobalLock( hNewDIB ));
 836                 PBITMAPINFOHEADER   pNewBIH = &pNewBI->bmiHeader;
 837                 const sal_uInt16        nColorCount = ImplGetDIBColorCount( hNewDIB );
 838                 const sal_uLong         nOffset = pBI->bmiHeader.biSize + nColorCount * sizeof( RGBQUAD );
 839                 BYTE*               pOldBits = reinterpret_cast<PBYTE>(pBI) + nOffset;
 840                 BYTE*               pNewBits = reinterpret_cast<PBYTE>(pNewBI) + nOffset;
 841
 842                 memcpy( pNewBI, pBI, nOffset );
 843                 pNewBIH->biCompression = 0;
 844                 ImplDecodeRLEBuffer( pOldBits, pNewBits, aSizePix, pBIH->biCompression == BI_RLE4 );
 845
 846                 GlobalUnlock( mhDIB );
 847                 GlobalFree( mhDIB );
 848                 mhDIB = hNewDIB;
 849                 pBI = pNewBI;
 850                 pBIH = pNewBIH;
 851             }
 852         }
 853
 854         if( pBIH->biPlanes == 1 )
 855         {
 856             pBuffer = new BitmapBuffer;
 857
 858             pBuffer->mnFormat = pBIH->biBitCount == 1 ? ScanlineFormat::N1BitMsbPal :
 859                                 pBIH->biBitCount == 4 ? ScanlineFormat::N4BitMsnPal :
 860                                 pBIH->biBitCount == 8 ? ScanlineFormat::N8BitPal :
 861                                 pBIH->biBitCount == 16 ? ScanlineFormat::N16BitTcLsbMask :
 862                                 pBIH->biBitCount == 24 ? ScanlineFormat::N24BitTcBgr :
 863                                 pBIH->biBitCount == 32 ? ScanlineFormat::N32BitTcMask :
 864                                 ScanlineFormat::NONE;
 865
 866             if( RemoveScanline( pBuffer->mnFormat ) != ScanlineFormat::NONE )
 867             {
 868                 pBuffer->mnWidth = maSize.Width();
 869                 pBuffer->mnHeight = maSize.Height();
 870                 pBuffer->mnScanlineSize = AlignedWidth4Bytes( maSize.Width() * pBIH->biBitCount );
 871                 pBuffer->mnBitCount = (sal_uInt16) pBIH->biBitCount;
 872
 873                 if( pBuffer->mnBitCount <= 8 )
 874                 {
 875                     const sal_uInt16 nPalCount = ImplGetDIBColorCount( mhDIB );
 876
 877                     pBuffer->maPalette.SetEntryCount( nPalCount );
 878                     memcpy( pBuffer->maPalette.ImplGetColorBuffer(), pBI->bmiColors, nPalCount * sizeof( RGBQUAD ) );
 879                     pBuffer->mpBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize + nPalCount * sizeof( RGBQUAD );
 880                 }
 881                 else if( ( pBIH->biBitCount == 16 ) || ( pBIH->biBitCount == 32 ) )
 882                 {
 883                     sal_uLong nOffset = 0;
 884
 885                     if( pBIH->biCompression == BI_BITFIELDS )
 886                     {
 887                         nOffset = 3 * sizeof( RGBQUAD );
 888                         ColorMaskElement aRedMask(*reinterpret_cast<UINT32*>(&pBI->bmiColors[ 0 ]));
 889                         aRedMask.CalcMaskShift();
 890                         ColorMaskElement aGreenMask(*reinterpret_cast<UINT32*>(&pBI->bmiColors[ 1 ]));
 891                         aGreenMask.CalcMaskShift();
 892                         ColorMaskElement aBlueMask(*reinterpret_cast<UINT32*>(&pBI->bmiColors[ 2 ]));
 893                         aBlueMask.CalcMaskShift();
 894                         pBuffer->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
 895                     }
 896                     else if( pBIH->biBitCount == 16 )
 897                     {
 898                         ColorMaskElement aRedMask(0x00007c00UL);
 899                         aRedMask.CalcMaskShift();
 900                         ColorMaskElement aGreenMask(0x000003e0UL);
 901                         aGreenMask.CalcMaskShift();
 902                         ColorMaskElement aBlueMask(0x0000001fUL);
 903                         aBlueMask.CalcMaskShift();
 904                         pBuffer->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
 905                     }
 906                     else
 907                     {
 908                         ColorMaskElement aRedMask(0x00ff0000UL);
 909                         aRedMask.CalcMaskShift();
 910                         ColorMaskElement aGreenMask(0x0000ff00UL);
 911                         aGreenMask.CalcMaskShift();
 912                         ColorMaskElement aBlueMask(0x000000ffUL);
 913                         aBlueMask.CalcMaskShift();
 914                         pBuffer->maColorMask = ColorMask(aRedMask, aGreenMask, aBlueMask);
 915                     }
 916
 917                     pBuffer->mpBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize + nOffset;
 918                 }
 919                 else
 920                     pBuffer->mpBits = reinterpret_cast<PBYTE>(pBI) + pBI->bmiHeader.biSize;
 921             }
 922             else
 923             {
 924                 GlobalUnlock( mhDIB );
 925                 delete pBuffer;
 926                 pBuffer = nullptr;
 927             }
 928         }
 929         else
 930             GlobalUnlock( mhDIB );
 931     }
 932
 933     return pBuffer;
 934 }
 935
 936 void WinSalBitmap::ReleaseBuffer( BitmapBuffer* pBuffer, BitmapAccessMode nMode )
 937 {
 938     if( pBuffer )
 939     {
 940         if( mhDIB )
 941         {
 942             if( nMode == BitmapAccessMode::Write && !!pBuffer->maPalette )
 943             {
 944                 PBITMAPINFO     pBI = static_cast<PBITMAPINFO>(GlobalLock( mhDIB ));
 945                 const sal_uInt16    nCount = pBuffer->maPalette.GetEntryCount();
 946                 const sal_uInt16    nDIBColorCount = ImplGetDIBColorCount( mhDIB );
 947                 memcpy( pBI->bmiColors, pBuffer->maPalette.ImplGetColorBuffer(), (std::min)( nDIBColorCount, nCount ) * sizeof( RGBQUAD ) );
 948                 GlobalUnlock( mhDIB );
 949             }
 950
 951             GlobalUnlock( mhDIB );
 952         }
 953
 954         delete pBuffer;
 955     }
 956 }
 957
 958 void WinSalBitmap::ImplDecodeRLEBuffer( const BYTE* pSrcBuf, BYTE* pDstBuf,
 959                                      const Size& rSizePixel, bool bRLE4 )
 960 {
 961     sal_uInt8 const * pRLE = pSrcBuf;
 962     sal_uInt8*      pDIB = pDstBuf;
 963     sal_uInt8*      pRow = pDstBuf;
 964     sal_uLong       nWidthAl = AlignedWidth4Bytes( rSizePixel.Width() * ( bRLE4 ? 4UL : 8UL ) );
 965     sal_uInt8*      pLast = pDIB + rSizePixel.Height() * nWidthAl - 1;
 966     sal_uLong       nCountByte;
 967     sal_uLong       nRunByte;
 968     sal_uLong       i;
 969     BYTE            cTmp;
 970     bool            bEndDecoding = FALSE;
 971
 972     if( pRLE && pDIB )
 973     {
 974         sal_uLong nX = 0;
 975         do
 976         {
 977             if( ( nCountByte = *pRLE++ ) == 0 )
 978             {
 979                 nRunByte = *pRLE++;
 980
 981                 if( nRunByte > 2 )
 982                 {
 983                     if( bRLE4 )
 984                     {
 985                         nCountByte = nRunByte >> 1;
 986
 987                         for( i = 0; i < nCountByte; i++ )
 988                         {
 989                             cTmp = *pRLE++;
 990                             ImplSetPixel4( pDIB, nX++, cTmp >> 4 );
 991                             ImplSetPixel4( pDIB, nX++, cTmp & 0x0f );
 992                         }
 993
 994                         if( nRunByte & 1 )
 995                             ImplSetPixel4( pDIB, nX++, *pRLE++ >> 4 );
 996
 997                         if( ( ( nRunByte + 1 ) >> 1 ) & 1 )
 998                             pRLE++;
 999                     }
1000                     else
1001                     {
1002                         memcpy( &pDIB[ nX ], pRLE, nRunByte );
1003                         pRLE += nRunByte;
1004                         nX += nRunByte;
1005
1006                         if( nRunByte & 1 )
1007                             pRLE++;
1008                     }
1009                 }
1010                 else if( !nRunByte )
1011                 {
1012                     pDIB = ( pRow += nWidthAl );
1013                     nX = 0;
1014                 }
1015                 else if( nRunByte == 1 )
1016                     bEndDecoding = TRUE;
1017                 else
1018                 {
1019                     nX += *pRLE++;
1020                     pDIB = ( pRow += ( *pRLE++ ) * nWidthAl );
1021                 }
1022             }
1023             else
1024             {
1025                 cTmp = *pRLE++;
1026
1027                 if( bRLE4 )
1028                 {
1029                     nRunByte = nCountByte >> 1;
1030
1031                     for( i = 0; i < nRunByte; i++ )
1032                     {
1033                         ImplSetPixel4( pDIB, nX++, cTmp >> 4 );
1034                         ImplSetPixel4( pDIB, nX++, cTmp & 0x0f );
1035                     }
1036
1037                     if( nCountByte & 1 )
1038                         ImplSetPixel4( pDIB, nX++, cTmp >> 4 );
1039                 }
1040                 else
1041                 {
1042                     for( i = 0; i < nCountByte; i++ )
1043                         pDIB[ nX++ ] = cTmp;
1044                 }
1045             }
1046         }
1047         while( !bEndDecoding && ( pDIB <= pLast ) );
1048     }
1049 }
1050
1051 bool WinSalBitmap::GetSystemData( BitmapSystemData& rData )
1052 {
1053     bool bRet = false;
1054     if( mhDIB || mhDDB )
1055     {
1056         bRet = true;
1057         rData.pDIB = mhDIB;
1058         rData.pDDB = mhDDB;
1059         const Size& rSize = GetSize ();
1060         rData.mnWidth = rSize.Width();
1061         rData.mnHeight = rSize.Height();
1062     }
1063     return bRet;
1064 }
1065
1066 bool WinSalBitmap::ScalingSupported() const
1067 {
1068     return false;
1069 }
1070
1071 bool WinSalBitmap::Scale( const double& /*rScaleX*/, const double& /*rScaleY*/, BmpScaleFlag /*nScaleFlag*/ )
1072 {
1073     return false;
1074 }
1075
1076 bool WinSalBitmap::Replace( const Color& /*rSearchColor*/, const Color& /*rReplaceColor*/, sal_uLong /*nTol*/ )
1077 {
1078     return false;
1079 }
1080
1081 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */