goodies/source/filter.vcl/ipbm/ipbm.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ipbm.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_goodies.hxx"
  33
  34 #include <vcl/graph.hxx>
  35 #include <vcl/bmpacc.hxx>
  36 #include <svtools/fltcall.hxx>
  37
  38 //============================ PBMReader ==================================
  39
  40 class PBMReader {
  41
  42 private:
  43
  44     SvStream*                   mpPBM;                  // Die einzulesende PBM-Datei
  45
  46     BOOL                                mbStatus;
  47     BOOL                                mbRemark;               // FALSE wenn sich stream in einem Kommentar befindet
  48     BOOL                                mbRaw;                  // RAW/ASCII MODE
  49     ULONG                               mnMode;                 // 0->PBM, 1->PGM, 2->PPM
  50     Bitmap                              maBmp;
  51     BitmapWriteAccess*  mpAcc;
  52     ULONG                               mnWidth, mnHeight;      // Bildausmass in Pixeln
  53     ULONG                               mnCol;
  54     ULONG                               mnMaxVal;                       // maximaler wert in den
  55     BOOL                                ImplCallback( USHORT nPercent );
  56     BOOL                                ImplReadBody();
  57     BOOL                                ImplReadHeader();
  58
  59 public:
  60                         PBMReader();
  61                         ~PBMReader();
  62     BOOL                                ReadPBM( SvStream & rPBM, Graphic & rGraphic );
  63 };
  64
  65 //=================== Methoden von PBMReader ==============================
  66
  67 PBMReader::PBMReader() :
  68     mbStatus    ( TRUE ),
  69     mbRemark    ( FALSE ),
  70     mbRaw               ( TRUE ),
  71     mpAcc               ( NULL )
  72 {
  73 }
  74
  75 PBMReader::~PBMReader()
  76 {
  77 }
  78
  79 BOOL PBMReader::ImplCallback( USHORT /*nPercent*/ )
  80 {
  81 /*
  82     if ( pCallback != NULL )
  83     {
  84         if ( ( (*pCallback)( pCallerData, nPercent ) ) == TRUE )
  85         {
  86             mpPBM->SetError( SVSTREAM_FILEFORMAT_ERROR );
  87             return TRUE;
  88         }
  89     }
  90 */
  91     return FALSE;
  92 }
  93
  94 BOOL PBMReader::ReadPBM( SvStream & rPBM, Graphic & rGraphic )
  95 {
  96     USHORT i;
  97
  98     if ( rPBM.GetError() )
  99         return FALSE;
 100
 101     mpPBM = &rPBM;
 102     mpPBM->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 103
 104     // Kopf einlesen:
 105
 106     if ( ( mbStatus = ImplReadHeader() ) == FALSE )
 107         return FALSE;
 108
 109     if ( mnWidth == 0 || mnHeight == 0 )
 110         return FALSE;
 111
 112     // 0->PBM, 1->PGM, 2->PPM
 113     switch ( mnMode )
 114     {
 115         case 0 :
 116             maBmp = Bitmap( Size( mnWidth, mnHeight ), 1 );
 117             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == FALSE )
 118                 return FALSE;
 119             mpAcc->SetPaletteEntryCount( 2 );
 120             mpAcc->SetPaletteColor( 0, BitmapColor( 0xff, 0xff, 0xff ) );
 121             mpAcc->SetPaletteColor( 1, BitmapColor( 0x00, 0x00, 0x00 ) );
 122             break;
 123
 124         case 1 :
 125             if ( mnMaxVal <= 1 )
 126                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 1);
 127             else if ( mnMaxVal <= 15 )
 128                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 4);
 129             else
 130                 maBmp = Bitmap( Size( mnWidth, mnHeight ), 8);
 131
 132             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == FALSE )
 133                 return FALSE;
 134             mnCol = (USHORT)mnMaxVal + 1;
 135             if ( mnCol > 256 )
 136                 mnCol = 256;
 137
 138             mpAcc->SetPaletteEntryCount( 256 );
 139             for ( i = 0; i < mnCol; i++ )
 140             {
 141                 ULONG nCount = 255 * i / mnCol;
 142                 mpAcc->SetPaletteColor( i, BitmapColor( (BYTE)nCount, (BYTE)nCount, (BYTE)nCount ) );
 143             }
 144             break;
 145         case 2 :
 146             maBmp = Bitmap( Size( mnWidth, mnHeight ), 24 );
 147             if ( ( mpAcc = maBmp.AcquireWriteAccess() ) == FALSE )
 148                 return FALSE;
 149             break;
 150     }
 151
 152     // Bitmap-Daten einlesen
 153     mbStatus = ImplReadBody();
 154
 155     if ( mpAcc )
 156     {
 157         maBmp.ReleaseAccess( mpAcc ), mpAcc = NULL;
 158     }
 159     if ( mbStatus )
 160         rGraphic = maBmp;
 161
 162     return mbStatus;
 163 }
 164
 165 BOOL PBMReader::ImplReadHeader()
 166 {
 167     BYTE        nID[ 2 ];
 168     BYTE        nDat;
 169     BYTE        nMax, nCount = 0;
 170     BOOL        bFinished = FALSE;
 171
 172     *mpPBM >> nID[ 0 ] >> nID[ 1 ];
 173     if ( nID[ 0 ] != 'P' )
 174         return FALSE;
 175     switch ( nID[ 1 ] )
 176     {
 177         case '1' :
 178             mbRaw = FALSE;
 179         case '4' :
 180             mnMode = 0;
 181             nMax = 2;                           // number of parameters in Header
 182             break;
 183         case '2' :
 184             mbRaw = FALSE;
 185         case '5' :
 186             mnMode = 1;
 187             nMax = 3;
 188             break;
 189         case '3' :
 190             mbRaw = FALSE;
 191         case '6' :
 192             mnMode = 2;
 193             nMax = 3;
 194             break;
 195         default:
 196             return FALSE;
 197     }
 198
 199     mnMaxVal = mnWidth = mnHeight = 0;
 200
 201     while ( bFinished == FALSE )
 202     {
 203         if ( mpPBM->GetError() )
 204             return FALSE;
 205
 206         *mpPBM >> nDat;
 207
 208         if ( nDat == '#' )
 209         {
 210             mbRemark = TRUE;
 211             continue;
 212         }
 213         else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 214         {
 215             mbRemark = FALSE;
 216             nDat = 0x20;
 217         }
 218         if ( mbRemark )
 219             continue;
 220
 221         if ( ( nDat == 0x20 ) || ( nDat == 0x09 ) )
 222         {
 223             if ( ( nCount == 0 ) && mnWidth )
 224                 nCount++;
 225             else if ( ( nCount == 1 ) && mnHeight )
 226             {
 227                 if ( ++nCount == nMax )
 228                     bFinished = TRUE;
 229             }
 230             else if ( ( nCount == 2 ) && mnMaxVal )
 231             {
 232                 bFinished = TRUE;
 233             }
 234             continue;
 235         }
 236         if ( ( nDat >= '0' ) && ( nDat <= '9' ) )
 237         {
 238             nDat -= '0';
 239             if ( nCount == 0 )
 240             {
 241                 mnWidth *= 10;
 242                 mnWidth += nDat;
 243             }
 244             else if ( nCount == 1 )
 245             {
 246                 mnHeight *= 10;
 247                 mnHeight += nDat;
 248             }
 249             else if ( nCount == 2 )
 250             {
 251                 mnMaxVal *= 10;
 252                 mnMaxVal += nDat;
 253             }
 254         }
 255         else
 256             return FALSE;
 257     }
 258     return mbStatus;
 259 }
 260
 261 BOOL PBMReader::ImplReadBody()
 262 {
 263     BOOL        bPara, bFinished = FALSE;
 264     BYTE        nDat = 0, nCount;
 265     ULONG       nGrey, nRGB[3];
 266     ULONG       nWidth = 0;
 267     ULONG       nHeight = 0;
 268     signed char nShift = 0;
 269
 270     if ( mbRaw )
 271     {
 272         switch ( mnMode )
 273         {
 274
 275             // PBM
 276             case 0 :
 277                 while ( nHeight != mnHeight )
 278                 {
 279                     if ( mpPBM->IsEof() || mpPBM->GetError() )
 280                         return FALSE;
 281
 282                     if ( --nShift < 0 )
 283                     {
 284                         *mpPBM >> nDat;
 285                         nShift = 7;
 286                     }
 287                     mpAcc->SetPixel( nHeight, nWidth, nDat >> nShift );
 288                     if ( ++nWidth == mnWidth )
 289                     {
 290                         nShift = 0;
 291                         nWidth = 0;
 292                         nHeight++;
 293                         ImplCallback( (USHORT)( ( 100 * nHeight ) / mnHeight ) );       // processing output in percent
 294                     }
 295                 }
 296                 break;
 297
 298             // PGM
 299             case 1 :
 300                 while ( nHeight != mnHeight )
 301                 {
 302                     if ( mpPBM->IsEof() || mpPBM->GetError() )
 303                         return FALSE;
 304
 305                     *mpPBM >> nDat;
 306                     mpAcc->SetPixel( nHeight, nWidth++, nDat);
 307
 308                     if ( nWidth == mnWidth )
 309                     {
 310                         nWidth = 0;
 311                         nHeight++;
 312                         ImplCallback( (USHORT)( ( 100 * nHeight ) / mnHeight ) );       // processing output in percent
 313                     }
 314                 }
 315                 break;
 316
 317             // PPM
 318             case 2 :
 319                 while ( nHeight != mnHeight )
 320                 {
 321                     if ( mpPBM->IsEof() || mpPBM->GetError() )
 322                         return FALSE;
 323
 324                     BYTE        nR, nG, nB;
 325                     ULONG       nRed, nGreen, nBlue;
 326                     *mpPBM >> nR >> nG >> nB;
 327                     nRed = 255 * nR / mnMaxVal;
 328                     nGreen = 255 * nG / mnMaxVal;
 329                     nBlue = 255 * nB / mnMaxVal;
 330                     mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( (BYTE)nRed, (BYTE)nGreen, (BYTE)nBlue ) );
 331                     if ( nWidth == mnWidth )
 332                     {
 333                         nWidth = 0;
 334                         nHeight++;
 335                         ImplCallback( (USHORT) ( ( 100 * nHeight ) / mnHeight ) );      // processing output in percent
 336                     }
 337                 }
 338                 break;
 339         }
 340     }
 341     else switch  ( mnMode )
 342     {
 343         // PBM
 344         case 0 :
 345             while ( bFinished == FALSE )
 346             {
 347                 if ( mpPBM->IsEof() || mpPBM->GetError() )
 348                     return FALSE;
 349
 350                 *mpPBM >> nDat;
 351
 352                 if ( nDat == '#' )
 353                 {
 354                     mbRemark = TRUE;
 355                     continue;
 356                 }
 357                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 358                 {
 359                     mbRemark = FALSE;
 360                     continue;
 361                 }
 362                 if ( mbRemark || nDat == 0x20 || nDat == 0x09 )
 363                     continue;
 364
 365                 if ( nDat == '0' || nDat == '1' )
 366                 {
 367                     mpAcc->SetPixel( nHeight, nWidth, (BYTE)nDat-'0' );
 368                     nWidth++;
 369                     if ( nWidth == mnWidth )
 370                     {
 371                         nWidth = 0;
 372                         if ( ++nHeight == mnHeight )
 373                             bFinished = TRUE;
 374                         ImplCallback( (USHORT) ( ( 100 * nHeight ) / mnHeight ) );      // processing output in percent
 375                     }
 376                 }
 377                 else
 378                     return FALSE;
 379             }
 380             break;
 381
 382         // PGM
 383         case 1 :
 384
 385             bPara = FALSE;
 386             nCount = 0;
 387             nGrey = 0;
 388
 389             while ( bFinished == FALSE )
 390             {
 391                 if ( nCount )
 392                 {
 393                     nCount--;
 394                     if ( nGrey <= mnMaxVal )
 395                         nGrey = 255 * nGrey / mnMaxVal;
 396                         mpAcc->SetPixel( nHeight, nWidth++, (BYTE)nGrey );
 397                     nGrey = 0;
 398                     if ( nWidth == mnWidth )
 399                     {
 400                         nWidth = 0;
 401                         if ( ++nHeight == mnHeight )
 402                             bFinished = TRUE;
 403                         ImplCallback( (USHORT) ( ( 100 * nHeight ) / mnHeight ) );      // processing output in percent
 404                     }
 405                     continue;
 406                 }
 407
 408                 if ( mpPBM->IsEof() || mpPBM->GetError() )
 409                     return FALSE;
 410
 411                 *mpPBM >> nDat;
 412
 413                 if ( nDat == '#' )
 414                 {
 415                     mbRemark = TRUE;
 416                     if ( bPara )
 417                     {
 418                         bPara = FALSE;
 419                         nCount++;
 420                     }
 421                     continue;
 422                 }
 423                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 424                 {
 425                     mbRemark = FALSE;
 426                     if ( bPara )
 427                     {
 428                         bPara = FALSE;
 429                         nCount++;
 430                     }
 431                     continue;
 432                 }
 433
 434                 if ( nDat == 0x20 || nDat == 0x09 )
 435                 {
 436                     if ( bPara )
 437                     {
 438                         bPara = FALSE;
 439                         nCount++;
 440                     }
 441                     continue;
 442                 }
 443                 if ( nDat >= '0' && nDat <= '9' )
 444                 {
 445                     bPara = TRUE;
 446                     nGrey *= 10;
 447                     nGrey += nDat-'0';
 448                     continue;
 449                 }
 450                 else
 451                     return FALSE;
 452             }
 453             break;
 454
 455
 456
 457         // PPM
 458         case 2 :
 459
 460             bPara = FALSE;
 461             nCount = 0;
 462             nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;
 463
 464             while ( bFinished == FALSE )
 465             {
 466                 if ( nCount == 3 )
 467                 {
 468                     nCount = 0;
 469                     mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( (BYTE)nRGB[ 0 ], (BYTE)nRGB[ 1 ], (BYTE)nRGB[ 2 ] ) );
 470                     nCount = 0;
 471                     nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;
 472                     if ( nWidth == mnWidth )
 473                     {
 474                         nWidth = 0;
 475                         if ( ++nHeight == mnHeight )
 476                             bFinished = TRUE;
 477                         ImplCallback( (USHORT) ( ( 100 * nHeight ) / mnHeight ) );      // processing output in percent
 478                     }
 479                     continue;
 480                 }
 481
 482                 if ( mpPBM->IsEof() || mpPBM->GetError() )
 483                     return FALSE;
 484
 485                 *mpPBM >> nDat;
 486
 487                 if ( nDat == '#' )
 488                 {
 489                     mbRemark = TRUE;
 490                     if ( bPara )
 491                     {
 492                         bPara = FALSE;
 493                         nCount++;
 494                     }
 495                     continue;
 496                 }
 497                 else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
 498                 {
 499                     mbRemark = FALSE;
 500                     if ( bPara )
 501                     {
 502                         bPara = FALSE;
 503                         nCount++;
 504                     }
 505                     continue;
 506                 }
 507
 508                 if ( nDat == 0x20 || nDat == 0x09 )
 509                 {
 510                     if ( bPara )
 511                     {
 512                         bPara = FALSE;
 513                         nCount++;
 514                     }
 515                     continue;
 516                 }
 517                 if ( nDat >= '0' && nDat <= '9' )
 518                 {
 519                     bPara = TRUE;
 520                     nRGB[ nCount ] *= 10;
 521                     nRGB[ nCount ] += nDat-'0';
 522                     continue;
 523                 }
 524                 else
 525                     return FALSE;
 526             }
 527             break;
 528     }
 529     return mbStatus;
 530 }
 531
 532 //================== GraphicImport - die exportierte Funktion ================
 533
 534 extern "C" BOOL __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, BOOL )
 535 {
 536     PBMReader aPBMReader;
 537
 538     return aPBMReader.ReadPBM( rStream, rGraphic );
 539 }
 540
 541 //================== ein bischen Muell fuer Windows ==========================
 542 #ifndef GCC
 543 #endif
 544
 545 #ifdef WIN
 546
 547 static HINSTANCE hDLLInst = 0;      // HANDLE der DLL
 548
 549 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 550 {
 551 #ifndef WNT
 552     if ( nHeap )
 553         UnlockData( 0 );
 554 #endif
 555
 556     hDLLInst = hDLL;
 557
 558     return TRUE;
 559 }
 560
 561 extern "C" int CALLBACK WEP( int )
 562 {
 563     return 1;
 564 }
 565
 566 #endif
 567