| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_filter.hxx" |
| |
| #include <vcl/graph.hxx> |
| #include <vcl/bmpacc.hxx> |
| #include <svtools/fltcall.hxx> |
| #include <svtools/FilterConfigItem.hxx> |
| |
| //============================ RASWriter ================================== |
| |
| class RASWriter { |
| |
| private: |
| |
| SvStream* mpOStm; |
| sal_uInt16 mpOStmOldModus; |
| |
| sal_Bool mbStatus; |
| BitmapReadAccess* mpAcc; |
| |
| sal_uLong mnWidth, mnHeight; |
| sal_uInt16 mnColors, mnDepth; |
| |
| sal_uLong mnRepCount; |
| sal_uInt8 mnRepVal; |
| |
| com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator; |
| |
| void ImplCallback( sal_uLong nCurrentYPos ); |
| sal_Bool ImplWriteHeader(); |
| void ImplWritePalette(); |
| void ImplWriteBody(); |
| void ImplPutByte( sal_uInt8 ); // RLE decoding |
| |
| public: |
| RASWriter(); |
| ~RASWriter(); |
| |
| sal_Bool WriteRAS( const Graphic& rGraphic, SvStream& rRAS, FilterConfigItem* pFilterConfigItem ); |
| }; |
| |
| //=================== Methoden von RASWriter ============================== |
| |
| RASWriter::RASWriter() : |
| mbStatus ( sal_True ), |
| mpAcc ( NULL ), |
| mnRepCount ( 0xffffffff ) |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| RASWriter::~RASWriter() |
| { |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void RASWriter::ImplCallback( sal_uLong nYPos ) |
| { |
| if ( xStatusIndicator.is() ) |
| xStatusIndicator->setValue( (sal_uInt16)( ( 100 * nYPos ) / mnHeight ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool RASWriter::WriteRAS( const Graphic& rGraphic, SvStream& rRAS, FilterConfigItem* pFilterConfigItem) |
| { |
| Bitmap aBmp; |
| |
| mpOStm = &rRAS; |
| |
| if ( pFilterConfigItem ) |
| { |
| xStatusIndicator = pFilterConfigItem->GetStatusIndicator(); |
| if ( xStatusIndicator.is() ) |
| { |
| rtl::OUString aMsg; |
| xStatusIndicator->start( aMsg, 100 ); |
| } |
| } |
| |
| BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); |
| aBmp = aBmpEx.GetBitmap(); |
| |
| if ( aBmp.GetBitCount() == 4 ) |
| aBmp.Convert( BMP_CONVERSION_8BIT_COLORS ); |
| |
| mnDepth = aBmp.GetBitCount(); |
| |
| // export code below only handles three discrete cases |
| mnDepth = mnDepth <= 1 ? 1 : mnDepth <= 8 ? 8 : 24; |
| |
| mpAcc = aBmp.AcquireReadAccess(); |
| if ( mpAcc ) |
| { |
| mpOStmOldModus = mpOStm->GetNumberFormatInt(); |
| mpOStm->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN ); |
| |
| if ( ImplWriteHeader() ) |
| { |
| if ( mnDepth <= 8 ) |
| ImplWritePalette(); |
| ImplWriteBody(); |
| } |
| aBmp.ReleaseAccess( mpAcc ); |
| } |
| else |
| mbStatus = sal_False; |
| |
| mpOStm->SetNumberFormatInt( mpOStmOldModus ); |
| |
| if ( xStatusIndicator.is() ) |
| xStatusIndicator->end(); |
| |
| return mbStatus; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool RASWriter::ImplWriteHeader() |
| { |
| mnWidth = mpAcc->Width(); |
| mnHeight = mpAcc->Height(); |
| if ( mnDepth <= 8 ) |
| { |
| mnColors = mpAcc->GetPaletteEntryCount(); |
| if (mnColors == 0) |
| mbStatus = sal_False; |
| } |
| if ( mbStatus && mnWidth && mnHeight && mnDepth ) |
| { |
| *mpOStm << (sal_uInt32)0x59a66a95 << (sal_uInt32)mnWidth << (sal_uInt32)mnHeight |
| << (sal_uInt32)mnDepth |
| << (sal_uInt32)(( ( ( ( mnWidth * mnDepth ) + 15 ) >> 4 ) << 1 ) * mnHeight) |
| << (sal_uInt32)2; |
| |
| if ( mnDepth > 8 ) |
| *mpOStm << (sal_uInt32)0 << (sal_uInt32)0; |
| else |
| { |
| |
| *mpOStm << (sal_uInt32)1 << (sal_uInt32)( mnColors * 3 ); |
| } |
| } |
| else mbStatus = sal_False; |
| |
| return mbStatus; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void RASWriter::ImplWritePalette() |
| { |
| sal_uInt16 i; |
| |
| for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetRed() ) ; |
| for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetGreen() ) ; |
| for ( i = 0; i < mnColors; *mpOStm << mpAcc->GetPaletteColor( i++ ).GetBlue() ) ; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void RASWriter::ImplWriteBody() |
| { |
| sal_uLong x, y; |
| |
| if ( mnDepth == 24 ) |
| { |
| for ( y = 0; y < mnHeight; y++ ) |
| { |
| ImplCallback( y ); // processing output |
| for ( x = 0; x < mnWidth; x++ ) |
| { |
| BitmapColor aColor( mpAcc->GetPixel( y, x ) ); |
| ImplPutByte( aColor.GetBlue() ); // Format ist BGR |
| ImplPutByte( aColor.GetGreen() ); |
| ImplPutByte( aColor.GetRed() ); |
| } |
| if ( x & 1 ) ImplPutByte( 0 ); // WORD ALIGNMENT ??? |
| } |
| } |
| else if ( mnDepth == 8 ) |
| { |
| for ( y = 0; y < mnHeight; y++ ) |
| { |
| ImplCallback( y ); // processing output |
| for ( x = 0; x < mnWidth; x++ ) |
| { |
| ImplPutByte ( mpAcc->GetPixelIndex( y, x ) ); |
| } |
| if ( x & 1 ) ImplPutByte( 0 ); // WORD ALIGNMENT ??? |
| } |
| } |
| else if ( mnDepth == 1 ) |
| { |
| sal_uInt8 nDat = 0; |
| |
| for ( y = 0; y < mnHeight; y++ ) |
| { |
| ImplCallback( y ); // processing output |
| for ( x = 0; x < mnWidth; x++ ) |
| { |
| nDat = ( ( nDat << 1 ) | ( mpAcc->GetPixelIndex( y, x ) & 1 ) ); |
| if ( ( x & 7 ) == 7 ) |
| ImplPutByte( nDat ); |
| } |
| if ( x & 7 ) |
| ImplPutByte( sal::static_int_cast< sal_uInt8 >(nDat << ( ( ( x & 7 ) ^ 7 ) + 1)) );// write remaining bits |
| if (!( ( x - 1 ) & 0x8 ) ) |
| ImplPutByte( 0 ); // WORD ALIGNMENT ??? |
| } |
| } |
| ImplPutByte( mnRepVal + 1 ); // end of RLE decoding |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void RASWriter::ImplPutByte( sal_uInt8 nPutThis ) |
| { |
| if ( mnRepCount == 0xffffffff ) |
| { |
| mnRepCount = 0; |
| mnRepVal = nPutThis; |
| } |
| else |
| { |
| if ( ( nPutThis == mnRepVal ) && ( mnRepCount != 0xff ) ) |
| mnRepCount++; |
| else |
| { |
| if ( mnRepCount == 0 ) |
| { |
| *mpOStm << (sal_uInt8)mnRepVal; |
| if ( mnRepVal == 0x80 ) |
| *mpOStm << (sal_uInt8)0; |
| } |
| else |
| { |
| *mpOStm << (sal_uInt8)0x80; |
| *mpOStm << (sal_uInt8)mnRepCount; |
| *mpOStm << (sal_uInt8)mnRepVal; |
| } |
| mnRepVal = nPutThis; |
| mnRepCount = 0; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| // --------------------- |
| // - exported function - |
| // --------------------- |
| |
| extern "C" sal_Bool __LOADONCALLAPI GraphicExport( SvStream& rStream, Graphic& rGraphic, FilterConfigItem* pFilterConfigItem, sal_Bool ) |
| { |
| RASWriter aRASWriter; |
| |
| return aRASWriter.WriteRAS( rGraphic, rStream, pFilterConfigItem ); |
| } |