vcl/source/filter/ixbm/xbmread.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <ctype.h>
  21 #include <comphelper/string.hxx>
  22 #include "xbmread.hxx"
  23
  24 enum XBMFormat
  25 {
  26     XBM10,
  27     XBM11
  28 };
  29
  30 enum ReadState
  31 {
  32     XBMREAD_OK,
  33     XBMREAD_ERROR,
  34     XBMREAD_NEED_MORE
  35 };
  36
  37 class XBMReader : public GraphicReader
  38 {
  39     SvStream&           rIStm;
  40     Bitmap              aBmp1;
  41     Bitmap::ScopedWriteAccess pAcc1;
  42     std::unique_ptr<short[]>
  43                         pHexTable;
  44     BitmapColor         aWhite;
  45     BitmapColor         aBlack;
  46     long                nLastPos;
  47     long                nWidth;
  48     long                nHeight;
  49     bool                bStatus;
  50
  51     void            InitTable();
  52     OString         FindTokenLine( SvStream* pInStm, const char* pTok1, const char* pTok2 );
  53     long            ParseDefine( const sal_Char* pDefine );
  54     bool            ParseData( SvStream* pInStm, const OString& aLastLine, XBMFormat eFormat );
  55
  56 public:
  57
  58     explicit        XBMReader( SvStream& rStm );
  59
  60     ReadState       ReadXBM( Graphic& rGraphic );
  61 };
  62
  63 XBMReader::XBMReader( SvStream& rStm ) :
  64             rIStm           ( rStm ),
  65             nLastPos        ( rStm.Tell() ),
  66             nWidth          ( 0 ),
  67             nHeight         ( 0 ),
  68             bStatus         ( true )
  69 {
  70     pHexTable.reset( new short[ 256 ] );
  71     maUpperName = "SVIXBM";
  72     InitTable();
  73 }
  74
  75 void XBMReader::InitTable()
  76 {
  77     memset( pHexTable.get(), 0, sizeof( short ) * 256 );
  78
  79     pHexTable[(int)'0'] = 0;
  80     pHexTable[(int)'1'] = 1;
  81     pHexTable[(int)'2'] = 2;
  82     pHexTable[(int)'3'] = 3;
  83     pHexTable[(int)'4'] = 4;
  84     pHexTable[(int)'5'] = 5;
  85     pHexTable[(int)'6'] = 6;
  86     pHexTable[(int)'7'] = 7;
  87     pHexTable[(int)'8'] = 8;
  88     pHexTable[(int)'9'] = 9;
  89     pHexTable[(int)'A'] = 10;
  90     pHexTable[(int)'B'] = 11;
  91     pHexTable[(int)'C'] = 12;
  92     pHexTable[(int)'D'] = 13;
  93     pHexTable[(int)'E'] = 14;
  94     pHexTable[(int)'F'] = 15;
  95     pHexTable[(int)'X'] = 0;
  96     pHexTable[(int)'a'] = 10;
  97     pHexTable[(int)'b'] = 11;
  98     pHexTable[(int)'c'] = 12;
  99     pHexTable[(int)'d'] = 13;
 100     pHexTable[(int)'e'] = 14;
 101     pHexTable[(int)'f'] = 15;
 102     pHexTable[(int)'x'] = 0;
 103     pHexTable[(int)' '] = -1;
 104     pHexTable[(int)','] = -1;
 105     pHexTable[(int)'}'] = -1;
 106     pHexTable[(int)'\n'] = -1;
 107     pHexTable[(int)'\t'] = -1;
 108     pHexTable[(int)'\0'] = -1;
 109 }
 110
 111 OString XBMReader::FindTokenLine( SvStream* pInStm, const char* pTok1,
 112                                  const char* pTok2 )
 113 {
 114     OString aRet;
 115     sal_Int32 nPos1, nPos2;
 116
 117     bStatus = false;
 118
 119     do
 120     {
 121         if( !pInStm->ReadLine( aRet ) )
 122             break;
 123
 124         if( pTok1 )
 125         {
 126             if( ( nPos1 = aRet.indexOf( pTok1 ) ) != -1 )
 127             {
 128                 bStatus = true;
 129
 130                 if( pTok2 )
 131                 {
 132                     bStatus = false;
 133
 134                     if( ( ( nPos2 = aRet.indexOf( pTok2 ) ) != -1 ) &&
 135                          ( nPos2 > nPos1 ) )
 136                     {
 137                         bStatus = true;
 138                     }
 139                 }
 140             }
 141         }
 142     }
 143     while( !bStatus );
 144
 145     return aRet;
 146 }
 147
 148 long XBMReader::ParseDefine( const sal_Char* pDefine )
 149 {
 150     long    nRet = 0;
 151     char*   pTmp = const_cast<char*>(pDefine);
 152     unsigned char   cTmp;
 153
 154     // move to end
 155     pTmp += ( strlen( pDefine ) - 1 );
 156     cTmp = *pTmp--;
 157
 158     // search last digit
 159     while (pHexTable[ cTmp ] == -1 && pTmp >= pDefine)
 160         cTmp = *pTmp--;
 161
 162     // move before number
 163     while (pHexTable[ cTmp ] != -1 && pTmp >= pDefine)
 164         cTmp = *pTmp--;
 165
 166     // move to start of number
 167     pTmp += 2;
 168
 169     // read Hex
 170     if( ( pTmp[0] == '0' ) && ( ( pTmp[1] == 'X' ) || ( pTmp[1] == 'x' ) ) )
 171     {
 172         pTmp += 2;
 173         cTmp = *pTmp++;
 174
 175         while ( pHexTable[ cTmp ] != -1 )
 176         {
 177             nRet = ( nRet << 4 ) + pHexTable[ cTmp ];
 178             cTmp = *pTmp++;
 179         }
 180     }
 181     // read decimal
 182     else
 183     {
 184         cTmp = *pTmp++;
 185         while( ( cTmp >= '0' ) && ( cTmp <= '9' ) )
 186         {
 187             nRet = nRet * 10 + ( cTmp - '0' );
 188             cTmp = *pTmp++;
 189         }
 190     }
 191
 192     return nRet;
 193 }
 194
 195 bool XBMReader::ParseData( SvStream* pInStm, const OString& aLastLine, XBMFormat eFormat )
 196 {
 197     OString    aLine;
 198     long            nRow = 0;
 199     long            nCol = 0;
 200     long            nBits = ( eFormat == XBM10 ) ? 16 : 8;
 201     long            nBit;
 202     sal_uInt16          nValue;
 203     sal_uInt16          nDigits;
 204     bool            bFirstLine = true;
 205
 206     while( nRow < nHeight )
 207     {
 208         if( bFirstLine )
 209         {
 210             sal_Int32 nPos;
 211
 212             // delete opening curly bracket
 213             if( (nPos = ( aLine = aLastLine ).indexOf('{') ) != -1 )
 214                 aLine = aLine.copy(nPos + 1);
 215
 216             bFirstLine = false;
 217         }
 218         else if( !pInStm->ReadLine( aLine ) )
 219             break;
 220
 221         if (!aLine.isEmpty())
 222         {
 223             const sal_Int32 nCount = comphelper::string::getTokenCount(aLine, ',');
 224
 225             for( sal_Int32 i = 0; ( i < nCount ) && ( nRow < nHeight ); ++i )
 226             {
 227                 const OString aToken(aLine.getToken(i, ','));
 228                 const sal_Int32 nLen = aToken.getLength();
 229                 bool bProcessed = false;
 230
 231                 nBit = nDigits = nValue = 0;
 232
 233                 for (sal_Int32 n = 0; n < nLen; ++n)
 234                 {
 235                     const unsigned char cChar = aToken[n];
 236                     const short         nTable = pHexTable[ cChar ];
 237
 238                     if( isxdigit( cChar ) || !nTable )
 239                     {
 240                         nValue = ( nValue << 4 ) + nTable;
 241                         nDigits++;
 242                         bProcessed = true;
 243                     }
 244                     else if( ( nTable < 0 ) && nDigits )
 245                     {
 246                         bProcessed = true;
 247                         break;
 248                     }
 249                 }
 250
 251                 if( bProcessed )
 252                 {
 253                     while( ( nCol < nWidth ) && ( nBit < nBits ) )
 254                         pAcc1->SetPixel( nRow, nCol++, ( nValue & ( 1 << nBit++ ) ) ? aBlack : aWhite );
 255
 256                     if( nCol == nWidth )
 257                     {
 258                         nCol = 0;
 259                         nRow++;
 260                     }
 261                 }
 262             }
 263         }
 264     }
 265
 266     return true;
 267 }
 268
 269 ReadState XBMReader::ReadXBM( Graphic& rGraphic )
 270 {
 271     ReadState   eReadState;
 272     sal_uInt8       cDummy;
 273
 274     // check if we can read ALL
 275     rIStm.Seek( STREAM_SEEK_TO_END );
 276     rIStm.ReadUChar( cDummy );
 277
 278     // if we cannot read all
 279     // we return and wait for new data
 280     if ( rIStm.GetError() != ERRCODE_IO_PENDING )
 281     {
 282         rIStm.Seek( nLastPos );
 283         bStatus = false;
 284         OString aLine = FindTokenLine( &rIStm, "#define", "_width" );
 285
 286         if ( bStatus )
 287         {
 288             int nValue;
 289             if ( ( nValue = (int) ParseDefine( aLine.getStr() ) ) > 0 )
 290             {
 291                 nWidth = nValue;
 292                 aLine = FindTokenLine( &rIStm, "#define", "_height" );
 293
 294                 // if height was not received, we search again
 295                 // from start of the file
 296                 if ( !bStatus )
 297                 {
 298                     rIStm.Seek( nLastPos );
 299                     aLine = FindTokenLine( &rIStm, "#define", "_height" );
 300                 }
 301             }
 302             else
 303                 bStatus = false;
 304
 305             if ( bStatus )
 306             {
 307                 if ( ( nValue = (int) ParseDefine( aLine.getStr() ) ) > 0 )
 308                 {
 309                     nHeight = nValue;
 310                     aLine = FindTokenLine( &rIStm, "static", "_bits" );
 311
 312                     if ( bStatus )
 313                     {
 314                         XBMFormat eFormat = XBM10;
 315
 316                         if (aLine.indexOf("short") != -1)
 317                             eFormat = XBM10;
 318                         else if (aLine.indexOf("char") != -1)
 319                             eFormat = XBM11;
 320                         else
 321                             bStatus = false;
 322
 323                         if ( bStatus && nWidth && nHeight )
 324                         {
 325                             aBmp1 = Bitmap( Size( nWidth, nHeight ), 1 );
 326                             pAcc1 = Bitmap::ScopedWriteAccess(aBmp1);
 327
 328                             if( pAcc1 )
 329                             {
 330                                 aWhite = pAcc1->GetBestMatchingColor( Color( COL_WHITE ) );
 331                                 aBlack = pAcc1->GetBestMatchingColor( Color( COL_BLACK ) );
 332                                 bStatus = ParseData( &rIStm, aLine, eFormat );
 333                             }
 334                             else
 335                                 bStatus = false;
 336                         }
 337                     }
 338                 }
 339             }
 340         }
 341
 342         if (bStatus && pAcc1)
 343         {
 344             Bitmap aBlackBmp( Size( pAcc1->Width(), pAcc1->Height() ), 1 );
 345
 346             pAcc1.reset();
 347             aBlackBmp.Erase( Color( COL_BLACK ) );
 348             rGraphic = BitmapEx( aBlackBmp, aBmp1 );
 349             eReadState = XBMREAD_OK;
 350         }
 351         else
 352             eReadState = XBMREAD_ERROR;
 353     }
 354     else
 355     {
 356         rIStm.ResetError();
 357         eReadState = XBMREAD_NEED_MORE;
 358     }
 359
 360     return eReadState;
 361 }
 362
 363 VCL_DLLPUBLIC bool ImportXBM( SvStream& rStm, Graphic& rGraphic )
 364 {
 365     std::shared_ptr<GraphicReader> pContext = rGraphic.GetContext();
 366     rGraphic.SetContext(nullptr);
 367     XBMReader* pXBMReader = dynamic_cast<XBMReader*>( pContext.get() );
 368     if (!pXBMReader)
 369     {
 370         pContext = std::make_shared<XBMReader>( rStm );
 371         pXBMReader = static_cast<XBMReader*>( pContext.get() );
 372     }
 373
 374     bool bRet = true;
 375
 376     ReadState eReadState = pXBMReader->ReadXBM( rGraphic );
 377
 378     if( eReadState == XBMREAD_ERROR )
 379     {
 380         bRet = false;
 381     }
 382     else if( eReadState == XBMREAD_NEED_MORE )
 383         rGraphic.SetContext( pContext );
 384
 385     return bRet;
 386 }
 387
 388 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */