vcl/unx/source/printergfx/bitmap_gfx.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: bitmap_gfx.cxx,v $
  10  * $Revision: 1.13 $
  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_vcl.hxx"
  33
  34 #include "psputil.hxx"
  35
  36 #include "vcl/printergfx.hxx"
  37 #include "vcl/strhelper.hxx"
  38
  39 namespace psp {
  40
  41 const sal_uInt32 nLineLength = 80;
  42 const sal_uInt32 nBufferSize = 16384;
  43
  44 /*
  45  *
  46  * Bitmap compression / Hex encoding / Ascii85 Encoding
  47  *
  48  */
  49
  50 PrinterBmp::~PrinterBmp ()
  51 { /* dont need this, but C50 does */ }
  52
  53 /* virtual base class */
  54
  55 class ByteEncoder
  56 {
  57 private:
  58
  59 public:
  60
  61     virtual void    EncodeByte (sal_uInt8 nByte) = 0;
  62     virtual         ~ByteEncoder () = 0;
  63 };
  64
  65 ByteEncoder::~ByteEncoder ()
  66 { /* dont need this, but the C50 does */ }
  67
  68 /* HexEncoder */
  69
  70 class HexEncoder : public ByteEncoder
  71 {
  72 private:
  73
  74     osl::File*      mpFile;
  75     sal_uInt32      mnColumn;
  76     sal_uInt32      mnOffset;
  77     sal_Char        mpFileBuffer[nBufferSize + 16];
  78
  79                     HexEncoder (); /* dont use */
  80
  81 public:
  82
  83     HexEncoder (osl::File* pFile);
  84     virtual         ~HexEncoder ();
  85     void            WriteAscii (sal_uInt8 nByte);
  86     virtual void    EncodeByte (sal_uInt8 nByte);
  87     void            FlushLine ();
  88 };
  89
  90 HexEncoder::HexEncoder (osl::File* pFile) :
  91         mpFile (pFile),
  92         mnColumn (0),
  93         mnOffset (0)
  94 {}
  95
  96 HexEncoder::~HexEncoder ()
  97 {
  98     FlushLine ();
  99     if (mnColumn > 0)
 100         WritePS (mpFile, "\n");
 101 }
 102
 103 void
 104 HexEncoder::WriteAscii (sal_uInt8 nByte)
 105 {
 106     sal_uInt32 nOff = psp::getHexValueOf (nByte, mpFileBuffer + mnOffset);
 107     mnColumn += nOff;
 108     mnOffset += nOff;
 109
 110     if (mnColumn >= nLineLength)
 111     {
 112         mnOffset += psp::appendStr ("\n", mpFileBuffer + mnOffset);
 113         mnColumn = 0;
 114     }
 115     if (mnOffset >= nBufferSize)
 116         FlushLine ();
 117 }
 118
 119 void
 120 HexEncoder::EncodeByte (sal_uInt8 nByte)
 121 {
 122     WriteAscii (nByte);
 123 }
 124
 125 void
 126 HexEncoder::FlushLine ()
 127 {
 128     if (mnOffset > 0)
 129     {
 130         WritePS (mpFile, mpFileBuffer, mnOffset);
 131         mnOffset = 0;
 132     }
 133 }
 134
 135 /* Ascii85 encoder, is abi compatible with HexEncoder but writes a ~> to
 136    indicate end of data EOD */
 137
 138 class Ascii85Encoder : public ByteEncoder
 139 {
 140 private:
 141
 142     osl::File*      mpFile;
 143     sal_uInt32      mnByte;
 144     sal_uInt8       mpByteBuffer[4];
 145
 146     sal_uInt32      mnColumn;
 147     sal_uInt32      mnOffset;
 148     sal_Char        mpFileBuffer[nBufferSize + 16];
 149
 150     Ascii85Encoder (); /* dont use */
 151
 152     inline void     PutByte (sal_uInt8 nByte);
 153     inline void     PutEOD ();
 154     void            ConvertToAscii85 ();
 155     void            FlushLine ();
 156
 157 public:
 158
 159     Ascii85Encoder (osl::File* pFile);
 160     virtual         ~Ascii85Encoder ();
 161     virtual void    EncodeByte (sal_uInt8 nByte);
 162     void            WriteAscii (sal_uInt8 nByte);
 163 };
 164
 165 Ascii85Encoder::Ascii85Encoder (osl::File* pFile) :
 166         mpFile (pFile),
 167         mnByte (0),
 168         mnColumn (0),
 169         mnOffset (0)
 170 {}
 171
 172 inline void
 173 Ascii85Encoder::PutByte (sal_uInt8 nByte)
 174 {
 175     mpByteBuffer [mnByte++] = nByte;
 176 }
 177
 178 inline void
 179 Ascii85Encoder::PutEOD ()
 180 {
 181     WritePS (mpFile, "~>\n");
 182 }
 183
 184 void
 185 Ascii85Encoder::ConvertToAscii85 ()
 186 {
 187     if (mnByte < 4)
 188         std::memset (mpByteBuffer + mnByte, 0, (4 - mnByte) * sizeof(sal_uInt8));
 189
 190     sal_uInt32 nByteValue =   mpByteBuffer[0] * 256 * 256 * 256
 191         + mpByteBuffer[1] * 256 * 256
 192         + mpByteBuffer[2] * 256
 193         + mpByteBuffer[3];
 194
 195     if (nByteValue == 0 && mnByte == 4)
 196     {
 197         /* special case of 4 Bytes in row */
 198         mpFileBuffer [mnOffset] = 'z';
 199
 200         mnOffset += 1;
 201         mnColumn += 1;
 202     }
 203     else
 204     {
 205         /* real ascii85 encoding */
 206         mpFileBuffer [mnOffset + 4] = (nByteValue % 85) + 33;
 207         nByteValue /= 85;
 208         mpFileBuffer [mnOffset + 3] = (nByteValue % 85) + 33;
 209         nByteValue /= 85;
 210         mpFileBuffer [mnOffset + 2] = (nByteValue % 85) + 33;
 211         nByteValue /= 85;
 212         mpFileBuffer [mnOffset + 1] = (nByteValue % 85) + 33;
 213         nByteValue /= 85;
 214         mpFileBuffer [mnOffset + 0] = (nByteValue % 85) + 33;
 215
 216         mnColumn += (mnByte + 1);
 217         mnOffset += (mnByte + 1);
 218
 219         /* insert a newline if necessary */
 220         if (mnColumn > nLineLength)
 221         {
 222             sal_uInt32 nEolOff = mnColumn - nLineLength;
 223             sal_uInt32 nBufOff = mnOffset - nEolOff;
 224
 225             std::memmove (mpFileBuffer + nBufOff + 1, mpFileBuffer + nBufOff, nEolOff);
 226             mpFileBuffer[ nBufOff ] = '\n';
 227
 228             mnOffset++;
 229             mnColumn = nEolOff;
 230         }
 231     }
 232
 233     mnByte = 0;
 234 }
 235
 236 void
 237 Ascii85Encoder::WriteAscii (sal_uInt8 nByte)
 238 {
 239     PutByte (nByte);
 240     if (mnByte == 4)
 241         ConvertToAscii85 ();
 242
 243     if (mnColumn >= nLineLength)
 244     {
 245         mnOffset += psp::appendStr ("\n", mpFileBuffer + mnOffset);
 246         mnColumn = 0;
 247     }
 248     if (mnOffset >= nBufferSize)
 249         FlushLine ();
 250 }
 251
 252 void
 253 Ascii85Encoder::EncodeByte (sal_uInt8 nByte)
 254 {
 255     WriteAscii (nByte);
 256 }
 257
 258 void
 259 Ascii85Encoder::FlushLine ()
 260 {
 261     if (mnOffset > 0)
 262     {
 263         WritePS (mpFile, mpFileBuffer, mnOffset);
 264         mnOffset = 0;
 265     }
 266 }
 267
 268 Ascii85Encoder::~Ascii85Encoder ()
 269 {
 270     if (mnByte > 0)
 271         ConvertToAscii85 ();
 272     if (mnOffset > 0)
 273         FlushLine ();
 274     PutEOD ();
 275 }
 276
 277 /* LZW encoder */
 278
 279 class LZWEncoder : public Ascii85Encoder
 280 {
 281 private:
 282
 283     struct LZWCTreeNode
 284     {
 285         LZWCTreeNode*   mpBrother;      // next node with same parent
 286         LZWCTreeNode*   mpFirstChild;   // first son
 287         sal_uInt16      mnCode;         // code for the string
 288         sal_uInt16      mnValue;        // pixelvalue
 289     };
 290
 291     LZWCTreeNode*   mpTable;    // LZW compression data
 292     LZWCTreeNode*   mpPrefix;   // the compression is as same as the TIFF compression
 293     sal_uInt16      mnDataSize;
 294     sal_uInt16      mnClearCode;
 295     sal_uInt16      mnEOICode;
 296     sal_uInt16      mnTableSize;
 297     sal_uInt16      mnCodeSize;
 298     sal_uInt32      mnOffset;
 299     sal_uInt32      mdwShift;
 300
 301     LZWEncoder ();
 302     void            WriteBits (sal_uInt16 nCode, sal_uInt16 nCodeLen);
 303
 304 public:
 305
 306     LZWEncoder (osl::File* pOutputFile);
 307     ~LZWEncoder ();
 308
 309     virtual void    EncodeByte (sal_uInt8 nByte);
 310 };
 311
 312 LZWEncoder::LZWEncoder(osl::File* pOutputFile) :
 313         Ascii85Encoder (pOutputFile)
 314 {
 315     mnDataSize  = 8;
 316
 317     mnClearCode = 1 << mnDataSize;
 318     mnEOICode   = mnClearCode + 1;
 319     mnTableSize = mnEOICode   + 1;
 320     mnCodeSize  = mnDataSize  + 1;
 321
 322     mnOffset    = 32;   // free bits in dwShift
 323     mdwShift    = 0;
 324
 325     mpTable = new LZWCTreeNode[ 4096 ];
 326
 327     for (sal_uInt32 i = 0; i < 4096; i++)
 328     {
 329         mpTable[i].mpBrother    = NULL;
 330         mpTable[i].mpFirstChild = NULL;
 331         mpTable[i].mnCode       = i;
 332         mpTable[i].mnValue      = (sal_uInt8)mpTable[i].mnCode;
 333     }
 334
 335     mpPrefix = NULL;
 336
 337     WriteBits( mnClearCode, mnCodeSize );
 338 }
 339
 340 LZWEncoder::~LZWEncoder()
 341 {
 342     if (mpPrefix)
 343         WriteBits (mpPrefix->mnCode, mnCodeSize);
 344
 345     WriteBits (mnEOICode, mnCodeSize);
 346
 347     delete[] mpTable;
 348 }
 349
 350 void
 351 LZWEncoder::WriteBits (sal_uInt16 nCode, sal_uInt16 nCodeLen)
 352 {
 353     mdwShift |= (nCode << (mnOffset - nCodeLen));
 354     mnOffset -= nCodeLen;
 355     while (mnOffset < 24)
 356     {
 357         WriteAscii ((sal_uInt8)(mdwShift >> 24));
 358         mdwShift <<= 8;
 359         mnOffset += 8;
 360     }
 361     if (nCode == 257 && mnOffset != 32)
 362         WriteAscii ((sal_uInt8)(mdwShift >> 24));
 363 }
 364
 365 void
 366 LZWEncoder::EncodeByte (sal_uInt8 nByte )
 367 {
 368     LZWCTreeNode*   p;
 369     sal_uInt16      i;
 370     sal_uInt8       nV;
 371
 372     if (!mpPrefix)
 373     {
 374         mpPrefix = mpTable + nByte;
 375     }
 376     else
 377     {
 378         nV = nByte;
 379         for (p = mpPrefix->mpFirstChild; p != NULL; p = p->mpBrother)
 380         {
 381             if (p->mnValue == nV)
 382                 break;
 383         }
 384
 385         if (p != NULL)
 386         {
 387             mpPrefix = p;
 388         }
 389         else
 390         {
 391             WriteBits (mpPrefix->mnCode, mnCodeSize);
 392
 393             if (mnTableSize == 409)
 394             {
 395                 WriteBits (mnClearCode, mnCodeSize);
 396
 397                 for (i = 0; i < mnClearCode; i++)
 398                     mpTable[i].mpFirstChild = NULL;
 399
 400                 mnCodeSize = mnDataSize + 1;
 401                 mnTableSize = mnEOICode + 1;
 402             }
 403             else
 404             {
 405                 if(mnTableSize == (sal_uInt16)((1 << mnCodeSize) - 1))
 406                     mnCodeSize++;
 407
 408                 p = mpTable + (mnTableSize++);
 409                 p->mpBrother = mpPrefix->mpFirstChild;
 410                 mpPrefix->mpFirstChild = p;
 411                 p->mnValue = nV;
 412                 p->mpFirstChild = NULL;
 413             }
 414
 415             mpPrefix = mpTable + nV;
 416         }
 417     }
 418 }
 419
 420 /*
 421  *
 422  * bitmap handling routines
 423  *
 424  */
 425
 426 void
 427 PrinterGfx::DrawBitmap (const Rectangle& rDest, const Rectangle& rSrc,
 428                         const PrinterBmp& rBitmap)
 429 {
 430     double fScaleX = (double)rDest.GetWidth() / (double)rSrc.GetWidth();
 431     double fScaleY = (double)rDest.GetHeight() / (double)rSrc.GetHeight();
 432
 433     PSGSave ();
 434     PSTranslate (rDest.BottomLeft());
 435     PSScale (fScaleX, fScaleY);
 436
 437     if (mnPSLevel >= 2)
 438     {
 439         if (rBitmap.GetDepth() == 1)
 440         {
 441             DrawPS2MonoImage (rBitmap, rSrc);
 442         }
 443         else
 444         if (rBitmap.GetDepth() ==  8 && mbColor)
 445         {
 446             // if the palette is larger than the image itself print it as a truecolor
 447             // image to save diskspace. This is important for printing transparent
 448             // bitmaps that are disassembled into small pieces
 449             sal_Int32 nImageSz   = rSrc.GetWidth() * rSrc.GetHeight();
 450             sal_Int32 nPaletteSz = rBitmap.GetPaletteEntryCount();
 451             if ((nImageSz < nPaletteSz) || (nImageSz < 24) )
 452                 DrawPS2TrueColorImage (rBitmap, rSrc);
 453             else
 454                 DrawPS2PaletteImage (rBitmap, rSrc);
 455         }
 456         else
 457         if (rBitmap.GetDepth() == 24 && mbColor)
 458         {
 459             DrawPS2TrueColorImage (rBitmap, rSrc);
 460         }
 461         else
 462         {
 463             DrawPS2GrayImage (rBitmap, rSrc);
 464         }
 465     }
 466     else
 467     {
 468         DrawPS1GrayImage (rBitmap, rSrc);
 469     }
 470
 471     PSGRestore ();
 472 }
 473
 474 /* XXX does not work XXX */
 475 void
 476 PrinterGfx::DrawBitmap (const Rectangle& rDest, const Rectangle& rSrc,
 477                         const PrinterBmp& /*rBitmap*/, const PrinterBmp& /*rTransBitmap*/)
 478 {
 479     double fScaleX = (double)rDest.GetWidth() / (double)rSrc.GetWidth();
 480     double fScaleY = (double)rDest.GetHeight() / (double)rSrc.GetHeight();
 481
 482     PSGSave ();
 483     PSTranslate (rDest.BottomLeft());
 484     PSScale (fScaleX, fScaleY);
 485     PSGRestore ();
 486 }
 487
 488 /* XXX does not work XXX */
 489 void
 490 PrinterGfx::DrawMask   (const Rectangle& rDest, const Rectangle& rSrc,
 491                         const PrinterBmp &/*rBitmap*/, PrinterColor& /*rMaskColor*/)
 492 {
 493     double fScaleX = (double)rDest.GetWidth() / (double)rSrc.GetWidth();
 494     double fScaleY = (double)rDest.GetHeight() / (double)rSrc.GetHeight();
 495
 496     PSGSave ();
 497     PSTranslate (rDest.BottomLeft());
 498     PSScale (fScaleX, fScaleY);
 499     PSGRestore ();
 500 }
 501
 502 /*
 503  *
 504  * Implementation: PS Level 1
 505  *
 506  */
 507
 508 void
 509 PrinterGfx::DrawPS1GrayImage (const PrinterBmp& rBitmap, const Rectangle& rArea)
 510 {
 511     sal_uInt32 nWidth  = rArea.GetWidth();
 512     sal_uInt32 nHeight = rArea.GetHeight();
 513
 514     sal_Char  pGrayImage [512];
 515     sal_Int32 nChar = 0;
 516
 517     // image header
 518     nChar += psp::getValueOf (nWidth,                           pGrayImage + nChar);
 519     nChar += psp::appendStr  (" ",                              pGrayImage + nChar);
 520     nChar += psp::getValueOf (nHeight,                          pGrayImage + nChar);
 521     nChar += psp::appendStr  (" 8 ",                            pGrayImage + nChar);
 522     nChar += psp::appendStr  ("[ 1 0 0 1 0 ",                   pGrayImage + nChar);
 523     nChar += psp::getValueOf (nHeight,                          pGrayImage + nChar);
 524     nChar += psp::appendStr  ("]",                              pGrayImage + nChar);
 525     nChar += psp::appendStr  (" {currentfile ",                 pGrayImage + nChar);
 526     nChar += psp::getValueOf (nWidth,                           pGrayImage + nChar);
 527     nChar += psp::appendStr  (" string readhexstring pop}\n",   pGrayImage + nChar);
 528     nChar += psp::appendStr  ("image\n",                        pGrayImage + nChar);
 529
 530     WritePS (mpPageBody, pGrayImage);
 531
 532     // image body
 533     HexEncoder* pEncoder = new HexEncoder (mpPageBody);
 534
 535     for (long nRow = rArea.Top(); nRow <= rArea.Bottom(); nRow++)
 536     {
 537         for (long nColumn = rArea.Left(); nColumn <= rArea.Right(); nColumn++)
 538         {
 539             sal_uChar nByte = rBitmap.GetPixelGray (nRow, nColumn);
 540             pEncoder->EncodeByte (nByte);
 541         }
 542     }
 543
 544     delete pEncoder;
 545
 546     WritePS (mpPageBody, "\n");
 547 }
 548
 549 /*
 550  *
 551  * Implementation: PS Level 2
 552  *
 553  */
 554
 555 void
 556 PrinterGfx::writePS2ImageHeader (const Rectangle& rArea, psp::ImageType nType)
 557 {
 558     sal_Int32 nChar = 0;
 559     sal_Char  pImage [512];
 560
 561     sal_Int32 nDictType = 0;
 562     switch (nType)
 563     {
 564         case psp::TrueColorImage:  nDictType = 0; break;
 565         case psp::PaletteImage:    nDictType = 1; break;
 566         case psp::GrayScaleImage:  nDictType = 2; break;
 567         case psp::MonochromeImage: nDictType = 3; break;
 568         default: break;
 569     }
 570     sal_Int32 nCompressType = mbCompressBmp ? 1 : 0;
 571
 572     nChar += psp::getValueOf (rArea.GetWidth(),  pImage + nChar);
 573     nChar += psp::appendStr  (" ",               pImage + nChar);
 574     nChar += psp::getValueOf (rArea.GetHeight(), pImage + nChar);
 575     nChar += psp::appendStr  (" ",               pImage + nChar);
 576     nChar += psp::getValueOf (nDictType,         pImage + nChar);
 577     nChar += psp::appendStr  (" ",               pImage + nChar);
 578     nChar += psp::getValueOf (nCompressType,     pImage + nChar);
 579     nChar += psp::appendStr  (" psp_imagedict image\n", pImage + nChar);
 580
 581     WritePS (mpPageBody, pImage);
 582 }
 583
 584 void
 585 PrinterGfx::writePS2Colorspace(const PrinterBmp& rBitmap, psp::ImageType nType)
 586 {
 587     switch (nType)
 588     {
 589         case psp::GrayScaleImage:
 590
 591             WritePS (mpPageBody, "/DeviceGray setcolorspace\n");
 592             break;
 593
 594         case psp::TrueColorImage:
 595
 596             WritePS (mpPageBody, "/DeviceRGB setcolorspace\n");
 597             break;
 598
 599         case psp::MonochromeImage:
 600         case psp::PaletteImage:
 601         {
 602
 603             sal_Int32 nChar = 0;
 604             sal_Char  pImage [4096];
 605
 606             const sal_uInt32 nSize = rBitmap.GetPaletteEntryCount();
 607
 608             nChar += psp::appendStr ("[/Indexed /DeviceRGB ", pImage + nChar);
 609             nChar += psp::getValueOf (nSize - 1, pImage + nChar);
 610             if (mbCompressBmp)
 611                 nChar += psp::appendStr ("\npsp_lzwstring\n", pImage + nChar);
 612             else
 613                 nChar += psp::appendStr ("\npsp_ascii85string\n", pImage + nChar);
 614             WritePS (mpPageBody, pImage);
 615
 616             ByteEncoder* pEncoder = mbCompressBmp ? new LZWEncoder(mpPageBody)
 617                                                   : new Ascii85Encoder(mpPageBody);
 618             for (sal_uInt32 i = 0; i < nSize; i++)
 619             {
 620                 PrinterColor aColor = rBitmap.GetPaletteColor(i);
 621
 622                 pEncoder->EncodeByte (aColor.GetRed());
 623                 pEncoder->EncodeByte (aColor.GetGreen());
 624                 pEncoder->EncodeByte (aColor.GetBlue());
 625             }
 626             delete pEncoder;
 627
 628             WritePS (mpPageBody, "pop ] setcolorspace\n");
 629         }
 630         break;
 631         default: break;
 632     }
 633 }
 634
 635 void
 636 PrinterGfx::DrawPS2GrayImage (const PrinterBmp& rBitmap, const Rectangle& rArea)
 637 {
 638     writePS2Colorspace(rBitmap, psp::GrayScaleImage);
 639     writePS2ImageHeader(rArea, psp::GrayScaleImage);
 640
 641     ByteEncoder* pEncoder = mbCompressBmp ? new LZWEncoder(mpPageBody)
 642                                           : new Ascii85Encoder(mpPageBody);
 643
 644     for (long nRow = rArea.Top(); nRow <= rArea.Bottom(); nRow++)
 645     {
 646         for (long nColumn = rArea.Left(); nColumn <= rArea.Right(); nColumn++)
 647         {
 648             sal_uChar nByte = rBitmap.GetPixelGray (nRow, nColumn);
 649             pEncoder->EncodeByte (nByte);
 650         }
 651     }
 652
 653     delete pEncoder;
 654 }
 655
 656 void
 657 PrinterGfx::DrawPS2MonoImage (const PrinterBmp& rBitmap, const Rectangle& rArea)
 658 {
 659     writePS2Colorspace(rBitmap, psp::MonochromeImage);
 660     writePS2ImageHeader(rArea, psp::MonochromeImage);
 661
 662     ByteEncoder* pEncoder = mbCompressBmp ? new LZWEncoder(mpPageBody)
 663                                           : new Ascii85Encoder(mpPageBody);
 664
 665     for (long nRow = rArea.Top(); nRow <= rArea.Bottom(); nRow++)
 666     {
 667         long      nBitPos = 0;
 668         sal_uChar nBit    = 0;
 669         sal_uChar nByte   = 0;
 670
 671         for (long nColumn = rArea.Left(); nColumn <= rArea.Right(); nColumn++)
 672         {
 673             nBit   = rBitmap.GetPixelIdx (nRow, nColumn);
 674             nByte |= nBit << (7 - nBitPos);
 675
 676             if (++nBitPos == 8)
 677             {
 678                 pEncoder->EncodeByte (nByte);
 679                 nBitPos = 0;
 680                 nByte   = 0;
 681             }
 682         }
 683         // keep the row byte aligned
 684         if (nBitPos != 0)
 685             pEncoder->EncodeByte (nByte);
 686     }
 687
 688     delete pEncoder;
 689 }
 690
 691 void
 692 PrinterGfx::DrawPS2PaletteImage (const PrinterBmp& rBitmap, const Rectangle& rArea)
 693 {
 694     writePS2Colorspace(rBitmap, psp::PaletteImage);
 695     writePS2ImageHeader(rArea, psp::PaletteImage);
 696
 697     ByteEncoder* pEncoder = mbCompressBmp ? new LZWEncoder(mpPageBody)
 698                                           : new Ascii85Encoder(mpPageBody);
 699
 700     for (long nRow = rArea.Top(); nRow <= rArea.Bottom(); nRow++)
 701     {
 702         for (long nColumn = rArea.Left(); nColumn <= rArea.Right(); nColumn++)
 703         {
 704             sal_uChar nByte = rBitmap.GetPixelIdx (nRow, nColumn);
 705             pEncoder->EncodeByte (nByte);
 706         }
 707     }
 708
 709     delete pEncoder;
 710 }
 711
 712 void
 713 PrinterGfx::DrawPS2TrueColorImage (const PrinterBmp& rBitmap, const Rectangle& rArea)
 714 {
 715     writePS2Colorspace(rBitmap, psp::TrueColorImage);
 716     writePS2ImageHeader(rArea, psp::TrueColorImage);
 717
 718     ByteEncoder* pEncoder = mbCompressBmp ? new LZWEncoder(mpPageBody)
 719                                           : new Ascii85Encoder(mpPageBody);
 720
 721     for (long nRow = rArea.Top(); nRow <= rArea.Bottom(); nRow++)
 722     {
 723         for (long nColumn = rArea.Left(); nColumn <= rArea.Right(); nColumn++)
 724         {
 725             PrinterColor aColor = rBitmap.GetPixelRGB (nRow, nColumn);
 726             pEncoder->EncodeByte (aColor.GetRed());
 727             pEncoder->EncodeByte (aColor.GetGreen());
 728             pEncoder->EncodeByte (aColor.GetBlue());
 729         }
 730     }
 731
 732     delete pEncoder;
 733 }
 734
 735 } /* namespace psp */