goodies/source/filter.vcl/ipcx/ipcx.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: ipcx.cxx,v $
  10  * $Revision: 1.8.30.1 $
  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 //============================ PCXReader ==================================
  39
  40 class PCXReader {
  41
  42 private:
  43
  44     SvStream*                   pPCX;                           // Die einzulesende PCX-Datei
  45
  46     Bitmap                              aBmp;
  47     BitmapWriteAccess*  pAcc;
  48     BYTE                                nVersion;                       // PCX-Version
  49     BYTE                                nEncoding;                      // Art der Komprimierung
  50     ULONG                               nBitsPerPlanePix;       // Bits Pro Ebene pro Pixel
  51     ULONG                               nPlanes;                        // Anzahl Ebenen
  52     ULONG                               nBytesPerPlaneLin;      // Bytes in einer Ebenen pro Zeile
  53     USHORT                              nPaletteInfo;
  54
  55     ULONG                               nWidth, nHeight;        // Bildausmass in Pixeln
  56     USHORT                              nResX, nResY;           // Aufloesung in Pixel pro Inch oder 0,0
  57     USHORT                              nDestBitsPerPixel;      // Bits pro Pixel der Zielbitmap 1,4,8 oder 24
  58     BYTE*                               pPalette;                       //
  59     BOOL                                nStatus;                        // status nun nicht mehr am stream abfragen ( SJ )
  60
  61
  62     BOOL                                Callback( USHORT nPercent );
  63     void                                ImplReadBody();
  64     void                                ImplReadPalette( ULONG nCol );
  65     void                                ImplReadHeader();
  66
  67 public:
  68                         PCXReader();
  69                         ~PCXReader();
  70     BOOL                                ReadPCX( SvStream & rPCX, Graphic & rGraphic );
  71                         // Liesst aus dem Stream eine PCX-Datei und fuellt das GDIMetaFile
  72 };
  73
  74 //=================== Methoden von PCXReader ==============================
  75
  76 PCXReader::PCXReader() :
  77     pAcc                ( NULL )
  78 {
  79     pPalette = new BYTE[ 768 ];
  80 }
  81
  82 PCXReader::~PCXReader()
  83 {
  84     delete[] pPalette;
  85 }
  86
  87 BOOL PCXReader::Callback( USHORT /*nPercent*/ )
  88 {
  89 /*
  90     if (pCallback!=NULL) {
  91         if (((*pCallback)(pCallerData,nPercent))==TRUE) {
  92             nStatus = FALSE;
  93             return TRUE;
  94         }
  95     }
  96 */
  97     return FALSE;
  98 }
  99
 100 BOOL PCXReader::ReadPCX( SvStream & rPCX, Graphic & rGraphic )
 101 {
 102     if ( rPCX.GetError() )
 103         return FALSE;
 104
 105     ULONG*      pDummy = new ULONG; delete pDummy; // damit unter OS/2
 106                                                // das richtige (Tools-)new
 107                                                // verwendet wird, da es sonst
 108                                                // in dieser DLL nur Vector-news
 109                                                // gibt;
 110
 111     pPCX = &rPCX;
 112     pPCX->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
 113
 114     // Kopf einlesen:
 115
 116     nStatus = TRUE;
 117
 118     ImplReadHeader();
 119
 120     // BMP-Header und ggf. (eventuell zunaechst ungueltige) Farbpalette schreiben:
 121     if ( nStatus )
 122     {
 123         aBmp = Bitmap( Size( nWidth, nHeight ), nDestBitsPerPixel );
 124         if ( ( pAcc = aBmp.AcquireWriteAccess() ) == FALSE )
 125             return FALSE;
 126
 127         if ( nDestBitsPerPixel <= 8 )
 128         {
 129             USHORT nColors = 1 << nDestBitsPerPixel;
 130             BYTE* pPal = pPalette;
 131             pAcc->SetPaletteEntryCount( nColors );
 132             for ( USHORT i = 0; i < nColors; i++, pPal += 3 )
 133             {
 134                 pAcc->SetPaletteColor( i, BitmapColor ( pPal[ 0 ], pPal[ 1 ], pPal[ 2 ] ) );
 135             }
 136         }
 137         // Bitmap-Daten einlesen
 138         ImplReadBody();
 139
 140         // Wenn erweiterte Farbpalette am Ende von PCX, dann diese einlesen, und nochmals
 141         // in Palette schreiben:
 142         if ( nDestBitsPerPixel == 8 && nStatus )
 143         {
 144             BYTE* pPal = pPalette;
 145             pPCX->SeekRel(1);
 146             ImplReadPalette(256);
 147             pAcc->SetPaletteEntryCount( 256 );
 148             for ( USHORT i = 0; i < 256; i++, pPal += 3 )
 149             {
 150                 pAcc->SetPaletteColor( i, BitmapColor ( pPal[ 0 ], pPal[ 1 ], pPal[ 2 ] ) );
 151             }
 152         }
 153     /*
 154         // Aufloesung einstellen:
 155         if (nResX!=0 && nResY!=0) {
 156             MapMode aMapMode(MAP_INCH,Point(0,0),Fraction(1,nResX),Fraction(1,nResY));
 157             rBitmap.SetPrefMapMode(aMapMode);
 158             rBitmap.SetPrefSize(Size(nWidth,nHeight));
 159         }
 160     */  if ( nStatus && pAcc )
 161         {
 162             aBmp.ReleaseAccess( pAcc ), pAcc = NULL;
 163             rGraphic = aBmp;
 164             return TRUE;
 165         }
 166     }
 167     return FALSE;
 168 }
 169
 170 void PCXReader::ImplReadHeader()
 171 {
 172     BYTE nbyte;
 173     USHORT nushort;
 174     USHORT nMinX,nMinY,nMaxX,nMaxY;
 175
 176     *pPCX >> nbyte >> nVersion >> nEncoding;
 177     if ( nbyte!=0x0a || (nVersion != 0 && nVersion != 2 && nVersion != 3 && nVersion != 5) || nEncoding > 1 )
 178     {
 179         nStatus = FALSE;
 180         return;
 181     }
 182
 183     *pPCX >> nbyte; nBitsPerPlanePix = (ULONG)nbyte;
 184     *pPCX >> nMinX >> nMinY >> nMaxX >> nMaxY;
 185
 186     if ((nMinX > nMaxX) || (nMinY > nMaxY))
 187     {
 188         nStatus = FALSE;
 189         return;
 190     }
 191
 192     nWidth = nMaxX-nMinX+1;
 193     nHeight = nMaxY-nMinY+1;
 194
 195     *pPCX >> nResX;
 196     *pPCX >> nResY;
 197     if ( nResX >= nWidth || nResY >= nHeight || ( nResX != nResY ) )
 198         nResX = nResY = 0;
 199
 200     ImplReadPalette( 16 );
 201
 202     pPCX->SeekRel( 1 );
 203     *pPCX >> nbyte;   nPlanes = (ULONG)nbyte;
 204     *pPCX >> nushort; nBytesPerPlaneLin = (ULONG)nushort;
 205     *pPCX >> nPaletteInfo;
 206
 207     pPCX->SeekRel( 58 );
 208
 209     nDestBitsPerPixel = (USHORT)( nBitsPerPlanePix * nPlanes );
 210     if (nDestBitsPerPixel == 2 || nDestBitsPerPixel == 3) nDestBitsPerPixel = 4;
 211
 212     if ( ( nDestBitsPerPixel != 1 && nDestBitsPerPixel != 4 && nDestBitsPerPixel != 8 && nDestBitsPerPixel != 24 )
 213         || nPlanes > 4 || nBytesPerPlaneLin < ( ( nWidth * nBitsPerPlanePix+7 ) >> 3 ) )
 214     {
 215         nStatus = FALSE;
 216         return;
 217     }
 218
 219     // Wenn das Bild nur 2 Farben hat, ist die Palette zumeist ungueltig, und es handelt sich
 220     // immer (?) um ein schwarz-weiss-Bild:
 221     if ( nPlanes == 1 && nBitsPerPlanePix == 1 )
 222     {
 223         pPalette[ 0 ] = pPalette[ 1 ] = pPalette[ 2 ] = 0x00;
 224         pPalette[ 3 ] = pPalette[ 4 ] = pPalette[ 5 ] = 0xff;
 225     }
 226 }
 227
 228 void PCXReader::ImplReadBody()
 229 {
 230     BYTE        *pPlane[ 4 ], * pDest, * pSource1, * pSource2, * pSource3, *pSource4;
 231     ULONG       i, nx, ny, np, nCount, nUsedLineSize, nLineSize, nPercent;
 232     ULONG   nLastPercent = 0;
 233     BYTE        nDat = 0, nCol = 0;
 234
 235     nUsedLineSize = (ULONG)( ( ( nWidth * (ULONG)nDestBitsPerPixel ) + 7 ) >> 3 );
 236     nLineSize = ( nUsedLineSize + 3 ) & 0xfffc;
 237
 238     for( np = 0; np < nPlanes; np++ )
 239         pPlane[ np ] = new BYTE[ nBytesPerPlaneLin ];
 240
 241     nCount = 0;
 242     for ( ny = 0; ny < nHeight; ny++ )
 243     {
 244         if (pPCX->GetError() || pPCX->IsEof())
 245         {
 246             nStatus = FALSE;
 247             break;
 248         }
 249         nPercent = ny * 60 / nHeight + 10;
 250         if ( ny == 0 || nLastPercent + 4 <= nPercent )
 251         {
 252             nLastPercent = nPercent;
 253             if ( Callback( (USHORT)nPercent ) == TRUE )
 254                 break;
 255         }
 256         for ( np = 0; np < nPlanes; np++)
 257         {
 258             if ( nEncoding == 0)
 259                 pPCX->Read( (void *)pPlane[ np ], nBytesPerPlaneLin );
 260             else
 261             {
 262                 pDest = pPlane[ np ];
 263                 nx = nBytesPerPlaneLin;
 264                 while ( nCount > 0 && nx > 0)
 265                 {
 266                     *(pDest++) = nDat;
 267                     nx--;
 268                     nCount--;
 269                 }
 270                 while ( nx > 0 )
 271                 {
 272                     *pPCX >> nDat;
 273                     if ( ( nDat & 0xc0 ) == 0xc0 )
 274                     {
 275                         nCount =( (ULONG)nDat ) & 0x003f;
 276                         *pPCX >> nDat;
 277                         if ( nCount < nx )
 278                         {
 279                             nx -= nCount;
 280                             while ( nCount > 0)
 281                             {
 282                                 *(pDest++) = nDat;
 283                                 nCount--;
 284                             }
 285                         }
 286                         else
 287                         {
 288                             nCount -= nx;
 289                             do
 290                             {
 291                                 *(pDest++) = nDat;
 292                                 nx--;
 293                             }
 294                             while ( nx > 0 );
 295                             break;
 296                         }
 297                     }
 298                     else
 299                     {
 300                         *(pDest++) = nDat;
 301                         nx--;
 302                     }
 303                 }
 304             }
 305         }
 306         pSource1 = pPlane[ 0 ];
 307         pSource2 = pPlane[ 1 ];
 308         pSource3 = pPlane[ 2 ];
 309         pSource4 = pPlane[ 3 ];
 310         switch ( nBitsPerPlanePix + ( nPlanes << 8 ) )
 311         {
 312             // 2 colors
 313             case 0x101 :
 314                 for ( i = 0; i < nWidth; i++ )
 315                 {
 316                     ULONG nShift = ( i & 7 ) ^ 7;
 317                     if ( nShift == 0 )
 318                         pAcc->SetPixel( ny, i, ( *pSource1++ & 1 ) );
 319                     else
 320                         pAcc->SetPixel(
 321                             ny, i,
 322                             sal::static_int_cast< BYTE >(
 323                                 ( *pSource1 >> nShift ) & 1) );
 324                 }
 325                 break;
 326             // 4 colors
 327             case 0x102 :
 328                 for ( i = 0; i < nWidth; i++ )
 329                 {
 330                     switch( i & 3 )
 331                     {
 332                         case 0 :
 333                             nCol = *pSource1 >> 6;
 334                             break;
 335                         case 1 :
 336                             nCol = ( *pSource1 >> 4 ) & 0x03 ;
 337                             break;
 338                         case 2 :
 339                             nCol = ( *pSource1 >> 2 ) & 0x03;
 340                             break;
 341                         case 3 :
 342                             nCol = ( *pSource1++ ) & 0x03;
 343                             break;
 344                     }
 345                     pAcc->SetPixel( ny, i, nCol );
 346                 }
 347                 break;
 348             // 256 colors
 349             case 0x108 :
 350                 for ( i = 0; i < nWidth; i++ )
 351                 {
 352                     pAcc->SetPixel( ny, i, *pSource1++ );
 353                 }
 354                 break;
 355             // 8 colors
 356             case 0x301 :
 357                 for ( i = 0; i < nWidth; i++ )
 358                 {
 359                     ULONG nShift = ( i & 7 ) ^ 7;
 360                     if ( nShift == 0 )
 361                     {
 362                         nCol = ( *pSource1++ & 1) + ( ( *pSource2++ << 1 ) & 2 ) + ( ( *pSource3++ << 2 ) & 4 );
 363                         pAcc->SetPixel( ny, i, nCol );
 364                     }
 365                     else
 366                     {
 367                         nCol = sal::static_int_cast< BYTE >(
 368                             ( ( *pSource1 >> nShift ) & 1)  + ( ( ( *pSource2 >> nShift ) << 1 ) & 2 ) +
 369                             ( ( ( *pSource3 >> nShift ) << 2 ) & 4 ));
 370                         pAcc->SetPixel( ny, i, nCol );
 371                     }
 372                 }
 373                 break;
 374             // 16 colors
 375             case 0x401 :
 376                 for ( i = 0; i < nWidth; i++ )
 377                 {
 378                     ULONG nShift = ( i & 7 ) ^ 7;
 379                     if ( nShift == 0 )
 380                     {
 381                         nCol = ( *pSource1++ & 1) + ( ( *pSource2++ << 1 ) & 2 ) + ( ( *pSource3++ << 2 ) & 4 ) +
 382                             ( ( *pSource4++ << 3 ) & 8 );
 383                         pAcc->SetPixel( ny, i, nCol );
 384                     }
 385                     else
 386                     {
 387                         nCol = sal::static_int_cast< BYTE >(
 388                             ( ( *pSource1 >> nShift ) & 1)  + ( ( ( *pSource2 >> nShift ) << 1 ) & 2 ) +
 389                             ( ( ( *pSource3 >> nShift ) << 2 ) & 4 ) + ( ( ( *pSource4 >> nShift ) << 3 ) & 8 ));
 390                         pAcc->SetPixel( ny, i, nCol );
 391                     }
 392                 }
 393                 break;
 394             // 16m colors
 395             case 0x308 :
 396                 for ( i = 0; i < nWidth; i++ )
 397                 {
 398                     pAcc->SetPixel( ny, i, Color( *pSource1++, *pSource2++, *pSource3++ ) );
 399
 400                 }
 401                 break;
 402             default :
 403                 nStatus = FALSE;
 404                 break;
 405         }
 406     }
 407     for ( np = 0; np < nPlanes; np++ )
 408         delete[] pPlane[ np ];
 409 }
 410
 411 void PCXReader::ImplReadPalette( ULONG nCol )
 412 {
 413     BYTE        r, g, b;
 414     BYTE*       pPtr = pPalette;
 415     for ( ULONG i = 0; i < nCol; i++ )
 416     {
 417         *pPCX >> r >> g >> b;
 418         *pPtr++ = r;
 419         *pPtr++ = g;
 420         *pPtr++ = b;
 421     }
 422 }
 423
 424 //================== GraphicImport - die exportierte Funktion ================
 425
 426 extern "C" BOOL __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, BOOL )
 427 {
 428     PCXReader aPCXReader;
 429     BOOL nRetValue = aPCXReader.ReadPCX( rStream, rGraphic );
 430     if ( nRetValue == FALSE )
 431         rStream.SetError( SVSTREAM_FILEFORMAT_ERROR );
 432     return nRetValue;
 433 }
 434
 435 //================== ein bischen Muell fuer Windows ==========================
 436 #ifndef GCC
 437 #endif
 438
 439 #ifdef WIN
 440
 441 static HINSTANCE hDLLInst = 0;      // HANDLE der DLL
 442
 443 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 444 {
 445 #ifndef WNT
 446     if ( nHeap )
 447         UnlockData( 0 );
 448 #endif
 449
 450     hDLLInst = hDLL;
 451
 452     return TRUE;
 453 }
 454
 455 extern "C" int CALLBACK WEP( int )
 456 {
 457     return 1;
 458 }
 459
 460 #endif
 461