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