svtools/source/filter.vcl/filter/filter2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: filter2.cxx,v $
  10  * $Revision: 1.20 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include <string.h>
  35 #include <stdio.h>
  36 #include <tools/stream.hxx>
  37 #include <tools/debug.hxx>
  38 #include <vcl/outdev.hxx>
  39 #include <tools/config.hxx>
  40 #include <svtools/filter.hxx>
  41 #include "FilterConfigCache.hxx"
  42 #include <unotools/ucbstreamhelper.hxx>
  43
  44 #define DATA_SIZE                       640
  45
  46 BYTE* ImplSearchEntry( BYTE* , BYTE* , ULONG , ULONG  );
  47
  48
  49 /*************************************************************************
  50 |*
  51 |*
  52 |*
  53 \************************************************************************/
  54
  55 GraphicDescriptor::GraphicDescriptor( const String* pPath ) :
  56     pFileStm            ( NULL )
  57 {
  58     ImpConstruct();
  59
  60     if ( pPath )
  61     {
  62         INetURLObject aURL( *pPath, INET_PROT_FILE );
  63         aPathExt = aURL.GetFileExtension().toAsciiLowerCase();
  64     }
  65     bLinked = TRUE;
  66     bLinkChanged = FALSE;
  67     bWideSearch = FALSE;
  68 }
  69
  70
  71 /*************************************************************************
  72 |*
  73 |*
  74 |*
  75 \************************************************************************/
  76
  77 GraphicDescriptor::GraphicDescriptor( const INetURLObject& rPath ) :
  78     pFileStm( ::utl::UcbStreamHelper::CreateStream( rPath.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ ) ),
  79     aPathExt( rPath.GetFileExtension().toAsciiLowerCase() )
  80 {
  81     if ( pFileStm )
  82     {
  83         nStmPos = 0;
  84         pFileStm->Seek( nStmPos );
  85         bDataReady = TRUE;
  86     }
  87
  88     ImpConstruct();
  89
  90     if ( pFileStm && !pFileStm->GetError() )
  91         bDataReady = TRUE;
  92 }
  93
  94 /*************************************************************************
  95 |*
  96 |*
  97 |*
  98 \************************************************************************/
  99
 100 GraphicDescriptor::GraphicDescriptor( SvStream& rInStream, const String* pPath) :
 101     pFileStm    ( NULL )
 102 {
 103     ImpConstruct();
 104
 105     if ( pPath )
 106     {
 107         INetURLObject aURL( *pPath );
 108         aPathExt = aURL.GetFileExtension().toAsciiLowerCase();
 109     }
 110     nStmPos = rInStream.Tell();
 111     pBaseStm = &rInStream;
 112     bBaseStm = TRUE;
 113
 114     if ( !pBaseStm->GetError() )
 115         bDataReady = TRUE;
 116 }
 117
 118
 119 /*************************************************************************
 120 |*
 121 |*
 122 |*
 123 \************************************************************************/
 124
 125 GraphicDescriptor::~GraphicDescriptor()
 126 {
 127     delete pFileStm;
 128 }
 129
 130
 131 /*************************************************************************
 132 |*
 133 |*
 134 |*
 135 \************************************************************************/
 136
 137 BOOL GraphicDescriptor::Detect( BOOL bExtendedInfo )
 138 {
 139     BOOL bRet = FALSE;
 140
 141     // Link-Status ueberpruefen
 142     if ( bLinked && bLinkChanged )
 143     {
 144         DBG_ASSERT( aReqLink.IsSet(), "Wo ist der RequestHandler???" );
 145         pMemStm = (SvStream*) aReqLink.Call( this );
 146         if ( pMemStm )
 147         {
 148             nStmPos = pMemStm->Tell();
 149             bDataReady = TRUE;
 150         }
 151     }
 152
 153     if ( bDataReady )
 154     {
 155         SvStream&       rStm = GetSearchStream();
 156         UINT16          nOldFormat = rStm.GetNumberFormatInt();
 157
 158         if              ( ImpDetectGIF( rStm, bExtendedInfo ) ) bRet = TRUE;
 159         else if ( ImpDetectJPG( rStm, bExtendedInfo ) ) bRet = TRUE;
 160         else if ( ImpDetectBMP( rStm, bExtendedInfo ) ) bRet = TRUE;
 161         else if ( ImpDetectPNG( rStm, bExtendedInfo ) ) bRet = TRUE;
 162         else if ( ImpDetectTIF( rStm, bExtendedInfo ) ) bRet = TRUE;
 163         else if ( ImpDetectPCX( rStm, bExtendedInfo ) ) bRet = TRUE;
 164         else if ( ImpDetectDXF( rStm, bExtendedInfo ) ) bRet = TRUE;
 165         else if ( ImpDetectMET( rStm, bExtendedInfo ) ) bRet = TRUE;
 166         else if ( ImpDetectSGF( rStm, bExtendedInfo ) ) bRet = TRUE;
 167         else if ( ImpDetectSGV( rStm, bExtendedInfo ) ) bRet = TRUE;
 168         else if ( ImpDetectSVM( rStm, bExtendedInfo ) ) bRet = TRUE;
 169         else if ( ImpDetectWMF( rStm, bExtendedInfo ) ) bRet = TRUE;
 170         else if ( ImpDetectEMF( rStm, bExtendedInfo ) ) bRet = TRUE;
 171         else if ( ImpDetectPCT( rStm, bExtendedInfo ) ) bRet = TRUE;
 172         else if ( ImpDetectXBM( rStm, bExtendedInfo ) ) bRet = TRUE;
 173         else if ( ImpDetectXPM( rStm, bExtendedInfo ) ) bRet = TRUE;
 174         else if ( ImpDetectPBM( rStm, bExtendedInfo ) ) bRet = TRUE;
 175         else if ( ImpDetectPGM( rStm, bExtendedInfo ) ) bRet = TRUE;
 176         else if ( ImpDetectPPM( rStm, bExtendedInfo ) ) bRet = TRUE;
 177         else if ( ImpDetectRAS( rStm, bExtendedInfo ) ) bRet = TRUE;
 178         else if ( ImpDetectTGA( rStm, bExtendedInfo ) ) bRet = TRUE;
 179         else if ( ImpDetectPSD( rStm, bExtendedInfo ) ) bRet = TRUE;
 180         else if ( ImpDetectEPS( rStm, bExtendedInfo ) ) bRet = TRUE;
 181
 182         // diese Formate lassen sich nur bei WideSearch im gesamten
 183         // Stream ermitteln
 184         else if ( bWideSearch )
 185         {
 186             if ( ImpDetectPCD( rStm, bExtendedInfo ) )
 187                 bRet = TRUE;
 188         }
 189
 190         rStm.SetNumberFormatInt( nOldFormat );
 191         rStm.Seek( nStmPos );
 192     }
 193
 194     return bRet;
 195 }
 196
 197
 198 /*************************************************************************
 199 |*
 200 |*
 201 |*
 202 \************************************************************************/
 203
 204 BOOL GraphicDescriptor::IsDataReady() const
 205 {
 206     return bDataReady;
 207 }
 208
 209
 210 /*************************************************************************
 211 |*
 212 |*
 213 |*
 214 \************************************************************************/
 215
 216 BOOL GraphicDescriptor::IsWideSearch() const
 217 {
 218     return bWideSearch;
 219 }
 220
 221
 222 /*************************************************************************
 223 |*
 224 |*
 225 |*
 226 \************************************************************************/
 227
 228 SvStream& GraphicDescriptor::GetSearchStream() const
 229 {
 230     DBG_ASSERT( bDataReady, "Was laeuft hier falsch???" );
 231
 232     if ( bLinked )
 233         return *pMemStm;
 234     else if ( bBaseStm )
 235         return *pBaseStm;
 236     else
 237         return *pFileStm;
 238 }
 239
 240
 241 /*************************************************************************
 242 |*
 243 |*
 244 |*
 245 \************************************************************************/
 246
 247 void GraphicDescriptor::SetRequestHdl( const Link& rRequestLink )
 248 {
 249     aReqLink = rRequestLink;
 250     bLinkChanged = TRUE;
 251 }
 252
 253
 254 /*************************************************************************
 255 |*
 256 |*
 257 |*
 258 \************************************************************************/
 259
 260 ULONG GraphicDescriptor::GetRequestedByteCount() const
 261 {
 262     return DATA_SIZE;
 263 }
 264
 265
 266 /******************************************************************************/
 267 /*                                                               IMP-Methoden                                                             */
 268 /*                                                                                                                                                        */
 269
 270
 271 /*************************************************************************
 272 |*
 273 |*
 274 |*
 275 \************************************************************************/
 276
 277 void GraphicDescriptor::ImpConstruct()
 278 {
 279     if ( !pFileStm )
 280         pFileStm = new SvStream();
 281     nFormat = GFF_NOT;
 282     nBitsPerPixel = 0;
 283     nPlanes = 0;
 284     bCompressed = FALSE;
 285     bDataReady = FALSE;
 286     bLinked = FALSE;
 287     bWideSearch = TRUE;
 288     bBaseStm = FALSE;
 289     pMemStm = NULL;
 290 }
 291
 292
 293 /*************************************************************************
 294 |*
 295 |*
 296 |*
 297 \************************************************************************/
 298
 299 BOOL GraphicDescriptor::ImpDetectBMP( SvStream& rStm, BOOL bExtendedInfo )
 300 {
 301     UINT16      nTemp16;
 302     BOOL        bRet = FALSE;
 303
 304     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 305     rStm.Seek( nStmPos );
 306
 307     rStm >> nTemp16;
 308
 309     // OS/2-BitmapArray
 310     if ( nTemp16 == 0x4142 )
 311     {
 312         rStm.SeekRel( 0x0c );
 313         rStm >> nTemp16;
 314     }
 315
 316     // Bitmap
 317     if ( nTemp16 == 0x4d42 )
 318     {
 319         nFormat = GFF_BMP;
 320         bRet = TRUE;
 321
 322         if ( bExtendedInfo )
 323         {
 324             UINT32      nTemp32;
 325             UINT32      nCompression;
 326
 327             // bis zur ersten Information
 328             rStm.SeekRel( 0x10 );
 329
 330             // PixelBreite auslesen
 331             rStm >> nTemp32;
 332             aPixSize.Width() = nTemp32;
 333
 334             // PixelHoehe auslesen
 335             rStm >> nTemp32;
 336             aPixSize.Height() = nTemp32;
 337
 338             // Planes auslesen
 339             rStm >> nTemp16;
 340             nPlanes = nTemp16;
 341
 342             // BitCount auslesen
 343             rStm >> nTemp16;
 344             nBitsPerPixel = nTemp16;
 345
 346             // Compression auslesen
 347             rStm >> nTemp32;
 348             bCompressed = ( ( nCompression = nTemp32 ) > 0 );
 349
 350             // logische Breite
 351             rStm.SeekRel( 4 );
 352             rStm >> nTemp32;
 353             if ( nTemp32 )
 354                 aLogSize.Width() = ( aPixSize.Width() * 100000 ) / nTemp32;
 355
 356             // logische Hoehe
 357             rStm >> nTemp32;
 358             if ( nTemp32 )
 359                 aLogSize.Height() = ( aPixSize.Height() * 100000 ) / nTemp32;
 360
 361             // Wir wollen noch etwas feiner differenzieren und
 362             // auf sinnvolle Werte ueberpruefen ( Bug-Id #29001 )
 363             if ( ( nBitsPerPixel > 24 ) || ( nCompression > 3 ) )
 364             {
 365                 nFormat = GFF_NOT;
 366                 bRet = FALSE;
 367             }
 368         }
 369     }
 370
 371     return bRet;
 372 }
 373
 374
 375 /*************************************************************************
 376 |*
 377 |*
 378 |*
 379 \************************************************************************/
 380
 381 BOOL GraphicDescriptor::ImpDetectGIF( SvStream& rStm, BOOL bExtendedInfo )
 382 {
 383     UINT32      n32;
 384     UINT16      n16;
 385     BOOL        bRet = FALSE;
 386     BYTE        cByte;
 387
 388     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 389     rStm.Seek( nStmPos );
 390
 391     rStm >> n32;
 392     if ( n32 == 0x38464947 )
 393     {
 394         rStm >> n16;
 395         if ( ( n16 == 0x6137 ) || ( n16 == 0x6139 ) )
 396         {
 397             nFormat = GFF_GIF;
 398             bRet = TRUE;
 399
 400             if ( bExtendedInfo )
 401             {
 402                 UINT16 nTemp16;
 403
 404                 // PixelBreite auslesen
 405                 rStm >> nTemp16;
 406                 aPixSize.Width() = nTemp16;
 407
 408                 // PixelHoehe auslesen
 409                 rStm >> nTemp16;
 410                 aPixSize.Height() = nTemp16;
 411
 412                 // Bits/Pixel auslesen
 413                 rStm >> cByte;
 414                 nBitsPerPixel = ( ( cByte & 112 ) >> 4 ) + 1;
 415             }
 416         }
 417     }
 418
 419     return bRet;
 420 }
 421
 422
 423 /*************************************************************************
 424 |*
 425 |*
 426 |*
 427 \************************************************************************/
 428
 429 BOOL GraphicDescriptor::ImpDetectJPG( SvStream& rStm,  BOOL bExtendedInfo )
 430 {
 431     UINT32      nTemp32;
 432     BOOL        bRet = FALSE;
 433     BYTE        cByte = 0;
 434     BOOL        bM_COM;
 435
 436     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 437     rStm.Seek( nStmPos );
 438
 439     rStm >> nTemp32;
 440
 441     // compare upper 28 bits
 442     if( 0xffd8ff00 == ( nTemp32 & 0xffffff00 ) )
 443     {
 444         nFormat = GFF_JPG;
 445         return TRUE;
 446     }
 447
 448     bM_COM = ( nTemp32 == 0xffd8fffe );
 449     if ( ( nTemp32 == 0xffd8ffe0 ) || bM_COM )
 450     {
 451         if( !bM_COM )
 452         {
 453             rStm.SeekRel( 2 );
 454             rStm >> nTemp32;
 455         }
 456
 457         if( bM_COM || ( nTemp32 == 0x4a464946 ) )
 458         {
 459             nFormat = GFF_JPG;
 460             bRet = TRUE;
 461
 462             if( bExtendedInfo )
 463             {
 464                 MapMode aMap;
 465                 UINT16  nTemp16;
 466                 ULONG   nCount = 9;
 467                 ULONG   nMax;
 468                 ULONG   nResX;
 469                 ULONG   nResY;
 470                 BYTE    cUnit;
 471
 472                 // Groesse des verbleibenden Puffers ermitteln
 473                 if ( bLinked )
 474                     nMax = ( (SvMemoryStream&) rStm ).GetSize() - 16;
 475                 else
 476                     nMax = DATA_SIZE - 16;
 477
 478                 // max. 8K
 479                 nMax = Min( nMax, (ULONG) 8192 );
 480
 481                 // Res-Unit ermitteln
 482                 rStm.SeekRel( 3 );
 483                 rStm >> cUnit;
 484
 485                 // ResX ermitteln
 486                 rStm >> nTemp16;
 487                 nResX = nTemp16;
 488
 489                 // ResY ermitteln
 490                 rStm >> nTemp16;
 491                 nResY = nTemp16;
 492
 493                 // SOF0/1-Marker finden, aber dabei
 494                 // nicht mehr als DATA_SIZE Pixel lesen, falls
 495                 // kein WideSearch
 496                 do
 497                 {
 498                     while ( ( cByte != 0xff ) &&
 499                             ( bWideSearch || ( nCount++ < nMax ) ) )
 500                     {
 501                         rStm >> cByte;
 502                     }
 503
 504                     while ( ( cByte == 0xff ) &&
 505                             ( bWideSearch || ( nCount++ < nMax ) ) )
 506                     {
 507                         rStm >> cByte;
 508                     }
 509                 }
 510                 while ( ( cByte != 0xc0 ) &&
 511                         ( cByte != 0xc1 ) &&
 512                         ( bWideSearch || ( nCount < nMax ) ) );
 513
 514                 // wir haben den SOF0/1-Marker
 515                 if ( ( cByte == 0xc0 ) || ( cByte == 0xc1 ) )
 516                 {
 517                     // Hoehe einlesen
 518                     rStm.SeekRel( 3 );
 519                     rStm >> nTemp16;
 520                     aPixSize.Height() = nTemp16;
 521
 522                     // Breite einlesen
 523                     rStm >> nTemp16;
 524                     aPixSize.Width() = nTemp16;
 525
 526                     // Bit/Pixel einlesen
 527                     rStm >> cByte;
 528                     nBitsPerPixel = ( cByte == 3 ? 24 : cByte == 1 ? 8 : 0 );
 529
 530                     // logische Groesse setzen
 531                     if ( cUnit && nResX && nResY )
 532                     {
 533                         aMap.SetMapUnit( cUnit == 1 ? MAP_INCH : MAP_CM );
 534                         aMap.SetScaleX( Fraction( 1, nResX ) );
 535                         aMap.SetScaleY( Fraction( 1, nResY ) );
 536                         aLogSize = OutputDevice::LogicToLogic( aPixSize, aMap,
 537                                                                MapMode( MAP_100TH_MM ) );
 538                     }
 539
 540                     // Planes immer 1
 541                     nPlanes = 1;
 542                 }
 543             }
 544         }
 545     }
 546
 547     return bRet;
 548 }
 549
 550
 551 /*************************************************************************
 552 |*
 553 |*
 554 |*
 555 \************************************************************************/
 556
 557 BOOL GraphicDescriptor::ImpDetectPCD( SvStream& rStm, BOOL )
 558 {
 559     BOOL        bRet = FALSE;
 560
 561     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 562     rStm.Seek( nStmPos );
 563
 564     if ( bWideSearch )
 565     {
 566         UINT32  nTemp32;
 567         UINT16  nTemp16;
 568         BYTE    cByte;
 569
 570         rStm.SeekRel( 2048 );
 571         rStm >> nTemp32;
 572         rStm >> nTemp16;
 573         rStm >> cByte;
 574
 575         if ( ( nTemp32 == 0x5f444350 ) &&
 576              ( nTemp16 == 0x5049 ) &&
 577              ( cByte == 0x49 ) )
 578         {
 579             nFormat = GFF_PCD;
 580             bRet = TRUE;
 581         }
 582     }
 583     else
 584     {
 585         bRet = aPathExt.CompareToAscii( "pcd", 3 ) == COMPARE_EQUAL;
 586         if ( bRet )
 587         {
 588             nFormat = GFF_PCD;
 589         }
 590     }
 591
 592     return bRet;
 593 }
 594
 595
 596 /*************************************************************************
 597 |*
 598 |*
 599 |*
 600 \************************************************************************/
 601
 602 BOOL GraphicDescriptor::ImpDetectPCX( SvStream& rStm, BOOL bExtendedInfo )
 603 {
 604     // ! Because 0x0a can be interpreted as LF too ...
 605     // we cant be shure that this special sign represent a PCX file only.
 606     // Every Ascii file is possible here :-(
 607     // We must detect the whole header.
 608     bExtendedInfo = TRUE;
 609
 610     BOOL        bRet = FALSE;
 611     BYTE        cByte;
 612
 613     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 614     rStm.Seek( nStmPos );
 615
 616     rStm >> cByte;
 617     if ( cByte == 0x0a )
 618     {
 619         nFormat = GFF_PCX;
 620         bRet = TRUE;
 621
 622         if ( bExtendedInfo )
 623         {
 624             UINT16      nTemp16;
 625             USHORT      nXmin;
 626             USHORT      nXmax;
 627             USHORT      nYmin;
 628             USHORT      nYmax;
 629             USHORT      nDPIx;
 630             USHORT      nDPIy;
 631
 632
 633             rStm.SeekRel( 1 );
 634
 635             // Kompression lesen
 636             rStm >> cByte;
 637             bCompressed = ( cByte > 0 );
 638
 639             bRet = (cByte==0 || cByte ==1);
 640
 641             // Bits/Pixel lesen
 642             rStm >> cByte;
 643             nBitsPerPixel = cByte;
 644
 645             // Bildabmessungen
 646             rStm >> nTemp16;
 647             nXmin = nTemp16;
 648             rStm >> nTemp16;
 649             nYmin = nTemp16;
 650             rStm >> nTemp16;
 651             nXmax = nTemp16;
 652             rStm >> nTemp16;
 653             nYmax = nTemp16;
 654
 655             aPixSize.Width() = nXmax - nXmin + 1;
 656             aPixSize.Height() = nYmax - nYmin + 1;
 657
 658             // Aufloesung
 659             rStm >> nTemp16;
 660             nDPIx = nTemp16;
 661             rStm >> nTemp16;
 662             nDPIy = nTemp16;
 663
 664             // logische Groesse setzen
 665             MapMode     aMap( MAP_INCH, Point(),
 666                           Fraction( 1, nDPIx ), Fraction( 1, nDPIy ) );
 667             aLogSize = OutputDevice::LogicToLogic( aPixSize, aMap,
 668                                                    MapMode( MAP_100TH_MM ) );
 669
 670
 671             // Anzahl Farbebenen
 672             rStm.SeekRel( 49 );
 673             rStm >> cByte;
 674             nPlanes = cByte;
 675
 676             bRet = (nPlanes<=4);
 677         }
 678     }
 679
 680     return bRet;
 681 }
 682
 683
 684 /*************************************************************************
 685 |*
 686 |*
 687 |*
 688 \************************************************************************/
 689
 690 BOOL GraphicDescriptor::ImpDetectPNG( SvStream& rStm, BOOL bExtendedInfo )
 691 {
 692     UINT32      nTemp32;
 693     BOOL        bRet = FALSE;
 694
 695     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 696     rStm.Seek( nStmPos );
 697
 698     rStm >> nTemp32;
 699     if ( nTemp32 == 0x89504e47 )
 700     {
 701         rStm >> nTemp32;
 702         if ( nTemp32 == 0x0d0a1a0a )
 703         {
 704             nFormat = GFF_PNG;
 705             bRet = TRUE;
 706
 707             if ( bExtendedInfo )
 708             {
 709                 BYTE cByte;
 710
 711                 // IHDR-Chunk
 712                 rStm.SeekRel( 8 );
 713
 714                 // Breite einlesen
 715                 rStm >> nTemp32;
 716                 aPixSize.Width() = nTemp32;
 717
 718                 // Hoehe einlesen
 719                 rStm >> nTemp32;
 720                 aPixSize.Height() = nTemp32;
 721
 722                 // Bits/Pixel einlesen
 723                 rStm >> cByte;
 724                 nBitsPerPixel = cByte;
 725
 726                 // Planes immer 1;
 727                 // Kompression immer
 728                 nPlanes = 1;
 729                 bCompressed = TRUE;
 730
 731                 if ( bWideSearch )
 732                 {
 733                     UINT32      nLen32;
 734
 735                     rStm.SeekRel( 8 );
 736
 737                     // so lange ueberlesen, bis wir den pHYs-Chunk haben oder
 738                     // den Anfang der Bilddaten
 739                     rStm >> nLen32;
 740                     rStm >> nTemp32;
 741                     while( ( nTemp32 != 0x70485973 ) && ( nTemp32 != 0x49444154 ) )
 742                     {
 743                         rStm.SeekRel( 4 + nLen32 );
 744                         rStm >> nLen32;
 745                         rStm >> nTemp32;
 746                     }
 747
 748                     if ( nTemp32 == 0x70485973 )
 749                     {
 750                         ULONG   nXRes;
 751                         ULONG   nYRes;
 752
 753                         // horizontale Aufloesung
 754                         rStm >> nTemp32;
 755                         nXRes = nTemp32;
 756
 757                         // vertikale Aufloesung
 758                         rStm >> nTemp32;
 759                         nYRes = nTemp32;
 760
 761                         // Unit einlesen
 762                         rStm >> cByte;
 763
 764                         if ( cByte )
 765                         {
 766                             if ( nXRes )
 767                                 aLogSize.Width() = ( aPixSize.Width() * 100000 ) /
 768                                                    nTemp32;
 769
 770                             if ( nYRes )
 771                                 aLogSize.Height() = ( aPixSize.Height() * 100000 ) /
 772                                                     nTemp32;
 773                         }
 774                     }
 775                 }
 776             }
 777         }
 778     }
 779
 780     return bRet;
 781 }
 782
 783
 784 /*************************************************************************
 785 |*
 786 |*
 787 |*
 788 \************************************************************************/
 789
 790 BOOL GraphicDescriptor::ImpDetectTIF( SvStream& rStm, BOOL bExtendedInfo )
 791 {
 792     BOOL        bDetectOk = FALSE;
 793     BOOL        bRet = FALSE;
 794     BYTE        cByte1;
 795     BYTE        cByte2;
 796
 797     rStm.Seek( nStmPos );
 798     rStm >> cByte1;
 799     rStm >> cByte2;
 800     if ( cByte1 == cByte2 )
 801     {
 802         if ( cByte1 == 0x49 )
 803         {
 804             rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 805             bDetectOk = TRUE;
 806         }
 807         else if ( cByte1 == 0x4d )
 808         {
 809             rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 810             bDetectOk = TRUE;
 811         }
 812
 813         if ( bDetectOk )
 814         {
 815             UINT16      nTemp16;
 816
 817             rStm >> nTemp16;
 818             if ( nTemp16 == 0x2a )
 819             {
 820                 nFormat = GFF_TIF;
 821                 bRet = TRUE;
 822
 823                 if ( bExtendedInfo )
 824                 {
 825                     ULONG       nCount;
 826                     ULONG       nMax = DATA_SIZE - 48;
 827                     UINT32      nTemp32;
 828                     BOOL        bOk = FALSE;
 829
 830                     // Offset des ersten IFD einlesen
 831                     rStm >> nTemp32;
 832                     rStm.SeekRel( ( nCount = ( nTemp32 + 2 ) ) - 0x08 );
 833
 834                     if ( bWideSearch || ( nCount < nMax ) )
 835                     {
 836                         // Tag's lesen, bis wir auf Tag256 ( Width ) treffen
 837                         // nicht mehr Bytes als DATA_SIZE lesen
 838                         rStm >> nTemp16;
 839                         while ( nTemp16 != 256 )
 840                         {
 841                             bOk = bWideSearch || ( nCount < nMax );
 842                             if ( !bOk )
 843                             {
 844                                 break;
 845                             }
 846                             rStm.SeekRel( 10 );
 847                             rStm >> nTemp16;
 848                             nCount += 12;
 849                         }
 850
 851                         if ( bOk )
 852                         {
 853                             // Breite lesen
 854                             rStm >> nTemp16;
 855                             rStm.SeekRel( 4 );
 856                             if ( nTemp16 == 3 )
 857                             {
 858                                 rStm >> nTemp16;
 859                                 aPixSize.Width() = nTemp16;
 860                                 rStm.SeekRel( 2 );
 861                             }
 862                             else
 863                             {
 864                                 rStm >> nTemp32;
 865                                 aPixSize.Width() = nTemp32;
 866                             }
 867                             nCount += 12;
 868
 869                             // Hoehe lesen
 870                             rStm.SeekRel( 2 );
 871                             rStm >> nTemp16;
 872                             rStm.SeekRel( 4 );
 873                             if ( nTemp16 == 3 )
 874                             {
 875                                 rStm >> nTemp16;
 876                                 aPixSize.Height() = nTemp16;
 877                                 rStm.SeekRel( 2 );
 878                             }
 879                             else
 880                             {
 881                                 rStm >> nTemp32;
 882                                 aPixSize.Height() = nTemp32;
 883                             }
 884                             nCount += 12;
 885
 886                             // ggf. Bits/Pixel lesen
 887                             rStm >> nTemp16;
 888                             if ( nTemp16 == 258 )
 889                             {
 890                                 rStm.SeekRel( 6 );
 891                                 rStm >> nTemp16;
 892                                 nBitsPerPixel = nTemp16;
 893                                 rStm.SeekRel( 2 );
 894                                 nCount += 12;
 895                             }
 896                             else
 897                                 rStm.SeekRel( -2 );
 898
 899                             // ggf. Compression lesen
 900                             rStm >> nTemp16;
 901                             if ( nTemp16 == 259 )
 902                             {
 903                                 rStm.SeekRel( 6 );
 904                                 rStm >> nTemp16;
 905                                 bCompressed = ( nTemp16 > 1 );
 906                                 rStm.SeekRel( 2 );
 907                                 nCount += 12;
 908                             }
 909                             else
 910                                 rStm.SeekRel( -2 );
 911                         }
 912                     }
 913                 }
 914             }
 915         }
 916     }
 917
 918     return bRet;
 919 }
 920
 921
 922 /*************************************************************************
 923 |*
 924 |*
 925 |*
 926 \************************************************************************/
 927
 928 BOOL GraphicDescriptor::ImpDetectXBM( SvStream&, BOOL )
 929 {
 930     BOOL bRet = aPathExt.CompareToAscii( "xbm", 3 ) == COMPARE_EQUAL;
 931     if (bRet)
 932         nFormat = GFF_XBM;
 933
 934     return bRet;
 935 }
 936
 937
 938 /*************************************************************************
 939 |*
 940 |*
 941 |*
 942 \************************************************************************/
 943
 944 BOOL GraphicDescriptor::ImpDetectXPM( SvStream&, BOOL )
 945 {
 946     BOOL bRet = aPathExt.CompareToAscii( "xpm", 3 ) == COMPARE_EQUAL;
 947     if (bRet)
 948         nFormat = GFF_XPM;
 949
 950     return bRet;
 951 }
 952
 953 /*************************************************************************
 954 |*
 955 |*
 956 |*
 957 \************************************************************************/
 958
 959 BOOL GraphicDescriptor::ImpDetectPBM( SvStream& rStm, BOOL )
 960 {
 961     BOOL bRet = FALSE;
 962
 963     // erst auf Datei Extension pruefen, da diese aussagekraeftiger ist
 964     // als die 2 ID Bytes
 965
 966     if ( aPathExt.CompareToAscii( "pbm", 3 ) == COMPARE_EQUAL )
 967         bRet = TRUE;
 968     else
 969     {
 970         BYTE    nFirst, nSecond;
 971         rStm.Seek( nStmPos );
 972         rStm >> nFirst >> nSecond;
 973         if ( nFirst == 'P' && ( ( nSecond == '1' ) || ( nSecond == '4' ) ) )
 974             bRet = TRUE;
 975     }
 976
 977     if ( bRet )
 978         nFormat = GFF_PBM;
 979
 980     return bRet;
 981 }
 982
 983 /*************************************************************************
 984 |*
 985 |*
 986 |*
 987 \************************************************************************/
 988
 989 BOOL GraphicDescriptor::ImpDetectPGM( SvStream& rStm, BOOL )
 990 {
 991     BOOL bRet = FALSE;
 992
 993     if ( aPathExt.CompareToAscii( "pgm", 3 ) == COMPARE_EQUAL )
 994         bRet = TRUE;
 995     else
 996     {
 997         BYTE    nFirst, nSecond;
 998         rStm.Seek( nStmPos );
 999         rStm >> nFirst >> nSecond;
1000         if ( nFirst == 'P' && ( ( nSecond == '2' ) || ( nSecond == '5' ) ) )
1001             bRet = TRUE;
1002     }
1003
1004     if ( bRet )
1005         nFormat = GFF_PGM;
1006
1007     return bRet;
1008 }
1009
1010 /*************************************************************************
1011 |*
1012 |*
1013 |*
1014 \************************************************************************/
1015
1016 BOOL GraphicDescriptor::ImpDetectPPM( SvStream& rStm, BOOL )
1017 {
1018     BOOL bRet = FALSE;
1019
1020     if ( aPathExt.CompareToAscii( "ppm", 3 ) == COMPARE_EQUAL )
1021         bRet = TRUE;
1022     else
1023     {
1024         BYTE    nFirst, nSecond;
1025         rStm.Seek( nStmPos );
1026         rStm >> nFirst >> nSecond;
1027         if ( nFirst == 'P' && ( ( nSecond == '3' ) || ( nSecond == '6' ) ) )
1028             bRet = TRUE;
1029     }
1030
1031     if ( bRet )
1032         nFormat = GFF_PPM;
1033
1034     return bRet;
1035 }
1036
1037 /*************************************************************************
1038 |*
1039 |*
1040 |*
1041 \************************************************************************/
1042
1043 BOOL GraphicDescriptor::ImpDetectRAS( SvStream& rStm, BOOL )
1044 {
1045     UINT32 nMagicNumber;
1046     rStm.Seek( nStmPos );
1047     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
1048     rStm >> nMagicNumber;
1049     if ( nMagicNumber == 0x59a66a95 )
1050     {
1051         nFormat = GFF_RAS;
1052         return TRUE;
1053     }
1054     else
1055         return FALSE;
1056 }
1057
1058 /*************************************************************************
1059 |*
1060 |*
1061 |*
1062 \************************************************************************/
1063
1064 BOOL GraphicDescriptor::ImpDetectTGA( SvStream&, BOOL )
1065 {
1066     BOOL bRet = aPathExt.CompareToAscii( "tga", 3 ) == COMPARE_EQUAL;
1067     if (bRet)
1068         nFormat = GFF_TGA;
1069
1070     return bRet;
1071 }
1072
1073 /*************************************************************************
1074 |*
1075 |*
1076 |*
1077 \************************************************************************/
1078
1079 BOOL GraphicDescriptor::ImpDetectPSD( SvStream& rStm, BOOL bExtendedInfo )
1080 {
1081     BOOL bRet = FALSE;
1082
1083     UINT32      nMagicNumber;
1084     rStm.Seek( nStmPos );
1085     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
1086     rStm >> nMagicNumber;
1087     if ( nMagicNumber == 0x38425053 )
1088     {
1089         UINT16 nVersion;
1090         rStm >> nVersion;
1091         if ( nVersion == 1 )
1092         {
1093             bRet = TRUE;
1094             if ( bExtendedInfo )
1095             {
1096                 UINT16 nChannels;
1097                 UINT32 nRows;
1098                 UINT32 nColumns;
1099                 UINT16 nDepth;
1100                 UINT16 nMode;
1101                 rStm.SeekRel( 6 );      // Pad
1102                 rStm >> nChannels >> nRows >> nColumns >> nDepth >> nMode;
1103                 if ( ( nDepth == 1 ) || ( nDepth == 8 ) || ( nDepth == 16 ) )
1104                 {
1105                     nBitsPerPixel = ( nDepth == 16 ) ? 8 : nDepth;
1106                     switch ( nChannels )
1107                     {
1108                         case 4 :
1109                         case 3 :
1110                             nBitsPerPixel = 24;
1111                         case 2 :
1112                         case 1 :
1113                             aPixSize.Width() = nColumns;
1114                             aPixSize.Height() = nRows;
1115                         break;
1116                         default:
1117                             bRet = FALSE;
1118                     }
1119                 }
1120                 else
1121                     bRet = FALSE;
1122             }
1123         }
1124     }
1125
1126     if ( bRet )
1127         nFormat = GFF_PSD;
1128     return bRet;
1129 }
1130
1131 /*************************************************************************
1132 |*
1133 |*
1134 |*
1135 \************************************************************************/
1136
1137 BOOL GraphicDescriptor::ImpDetectEPS( SvStream& rStm, BOOL )
1138 {
1139     // es wird die EPS mit Vorschaubild Variante und die Extensionuebereinstimmung
1140     // geprueft
1141
1142     sal_uInt32  nFirstLong;
1143     sal_uInt8   nFirstBytes[20];
1144
1145     rStm.Seek( nStmPos );
1146     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
1147     rStm >> nFirstLong;
1148     rStm.SeekRel( -4 );
1149     rStm.Read( &nFirstBytes, 20 );
1150
1151     if ( ( nFirstLong == 0xC5D0D3C6 ) || ( aPathExt.CompareToAscii( "eps", 3 ) == COMPARE_EQUAL ) ||
1152         ( ImplSearchEntry( nFirstBytes, (sal_uInt8*)"%!PS-Adobe", 10, 10 )
1153             && ImplSearchEntry( &nFirstBytes[15], (sal_uInt8*)"EPS", 3, 3 ) ) )
1154     {
1155         nFormat = GFF_EPS;
1156         return TRUE;
1157     }
1158     else
1159         return FALSE;
1160 }
1161
1162 /*************************************************************************
1163 |*
1164 |*
1165 |*
1166 \************************************************************************/
1167
1168 BOOL GraphicDescriptor::ImpDetectDXF( SvStream&, BOOL )
1169 {
1170     BOOL bRet = aPathExt.CompareToAscii( "dxf", 3 ) == COMPARE_EQUAL;
1171     if (bRet)
1172         nFormat = GFF_DXF;
1173
1174     return bRet;
1175 }
1176
1177 /*************************************************************************
1178 |*
1179 |*
1180 |*
1181 \************************************************************************/
1182
1183 BOOL GraphicDescriptor::ImpDetectMET( SvStream&, BOOL )
1184 {
1185     BOOL bRet = aPathExt.CompareToAscii( "met", 3 ) == COMPARE_EQUAL;
1186     if (bRet)
1187         nFormat = GFF_MET;
1188
1189     return bRet;
1190 }
1191
1192
1193 /*************************************************************************
1194 |*
1195 |*
1196 |*
1197 \************************************************************************/
1198
1199 BOOL GraphicDescriptor::ImpDetectPCT( SvStream& rStm, BOOL )
1200 {
1201     BOOL bRet = aPathExt.CompareToAscii( "pct", 3 ) == COMPARE_EQUAL;
1202     if (bRet)
1203         nFormat = GFF_PCT;
1204     else
1205     {
1206         BYTE sBuf[4];
1207
1208         rStm.Seek( nStmPos + 522 );
1209         rStm.Read( sBuf, 3 );
1210
1211         if( !rStm.GetError() )
1212         {
1213             if ( ( sBuf[0] == 0x00 ) && ( sBuf[1] == 0x11 ) &&
1214                  ( ( sBuf[2] == 0x01 ) || ( sBuf[2] == 0x02 ) ) )
1215             {
1216                 bRet = TRUE;
1217                 nFormat = GFF_PCT;
1218             }
1219         }
1220     }
1221
1222     return bRet;
1223 }
1224
1225
1226 /*************************************************************************
1227 |*
1228 |*
1229 |*
1230 \************************************************************************/
1231
1232 BOOL GraphicDescriptor::ImpDetectSGF( SvStream& rStm, BOOL )
1233 {
1234     BOOL bRet = FALSE;
1235
1236     if( aPathExt.CompareToAscii( "sgf", 3 ) == COMPARE_EQUAL )
1237         bRet = TRUE;
1238     else
1239     {
1240         BYTE nFirst, nSecond;
1241
1242         rStm.Seek( nStmPos );
1243         rStm >> nFirst >> nSecond;
1244
1245         if( nFirst == 'J' && nSecond == 'J' )
1246             bRet = TRUE;
1247     }
1248
1249     if( bRet )
1250         nFormat = GFF_SGF;
1251
1252     return bRet;
1253 }
1254
1255
1256 /*************************************************************************
1257 |*
1258 |*
1259 |*
1260 \************************************************************************/
1261
1262 BOOL GraphicDescriptor::ImpDetectSGV( SvStream&, BOOL )
1263 {
1264     BOOL bRet = aPathExt.CompareToAscii( "sgv", 3 ) == COMPARE_EQUAL;
1265     if (bRet)
1266         nFormat = GFF_SGV;
1267
1268     return bRet;
1269 }
1270
1271
1272 /*************************************************************************
1273 |*
1274 |*
1275 |*
1276 \************************************************************************/
1277
1278 BOOL GraphicDescriptor::ImpDetectSVM( SvStream& rStm, BOOL bExtendedInfo )
1279 {
1280     UINT32      n32;
1281     BOOL        bRet = FALSE;
1282     BYTE        cByte;
1283
1284     rStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
1285     rStm.Seek( nStmPos );
1286
1287     rStm >> n32;
1288     if ( n32 == 0x44475653 )
1289     {
1290         rStm >> cByte;
1291         if ( cByte == 0x49 )
1292         {
1293             nFormat = GFF_SVM;
1294             bRet = TRUE;
1295
1296             if ( bExtendedInfo )
1297             {
1298                 UINT32  nTemp32;
1299                 UINT16  nTemp16;
1300
1301                 rStm.SeekRel( 0x04 );
1302
1303                 // Breite auslesen
1304                 rStm >> nTemp32;
1305                 aLogSize.Width() = nTemp32;
1306
1307                 // Hoehe auslesen
1308                 rStm >> nTemp32;
1309                 aLogSize.Height() = nTemp32;
1310
1311                 // Map-Unit auslesen und PrefSize ermitteln
1312                 rStm >> nTemp16;
1313                 aLogSize = OutputDevice::LogicToLogic( aLogSize,
1314                                                        MapMode( (MapUnit) nTemp16 ),
1315                                                        MapMode( MAP_100TH_MM ) );
1316             }
1317         }
1318     }
1319     else
1320     {
1321         rStm.SeekRel( -4L );
1322         rStm >> n32;
1323
1324         if( n32 == 0x4D4C4356 )
1325         {
1326             UINT16 nTmp16;
1327
1328             rStm >> nTmp16;
1329
1330             if( nTmp16 == 0x4654 )
1331             {
1332                 nFormat = GFF_SVM;
1333                 bRet = TRUE;
1334
1335                 if( bExtendedInfo )
1336                 {
1337                     MapMode aMapMode;
1338
1339                     rStm.SeekRel( 0x06 );
1340                     rStm >> aMapMode;
1341                     rStm >> aLogSize;
1342                     aLogSize = OutputDevice::LogicToLogic( aLogSize, aMapMode, MapMode( MAP_100TH_MM ) );
1343                 }
1344             }
1345         }
1346     }
1347
1348     return bRet;
1349 }
1350
1351
1352 /*************************************************************************
1353 |*
1354 |*
1355 |*
1356 \************************************************************************/
1357
1358 BOOL GraphicDescriptor::ImpDetectWMF( SvStream&, BOOL )
1359 {
1360     BOOL bRet = aPathExt.CompareToAscii( "wmf",3 ) == COMPARE_EQUAL;
1361     if (bRet)
1362         nFormat = GFF_WMF;
1363
1364     return bRet;
1365 }
1366
1367 /*************************************************************************
1368 |*
1369 |*
1370 |*
1371 \************************************************************************/
1372
1373 BOOL GraphicDescriptor::ImpDetectEMF( SvStream&, BOOL )
1374 {
1375     BOOL bRet = aPathExt.CompareToAscii( "emf", 3 ) == COMPARE_EQUAL;
1376     if (bRet)
1377         nFormat = GFF_EMF;
1378
1379     return bRet;
1380 }
1381
1382 /*************************************************************************
1383 |*
1384 |*
1385 |*
1386 \************************************************************************/
1387
1388 String GraphicDescriptor::GetImportFormatShortName( sal_uInt16 nFormat )
1389 {
1390     ByteString                  aKeyName;
1391
1392     switch( nFormat )
1393     {
1394         case( GFF_BMP ) :       aKeyName = "bmp";       break;
1395         case( GFF_GIF ) :       aKeyName = "gif";       break;
1396         case( GFF_JPG ) :       aKeyName = "jpg";       break;
1397         case( GFF_PCD ) :       aKeyName = "pcd";       break;
1398         case( GFF_PCX ) :       aKeyName = "pcx";       break;
1399         case( GFF_PNG ) :       aKeyName = "png";       break;
1400         case( GFF_XBM ) :       aKeyName = "xbm";       break;
1401         case( GFF_XPM ) :       aKeyName = "xpm";       break;
1402         case( GFF_PBM ) :       aKeyName = "pbm";       break;
1403         case( GFF_PGM ) :       aKeyName = "pgm";       break;
1404         case( GFF_PPM ) :       aKeyName = "ppm";       break;
1405         case( GFF_RAS ) :       aKeyName = "ras";       break;
1406         case( GFF_TGA ) :       aKeyName = "tga";       break;
1407         case( GFF_PSD ) :       aKeyName = "psd";       break;
1408         case( GFF_EPS ) :       aKeyName = "eps";       break;
1409         case( GFF_TIF ) :       aKeyName = "tif";       break;
1410         case( GFF_DXF ) :       aKeyName = "dxf";       break;
1411         case( GFF_MET ) :       aKeyName = "met";       break;
1412         case( GFF_PCT ) :       aKeyName = "pct";       break;
1413         case( GFF_SGF ) :       aKeyName = "sgf";       break;
1414         case( GFF_SGV ) :       aKeyName = "sgv";       break;
1415         case( GFF_SVM ) :       aKeyName = "svm";       break;
1416         case( GFF_WMF ) :       aKeyName = "wmf";       break;
1417         case( GFF_EMF ) :       aKeyName = "emf";       break;
1418     }
1419
1420     return String( aKeyName, RTL_TEXTENCODING_ASCII_US );
1421 }