goodies/source/filter.vcl/ipsd/ipsd.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: ipsd.cxx,v $
  10  * $Revision: 1.14 $
  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 //============================ PSDReader ==================================
  39
  40 #define PSD_BITMAP                      0
  41 #define PSD_GRAYSCALE           1
  42 #define PSD_INDEXED                     2
  43 #define PSD_RGB                         3
  44 #define PSD_CMYK                        4
  45 #define PSD_MULTICHANNEL        7
  46 #define PSD_DUOTONE                     8
  47 #define PSD_LAB                         9
  48
  49 typedef struct
  50 {
  51     UINT32      nSignature;
  52     UINT16      nVersion;
  53     UINT32      nPad1;
  54     UINT16      nPad2;
  55     UINT16      nChannels;
  56     UINT32      nRows;
  57     UINT32      nColumns;
  58     UINT16      nDepth;
  59     UINT16      nMode;
  60
  61 } PSDFileHeader;
  62
  63 class PSDReader {
  64
  65 private:
  66
  67     SvStream*                   mpPSD;                  // Die einzulesende PSD-Datei
  68     PSDFileHeader*              mpFileHeader;
  69
  70     sal_uInt32          mnXResFixed;
  71     sal_uInt32          mnYResFixed;
  72
  73     sal_Bool            mbStatus;
  74     sal_Bool            mbTransparent;
  75
  76     Bitmap                              maBmp;
  77     Bitmap                              maMaskBmp;
  78     BitmapReadAccess*   mpReadAcc;
  79     BitmapWriteAccess*  mpWriteAcc;
  80     BitmapWriteAccess*  mpMaskWriteAcc;
  81     USHORT                              mnDestBitDepth;
  82     BOOL                                mbCompression;  // RLE decoding
  83     BYTE*                               mpPalette;
  84
  85     BOOL                                ImplReadBody();
  86     BOOL                                ImplReadHeader();
  87
  88 public:
  89                         PSDReader();
  90                         ~PSDReader();
  91     BOOL                                ReadPSD( SvStream & rPSD, Graphic & rGraphic );
  92 };
  93
  94 //=================== Methoden von PSDReader ==============================
  95
  96 PSDReader::PSDReader() :
  97     mpFileHeader        ( NULL ),
  98     mnXResFixed     ( 0 ),
  99     mnYResFixed     ( 0 ),
 100     mbStatus            ( TRUE ),
 101     mbTransparent       ( FALSE ),
 102     mpReadAcc           ( NULL ),
 103     mpWriteAcc          ( NULL ),
 104     mpMaskWriteAcc      ( NULL ),
 105     mpPalette           ( NULL )
 106 {
 107 }
 108
 109 PSDReader::~PSDReader()
 110 {
 111     delete[] mpPalette;
 112     delete mpFileHeader;
 113 }
 114
 115 // ------------------------------------------------------------------------
 116
 117 BOOL PSDReader::ReadPSD( SvStream & rPSD, Graphic & rGraphic )
 118 {
 119     if ( rPSD.GetError() )
 120         return FALSE;
 121
 122     mpPSD = &rPSD;
 123     mpPSD->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 124
 125     // Kopf einlesen:
 126
 127     if ( ImplReadHeader() == FALSE )
 128         return FALSE;
 129
 130     Size aBitmapSize( mpFileHeader->nColumns, mpFileHeader->nRows );
 131     maBmp = Bitmap( aBitmapSize, mnDestBitDepth );
 132     if ( ( mpWriteAcc = maBmp.AcquireWriteAccess() ) == NULL )
 133         mbStatus = FALSE;
 134     if ( ( mpReadAcc = maBmp.AcquireReadAccess() ) == NULL )
 135         mbStatus = FALSE;
 136     if ( mbTransparent && mbStatus )
 137     {
 138         maMaskBmp = Bitmap( aBitmapSize, 1 );
 139         if ( ( mpMaskWriteAcc = maMaskBmp.AcquireWriteAccess() ) == NULL )
 140             mbStatus = FALSE;
 141     }
 142     if ( mpPalette && mbStatus )
 143     {
 144         mpWriteAcc->SetPaletteEntryCount( 256 );
 145         for ( USHORT i = 0; i < 256; i++ )
 146         {
 147             mpWriteAcc->SetPaletteColor( i, Color( mpPalette[ i ], mpPalette[ i + 256 ], mpPalette[ i + 512 ] ) );
 148         }
 149     }
 150     // Bitmap-Daten einlesen
 151     if ( mbStatus && ImplReadBody() )
 152     {
 153         if ( mbTransparent )
 154             rGraphic = Graphic( BitmapEx( maBmp, maMaskBmp ) );
 155         else
 156             rGraphic = maBmp;
 157
 158         if ( mnXResFixed && mnYResFixed )
 159         {
 160             Point       aEmptyPoint;
 161             Fraction    aFractX( 1, mnXResFixed >> 16 );
 162             Fraction    aFractY( 1, mnYResFixed >> 16 );
 163             MapMode             aMapMode( MAP_INCH, aEmptyPoint, aFractX, aFractY );
 164             Size                aPrefSize = OutputDevice::LogicToLogic( aBitmapSize, aMapMode, MAP_100TH_MM );
 165             rGraphic.SetPrefSize( aPrefSize );
 166             rGraphic.SetPrefMapMode( MapMode( MAP_100TH_MM ) );
 167         }
 168     }
 169     else
 170         mbStatus = FALSE;
 171     if ( mpWriteAcc )
 172         maBmp.ReleaseAccess( mpWriteAcc );
 173     if ( mpReadAcc )
 174         maBmp.ReleaseAccess( mpReadAcc );
 175     if ( mpMaskWriteAcc )
 176         maMaskBmp.ReleaseAccess( mpMaskWriteAcc );
 177     return mbStatus;
 178 }
 179
 180 // ------------------------------------------------------------------------
 181
 182 BOOL PSDReader::ImplReadHeader()
 183 {
 184     UINT16      nCompression;
 185     UINT32      nColorLength, nResourceLength, nLayerMaskLength;
 186
 187     mpFileHeader = new PSDFileHeader;
 188
 189     if ( !mpFileHeader )
 190         return FALSE;
 191
 192     *mpPSD >> mpFileHeader->nSignature >> mpFileHeader->nVersion >> mpFileHeader->nPad1 >>
 193         mpFileHeader->nPad2 >> mpFileHeader->nChannels >> mpFileHeader->nRows >>
 194             mpFileHeader->nColumns >> mpFileHeader->nDepth >> mpFileHeader->nMode;
 195
 196     if ( ( mpFileHeader->nSignature != 0x38425053 ) || ( mpFileHeader->nVersion != 1 ) )
 197         return FALSE;
 198
 199     if ( mpFileHeader->nRows == 0 || mpFileHeader->nColumns == 0 )
 200         return FALSE;
 201
 202     if ( ( mpFileHeader->nRows > 30000 ) || ( mpFileHeader->nColumns > 30000 ) )
 203         return FALSE;
 204
 205     UINT16 nDepth = mpFileHeader->nDepth;
 206     if (!( ( nDepth == 1 ) || ( nDepth == 8 ) || ( nDepth == 16 ) ) )
 207         return FALSE;
 208
 209     mnDestBitDepth = ( nDepth == 16 ) ? 8 : nDepth;
 210
 211     *mpPSD >> nColorLength;
 212     if ( mpFileHeader->nMode == PSD_CMYK )
 213     {
 214         switch ( mpFileHeader->nChannels )
 215         {
 216             case 5 :
 217                 mbTransparent = TRUE;
 218             case 4 :
 219                 mnDestBitDepth = 24;
 220             break;
 221             default :
 222                 return FALSE;
 223         }
 224     }
 225     else switch ( mpFileHeader->nChannels )
 226     {
 227         case 2 :
 228             mbTransparent = TRUE;
 229         case 1 :
 230             break;
 231         case 4 :
 232             mbTransparent = TRUE;
 233         case 3 :
 234             mnDestBitDepth = 24;
 235             break;
 236         default:
 237             return FALSE;
 238     }
 239
 240     switch ( mpFileHeader->nMode )
 241     {
 242         case PSD_BITMAP :
 243         {
 244             if ( nColorLength || ( nDepth != 1 ) )
 245                 return FALSE;
 246         }
 247         break;
 248
 249         case PSD_INDEXED :
 250         {
 251             if ( nColorLength != 768 )          // we need the color map
 252                 return FALSE;
 253             mpPalette = new BYTE[ 768 ];
 254             if ( mpPalette == NULL )
 255                 return FALSE;
 256             mpPSD->Read( mpPalette, 768 );
 257         }
 258         break;
 259
 260         case PSD_DUOTONE :                                      // we'll handle the doutone color like a normal grayscale picture
 261             mpPSD->SeekRel( nColorLength );
 262             nColorLength = 0;
 263         case PSD_GRAYSCALE :
 264         {
 265             if ( nColorLength )
 266                 return FALSE;
 267             mpPalette = new BYTE[ 768 ];
 268             if ( mpPalette == NULL )
 269                 return FALSE;
 270             for ( USHORT i = 0; i < 256; i++ )
 271             {
 272                 mpPalette[ i ] = mpPalette[ i + 256 ] = mpPalette[ i + 512 ] = (BYTE)i;
 273             }
 274         }
 275         break;
 276
 277         case PSD_CMYK :
 278         case PSD_RGB :
 279         case PSD_MULTICHANNEL :
 280         case PSD_LAB :
 281         {
 282             if ( nColorLength )         // color table is not supported by the other graphic modes
 283                 return FALSE;
 284         }
 285         break;
 286
 287         default:
 288             return FALSE;
 289     }
 290     *mpPSD >> nResourceLength;
 291     sal_uInt32 nLayerPos = mpPSD->Tell() + nResourceLength;
 292
 293     // this is a loop over the resource entries to get the resolution info
 294     while( mpPSD->Tell() < nLayerPos )
 295     {
 296         sal_uInt8 n8;
 297         sal_uInt32 nType, nPStringLen, nResEntryLen;
 298         sal_uInt16 nUniqueID;
 299
 300         *mpPSD >> nType >> nUniqueID >> n8;
 301         nPStringLen = n8;
 302         if ( nType != 0x3842494d )
 303             break;
 304         if ( ! ( nPStringLen & 1 ) )
 305             nPStringLen++;
 306         mpPSD->SeekRel( nPStringLen );  // skipping the pstring
 307         *mpPSD >> nResEntryLen;
 308         if ( nResEntryLen & 1 )
 309             nResEntryLen++;             // the resource entries are padded
 310         sal_uInt32 nCurrentPos = mpPSD->Tell();
 311         if ( ( nResEntryLen + nCurrentPos ) > nLayerPos )   // check if size
 312             break;                                          // is possible
 313         switch( nUniqueID )
 314         {
 315             case 0x3ed :    // UID for the resolution info
 316             {
 317                 sal_Int16   nUnit;
 318
 319                 *mpPSD >> mnXResFixed >> nUnit >> nUnit
 320                        >> mnYResFixed >> nUnit >> nUnit;
 321             }
 322             break;
 323         }
 324         mpPSD->Seek( nCurrentPos + nResEntryLen );          // set the stream to the next
 325     }                                                       // resource entry
 326     mpPSD->Seek( nLayerPos );
 327     *mpPSD >> nLayerMaskLength;
 328     mpPSD->SeekRel( nLayerMaskLength );
 329
 330     *mpPSD >> nCompression;
 331     if ( nCompression == 0 )
 332     {
 333         mbCompression = FALSE;
 334     }
 335     else if ( nCompression == 1 )
 336     {
 337         mpPSD->SeekRel( ( mpFileHeader->nRows * mpFileHeader->nChannels ) << 1 );
 338         mbCompression = TRUE;
 339     }
 340     else
 341         return FALSE;
 342
 343     return TRUE;
 344 }
 345
 346 // ------------------------------------------------------------------------
 347
 348 BOOL PSDReader::ImplReadBody()
 349 {
 350     ULONG               nX, nY;
 351     char                nRunCount = 0;
 352     signed char nBitCount = -1;
 353     BYTE                nDat = 0, nDummy, nRed, nGreen, nBlue;
 354     BitmapColor aBitmapColor;
 355     nX = nY = 0;
 356
 357     switch ( mnDestBitDepth )
 358     {
 359         case 1 :
 360         {
 361             while ( nY < mpFileHeader->nRows )
 362             {
 363                 if ( nBitCount == -1 )
 364                 {
 365                     if ( mbCompression )        // else nRunCount = 0 -> so we use only single raw packets
 366                         *mpPSD >> nRunCount;
 367                 }
 368                 if ( nRunCount & 0x80 )         // a run length packet
 369                 {
 370                     if ( nBitCount == -1 )      // bits left in nDat ?
 371                     {
 372                         *mpPSD >> nDat;
 373                         nDat ^= 0xff;
 374                         nBitCount = 7;
 375                     }
 376                     for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 377                     {
 378                         mpWriteAcc->SetPixel( nY, nX, (BYTE)nDat >> nBitCount-- );
 379                         if ( ++nX == mpFileHeader->nColumns )
 380                         {
 381                             nX = 0;
 382                             nY++;
 383                             nBitCount = -1;
 384                             if ( nY == mpFileHeader->nRows )
 385                                 break;
 386                         }
 387                     }
 388                 }
 389                 else                                            // a raw packet
 390                 {
 391                     for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 392                     {
 393                         if ( nBitCount == -1 )  // bits left in nDat ?
 394                         {
 395                             *mpPSD >> nDat;
 396                             nDat ^= 0xff;
 397                             nBitCount = 7;
 398                         }
 399                         mpWriteAcc->SetPixel( nY, nX, (BYTE)nDat >> nBitCount-- );
 400                         if ( ++nX == mpFileHeader->nColumns )
 401                         {
 402                             nX = 0;
 403                             nY++;
 404                             nBitCount = -1;
 405                             if ( nY == mpFileHeader->nRows )
 406                                 break;
 407                         }
 408                     }
 409                 }
 410             }
 411         }
 412         break;
 413
 414         case 8 :
 415         {
 416             while ( nY < mpFileHeader->nRows )
 417             {
 418                 if ( mbCompression )            // else nRunCount = 0 -> so we use only single raw packets
 419                     *mpPSD >> nRunCount;
 420
 421                 if ( nRunCount & 0x80 )         // a run length packet
 422                 {
 423                     *mpPSD >> nDat;
 424                     if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 425                         *mpPSD >> nDummy;
 426                     for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 427                     {
 428                         mpWriteAcc->SetPixel( nY, nX, (BYTE)nDat );
 429                         if ( ++nX == mpFileHeader->nColumns )
 430                         {
 431                             nX = 0;
 432                             nY++;
 433                             if ( nY == mpFileHeader->nRows )
 434                                 break;
 435                         }
 436                     }
 437                 }
 438                 else                                            // a raw packet
 439                 {
 440                     for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 441                     {
 442                         *mpPSD >> nDat;
 443                         if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 444                             *mpPSD >> nDummy;
 445                         mpWriteAcc->SetPixel( nY, nX, (BYTE)nDat );
 446                         if ( ++nX == mpFileHeader->nColumns )
 447                         {
 448                             nX = 0;
 449                             nY++;
 450                             if ( nY == mpFileHeader->nRows )
 451                                 break;
 452                         }
 453                     }
 454                 }
 455             }
 456         }
 457         break;
 458
 459         case 24 :
 460         {
 461
 462             // the psd format is in plain order (RRRR GGGG BBBB) so we have to set each pixel three times
 463             // maybe the format is CCCC MMMM YYYY KKKK
 464
 465             while ( nY < mpFileHeader->nRows )
 466             {
 467                 if ( mbCompression )            // else nRunCount = 0 -> so we use only single raw packets
 468                     *mpPSD >> nRunCount;
 469
 470                 if ( nRunCount & 0x80 )         // a run length packet
 471                 {
 472                     *mpPSD >> nRed;
 473                     if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 474                         *mpPSD >> nDummy;
 475                     for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 476                     {
 477                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (BYTE)0, (BYTE)0 ) );
 478                         if ( ++nX == mpFileHeader->nColumns )
 479                         {
 480                             nX = 0;
 481                             nY++;
 482                             if ( nY == mpFileHeader->nRows )
 483                                 break;
 484                         }
 485                     }
 486                 }
 487                 else                                            // a raw packet
 488                 {
 489                     for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 490                     {
 491                         *mpPSD >> nRed;
 492                         if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 493                             *mpPSD >> nDummy;
 494                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (BYTE)0, (BYTE)0 ) );
 495                         if ( ++nX == mpFileHeader->nColumns )
 496                         {
 497                             nX = 0;
 498                             nY++;
 499                             if ( nY == mpFileHeader->nRows )
 500                                 break;
 501                         }
 502                     }
 503                 }
 504             }
 505             nY = 0;
 506             while ( nY < mpFileHeader->nRows )
 507             {
 508                 if ( mbCompression )
 509                     *mpPSD >> nRunCount;
 510                 if ( nRunCount & 0x80 )         // a run length packet
 511                 {
 512                     *mpPSD >> nGreen;
 513                     if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 514                         *mpPSD >> nDummy;
 515                     for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 516                     {
 517                         aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 518                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
 519                         if ( ++nX == mpFileHeader->nColumns )
 520                         {
 521                             nX = 0;
 522                             nY++;
 523                             if ( nY == mpFileHeader->nRows )
 524                                 break;
 525                         }
 526                     }
 527                 }
 528                 else                                            // a raw packet
 529                 {
 530                     for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 531                     {
 532                         *mpPSD >> nGreen;
 533                         if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 534                             *mpPSD >> nDummy;
 535                         aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 536                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
 537                         if ( ++nX == mpFileHeader->nColumns )
 538                         {
 539                             nX = 0;
 540                             nY++;
 541                             if ( nY == mpFileHeader->nRows )
 542                                 break;
 543                         }
 544                     }
 545                 }
 546             }
 547             nY = 0;
 548             while ( nY < mpFileHeader->nRows )
 549             {
 550                 if ( mbCompression )
 551                     *mpPSD >> nRunCount;
 552                 if ( nRunCount & 0x80 )         // a run length packet
 553                 {
 554                     *mpPSD >> nBlue;
 555                     if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 556                         *mpPSD >> nDummy;
 557                     for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 558                     {
 559                         aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 560                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
 561                         if ( ++nX == mpFileHeader->nColumns )
 562                         {
 563                             nX = 0;
 564                             nY++;
 565                             if ( nY == mpFileHeader->nRows )
 566                                 break;
 567                         }
 568                     }
 569                 }
 570                 else                                            // a raw packet
 571                 {
 572                     for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 573                     {
 574                         *mpPSD >> nBlue;
 575                         if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 576                             *mpPSD >> nDummy;
 577                         aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 578                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
 579                         if ( ++nX == mpFileHeader->nColumns )
 580                         {
 581                             nX = 0;
 582                             nY++;
 583                             if ( nY == mpFileHeader->nRows )
 584                                 break;
 585                         }
 586                     }
 587                 }
 588             }
 589             if ( mpFileHeader->nMode == PSD_CMYK )
 590             {
 591                 UINT32  nBlack, nBlackMax = 0;
 592                 BYTE*   pBlack = new BYTE[ mpFileHeader->nRows * mpFileHeader->nColumns ];
 593                 nY = 0;
 594                 while ( nY < mpFileHeader->nRows )
 595                 {
 596                     if ( mbCompression )                // else nRunCount = 0 -> so we use only single raw packets
 597                         *mpPSD >> nRunCount;
 598
 599                     if ( nRunCount & 0x80 )     // a run length packet
 600                     {
 601                         *mpPSD >> nDat;
 602
 603                         if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 604                             *mpPSD >> nDummy;
 605
 606                         for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 607                         {
 608                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
 609                             if ( nBlack > nBlackMax )
 610                                 nBlackMax = nBlack;
 611                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
 612                             if ( nBlack > nBlackMax )
 613                                 nBlackMax = nBlack;
 614                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
 615                             if ( nBlack > nBlackMax )
 616                                 nBlackMax = nBlack;
 617                             pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
 618                             if ( ++nX == mpFileHeader->nColumns )
 619                             {
 620                                 nX = 0;
 621                                 nY++;
 622                             if ( nY == mpFileHeader->nRows )
 623                                 break;
 624                             }
 625                         }
 626                     }
 627                     else                                                // a raw packet
 628                     {
 629                         for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 630                         {
 631                             *mpPSD >> nDat;
 632
 633                             if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 634                                 *mpPSD >> nDummy;
 635                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
 636                             if ( nBlack > nBlackMax )
 637                                 nBlackMax = nBlack;
 638                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
 639                             if ( nBlack > nBlackMax )
 640                                 nBlackMax = nBlack;
 641                             nBlack = (BYTE)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
 642                             if ( nBlack > nBlackMax )
 643                                 nBlackMax = nBlack;
 644                             pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
 645                             if ( ++nX == mpFileHeader->nColumns )
 646                             {
 647                                 nX = 0;
 648                                 nY++;
 649                                 if ( nY == mpFileHeader->nRows )
 650                                     break;
 651                             }
 652                         }
 653                     }
 654                 }
 655
 656                 for ( nY = 0; nY < mpFileHeader->nRows; nY++ )
 657                 {
 658                     for ( nX = 0; nX < mpFileHeader->nColumns; nX++ )
 659                     {
 660                         INT32 nDAT = pBlack[ nX + nY * mpFileHeader->nColumns ] * ( nBlackMax - 256 ) / 0x1ff;
 661
 662                         aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 663                         BYTE cR = (BYTE) MinMax( aBitmapColor.GetRed() - nDAT, 0L, 255L );
 664                         BYTE cG = (BYTE) MinMax( aBitmapColor.GetGreen() - nDAT, 0L, 255L );
 665                         BYTE cB = (BYTE) MinMax( aBitmapColor.GetBlue() - nDAT, 0L, 255L );
 666                         mpWriteAcc->SetPixel( nY, nX, BitmapColor( cR, cG, cB ) );
 667                     }
 668                 }
 669                 delete[] pBlack;
 670             }
 671         }
 672         break;
 673     }
 674
 675     if ( mbTransparent )
 676     {
 677         // the psd is 24 or 8 bit grafix + alphachannel
 678
 679         nY = nX = 0;
 680         while ( nY < mpFileHeader->nRows )
 681         {
 682             if ( mbCompression )                // else nRunCount = 0 -> so we use only single raw packets
 683                 *mpPSD >> nRunCount;
 684
 685             if ( nRunCount & 0x80 )     // a run length packet
 686             {
 687                 *mpPSD >> nDat;
 688                 if ( nDat )
 689                     nDat = 0;
 690                 else
 691                     nDat = 1;
 692                 if ( mpFileHeader->nDepth == 16 )       // 16 bit depth is to be skipped
 693                     *mpPSD >> nDummy;
 694                 for ( USHORT i = 0; i < ( -nRunCount + 1 ); i++ )
 695                 {
 696                     mpMaskWriteAcc->SetPixel( nY, nX, (BYTE)nDat );
 697                     if ( ++nX == mpFileHeader->nColumns )
 698                     {
 699                         nX = 0;
 700                         nY++;
 701                         if ( nY == mpFileHeader->nRows )
 702                             break;
 703                     }
 704                 }
 705             }
 706             else                                                // a raw packet
 707             {
 708                 for ( USHORT i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 709                 {
 710                     *mpPSD >> nDat;
 711                     if ( nDat )
 712                         nDat = 0;
 713                     else
 714                         nDat = 1;
 715                     if ( mpFileHeader->nDepth == 16 )   // 16 bit depth is to be skipped
 716                         *mpPSD >> nDummy;
 717                     mpMaskWriteAcc->SetPixel( nY, nX, (BYTE)nDat );
 718                     if ( ++nX == mpFileHeader->nColumns )
 719                     {
 720                         nX = 0;
 721                         nY++;
 722                         if ( nY == mpFileHeader->nRows )
 723                             break;
 724                     }
 725                 }
 726             }
 727         }
 728     }
 729     return TRUE;
 730 }
 731
 732 //================== GraphicImport - die exportierte Funktion ================
 733
 734 extern "C" BOOL __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, BOOL )
 735 {
 736     PSDReader aPSDReader;
 737
 738     return aPSDReader.ReadPSD( rStream, rGraphic );
 739 }
 740
 741 //================== ein bischen Muell fuer Windows ==========================
 742 #ifndef GCC
 743 #endif
 744
 745 #ifdef WIN
 746
 747 static HINSTANCE hDLLInst = 0;          // HANDLE der DLL
 748
 749 extern "C" int CALLBACK LibMain( HINSTANCE hDLL, WORD, WORD nHeap, LPSTR )
 750 {
 751 #ifndef WNT
 752     if ( nHeap )
 753         UnlockData( 0 );
 754 #endif
 755
 756     hDLLInst = hDLL;
 757
 758     return TRUE;
 759 }
 760
 761 extern "C" int CALLBACK WEP( int )
 762 {
 763     return 1;
 764 }
 765
 766 #endif