vcl/source/bitmap/dibtools.cxx

   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 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <cassert>
  24
  25 #include <o3tl/safeint.hxx>
  26 #include <vcl/dibtools.hxx>
  27 #include <comphelper/fileformat.h>
  28 #include <tools/zcodec.hxx>
  29 #include <tools/stream.hxx>
  30 #include <tools/fract.hxx>
  31 #include <tools/helpers.hxx>
  32 #include <tools/GenericTypeSerializer.hxx>
  33 #include <comphelper/configuration.hxx>
  34 #include <vcl/bitmapex.hxx>
  35 #include <vcl/outdev.hxx>
  36 #include <vcl/BitmapWriteAccess.hxx>
  37 #include <memory>
  38
  39 #define DIBCOREHEADERSIZE       ( 12UL )
  40 #define DIBINFOHEADERSIZE       ( sizeof(DIBInfoHeader) )
  41 #define DIBV5HEADERSIZE         ( sizeof(DIBV5Header) )
  42
  43 // - DIBInfoHeader and DIBV5Header
  44
  45 typedef sal_Int32 FXPT2DOT30;
  46
  47 namespace
  48 {
  49
  50 struct CIEXYZ
  51 {
  52     FXPT2DOT30      aXyzX;
  53     FXPT2DOT30      aXyzY;
  54     FXPT2DOT30      aXyzZ;
  55
  56     CIEXYZ()
  57     :   aXyzX(0),
  58         aXyzY(0),
  59         aXyzZ(0)
  60     {}
  61 };
  62
  63 struct CIEXYZTriple
  64 {
  65     CIEXYZ          aXyzRed;
  66     CIEXYZ          aXyzGreen;
  67     CIEXYZ          aXyzBlue;
  68
  69     CIEXYZTriple()
  70     {}
  71 };
  72
  73 struct DIBInfoHeader
  74 {
  75     sal_uInt32      nSize;
  76     sal_Int32       nWidth;
  77     sal_Int32       nHeight;
  78     sal_uInt16      nPlanes;
  79     sal_uInt16      nBitCount;
  80     sal_uInt32      nCompression;
  81     sal_uInt32      nSizeImage;
  82     sal_Int32       nXPelsPerMeter;
  83     sal_Int32       nYPelsPerMeter;
  84     sal_uInt32      nColsUsed;
  85     sal_uInt32      nColsImportant;
  86
  87     DIBInfoHeader()
  88     :   nSize(0),
  89         nWidth(0),
  90         nHeight(0),
  91         nPlanes(0),
  92         nBitCount(0),
  93         nCompression(0),
  94         nSizeImage(0),
  95         nXPelsPerMeter(0),
  96         nYPelsPerMeter(0),
  97         nColsUsed(0),
  98         nColsImportant(0)
  99     {}
 100 };
 101
 102 struct DIBV5Header : public DIBInfoHeader
 103 {
 104     sal_uInt32      nV5RedMask;
 105     sal_uInt32      nV5GreenMask;
 106     sal_uInt32      nV5BlueMask;
 107     sal_uInt32      nV5AlphaMask;
 108     sal_uInt32      nV5CSType;
 109     CIEXYZTriple    aV5Endpoints;
 110     sal_uInt32      nV5GammaRed;
 111     sal_uInt32      nV5GammaGreen;
 112     sal_uInt32      nV5GammaBlue;
 113     sal_uInt32      nV5Intent;
 114     sal_uInt32      nV5ProfileData;
 115     sal_uInt32      nV5ProfileSize;
 116     sal_uInt32      nV5Reserved;
 117
 118     DIBV5Header()
 119     :   nV5RedMask(0),
 120         nV5GreenMask(0),
 121         nV5BlueMask(0),
 122         nV5AlphaMask(0),
 123         nV5CSType(0),
 124         nV5GammaRed(0),
 125         nV5GammaGreen(0),
 126         nV5GammaBlue(0),
 127         nV5Intent(0),
 128         nV5ProfileData(0),
 129         nV5ProfileSize(0),
 130         nV5Reserved(0)
 131     {}
 132 };
 133
 134 vcl::PixelFormat convertToBPP(sal_uInt16 nCount)
 135 {
 136     return (nCount <= 8) ? vcl::PixelFormat::N8_BPP :
 137                            vcl::PixelFormat::N24_BPP;
 138 }
 139
 140 bool isBitfieldCompression( ScanlineFormat nScanlineFormat )
 141 {
 142     return ScanlineFormat::N32BitTcMask == nScanlineFormat;
 143 }
 144
 145 bool ImplReadDIBInfoHeader(SvStream& rIStm, DIBV5Header& rHeader, bool& bTopDown, bool bMSOFormat)
 146 {
 147     if (rIStm.remainingSize() <= 4)
 148         return false;
 149     // BITMAPINFOHEADER or BITMAPCOREHEADER or BITMAPV5HEADER
 150     sal_uInt64 const aStartPos(rIStm.Tell());
 151     rIStm.ReadUInt32( rHeader.nSize );
 152
 153     // BITMAPCOREHEADER
 154     if ( rHeader.nSize == DIBCOREHEADERSIZE )
 155     {
 156         sal_Int16 nTmp16;
 157
 158         rIStm.ReadInt16( nTmp16 ); rHeader.nWidth = nTmp16;
 159         rIStm.ReadInt16( nTmp16 ); rHeader.nHeight = nTmp16;
 160         rIStm.ReadUInt16( rHeader.nPlanes );
 161         rIStm.ReadUInt16( rHeader.nBitCount );
 162     }
 163     else if ( bMSOFormat && rHeader.nSize == DIBINFOHEADERSIZE )
 164     {
 165         sal_Int16 nTmp16(0);
 166         rIStm.ReadInt16(nTmp16);
 167         rHeader.nWidth = nTmp16;
 168         rIStm.ReadInt16(nTmp16);
 169         rHeader.nHeight = nTmp16;
 170         sal_uInt8 nTmp8(0);
 171         rIStm.ReadUChar(nTmp8);
 172         rHeader.nPlanes = nTmp8;
 173         rIStm.ReadUChar(nTmp8);
 174         rHeader.nBitCount = nTmp8;
 175         rIStm.ReadInt16(nTmp16);
 176         rHeader.nSizeImage = nTmp16;
 177         rIStm.ReadInt16(nTmp16);
 178         rHeader.nCompression = nTmp16;
 179         if ( !rHeader.nSizeImage ) // uncompressed?
 180             rHeader.nSizeImage = ((rHeader.nWidth * rHeader.nBitCount + 31) & ~31) / 8 * rHeader.nHeight;
 181         rIStm.ReadInt32( rHeader.nXPelsPerMeter );
 182         rIStm.ReadInt32( rHeader.nYPelsPerMeter );
 183         rIStm.ReadUInt32( rHeader.nColsUsed );
 184         rIStm.ReadUInt32( rHeader.nColsImportant );
 185     }
 186     else
 187     {
 188         // BITMAPCOREHEADER, BITMAPV5HEADER or unknown. Read as far as possible
 189         std::size_t nUsed(sizeof(rHeader.nSize));
 190
 191         auto readUInt16 = [&nUsed, &rHeader, &rIStm](sal_uInt16 & v) {
 192             if (nUsed < rHeader.nSize) {
 193                 rIStm.ReadUInt16(v);
 194                 nUsed += sizeof(v);
 195             }
 196         };
 197         auto readInt32 = [&nUsed, &rHeader, &rIStm](sal_Int32 & v) {
 198             if (nUsed < rHeader.nSize) {
 199                 rIStm.ReadInt32(v);
 200                 nUsed += sizeof(v);
 201             }
 202         };
 203         auto readUInt32 = [&nUsed, &rHeader, &rIStm](sal_uInt32 & v) {
 204             if (nUsed < rHeader.nSize) {
 205                 rIStm.ReadUInt32(v);
 206                 nUsed += sizeof(v);
 207             }
 208         };
 209
 210         // read DIBInfoHeader entries
 211         readInt32( rHeader.nWidth );
 212         readInt32( rHeader.nHeight );
 213         readUInt16( rHeader.nPlanes );
 214         readUInt16( rHeader.nBitCount );
 215         readUInt32( rHeader.nCompression );
 216         readUInt32( rHeader.nSizeImage );
 217         readInt32( rHeader.nXPelsPerMeter );
 218         readInt32( rHeader.nYPelsPerMeter );
 219         readUInt32( rHeader.nColsUsed );
 220         readUInt32( rHeader.nColsImportant );
 221
 222         // read DIBV5HEADER members
 223         readUInt32( rHeader.nV5RedMask );
 224         readUInt32( rHeader.nV5GreenMask );
 225         readUInt32( rHeader.nV5BlueMask );
 226         readUInt32( rHeader.nV5AlphaMask );
 227         readUInt32( rHeader.nV5CSType );
 228
 229         // read contained CIEXYZTriple's
 230         readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzX );
 231         readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzY );
 232         readInt32( rHeader.aV5Endpoints.aXyzRed.aXyzZ );
 233         readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzX );
 234         readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzY );
 235         readInt32( rHeader.aV5Endpoints.aXyzGreen.aXyzZ );
 236         readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzX );
 237         readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzY );
 238         readInt32( rHeader.aV5Endpoints.aXyzBlue.aXyzZ );
 239
 240         readUInt32( rHeader.nV5GammaRed );
 241         readUInt32( rHeader.nV5GammaGreen );
 242         readUInt32( rHeader.nV5GammaBlue );
 243         readUInt32( rHeader.nV5Intent );
 244         readUInt32( rHeader.nV5ProfileData );
 245         readUInt32( rHeader.nV5ProfileSize );
 246         readUInt32( rHeader.nV5Reserved );
 247
 248         // Read color mask. An additional 12 bytes of color bitfields follow the info header (WinBMPv3-NT)
 249         sal_uInt32 nColorMask = 0;
 250         if (BITFIELDS == rHeader.nCompression && DIBINFOHEADERSIZE == rHeader.nSize)
 251         {
 252             rIStm.ReadUInt32( rHeader.nV5RedMask );
 253             rIStm.ReadUInt32( rHeader.nV5GreenMask );
 254             rIStm.ReadUInt32( rHeader.nV5BlueMask );
 255             nColorMask = 12;
 256         }
 257
 258         // seek to EndPos
 259         if (!checkSeek(rIStm, aStartPos + rHeader.nSize + nColorMask))
 260             return false;
 261     }
 262
 263     if (!rIStm.good() || rHeader.nHeight == SAL_MIN_INT32)
 264         return false;
 265
 266     if ( rHeader.nHeight < 0 )
 267     {
 268         bTopDown = true;
 269         rHeader.nHeight *= -1;
 270     }
 271     else
 272     {
 273         bTopDown = false;
 274     }
 275
 276     if ( rHeader.nWidth < 0 || rHeader.nXPelsPerMeter < 0 || rHeader.nYPelsPerMeter < 0 )
 277     {
 278         rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 279     }
 280
 281     // #144105# protect a little against damaged files
 282     assert(rHeader.nHeight >= 0);
 283     if (rHeader.nHeight != 0 && rHeader.nWidth >= 0
 284         && (rHeader.nSizeImage / 16 / static_cast<sal_uInt32>(rHeader.nHeight)
 285             > o3tl::make_unsigned(rHeader.nWidth)))
 286     {
 287         rHeader.nSizeImage = 0;
 288     }
 289
 290
 291     if (rHeader.nPlanes != 1)
 292         return false;
 293
 294     if (rHeader.nBitCount != 0 && rHeader.nBitCount != 1 &&
 295         rHeader.nBitCount != 4 && rHeader.nBitCount != 8 &&
 296         rHeader.nBitCount != 16 && rHeader.nBitCount != 24 &&
 297         rHeader.nBitCount != 32)
 298     {
 299         return false;
 300     }
 301
 302     return rIStm.good();
 303 }
 304
 305 bool ImplReadDIBPalette(SvStream& rIStm, BitmapPalette& rPal, bool bQuad)
 306 {
 307     const sal_uInt16    nColors = rPal.GetEntryCount();
 308     const sal_uLong     nPalSize = nColors * ( bQuad ? 4UL : 3UL );
 309     BitmapColor     aPalColor;
 310
 311     std::unique_ptr<sal_uInt8[]> pEntries(new sal_uInt8[ nPalSize ]);
 312     if (rIStm.ReadBytes(pEntries.get(), nPalSize) != nPalSize)
 313     {
 314         return false;
 315     }
 316
 317     sal_uInt8* pTmpEntry = pEntries.get();
 318     for( sal_uInt16 i = 0; i < nColors; i++ )
 319     {
 320         aPalColor.SetBlue( *pTmpEntry++ );
 321         aPalColor.SetGreen( *pTmpEntry++ );
 322         aPalColor.SetRed( *pTmpEntry++ );
 323
 324         if( bQuad )
 325             pTmpEntry++;
 326
 327         rPal[i] = aPalColor;
 328     }
 329
 330     return rIStm.GetError() == ERRCODE_NONE;
 331 }
 332
 333 BitmapColor SanitizePaletteIndex(sal_uInt8 nIndex, BitmapPalette& rPalette)
 334 {
 335     const sal_uInt16 nPaletteEntryCount = rPalette.GetEntryCount();
 336     if (nPaletteEntryCount && nIndex >= nPaletteEntryCount)
 337     {
 338         auto nSanitizedIndex = nIndex % nPaletteEntryCount;
 339         SAL_WARN_IF(nIndex != nSanitizedIndex, "vcl", "invalid colormap index: "
 340                     << static_cast<unsigned int>(nIndex) << ", colormap len is: "
 341                     << nPaletteEntryCount);
 342         nIndex = nSanitizedIndex;
 343     }
 344     return BitmapColor(nIndex);
 345 }
 346
 347 bool ImplDecodeRLE(sal_uInt8* pBuffer, DIBV5Header const & rHeader, BitmapWriteAccess& rAcc, BitmapPalette& rPalette, bool bRLE4)
 348 {
 349     Scanline pRLE = pBuffer;
 350     Scanline pEndRLE = pBuffer + rHeader.nSizeImage;
 351     tools::Long        nY = rHeader.nHeight - 1;
 352     const sal_uLong nWidth = rAcc.Width();
 353     sal_uLong       nCountByte;
 354     sal_uLong       nRunByte;
 355     sal_uLong       nX = 0;
 356     sal_uInt8       cTmp;
 357     bool        bEndDecoding = false;
 358
 359     do
 360     {
 361         if (pRLE == pEndRLE)
 362             return false;
 363         if( ( nCountByte = *pRLE++ ) == 0 )
 364         {
 365             if (pRLE == pEndRLE)
 366                 return false;
 367             nRunByte = *pRLE++;
 368
 369             if( nRunByte > 2 )
 370             {
 371                 Scanline pScanline = rAcc.GetScanline(nY);
 372                 if( bRLE4 )
 373                 {
 374                     nCountByte = nRunByte >> 1;
 375
 376                     for( sal_uLong i = 0; i < nCountByte; i++ )
 377                     {
 378                         if (pRLE == pEndRLE)
 379                             return false;
 380
 381                         cTmp = *pRLE++;
 382
 383                         if( nX < nWidth )
 384                             rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
 385
 386                         if( nX < nWidth )
 387                             rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette));
 388                     }
 389
 390                     if( nRunByte & 1 )
 391                     {
 392                         if (pRLE == pEndRLE)
 393                             return false;
 394
 395                         if( nX < nWidth )
 396                             rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE >> 4, rPalette));
 397
 398                         pRLE++;
 399                     }
 400
 401                     if( ( ( nRunByte + 1 ) >> 1 ) & 1 )
 402                     {
 403                         if (pRLE == pEndRLE)
 404                             return false;
 405
 406                         pRLE++;
 407                     }
 408                 }
 409                 else
 410                 {
 411                     for( sal_uLong i = 0; i < nRunByte; i++ )
 412                     {
 413                         if (pRLE == pEndRLE)
 414                             return false;
 415
 416                         if( nX < nWidth )
 417                             rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE, rPalette));
 418
 419                         pRLE++;
 420                     }
 421
 422                     if( nRunByte & 1 )
 423                     {
 424                         if (pRLE == pEndRLE)
 425                             return false;
 426
 427                         pRLE++;
 428                     }
 429                 }
 430             }
 431             else if( !nRunByte )
 432             {
 433                 nY--;
 434                 nX = 0;
 435             }
 436             else if( nRunByte == 1 )
 437                 bEndDecoding = true;
 438             else
 439             {
 440                 if (pRLE == pEndRLE)
 441                     return false;
 442
 443                 nX += *pRLE++;
 444
 445                 if (pRLE == pEndRLE)
 446                     return false;
 447
 448                 nY -= *pRLE++;
 449             }
 450         }
 451         else
 452         {
 453             if (pRLE == pEndRLE)
 454                 return false;
 455             cTmp = *pRLE++;
 456
 457             Scanline pScanline = rAcc.GetScanline(nY);
 458             if( bRLE4 )
 459             {
 460                 nRunByte = nCountByte >> 1;
 461
 462                 for (sal_uLong i = 0; i < nRunByte && nX < nWidth; ++i)
 463                 {
 464                     rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
 465                     if( nX < nWidth )
 466                         rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette));
 467                 }
 468
 469                 if( ( nCountByte & 1 ) && ( nX < nWidth ) )
 470                     rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette));
 471             }
 472             else
 473             {
 474                 for (sal_uLong i = 0; i < nCountByte && nX < nWidth; ++i)
 475                     rAcc.SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp, rPalette));
 476             }
 477         }
 478     }
 479     while (!bEndDecoding && (nY >= 0));
 480
 481     return true;
 482 }
 483
 484 bool ImplReadDIBBits(SvStream& rIStm, DIBV5Header& rHeader, BitmapWriteAccess& rAcc, BitmapPalette& rPalette, BitmapWriteAccess* pAccAlpha,
 485                      bool bTopDown, bool& rAlphaUsed, const sal_uInt64 nAlignedWidth)
 486 {
 487     sal_uInt32 nRMask(( rHeader.nBitCount == 16 ) ? 0x00007c00UL : 0x00ff0000UL);
 488     sal_uInt32 nGMask(( rHeader.nBitCount == 16 ) ? 0x000003e0UL : 0x0000ff00UL);
 489     sal_uInt32 nBMask(( rHeader.nBitCount == 16 ) ? 0x0000001fUL : 0x000000ffUL);
 490     bool bNative(false);
 491     bool bTCMask(!pAccAlpha && ((16 == rHeader.nBitCount) || (32 == rHeader.nBitCount)));
 492     bool bRLE((RLE_8 == rHeader.nCompression && 8 == rHeader.nBitCount) || (RLE_4 == rHeader.nCompression && 4 == rHeader.nBitCount));
 493
 494     // Is native format?
 495     switch(rAcc.GetScanlineFormat())
 496     {
 497         case ScanlineFormat::N1BitMsbPal:
 498         case ScanlineFormat::N24BitTcBgr:
 499         {
 500             // we can't trust arbitrary-sourced index based formats to have correct indexes, so we exclude the pal formats
 501             // from raw read and force checking their colormap indexes
 502             bNative = bTopDown && !bRLE && !bTCMask && ( rAcc.GetScanlineSize() == nAlignedWidth );
 503             break;
 504         }
 505
 506         default:
 507         {
 508             break;
 509         }
 510     }
 511
 512     // Read data
 513     if (bNative)
 514     {
 515         if (nAlignedWidth
 516             > std::numeric_limits<std::size_t>::max() / rHeader.nHeight)
 517         {
 518             return false;
 519         }
 520         std::size_t n = nAlignedWidth * rHeader.nHeight;
 521         if (rIStm.ReadBytes(rAcc.GetBuffer(), n) != n)
 522         {
 523             return false;
 524         }
 525     }
 526     else
 527     {
 528         if (rHeader.nV5RedMask > 0)
 529             nRMask = rHeader.nV5RedMask;
 530         if (rHeader.nV5GreenMask > 0)
 531             nGMask = rHeader.nV5GreenMask;
 532         if (rHeader.nV5BlueMask > 0)
 533             nBMask = rHeader.nV5BlueMask;
 534
 535         const tools::Long nWidth(rHeader.nWidth);
 536         const tools::Long nHeight(rHeader.nHeight);
 537         tools::Long nResult = 0;
 538         if (comphelper::IsFuzzing() && (o3tl::checked_multiply(nWidth, nHeight, nResult) || nResult > 4000000))
 539             return false;
 540
 541         if (bRLE)
 542         {
 543             if(!rHeader.nSizeImage)
 544             {
 545                 rHeader.nSizeImage = rIStm.remainingSize();
 546             }
 547
 548             if (rHeader.nSizeImage > rIStm.remainingSize())
 549                 return false;
 550             std::vector<sal_uInt8> aBuffer(rHeader.nSizeImage);
 551             if (rIStm.ReadBytes(aBuffer.data(), rHeader.nSizeImage) != rHeader.nSizeImage)
 552                 return false;
 553             if (!ImplDecodeRLE(aBuffer.data(), rHeader, rAcc, rPalette, RLE_4 == rHeader.nCompression))
 554                 return false;
 555         }
 556         else
 557         {
 558             if (nAlignedWidth > rIStm.remainingSize())
 559             {
 560                 // ofz#11188 avoid timeout
 561                 // all following paths will enter a case statement, and nCount
 562                 // is always at least 1, so we can check here before allocation
 563                 // if at least one row can be read
 564                 return false;
 565             }
 566             std::vector<sal_uInt8> aBuf(nAlignedWidth);
 567
 568             const tools::Long nI(bTopDown ? 1 : -1);
 569             tools::Long nY(bTopDown ? 0 : nHeight - 1);
 570             tools::Long nCount(nHeight);
 571
 572             switch(rHeader.nBitCount)
 573             {
 574                 case 1:
 575                 {
 576                     for( ; nCount--; nY += nI )
 577                     {
 578                         sal_uInt8 * pTmp = aBuf.data();
 579                         if (rIStm.ReadBytes(pTmp, nAlignedWidth)
 580                             != nAlignedWidth)
 581                         {
 582                             return false;
 583                         }
 584                         sal_uInt8   cTmp = *pTmp++;
 585                         Scanline pScanline = rAcc.GetScanline(nY);
 586                         for( tools::Long nX = 0, nShift = 8; nX < nWidth; nX++ )
 587                         {
 588                             if( !nShift )
 589                             {
 590                                 nShift = 8;
 591                                 cTmp = *pTmp++;
 592                             }
 593
 594                             auto nIndex = (cTmp >> --nShift) & 1;
 595                             rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
 596                         }
 597                     }
 598                 }
 599                 break;
 600
 601                 case 4:
 602                 {
 603                     for( ; nCount--; nY += nI )
 604                     {
 605                         sal_uInt8 * pTmp = aBuf.data();
 606                         if (rIStm.ReadBytes(pTmp, nAlignedWidth)
 607                             != nAlignedWidth)
 608                         {
 609                             return false;
 610                         }
 611                         sal_uInt8   cTmp = *pTmp++;
 612                         Scanline pScanline = rAcc.GetScanline(nY);
 613                         for( tools::Long nX = 0, nShift = 2; nX < nWidth; nX++ )
 614                         {
 615                             if( !nShift )
 616                             {
 617                                 nShift = 2;
 618                                 cTmp = *pTmp++;
 619                             }
 620
 621                             auto nIndex = (cTmp >> ( --nShift << 2 ) ) & 0x0f;
 622                             rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
 623                         }
 624                     }
 625                 }
 626                 break;
 627
 628                 case 8:
 629                 {
 630                     for( ; nCount--; nY += nI )
 631                     {
 632                         sal_uInt8 * pTmp = aBuf.data();
 633                         if (rIStm.ReadBytes(pTmp, nAlignedWidth)
 634                             != nAlignedWidth)
 635                         {
 636                             return false;
 637                         }
 638
 639                         Scanline pScanline = rAcc.GetScanline(nY);
 640                         for( tools::Long nX = 0; nX < nWidth; nX++ )
 641                         {
 642                             auto nIndex = *pTmp++;
 643                             rAcc.SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette));
 644                         }
 645                     }
 646                 }
 647                 break;
 648
 649                 case 16:
 650                 {
 651                     ColorMaskElement aRedMask(nRMask);
 652                     if (!aRedMask.CalcMaskShift())
 653                         return false;
 654                     ColorMaskElement aGreenMask(nGMask);
 655                     if (!aGreenMask.CalcMaskShift())
 656                         return false;
 657                     ColorMaskElement aBlueMask(nBMask);
 658                     if (!aBlueMask.CalcMaskShift())
 659                         return false;
 660
 661                     ColorMask   aMask(aRedMask, aGreenMask, aBlueMask);
 662                     BitmapColor aColor;
 663
 664                     for( ; nCount--; nY += nI )
 665                     {
 666                         sal_uInt16 * pTmp16 = reinterpret_cast<sal_uInt16*>(aBuf.data());
 667                         if (rIStm.ReadBytes(pTmp16, nAlignedWidth)
 668                             != nAlignedWidth)
 669                         {
 670                             return false;
 671                         }
 672
 673                         Scanline pScanline = rAcc.GetScanline(nY);
 674                         for( tools::Long nX = 0; nX < nWidth; nX++ )
 675                         {
 676                             aMask.GetColorFor16BitLSB( aColor, reinterpret_cast<sal_uInt8*>(pTmp16++) );
 677                             rAcc.SetPixelOnData(pScanline, nX, aColor);
 678                         }
 679                     }
 680                 }
 681                 break;
 682
 683                 case 24:
 684                 {
 685                     BitmapColor aPixelColor;
 686
 687                     for( ; nCount--; nY += nI )
 688                     {
 689                         sal_uInt8* pTmp = aBuf.data();
 690                         if (rIStm.ReadBytes(pTmp, nAlignedWidth)
 691                             != nAlignedWidth)
 692                         {
 693                             return false;
 694                         }
 695
 696                         Scanline pScanline = rAcc.GetScanline(nY);
 697                         for( tools::Long nX = 0; nX < nWidth; nX++ )
 698                         {
 699                             aPixelColor.SetBlue( *pTmp++ );
 700                             aPixelColor.SetGreen( *pTmp++ );
 701                             aPixelColor.SetRed( *pTmp++ );
 702                             rAcc.SetPixelOnData(pScanline, nX, aPixelColor);
 703                         }
 704                     }
 705                 }
 706                 break;
 707
 708                 case 32:
 709                 {
 710                     ColorMaskElement aRedMask(nRMask);
 711                     if (!aRedMask.CalcMaskShift())
 712                         return false;
 713                     ColorMaskElement aGreenMask(nGMask);
 714                     if (!aGreenMask.CalcMaskShift())
 715                         return false;
 716                     ColorMaskElement aBlueMask(nBMask);
 717                     if (!aBlueMask.CalcMaskShift())
 718                         return false;
 719                     ColorMask aMask(aRedMask, aGreenMask, aBlueMask);
 720
 721                     BitmapColor aColor;
 722                     sal_uInt32* pTmp32;
 723
 724                     if(pAccAlpha)
 725                     {
 726                         sal_uInt8 aAlpha;
 727
 728                         for( ; nCount--; nY += nI )
 729                         {
 730                             pTmp32 = reinterpret_cast<sal_uInt32*>(aBuf.data());
 731                             if (rIStm.ReadBytes(pTmp32, nAlignedWidth)
 732                                 != nAlignedWidth)
 733                             {
 734                                 return false;
 735                             }
 736
 737                             Scanline pScanline = rAcc.GetScanline(nY);
 738                             Scanline pAlphaScanline = pAccAlpha->GetScanline(nY);
 739                             for( tools::Long nX = 0; nX < nWidth; nX++ )
 740                             {
 741                                 aMask.GetColorAndAlphaFor32Bit( aColor, aAlpha, reinterpret_cast<sal_uInt8*>(pTmp32++) );
 742                                 rAcc.SetPixelOnData(pScanline, nX, aColor);
 743                                 pAccAlpha->SetPixelOnData(pAlphaScanline, nX, BitmapColor(sal_uInt8(0xff) - aAlpha));
 744                                 rAlphaUsed |= 0xff != aAlpha;
 745                             }
 746                         }
 747                     }
 748                     else
 749                     {
 750                         for( ; nCount--; nY += nI )
 751                         {
 752                             pTmp32 = reinterpret_cast<sal_uInt32*>(aBuf.data());
 753                             if (rIStm.ReadBytes(pTmp32, nAlignedWidth)
 754                                 != nAlignedWidth)
 755                             {
 756                                 return false;
 757                             }
 758
 759                             Scanline pScanline = rAcc.GetScanline(nY);
 760                             for( tools::Long nX = 0; nX < nWidth; nX++ )
 761                             {
 762                                 aMask.GetColorFor32Bit( aColor, reinterpret_cast<sal_uInt8*>(pTmp32++) );
 763                                 rAcc.SetPixelOnData(pScanline, nX, aColor);
 764                             }
 765                         }
 766                     }
 767                 }
 768             }
 769         }
 770     }
 771
 772     return rIStm.GetError() == ERRCODE_NONE;
 773 }
 774
 775 bool ImplReadDIBBody(SvStream& rIStm, Bitmap& rBmp, AlphaMask* pBmpAlpha, sal_uInt64 nOffset, bool bMSOFormat)
 776 {
 777     DIBV5Header aHeader;
 778     const sal_uInt64 nStmPos = rIStm.Tell();
 779     bool bTopDown(false);
 780
 781     if (!ImplReadDIBInfoHeader(rIStm, aHeader, bTopDown, bMSOFormat))
 782         return false;
 783
 784     //BI_BITCOUNT_0 jpeg/png is unsupported
 785     if (aHeader.nBitCount == 0)
 786         return false;
 787
 788     if (aHeader.nWidth <= 0 || aHeader.nHeight <= 0)
 789         return false;
 790
 791     // In case ImplReadDIB() didn't call ImplReadDIBFileHeader() before
 792     // this method, nOffset is 0, that's OK.
 793     if (nOffset && aHeader.nSize > nOffset)
 794     {
 795         // Header size claims to extend into the image data.
 796         // Looks like an error.
 797         return false;
 798     }
 799
 800     sal_uInt16 nColors(0);
 801     SvStream* pIStm;
 802     std::unique_ptr<SvMemoryStream> pMemStm;
 803     std::vector<sal_uInt8> aData;
 804
 805     if (aHeader.nBitCount <= 8)
 806     {
 807         if(aHeader.nColsUsed)
 808         {
 809             nColors = static_cast<sal_uInt16>(aHeader.nColsUsed);
 810         }
 811         else
 812         {
 813             nColors = ( 1 << aHeader.nBitCount );
 814         }
 815     }
 816
 817     if (ZCOMPRESS == aHeader.nCompression)
 818     {
 819         sal_uInt32 nCodedSize(0);
 820         sal_uInt32  nUncodedSize(0);
 821
 822         // read coding information
 823         rIStm.ReadUInt32( nCodedSize ).ReadUInt32( nUncodedSize ).ReadUInt32( aHeader.nCompression );
 824         if (nCodedSize > rIStm.remainingSize())
 825            nCodedSize = sal_uInt32(rIStm.remainingSize());
 826
 827         pMemStm.reset(new SvMemoryStream);
 828         // There may be bytes left over or the codec might read more than
 829         // necessary. So to preserve the correctness of the source stream copy
 830         // the encoded block
 831         pMemStm->WriteStream(rIStm, nCodedSize);
 832         pMemStm->Seek(0);
 833
 834         size_t nSizeInc(4 * pMemStm->remainingSize());
 835         if (nUncodedSize < nSizeInc)
 836             nSizeInc = nUncodedSize;
 837
 838         if (nSizeInc > 0)
 839         {
 840             // decode buffer
 841             ZCodec aCodec;
 842             aCodec.BeginCompression();
 843             aData.resize(nSizeInc);
 844             size_t nDataPos(0);
 845             while (nUncodedSize > nDataPos)
 846             {
 847                 assert(aData.size() > nDataPos);
 848                 const size_t nToRead(std::min<size_t>(nUncodedSize - nDataPos, aData.size() - nDataPos));
 849                 assert(nToRead > 0);
 850                 assert(!aData.empty());
 851                 const tools::Long nRead = aCodec.Read(*pMemStm, aData.data() + nDataPos, sal_uInt32(nToRead));
 852                 if (nRead > 0)
 853                 {
 854                     nDataPos += static_cast<tools::ULong>(nRead);
 855                     // we haven't read everything yet: resize buffer and continue
 856                     if (nDataPos < nUncodedSize)
 857                         aData.resize(aData.size() + nSizeInc);
 858                 }
 859                 else
 860                 {
 861                     break;
 862                 }
 863             }
 864             // truncate the data buffer to actually read size
 865             aData.resize(nDataPos);
 866             // set the real uncoded size
 867             nUncodedSize = sal_uInt32(aData.size());
 868             aCodec.EndCompression();
 869         }
 870
 871         if (aData.empty())
 872         {
 873             // add something so we can take address of the first element
 874             aData.resize(1);
 875             nUncodedSize = 0;
 876         }
 877
 878         // set decoded bytes to memory stream,
 879         // from which we will read the bitmap data
 880         pMemStm.reset(new SvMemoryStream);
 881         pIStm = pMemStm.get();
 882         assert(!aData.empty());
 883         pMemStm->SetBuffer(aData.data(), nUncodedSize, nUncodedSize);
 884         nOffset = 0;
 885     }
 886     else
 887     {
 888         pIStm = &rIStm;
 889     }
 890
 891     // read palette
 892     BitmapPalette aPalette;
 893     if (nColors)
 894     {
 895         aPalette.SetEntryCount(nColors);
 896         ImplReadDIBPalette(*pIStm, aPalette, aHeader.nSize != DIBCOREHEADERSIZE);
 897     }
 898
 899     if (pIStm->GetError())
 900         return false;
 901
 902     if (nOffset)
 903     {
 904         // It is problematic to seek backwards. We are at the
 905         // end of BITMAPINFOHEADER or 12 bytes further in case
 906         // of WinBMPv3-NT format. It is possible to seek forward
 907         // though because a gap may be there.
 908         sal_Int64 nSeekRel = nOffset - (pIStm->Tell() - nStmPos);
 909         if (nSeekRel > 0)
 910             pIStm->SeekRel(nSeekRel);
 911     }
 912
 913     const sal_Int64 nBitsPerLine (static_cast<sal_Int64>(aHeader.nWidth) * static_cast<sal_Int64>(aHeader.nBitCount));
 914     if (nBitsPerLine > SAL_MAX_UINT32)
 915         return false;
 916     const sal_uInt64 nAlignedWidth(AlignedWidth4Bytes(static_cast<sal_uLong>(nBitsPerLine)));
 917
 918     switch (aHeader.nCompression)
 919     {
 920         case RLE_8:
 921         {
 922             if (aHeader.nBitCount != 8)
 923                 return false;
 924             // (partially) check the image dimensions to avoid potential large bitmap allocation if the input is damaged
 925             sal_uInt64 nMaxWidth = pIStm->remainingSize();
 926             nMaxWidth *= 256;   //assume generous compression ratio
 927             nMaxWidth /= aHeader.nHeight;
 928             if (nMaxWidth < o3tl::make_unsigned(aHeader.nWidth))
 929                 return false;
 930             break;
 931         }
 932         case RLE_4:
 933         {
 934             if (aHeader.nBitCount != 4)
 935                 return false;
 936             sal_uInt64 nMaxWidth = pIStm->remainingSize();
 937             nMaxWidth *= 512;   //assume generous compression ratio
 938             nMaxWidth /= aHeader.nHeight;
 939             if (nMaxWidth < o3tl::make_unsigned(aHeader.nWidth))
 940                 return false;
 941             break;
 942         }
 943         default:
 944             // tdf#122958 invalid compression value used
 945             if (aHeader.nCompression & 0x000F)
 946             {
 947                 // let's assume that there was an error in the generating application
 948                 // and allow through as COMPRESS_NONE if the bottom byte is 0
 949                 SAL_WARN( "vcl", "bad bmp compression scheme: " << aHeader.nCompression << ", rejecting bmp");
 950                 return false;
 951             }
 952             else
 953                 SAL_WARN( "vcl", "bad bmp compression scheme: " << aHeader.nCompression << ", assuming meant to be COMPRESS_NONE");
 954         [[fallthrough]];
 955         case BITFIELDS:
 956         case ZCOMPRESS:
 957         case COMPRESS_NONE:
 958         {
 959             // (partially) check the image dimensions to avoid potential large bitmap allocation if the input is damaged
 960             sal_uInt64 nMaxWidth = pIStm->remainingSize();
 961             nMaxWidth /= aHeader.nHeight;
 962             if (nMaxWidth < nAlignedWidth)
 963                 return false;
 964             break;
 965         }
 966     }
 967
 968     const Size aSizePixel(aHeader.nWidth, aHeader.nHeight);
 969     AlphaMask aNewBmpAlpha;
 970     BitmapScopedWriteAccess pAccAlpha;
 971     bool bAlphaPossible(pBmpAlpha && aHeader.nBitCount == 32);
 972
 973     if (bAlphaPossible)
 974     {
 975         const bool bRedSet(0 != aHeader.nV5RedMask);
 976         const bool bGreenSet(0 != aHeader.nV5GreenMask);
 977         const bool bBlueSet(0 != aHeader.nV5BlueMask);
 978
 979         // some clipboard entries have alpha mask on zero to say that there is
 980         // no alpha; do only use this when the other masks are set. The MS docu
 981         // says that masks are only to be set when bV5Compression is set to
 982         // BI_BITFIELDS, but there seem to exist a wild variety of usages...
 983         if((bRedSet || bGreenSet || bBlueSet) && (0 == aHeader.nV5AlphaMask))
 984         {
 985             bAlphaPossible = false;
 986         }
 987     }
 988
 989     if (bAlphaPossible)
 990     {
 991         aNewBmpAlpha = AlphaMask(aSizePixel);
 992         pAccAlpha = aNewBmpAlpha;
 993     }
 994
 995     vcl::PixelFormat ePixelFormat(convertToBPP(aHeader.nBitCount));
 996     const BitmapPalette* pPal = &aPalette;
 997     //ofz#948 match the surrounding logic of case TransparentType::Bitmap of
 998     //ReadDIBBitmapEx but do it while reading for performance
 999
1000     Bitmap aNewBmp(aSizePixel, ePixelFormat, pPal);
1001     BitmapScopedWriteAccess pAcc(aNewBmp);
1002     if (!pAcc)
1003         return false;
1004     if (pAcc->Width() != aHeader.nWidth || pAcc->Height() != aHeader.nHeight)
1005     {
1006         return false;
1007     }
1008
1009     // read bits
1010     bool bAlphaUsed(false);
1011     bool bRet = ImplReadDIBBits(*pIStm, aHeader, *pAcc, aPalette, pAccAlpha.get(), bTopDown, bAlphaUsed, nAlignedWidth);
1012
1013     if (bRet && aHeader.nXPelsPerMeter && aHeader.nYPelsPerMeter)
1014     {
1015         MapMode aMapMode(
1016             MapUnit::MapMM,
1017             Point(),
1018             Fraction(1000, aHeader.nXPelsPerMeter),
1019             Fraction(1000, aHeader.nYPelsPerMeter));
1020
1021         aNewBmp.SetPrefMapMode(aMapMode);
1022         aNewBmp.SetPrefSize(Size(aHeader.nWidth, aHeader.nHeight));
1023     }
1024
1025     pAcc.reset();
1026
1027     if (bAlphaPossible)
1028     {
1029         pAccAlpha.reset();
1030
1031         if(!bAlphaUsed)
1032         {
1033             bAlphaPossible = false;
1034         }
1035     }
1036
1037     if (bRet)
1038     {
1039         rBmp = std::move(aNewBmp);
1040
1041         if(bAlphaPossible)
1042         {
1043             *pBmpAlpha = std::move(aNewBmpAlpha);
1044         }
1045     }
1046
1047     return bRet;
1048 }
1049
1050 bool ImplReadDIBFileHeader( SvStream& rIStm, sal_uLong& rOffset )
1051 {
1052     bool bRet = false;
1053
1054     const sal_uInt64 nStreamLength = rIStm.TellEnd();
1055
1056     sal_uInt16 nTmp16 = 0;
1057     rIStm.ReadUInt16( nTmp16 );
1058
1059     if ( ( 0x4D42 == nTmp16 ) || ( 0x4142 == nTmp16 ) )
1060     {
1061         sal_uInt32 nTmp32(0);
1062         if ( 0x4142 == nTmp16 )
1063         {
1064             rIStm.SeekRel( 12 );
1065             rIStm.ReadUInt16( nTmp16 );
1066             rIStm.SeekRel( 8 );
1067             rIStm.ReadUInt32( nTmp32 );
1068             rOffset = nTmp32 - 28;
1069             bRet = ( 0x4D42 == nTmp16 );
1070         }
1071         else // 0x4D42 == nTmp16, 'MB' from BITMAPFILEHEADER
1072         {
1073             rIStm.SeekRel( 8 );        // we are on bfSize member of BITMAPFILEHEADER, forward to bfOffBits
1074             rIStm.ReadUInt32( nTmp32 );            // read bfOffBits
1075             rOffset = nTmp32 - 14;    // adapt offset by sizeof(BITMAPFILEHEADER)
1076             bRet = rIStm.GetError() == ERRCODE_NONE;
1077         }
1078
1079         if ( rOffset >= nStreamLength )
1080         {
1081             // Offset claims that image starts past the end of the
1082             // stream.  Unlikely.
1083             rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
1084             bRet = false;
1085         }
1086     }
1087     else
1088         rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
1089
1090     return bRet;
1091 }
1092
1093 bool ImplWriteDIBPalette( SvStream& rOStm, BitmapReadAccess const & rAcc )
1094 {
1095     const sal_uInt16    nColors = rAcc.GetPaletteEntryCount();
1096     const sal_uLong     nPalSize = nColors * 4UL;
1097     std::unique_ptr<sal_uInt8[]> pEntries(new sal_uInt8[ nPalSize ]);
1098     sal_uInt8*          pTmpEntry = pEntries.get();
1099
1100     for( sal_uInt16 i = 0; i < nColors; i++ )
1101     {
1102         const BitmapColor& rPalColor = rAcc.GetPaletteColor( i );
1103
1104         *pTmpEntry++ = rPalColor.GetBlue();
1105         *pTmpEntry++ = rPalColor.GetGreen();
1106         *pTmpEntry++ = rPalColor.GetRed();
1107         *pTmpEntry++ = 0;
1108     }
1109
1110     rOStm.WriteBytes( pEntries.get(), nPalSize );
1111
1112     return rOStm.GetError() == ERRCODE_NONE;
1113 }
1114
1115 bool ImplWriteRLE( SvStream& rOStm, BitmapReadAccess const & rAcc, bool bRLE4 )
1116 {
1117     const sal_uLong nWidth = rAcc.Width();
1118     const sal_uLong nHeight = rAcc.Height();
1119     sal_uLong       nX;
1120     sal_uLong       nSaveIndex;
1121     sal_uLong       nCount;
1122     sal_uLong       nBufCount;
1123     std::vector<sal_uInt8> aBuf(( nWidth << 1 ) + 2);
1124     sal_uInt8       cPix;
1125     sal_uInt8       cLast;
1126     bool        bFound;
1127
1128     for ( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1129     {
1130         sal_uInt8* pTmp = aBuf.data();
1131         nX = nBufCount = 0;
1132         Scanline pScanline = rAcc.GetScanline( nY );
1133
1134         while( nX < nWidth )
1135         {
1136             nCount = 1;
1137             cPix = rAcc.GetIndexFromData( pScanline, nX++ );
1138
1139             while( ( nX < nWidth ) && ( nCount < 255 )
1140                 && ( cPix == rAcc.GetIndexFromData( pScanline, nX ) ) )
1141             {
1142                 nX++;
1143                 nCount++;
1144             }
1145
1146             if ( nCount > 1 )
1147             {
1148                 *pTmp++ = static_cast<sal_uInt8>(nCount);
1149                 *pTmp++ = ( bRLE4 ? ( ( cPix << 4 ) | cPix ) : cPix );
1150                 nBufCount += 2;
1151             }
1152             else
1153             {
1154                 cLast = cPix;
1155                 nSaveIndex = nX - 1;
1156                 bFound = false;
1157
1158                 while( ( nX < nWidth ) && ( nCount < 256 ) )
1159                 {
1160                     cPix = rAcc.GetIndexFromData( pScanline, nX );
1161                     if (cPix == cLast)
1162                         break;
1163                     nX++; nCount++;
1164                     cLast = cPix;
1165                     bFound = true;
1166                 }
1167
1168                 if ( bFound )
1169                     nX--;
1170
1171                 if ( nCount > 3 )
1172                 {
1173                     *pTmp++ = 0;
1174                     *pTmp++ = static_cast<sal_uInt8>(--nCount);
1175
1176                     if( bRLE4 )
1177                     {
1178                         for ( sal_uLong i = 0; i < nCount; i++, pTmp++ )
1179                         {
1180                             *pTmp = rAcc.GetIndexFromData( pScanline, nSaveIndex++ ) << 4;
1181
1182                             if ( ++i < nCount )
1183                                 *pTmp |= rAcc.GetIndexFromData( pScanline, nSaveIndex++ );
1184                         }
1185
1186                         nCount = ( nCount + 1 ) >> 1;
1187                     }
1188                     else
1189                     {
1190                         for( sal_uLong i = 0; i < nCount; i++ )
1191                             *pTmp++ = rAcc.GetIndexFromData( pScanline, nSaveIndex++ );
1192                     }
1193
1194                     if ( nCount & 1 )
1195                     {
1196                         *pTmp++ = 0;
1197                         nBufCount += ( nCount + 3 );
1198                     }
1199                     else
1200                         nBufCount += ( nCount + 2 );
1201                 }
1202                 else
1203                 {
1204                     *pTmp++ = 1;
1205                     *pTmp++ = rAcc.GetIndexFromData( pScanline, nSaveIndex ) << (bRLE4 ? 4 : 0);
1206
1207                     if ( nCount == 3 )
1208                     {
1209                         *pTmp++ = 1;
1210                         *pTmp++ = rAcc.GetIndexFromData( pScanline, ++nSaveIndex ) << ( bRLE4 ? 4 : 0 );
1211                         nBufCount += 4;
1212                     }
1213                     else
1214                         nBufCount += 2;
1215                 }
1216             }
1217         }
1218
1219         aBuf[ nBufCount++ ] = 0;
1220         aBuf[ nBufCount++ ] = 0;
1221
1222         rOStm.WriteBytes(aBuf.data(), nBufCount);
1223     }
1224
1225     rOStm.WriteUChar( 0 );
1226     rOStm.WriteUChar( 1 );
1227
1228     return rOStm.GetError() == ERRCODE_NONE;
1229 }
1230
1231 bool ImplWriteDIBBits(SvStream& rOStm, BitmapReadAccess const & rAcc, sal_uLong nCompression, sal_uInt32& rImageSize)
1232 {
1233     if(BITFIELDS == nCompression)
1234     {
1235         const ColorMask&    rMask = rAcc.GetColorMask();
1236         SVBT32              aVal32;
1237
1238         UInt32ToSVBT32( rMask.GetRedMask(), aVal32 );
1239         rOStm.WriteBytes( aVal32, 4UL );
1240
1241         UInt32ToSVBT32( rMask.GetGreenMask(), aVal32 );
1242         rOStm.WriteBytes( aVal32, 4UL );
1243
1244         UInt32ToSVBT32( rMask.GetBlueMask(), aVal32 );
1245         rOStm.WriteBytes( aVal32, 4UL );
1246
1247         rImageSize = rOStm.Tell();
1248
1249         for( tools::Long nY = rAcc.Height() - 1, nScanlineSize = rAcc.GetScanlineSize(); nY >= 0; nY-- )
1250             rOStm.WriteBytes( rAcc.GetScanline(nY), nScanlineSize );
1251     }
1252     else if((RLE_4 == nCompression) || (RLE_8 == nCompression))
1253     {
1254         rImageSize = rOStm.Tell();
1255         ImplWriteRLE( rOStm, rAcc, RLE_4 == nCompression );
1256     }
1257     else if(!nCompression)
1258     {
1259         // #i5xxx# Limit bitcount to 24bit, the 32 bit cases are not
1260         // handled properly below (would have to set color masks, and
1261         // nCompression=BITFIELDS - but color mask is not set for
1262         // formats != *_TC_*). Note that this very problem might cause
1263         // trouble at other places - the introduction of 32 bit RGBA
1264         // bitmaps is relatively recent.
1265         // #i59239# discretize bitcount for aligned width to 1,8,24
1266         // (other cases are not written below)
1267         const auto ePixelFormat(convertToBPP(rAcc.GetBitCount()));
1268         const sal_uLong nAlignedWidth(AlignedWidth4Bytes(rAcc.Width() * sal_Int32(ePixelFormat)));
1269
1270         rImageSize = rOStm.Tell();
1271
1272         const tools::Long nWidth(rAcc.Width());
1273         const tools::Long nHeight(rAcc.Height());
1274         std::vector<sal_uInt8> aBuf(nAlignedWidth);
1275         switch(ePixelFormat)
1276         {
1277             case vcl::PixelFormat::N8_BPP:
1278             {
1279                 for( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1280                 {
1281                     sal_uInt8* pTmp = aBuf.data();
1282                     Scanline pScanline = rAcc.GetScanline( nY );
1283
1284                     for( tools::Long nX = 0; nX < nWidth; nX++ )
1285                         *pTmp++ = rAcc.GetIndexFromData( pScanline, nX );
1286
1287                     rOStm.WriteBytes(aBuf.data(), nAlignedWidth);
1288                 }
1289             }
1290             break;
1291
1292             case vcl::PixelFormat::N24_BPP:
1293             {
1294                 //valgrind, zero out the trailing unused alignment bytes
1295                 size_t nUnusedBytes = nAlignedWidth - nWidth * 3;
1296                 memset(aBuf.data() + nAlignedWidth - nUnusedBytes, 0, nUnusedBytes);
1297             }
1298             [[fallthrough]];
1299             // #i59239# fallback to 24 bit format, if bitcount is non-default
1300             default:
1301             {
1302                 BitmapColor aPixelColor;
1303
1304                 for( tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1305                 {
1306                     sal_uInt8* pTmp = aBuf.data();
1307
1308                     for( tools::Long nX = 0; nX < nWidth; nX++ )
1309                     {
1310                         // when alpha is used, this may be non-24bit main bitmap, so use GetColor
1311                         // instead of GetPixel to ensure RGB value
1312                         aPixelColor = rAcc.GetColor( nY, nX );
1313
1314                         *pTmp++ = aPixelColor.GetBlue();
1315                         *pTmp++ = aPixelColor.GetGreen();
1316                         *pTmp++ = aPixelColor.GetRed();
1317                     }
1318
1319                     rOStm.WriteBytes(aBuf.data(), nAlignedWidth);
1320                 }
1321             }
1322             break;
1323         }
1324     }
1325
1326     rImageSize = rOStm.Tell() - rImageSize;
1327
1328     return (!rOStm.GetError());
1329 }
1330
1331 bool ImplWriteDIBBody(const Bitmap& rBitmap, SvStream& rOStm, BitmapReadAccess const & rAcc, bool bCompressed)
1332 {
1333     const MapMode aMapPixel(MapUnit::MapPixel);
1334     DIBV5Header aHeader;
1335     sal_uInt64 nImageSizePos(0);
1336     sal_uInt64 nEndPos(0);
1337     sal_uInt32 nCompression(COMPRESS_NONE);
1338     bool bRet(false);
1339
1340     aHeader.nSize = DIBINFOHEADERSIZE; // size dependent on CF_DIB type to use
1341     aHeader.nWidth = rAcc.Width();
1342     aHeader.nHeight = rAcc.Height();
1343     aHeader.nPlanes = 1;
1344
1345     if(isBitfieldCompression(rAcc.GetScanlineFormat()))
1346     {
1347         aHeader.nBitCount = 32;
1348         aHeader.nSizeImage = rAcc.Height() * rAcc.GetScanlineSize();
1349         nCompression = BITFIELDS;
1350     }
1351     else
1352     {
1353         // #i5xxx# Limit bitcount to 24bit, the 32 bit cases are
1354         // not handled properly below (would have to set color
1355         // masks, and nCompression=BITFIELDS - but color mask is
1356         // not set for formats != *_TC_*). Note that this very
1357         // problem might cause trouble at other places - the
1358         // introduction of 32 bit RGBA bitmaps is relatively
1359         // recent.
1360         // #i59239# discretize bitcount to 1,8,24 (other cases
1361         // are not written below)
1362         const auto ePixelFormat(convertToBPP(rAcc.GetBitCount()));
1363         aHeader.nBitCount = sal_uInt16(ePixelFormat);
1364         aHeader.nSizeImage = rAcc.Height() * AlignedWidth4Bytes(rAcc.Width() * aHeader.nBitCount);
1365
1366         if (bCompressed)
1367         {
1368             if (ePixelFormat == vcl::PixelFormat::N8_BPP)
1369                 nCompression = RLE_8;
1370         }
1371     }
1372
1373     if((rOStm.GetCompressMode() & SvStreamCompressFlags::ZBITMAP) && (rOStm.GetVersion() >= SOFFICE_FILEFORMAT_40))
1374     {
1375         aHeader.nCompression = ZCOMPRESS;
1376     }
1377     else
1378     {
1379         aHeader.nCompression = nCompression;
1380     }
1381
1382     if(rBitmap.GetPrefSize().Width() && rBitmap.GetPrefSize().Height() && (rBitmap.GetPrefMapMode() != aMapPixel))
1383     {
1384         // #i48108# Try to recover xpels/ypels as previously stored on
1385         // disk. The problem with just converting maPrefSize to 100th
1386         // mm and then relating that to the bitmap pixel size is that
1387         // MapMode is integer-based, and suffers from roundoffs,
1388         // especially if maPrefSize is small. Trying to circumvent
1389         // that by performing part of the math in floating point.
1390         const Size aScale100000(OutputDevice::LogicToLogic(Size(100000, 100000), MapMode(MapUnit::Map100thMM), rBitmap.GetPrefMapMode()));
1391         const double fBmpWidthM(static_cast<double>(rBitmap.GetPrefSize().Width()) / aScale100000.Width());
1392         const double fBmpHeightM(static_cast<double>(rBitmap.GetPrefSize().Height()) / aScale100000.Height());
1393
1394         if(!basegfx::fTools::equalZero(fBmpWidthM) && !basegfx::fTools::equalZero(fBmpHeightM))
1395         {
1396             aHeader.nXPelsPerMeter = basegfx::fround(rAcc.Width() / fabs(fBmpWidthM));
1397             aHeader.nYPelsPerMeter = basegfx::fround(rAcc.Height() / fabs(fBmpHeightM));
1398         }
1399     }
1400
1401     aHeader.nColsUsed = ((aHeader.nBitCount <= 8) ? rAcc.GetPaletteEntryCount() : 0);
1402     aHeader.nColsImportant = 0;
1403
1404     rOStm.WriteUInt32( aHeader.nSize );
1405     rOStm.WriteInt32( aHeader.nWidth );
1406     rOStm.WriteInt32( aHeader.nHeight );
1407     rOStm.WriteUInt16( aHeader.nPlanes );
1408     rOStm.WriteUInt16( aHeader.nBitCount );
1409     rOStm.WriteUInt32( aHeader.nCompression );
1410
1411     nImageSizePos = rOStm.Tell();
1412     rOStm.SeekRel( sizeof( aHeader.nSizeImage ) );
1413
1414     rOStm.WriteInt32( aHeader.nXPelsPerMeter );
1415     rOStm.WriteInt32( aHeader.nYPelsPerMeter );
1416     rOStm.WriteUInt32( aHeader.nColsUsed );
1417     rOStm.WriteUInt32( aHeader.nColsImportant );
1418
1419     if(ZCOMPRESS == aHeader.nCompression)
1420     {
1421         ZCodec aCodec;
1422         SvMemoryStream aMemStm(aHeader.nSizeImage + 4096, 65535);
1423         sal_uInt64 nCodedPos(rOStm.Tell());
1424         sal_uInt64 nLastPos(0);
1425         sal_uInt32 nCodedSize(0);
1426         sal_uInt32 nUncodedSize(0);
1427
1428         // write uncoded data palette
1429         if(aHeader.nColsUsed)
1430         {
1431             ImplWriteDIBPalette(aMemStm, rAcc);
1432         }
1433
1434         // write uncoded bits
1435         bRet = ImplWriteDIBBits(aMemStm, rAcc, nCompression, aHeader.nSizeImage);
1436
1437         // get uncoded size
1438         nUncodedSize = aMemStm.Tell();
1439
1440         // seek over compress info
1441         rOStm.SeekRel(12);
1442
1443         // write compressed data
1444         aCodec.BeginCompression(3);
1445         aCodec.Write(rOStm, static_cast<sal_uInt8 const *>(aMemStm.GetData()), nUncodedSize);
1446         aCodec.EndCompression();
1447
1448         // update compress info ( coded size, uncoded size, uncoded compression )
1449         nLastPos = rOStm.Tell();
1450         nCodedSize = nLastPos - nCodedPos - 12;
1451         rOStm.Seek(nCodedPos);
1452         rOStm.WriteUInt32( nCodedSize ).WriteUInt32( nUncodedSize ).WriteUInt32( nCompression );
1453         rOStm.Seek(nLastPos);
1454
1455         if(bRet)
1456         {
1457             bRet = (ERRCODE_NONE == rOStm.GetError());
1458         }
1459     }
1460     else
1461     {
1462         if(aHeader.nColsUsed)
1463         {
1464             ImplWriteDIBPalette(rOStm, rAcc);
1465         }
1466
1467         bRet = ImplWriteDIBBits(rOStm, rAcc, aHeader.nCompression, aHeader.nSizeImage);
1468     }
1469
1470     nEndPos = rOStm.Tell();
1471     rOStm.Seek(nImageSizePos);
1472     rOStm.WriteUInt32( aHeader.nSizeImage );
1473     rOStm.Seek(nEndPos);
1474
1475     return bRet;
1476 }
1477
1478 bool ImplWriteDIBFileHeader(SvStream& rOStm, BitmapReadAccess const & rAcc)
1479 {
1480     const sal_uInt32 nPalCount((rAcc.HasPalette() ? rAcc.GetPaletteEntryCount() : isBitfieldCompression(rAcc.GetScanlineFormat()) ? 3UL : 0UL));
1481     const sal_uInt32 nOffset(14 + DIBINFOHEADERSIZE + nPalCount * 4UL);
1482
1483     rOStm.WriteUInt16( 0x4D42 ); // 'MB' from BITMAPFILEHEADER
1484     rOStm.WriteUInt32( nOffset + (rAcc.Height() * rAcc.GetScanlineSize()) );
1485     rOStm.WriteUInt16( 0 );
1486     rOStm.WriteUInt16( 0 );
1487     rOStm.WriteUInt32( nOffset );
1488
1489     return rOStm.GetError() == ERRCODE_NONE;
1490 }
1491
1492 bool ImplReadDIB(
1493     Bitmap& rTarget,
1494     AlphaMask* pTargetAlpha,
1495     SvStream& rIStm,
1496     bool bFileHeader,
1497     bool bMSOFormat=false)
1498 {
1499     const SvStreamEndian nOldFormat(rIStm.GetEndian());
1500     const auto nOldPos(rIStm.Tell());
1501     sal_uLong nOffset(0);
1502     bool bRet(false);
1503
1504     rIStm.SetEndian(SvStreamEndian::LITTLE);
1505
1506     if(bFileHeader)
1507     {
1508         if(ImplReadDIBFileHeader(rIStm, nOffset))
1509         {
1510             bRet = ImplReadDIBBody(rIStm, rTarget, nOffset >= DIBV5HEADERSIZE ? pTargetAlpha : nullptr, nOffset, bMSOFormat);
1511         }
1512     }
1513     else
1514     {
1515         bRet = ImplReadDIBBody(rIStm, rTarget, nullptr, nOffset, bMSOFormat);
1516     }
1517
1518     if(!bRet)
1519     {
1520         if(!rIStm.GetError()) // Set error and stop processing whole stream due to security reason
1521         {
1522             rIStm.SetError(SVSTREAM_GENERALERROR);
1523         }
1524
1525         rIStm.Seek(nOldPos);
1526     }
1527
1528     rIStm.SetEndian(nOldFormat);
1529
1530     return bRet;
1531 }
1532
1533 bool ImplWriteDIB(
1534     const Bitmap& rSource,
1535     SvStream& rOStm,
1536     bool bCompressed,
1537     bool bFileHeader)
1538 {
1539     const Size aSizePix(rSource.GetSizePixel());
1540     bool bRet(false);
1541
1542     if(!aSizePix.Width() || !aSizePix.Height())
1543         return false;
1544
1545     BitmapScopedReadAccess pAcc(rSource);
1546     const SvStreamEndian nOldFormat(rOStm.GetEndian());
1547     const sal_uInt64 nOldPos(rOStm.Tell());
1548
1549     rOStm.SetEndian(SvStreamEndian::LITTLE);
1550
1551     if (pAcc)
1552     {
1553         if(bFileHeader)
1554         {
1555             if(ImplWriteDIBFileHeader(rOStm, *pAcc))
1556             {
1557                 bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
1558             }
1559         }
1560         else
1561         {
1562             bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
1563         }
1564
1565         pAcc.reset();
1566     }
1567
1568     if(!bRet)
1569     {
1570         rOStm.SetError(SVSTREAM_GENERALERROR);
1571         rOStm.Seek(nOldPos);
1572     }
1573
1574     rOStm.SetEndian(nOldFormat);
1575
1576     return bRet;
1577 }
1578
1579 } // unnamed namespace
1580
1581 bool ReadDIB(
1582     Bitmap& rTarget,
1583     SvStream& rIStm,
1584     bool bFileHeader,
1585     bool bMSOFormat)
1586 {
1587     return ImplReadDIB(rTarget, nullptr, rIStm, bFileHeader, bMSOFormat);
1588 }
1589
1590 bool ReadDIBBitmapEx(
1591     BitmapEx& rTarget,
1592     SvStream& rIStm,
1593     bool bFileHeader,
1594     bool bMSOFormat)
1595 {
1596     Bitmap aBmp;
1597     bool bRetval(ImplReadDIB(aBmp, nullptr, rIStm, bFileHeader, bMSOFormat) && !rIStm.GetError());
1598
1599     if(bRetval)
1600     {
1601         // base bitmap was read, set as return value and try to read alpha extra-data
1602         const sal_uInt64 nStmPos(rIStm.Tell());
1603         sal_uInt32 nMagic1(0);
1604         sal_uInt32 nMagic2(0);
1605
1606         rTarget = BitmapEx(aBmp);
1607         if (rIStm.remainingSize() >= 4)
1608             rIStm.ReadUInt32( nMagic1 ).ReadUInt32( nMagic2 );
1609         bRetval = (0x25091962 == nMagic1) && (0xACB20201 == nMagic2) && !rIStm.GetError();
1610
1611         if(bRetval)
1612         {
1613             sal_uInt8 tmp = 0;
1614             rIStm.ReadUChar( tmp );
1615             bRetval = !rIStm.GetError();
1616
1617             if(bRetval)
1618             {
1619                 switch (tmp)
1620                 {
1621                 case 2: // TransparentType::Bitmap
1622                     {
1623                         Bitmap aMask;
1624
1625                         bRetval = ImplReadDIB(aMask, nullptr, rIStm, true);
1626
1627                         if(bRetval && !aMask.IsEmpty())
1628                             rTarget = BitmapEx(aBmp, aMask);
1629
1630                         break;
1631                     }
1632                 case 1: // backwards compat for old option TransparentType::Color
1633                     {
1634                         Color aTransparentColor;
1635
1636                         tools::GenericTypeSerializer aSerializer(rIStm);
1637                         aSerializer.readColor(aTransparentColor);
1638
1639                         bRetval = rIStm.good();
1640
1641                         if(bRetval)
1642                         {
1643                             rTarget = BitmapEx(aBmp, aTransparentColor);
1644                         }
1645                         break;
1646                     }
1647                 default: break;
1648                 }
1649             }
1650         }
1651
1652         if(!bRetval)
1653         {
1654             // alpha extra data could not be read; reset, but use base bitmap as result
1655             rIStm.ResetError();
1656             rIStm.Seek(nStmPos);
1657             bRetval = true;
1658         }
1659     }
1660
1661     return bRetval;
1662 }
1663
1664 bool ReadDIBV5(
1665     Bitmap& rTarget,
1666     AlphaMask& rTargetAlpha,
1667     SvStream& rIStm)
1668 {
1669     bool rv = ImplReadDIB(rTarget, &rTargetAlpha, rIStm, true);
1670     // convert transparency->alpha
1671     if (rv)
1672         rTargetAlpha.Invert();
1673     return rv;
1674 }
1675
1676 bool ReadRawDIB(
1677     BitmapEx& rTarget,
1678     const unsigned char* pBuf,
1679     const ScanlineFormat nFormat,
1680     const int nHeight,
1681     const int nStride)
1682 {
1683     BitmapScopedWriteAccess pWriteAccess(rTarget.maBitmap);
1684     for (int nRow = 0; nRow < nHeight; ++nRow)
1685     {
1686         pWriteAccess->CopyScanline(nRow, pBuf + (nStride * nRow), nFormat, nStride);
1687     }
1688
1689     return true;
1690 }
1691
1692 bool WriteDIB(
1693     const Bitmap& rSource,
1694     SvStream& rOStm,
1695     bool bCompressed,
1696     bool bFileHeader)
1697 {
1698     return ImplWriteDIB(rSource, rOStm, bCompressed, bFileHeader);
1699 }
1700
1701 bool WriteDIB(
1702     const BitmapEx& rSource,
1703     SvStream& rOStm,
1704     bool bCompressed)
1705 {
1706     return ImplWriteDIB(rSource.GetBitmap(), rOStm, bCompressed, /*bFileHeader*/true);
1707 }
1708
1709 bool WriteDIBBitmapEx(
1710     const BitmapEx& rSource,
1711     SvStream& rOStm)
1712 {
1713     if(ImplWriteDIB(rSource.GetBitmap(), rOStm, true, true))
1714     {
1715         rOStm.WriteUInt32( 0x25091962 );
1716         rOStm.WriteUInt32( 0xACB20201 );
1717         rOStm.WriteUChar( rSource.IsAlpha() ? 2 : 0 ); // Used to be TransparentType enum
1718
1719         if(rSource.IsAlpha())
1720         {
1721             // invert the alpha because the other routines actually want transparency
1722             AlphaMask tmpAlpha = rSource.maAlphaMask;
1723             tmpAlpha.Invert();
1724             return ImplWriteDIB(tmpAlpha.GetBitmap(), rOStm, true, true);
1725         }
1726     }
1727
1728     return false;
1729 }
1730
1731 sal_uInt32 getDIBV5HeaderSize()
1732 {
1733     return DIBV5HEADERSIZE;
1734 }
1735
1736 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */