filter/source/graphicfilter/ipbm/ipbm.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
  21 #include <vcl/graph.hxx>
  22 #include <vcl/bmpacc.hxx>
  23
  24 class FilterConfigItem;
  25
  26 //============================ PBMReader ==================================
  27
  28 class PBMReader {
  29
  30 private:
  31
  32     SvStream&           mrPBM;              // the PBM file to read
  33
  34     sal_Bool            mbStatus;
  35     sal_Bool            mbRemark;           // sal_False if the stream is in a comment
  36     sal_Bool            mbRaw;              // RAW/ASCII MODE
  37     sal_uLong           mnMode;             // 0->PBM, 1->PGM, 2->PPM
  38     Bitmap              maBmp;
  39     BitmapWriteAccess*  mpAcc;
  40     sal_uLong           mnWidth, mnHeight;  // dimensions in pixel
  41     sal_uLong           mnCol;
  42     sal_uLong           mnMaxVal;           // max value in the <missing comment>
  43     sal_Bool            ImplCallback( sal_uInt16 nPercent );
  44     sal_Bool            ImplReadBody();
  45     sal_Bool            ImplReadHeader();
  46
  47 public:
  48                         PBMReader(SvStream & rPBM);
  49                         ~PBMReader();
  50     sal_Bool                ReadPBM(Graphic & rGraphic );
  51 };
  52
  53 //=================== Methods of PBMReader ==============================
  54
  55 PBMReader::PBMReader(SvStream & rPBM)
  56     : mrPBM( rPBM )
  57     , mbStatus( sal_True )
  58     , mbRemark( sal_False )
  59     , mbRaw( sal_True )
  60     , mpAcc( NULL )
  61 {
  62 }
  63
  64 PBMReader::~PBMReader()
  65 {
  66 }
  67
  68 sal_Bool PBMReader::ImplCallback( sal_uInt16 /*nPercent*/ )
  69 {
  70 /*
  71     if ( pCallback != NULL )
  72     {
  73         if ( ( (*pCallback)( pCallerData, nPercent ) ) == sal_True )
  74         {
  75             mrPBM.SetError( SVSTREAM_FILEFORMAT_ERROR );
  76             return sal_True;
  77         }
  78     }
  79 */
  80     return sal_False;
  81 }
  82
  83 sal_Bool PBMReader::ReadPBM(Graphic & rGraphic )
  84 {
  85     sal_uInt16 i;
  86
  87     if ( mrPBM.GetError() )
  88         return sal_False;
  89
  90     mrPBM.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
  91
  92     // read header:
  93
  94     if ( ( mbStatus = ImplReadHeader() ) == sal_False )
  95         return sal_False;
  96
  97     if ( ( mnMaxVal == 0 ) || ( mnWidth == 0 ) || ( mnHeight == 0 ) )
  98         return sal_False;
  99
 100     // 0->PBM, 1->PGM, 2->PPM
 101     switch ( mnMode )
 102     {
 103         case 0 :
 104             maBmp = Bitmap( Size( mnWidth, mnHeight ), 1 );
 105             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == sal_False )
 106                 return sal_False;
 107             mpAcc->SetPaletteEntryCount( 2 );
 108             mpAcc->SetPaletteColor( 0, BitmapColor( 0xff, 0xff, 0xff ) );
 109             mpAcc->SetPaletteColor( 1, BitmapColor( 0x00, 0x00, 0x00 ) );
 110             break;
 111
 112         case 1 :
 113             if ( mnMaxVal <= 1 )
 114                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 1);
 115             else if ( mnMaxVal <= 15 )
 116                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 4);
 117             else
 118                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 8);
 119
 120             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == sal_False )
 121                 return sal_False;
 122             mnCol = (sal_uInt16)mnMaxVal + 1;
 123             if ( mnCol > 256 )
 124                 mnCol = 256;
 125
 126             mpAcc->SetPaletteEntryCount( 256 );
 127             for ( i = 0; i < mnCol; i++ )
 128             {
 129                 sal_uLong nCount = 255 * i / mnCol;
 130                 mpAcc->SetPaletteColor( i, BitmapColor( (sal_uInt8)nCount, (sal_uInt8)nCount, (sal_uInt8)nCount ) );
 131             }
 132             break;
 133         case 2 :
 134             maBmp = Bitmap( Size( mnWidth, mnHeight ), 24 );
 135             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == sal_False )
 136                 return sal_False;
 137             break;
 138     }
 139
 140     // read bitmap data
 141     mbStatus = ImplReadBody();
 142
 143     if ( mpAcc )
 144     {
 145         maBmp.ReleaseAccess( mpAcc ), mpAcc = NULL;
 146     }
 147     if ( mbStatus )
 148         rGraphic = maBmp;
 149
 150     return mbStatus;
 151 }
 152
 153 sal_Bool PBMReader::ImplReadHeader()
 154 {
 155     sal_uInt8   nID[ 2 ];
 156     sal_uInt8   nDat;
 157     sal_uInt8   nMax, nCount = 0;
 158     sal_Bool    bFinished = sal_False;
 159
 160     mrPBM >> nID[ 0 ] >> nID[ 1 ];
 161     if ( nID[ 0 ] != 'P' )
 162         return sal_False;
 163     mnMaxVal = mnWidth = mnHeight = 0;
 164     switch ( nID[ 1 ] )
 165     {
 166         case '1' :
 167             mbRaw = sal_False;
 168         case '4' :
 169             mnMode = 0;
 170             nMax = 2;               // number of parameters in Header
 171             mnMaxVal = 1;
 172             break;
 173         case '2' :
 174             mbRaw = sal_False;
 175         case '5' :
 176             mnMode = 1;
 177             nMax = 3;
 178             break;
 179         case '3' :
 180             mbRaw = sal_False;
 181         case '6' :
 182             mnMode = 2;
 183             nMax = 3;
 184             break;
 185         default:
 186             return sal_False;
 187     }
 188     while ( bFinished == sal_False )
 189     {
 190         if ( mrPBM.GetError() )
 191             return sal_False;
 192
 193         mrPBM >> nDat;
 194
 195         if ( nDat == '#' )
 196         {
 197             mbRemark = sal_True;
 198             continue;
 199         }
 200         else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 201         {
 202             mbRemark = sal_False;
 203             nDat = 0x20;
 204         }
 205         if ( mbRemark )
 206             continue;
 207
 208         if ( ( nDat == 0x20 ) || ( nDat == 0x09 ) )
 209         {
 210             if ( ( nCount == 0 ) && mnWidth )
 211                 nCount++;
 212             else if ( ( nCount == 1 ) && mnHeight )
 213             {
 214                 if ( ++nCount == nMax )
 215                     bFinished = sal_True;
 216             }
 217             else if ( ( nCount == 2 ) && mnMaxVal )
 218             {
 219                 bFinished = sal_True;
 220             }
 221             continue;
 222         }
 223         if ( ( nDat >= '0' ) && ( nDat <= '9' ) )
 224         {
 225             nDat -= '0';
 226             if ( nCount == 0 )
 227             {
 228                 mnWidth *= 10;
 229                 mnWidth += nDat;
 230             }
 231             else if ( nCount == 1 )
 232             {
 233                 mnHeight *= 10;
 234                 mnHeight += nDat;
 235             }
 236             else if ( nCount == 2 )
 237             {
 238                 mnMaxVal *= 10;
 239                 mnMaxVal += nDat;
 240             }
 241         }
 242         else
 243             return sal_False;
 244     }
 245     return mbStatus;
 246 }
 247
 248 sal_Bool PBMReader::ImplReadBody()
 249 {
 250     sal_Bool    bPara, bFinished = sal_False;
 251     sal_uInt8   nDat = 0, nCount;
 252     sal_uLong   nGrey, nRGB[3];
 253     sal_uLong   nWidth = 0;
 254     sal_uLong   nHeight = 0;
 255
 256     if ( mbRaw )
 257     {
 258         signed char nShift = 0;
 259         switch ( mnMode )
 260         {
 261
 262             // PBM
 263             case 0 :
 264                 while ( nHeight != mnHeight )
 265                 {
 266                     if ( mrPBM.IsEof() || mrPBM.GetError() )
 267                         return sal_False;
 268
 269                     if ( --nShift < 0 )
 270                     {
 271                         mrPBM >> nDat;
 272                         nShift = 7;
 273                     }
 274                     mpAcc->SetPixelIndex( nHeight, nWidth, nDat >> nShift );
 275                     if ( ++nWidth == mnWidth )
 276                     {
 277                         nShift = 0;
 278                         nWidth = 0;
 279                         nHeight++;
 280                         ImplCallback( (sal_uInt16)( ( 100 * nHeight ) / mnHeight ) );   // processing output in percent
 281                     }
 282                 }
 283                 break;
 284
 285             // PGM
 286             case 1 :
 287                 while ( nHeight != mnHeight )
 288                 {
 289                     if ( mrPBM.IsEof() || mrPBM.GetError() )
 290                         return sal_False;
 291
 292                     mrPBM >> nDat;
 293                     mpAcc->SetPixelIndex( nHeight, nWidth++, nDat);
 294
 295                     if ( nWidth == mnWidth )
 296                     {
 297                         nWidth = 0;
 298                         nHeight++;
 299                         ImplCallback( (sal_uInt16)( ( 100 * nHeight ) / mnHeight ) );   // processing output in percent
 300                     }
 301                 }
 302                 break;
 303
 304             // PPM
 305             case 2 :
 306                 while ( nHeight != mnHeight )
 307                 {
 308                     if ( mrPBM.IsEof() || mrPBM.GetError() )
 309                         return sal_False;
 310
 311                     sal_uInt8   nR, nG, nB;
 312                     sal_uLong   nRed, nGreen, nBlue;
 313                     mrPBM >> nR >> nG >> nB;
 314                     nRed = 255 * nR / mnMaxVal;
 315                     nGreen = 255 * nG / mnMaxVal;
 316                     nBlue = 255 * nB / mnMaxVal;
 317                     mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( (sal_uInt8)nRed, (sal_uInt8)nGreen, (sal_uInt8)nBlue ) );
 318                     if ( nWidth == mnWidth )
 319                     {
 320                         nWidth = 0;
 321                         nHeight++;
 322                         ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );  // processing output in percent
 323                     }
 324                 }
 325                 break;
 326         }
 327     }
 328     else switch  ( mnMode )
 329     {
 330         // PBM
 331         case 0 :
 332             while ( bFinished == sal_False )
 333             {
 334                 if ( mrPBM.IsEof() || mrPBM.GetError() )
 335                     return sal_False;
 336
 337                 mrPBM >> nDat;
 338
 339                 if ( nDat == '#' )
 340                 {
 341                     mbRemark = sal_True;
 342                     continue;
 343                 }
 344                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 345                 {
 346                     mbRemark = sal_False;
 347                     continue;
 348                 }
 349                 if ( mbRemark || nDat == 0x20 || nDat == 0x09 )
 350                     continue;
 351
 352                 if ( nDat == '0' || nDat == '1' )
 353                 {
 354                     mpAcc->SetPixelIndex( nHeight, nWidth, static_cast<sal_uInt8>(nDat - '0') );
 355                     nWidth++;
 356                     if ( nWidth == mnWidth )
 357                     {
 358                         nWidth = 0;
 359                         if ( ++nHeight == mnHeight )
 360                             bFinished = sal_True;
 361                         ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );  // processing output in percent
 362                     }
 363                 }
 364                 else
 365                     return sal_False;
 366             }
 367             break;
 368
 369         // PGM
 370         case 1 :
 371
 372             bPara = sal_False;
 373             nCount = 0;
 374             nGrey = 0;
 375
 376             while ( bFinished == sal_False )
 377             {
 378                 if ( nCount )
 379                 {
 380                     nCount--;
 381                     if ( nGrey <= mnMaxVal )
 382                         nGrey = 255 * nGrey / mnMaxVal;
 383                     mpAcc->SetPixelIndex( nHeight, nWidth++, static_cast<sal_uInt8>(nGrey) );
 384                     nGrey = 0;
 385                     if ( nWidth == mnWidth )
 386                     {
 387                         nWidth = 0;
 388                         if ( ++nHeight == mnHeight )
 389                             bFinished = sal_True;
 390                         ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );  // processing output in percent
 391                     }
 392                     continue;
 393                 }
 394
 395                 if ( mrPBM.IsEof() || mrPBM.GetError() )
 396                     return sal_False;
 397
 398                 mrPBM >> nDat;
 399
 400                 if ( nDat == '#' )
 401                 {
 402                     mbRemark = sal_True;
 403                     if ( bPara )
 404                     {
 405                         bPara = sal_False;
 406                         nCount++;
 407                     }
 408                     continue;
 409                 }
 410                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 411                 {
 412                     mbRemark = sal_False;
 413                     if ( bPara )
 414                     {
 415                         bPara = sal_False;
 416                         nCount++;
 417                     }
 418                     continue;
 419                 }
 420
 421                 if ( nDat == 0x20 || nDat == 0x09 )
 422                 {
 423                     if ( bPara )
 424                     {
 425                         bPara = sal_False;
 426                         nCount++;
 427                     }
 428                     continue;
 429                 }
 430                 if ( nDat >= '0' && nDat <= '9' )
 431                 {
 432                     bPara = sal_True;
 433                     nGrey *= 10;
 434                     nGrey += nDat-'0';
 435                     continue;
 436                 }
 437                 else
 438                     return sal_False;
 439             }
 440             break;
 441
 442
 443
 444         // PPM
 445         case 2 :
 446
 447             bPara = sal_False;
 448             nCount = 0;
 449             nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;
 450
 451             while ( bFinished == sal_False )
 452             {
 453                 if ( nCount == 3 )
 454                 {
 455                     nCount = 0;
 456                     mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( static_cast< sal_uInt8 >( ( nRGB[ 0 ] * 255 ) / mnMaxVal ),
 457                                                                      static_cast< sal_uInt8 >( ( nRGB[ 1 ] * 255 ) / mnMaxVal ),
 458                                                                      static_cast< sal_uInt8 >( ( nRGB[ 2 ] * 255 ) / mnMaxVal ) ) );
 459                     nCount = 0;
 460                     nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;
 461                     if ( nWidth == mnWidth )
 462                     {
 463                         nWidth = 0;
 464                         if ( ++nHeight == mnHeight )
 465                             bFinished = sal_True;
 466                         ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );  // processing output in percent
 467                     }
 468                     continue;
 469                 }
 470
 471                 if ( mrPBM.IsEof() || mrPBM.GetError() )
 472                     return sal_False;
 473
 474                 mrPBM >> nDat;
 475
 476                 if ( nDat == '#' )
 477                 {
 478                     mbRemark = sal_True;
 479                     if ( bPara )
 480                     {
 481                         bPara = sal_False;
 482                         nCount++;
 483                     }
 484                     continue;
 485                 }
 486                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 487                 {
 488                     mbRemark = sal_False;
 489                     if ( bPara )
 490                     {
 491                         bPara = sal_False;
 492                         nCount++;
 493                     }
 494                     continue;
 495                 }
 496
 497                 if ( nDat == 0x20 || nDat == 0x09 )
 498                 {
 499                     if ( bPara )
 500                     {
 501                         bPara = sal_False;
 502                         nCount++;
 503                     }
 504                     continue;
 505                 }
 506                 if ( nDat >= '0' && nDat <= '9' )
 507                 {
 508                     bPara = sal_True;
 509                     nRGB[ nCount ] *= 10;
 510                     nRGB[ nCount ] += nDat-'0';
 511                     continue;
 512                 }
 513                 else
 514                     return sal_False;
 515             }
 516             break;
 517     }
 518     return mbStatus;
 519 }
 520
 521 //================== GraphicImport - the exported function ================
 522
 523 // this needs to be kept in sync with
 524 // ImpFilterLibCacheEntry::GetImportFunction() from
 525 // vcl/source/filter/graphicfilter.cxx
 526 #if defined(DISABLE_DYNLOADING)
 527 #define GraphicImport ipbGraphicImport
 528 #endif
 529
 530 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL
 531 GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool)
 532 {
 533     PBMReader aPBMReader(rStream);
 534
 535     return aPBMReader.ReadPBM(rGraphic );
 536 }
 537
 538 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */