39#define DIBCOREHEADERSIZE ( 12UL )
40#define DIBINFOHEADERSIZE ( sizeof(DIBInfoHeader) )
41#define DIBV5HEADERSIZE ( sizeof(DIBV5Header) )
80 sal_uInt32 nCompression;
81 sal_uInt32 nSizeImage;
82 sal_Int32 nXPelsPerMeter;
83 sal_Int32 nYPelsPerMeter;
85 sal_uInt32 nColsImportant;
102struct DIBV5Header :
public DIBInfoHeader
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;
145bool ImplReadDIBInfoHeader(
SvStream& rIStm, DIBV5Header& rHeader,
bool& bTopDown,
bool bMSOFormat)
150 sal_uInt64
const aStartPos(rIStm.
Tell());
158 rIStm.
ReadInt16( nTmp16 ); rHeader.nWidth = nTmp16;
159 rIStm.
ReadInt16( nTmp16 ); rHeader.nHeight = nTmp16;
167 rHeader.nWidth = nTmp16;
169 rHeader.nHeight = nTmp16;
172 rHeader.nPlanes = nTmp8;
174 rHeader.nBitCount = nTmp8;
176 rHeader.nSizeImage = nTmp16;
178 rHeader.nCompression = nTmp16;
179 if ( !rHeader.nSizeImage )
180 rHeader.nSizeImage = ((rHeader.nWidth * rHeader.nBitCount + 31) & ~31) / 8 * rHeader.nHeight;
181 rIStm.
ReadInt32( rHeader.nXPelsPerMeter );
182 rIStm.
ReadInt32( rHeader.nYPelsPerMeter );
189 std::size_t nUsed(
sizeof(rHeader.nSize));
191 auto readUInt16 = [&nUsed, &rHeader, &rIStm](sal_uInt16 &
v) {
192 if (nUsed < rHeader.nSize) {
197 auto readInt32 = [&nUsed, &rHeader, &rIStm](sal_Int32 &
v) {
198 if (nUsed < rHeader.nSize) {
203 auto readUInt32 = [&nUsed, &rHeader, &rIStm](sal_uInt32 &
v) {
204 if (nUsed < rHeader.nSize) {
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 );
223 readUInt32( rHeader.nV5RedMask );
224 readUInt32( rHeader.nV5GreenMask );
225 readUInt32( rHeader.nV5BlueMask );
226 readUInt32( rHeader.nV5AlphaMask );
227 readUInt32( rHeader.nV5CSType );
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 );
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 );
249 sal_uInt32 nColorMask = 0;
259 if (!
checkSeek(rIStm, aStartPos + rHeader.nSize + nColorMask))
263 if (!rIStm.
good() || rHeader.nHeight == SAL_MIN_INT32)
266 if ( rHeader.nHeight < 0 )
269 rHeader.nHeight *= -1;
276 if ( rHeader.nWidth < 0 || rHeader.nXPelsPerMeter < 0 || rHeader.nYPelsPerMeter < 0 )
278 rIStm.
SetError( SVSTREAM_FILEFORMAT_ERROR );
282 assert(rHeader.nHeight >= 0);
283 if (rHeader.nHeight != 0 && rHeader.nWidth >= 0
284 && (rHeader.nSizeImage / 16 /
static_cast<sal_uInt32
>(rHeader.nHeight)
287 rHeader.nSizeImage = 0;
291 if (rHeader.nPlanes != 1)
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)
308 const sal_uLong nPalSize = nColors * ( bQuad ? 4UL : 3UL );
311 std::unique_ptr<sal_uInt8[]> pEntries(
new sal_uInt8[ nPalSize ]);
312 if (rIStm.
ReadBytes(pEntries.get(), nPalSize) != nPalSize)
318 for( sal_uInt16 i = 0;
i < nColors;
i++ )
320 aPalColor.SetBlue( *pTmpEntry++ );
321 aPalColor.SetGreen( *pTmpEntry++ );
322 aPalColor.SetRed( *pTmpEntry++ );
335 const sal_uInt16 nPaletteEntryCount = rPalette.
GetEntryCount();
336 if (nPaletteEntryCount && nIndex >= nPaletteEntryCount)
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);
345 if (nPaletteEntryCount && bForceToMonoWhileReading)
355 if (!bForceToMonoWhileReading)
363 Scanline pEndRLE = pBuffer + rHeader.nSizeImage;
370 bool bEndDecoding =
false;
376 if( ( nCountByte = *pRLE++ ) == 0 )
387 nCountByte = nRunByte >> 1;
397 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette,
false));
400 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette,
false));
409 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE >> 4, rPalette,
false));
414 if( ( ( nRunByte + 1 ) >> 1 ) & 1 )
430 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(*pRLE, rPalette,
false));
449 else if( nRunByte == 1 )
473 nRunByte = nCountByte >> 1;
477 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette,
false));
479 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp & 0x0f, rPalette,
false));
482 if( ( nCountByte & 1 ) && ( nX < nWidth ) )
483 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp >> 4, rPalette,
false));
487 for (
sal_uLong i = 0;
i < nCountByte && nX < nWidth; ++
i)
488 rAcc.
SetPixelOnData(pScanline, nX++, SanitizePaletteIndex(cTmp, rPalette,
false));
492 while (!bEndDecoding && (nY >= 0));
498 bool bTopDown,
bool& rAlphaUsed,
const sal_uInt64 nAlignedWidth)
500 sal_uInt32 nRMask(( rHeader.nBitCount == 16 ) ? 0x00007c00UL : 0x00ff0000UL);
501 sal_uInt32 nGMask(( rHeader.nBitCount == 16 ) ? 0x000003e0UL : 0x0000ff00UL);
502 sal_uInt32 nBMask(( rHeader.nBitCount == 16 ) ? 0x0000001fUL : 0x000000ffUL);
504 bool bTCMask(!pAccAlpha && ((16 == rHeader.nBitCount) || (32 == rHeader.nBitCount)));
505 bool bRLE((
RLE_8 == rHeader.nCompression && 8 == rHeader.nBitCount) || (
RLE_4 == rHeader.nCompression && 4 == rHeader.nBitCount));
529 > std::numeric_limits<std::size_t>::max() / rHeader.nHeight)
533 std::size_t
n = nAlignedWidth * rHeader.nHeight;
541 if (rHeader.nV5RedMask > 0)
542 nRMask = rHeader.nV5RedMask;
543 if (rHeader.nV5GreenMask > 0)
544 nGMask = rHeader.nV5GreenMask;
545 if (rHeader.nV5BlueMask > 0)
546 nBMask = rHeader.nV5BlueMask;
556 if(!rHeader.nSizeImage)
563 std::vector<sal_uInt8>
aBuffer(rHeader.nSizeImage);
564 if (rIStm.
ReadBytes(
aBuffer.data(), rHeader.nSizeImage) != rHeader.nSizeImage)
566 if (!ImplDecodeRLE(
aBuffer.data(), rHeader, rAcc, rPalette,
RLE_4 == rHeader.nCompression))
579 std::vector<sal_uInt8>
aBuf(nAlignedWidth);
585 switch(rHeader.nBitCount)
589 for( ;
nCount--; nY += nI )
599 for(
tools::Long nX = 0, nShift = 8; nX < nWidth; nX++ )
607 auto nIndex = (cTmp >> --nShift) & 1;
608 rAcc.
SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette,
false));
616 for( ;
nCount--; nY += nI )
626 for(
tools::Long nX = 0, nShift = 2; nX < nWidth; nX++ )
634 auto nIndex = (cTmp >> ( --nShift << 2 ) ) & 0x0f;
635 rAcc.
SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette,
false));
643 for( ;
nCount--; nY += nI )
656 rAcc.
SetPixelOnData(pScanline, nX, SanitizePaletteIndex(nIndex, rPalette,
false));
665 if (!aRedMask.CalcMaskShift())
668 if (!aGreenMask.CalcMaskShift())
671 if (!aBlueMask.CalcMaskShift())
674 ColorMask aMask(aRedMask, aGreenMask, aBlueMask);
677 for( ;
nCount--; nY += nI )
679 sal_uInt16 * pTmp16 =
reinterpret_cast<sal_uInt16*
>(
aBuf.data());
680 if (rIStm.
ReadBytes(pTmp16, nAlignedWidth)
689 aMask.GetColorFor16BitLSB( aColor,
reinterpret_cast<sal_uInt8*
>(pTmp16++) );
700 for( ;
nCount--; nY += nI )
712 aPixelColor.
SetBlue( *pTmp++ );
714 aPixelColor.
SetRed( *pTmp++ );
715 rAcc.
SetPixelOnData(pScanline, nX, SanitizeColor(aPixelColor,
false));
724 if (!aRedMask.CalcMaskShift())
727 if (!aGreenMask.CalcMaskShift())
730 if (!aBlueMask.CalcMaskShift())
732 ColorMask aMask(aRedMask, aGreenMask, aBlueMask);
741 for( ;
nCount--; nY += nI )
743 pTmp32 =
reinterpret_cast<sal_uInt32*
>(
aBuf.data());
744 if (rIStm.
ReadBytes(pTmp32, nAlignedWidth)
754 aMask.GetColorAndAlphaFor32Bit( aColor, aAlpha,
reinterpret_cast<sal_uInt8*
>(pTmp32++) );
757 rAlphaUsed |= 0xff != aAlpha;
763 for( ;
nCount--; nY += nI )
765 pTmp32 =
reinterpret_cast<sal_uInt32*
>(
aBuf.data());
766 if (rIStm.
ReadBytes(pTmp32, nAlignedWidth)
775 aMask.GetColorFor32Bit( aColor,
reinterpret_cast<sal_uInt8*
>(pTmp32++) );
791 const sal_uInt64 nStmPos = rIStm.
Tell();
792 bool bTopDown(
false);
794 if (!ImplReadDIBInfoHeader(rIStm, aHeader, bTopDown, bMSOFormat))
798 if (aHeader.nBitCount == 0)
801 if (aHeader.nWidth <= 0 || aHeader.nHeight <= 0)
806 if (nOffset && aHeader.nSize > nOffset)
813 sal_uInt16 nColors(0);
815 std::unique_ptr<SvMemoryStream> pMemStm;
816 std::vector<sal_uInt8>
aData;
818 if (aHeader.nBitCount <= 8)
820 if(aHeader.nColsUsed)
822 nColors =
static_cast<sal_uInt16
>(aHeader.nColsUsed);
826 nColors = ( 1 << aHeader.nBitCount );
832 sal_uInt32 nCodedSize(0);
833 sal_uInt32 nUncodedSize(0);
844 pMemStm->WriteStream(rIStm, nCodedSize);
847 size_t nSizeInc(4 * pMemStm->remainingSize());
848 if (nUncodedSize < nSizeInc)
849 nSizeInc = nUncodedSize;
856 aData.resize(nSizeInc);
858 while (nUncodedSize > nDataPos)
860 assert(
aData.size() > nDataPos);
861 const size_t nToRead(std::min<size_t>(nUncodedSize - nDataPos,
aData.size() - nDataPos));
863 assert(!
aData.empty());
869 if (nDataPos < nUncodedSize)
878 aData.resize(nDataPos);
880 nUncodedSize = sal_uInt32(
aData.size());
894 pIStm = pMemStm.get();
895 assert(!
aData.empty());
896 pMemStm->SetBuffer(
aData.data(), nUncodedSize, nUncodedSize);
921 sal_Int32 nSeekRel = nOffset - (pIStm->
Tell() - nStmPos);
926 const sal_Int64 nBitsPerLine (
static_cast<sal_Int64
>(aHeader.nWidth) *
static_cast<sal_Int64
>(aHeader.nBitCount));
927 if (nBitsPerLine > SAL_MAX_UINT32)
931 switch (aHeader.nCompression)
935 if (aHeader.nBitCount != 8)
940 nMaxWidth /= aHeader.nHeight;
947 if (aHeader.nBitCount != 4)
951 nMaxWidth /= aHeader.nHeight;
958 if (aHeader.nCompression & 0x000F)
962 SAL_WARN(
"vcl",
"bad bmp compression scheme: " << aHeader.nCompression <<
", rejecting bmp");
966 SAL_WARN(
"vcl",
"bad bmp compression scheme: " << aHeader.nCompression <<
", assuming meant to be COMPRESS_NONE");
974 nMaxWidth /= aHeader.nHeight;
975 if (nMaxWidth < nAlignedWidth)
981 const Size aSizePixel(aHeader.nWidth, aHeader.nHeight);
984 bool bAlphaPossible(pBmpAlpha && aHeader.nBitCount == 32);
988 const bool bRedSet(0 != aHeader.nV5RedMask);
989 const bool bGreenSet(0 != aHeader.nV5GreenMask);
990 const bool bBlueSet(0 != aHeader.nV5BlueMask);
996 if((bRedSet || bGreenSet || bBlueSet) && (0 == aHeader.nV5AlphaMask))
998 bAlphaPossible =
false;
1013 Bitmap aNewBmp(aSizePixel, ePixelFormat, pPal);
1017 if (pAcc->Width() != aHeader.nWidth || pAcc->Height() != aHeader.nHeight)
1023 bool bAlphaUsed(
false);
1024 bool bRet = ImplReadDIBBits(*pIStm, aHeader, *pAcc, aPalette, pAccAlpha.
get(), bTopDown, bAlphaUsed, nAlignedWidth);
1026 if (bRet && aHeader.nXPelsPerMeter && aHeader.nYPelsPerMeter)
1031 Fraction(1000, aHeader.nXPelsPerMeter),
1032 Fraction(1000, aHeader.nYPelsPerMeter));
1034 aNewBmp.SetPrefMapMode(aMapMode);
1035 aNewBmp.SetPrefSize(
Size(aHeader.nWidth, aHeader.nHeight));
1046 bAlphaPossible =
false;
1056 *pBmpAlpha = aNewBmpAlpha;
1067 const sal_uInt64 nStreamLength = rIStm.
TellEnd();
1069 sal_uInt16 nTmp16 = 0;
1072 if ( ( 0x4D42 == nTmp16 ) || ( 0x4142 == nTmp16 ) )
1074 sal_uInt32 nTmp32(0);
1075 if ( 0x4142 == nTmp16 )
1081 rOffset = nTmp32 - 28;
1082 bRet = ( 0x4D42 == nTmp16 );
1088 rOffset = nTmp32 - 14;
1092 if ( rOffset >= nStreamLength )
1096 rIStm.
SetError( SVSTREAM_FILEFORMAT_ERROR );
1101 rIStm.
SetError( SVSTREAM_FILEFORMAT_ERROR );
1109 const sal_uLong nPalSize = nColors * 4UL;
1110 std::unique_ptr<sal_uInt8[]> pEntries(
new sal_uInt8[ nPalSize ]);
1113 for( sal_uInt16 i = 0;
i < nColors;
i++ )
1117 *pTmpEntry++ = rPalColor.
GetBlue();
1118 *pTmpEntry++ = rPalColor.
GetGreen();
1119 *pTmpEntry++ = rPalColor.
GetRed();
1123 rOStm.
WriteBytes( pEntries.get(), nPalSize );
1136 std::vector<sal_uInt8>
aBuf(( nWidth << 1 ) + 2);
1141 for (
tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1147 while( nX < nWidth )
1152 while( ( nX < nWidth ) && ( nCount < 255 )
1162 *pTmp++ = ( bRLE4 ? ( ( cPix << 4 ) | cPix ) : cPix );
1168 nSaveIndex = nX - 1;
1171 while( ( nX < nWidth ) && ( nCount < 256 ) )
1210 nBufCount += (
nCount + 3 );
1213 nBufCount += (
nCount + 2 );
1218 *pTmp++ = rAcc.
GetIndexFromData( pScanline, nSaveIndex ) << (bRLE4 ? 4 : 0);
1223 *pTmp++ = rAcc.
GetIndexFromData( pScanline, ++nSaveIndex ) << ( bRLE4 ? 4 : 0 );
1232 aBuf[ nBufCount++ ] = 0;
1233 aBuf[ nBufCount++ ] = 0;
1251 UInt32ToSVBT32( rMask.
GetRedMask(), aVal32 );
1260 rImageSize = rOStm.
Tell();
1270 else if((
RLE_4 == nCompression) || (
RLE_8 == nCompression))
1272 rImageSize = rOStm.
Tell();
1273 ImplWriteRLE( rOStm, rAcc,
RLE_4 == nCompression );
1275 else if(!nCompression)
1285 const auto ePixelFormat(convertToBPP(rAcc.
GetBitCount()));
1287 bool bNative(
false);
1309 rImageSize = rOStm.
Tell();
1319 std::vector<sal_uInt8>
aBuf(nAlignedWidth);
1320 switch(ePixelFormat)
1324 for(
tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1340 size_t nUnusedBytes = nAlignedWidth - nWidth * 3;
1341 memset(
aBuf.data() + nAlignedWidth - nUnusedBytes, 0, nUnusedBytes);
1349 for(
tools::Long nY = nHeight - 1; nY >= 0; nY-- )
1357 aPixelColor = rAcc.
GetColor( nY, nX );
1359 *pTmp++ = aPixelColor.
GetBlue();
1361 *pTmp++ = aPixelColor.
GetRed();
1372 rImageSize = rOStm.
Tell() - rImageSize;
1379 const MapMode aMapPixel(MapUnit::MapPixel);
1380 DIBV5Header aHeader;
1381 sal_uInt64 nImageSizePos(0);
1382 sal_uInt64 nEndPos(0);
1387 aHeader.nWidth = rAcc.
Width();
1388 aHeader.nHeight = rAcc.
Height();
1389 aHeader.nPlanes = 1;
1393 aHeader.nBitCount = 32;
1408 const auto ePixelFormat(convertToBPP(rAcc.
GetBitCount()));
1409 aHeader.nBitCount = sal_uInt16(ePixelFormat);
1415 nCompression =
RLE_8;
1425 aHeader.nCompression = nCompression;
1437 const double fBmpWidthM(
static_cast<double>(rBitmap.
GetPrefSize().
Width()) / aScale100000.Width());
1438 const double fBmpHeightM(
static_cast<double>(rBitmap.
GetPrefSize().
Height()) / aScale100000.Height());
1448 aHeader.nColsImportant = 0;
1457 nImageSizePos = rOStm.
Tell();
1458 rOStm.
SeekRel(
sizeof( aHeader.nSizeImage ) );
1469 sal_uInt64 nCodedPos(rOStm.
Tell());
1470 sal_uInt64 nLastPos(0);
1471 sal_uInt32 nCodedSize(0);
1472 sal_uInt32 nUncodedSize(0);
1475 if(aHeader.nColsUsed)
1477 ImplWriteDIBPalette(aMemStm, rAcc);
1481 bRet = ImplWriteDIBBits(aMemStm, rAcc, nCompression, aHeader.nSizeImage);
1484 nUncodedSize = aMemStm.Tell();
1491 aCodec.
Write(rOStm,
static_cast<sal_uInt8 const *
>(aMemStm.GetData()), nUncodedSize);
1495 nLastPos = rOStm.
Tell();
1496 nCodedSize = nLastPos - nCodedPos - 12;
1497 rOStm.
Seek(nCodedPos);
1499 rOStm.
Seek(nLastPos);
1508 if(aHeader.nColsUsed)
1510 ImplWriteDIBPalette(rOStm, rAcc);
1513 bRet = ImplWriteDIBBits(rOStm, rAcc, aHeader.nCompression, aHeader.nSizeImage);
1516 nEndPos = rOStm.
Tell();
1517 rOStm.
Seek(nImageSizePos);
1519 rOStm.
Seek(nEndPos);
1543 bool bMSOFormat=
false)
1546 const auto nOldPos(rIStm.
Tell());
1550 rIStm.
SetEndian(SvStreamEndian::LITTLE);
1554 if(ImplReadDIBFileHeader(rIStm, nOffset))
1556 bRet = ImplReadDIBBody(rIStm, rTarget, nOffset >=
DIBV5HEADERSIZE ? pTargetAlpha :
nullptr, nOffset, bMSOFormat);
1561 bRet = ImplReadDIBBody(rIStm, rTarget,
nullptr, nOffset, bMSOFormat);
1568 rIStm.
SetError(SVSTREAM_GENERALERROR);
1571 rIStm.
Seek(nOldPos);
1588 if(!aSizePix.Width() || !aSizePix.Height())
1593 const sal_uInt64 nOldPos(rOStm.
Tell());
1595 rOStm.
SetEndian(SvStreamEndian::LITTLE);
1601 if(ImplWriteDIBFileHeader(rOStm, *pAcc))
1603 bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
1608 bRet = ImplWriteDIBBody(rSource, rOStm, *pAcc, bCompressed);
1616 rOStm.
SetError(SVSTREAM_GENERALERROR);
1617 rOStm.
Seek(nOldPos);
1633 return ImplReadDIB(
rTarget,
nullptr, rIStm, bFileHeader, bMSOFormat);
1643 bool bRetval(ImplReadDIB(aBmp,
nullptr, rIStm, bFileHeader, bMSOFormat) && !rIStm.
GetError());
1648 const sal_uInt64 nStmPos(rIStm.
Tell());
1649 sal_uInt32 nMagic1(0);
1650 sal_uInt32 nMagic2(0);
1655 bRetval = (0x25091962 == nMagic1) && (0xACB20201 == nMagic2) && !rIStm.
GetError();
1671 bRetval = ImplReadDIB(aMask,
nullptr, rIStm,
true);
1673 if(bRetval && !aMask.
IsEmpty())
1680 Color aTransparentColor;
1683 aSerializer.
readColor(aTransparentColor);
1685 bRetval = rIStm.
good();
1702 rIStm.
Seek(nStmPos);
1715 return ImplReadDIB(
rTarget, &rTargetAlpha, rIStm,
true);
1720 const unsigned char* pBuf,
1726 for (
int nRow = 0; nRow < nHeight; ++nRow)
1728 pWriteAccess->CopyScanline(nRow, pBuf + (nStride * nRow), nFormat, nStride);
1740 return ImplWriteDIB(rSource, rOStm, bCompressed, bFileHeader);
1748 return ImplWriteDIB(rSource.
GetBitmap(), rOStm, bCompressed,
true);
1755 if(ImplWriteDIB(rSource.
GetBitmap(), rOStm,
true,
true))
1763 return ImplWriteDIB(rSource.
maAlphaMask, rOStm,
true,
true);
vcl::ScopedBitmapAccess< BitmapWriteAccess, AlphaMask, &AlphaMask::AcquireAlphaWriteAccess > AlphaScopedWriteAccess
Bitmap GetBitmap(Color aTransparentReplaceColor) const
tools::Long Height() const
tools::Long Width() const
ScanlineFormat GetScanlineFormat() const
sal_uInt16 GetPaletteEntryCount() const
sal_uInt16 GetBitCount() const
const ColorMask & GetColorMask() const
const BitmapColor & GetPaletteColor(sal_uInt16 nColor) const
sal_uInt32 GetScanlineSize() const
sal_uInt16 GetEntryCount() const
void SetEntryCount(sal_uInt16 nCount)
Scanline GetBuffer() const
BitmapColor GetColor(tools::Long nY, tools::Long nX) const
void SetPixelOnData(sal_uInt8 *pData, tools::Long nX, const BitmapColor &rBitmapColor)
sal_uInt8 GetIndexFromData(const sal_uInt8 *pData, tools::Long nX) const
Scanline GetScanline(tools::Long nY) const
const MapMode & GetPrefMapMode() const
Size GetSizePixel() const
const Size & GetPrefSize() const
sal_uInt32 GetRedMask() const
sal_uInt32 GetGreenMask() const
sal_uInt32 GetBlueMask() const
sal_uInt8 GetLuminance() const
sal_uInt8 GetBlue() const
void SetGreen(sal_uInt8 nGreen)
void SetRed(sal_uInt8 nRed)
sal_uInt8 GetGreen() const
void SetBlue(sal_uInt8 nBlue)
SAL_WARN_UNUSED_RESULT Point LogicToLogic(const Point &rPtSource, const MapMode *pMapModeSource, const MapMode *pMapModeDest) const
constexpr tools::Long Height() const
constexpr tools::Long Width() const
virtual void ResetError()
SvStream & WriteInt32(sal_Int32 nInt32)
void SetEndian(SvStreamEndian SvStreamEndian)
virtual sal_uInt64 TellEnd()
SvStream & ReadInt16(sal_Int16 &rInt16)
SvStreamCompressFlags GetCompressMode() const
std::size_t WriteBytes(const void *pData, std::size_t nSize)
SvStream & WriteUChar(unsigned char nChar)
SvStream & WriteUInt16(sal_uInt16 nUInt16)
sal_Int32 GetVersion() const
SvStream & WriteUInt32(sal_uInt32 nUInt32)
SvStream & ReadUInt32(sal_uInt32 &rUInt32)
SvStreamEndian GetEndian() const
void SetError(ErrCode nErrorCode)
sal_uInt64 Seek(sal_uInt64 nPos)
SvStream & ReadInt32(sal_Int32 &rInt32)
std::size_t ReadBytes(void *pData, std::size_t nSize)
sal_uInt64 SeekRel(sal_Int64 nPos)
SvStream & ReadUInt16(sal_uInt16 &rUInt16)
sal_uInt64 remainingSize()
SvStream & ReadUChar(unsigned char &rChar)
tools::Long Read(SvStream &rIStm, sal_uInt8 *pData, sal_uInt32 nSize)
tools::Long EndCompression()
void BeginCompression(int nCompressLevel=ZCODEC_DEFAULT_COMPRESSION, bool gzLib=false)
void Write(SvStream &rOStm, const sal_uInt8 *pData, sal_uInt32 nSize)
This template handles BitmapAccess the RAII way.
sal_uInt32 AlignedWidth4Bytes(sal_uInt32 nWidthBits)
#define SAL_WARN_IF(condition, area, stream)
#define SAL_WARN(area, stream)
constexpr OUStringLiteral aData
B2IRange fround(const B2DRange &rRange)
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
std::enable_if< std::is_signed< T >::value, bool >::type checked_multiply(T a, T b, T &result)
PixelFormat
Pixel format of the bitmap in bits per pixel.
TOOLS_DLLPUBLIC bool checkSeek(SvStream &rSt, sal_uInt64 nOffset)
std::unique_ptr< char[]> aBuffer