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