?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nss: upgrade to release 3.73
[LibreOffice.git] / filter / source / graphicfilter / icgm / bitmap.cxx
blobd857c5848ed6e7f40af3ca8526e4fea361d0f80b
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <sal/log.hxx>
22 #include <unotools/configmgr.hxx>
23 #include <vcl/BitmapTools.hxx>
24 #include <memory>
25
26 #include "bitmap.hxx"
27 #include "elements.hxx"
28
29 namespace {
30
31 Color BMCOL(sal_uInt32 _col) {
32 return Color( static_cast<sal_Int8>(_col >> 16 ), static_cast<sal_Int8>( _col >> 8 ), static_cast<sal_Int8>(_col) );
33 }
34
35 }
36
37 CGMBitmap::CGMBitmap( CGM& rCGM ) :
38 mpCGM ( &rCGM ),
39 pCGMBitmapDescriptor ( new CGMBitmapDescriptor )
40 {
41 ImplGetBitmap( *pCGMBitmapDescriptor );
42 };
43
44
45 CGMBitmap::~CGMBitmap()
46 {
47 }
48
49 namespace
50 {
51 bool isLegalBitsPerPixel(sal_uInt32 nBitsPerPixel)
52 {
53 switch (nBitsPerPixel)
54 {
55 case 1:
56 case 2:
57 case 4:
58 case 8:
59 case 24:
60 return true;
61 break;
62 default:
63 break;
64 }
65 return false;
66 }
67 }
68
69 void CGMBitmap::ImplGetBitmap( CGMBitmapDescriptor& rDesc )
70 {
71 rDesc.mbStatus = true;
72
73 if (!ImplGetDimensions(rDesc) || !rDesc.mpBuf)
74 return;
75
76 if (!isLegalBitsPerPixel(rDesc.mnDstBitsPerPixel))
77 {
78 rDesc.mbStatus = false;
79 return;
80 }
81
82 try
83 {
84 if (rDesc.mnScanSize)
85 {
86 vcl::bitmap::RawBitmap aBitmap( Size( rDesc.mnX, rDesc.mnY ), 24 );
87
88 // the picture may either be read from left to right or right to left, from top to bottom ...
89
90 tools::Long nxCount = rDesc.mnX + 1; // +1 because we are using prefix decreasing
91 tools::Long nyCount = rDesc.mnY + 1;
92 tools::Long nx, ny, nxC;
93
94 switch ( rDesc.mnDstBitsPerPixel ) {
95 case 1 : {
96 bool bOk = true;
97 std::vector<Color> palette(2);
98 if ( rDesc.mnLocalColorPrecision == 1 )
99 palette = ImplGeneratePalette( rDesc );
100 else {
101 palette[0] = BMCOL( mpCGM->pElement->nBackGroundColor );
102 palette[1] = ( mpCGM->pElement->nAspectSourceFlags & ASF_FILLINTERIORSTYLE )
103 ? BMCOL( mpCGM->pElement->pFillBundle->GetColor() )
104 : BMCOL( mpCGM->pElement->aFillBundle.GetColor() );
105 };
106 for (ny = 0; bOk && --nyCount; ny++, rDesc.mpBuf += rDesc.mnScanSize) {
107 nxC = nxCount;
108 for ( nx = 0; --nxC; nx++ ) {
109 // this is not fast, but a one bit/pixel format is rarely used
110 const sal_uInt8* pPos = rDesc.mpBuf + (nx >> 3);
111 if (pPos >= rDesc.mpEndBuf)
112 {
113 SAL_WARN("filter.icgm", "buffer is too small");
114 bOk = false;
115 break;
116 }
117 sal_uInt8 colorIndex = static_cast<sal_uInt8>((*pPos >> ((nx & 7)^7))) & 1;
118 aBitmap.SetPixel(ny, nx, palette[colorIndex]);
119 }
120 }
121 }
122 break;
123
124 case 2 : {
125 bool bOk = true;
126 auto palette = ImplGeneratePalette( rDesc );
127 for (ny = 0; bOk && --nyCount; ny++, rDesc.mpBuf += rDesc.mnScanSize) {
128 nxC = nxCount;
129 for ( nx = 0; --nxC; nx++ ) {
130 // this is not fast, but a two bits/pixel format is rarely used
131 const sal_uInt8* pPos = rDesc.mpBuf + (nx >> 2);
132 if (pPos >= rDesc.mpEndBuf)
133 {
134 SAL_WARN("filter.icgm", "buffer is too small");
135 bOk = false;
136 break;
137 }
138 aBitmap.SetPixel(ny, nx, palette[static_cast<sal_uInt8>( (*pPos >> (((nx & 3)^3) << 1))) & 3]);
139 }
140 }
141 }
142 break;
143
144 case 4 : {
145 bool bOk = true;
146 auto palette = ImplGeneratePalette( rDesc );
147 for (ny = 0; bOk && --nyCount; ny++, rDesc.mpBuf += rDesc.mnScanSize) {
148 nxC = nxCount;
149 sal_uInt8* pTemp = rDesc.mpBuf;
150 for ( nx = 0; --nxC; nx++ ) {
151
152 if (pTemp >= rDesc.mpEndBuf)
153 {
154 SAL_WARN("filter.icgm", "buffer is too small");
155 bOk = false;
156 break;
157 }
158
159 sal_uInt8 nDat = *pTemp++;
160
161 aBitmap.SetPixel(ny, nx, palette[static_cast<sal_uInt8>(nDat >> 4)]);
162 if ( --nxC ) {
163 ++nx;
164 aBitmap.SetPixel(ny, nx, palette[static_cast<sal_uInt8>(nDat & 15)]);
165 } else
166 break;
167 }
168 }
169 }
170 break;
171
172 case 8 : {
173 bool bOk = true;
174 auto palette = ImplGeneratePalette( rDesc );
175 for (ny = 0; bOk && --nyCount; ny++, rDesc.mpBuf += rDesc.mnScanSize) {
176 sal_uInt8* pTemp = rDesc.mpBuf;
177 nxC = nxCount;
178 for ( nx = 0; --nxC; nx++ ) {
179
180 if (pTemp >= rDesc.mpEndBuf)
181 {
182 SAL_WARN("filter.icgm", "buffer is too small");
183 bOk = false;
184 break;
185 }
186
187 aBitmap.SetPixel(ny, nx, palette[*(pTemp++)]);
188 }
189 }
190 }
191 break;
192
193 case 24 : {
194 bool bOk = true;
195 Color aBitmapColor;
196 for (ny = 0; bOk && --nyCount; ny++, rDesc.mpBuf += rDesc.mnScanSize) {
197 sal_uInt8* pTemp = rDesc.mpBuf;
198 nxC = nxCount;
199 for ( nx = 0; --nxC; nx++ ) {
200
201 if (pTemp + 2 >= rDesc.mpEndBuf)
202 {
203 SAL_WARN("filter.icgm", "buffer is too small");
204 bOk = false;
205 break;
206 }
207
208 aBitmapColor.SetRed( *pTemp++ );
209 aBitmapColor.SetGreen( *pTemp++ );
210 aBitmapColor.SetBlue( *pTemp++ );
211 aBitmap.SetPixel(ny, nx, aBitmapColor);
212 }
213 }
214 }
215 break;
216 }
217
218 if ( rDesc.mbStatus )
219 rDesc.mxBitmap = vcl::bitmap::CreateFromData(std::move(aBitmap));
220 }
221
222 double nX = rDesc.mnR.X - rDesc.mnQ.X;
223 double nY = rDesc.mnR.Y - rDesc.mnQ.Y;
224
225 rDesc.mndy = sqrt( nX * nX + nY * nY );
226
227 nX = rDesc.mnR.X - rDesc.mnP.X;
228 nY = rDesc.mnR.Y - rDesc.mnP.Y;
229
230 rDesc.mndx = sqrt( nX * nX + nY * nY );
231
232 nX = rDesc.mnR.X - rDesc.mnP.X;
233 nY = rDesc.mnR.Y - rDesc.mnP.Y;
234
235 double fSqrt = sqrt(nX * nX + nY * nY);
236 rDesc.mnOrientation = fSqrt != 0.0 ? (acos(nX / fSqrt) * 57.29577951308) : 0.0;
237 if ( nY > 0 )
238 rDesc.mnOrientation = 360 - rDesc.mnOrientation;
239
240 nX = rDesc.mnQ.X - rDesc.mnR.X;
241 nY = rDesc.mnQ.Y - rDesc.mnR.Y;
242
243 double fAngle = 0.01745329251994 * ( 360 - rDesc.mnOrientation );
244 double fSin = sin(fAngle);
245 double fCos = cos(fAngle);
246 nX = fCos * nX + fSin * nY;
247 nY = -( fSin * nX - fCos * nY );
248
249 fSqrt = sqrt(nX * nX + nY * nY);
250 fAngle = fSqrt != 0.0 ? (acos(nX / fSqrt) * 57.29577951308) : 0.0;
251 if ( nY > 0 )
252 fAngle = 360 - fAngle;
253
254 if ( fAngle > 180 ) { // is the picture build upwards or downwards ?
255 rDesc.mnOrigin = rDesc.mnP;
256 } else {
257 rDesc.mbVMirror = true;
258 rDesc.mnOrigin = rDesc.mnP;
259 rDesc.mnOrigin.X += rDesc.mnQ.X - rDesc.mnR.X;
260 rDesc.mnOrigin.Y += rDesc.mnQ.Y - rDesc.mnR.Y;
261 }
262 }
263 catch (const std::bad_alloc&)
264 {
265 rDesc.mbStatus = false;
266 }
267 }
268
269 std::vector<Color> CGMBitmap::ImplGeneratePalette( CGMBitmapDescriptor const & rDesc )
270 {
271 sal_uInt16 nColors = sal::static_int_cast< sal_uInt16 >(
272 1 << rDesc.mnDstBitsPerPixel);
273 std::vector<Color> palette( nColors );
274 for ( sal_uInt16 i = 0; i < nColors; i++ )
275 {
276 palette[i] = BMCOL( mpCGM->pElement->aLatestColorTable[ i ] );
277 }
278 return palette;
279 }
280
281
282 bool CGMBitmap::ImplGetDimensions( CGMBitmapDescriptor& rDesc )
283 {
284 mpCGM->ImplGetPoint( rDesc.mnP ); // parallelogram p < - > r
285 mpCGM->ImplGetPoint( rDesc.mnQ ); // |
286 mpCGM->ImplGetPoint( rDesc.mnR ); // q
287 sal_uInt32 nPrecision = mpCGM->pElement->nIntegerPrecision;
288 rDesc.mnX = mpCGM->ImplGetUI( nPrecision );
289 rDesc.mnY = mpCGM->ImplGetUI( nPrecision );
290 rDesc.mnLocalColorPrecision = mpCGM->ImplGetI( nPrecision );
291 rDesc.mnScanSize = 0;
292 switch( rDesc.mnLocalColorPrecision )
293 {
294 case tools::Long(0x80000001) : // monochrome ( bit = 0->backgroundcolor )
295 case 0 : // bit = 1->fillcolor
296 rDesc.mnDstBitsPerPixel = 1;
297 break;
298 case 1 : // 2 color indexed ( monochrome )
299 case -1 :
300 rDesc.mnDstBitsPerPixel = 1;
301 break;
302 case 2 : // 4 color indexed
303 case -2 :
304 rDesc.mnDstBitsPerPixel = 2;
305 break;
306 case 4 : // 16 color indexed
307 case -4 :
308 rDesc.mnDstBitsPerPixel = 4;
309 break;
310 case 8 : // 256 color indexed
311 case -8 :
312 rDesc.mnDstBitsPerPixel = 8;
313 rDesc.mnScanSize = rDesc.mnX;
314 break;
315 case 16 : // NS
316 case -16 :
317 rDesc.mbStatus = false;
318 break;
319 case 24 : // 24 bit directColor ( 8 bits each component )
320 case -24 :
321 rDesc.mnDstBitsPerPixel = 24;
322 break;
323 case 32 : // NS
324 case -32 :
325 rDesc.mbStatus = false;
326 break;
327
328 }
329 // mnCompressionMode == 0 : CCOMP_RUNLENGTH
330 // == 1 : CCOMP_PACKED ( no compression. each row starts on a 4 byte boundary )
331 if ( ( rDesc.mnCompressionMode = mpCGM->ImplGetUI16() ) != 1 )
332 rDesc.mbStatus = false;
333
334 if ( !( rDesc.mnX || rDesc.mnY ) )
335 rDesc.mbStatus = false;
336
337 sal_uInt32 nHeaderSize = 2 + 3 * nPrecision + 3 * mpCGM->ImplGetPointSize();
338
339 sal_uInt32 nWidthBits;
340 if (o3tl::checked_multiply(rDesc.mnX, rDesc.mnDstBitsPerPixel, nWidthBits))
341 {
342 rDesc.mbStatus = false;
343 return false;
344 }
345
346 rDesc.mnScanSize = (nWidthBits + 7) >> 3;
347
348 sal_uInt32 nScanSize;
349 nScanSize = rDesc.mnScanSize;
350 if ( ( nScanSize * rDesc.mnY + nHeaderSize ) != mpCGM->mnElementSize ) // try a scansize without dw alignment
351 {
352 nScanSize = ( rDesc.mnScanSize + 1 ) & ~1;
353 if ( ( nScanSize * rDesc.mnY + nHeaderSize ) != mpCGM->mnElementSize ) // then we'll try word alignment
354 {
355 nScanSize = ( rDesc.mnScanSize + 3 ) & ~3;
356 if ( ( nScanSize * rDesc.mnY + nHeaderSize ) != mpCGM->mnElementSize ) // and last we'll try dword alignment
357 {
358 nScanSize = ( rDesc.mnScanSize + 1 ) & ~1; // and LAST BUT NOT LEAST we'll try word alignment without aligning the last line
359 if ( ( nScanSize * ( rDesc.mnY - 1 ) + rDesc.mnScanSize + nHeaderSize ) != mpCGM->mnElementSize )
360 {
361 nScanSize = ( rDesc.mnScanSize + 3 ) & ~3;
362 if ( ( nScanSize * ( rDesc.mnY - 1 ) + rDesc.mnScanSize + nHeaderSize ) != mpCGM->mnElementSize )
363 {
364 mpCGM->mnParaSize = 0; // this format is corrupt
365 rDesc.mbStatus = false;
366 }
367 }
368 }
369 }
370 }
371 rDesc.mnScanSize = nScanSize;
372 if ( rDesc.mbStatus )
373 {
374 rDesc.mpBuf = mpCGM->mpSource + mpCGM->mnParaSize; // mpBuf now points to the first scanline
375 rDesc.mpEndBuf = mpCGM->mpEndValidSource;
376 mpCGM->mnParaSize += rDesc.mnScanSize * rDesc.mnY;
377 }
378 return rDesc.mbStatus;
379 }
380
381
382 void CGMBitmap::ImplInsert( CGMBitmapDescriptor const & rSource, CGMBitmapDescriptor& rDest )
383 {
384 if (utl::ConfigManager::IsFuzzing() && rDest.mxBitmap.GetSizePixel().Height() + rSource.mnY > SAL_MAX_UINT16)
385 {
386 SAL_WARN("filter.icgm", "bitmap would expand too much");
387 rDest.mbStatus = false;
388 return;
389 }
390 rDest.mxBitmap.Expand( 0, rSource.mnY );
391 rDest.mxBitmap.CopyPixel( tools::Rectangle( Point( 0, rDest.mnY ), Size( rSource.mnX, rSource.mnY ) ),
392 tools::Rectangle( Point( 0, 0 ), Size( rSource.mnX, rSource.mnY ) ), &rSource.mxBitmap );
393
394 if ( ( rSource.mnR.Y == rDest.mnQ.Y ) && ( rSource.mnR.X == rDest.mnQ.X ) )
395 { // Insert on Bottom
396 if ( mpCGM->mnVDCYmul == -1 )
397 rDest.mnOrigin = rSource.mnOrigin; // new origin
398 FloatPoint aFloatPoint;
399 aFloatPoint.X = rSource.mnQ.X - rSource.mnR.X;
400 aFloatPoint.Y = rSource.mnQ.Y - rSource.mnR.Y;
401 rDest.mnQ.X += aFloatPoint.X;
402 rDest.mnQ.Y += aFloatPoint.Y;
403 rDest.mnP = rSource.mnP;
404 rDest.mnR = rSource.mnR;
405 }
406 else
407 { // Insert on Top
408 if ( mpCGM->mnVDCYmul == 1 )
409 rDest.mnOrigin = rSource.mnOrigin; // new origin
410 rDest.mnP = rSource.mnP;
411 rDest.mnR = rSource.mnR;
412 }
413 rDest.mnY += rSource.mnY;
414 rDest.mndy += rSource.mndy;
415 };
416
417 std::unique_ptr<CGMBitmap> CGMBitmap::GetNext()
418 {
419 std::unique_ptr<CGMBitmap> xCGMTempBitmap;
420 if (!!pCGMBitmapDescriptor->mxBitmap && pCGMBitmapDescriptor->mbStatus)
421 {
422 xCGMTempBitmap.reset(new CGMBitmap(*mpCGM));
423 if ( ( static_cast<tools::Long>(xCGMTempBitmap->pCGMBitmapDescriptor->mnOrientation) == static_cast<tools::Long>(pCGMBitmapDescriptor->mnOrientation) ) &&
424 ( ( ( xCGMTempBitmap->pCGMBitmapDescriptor->mnR.X == pCGMBitmapDescriptor->mnQ.X ) &&
425 ( xCGMTempBitmap->pCGMBitmapDescriptor->mnR.Y == pCGMBitmapDescriptor->mnQ.Y ) ) ||
426 ( ( xCGMTempBitmap->pCGMBitmapDescriptor->mnQ.X == pCGMBitmapDescriptor->mnR.X ) &&
427 ( xCGMTempBitmap->pCGMBitmapDescriptor->mnQ.Y == pCGMBitmapDescriptor->mnR.Y ) ) ) )
428 {
429 ImplInsert( *(xCGMTempBitmap->pCGMBitmapDescriptor), *pCGMBitmapDescriptor );
430 xCGMTempBitmap.reset();
431 return xCGMTempBitmap;
432 }
433
434 pCGMBitmapDescriptor.swap(xCGMTempBitmap->pCGMBitmapDescriptor);
435 }
436 return xCGMTempBitmap;
437 }
438
439 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE