goodies/source/filter.vcl/eras/eras.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: eras.cxx,v $
  10  * $Revision: 1.11.38.1 $
  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 #include <svtools/FilterConfigItem.hxx>
  38
  39 //============================ RASWriter ==================================
  40
  41 class RASWriter {
  42
  43 private:
  44
  45     SvStream*                   mpOStm;
  46     USHORT                              mpOStmOldModus;
  47
  48     BOOL                                mbStatus;
  49     BitmapReadAccess*   mpAcc;
  50
  51     ULONG                               mnWidth, mnHeight;
  52     USHORT                              mnColors, mnDepth;
  53
  54     ULONG                               mnRepCount;
  55     BYTE                                mnRepVal;
  56
  57     com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
  58
  59     void                                ImplCallback( ULONG nCurrentYPos );
  60     BOOL                                ImplWriteHeader();
  61     void                                ImplWritePalette();
  62     void                                ImplWriteBody();
  63     void                                ImplPutByte( BYTE );    // RLE decoding
  64
  65 public:
  66                         RASWriter();
  67                         ~RASWriter();
  68
  69     BOOL                                WriteRAS( const Graphic& rGraphic, SvStream& rRAS, FilterConfigItem* pFilterConfigItem );
  70 };
  71
  72 //=================== Methoden von RASWriter ==============================
  73
  74 RASWriter::RASWriter() :
  75     mbStatus    ( TRUE ),
  76     mpAcc               ( NULL ),
  77     mnRepCount  ( 0xffffffff )
  78 {
  79 }
  80
  81 // ------------------------------------------------------------------------
  82
  83 RASWriter::~RASWriter()
  84 {
  85 }
  86
  87 // ------------------------------------------------------------------------
  88
  89 void RASWriter::ImplCallback( ULONG nYPos )
  90 {
  91     if ( xStatusIndicator.is() )
  92         xStatusIndicator->setValue( (USHORT)( ( 100 * nYPos ) / mnHeight ) );
  93 }
  94
  95 //      ------------------------------------------------------------------------
  96
  97 BOOL RASWriter::WriteRAS( const Graphic& rGraphic, SvStream& rRAS, FilterConfigItem* pFilterConfigItem)
  98 {
  99     Bitmap      aBmp;
 100
 101     mpOStm = &rRAS;
 102
 103     if ( pFilterConfigItem )
 104     {
 105         xStatusIndicator = pFilterConfigItem->GetStatusIndicator();
 106         if ( xStatusIndicator.is() )
 107         {
 108             rtl::OUString aMsg;
 109             xStatusIndicator->start( aMsg, 100 );
 110         }
 111     }
 112
 113     BitmapEx    aBmpEx( rGraphic.GetBitmapEx() );
 114     aBmp = aBmpEx.GetBitmap();
 115
 116     if ( aBmp.GetBitCount() == 4 )
 117         aBmp.Convert( BMP_CONVERSION_8BIT_COLORS );
 118
 119     mnDepth = aBmp.GetBitCount();
 120
 121     // export code below only handles three discrete cases
 122     mnDepth = mnDepth <= 1 ? 1 : mnDepth <= 8 ? 8 : 24;
 123
 124     mpAcc = aBmp.AcquireReadAccess();
 125     if ( mpAcc )
 126     {
 127         mpOStmOldModus = mpOStm->GetNumberFormatInt();
 128         mpOStm->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 129
 130         if ( ImplWriteHeader() )
 131         {
 132             if ( mnDepth <= 8 )
 133                 ImplWritePalette();
 134             ImplWriteBody();
 135         }
 136         aBmp.ReleaseAccess( mpAcc );
 137     }
 138     else
 139         mbStatus = FALSE;
 140
 141     mpOStm->SetNumberFormatInt( mpOStmOldModus );
 142
 143     if ( xStatusIndicator.is() )
 144         xStatusIndicator->end();
 145
 146     return mbStatus;
 147 }
 148
 149 // ------------------------------------------------------------------------
 150
 151 BOOL RASWriter::ImplWriteHeader()
 152 {
 153     mnWidth = mpAcc->Width();
 154     mnHeight = mpAcc->Height();
 155     if ( mnDepth <= 8 )
 156     {
 157         mnColors = mpAcc->GetPaletteEntryCount();
 158         if (mnColors == 0)
 159             mbStatus = FALSE;
 160     }
 161         if ( mbStatus && mnWidth && mnHeight && mnDepth )
 162     {
 163         *mpOStm << (UINT32)0x59a66a95 << (UINT32)mnWidth << (UINT32)mnHeight
 164             << (UINT32)mnDepth
 165             << (UINT32)(( ( ( ( mnWidth * mnDepth ) + 15 ) >> 4 ) << 1 ) * mnHeight)
 166             << (UINT32)2;
 167
 168         if ( mnDepth > 8 )
 169             *mpOStm << (UINT32)0 << (UINT32)0;
 170         else
 171         {
 172
 173             *mpOStm << (UINT32)1 << (UINT32)( mnColors * 3 );
 174         }
 175     }
 176     else mbStatus = FALSE;
 177
 178     return mbStatus;
 179 }
 180
 181 // ------------------------------------------------------------------------
 182
 183 void RASWriter::ImplWritePalette()
 184 {
 185     USHORT i;
 186
 187     for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetRed() ) ;
 188     for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetGreen() ) ;
 189     for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetBlue() ) ;
 190 }
 191
 192 // ------------------------------------------------------------------------
 193
 194 void RASWriter::ImplWriteBody()
 195 {
 196     ULONG       x, y;
 197
 198     if ( mnDepth == 24 )
 199     {
 200         for ( y = 0; y < mnHeight; y++ )
 201         {
 202             ImplCallback( y );                                                          // processing output
 203             for ( x = 0; x < mnWidth; x++ )
 204             {
 205                 BitmapColor aColor( mpAcc->GetPixel( y, x ) );
 206                 ImplPutByte( aColor.GetBlue() );                        // Format ist BGR
 207                 ImplPutByte( aColor.GetGreen() );
 208                 ImplPutByte( aColor.GetRed() );
 209             }
 210             if ( x & 1 ) ImplPutByte( 0 );              // WORD ALIGNMENT ???
 211         }
 212     }
 213     else if ( mnDepth == 8 )
 214     {
 215         for ( y = 0; y < mnHeight; y++ )
 216         {
 217             ImplCallback( y );                                                          // processing output
 218             for ( x = 0; x < mnWidth; x++ )
 219             {
 220                 ImplPutByte ( mpAcc->GetPixel( y, x ) );
 221             }
 222             if ( x & 1 ) ImplPutByte( 0 );              // WORD ALIGNMENT ???
 223         }
 224     }
 225     else if ( mnDepth == 1 )
 226     {
 227         BYTE nDat = 0;
 228
 229         for ( y = 0; y < mnHeight; y++ )
 230         {
 231             ImplCallback( y );                                                          // processing output
 232             for ( x = 0; x < mnWidth; x++ )
 233             {
 234                 nDat = ( ( nDat << 1 ) | ( mpAcc->GetPixel ( y, x ) & 1 ) );
 235                 if ( ( x & 7 ) == 7 )
 236                     ImplPutByte( nDat );
 237             }
 238             if ( x & 7 )
 239                 ImplPutByte( sal::static_int_cast< BYTE >(nDat << ( ( ( x & 7 ) ^ 7 ) + 1)) );// write remaining bits
 240             if (!( ( x - 1 ) & 0x8 ) )
 241                 ImplPutByte( 0 );                               // WORD ALIGNMENT ???
 242         }
 243     }
 244     ImplPutByte( mnRepVal + 1 );        // end of RLE decoding
 245 }
 246
 247 // ------------------------------------------------------------------------
 248
 249 void RASWriter::ImplPutByte( BYTE nPutThis )
 250 {
 251     if ( mnRepCount == 0xffffffff )
 252     {
 253         mnRepCount = 0;
 254         mnRepVal = nPutThis;
 255     }
 256     else
 257     {
 258         if ( ( nPutThis == mnRepVal ) && ( mnRepCount != 0xff ) )
 259             mnRepCount++;
 260         else
 261         {
 262             if ( mnRepCount == 0 )
 263             {
 264                 *mpOStm << (BYTE)mnRepVal;
 265                 if ( mnRepVal == 0x80 )
 266                     *mpOStm << (BYTE)0;
 267             }
 268             else
 269             {
 270                 *mpOStm << (BYTE)0x80;
 271                 *mpOStm << (BYTE)mnRepCount;
 272                 *mpOStm << (BYTE)mnRepVal;
 273             }
 274             mnRepVal = nPutThis;
 275             mnRepCount = 0;
 276         }
 277     }
 278 }
 279
 280 // ------------------------------------------------------------------------
 281
 282 // ---------------------
 283 // - exported function -
 284 // ---------------------
 285
 286 extern "C" BOOL __LOADONCALLAPI GraphicExport( SvStream& rStream, Graphic& rGraphic, FilterConfigItem* pFilterConfigItem, BOOL )
 287 {
 288     RASWriter aRASWriter;
 289
 290     return aRASWriter.WriteRAS( rGraphic, rStream, pFilterConfigItem );
 291 }
 292 #ifndef GCC
 293 #endif
 294
 295 // ---------------
 296 // - Win16 trash -
 297 // ---------------
 298
 299 #ifdef WIN
 300
 301 static HINSTANCE hDLLInst = 0;
 302
 303 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 304 {
 305     if ( nHeap )
 306         UnlockData( 0 );
 307
 308     hDLLInst = hDLL;
 309
 310     return TRUE;
 311 }
 312
 313 // ------------------------------------------------------------------------
 314
 315 extern "C" int CALLBACK WEP( int )
 316 {
 317     return 1;
 318 }
 319
 320 #endif