goodies/source/filter.vcl/iras/iras.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: iras.cxx,v $
  10  * $Revision: 1.10 $
  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_goodies.hxx"
  33
  34 #include <vcl/graph.hxx>
  35 #include <vcl/bmpacc.hxx>
  36 #include <svtools/fltcall.hxx>
  37
  38 #define RAS_TYPE_OLD                    0x00000000              // supported formats by this filter
  39 #define RAS_TYPE_STANDARD               0x00000001
  40 #define RAS_TYPE_BYTE_ENCODED   0x00000002
  41 #define RAS_TYPE_RGB_FORMAT             0x00000003
  42
  43 #define RAS_COLOR_NO_MAP                0x00000000
  44 #define RAS_COLOR_RGB_MAP               0x00000001
  45 #define RAS_COLOR_RAW_MAP               0x00000002
  46
  47 #define SUNRASTER_MAGICNUMBER   0x59a66a95
  48
  49 //============================ RASReader ==================================
  50
  51 class RASReader {
  52
  53 private:
  54
  55     SvStream*                   mpRAS;                                  // Die einzulesende RAS-Datei
  56
  57     BOOL                                mbStatus;
  58     Bitmap                              maBmp;
  59     BitmapWriteAccess*  mpAcc;
  60     sal_uInt32                  mnWidth, mnHeight;              // Bildausmass in Pixeln
  61     USHORT                              mnDstBitsPerPix;
  62     USHORT                              mnDstColors;
  63     sal_uInt32                  mnDepth, mnImageDatSize, mnType;
  64     sal_uInt32                  mnColorMapType, mnColorMapSize;
  65     BYTE                                mnRepCount, mnRepVal;   // RLE Decoding
  66     BOOL                                mbPalette;
  67
  68     BOOL                                ImplReadBody();
  69     BOOL                                ImplReadHeader();
  70     BYTE                                ImplGetByte();
  71
  72 public:
  73                         RASReader();
  74                         ~RASReader();
  75     BOOL                                ReadRAS( SvStream & rRAS, Graphic & rGraphic );
  76 };
  77
  78 //=================== Methoden von RASReader ==============================
  79
  80 RASReader::RASReader() :
  81     mbStatus    ( TRUE ),
  82     mpAcc               ( NULL ),
  83     mnRepCount  ( 0 ),
  84     mbPalette   ( FALSE )
  85 {
  86 }
  87
  88 RASReader::~RASReader()
  89 {
  90 }
  91
  92 //----------------------------------------------------------------------------
  93
  94 BOOL RASReader::ReadRAS( SvStream & rRAS, Graphic & rGraphic )
  95 {
  96     UINT32 nMagicNumber;
  97
  98     if ( rRAS.GetError() )
  99         return FALSE;
 100
 101     mpRAS = &rRAS;
 102     mpRAS->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 103     *mpRAS >> nMagicNumber;
 104     if ( nMagicNumber != SUNRASTER_MAGICNUMBER )
 105         return FALSE;
 106
 107     // Kopf einlesen:
 108
 109     if ( ( mbStatus = ImplReadHeader() ) == FALSE )
 110         return FALSE;
 111
 112     maBmp = Bitmap( Size( mnWidth, mnHeight ), mnDstBitsPerPix );
 113     if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == FALSE )
 114         return FALSE;
 115
 116     if ( mnDstBitsPerPix <= 8 )         // paletten bildchen
 117     {
 118         if ( mnColorMapType == RAS_COLOR_RAW_MAP )              // RAW Colormap wird geskipped
 119         {
 120             ULONG nCurPos = mpRAS->Tell();
 121             mpRAS->Seek( nCurPos + mnColorMapSize );
 122         }
 123         else if ( mnColorMapType == RAS_COLOR_RGB_MAP ) // RGB koennen wir auslesen
 124         {
 125             mnDstColors = (USHORT)( mnColorMapSize / 3 );
 126
 127             if ( ( 1 << mnDstBitsPerPix ) < mnDstColors )
 128                 return FALSE;
 129
 130             if ( ( mnDstColors >= 2 ) && ( ( mnColorMapSize % 3 ) == 0 ) )
 131             {
 132                 mpAcc->SetPaletteEntryCount( mnDstColors );
 133                 USHORT  i;
 134                 BYTE    nRed[256], nGreen[256], nBlue[256];
 135                 for ( i = 0; i < mnDstColors; i++ ) *mpRAS >> nRed[ i ];
 136                 for ( i = 0; i < mnDstColors; i++ ) *mpRAS >> nGreen[ i ];
 137                 for ( i = 0; i < mnDstColors; i++ ) *mpRAS >> nBlue[ i ];
 138                 for ( i = 0; i < mnDstColors; i++ )
 139                 {
 140                     mpAcc->SetPaletteColor( i, BitmapColor( nRed[ i ], nGreen[ i ], nBlue[ i ] ) );
 141                 }
 142                 mbPalette = TRUE;
 143             }
 144             else
 145                 return FALSE;
 146
 147         }
 148         else if ( mnColorMapType != RAS_COLOR_NO_MAP )  // alles andere ist kein standard
 149             return FALSE;
 150
 151         if ( !mbPalette )
 152         {
 153             mnDstColors = 1 << mnDstBitsPerPix;
 154             mpAcc->SetPaletteEntryCount( mnDstColors );
 155             for ( USHORT i = 0; i < mnDstColors; i++ )
 156             {
 157                 ULONG nCount = 255 - ( 255 * i / ( mnDstColors - 1 ) );
 158                 mpAcc->SetPaletteColor( i, BitmapColor( (BYTE)nCount, (BYTE)nCount, (BYTE)nCount ) );
 159             }
 160         }
 161     }
 162     else
 163     {
 164         if ( mnColorMapType != RAS_COLOR_NO_MAP )       // when graphic has more then 256 colors and a color map we skip
 165         {                                                                                       // the colormap
 166             ULONG nCurPos = mpRAS->Tell();
 167             mpRAS->Seek( nCurPos + mnColorMapSize );
 168         }
 169     }
 170
 171     // Bitmap-Daten einlesen
 172     mbStatus = ImplReadBody();
 173
 174     if ( mpAcc )
 175     {
 176         maBmp.ReleaseAccess( mpAcc ), mpAcc = NULL;
 177     }
 178     if ( mbStatus )
 179         rGraphic = maBmp;
 180
 181     return mbStatus;
 182 }
 183
 184 //----------------------------------------------------------------------------
 185
 186 BOOL RASReader::ImplReadHeader()
 187 {
 188     *mpRAS >> mnWidth >> mnHeight >> mnDepth >> mnImageDatSize >>
 189         mnType >> mnColorMapType >> mnColorMapSize;
 190
 191     if ( mnWidth == 0 || mnHeight == 0 )
 192         mbStatus = FALSE;
 193
 194     switch ( mnDepth )
 195     {
 196         case 24 :
 197         case  8 :
 198         case  1 :
 199             mnDstBitsPerPix = (USHORT)mnDepth;
 200             break;
 201         case 32 :
 202             mnDstBitsPerPix = 24;
 203             break;
 204
 205         default :
 206             mbStatus = FALSE;
 207     }
 208
 209     switch ( mnType )
 210     {
 211         case RAS_TYPE_OLD :
 212         case RAS_TYPE_STANDARD :
 213         case RAS_TYPE_RGB_FORMAT :
 214         case RAS_TYPE_BYTE_ENCODED :                    // this type will be supported later
 215             break;
 216
 217         default:
 218             mbStatus = FALSE;
 219     }
 220     return mbStatus;
 221 }
 222
 223 //----------------------------------------------------------------------------
 224
 225 BOOL RASReader::ImplReadBody()
 226 {
 227     ULONG       x, y;
 228     BYTE        nDat = 0;
 229     BYTE    nRed, nGreen, nBlue;
 230     switch ( mnDstBitsPerPix )
 231     {
 232         case 1 :
 233             for ( y = 0; y < mnHeight; y++ )
 234             {
 235                 for ( x = 0; x < mnWidth; x++ )
 236                 {
 237                     if (!(x & 7))
 238                         nDat = ImplGetByte();
 239                     mpAcc->SetPixel (
 240                         y, x,
 241                         sal::static_int_cast< BYTE >(
 242                             nDat >> ( ( x & 7 ) ^ 7 )) );
 243                 }
 244                 if (!( ( x - 1 ) & 0x8 ) ) ImplGetByte();               // WORD ALIGNMENT ???
 245             }
 246             break;
 247
 248         case 8 :
 249             for ( y = 0; y < mnHeight; y++ )
 250             {
 251                 for ( x = 0; x < mnWidth; x++ )
 252                 {
 253                     nDat = ImplGetByte();
 254                     mpAcc->SetPixel ( y, x, nDat );
 255                 }
 256                 if ( x & 1 ) ImplGetByte();                                             // WORD ALIGNMENT ???
 257             }
 258             break;
 259
 260         case 24 :
 261             switch ( mnDepth )
 262             {
 263
 264                 case 24 :
 265                     for ( y = 0; y < mnHeight; y++ )
 266                     {
 267                         for ( x = 0; x < mnWidth; x++ )
 268                         {
 269                             if ( mnType == RAS_TYPE_RGB_FORMAT )
 270                             {
 271                                 nRed = ImplGetByte();
 272                                 nGreen = ImplGetByte();
 273                                 nBlue = ImplGetByte();
 274                             }
 275                             else
 276                             {
 277                                 nBlue = ImplGetByte();
 278                                 nGreen = ImplGetByte();
 279                                 nRed = ImplGetByte();
 280                             }
 281                             mpAcc->SetPixel ( y, x, BitmapColor( nRed, nGreen, nBlue ) );
 282                         }
 283                         if ( x & 1 ) ImplGetByte();                                             // WORD ALIGNMENT ???
 284                     }
 285                     break;
 286
 287                 case 32 :
 288                     for ( y = 0; y < mnHeight; y++ )
 289                     {
 290                         for ( x = 0; x < mnWidth; x++ )
 291                         {
 292                             nDat = ImplGetByte();                               // pad byte > nil
 293                             if ( mnType == RAS_TYPE_RGB_FORMAT )
 294                             {
 295                                 nRed = ImplGetByte();
 296                                 nGreen = ImplGetByte();
 297                                 nBlue = ImplGetByte();
 298                             }
 299                             else
 300                             {
 301                                 nBlue = ImplGetByte();
 302                                 nGreen = ImplGetByte();
 303                                 nRed = ImplGetByte();
 304                             }
 305                             mpAcc->SetPixel ( y, x, BitmapColor( nRed, nGreen, nBlue ) );
 306                         }
 307                     }
 308                     break;
 309             }
 310             break;
 311
 312         default:
 313             mbStatus = FALSE;
 314             break;
 315     }
 316     return mbStatus;
 317 }
 318
 319 //----------------------------------------------------------------------------
 320
 321 BYTE RASReader::ImplGetByte()
 322 {
 323     BYTE nRetVal;
 324     if ( mnType != RAS_TYPE_BYTE_ENCODED )
 325     {
 326         *mpRAS >> nRetVal;
 327         return nRetVal;
 328     }
 329     else
 330     {
 331         if ( mnRepCount )
 332         {
 333             mnRepCount--;
 334             return mnRepVal;
 335         }
 336         else
 337         {
 338             *mpRAS >> nRetVal;
 339             if ( nRetVal != 0x80 )
 340                 return nRetVal;
 341             *mpRAS >> nRetVal;
 342             if ( nRetVal == 0 )
 343                 return 0x80;
 344             mnRepCount = nRetVal        ;
 345             *mpRAS >> mnRepVal;
 346             return mnRepVal;
 347         }
 348     }
 349 }
 350
 351 //================== GraphicImport - die exportierte Funktion ================
 352
 353 extern "C" BOOL __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, BOOL )
 354 {
 355     RASReader aRASReader;
 356
 357     return aRASReader.ReadRAS( rStream, rGraphic );
 358 }
 359
 360 //================== ein bischen Muell fuer Windows ==========================
 361 #ifndef GCC
 362 #endif
 363
 364 #ifdef WIN
 365
 366 static HINSTANCE hDLLInst = 0;      // HANDLE der DLL
 367
 368 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 369 {
 370 #ifndef WNT
 371     if ( nHeap )
 372         UnlockData( 0 );
 373 #endif
 374
 375     hDLLInst = hDLL;
 376
 377     return TRUE;
 378 }
 379
 380 extern "C" int CALLBACK WEP( int )
 381 {
 382     return 1;
 383 }
 384
 385 #endif
 386