LCOV - code coverage report
Current view: top level - libreoffice/filter/source/graphicfilter/ipbm - ipbm.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 262 0.0 %
Date: 2012-12-27 Functions: 0 7 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10