prnt/hpcups/LJJetReady.cpp

   1 /*****************************************************************************\
   2   LJJetReady.cpp : Implementation of LJJetReady class
   3
   4   Copyright (c) 1996 - 2009, Hewlett-Packard Co.
   5   All rights reserved.
   6
   7   Redistribution and use in source and binary forms, with or without
   8   modification, are permitted provided that the following conditions
   9   are met:
  10   1. Redistributions of source code must retain the above copyright
  11      notice, this list of conditions and the following disclaimer.
  12   2. Redistributions in binary form must reproduce the above copyright
  13      notice, this list of conditions and the following disclaimer in the
  14      documentation and/or other materials provided with the distribution.
  15   3. Neither the name of Hewlett-Packard nor the names of its
  16      contributors may be used to endorse or promote products derived
  17      from this software without specific prior written permission.
  18
  19   THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  20   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  22   NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  24   TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  25   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  26   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 \*****************************************************************************/
  30
  31 #include "Encapsulator.h"
  32 #include "ModeJpeg.h"
  33 #include "LJJetReady.h"
  34 #include "PrinterCommands.h"
  35
  36 #define MOJAVE_STRIP_HEIGHT 128
  37
  38 LJJetReady::LJJetReady() : Encapsulator()
  39 {
  40     m_eCompressMode = COMPRESS_MODE_JPEG;
  41     memset(&m_QTableInfo, 0, sizeof(m_QTableInfo));
  42 }
  43
  44 LJJetReady::~LJJetReady()
  45 {
  46 }
  47
  48 DRIVER_ERROR LJJetReady::addJobSettings()
  49 {
  50     DRIVER_ERROR    err;
  51     addToHeader("@PJL SET STRINGCODESET=UTF8\012");
  52     addToHeader("@PJL SET COPIES=1\012");
  53     if (m_pJA->color_mode != 0)
  54     {
  55         addToHeader("@PJL SET PLANESINUSE=1\012");
  56     }
  57     if (m_pJA->e_duplex_mode != DUPLEXMODE_NONE)
  58     {
  59         addToHeader("@PJL SET DUPLEX=ON\012@PJL SET BINDING=%s\012",
  60                     m_pJA->e_duplex_mode == DUPLEXMODE_BOOK ? "LONGEDGE" : "SHORTEDGE");
  61     }
  62     addToHeader("@PJL SET RESOLUTION=600\012");
  63     addToHeader("@PJL SET TIMEOUT=90\012");
  64     addToHeader("@PJL ENTER LANGUAGE=PCLXL\012");
  65     addToHeader(") HP-PCL XL;3;0;Comment, PCL-XL JetReady generator\012");
  66     addToHeader(JRBeginSessionSeq, (int) sizeof(JRBeginSessionSeq));
  67     err = Cleanup();
  68     return err;
  69 }
  70
  71 DRIVER_ERROR LJJetReady::Configure(Pipeline **pipeline)
  72 {
  73     Pipeline    *head;
  74     ModeJpeg    *pModeJpeg;
  75     pModeJpeg = new ModeJpeg(((m_pMA->printable_width + 31) / 32) * 32);
  76     if (pModeJpeg == NULL)
  77     {
  78         return ALLOCMEM_ERROR;
  79     }
  80
  81     m_eCompressMode = m_pQA->print_quality == 1 ? COMPRESS_MODE_LJ : COMPRESS_MODE_JPEG;
  82     pModeJpeg->myplane = COLORTYPE_COLOR;
  83     m_QTableInfo.qFactor = 6;
  84     pModeJpeg->Init(m_pJA->color_mode, MOJAVE_STRIP_HEIGHT, &m_eCompressMode, &m_QTableInfo);
  85     head = new Pipeline(pModeJpeg);
  86     *pipeline = head;
  87     return NO_ERROR;
  88 }
  89
  90 DRIVER_ERROR LJJetReady::StartPage(JobAttributes *pJA)
  91 {
  92     DRIVER_ERROR    err;
  93     BYTE            JRPaperSizeSeq[] = {0xC0, 0x00, 0xF8, 0x25};
  94     BYTE            szCustomSize[16];
  95     m_iStripHeight = 0;
  96     if (m_eCompressMode != COMPRESS_MODE_LJ)
  97         m_bSendQTable = true;
  98     addToHeader((const BYTE *) JRFeedOrientationSeq, sizeof(JRFeedOrientationSeq));
  99     if (pJA->media_attributes.pcl_id == 96) // Custom paper size
 100     {
 101
 102         union
 103         {
 104             float       fValue;
 105             uint32_t    uiValue;
 106         } JRCustomPaperSize;
 107         uint32_t    uiXsize;
 108         uint32_t    uiYsize;
 109         int         k = 0;
 110
 111         // Physical width and height in inches
 112         JRCustomPaperSize.fValue = (float) pJA->media_attributes.physical_width / (float) pJA->quality_attributes.horizontal_resolution;
 113         uiXsize = JRCustomPaperSize.uiValue;
 114         JRCustomPaperSize.fValue = (float) pJA->media_attributes.physical_height / (float) pJA->quality_attributes.vertical_resolution;;
 115         uiYsize = JRCustomPaperSize.uiValue;
 116         szCustomSize[k++] = 0xD5;
 117         szCustomSize[k++] = (BYTE) (uiXsize & 0x000000FF);
 118         szCustomSize[k++] = (BYTE) ((uiXsize & 0x0000FF00) >> 8);
 119         szCustomSize[k++] = (BYTE) ((uiXsize & 0x00FF0000) >> 16);
 120         szCustomSize[k++] = (BYTE) ((uiXsize & 0xFF000000) >> 24);
 121         szCustomSize[k++] = (BYTE) (uiYsize & 0x000000FF);
 122         szCustomSize[k++] = (BYTE) ((uiYsize & 0x0000FF00) >> 8);
 123         szCustomSize[k++] = (BYTE) ((uiYsize & 0x00FF0000) >> 16);
 124         szCustomSize[k++] = (BYTE) ((uiYsize & 0xFF000000) >> 24);
 125         addToHeader((const BYTE *) szCustomSize, k);
 126         addToHeader(JRCustomPaperSizeSeq, sizeof(JRCustomPaperSizeSeq));
 127     }
 128     else
 129     {
 130         JRPaperSizeSeq[1] = pJA->media_attributes.pcl_id;
 131         addToHeader((const BYTE *) JRPaperSizeSeq, sizeof(JRPaperSizeSeq));
 132     }
 133     BYTE    szPrintableAreaSeq[] = {0xD1, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x74};
 134     int     iWidth = pJA->media_attributes.printable_width;
 135     int     iHeight = pJA->media_attributes.printable_height;
 136
 137 //  The minimum printable width is 1600 pixels (3 inch * 600 - 200 for margins)
 138     if (iWidth < 1600)
 139     {
 140         iWidth = 1600;
 141     }
 142 //  The source width must be a mutiple of 32
 143     iWidth = ((iWidth + 31) / 32) * 32;
 144     iHeight = ((iHeight + (MOJAVE_STRIP_HEIGHT - 1)) / MOJAVE_STRIP_HEIGHT) * MOJAVE_STRIP_HEIGHT;
 145     szPrintableAreaSeq[1] = (BYTE) (iWidth & 0xFF);
 146     szPrintableAreaSeq[2] = (BYTE) ((iWidth >> 8) & 0xFF);
 147     szPrintableAreaSeq[3] = (BYTE) (iHeight & 0xFF);
 148     szPrintableAreaSeq[4] = (BYTE) ((iHeight >> 8) & 0xFF);
 149     addToHeader((const BYTE *) szPrintableAreaSeq, sizeof(szPrintableAreaSeq));
 150
 151     addToHeader(JRBeginPageSeq, sizeof(JRBeginPageSeq));
 152
 153 //  Colormode must be 0 - color and 1 - grayscale
 154     BYTE szColorModeSeq[] = {0xC0, 0x06, 0xF8, 0x03, 0x6A};
 155     szColorModeSeq[1] += pJA->color_mode;
 156     addToHeader((const BYTE *) szColorModeSeq, sizeof(szColorModeSeq));
 157     err = Cleanup();
 158
 159     BYTE    szStr[16];
 160     addToHeader(JRBeginImageSeq, sizeof(JRBeginImageSeq));
 161     szStr[0] = (BYTE) (iWidth & 0xFF);
 162     szStr[1] = (BYTE) ((iWidth & 0xFF00) >> 8);
 163     szStr[2] = 0xF8;
 164     szStr[3] = 0x6C;
 165     szStr[4] = 0xC1;
 166     szStr[5] = (BYTE) (iHeight & 0xFF);
 167     szStr[6] = (BYTE) ((iHeight & 0xFF00) >> 8);
 168     szStr[7] = 0xF8;
 169     szStr[8] = 0x6B;
 170     szStr[9] = 0xC1;
 171     addToHeader((const BYTE *) szStr, 10);
 172     unsigned int uiStripCount = iHeight / MOJAVE_STRIP_HEIGHT;
 173     szStr[0] = (BYTE) (uiStripCount & 0xFF);
 174     szStr[1] = (BYTE) ((uiStripCount & 0xFF00) >> 8);
 175     szStr[2] = 0xF8;
 176     szStr[3] = 0x93;
 177     szStr[4] = 0xC1;
 178     addToHeader((const BYTE *) szStr, 5);
 179     const BYTE szStripHeightSeq[] = {0x80, 0x00, 0xF8, 0x94};
 180     addToHeader(szStripHeightSeq, sizeof(szStripHeightSeq));
 181     szStr[0] = 0xC0;
 182     szStr[1] = 0x00;
 183     szStr[2] = 0xF8;
 184     szStr[3] = 0x97;
 185     if (m_pJA->color_mode == 0)
 186     {
 187         szStr[1] = 0x04;
 188     }
 189     addToHeader((const BYTE *) szStr, 4);
 190 //  Interleaved Color Enumeration sequence
 191     addToHeader(JRICESeq, sizeof(JRICESeq));
 192     addToHeader(JRVueVersionTagSeq, sizeof(JRVueVersionTagSeq));
 193     BYTE szDataLengthSeq[] = {0xC2, 0x38, 0x03, 0x00, 0x00, 0xF8, 0x92, 0x46};
 194     if (m_eCompressMode == COMPRESS_MODE_LJ)
 195     {
 196         szDataLengthSeq[1] = 0;
 197         szDataLengthSeq[2] = 0;
 198     }
 199     addToHeader(szDataLengthSeq, sizeof(szDataLengthSeq));
 200     err = Cleanup();
 201     return err;
 202 }
 203
 204 DRIVER_ERROR LJJetReady::FormFeed()
 205 {
 206     DRIVER_ERROR    err;
 207     addToHeader(JRVueExtn3Seq, sizeof(JRVueExtn3Seq));
 208     addToHeader(JRVueVersionTagSeq, sizeof(JRVueVersionTagSeq));
 209     addToHeader(JRVendorUniqueSeq, sizeof(JRVendorUniqueSeq));
 210     addToHeader(JREndPageSeq, sizeof(JREndPageSeq));
 211     err = Cleanup();
 212     return err;
 213 }
 214
 215 DRIVER_ERROR LJJetReady::EndJob()
 216 {
 217     DRIVER_ERROR    err;
 218     addToHeader(JREndSessionSeq, sizeof(JREndSessionSeq));
 219     addToHeader((const BYTE *) PJLExit, strlen(PJLExit));
 220     err = Cleanup();
 221     return err;
 222 }
 223
 224 DRIVER_ERROR LJJetReady::Encapsulate(RASTERDATA *InputRaster, bool bLastPlane)
 225 {
 226     DRIVER_ERROR    err;
 227     int             iJpegHeaderSize = 623;
 228     unsigned int    ulVuDataLength;
 229     BYTE            *pDataPtr;
 230
 231     if (m_eCompressMode != COMPRESS_MODE_LJ)
 232     {
 233         err = sendJPEGHeaderInfo(InputRaster);
 234     }
 235
 236     if (m_pJA->color_mode != 0 || m_eCompressMode == COMPRESS_MODE_LJ)
 237         iJpegHeaderSize = 0;
 238
 239     if (InputRaster->rasterdata[COLORTYPE_COLOR] == NULL)
 240     {
 241         return NO_ERROR;
 242     }
 243
 244     ulVuDataLength = InputRaster->rastersize[COLORTYPE_COLOR] - iJpegHeaderSize;
 245     pDataPtr       = InputRaster->rasterdata[COLORTYPE_COLOR] + iJpegHeaderSize;
 246     BYTE    szStr[16];
 247     szStr[0] = m_iStripHeight & 0xFF;
 248     szStr[1] = (m_iStripHeight & 0xFF00) >> 8;
 249     m_iStripHeight += MOJAVE_STRIP_HEIGHT;
 250     addToHeader(JRReadImageSeq, sizeof(JRReadImageSeq));
 251     addToHeader(szStr, 2);
 252     addToHeader(JRStripHeightSeq, sizeof(JRStripHeightSeq));
 253     addToHeader(JRTextObjectTypeSeq, sizeof(JRTextObjectTypeSeq));
 254     addToHeader(JRVueVersionTagSeq, sizeof(JRVueVersionTagSeq));
 255     int    i = 0;
 256     szStr[i++] = 0xC2;
 257     ulVuDataLength += 6;
 258     szStr[i++] = (BYTE) (ulVuDataLength & 0xFF);
 259     szStr[i++] = (BYTE) ((ulVuDataLength & 0x0000FF00) >> 8);
 260     szStr[i++] = (BYTE) ((ulVuDataLength & 0x00FF0000) >> 16);
 261     szStr[i++] = (BYTE) ((ulVuDataLength & 0xFF000000) >> 24);
 262     szStr[i++] = 0xF8;
 263     szStr[i++] = 0x92;
 264     szStr[i++] = 0x46;
 265     if (m_eCompressMode == COMPRESS_MODE_LJ)
 266         szStr[i++] = 0x11;
 267     else
 268         szStr[i++] = 0x21;
 269     szStr[i++] = 0x90;
 270     ulVuDataLength -= 6;
 271     szStr[i++] = (BYTE) (ulVuDataLength & 0xFF);
 272     szStr[i++] = (BYTE) ((ulVuDataLength & 0x0000FF00) >> 8);
 273     szStr[i++] = (BYTE) ((ulVuDataLength & 0x00FF0000) >> 16);
 274     szStr[i++] = (BYTE) ((ulVuDataLength & 0xFF000000) >> 24);
 275     addToHeader((const BYTE *) szStr, i);
 276     err = Cleanup();
 277     if (err == NO_ERROR)
 278         err = sendBuffer((const BYTE *) pDataPtr, ulVuDataLength);
 279     return err;
 280 }
 281
 282 void LJJetReady::addQTable(DWORD *qtable)
 283 {
 284     for (int i = 0; i < QTABLE_SIZE; i++)
 285     {
 286         *cur_pcl_buffer_ptr++ = (BYTE) (qtable[i] & 0xFF);
 287         *cur_pcl_buffer_ptr++ = (BYTE) ((qtable[i] >> 8)  & 0xFF);
 288         *cur_pcl_buffer_ptr++ = 0;
 289         *cur_pcl_buffer_ptr++ = 0;
 290     }
 291 }
 292
 293 DRIVER_ERROR LJJetReady::sendJPEGHeaderInfo(RASTERDATA *InputRaster)
 294 {
 295     DRIVER_ERROR    err;
 296     if (!m_bSendQTable)
 297     {
 298         return NO_ERROR;
 299     }
 300     union
 301     {
 302         short    s;
 303         BYTE     c[2];
 304     } endianness;
 305     endianness.s = 0x0A0B;
 306     err = sendBuffer(JRQTSeq, sizeof(JRQTSeq));
 307     if (endianness.c[0] == 0x0B)
 308     {
 309         err = sendBuffer((const BYTE *) &m_QTableInfo, sizeof(DWORD) * QTABLE_SIZE * 3);
 310     }
 311     else
 312     {
 313         addQTable(m_QTableInfo.qtable0);
 314         addQTable(m_QTableInfo.qtable1);
 315         addQTable(m_QTableInfo.qtable2);
 316         err = Cleanup();
 317     }
 318     m_bSendQTable = false;
 319     addToHeader(JRCRSeq, sizeof(JRCRSeq));
 320     BYTE    szCR3Seq[] = {0x00, 0x00, 0x00, 0x00};
 321     if (m_pJA->color_mode != 0)
 322     {
 323         addToHeader(JRCR1GSeq, sizeof(JRCR1GSeq));
 324     }
 325     else
 326     {
 327         addToHeader(JRCR1CSeq, sizeof(JRCR1CSeq));
 328         szCR3Seq[0] = 0x01;
 329     }
 330     addToHeader(szCR3Seq, sizeof(szCR3Seq));
 331     for (int i = 0; i < 9; i++)
 332     {
 333         addToHeader(JRSCSeq[i], 4);
 334     }
 335     err = Cleanup();
 336     return err;
 337 }
 338