Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : :
30 : : #include <string.h>
31 : : #include <stdio.h>
32 : : #include <tools/stream.hxx>
33 : : #include <vcl/outdev.hxx>
34 : : #include <svtools/filter.hxx>
35 : : #include "FilterConfigCache.hxx"
36 : : #include <unotools/ucbstreamhelper.hxx>
37 : :
38 : : #define DATA_SIZE 640
39 : :
40 : : sal_uInt8* ImplSearchEntry( sal_uInt8* , sal_uInt8* , sal_uLong , sal_uLong );
41 : :
42 : 0 : GraphicDescriptor::GraphicDescriptor( const INetURLObject& rPath ) :
43 [ # # ][ # # ]: 0 : pFileStm( ::utl::UcbStreamHelper::CreateStream( rPath.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ ) ),
[ # # ]
44 : : aPathExt( rPath.GetFileExtension().toAsciiLowerCase() ),
45 [ # # ]: 0 : bOwnStream( sal_True )
46 : : {
47 [ # # ]: 0 : ImpConstruct();
48 : 0 : }
49 : :
50 : 0 : GraphicDescriptor::GraphicDescriptor( SvStream& rInStream, const String* pPath) :
51 : : pFileStm ( &rInStream ),
52 : 0 : bOwnStream ( sal_False )
53 : : {
54 [ # # ]: 0 : ImpConstruct();
55 : :
56 [ # # ]: 0 : if ( pPath )
57 : : {
58 [ # # ][ # # ]: 0 : INetURLObject aURL( *pPath );
59 [ # # ][ # # ]: 0 : aPathExt = aURL.GetFileExtension().toAsciiLowerCase();
[ # # ]
60 : : }
61 : 0 : }
62 : :
63 : 0 : GraphicDescriptor::~GraphicDescriptor()
64 : : {
65 [ # # ]: 0 : if ( bOwnStream )
66 [ # # ][ # # ]: 0 : delete pFileStm;
67 [ # # ]: 0 : }
68 : :
69 : 0 : sal_Bool GraphicDescriptor::Detect( sal_Bool bExtendedInfo )
70 : : {
71 : 0 : sal_Bool bRet = sal_False;
72 [ # # ][ # # ]: 0 : if ( pFileStm && !pFileStm->GetError() )
[ # # ]
73 : : {
74 : 0 : SvStream& rStm = *pFileStm;
75 : 0 : sal_uInt16 nOldFormat = rStm.GetNumberFormatInt();
76 : :
77 [ # # ]: 0 : if ( ImpDetectGIF( rStm, bExtendedInfo ) ) bRet = sal_True;
78 [ # # ]: 0 : else if ( ImpDetectJPG( rStm, bExtendedInfo ) ) bRet = sal_True;
79 [ # # ]: 0 : else if ( ImpDetectBMP( rStm, bExtendedInfo ) ) bRet = sal_True;
80 [ # # ]: 0 : else if ( ImpDetectPNG( rStm, bExtendedInfo ) ) bRet = sal_True;
81 [ # # ]: 0 : else if ( ImpDetectTIF( rStm, bExtendedInfo ) ) bRet = sal_True;
82 [ # # ]: 0 : else if ( ImpDetectPCX( rStm, bExtendedInfo ) ) bRet = sal_True;
83 [ # # ]: 0 : else if ( ImpDetectDXF( rStm, bExtendedInfo ) ) bRet = sal_True;
84 [ # # ]: 0 : else if ( ImpDetectMET( rStm, bExtendedInfo ) ) bRet = sal_True;
85 [ # # ]: 0 : else if ( ImpDetectSGF( rStm, bExtendedInfo ) ) bRet = sal_True;
86 [ # # ]: 0 : else if ( ImpDetectSGV( rStm, bExtendedInfo ) ) bRet = sal_True;
87 [ # # ]: 0 : else if ( ImpDetectSVM( rStm, bExtendedInfo ) ) bRet = sal_True;
88 [ # # ]: 0 : else if ( ImpDetectWMF( rStm, bExtendedInfo ) ) bRet = sal_True;
89 [ # # ]: 0 : else if ( ImpDetectEMF( rStm, bExtendedInfo ) ) bRet = sal_True;
90 [ # # ]: 0 : else if ( ImpDetectSVG( rStm, bExtendedInfo ) ) bRet = sal_True;
91 [ # # ]: 0 : else if ( ImpDetectPCT( rStm, bExtendedInfo ) ) bRet = sal_True;
92 [ # # ]: 0 : else if ( ImpDetectXBM( rStm, bExtendedInfo ) ) bRet = sal_True;
93 [ # # ]: 0 : else if ( ImpDetectXPM( rStm, bExtendedInfo ) ) bRet = sal_True;
94 [ # # ]: 0 : else if ( ImpDetectPBM( rStm, bExtendedInfo ) ) bRet = sal_True;
95 [ # # ]: 0 : else if ( ImpDetectPGM( rStm, bExtendedInfo ) ) bRet = sal_True;
96 [ # # ]: 0 : else if ( ImpDetectPPM( rStm, bExtendedInfo ) ) bRet = sal_True;
97 [ # # ]: 0 : else if ( ImpDetectRAS( rStm, bExtendedInfo ) ) bRet = sal_True;
98 [ # # ]: 0 : else if ( ImpDetectTGA( rStm, bExtendedInfo ) ) bRet = sal_True;
99 [ # # ]: 0 : else if ( ImpDetectPSD( rStm, bExtendedInfo ) ) bRet = sal_True;
100 [ # # ]: 0 : else if ( ImpDetectEPS( rStm, bExtendedInfo ) ) bRet = sal_True;
101 [ # # ]: 0 : else if ( ImpDetectPCD( rStm, bExtendedInfo ) ) bRet = sal_True;
102 : :
103 : 0 : rStm.SetNumberFormatInt( nOldFormat );
104 : : }
105 : 0 : return bRet;
106 : : }
107 : :
108 : 0 : void GraphicDescriptor::ImpConstruct()
109 : : {
110 : 0 : nFormat = GFF_NOT;
111 : 0 : nBitsPerPixel = 0;
112 : 0 : nPlanes = 0;
113 : 0 : bCompressed = sal_False;
114 : 0 : }
115 : :
116 : 0 : sal_Bool GraphicDescriptor::ImpDetectBMP( SvStream& rStm, sal_Bool bExtendedInfo )
117 : : {
118 : : sal_uInt16 nTemp16;
119 : 0 : sal_Bool bRet = sal_False;
120 : 0 : sal_Int32 nStmPos = rStm.Tell();
121 : :
122 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
123 [ # # ]: 0 : rStm >> nTemp16;
124 : :
125 : : // OS/2-BitmapArray
126 [ # # ]: 0 : if ( nTemp16 == 0x4142 )
127 : : {
128 [ # # ]: 0 : rStm.SeekRel( 0x0c );
129 [ # # ]: 0 : rStm >> nTemp16;
130 : : }
131 : :
132 : : // Bitmap
133 [ # # ]: 0 : if ( nTemp16 == 0x4d42 )
134 : : {
135 : 0 : nFormat = GFF_BMP;
136 : 0 : bRet = sal_True;
137 : :
138 [ # # ]: 0 : if ( bExtendedInfo )
139 : : {
140 : : sal_uInt32 nTemp32;
141 : : sal_uInt32 nCompression;
142 : :
143 : : // bis zur ersten Information
144 [ # # ]: 0 : rStm.SeekRel( 0x10 );
145 : :
146 : : // PixelBreite auslesen
147 [ # # ]: 0 : rStm >> nTemp32;
148 : 0 : aPixSize.Width() = nTemp32;
149 : :
150 : : // PixelHoehe auslesen
151 [ # # ]: 0 : rStm >> nTemp32;
152 : 0 : aPixSize.Height() = nTemp32;
153 : :
154 : : // Planes auslesen
155 [ # # ]: 0 : rStm >> nTemp16;
156 : 0 : nPlanes = nTemp16;
157 : :
158 : : // BitCount auslesen
159 [ # # ]: 0 : rStm >> nTemp16;
160 : 0 : nBitsPerPixel = nTemp16;
161 : :
162 : : // Compression auslesen
163 [ # # ]: 0 : rStm >> nTemp32;
164 : 0 : bCompressed = ( ( nCompression = nTemp32 ) > 0 );
165 : :
166 : : // logische Breite
167 [ # # ]: 0 : rStm.SeekRel( 4 );
168 [ # # ]: 0 : rStm >> nTemp32;
169 [ # # ]: 0 : if ( nTemp32 )
170 : 0 : aLogSize.Width() = ( aPixSize.Width() * 100000 ) / nTemp32;
171 : :
172 : : // logische Hoehe
173 [ # # ]: 0 : rStm >> nTemp32;
174 [ # # ]: 0 : if ( nTemp32 )
175 : 0 : aLogSize.Height() = ( aPixSize.Height() * 100000 ) / nTemp32;
176 : :
177 : : // Wir wollen noch etwas feiner differenzieren und
178 : : // auf sinnvolle Werte ueberpruefen ( Bug-Id #29001 )
179 [ # # ][ # # ]: 0 : if ( ( nBitsPerPixel > 24 ) || ( nCompression > 3 ) )
180 : : {
181 : 0 : nFormat = GFF_NOT;
182 : 0 : bRet = sal_False;
183 : : }
184 : : }
185 : : }
186 [ # # ]: 0 : rStm.Seek( nStmPos );
187 : 0 : return bRet;
188 : : }
189 : :
190 : 0 : sal_Bool GraphicDescriptor::ImpDetectGIF( SvStream& rStm, sal_Bool bExtendedInfo )
191 : : {
192 : : sal_uInt32 n32;
193 : : sal_uInt16 n16;
194 : 0 : sal_Bool bRet = sal_False;
195 : : sal_uInt8 cByte;
196 : :
197 : 0 : sal_Int32 nStmPos = rStm.Tell();
198 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
199 [ # # ]: 0 : rStm >> n32;
200 : :
201 [ # # ]: 0 : if ( n32 == 0x38464947 )
202 : : {
203 [ # # ]: 0 : rStm >> n16;
204 [ # # ][ # # ]: 0 : if ( ( n16 == 0x6137 ) || ( n16 == 0x6139 ) )
205 : : {
206 : 0 : nFormat = GFF_GIF;
207 : 0 : bRet = sal_True;
208 : :
209 [ # # ]: 0 : if ( bExtendedInfo )
210 : : {
211 : : sal_uInt16 nTemp16;
212 : :
213 : : // PixelBreite auslesen
214 [ # # ]: 0 : rStm >> nTemp16;
215 : 0 : aPixSize.Width() = nTemp16;
216 : :
217 : : // PixelHoehe auslesen
218 [ # # ]: 0 : rStm >> nTemp16;
219 : 0 : aPixSize.Height() = nTemp16;
220 : :
221 : : // Bits/Pixel auslesen
222 [ # # ]: 0 : rStm >> cByte;
223 : 0 : nBitsPerPixel = ( ( cByte & 112 ) >> 4 ) + 1;
224 : : }
225 : : }
226 : : }
227 [ # # ]: 0 : rStm.Seek( nStmPos );
228 : 0 : return bRet;
229 : : }
230 : :
231 : : // returns the next jpeg marker, a return value of 0 represents an error
232 : 0 : sal_uInt8 ImpDetectJPG_GetNextMarker( SvStream& rStm )
233 : : {
234 : : sal_uInt8 nByte;
235 [ # # ]: 0 : do
236 : : {
237 [ # # ]: 0 : do
238 : : {
239 [ # # ]: 0 : rStm >> nByte;
240 [ # # ][ # # ]: 0 : if ( rStm.IsEof() || rStm.GetError() ) // as 0 is not allowed as marker,
[ # # ]
241 : 0 : return 0; // we can use it as errorcode
242 : : }
243 : : while ( nByte != 0xff );
244 [ # # ]: 0 : do
245 : : {
246 [ # # ]: 0 : rStm >> nByte;
247 [ # # ][ # # ]: 0 : if ( rStm.IsEof() || rStm.GetError() )
[ # # ]
248 : 0 : return 0;
249 : : }
250 : : while( nByte == 0xff );
251 : : }
252 : : while( nByte == 0 ); // 0xff00 represents 0xff and not a marker,
253 : : // the marker detection has to be restartet.
254 : 0 : return nByte;
255 : : }
256 : :
257 : 0 : sal_Bool GraphicDescriptor::ImpDetectJPG( SvStream& rStm, sal_Bool bExtendedInfo )
258 : : {
259 : : sal_uInt32 nTemp32;
260 : 0 : sal_Bool bRet = sal_False;
261 : :
262 : 0 : sal_Int32 nStmPos = rStm.Tell();
263 : :
264 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
265 [ # # ]: 0 : rStm >> nTemp32;
266 : :
267 : : // compare upper 24 bits
268 [ # # ]: 0 : if( 0xffd8ff00 == ( nTemp32 & 0xffffff00 ) )
269 : : {
270 : 0 : nFormat = GFF_JPG;
271 : 0 : bRet = sal_True;
272 : :
273 [ # # ]: 0 : if ( bExtendedInfo )
274 : : {
275 [ # # ]: 0 : rStm.SeekRel( -2 );
276 : :
277 : 0 : sal_uInt32 nError( rStm.GetError() );
278 : :
279 : 0 : sal_Bool bScanFailure = sal_False;
280 : 0 : sal_Bool bScanFinished = sal_False;
281 : :
282 [ # # ][ # # ]: 0 : while( !bScanFailure && !bScanFinished && !rStm.IsEof() && !rStm.GetError() )
[ # # ][ # # ]
[ # # ]
283 : : {
284 [ # # ]: 0 : sal_uInt8 nMarker = ImpDetectJPG_GetNextMarker( rStm );
285 [ # # # # ]: 0 : switch( nMarker )
286 : : {
287 : : // fixed size marker, not having a two byte length parameter
288 : : case 0xd0 : // RST0
289 : : case 0xd1 :
290 : : case 0xd2 :
291 : : case 0xd3 :
292 : : case 0xd4 :
293 : : case 0xd5 :
294 : : case 0xd6 :
295 : : case 0xd7 : // RST7
296 : : case 0x01 : // TEM
297 : 0 : break;
298 : :
299 : : case 0xd8 : // SOI (has already been checked, there should not be a second one)
300 : : case 0x00 : // marker is invalid, we should stop now
301 : 0 : bScanFailure = sal_True;
302 : 0 : break;
303 : :
304 : : case 0xd9 : // EOI
305 : 0 : bScanFinished = sal_True;
306 : 0 : break;
307 : :
308 : : // per default we assume marker segments conaining a length parameter
309 : : default :
310 : : {
311 : : sal_uInt16 nLength;
312 [ # # ]: 0 : rStm >> nLength;
313 : :
314 [ # # ]: 0 : if ( nLength < 2 )
315 : 0 : bScanFailure = sal_True;
316 : : else
317 : : {
318 : 0 : sal_uInt32 nNextMarkerPos = rStm.Tell() + nLength - 2;
319 [ # # # ]: 0 : switch( nMarker )
320 : : {
321 : : case 0xe0 : // APP0 Marker
322 : : {
323 [ # # ]: 0 : if ( nLength == 16 )
324 : : {
325 : : sal_Int32 nIdentifier;
326 [ # # ]: 0 : rStm >> nIdentifier;
327 [ # # ]: 0 : if ( nIdentifier == 0x4a464946 ) // JFIF Identifier
328 : : {
329 : : sal_uInt8 nStringTerminator;
330 : : sal_uInt8 nMajorRevision;
331 : : sal_uInt8 nMinorRevision;
332 : : sal_uInt8 nUnits;
333 : : sal_uInt16 nHorizontalResolution;
334 : : sal_uInt16 nVerticalResolution;
335 : : sal_uInt8 nHorzThumbnailPixelCount;
336 : : sal_uInt8 nVertThumbnailPixelCount;
337 : :
338 [ # # ]: 0 : rStm >> nStringTerminator
339 [ # # ]: 0 : >> nMajorRevision
340 [ # # ]: 0 : >> nMinorRevision
341 [ # # ]: 0 : >> nUnits
342 [ # # ]: 0 : >> nHorizontalResolution
343 [ # # ]: 0 : >> nVerticalResolution
344 [ # # ]: 0 : >> nHorzThumbnailPixelCount
345 [ # # ]: 0 : >> nVertThumbnailPixelCount;
346 : :
347 : : // setting the logical size
348 [ # # ][ # # ]: 0 : if ( nUnits && nHorizontalResolution && nVerticalResolution )
[ # # ]
349 : : {
350 [ # # ]: 0 : MapMode aMap;
351 [ # # ][ # # ]: 0 : aMap.SetMapUnit( nUnits == 1 ? MAP_INCH : MAP_CM );
352 [ # # ][ # # ]: 0 : aMap.SetScaleX( Fraction( 1, nHorizontalResolution ) );
353 [ # # ][ # # ]: 0 : aMap.SetScaleY( Fraction( 1, nVerticalResolution ) );
354 [ # # ][ # # ]: 0 : aLogSize = OutputDevice::LogicToLogic( aPixSize, aMap, MapMode( MAP_100TH_MM ) );
[ # # ][ # # ]
355 : : }
356 : : }
357 : : }
358 : : }
359 : 0 : break;
360 : :
361 : : // Start of Frame Markers
362 : : case 0xc0 : // SOF0
363 : : case 0xc1 : // SOF1
364 : : case 0xc2 : // SOF2
365 : : case 0xc3 : // SOF3
366 : : case 0xc5 : // SOF5
367 : : case 0xc6 : // SOF6
368 : : case 0xc7 : // SOF7
369 : : case 0xc9 : // SOF9
370 : : case 0xca : // SOF10
371 : : case 0xcb : // SOF11
372 : : case 0xcd : // SOF13
373 : : case 0xce : // SOF14
374 : : case 0xcf : // SOF15
375 : : {
376 : : sal_uInt8 nSamplePrecision;
377 : : sal_uInt16 nNumberOfLines;
378 : : sal_uInt16 nSamplesPerLine;
379 : : sal_uInt8 nNumberOfImageComponents;
380 : : sal_uInt8 nComponentsIdentifier;
381 : : sal_uInt8 nHorizontalSamplingFactor;
382 : : sal_uInt8 nQuantizationTableDestinationSelector;
383 [ # # ]: 0 : rStm >> nSamplePrecision
384 [ # # ]: 0 : >> nNumberOfLines
385 [ # # ]: 0 : >> nSamplesPerLine
386 [ # # ]: 0 : >> nNumberOfImageComponents
387 [ # # ]: 0 : >> nComponentsIdentifier
388 [ # # ]: 0 : >> nHorizontalSamplingFactor
389 [ # # ]: 0 : >> nQuantizationTableDestinationSelector;
390 : 0 : nHorizontalSamplingFactor >>= 4;
391 : :
392 : 0 : aPixSize.Height() = nNumberOfLines;
393 : 0 : aPixSize.Width() = nSamplesPerLine;
394 [ # # ][ # # ]: 0 : nBitsPerPixel = ( nNumberOfImageComponents == 3 ? 24 : nNumberOfImageComponents == 1 ? 8 : 0 );
395 : 0 : nPlanes = 1;
396 : :
397 : 0 : bScanFinished = sal_True;
398 : : }
399 : 0 : break;
400 : : }
401 [ # # ]: 0 : rStm.Seek( nNextMarkerPos );
402 : : }
403 : : }
404 : 0 : break;
405 : : }
406 : : }
407 [ # # ]: 0 : rStm.SetError( nError );
408 : : }
409 : : }
410 [ # # ]: 0 : rStm.Seek( nStmPos );
411 : 0 : return bRet;
412 : : }
413 : :
414 : 0 : sal_Bool GraphicDescriptor::ImpDetectPCD( SvStream& rStm, sal_Bool )
415 : : {
416 : 0 : sal_Bool bRet = sal_False;
417 : :
418 : 0 : sal_Int32 nStmPos = rStm.Tell();
419 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
420 : :
421 : : sal_uInt32 nTemp32;
422 : : sal_uInt16 nTemp16;
423 : : sal_uInt8 cByte;
424 : :
425 [ # # ]: 0 : rStm.SeekRel( 2048 );
426 [ # # ]: 0 : rStm >> nTemp32;
427 [ # # ]: 0 : rStm >> nTemp16;
428 [ # # ]: 0 : rStm >> cByte;
429 : :
430 [ # # ][ # # ]: 0 : if ( ( nTemp32 == 0x5f444350 ) &&
[ # # ]
431 : : ( nTemp16 == 0x5049 ) &&
432 : : ( cByte == 0x49 ) )
433 : : {
434 : 0 : nFormat = GFF_PCD;
435 : 0 : bRet = sal_True;
436 : : }
437 [ # # ]: 0 : rStm.Seek( nStmPos );
438 : 0 : return bRet;
439 : : }
440 : :
441 : 0 : sal_Bool GraphicDescriptor::ImpDetectPCX( SvStream& rStm, sal_Bool bExtendedInfo )
442 : : {
443 : : // ! Because 0x0a can be interpreted as LF too ...
444 : : // we cant be shure that this special sign represent a PCX file only.
445 : : // Every Ascii file is possible here :-(
446 : : // We must detect the whole header.
447 : 0 : bExtendedInfo = sal_True;
448 : :
449 : 0 : sal_Bool bRet = sal_False;
450 : : sal_uInt8 cByte;
451 : :
452 : 0 : sal_Int32 nStmPos = rStm.Tell();
453 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
454 [ # # ]: 0 : rStm >> cByte;
455 : :
456 [ # # ]: 0 : if ( cByte == 0x0a )
457 : : {
458 : 0 : nFormat = GFF_PCX;
459 : 0 : bRet = sal_True;
460 : :
461 [ # # ]: 0 : if ( bExtendedInfo )
462 : : {
463 : : sal_uInt16 nTemp16;
464 : : sal_uInt16 nXmin;
465 : : sal_uInt16 nXmax;
466 : : sal_uInt16 nYmin;
467 : : sal_uInt16 nYmax;
468 : : sal_uInt16 nDPIx;
469 : : sal_uInt16 nDPIy;
470 : :
471 : :
472 [ # # ]: 0 : rStm.SeekRel( 1 );
473 : :
474 : : // Kompression lesen
475 [ # # ]: 0 : rStm >> cByte;
476 : 0 : bCompressed = ( cByte > 0 );
477 : :
478 [ # # ][ # # ]: 0 : bRet = (cByte==0 || cByte ==1);
479 : :
480 : : // Bits/Pixel lesen
481 [ # # ]: 0 : rStm >> cByte;
482 : 0 : nBitsPerPixel = cByte;
483 : :
484 : : // Bildabmessungen
485 [ # # ]: 0 : rStm >> nTemp16;
486 : 0 : nXmin = nTemp16;
487 [ # # ]: 0 : rStm >> nTemp16;
488 : 0 : nYmin = nTemp16;
489 [ # # ]: 0 : rStm >> nTemp16;
490 : 0 : nXmax = nTemp16;
491 [ # # ]: 0 : rStm >> nTemp16;
492 : 0 : nYmax = nTemp16;
493 : :
494 : 0 : aPixSize.Width() = nXmax - nXmin + 1;
495 : 0 : aPixSize.Height() = nYmax - nYmin + 1;
496 : :
497 : : // Aufloesung
498 [ # # ]: 0 : rStm >> nTemp16;
499 : 0 : nDPIx = nTemp16;
500 [ # # ]: 0 : rStm >> nTemp16;
501 : 0 : nDPIy = nTemp16;
502 : :
503 : : // logische Groesse setzen
504 : : MapMode aMap( MAP_INCH, Point(),
505 [ # # ][ # # ]: 0 : Fraction( 1, nDPIx ), Fraction( 1, nDPIy ) );
[ # # ]
506 : : aLogSize = OutputDevice::LogicToLogic( aPixSize, aMap,
507 [ # # ][ # # ]: 0 : MapMode( MAP_100TH_MM ) );
[ # # ]
508 : :
509 : :
510 : : // Anzahl Farbebenen
511 [ # # ]: 0 : rStm.SeekRel( 49 );
512 [ # # ]: 0 : rStm >> cByte;
513 : 0 : nPlanes = cByte;
514 : :
515 [ # # ]: 0 : bRet = (nPlanes<=4);
516 : : }
517 : : }
518 : :
519 [ # # ]: 0 : rStm.Seek( nStmPos );
520 : 0 : return bRet;
521 : : }
522 : :
523 : 0 : sal_Bool GraphicDescriptor::ImpDetectPNG( SvStream& rStm, sal_Bool bExtendedInfo )
524 : : {
525 : : sal_uInt32 nTemp32;
526 : 0 : sal_Bool bRet = sal_False;
527 : :
528 : 0 : sal_Int32 nStmPos = rStm.Tell();
529 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
530 [ # # ]: 0 : rStm >> nTemp32;
531 : :
532 [ # # ]: 0 : if ( nTemp32 == 0x89504e47 )
533 : : {
534 [ # # ]: 0 : rStm >> nTemp32;
535 [ # # ]: 0 : if ( nTemp32 == 0x0d0a1a0a )
536 : : {
537 : 0 : nFormat = GFF_PNG;
538 : 0 : bRet = sal_True;
539 : :
540 [ # # ]: 0 : if ( bExtendedInfo )
541 : : {
542 : : sal_uInt8 cByte;
543 : :
544 : : // IHDR-Chunk
545 [ # # ]: 0 : rStm.SeekRel( 8 );
546 : :
547 : : // Breite einlesen
548 [ # # ]: 0 : rStm >> nTemp32;
549 : 0 : aPixSize.Width() = nTemp32;
550 : :
551 : : // Hoehe einlesen
552 [ # # ]: 0 : rStm >> nTemp32;
553 : 0 : aPixSize.Height() = nTemp32;
554 : :
555 : : // Bits/Pixel einlesen
556 [ # # ]: 0 : rStm >> cByte;
557 : 0 : nBitsPerPixel = cByte;
558 : :
559 : : // Planes immer 1;
560 : : // Kompression immer
561 : 0 : nPlanes = 1;
562 : 0 : bCompressed = sal_True;
563 : :
564 : : sal_uInt32 nLen32;
565 : :
566 [ # # ]: 0 : rStm.SeekRel( 8 );
567 : :
568 : : // so lange ueberlesen, bis wir den pHYs-Chunk haben oder
569 : : // den Anfang der Bilddaten
570 [ # # ]: 0 : rStm >> nLen32;
571 [ # # ]: 0 : rStm >> nTemp32;
572 [ # # ][ # # ]: 0 : while( ( nTemp32 != 0x70485973 ) && ( nTemp32 != 0x49444154 ) )
[ # # ]
573 : : {
574 [ # # ]: 0 : rStm.SeekRel( 4 + nLen32 );
575 [ # # ]: 0 : rStm >> nLen32;
576 [ # # ]: 0 : rStm >> nTemp32;
577 : : }
578 : :
579 [ # # ]: 0 : if ( nTemp32 == 0x70485973 )
580 : : {
581 : : sal_uLong nXRes;
582 : : sal_uLong nYRes;
583 : :
584 : : // horizontale Aufloesung
585 [ # # ]: 0 : rStm >> nTemp32;
586 : 0 : nXRes = nTemp32;
587 : :
588 : : // vertikale Aufloesung
589 [ # # ]: 0 : rStm >> nTemp32;
590 : 0 : nYRes = nTemp32;
591 : :
592 : : // Unit einlesen
593 [ # # ]: 0 : rStm >> cByte;
594 : :
595 [ # # ]: 0 : if ( cByte )
596 : : {
597 [ # # ]: 0 : if ( nXRes )
598 : 0 : aLogSize.Width() = ( aPixSize.Width() * 100000 ) /
599 : 0 : nTemp32;
600 : :
601 [ # # ]: 0 : if ( nYRes )
602 : 0 : aLogSize.Height() = ( aPixSize.Height() * 100000 ) /
603 : 0 : nTemp32;
604 : : }
605 : : }
606 : : }
607 : : }
608 : : }
609 [ # # ]: 0 : rStm.Seek( nStmPos );
610 : 0 : return bRet;
611 : : }
612 : :
613 : 0 : sal_Bool GraphicDescriptor::ImpDetectTIF( SvStream& rStm, sal_Bool bExtendedInfo )
614 : : {
615 : 0 : sal_Bool bDetectOk = sal_False;
616 : 0 : sal_Bool bRet = sal_False;
617 : : sal_uInt8 cByte1;
618 : : sal_uInt8 cByte2;
619 : :
620 : 0 : sal_Int32 nStmPos = rStm.Tell();
621 [ # # ]: 0 : rStm >> cByte1;
622 [ # # ]: 0 : rStm >> cByte2;
623 [ # # ]: 0 : if ( cByte1 == cByte2 )
624 : : {
625 [ # # ]: 0 : if ( cByte1 == 0x49 )
626 : : {
627 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
628 : 0 : bDetectOk = sal_True;
629 : : }
630 [ # # ]: 0 : else if ( cByte1 == 0x4d )
631 : : {
632 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
633 : 0 : bDetectOk = sal_True;
634 : : }
635 : :
636 [ # # ]: 0 : if ( bDetectOk )
637 : : {
638 : : sal_uInt16 nTemp16;
639 : :
640 [ # # ]: 0 : rStm >> nTemp16;
641 [ # # ]: 0 : if ( nTemp16 == 0x2a )
642 : : {
643 : 0 : nFormat = GFF_TIF;
644 : 0 : bRet = sal_True;
645 : :
646 [ # # ]: 0 : if ( bExtendedInfo )
647 : : {
648 : : sal_uLong nCount;
649 : 0 : sal_uLong nMax = DATA_SIZE - 48;
650 : : sal_uInt32 nTemp32;
651 : 0 : sal_Bool bOk = sal_False;
652 : :
653 : : // Offset des ersten IFD einlesen
654 [ # # ]: 0 : rStm >> nTemp32;
655 [ # # ]: 0 : rStm.SeekRel( ( nCount = ( nTemp32 + 2 ) ) - 0x08 );
656 : :
657 [ # # ]: 0 : if ( nCount < nMax )
658 : : {
659 : : // Tag's lesen, bis wir auf Tag256 ( Width ) treffen
660 : : // nicht mehr Bytes als DATA_SIZE lesen
661 [ # # ]: 0 : rStm >> nTemp16;
662 [ # # ]: 0 : while ( nTemp16 != 256 )
663 : : {
664 : 0 : bOk = nCount < nMax;
665 [ # # ]: 0 : if ( !bOk )
666 : : {
667 : 0 : break;
668 : : }
669 [ # # ]: 0 : rStm.SeekRel( 10 );
670 [ # # ]: 0 : rStm >> nTemp16;
671 : 0 : nCount += 12;
672 : : }
673 : :
674 [ # # ]: 0 : if ( bOk )
675 : : {
676 : : // Breite lesen
677 [ # # ]: 0 : rStm >> nTemp16;
678 [ # # ]: 0 : rStm.SeekRel( 4 );
679 [ # # ]: 0 : if ( nTemp16 == 3 )
680 : : {
681 [ # # ]: 0 : rStm >> nTemp16;
682 : 0 : aPixSize.Width() = nTemp16;
683 [ # # ]: 0 : rStm.SeekRel( 2 );
684 : : }
685 : : else
686 : : {
687 [ # # ]: 0 : rStm >> nTemp32;
688 : 0 : aPixSize.Width() = nTemp32;
689 : : }
690 : 0 : nCount += 12;
691 : :
692 : : // Hoehe lesen
693 [ # # ]: 0 : rStm.SeekRel( 2 );
694 [ # # ]: 0 : rStm >> nTemp16;
695 [ # # ]: 0 : rStm.SeekRel( 4 );
696 [ # # ]: 0 : if ( nTemp16 == 3 )
697 : : {
698 [ # # ]: 0 : rStm >> nTemp16;
699 : 0 : aPixSize.Height() = nTemp16;
700 [ # # ]: 0 : rStm.SeekRel( 2 );
701 : : }
702 : : else
703 : : {
704 [ # # ]: 0 : rStm >> nTemp32;
705 : 0 : aPixSize.Height() = nTemp32;
706 : : }
707 : 0 : nCount += 12;
708 : :
709 : : // ggf. Bits/Pixel lesen
710 [ # # ]: 0 : rStm >> nTemp16;
711 [ # # ]: 0 : if ( nTemp16 == 258 )
712 : : {
713 [ # # ]: 0 : rStm.SeekRel( 6 );
714 [ # # ]: 0 : rStm >> nTemp16;
715 : 0 : nBitsPerPixel = nTemp16;
716 [ # # ]: 0 : rStm.SeekRel( 2 );
717 : 0 : nCount += 12;
718 : : }
719 : : else
720 [ # # ]: 0 : rStm.SeekRel( -2 );
721 : :
722 : : // ggf. Compression lesen
723 [ # # ]: 0 : rStm >> nTemp16;
724 [ # # ]: 0 : if ( nTemp16 == 259 )
725 : : {
726 [ # # ]: 0 : rStm.SeekRel( 6 );
727 [ # # ]: 0 : rStm >> nTemp16;
728 : 0 : bCompressed = ( nTemp16 > 1 );
729 [ # # ]: 0 : rStm.SeekRel( 2 );
730 : 0 : nCount += 12;
731 : : }
732 : : else
733 [ # # ]: 0 : rStm.SeekRel( -2 );
734 : : }
735 : : }
736 : : }
737 : : }
738 : : }
739 : : }
740 [ # # ]: 0 : rStm.Seek( nStmPos );
741 : 0 : return bRet;
742 : : }
743 : :
744 : 0 : sal_Bool GraphicDescriptor::ImpDetectXBM( SvStream&, sal_Bool )
745 : : {
746 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "xbm", 3 ) == COMPARE_EQUAL;
747 [ # # ]: 0 : if (bRet)
748 : 0 : nFormat = GFF_XBM;
749 : :
750 : 0 : return bRet;
751 : : }
752 : :
753 : 0 : sal_Bool GraphicDescriptor::ImpDetectXPM( SvStream&, sal_Bool )
754 : : {
755 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "xpm", 3 ) == COMPARE_EQUAL;
756 [ # # ]: 0 : if (bRet)
757 : 0 : nFormat = GFF_XPM;
758 : :
759 : 0 : return bRet;
760 : : }
761 : :
762 : 0 : sal_Bool GraphicDescriptor::ImpDetectPBM( SvStream& rStm, sal_Bool )
763 : : {
764 : 0 : sal_Bool bRet = sal_False;
765 : :
766 : : // erst auf Datei Extension pruefen, da diese aussagekraeftiger ist
767 : : // als die 2 ID Bytes
768 : :
769 [ # # ]: 0 : if ( aPathExt.CompareToAscii( "pbm", 3 ) == COMPARE_EQUAL )
770 : 0 : bRet = sal_True;
771 : : else
772 : : {
773 : 0 : sal_Int32 nStmPos = rStm.Tell();
774 : : sal_uInt8 nFirst, nSecond;
775 [ # # ][ # # ]: 0 : rStm >> nFirst >> nSecond;
776 [ # # ][ # # ]: 0 : if ( nFirst == 'P' && ( ( nSecond == '1' ) || ( nSecond == '4' ) ) )
[ # # ]
777 : 0 : bRet = sal_True;
778 [ # # ]: 0 : rStm.Seek( nStmPos );
779 : : }
780 : :
781 [ # # ]: 0 : if ( bRet )
782 : 0 : nFormat = GFF_PBM;
783 : :
784 : 0 : return bRet;
785 : : }
786 : :
787 : 0 : sal_Bool GraphicDescriptor::ImpDetectPGM( SvStream& rStm, sal_Bool )
788 : : {
789 : 0 : sal_Bool bRet = sal_False;
790 : :
791 [ # # ]: 0 : if ( aPathExt.CompareToAscii( "pgm", 3 ) == COMPARE_EQUAL )
792 : 0 : bRet = sal_True;
793 : : else
794 : : {
795 : : sal_uInt8 nFirst, nSecond;
796 : 0 : sal_Int32 nStmPos = rStm.Tell();
797 [ # # ][ # # ]: 0 : rStm >> nFirst >> nSecond;
798 [ # # ][ # # ]: 0 : if ( nFirst == 'P' && ( ( nSecond == '2' ) || ( nSecond == '5' ) ) )
[ # # ]
799 : 0 : bRet = sal_True;
800 [ # # ]: 0 : rStm.Seek( nStmPos );
801 : : }
802 : :
803 [ # # ]: 0 : if ( bRet )
804 : 0 : nFormat = GFF_PGM;
805 : :
806 : 0 : return bRet;
807 : : }
808 : :
809 : 0 : sal_Bool GraphicDescriptor::ImpDetectPPM( SvStream& rStm, sal_Bool )
810 : : {
811 : 0 : sal_Bool bRet = sal_False;
812 : :
813 [ # # ]: 0 : if ( aPathExt.CompareToAscii( "ppm", 3 ) == COMPARE_EQUAL )
814 : 0 : bRet = sal_True;
815 : : else
816 : : {
817 : : sal_uInt8 nFirst, nSecond;
818 : 0 : sal_Int32 nStmPos = rStm.Tell();
819 [ # # ][ # # ]: 0 : rStm >> nFirst >> nSecond;
820 [ # # ][ # # ]: 0 : if ( nFirst == 'P' && ( ( nSecond == '3' ) || ( nSecond == '6' ) ) )
[ # # ]
821 : 0 : bRet = sal_True;
822 [ # # ]: 0 : rStm.Seek( nStmPos );
823 : : }
824 : :
825 [ # # ]: 0 : if ( bRet )
826 : 0 : nFormat = GFF_PPM;
827 : :
828 : 0 : return bRet;
829 : : }
830 : :
831 : 0 : sal_Bool GraphicDescriptor::ImpDetectRAS( SvStream& rStm, sal_Bool )
832 : : {
833 : : sal_uInt32 nMagicNumber;
834 : 0 : sal_Bool bRet = sal_False;
835 : 0 : sal_Int32 nStmPos = rStm.Tell();
836 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
837 [ # # ]: 0 : rStm >> nMagicNumber;
838 [ # # ]: 0 : if ( nMagicNumber == 0x59a66a95 )
839 : : {
840 : 0 : nFormat = GFF_RAS;
841 : 0 : bRet = sal_True;
842 : : }
843 [ # # ]: 0 : rStm.Seek( nStmPos );
844 : 0 : return bRet;
845 : : }
846 : :
847 : 0 : sal_Bool GraphicDescriptor::ImpDetectTGA( SvStream&, sal_Bool )
848 : : {
849 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "tga", 3 ) == COMPARE_EQUAL;
850 [ # # ]: 0 : if (bRet)
851 : 0 : nFormat = GFF_TGA;
852 : :
853 : 0 : return bRet;
854 : : }
855 : :
856 : 0 : sal_Bool GraphicDescriptor::ImpDetectPSD( SvStream& rStm, sal_Bool bExtendedInfo )
857 : : {
858 : 0 : sal_Bool bRet = sal_False;
859 : :
860 : : sal_uInt32 nMagicNumber;
861 : 0 : sal_Int32 nStmPos = rStm.Tell();
862 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
863 [ # # ]: 0 : rStm >> nMagicNumber;
864 [ # # ]: 0 : if ( nMagicNumber == 0x38425053 )
865 : : {
866 : : sal_uInt16 nVersion;
867 [ # # ]: 0 : rStm >> nVersion;
868 [ # # ]: 0 : if ( nVersion == 1 )
869 : : {
870 : 0 : bRet = sal_True;
871 [ # # ]: 0 : if ( bExtendedInfo )
872 : : {
873 : : sal_uInt16 nChannels;
874 : : sal_uInt32 nRows;
875 : : sal_uInt32 nColumns;
876 : : sal_uInt16 nDepth;
877 : : sal_uInt16 nMode;
878 [ # # ]: 0 : rStm.SeekRel( 6 ); // Pad
879 [ # # ][ # # ]: 0 : rStm >> nChannels >> nRows >> nColumns >> nDepth >> nMode;
[ # # ][ # # ]
[ # # ]
880 [ # # ][ # # ]: 0 : if ( ( nDepth == 1 ) || ( nDepth == 8 ) || ( nDepth == 16 ) )
[ # # ]
881 : : {
882 [ # # ]: 0 : nBitsPerPixel = ( nDepth == 16 ) ? 8 : nDepth;
883 [ # # # ]: 0 : switch ( nChannels )
884 : : {
885 : : case 4 :
886 : : case 3 :
887 : 0 : nBitsPerPixel = 24;
888 : : case 2 :
889 : : case 1 :
890 : 0 : aPixSize.Width() = nColumns;
891 : 0 : aPixSize.Height() = nRows;
892 : 0 : break;
893 : : default:
894 : 0 : bRet = sal_False;
895 : : }
896 : : }
897 : : else
898 : 0 : bRet = sal_False;
899 : : }
900 : : }
901 : : }
902 : :
903 [ # # ]: 0 : if ( bRet )
904 : 0 : nFormat = GFF_PSD;
905 [ # # ]: 0 : rStm.Seek( nStmPos );
906 : 0 : return bRet;
907 : : }
908 : :
909 : 0 : sal_Bool GraphicDescriptor::ImpDetectEPS( SvStream& rStm, sal_Bool )
910 : : {
911 : : // es wird die EPS mit Vorschaubild Variante und die Extensionuebereinstimmung
912 : : // geprueft
913 : :
914 : : sal_uInt32 nFirstLong;
915 : : sal_uInt8 nFirstBytes[20];
916 : 0 : sal_Bool bRet = sal_False;
917 : :
918 : 0 : sal_Int32 nStmPos = rStm.Tell();
919 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
920 [ # # ]: 0 : rStm >> nFirstLong;
921 [ # # ]: 0 : rStm.SeekRel( -4 );
922 [ # # ]: 0 : rStm.Read( &nFirstBytes, 20 );
923 : :
924 [ # # ][ # # ]: 0 : if ( ( nFirstLong == 0xC5D0D3C6 ) || ( aPathExt.CompareToAscii( "eps", 3 ) == COMPARE_EQUAL ) ||
[ # # ][ # # ]
[ # # ][ # # ]
925 [ # # ]: 0 : ( ImplSearchEntry( nFirstBytes, (sal_uInt8*)"%!PS-Adobe", 10, 10 )
926 [ # # ]: 0 : && ImplSearchEntry( &nFirstBytes[15], (sal_uInt8*)"EPS", 3, 3 ) ) )
927 : : {
928 : 0 : nFormat = GFF_EPS;
929 : 0 : bRet = sal_True;
930 : : }
931 [ # # ]: 0 : rStm.Seek( nStmPos );
932 : 0 : return bRet;
933 : : }
934 : :
935 : 0 : sal_Bool GraphicDescriptor::ImpDetectDXF( SvStream&, sal_Bool )
936 : : {
937 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "dxf", 3 ) == COMPARE_EQUAL;
938 [ # # ]: 0 : if (bRet)
939 : 0 : nFormat = GFF_DXF;
940 : :
941 : 0 : return bRet;
942 : : }
943 : :
944 : 0 : sal_Bool GraphicDescriptor::ImpDetectMET( SvStream&, sal_Bool )
945 : : {
946 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "met", 3 ) == COMPARE_EQUAL;
947 [ # # ]: 0 : if (bRet)
948 : 0 : nFormat = GFF_MET;
949 : :
950 : 0 : return bRet;
951 : : }
952 : :
953 : : extern bool isPCT(SvStream& rStream, sal_uLong nStreamPos, sal_uLong nStreamLen);
954 : :
955 : 0 : sal_Bool GraphicDescriptor::ImpDetectPCT( SvStream& rStm, sal_Bool )
956 : : {
957 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "pct", 3 ) == COMPARE_EQUAL;
958 [ # # ]: 0 : if (bRet)
959 : 0 : nFormat = GFF_PCT;
960 : : else
961 : : {
962 : 0 : sal_Size nStreamPos = rStm.Tell();
963 : 0 : sal_Size nStreamLen = rStm.remainingSize();
964 [ # # ]: 0 : if (isPCT(rStm, nStreamPos, nStreamLen))
965 : : {
966 : 0 : bRet = sal_True;
967 : 0 : nFormat = GFF_PCT;
968 : : }
969 : 0 : rStm.Seek(nStreamPos);
970 : : }
971 : :
972 : 0 : return bRet;
973 : : }
974 : :
975 : 0 : sal_Bool GraphicDescriptor::ImpDetectSGF( SvStream& rStm, sal_Bool )
976 : : {
977 : 0 : sal_Bool bRet = sal_False;
978 [ # # ]: 0 : if( aPathExt.CompareToAscii( "sgf", 3 ) == COMPARE_EQUAL )
979 : 0 : bRet = sal_True;
980 : : else
981 : : {
982 : 0 : sal_Int32 nStmPos = rStm.Tell();
983 : :
984 : : sal_uInt8 nFirst, nSecond;
985 : :
986 [ # # ][ # # ]: 0 : rStm >> nFirst >> nSecond;
987 : :
988 [ # # ][ # # ]: 0 : if( nFirst == 'J' && nSecond == 'J' )
989 : 0 : bRet = sal_True;
990 : :
991 [ # # ]: 0 : rStm.Seek( nStmPos );
992 : : }
993 : :
994 [ # # ]: 0 : if( bRet )
995 : 0 : nFormat = GFF_SGF;
996 : :
997 : 0 : return bRet;
998 : : }
999 : :
1000 : 0 : sal_Bool GraphicDescriptor::ImpDetectSGV( SvStream&, sal_Bool )
1001 : : {
1002 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "sgv", 3 ) == COMPARE_EQUAL;
1003 [ # # ]: 0 : if (bRet)
1004 : 0 : nFormat = GFF_SGV;
1005 : :
1006 : 0 : return bRet;
1007 : : }
1008 : :
1009 : 0 : sal_Bool GraphicDescriptor::ImpDetectSVM( SvStream& rStm, sal_Bool bExtendedInfo )
1010 : : {
1011 : : sal_uInt32 n32;
1012 : 0 : sal_Bool bRet = sal_False;
1013 : : sal_uInt8 cByte;
1014 : :
1015 : 0 : sal_Int32 nStmPos = rStm.Tell();
1016 [ # # ]: 0 : rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
1017 [ # # ]: 0 : rStm >> n32;
1018 [ # # ]: 0 : if ( n32 == 0x44475653 )
1019 : : {
1020 [ # # ]: 0 : rStm >> cByte;
1021 [ # # ]: 0 : if ( cByte == 0x49 )
1022 : : {
1023 : 0 : nFormat = GFF_SVM;
1024 : 0 : bRet = sal_True;
1025 : :
1026 [ # # ]: 0 : if ( bExtendedInfo )
1027 : : {
1028 : : sal_uInt32 nTemp32;
1029 : : sal_uInt16 nTemp16;
1030 : :
1031 [ # # ]: 0 : rStm.SeekRel( 0x04 );
1032 : :
1033 : : // Breite auslesen
1034 [ # # ]: 0 : rStm >> nTemp32;
1035 : 0 : aLogSize.Width() = nTemp32;
1036 : :
1037 : : // Hoehe auslesen
1038 [ # # ]: 0 : rStm >> nTemp32;
1039 : 0 : aLogSize.Height() = nTemp32;
1040 : :
1041 : : // Map-Unit auslesen und PrefSize ermitteln
1042 [ # # ]: 0 : rStm >> nTemp16;
1043 : : aLogSize = OutputDevice::LogicToLogic( aLogSize,
1044 : : MapMode( (MapUnit) nTemp16 ),
1045 [ # # ][ # # ]: 0 : MapMode( MAP_100TH_MM ) );
[ # # ][ # # ]
[ # # ]
1046 : : }
1047 : : }
1048 : : }
1049 : : else
1050 : : {
1051 [ # # ]: 0 : rStm.SeekRel( -4L );
1052 [ # # ]: 0 : rStm >> n32;
1053 : :
1054 [ # # ]: 0 : if( n32 == 0x4D4C4356 )
1055 : : {
1056 : : sal_uInt16 nTmp16;
1057 : :
1058 [ # # ]: 0 : rStm >> nTmp16;
1059 : :
1060 [ # # ]: 0 : if( nTmp16 == 0x4654 )
1061 : : {
1062 : 0 : nFormat = GFF_SVM;
1063 : 0 : bRet = sal_True;
1064 : :
1065 [ # # ]: 0 : if( bExtendedInfo )
1066 : : {
1067 [ # # ]: 0 : MapMode aMapMode;
1068 : :
1069 [ # # ]: 0 : rStm.SeekRel( 0x06 );
1070 [ # # ]: 0 : rStm >> aMapMode;
1071 [ # # ]: 0 : rStm >> aLogSize;
1072 [ # # ][ # # ]: 0 : aLogSize = OutputDevice::LogicToLogic( aLogSize, aMapMode, MapMode( MAP_100TH_MM ) );
[ # # ][ # # ]
1073 : : }
1074 : : }
1075 : : }
1076 : : }
1077 [ # # ]: 0 : rStm.Seek( nStmPos );
1078 : 0 : return bRet;
1079 : : }
1080 : :
1081 : 0 : sal_Bool GraphicDescriptor::ImpDetectWMF( SvStream&, sal_Bool )
1082 : : {
1083 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "wmf",3 ) == COMPARE_EQUAL;
1084 [ # # ]: 0 : if (bRet)
1085 : 0 : nFormat = GFF_WMF;
1086 : :
1087 : 0 : return bRet;
1088 : : }
1089 : :
1090 : 0 : sal_Bool GraphicDescriptor::ImpDetectEMF( SvStream&, sal_Bool )
1091 : : {
1092 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "emf", 3 ) == COMPARE_EQUAL;
1093 [ # # ]: 0 : if (bRet)
1094 : 0 : nFormat = GFF_EMF;
1095 : :
1096 : 0 : return bRet;
1097 : : }
1098 : :
1099 : 0 : sal_Bool GraphicDescriptor::ImpDetectSVG( SvStream& /*rStm*/, sal_Bool /*bExtendedInfo*/ )
1100 : : {
1101 : 0 : sal_Bool bRet = aPathExt.CompareToAscii( "svg", 3 ) == COMPARE_EQUAL;
1102 [ # # ]: 0 : if (bRet)
1103 : 0 : nFormat = GFF_SVG;
1104 : :
1105 : 0 : return bRet;
1106 : : }
1107 : :
1108 : 0 : String GraphicDescriptor::GetImportFormatShortName( sal_uInt16 nFormat )
1109 : : {
1110 : 0 : const char *pKeyName = 0;
1111 : :
1112 [ # # # # : 0 : switch( nFormat )
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
1113 : : {
1114 : 0 : case( GFF_BMP ) : pKeyName = "bmp"; break;
1115 : 0 : case( GFF_GIF ) : pKeyName = "gif"; break;
1116 : 0 : case( GFF_JPG ) : pKeyName = "jpg"; break;
1117 : 0 : case( GFF_PCD ) : pKeyName = "pcd"; break;
1118 : 0 : case( GFF_PCX ) : pKeyName = "pcx"; break;
1119 : 0 : case( GFF_PNG ) : pKeyName = "png"; break;
1120 : 0 : case( GFF_XBM ) : pKeyName = "xbm"; break;
1121 : 0 : case( GFF_XPM ) : pKeyName = "xpm"; break;
1122 : 0 : case( GFF_PBM ) : pKeyName = "pbm"; break;
1123 : 0 : case( GFF_PGM ) : pKeyName = "pgm"; break;
1124 : 0 : case( GFF_PPM ) : pKeyName = "ppm"; break;
1125 : 0 : case( GFF_RAS ) : pKeyName = "ras"; break;
1126 : 0 : case( GFF_TGA ) : pKeyName = "tga"; break;
1127 : 0 : case( GFF_PSD ) : pKeyName = "psd"; break;
1128 : 0 : case( GFF_EPS ) : pKeyName = "eps"; break;
1129 : 0 : case( GFF_TIF ) : pKeyName = "tif"; break;
1130 : 0 : case( GFF_DXF ) : pKeyName = "dxf"; break;
1131 : 0 : case( GFF_MET ) : pKeyName = "met"; break;
1132 : 0 : case( GFF_PCT ) : pKeyName = "pct"; break;
1133 : 0 : case( GFF_SGF ) : pKeyName = "sgf"; break;
1134 : 0 : case( GFF_SGV ) : pKeyName = "sgv"; break;
1135 : 0 : case( GFF_SVM ) : pKeyName = "svm"; break;
1136 : 0 : case( GFF_WMF ) : pKeyName = "wmf"; break;
1137 : 0 : case( GFF_EMF ) : pKeyName = "emf"; break;
1138 : 0 : case( GFF_SVG ) : pKeyName = "svg"; break;
1139 : : }
1140 : :
1141 [ # # ]: 0 : return rtl::OUString::createFromAscii(pKeyName);
1142 : : }
1143 : :
1144 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
