lib/epson-escpage-color.c

   1 /*______________________________  epson-escpage-color.c   ______________________________*/\r
   2 \r
   3 /*       1         2         3         4         5         6         7         8        */\r
   4 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
   5 /*******************************************|********************************************/\r
   6 /*\r
   7  *   Copyright (c) 2010  Seiko Epson Corporation                 All rights reserved.\r
   8  *\r
   9  *   Copyright protection claimed includes all forms and matters of\r
  10  *   copyrightable material and information now allowed by statutory or judicial\r
  11  *   law or hereinafter granted, including without limitation, material generated\r
  12  *   from the software programs which are displayed on the screen such as icons,\r
  13  *   screen display looks, etc.\r
  14  *\r
  15  */\r
  16 \r
  17 /*------------------------------------  Includes   -------------------------------------*/\r
  18 /*******************************************|********************************************/\r
  19 #include "epson-escpr-err.h"\r
  20 #include "epson-escpr-media.h"\r
  21 #include "epson-escpr-mem.h"\r
  22 #include "epson-escpage.h"\r
  23 #include "epson-escpage-comp.h"\r
  24 #include "epson-escpage-color.h"\r
  25 \r
  26 /*-----------------------------  Local Macro Definitions -------------------------------*/\r
  27 /*******************************************|********************************************/\r
  28 #ifdef EPS_LOG_MODULE_PAGE\r
  29 #define EPS_LOG_MODULE  EPS_LOG_MODULE_PAGE\r
  30 #else\r
  31 #define EPS_LOG_MODULE  0\r
  32 #endif\r
  33 \r
  34 \r
  35 /*-----------------------------  ESC/PAGE-Color commands -------------------------------*/\r
  36 /*******************************************|********************************************/\r
  37 const static EPS_UINT8 sbCR[]       = {0x0D};                     /* Carriage return "CR" */\r
  38 const static EPS_UINT8 sbFF[]   = {0x0C};                     /* Form Feed "FF" */\r
  39 const static EPS_UINT8 sbIP[]   = {0x1D, 'r', 'h', 'E'};              /* Initialize printer */\r
  40 const static EPS_UINT8 sbSU150[]    = {0x1D, '0', ';', '.', '4', '8', 'm', 'u', 'E'}; /* Set unit to 150 */\r
  41 const static EPS_UINT8 sbSU300[]    = {0x1D, '0', ';', '.', '2', '4', 'm', 'u', 'E'}; /* Set unit to 300 */\r
  42 const static EPS_UINT8 sbSU600[]    = {0x1D, '0', ';', '.', '1', '2', 'm', 'u', 'E'}; /* Set unit to 600 */\r
  43 const static EPS_UINT8 sbSU1200[]   = {0x1D, '0', ';', '.', '0', '6', 'm', 'u', 'E'}; /* Set unit to 1200 */\r
  44 \r
  45 const static EPS_UINT8 sbPSSL[]     = {0x1D, '3', '0', 'p', 's', 'E'};          /* Set Letter paper */\r
  46 const static EPS_UINT8 sbPSSA4[]  = {0x1D, '1', '4', 'p', 's', 'E'};          /* Set A4 paper */\r
  47 const static EPS_UINT8 sbPSSB5[]    = {0x1D, '2', '5', 'p', 's', 'E'};          /* Set B5 paper */\r
  48 const static EPS_UINT8 sbPSSLE[]  = {0x1D, '3', '2', 'p', 's', 'E'};          /* Set Legal paper */\r
  49 const static EPS_UINT8 sbPSSA3[]  = {0x1D, '1', '3', 'p', 's', 'E'};          /* Set A3 paper */\r
  50 const static EPS_UINT8 sbPSSB4[]    = {0x1D, '2', '4', 'p', 's', 'E'};          /* Set B4 paper */\r
  51 const static EPS_UINT8 sbPSSPS[]    = {0x1D, '3', '8', 'p', 's', 'E'};          /* Set B4 paper */\r
  52 const static EPS_UINT8 sbPSSF4[]    = {0x1D, '3', '7', 'p', 's', 'E'};          /* Set F4 paper */\r
  53 const static EPS_UINT8 sbPSSA5[]    = {0x1D, '1', '5', 'p', 's', 'E'};          /* Set A5 paper */\r
  54 const static EPS_UINT8 sbPSSHLT[]    = {0x1D, '3', '1', 'p', 's', 'E'};         /* Set HLT paper */\r
  55 const static EPS_UINT8 sbPSSEXE[]    = {0x1D, '3', '3', 'p', 's', 'E'};         /* Set EXE paper */\r
  56 const static EPS_UINT8 sbPSSB[]    = {0x1D, '3', '6', 'p', 's', 'E'};         /* Set B paper */\r
  57 const static EPS_UINT8 sbPSSGLT[]    = {0x1D, '3', '5', 'p', 's', 'E'};         /* Set GLT paper */\r
  58 const static EPS_UINT8 sbPSSGLG[]    = {0x1D, '3', '4', 'p', 's', 'E'};         /* Set GLG paper */\r
  59 const static EPS_UINT8 sbPSSMON[]    = {0x1D, '8', '0', 'p', 's', 'E'};         /* Set MON paper */\r
  60 const static EPS_UINT8 sbPSSC10[]    = {0x1D, '8', '1', 'p', 's', 'E'};         /* Set C10 paper */\r
  61 const static EPS_UINT8 sbPSSDL[]    = {0x1D, '9', '0', 'p', 's', 'E'};          /* Set DL paper */\r
  62 const static EPS_UINT8 sbPSSC5[]    = {0x1D, '9', '1', 'p', 's', 'E'};          /* Set C5 paper */\r
  63 const static EPS_UINT8 sbPSSC6[]    = {0x1D, '9', '2', 'p', 's', 'E'};          /* Set C6 paper */\r
  64 const static EPS_UINT8 sbPSSIB5[]    = {0x1D, '9', '9', 'p', 's', 'E'};         /* Set IB5 paper */\r
  65 \r
  66 \r
  67 const static EPS_UINT8 sbSDE0[]     = {0x1D, '0', 's', 'd', 'E'};           /* Set Duplex OFF */\r
  68 const static EPS_UINT8 sbSDE1[]     = {0x1D, '1', 's', 'd', 'E'};           /* Set Duplex ON */\r
  69 const static EPS_UINT8 sbBDE0[]     = {0x1D, '0', 'b', 'd', 'E'};           /* Set Duplex long */\r
  70 const static EPS_UINT8 sbBDE1[]     = {0x1D, '1', 'b', 'd', 'E'};           /* Set Duplex short */\r
  71 \r
  72 const static EPS_UINT8 sbPTE0[]   = {0x1D, '0', 'p', 't', 'E'};           /* select paper type 0:other */\r
  73 const static EPS_UINT8 sbPTE1[]   = {0x1D, '1', 'p', 't', 'E'};           /* select paper type 1:plane */\r
  74 const static EPS_UINT8 sbPTE2[]   = {0x1D, '1', '3', 'p', 't', 'E'};            /* select paper type 1:semi thick */\r
  75 const static EPS_UINT8 sbPTE3[]   = {0x1D, '2', 'p', 't', 'E'};           /* select paper type 1:preprinter */\r
  76 const static EPS_UINT8 sbPTE4[]   = {0x1D, '3', 'p', 't', 'E'};           /* select paper type 1:letterhead */\r
  77 const static EPS_UINT8 sbPTE5[]   = {0x1D, '6', 'p', 't', 'E'};           /* select paper type 1:Recycled */\r
  78 const static EPS_UINT8 sbPTE6[]   = {0x1D, '7', 'p', 't', 'E'};           /* select paper type 1:color */\r
  79 const static EPS_UINT8 sbPTE7[]   = {0x1D, '9', 'p', 't', 'E'};           /* select paper type 1:labels */\r
  80 const static EPS_UINT8 sbPTE8[]   = {0x1D, '1', '2', 'p', 't', 'E'};            /* select paper type 1:thick */\r
  81 const static EPS_UINT8 sbPTE9[]   = {0x1D, '1', '6', 'p', 't', 'E'};            /* select paper type 1:coated */\r
  82 const static EPS_UINT8 sbPTE10[]    = {0x1D, '1', '0', 'p', 't', 'E'};            /* select paper type 1:special */\r
  83 const static EPS_UINT8 sbPTE11[]    = {0x1D, '1', '7', 'p', 't', 'E'};            /* select paper type 1:transparent */\r
  84 \r
  85 const static EPS_UINT8 sbIUE1[]    = {0x1D, '0', ';', '0', 'i', 'u', 'E'};\r
  86 const static EPS_UINT8 sbIUE0[]    = {0x1D, '1', '6', ';', '1', 'i', 'u', 'E'};\r
  87 const static EPS_UINT8 sbIUE2[]    = {0x1D, '1', ';', '1', 'i', 'u', 'E'};\r
  88 const static EPS_UINT8 sbIUE3[]    = {0x1D, '2', ';', '1', 'i', 'u', 'E'};\r
  89 const static EPS_UINT8 sbIUE4[]    = {0x1D, '3', ';', '1', 'i', 'u', 'E'};\r
  90 const static EPS_UINT8 sbIUE5[]    = {0x1D, '4', ';', '1', 'i', 'u', 'E'};\r
  91 const static EPS_UINT8 sbIUE6[]    = {0x1D, '5', ';', '1', 'i', 'u', 'E'};\r
  92 const static EPS_UINT8 sbIUE7[]    = {0x1D, '6', ';', '1', 'i', 'u', 'E'};\r
  93 const static EPS_UINT8 sbIUE8[]    = {0x1D, '7', ';', '1', 'i', 'u', 'E'};\r
  94 const static EPS_UINT8 sbIUE9[]    = {0x1D, '8', ';', '1', 'i', 'u', 'E'};\r
  95 const static EPS_UINT8 sbIUE10[]    = {0x1D, '9', ';', '1', 'i', 'u', 'E'};\r
  96 const static EPS_UINT8 sbIUE11[]    = {0x1D, '1', '0', ';', '1', 'i', 'u', 'E'};\r
  97 const static EPS_UINT8 sbIUE12[]    = {0x1D, '1', '1', ';', '1', 'i', 'u', 'E'};\r
  98 const static EPS_UINT8 sbIUE13[]    = {0x1D, '1', '2', ';', '1', 'i', 'u', 'E'};\r
  99 const static EPS_UINT8 sbIUE14[]    = {0x1D, '1', '3',';', '1', 'i', 'u', 'E'};\r
 100 const static EPS_UINT8 sbIUE15[]    = {0x1D, '2', '4',';', '1', 'i', 'u', 'E'};\r
 101 const static EPS_UINT8 sbIUE16[]    = {0x1D, '2', '5',';', '1', 'i', 'u', 'E'};\r
 102 \r
 103 const static EPS_UINT8 sbCMS[]      = {0x1D, '1', 'c', 'm', 'E'};           /* Clip Mode Set */\r
 104 const static EPS_UINT8 sbSDS1200_0[] = {0x1D, '0', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};  /* Select Dot Size(1200) 0:image */\r
 105 const static EPS_UINT8 sbSDS1200_1[] = {0x1D, '1', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};  /* Select Dot Size(1200) 1:font */\r
 106 const static EPS_UINT8 sbSDS1200_2[] = {0x1D, '2', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};  /* Select Dot Size(1200) 2:binary format pattern */\r
 107 const static EPS_UINT8 sbSDS1200_3[] = {0x1D, '3', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};  /* Select Dot Size(1200) 3:color pattern */\r
 108 const static EPS_UINT8 sbSDS600_0[] = {0x1D, '0', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(600) 0:image */\r
 109 const static EPS_UINT8 sbSDS600_1[] = {0x1D, '1', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(600) 1:font */\r
 110 const static EPS_UINT8 sbSDS600_2[] = {0x1D, '2', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(600) 2:binary format pattern */\r
 111 const static EPS_UINT8 sbSDS600_3[] = {0x1D, '3', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(600) 3:color pattern */\r
 112 const static EPS_UINT8 sbSDS300_0[] = {0x1D, '0', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(300) 0:image */\r
 113 const static EPS_UINT8 sbSDS300_1[] = {0x1D, '1', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(300) 1:font */\r
 114 const static EPS_UINT8 sbSDS300_2[] = {0x1D, '2', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(300) 2:binary format pattern */\r
 115 const static EPS_UINT8 sbSDS300_3[] = {0x1D, '3', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'}; /* Select Dot Size(300) 3:color pattern */\r
 116 const static EPS_UINT8 sbSDS150_0[] = {0x1D, '0', ';', '1', '5', '0', ';', '1', '5', '0', 'd', 'r', 'E'}; /* Select Dot Size(150) 0:image */\r
 117 const static EPS_UINT8 sbSDS150_1[] = {0x1D, '1', ';', '1', '5', '0', ';', '1', '5', '0', 'd', 'r', 'E'}; /* Select Dot Size(150) 1:font */\r
 118 const static EPS_UINT8 sbSDS150_2[] = {0x1D, '2', ';', '1', '5', '0', ';', '1', '5', '0', 'd', 'r', 'E'}; /* Select Dot Size(150) 2:binary format pattern */\r
 119 const static EPS_UINT8 sbSDS150_3[] = {0x1D, '3', ';', '1', '5', '0', ';', '1', '5', '0', 'd', 'r', 'E'}; /* Select Dot Size(150) 3:color pattern */\r
 120 \r
 121 const static EPS_UINT8 sbMMS[]    = {0x1D, '1', 'm', 'm', 'E'};           /* Select Page memory mode */\r
 122 \r
 123 const static EPS_UINT8 sbPDS0[]      = {0x1D, '0', 'p', 'o', 'E'};            /* Set paper direction to normal */\r
 124 const static EPS_UINT8 sbPDS1[]      = {0x1D, '1', 'p', 'o', 'E'};            /* Set paper direction to rotate */\r
 125 \r
 126 const static EPS_UINT8 sbPDS[]      = {0x1D, '0', 'p', 'o', 'E'};           /* Set paper direction to normal */\r
 127 const static EPS_UINT8 sbACRLFS[]   = {0x1D, '0', 'a', 'l', 'f', 'P'};          /* Does not perform auto carriage return */\r
 128 const static EPS_UINT8 sbAFFS[]     = {0x1D, '0', 'a', 'f', 'f', 'P'};          /* Does not perform auto Form Feed */\r
 129 const static EPS_UINT8 sbABPS[]     = {0x1D, '1', 'a', 'b', 'P'};           /* Set current position to 0 after bit image draw */\r
 130 const static EPS_UINT8 sbSARGAS[]   = {0x1D, '2', 's', 'a', 'r', 'G'};          /* Set Absolute Graph Coordinate mode */\r
 131 const static EPS_UINT8 sbPMPPS[]    = {0x1D, '0', 'p', 'm', 'P'};           /* Set current move mode to print pitch mode */\r
 132 const static EPS_UINT8 sbCSE[]      = {0x1D, '2', 'c', 's', 'E'};           /* Select color space */\r
 133 const static EPS_UINT8 sbPDDO[]     = {0x1D, '0', 'p', 'd', 'd', 'O'};          /* Select Imaging device 0:CPGI 1:PGI */\r
 134 const static EPS_UINT8 sbCCME[]   = {0x1D, '0', ';', '2', ';', '4', 'c', 'c', 'm', 'E'};          /* Select color collect */\r
 135 const static EPS_UINT8 sbCAME[]     = {0x1D, '7', ';', '0', ';', '2', ';', '3', 'c', 'a', 'm', '{', 'E'};\r
 136 const static EPS_UINT8 sbRAE_1[]    = {0x1D, '1', ';', '1', 'r', 'a', 'E'};\r
 137 const static EPS_UINT8 sbRAE_2[]    = {0x1D, '2', ';', '1', 'r', 'a', 'E'};\r
 138 const static EPS_UINT8 sbRAE_3[]    = {0x1D, '3', ';', '2', 'r', 'a', 'E'};\r
 139 const static EPS_UINT8 sbCMME_0[] = {0x1D, '0', 'c', 'm', 'm', 'E'};\r
 140 const static EPS_UINT8 sbCMME_1[] = {0x1D, '1', 'c', 'm', 'm', 'E'};\r
 141 const static EPS_UINT8 sbCLFP[]     = {0x1D, '0', ';', '0', ';', '0', 'c', 'l', 'f', 'P'};\r
 142 const static EPS_UINT8 sbWFE[]      = {0x1D, '5', ';', '2', '0', '4', 'w', 'f', 'E'};\r
 143 \r
 144 const static EPS_UINT8 sbBCTI20[] = {0x1D, '2', ';', '2', '0', 'b', 'c', 't', '{', 'I'};\r
 145 const static EPS_UINT8 sbC20[]      = {0x1, 0x2};\r
 146 \r
 147 const static EPS_INT8 sbSCRI[]    = "scrI";\r
 148 const static EPS_INT8 sbCRI[]   = "\x1D%d;%dcr{I";\r
 149 const static EPS_INT8 sbCUI[]   = "cu{I";\r
 150 const static EPS_UINT8 sbECRI[]   = {0x1D, 'e', 'c', 'r', 'I'};\r
 151 \r
 152 const static EPS_INT8 sbplrBE[]     = "\x1D%d;0;2;256;256plr{E";\r
 153 \r
 154 /*-----------------------------  Local Macro Definitions -------------------------------*/\r
 155 /*******************************************|********************************************/\r
 156 #define EPS_PAGE_RASTER       (64)    /* number of scanning rasters */\r
 157 #define EPS_PAGE_CMDBUFF_SIZE   EPS_EJL_LINEMAX\r
 158 \r
 159 \r
 160 /*---------------------------  Data Structure Declarations   ---------------------------*/\r
 161 /*******************************************|********************************************/\r
 162 typedef struct _tagEPS_PAGE_BAND_ \r
 163 {\r
 164   EPS_INT32 compressType;   /* compless mode */\r
 165   EPS_INT32 widthInPixels;\r
 166   EPS_INT32 currentWidthInPixels;\r
 167   EPS_INT32 rasterRow;\r
 168   EPS_INT32   encDataSize;    /* Compless data size */\r
 169   EPS_UINT8 *pEncData;      /* Compless data */\r
 170   EPS_INT32 scanLineSize;   /* Source data line size */\r
 171   EPS_INT32 scanBuffSize;   /* Source data buffer size */\r
 172   EPS_INT32   scanDataSize;   /* Source data size */\r
 173   EPS_UINT8 *pScanData;     /* Source data */\r
 174   EPS_BOOL  emited;\r
 175   EPS_BOOL  dataSent;\r
 176 }EPS_PAGE_BAND;\r
 177 \r
 178 /*----------------------------  ESC/P-R Lib Global Variables  --------------------------*/\r
 179 /*******************************************|********************************************/\r
 180 extern EPS_CMN_FUNC   epsCmnFnc;\r
 181 extern EPS_PRINT_JOB  printJob;\r
 182 \r
 183 /*----------------------------------   Local Variables  --------------------------------*/\r
 184 /*******************************************|********************************************/\r
 185 static EPS_PAGE_BAND    band;\r
 186 static EPS_COMMAND_BUFFER cmdBuf;\r
 187 static EPS_INT32      pageCount = 0;\r
 188 static EPS_INT32      emitRowCount = 0;\r
 189 \r
 190 \r
 191 /*--------------------------  Local Functions Declaration   ----------------------------*/\r
 192 /*******************************************|********************************************/\r
 193 static EPS_ERR_CODE CmdBuffInit   (EPS_COMMAND_BUFFER *pCmdBuff, EPS_PAGE_BAND *pBand);\r
 194 static EPS_ERR_CODE CmdBuffGrow   (EPS_COMMAND_BUFFER *pCmdBuff, EPS_INT32 addSize);\r
 195 static void     CmdBuffTerm   (EPS_COMMAND_BUFFER *pCmdBuff);\r
 196 \r
 197 static EPS_ERR_CODE RegisterPalette (EPS_UINT16, EPS_UINT8*, EPS_COMMAND_BUFFER *pCmdBuff);\r
 198 \r
 199 static EPS_BOOL   BandInit    (EPS_PAGE_BAND* pBand);\r
 200 static void     BandTerm    (EPS_PAGE_BAND* pBand);\r
 201 static EPS_BOOL   BandEmit    (EPS_PAGE_BAND* pBand); \r
 202 static EPS_ERR_CODE BandSetScanData (EPS_PAGE_BAND* pBand, const EPS_UINT8 *Row, EPS_UINT32 DeltaByte);\r
 203 static EPS_ERR_CODE BandCompress  (EPS_PAGE_BAND* pBand, EPS_INT32);\r
 204 static void     BandClear   (EPS_PAGE_BAND* pBand);\r
 205 \r
 206 static EPS_INT32 GetEncodeMode(EPS_INT32 bpp);\r
 207 \r
 208 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 209 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 210 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 211 /*--------------------              Public Functions               ---------------------*/\r
 212 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 213 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 214 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 215 \r
 216 /*******************************************|********************************************/\r
 217 /*                                                                                      */\r
 218 /* Function name:   pageAllocBuffer_C()                                             */\r
 219 /*                                                                                      */\r
 220 /* Arguments                                                                            */\r
 221 /* ---------                                                                            */\r
 222 /* Name:    Type:         Description:                                    */\r
 223 /* N/A                                          */\r
 224 /*                                                                                      */\r
 225 /* Return value:                                                                        */\r
 226 /*      EPS_ERR_NONE                    - Success                   */\r
 227 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 228 /*                                                                                      */\r
 229 /* Description:                                                                         */\r
 230 /*      Allocate buffer for ESC/Page Job.                       */\r
 231 /*                                                                                      */\r
 232 /*******************************************|********************************************/\r
 233 EPS_ERR_CODE pageAllocBuffer_C(void)\r
 234 {\r
 235   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
 236 \r
 237   EPS_LOG_FUNCIN\r
 238 \r
 239   ret = BandInit(&band);\r
 240 \r
 241   if ( EPS_ERR_NONE == ret ) {\r
 242     ret = CmdBuffInit(&cmdBuf, &band);\r
 243   }\r
 244 \r
 245   EPS_RETURN( ret )\r
 246 }\r
 247 \r
 248 \r
 249 /*******************************************|********************************************/\r
 250 /*                                                                                      */\r
 251 /* Function name:   pageRelaseBuffer_C()                                            */\r
 252 /*                                                                                      */\r
 253 /* Arguments                                                                            */\r
 254 /* ---------                                                                            */\r
 255 /* Name:    Type:         Description:                                    */\r
 256 /* N/A                                          */\r
 257 /*                                                                                      */\r
 258 /* Return value:                                                                        */\r
 259 /*      N/A                                                                             */\r
 260 /*                                                                                      */\r
 261 /* Description:                                                                         */\r
 262 /*      Free buffer for ESC/Page Job.                                             */\r
 263 /*                                                                                      */\r
 264 /*******************************************|********************************************/\r
 265 void pageRelaseBuffer_C(void)\r
 266 {\r
 267   /*** Clear Memory */\r
 268   CmdBuffTerm(&cmdBuf);\r
 269   BandTerm(&band);\r
 270 }\r
 271 \r
 272 \r
 273 /*******************************************|********************************************/\r
 274 /*                                                                                      */\r
 275 /* Function name:   pageStartJob_C()                          */\r
 276 /*                                                                                      */\r
 277 /* Arguments                                                                            */\r
 278 /* ---------                                                                            */\r
 279 /* Name:    Type:         Description:                                    */\r
 280 /* N/A                                          */\r
 281 /*                                                                                      */\r
 282 /* Return value:                                                                        */\r
 283 /*      EPS_ERR_NONE                    - Success                   */\r
 284 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 285 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 286 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 287 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 288 /*                                                                                      */\r
 289 /* Description:                                                                         */\r
 290 /*      Send ESC/Page start job commands.                                       */\r
 291 /*                                                                                      */\r
 292 /*******************************************|********************************************/\r
 293 EPS_ERR_CODE pageStartJob_C(void)\r
 294 {\r
 295   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
 296   EPS_UINT32      retBufSize = 0;\r
 297 \r
 298   EPS_LOG_FUNCIN\r
 299 \r
 300 #define pgStartJob_ADDCMD(CMD) {              \\r
 301     ret = CmdBuffGrow(&cmdBuf, sizeof(CMD) );     \\r
 302     if( EPS_ERR_NONE != ret){EPS_RETURN( ret )}     \\r
 303     memcpy(cmdBuf.p + cmdBuf.len, CMD, sizeof(CMD));  \\r
 304     cmdBuf.len += sizeof(CMD);              \\r
 305   }\r
 306 \r
 307   debug_msg("__ debug 0 __\n");\r
 308   cmdBuf.len = 0; /* reset */\r
 309   debug_msg("__ debug 0.1 __\n");\r
 310   /*** Make EJL Command ***/\r
 311   ret = ejlStart(&cmdBuf, CmdBuffGrow);\r
 312   if( EPS_ERR_NONE != ret){\r
 313     EPS_RETURN( ret )\r
 314   }\r
 315   debug_msg("__ debug 0.0 __\n");\r
 316     /* Initialize the printer. */\r
 317   pgStartJob_ADDCMD(sbIP)\r
 318   debug_msg("__ debug 1 __\n");\r
 319     /* Set the minimum Unit Setting (600 or 300 resolution) */\r
 320   /* Dot Pattern Resolution Selection            */\r
 321   if(EPS_IR_600X600 == printJob.attr.inputResolution) {\r
 322     pgStartJob_ADDCMD(sbSU600);\r
 323     pgStartJob_ADDCMD(sbSDS600_3);\r
 324     pgStartJob_ADDCMD(sbSDS600_2);\r
 325     pgStartJob_ADDCMD(sbSDS600_1);\r
 326     pgStartJob_ADDCMD(sbSDS600_0);\r
 327   }\r
 328   else if(EPS_IR_1200X1200 == printJob.attr.inputResolution) {  \r
 329     pgStartJob_ADDCMD(sbSU1200);\r
 330     pgStartJob_ADDCMD(sbSDS1200_3);\r
 331     pgStartJob_ADDCMD(sbSDS1200_2);\r
 332     pgStartJob_ADDCMD(sbSDS1200_1);\r
 333     pgStartJob_ADDCMD(sbSDS1200_0);\r
 334   }\r
 335   else if(EPS_IR_300X300 == printJob.attr.inputResolution) {  \r
 336     pgStartJob_ADDCMD(sbSU300);\r
 337     pgStartJob_ADDCMD(sbSDS300_3);\r
 338     pgStartJob_ADDCMD(sbSDS300_2);\r
 339     pgStartJob_ADDCMD(sbSDS300_1);\r
 340     pgStartJob_ADDCMD(sbSDS300_0);\r
 341   } else {\r
 342     pgStartJob_ADDCMD(sbSU150);\r
 343     pgStartJob_ADDCMD(sbSDS150_3);\r
 344     pgStartJob_ADDCMD(sbSDS150_2);\r
 345     pgStartJob_ADDCMD(sbSDS150_1);\r
 346     pgStartJob_ADDCMD(sbSDS150_0);\r
 347   }\r
 348   debug_msg("__ debug 2 __\n");\r
 349   /* Set Memory Mode Selection to Page memory mode */\r
 350   pgStartJob_ADDCMD(sbMMS);\r
 351   \r
 352   /* Set Paper Size */\r
 353   debug_msg("__ nguyen nam __\n", printJob.attr.mediaSizeIdx );\r
 354   switch ( printJob.attr.mediaSizeIdx ) {\r
 355   case EPS_MSID_A4:       pgStartJob_ADDCMD(sbPSSA4); break;\r
 356   case EPS_MSID_A5:       pgStartJob_ADDCMD(sbPSSA5);   break;\r
 357   case EPS_MSID_HLT:      pgStartJob_ADDCMD(sbPSSHLT);  break;\r
 358   case EPS_MSID_EXECUTIVE:  pgStartJob_ADDCMD(sbPSSEXE);  break;\r
 359   case EPS_MSID_B:        pgStartJob_ADDCMD(sbPSSB);    break;\r
 360   case EPS_MSID_GLT:      pgStartJob_ADDCMD(sbPSSGLT);  break;\r
 361   case EPS_MSID_GLG:      pgStartJob_ADDCMD(sbPSSGLG);  break;\r
 362   case EPS_MSID_MON:      pgStartJob_ADDCMD(sbPSSMON);  break;\r
 363   case EPS_MSID_C10:      pgStartJob_ADDCMD(sbPSSC10);  break;\r
 364   case EPS_MSID_DL:       pgStartJob_ADDCMD(sbPSSDL); break;\r
 365   case EPS_MSID_C5:       pgStartJob_ADDCMD(sbPSSC5); break;\r
 366   case EPS_MSID_C6:       pgStartJob_ADDCMD(sbPSSC6); break;\r
 367   case EPS_MSID_IB5:      pgStartJob_ADDCMD(sbPSSIB5);  break;\r
 368   case EPS_MSID_F4:       pgStartJob_ADDCMD(sbPSSF4); break;\r
 369   case EPS_MSID_B5:       pgStartJob_ADDCMD(sbPSSB5); break;\r
 370   case EPS_MSID_B4:       pgStartJob_ADDCMD(sbPSSB4); break;  \r
 371   case EPS_MSID_A3:       pgStartJob_ADDCMD(sbPSSA3); break;\r
 372   case EPS_MSID_LETTER:   pgStartJob_ADDCMD(sbPSSL);  break;\r
 373   case EPS_MSID_LEGAL:    pgStartJob_ADDCMD(sbPSSLE); break;\r
 374   default:                pgStartJob_ADDCMD(sbPSSA4); break;\r
 375   }\r
 376 \r
 377   ret = ejlPageEsc(&cmdBuf, CmdBuffGrow);\r
 378   if( EPS_ERR_NONE != ret){\r
 379     EPS_RETURN( ret )\r
 380   }\r
 381 \r
 382   /* Set Clip Mode */\r
 383   pgStartJob_ADDCMD(sbCMS);\r
 384   \r
 385   /* Does not perform automatic carriage return line feed */\r
 386   pgStartJob_ADDCMD(sbACRLFS);\r
 387 \r
 388   /* Does not perform automatic Form Feed */\r
 389   pgStartJob_ADDCMD(sbAFFS);\r
 390 \r
 391   /* Set current position to 0 after Bit image draw */\r
 392   pgStartJob_ADDCMD(sbABPS);\r
 393 \r
 394     /* Step 4 - Adjust Vertical Print Position (if necessary) */\r
 395     /* CR */\r
 396     pgStartJob_ADDCMD(sbCR);\r
 397     \r
 398   /* Set Absolute graph coordinate mode */\r
 399   pgStartJob_ADDCMD(sbSARGAS);\r
 400 \r
 401   /* Set current position move mode to print pitch */\r
 402   pgStartJob_ADDCMD(sbPMPPS);\r
 403 \r
 404   /* select paper type */\r
 405   switch(printJob.attr.mediaTypeIdx){\r
 406   case EPS_MTID_PLAIN:    pgStartJob_ADDCMD(sbPTE1);  break;\r
 407   case EPS_MTID_SEMITHICK:  pgStartJob_ADDCMD(sbPTE2);  break;\r
 408   case EPS_MTID_PREPRINTED: pgStartJob_ADDCMD(sbPTE3);  break;\r
 409   case EPS_MTID_LETTERHEAD: pgStartJob_ADDCMD(sbPTE4);  break;\r
 410   case EPS_MTID_RECYCLED:   pgStartJob_ADDCMD(sbPTE5);  break;\r
 411   case EPS_MTID_COLOR:    pgStartJob_ADDCMD(sbPTE6);  break;\r
 412   case EPS_MTID_LABEL:    pgStartJob_ADDCMD(sbPTE7);  break;\r
 413   case EPS_MTID_THICK:    pgStartJob_ADDCMD(sbPTE8);  break;\r
 414   case EPS_MTID_COATED:     pgStartJob_ADDCMD(sbPTE9);  break;\r
 415   case EPS_MTID_SPECIAL:    pgStartJob_ADDCMD(sbPTE10);   break;\r
 416   case EPS_MTID_TRANSPARENT:  pgStartJob_ADDCMD(sbPTE11);   break;\r
 417   case EPS_MTID_UNSPECIFIED:  pgStartJob_ADDCMD(sbPTE0);  break;\r
 418   default:              pgStartJob_ADDCMD(sbPTE0);    break;\r
 419   }\r
 420 \r
 421   /* Set paper direction */\r
 422   if(printJob.attr.orienTation == 1) \r
 423   {\r
 424     pgStartJob_ADDCMD(sbPDS1);  /* Landscape */\r
 425   } else{\r
 426     pgStartJob_ADDCMD(sbPDS0);  /* Potrait */\r
 427   }\r
 428 \r
 429   /* set duplex */\r
 430   if(printJob.attr.duplex == EPS_DUPLEX_NONE){\r
 431     pgStartJob_ADDCMD(sbSDE0);\r
 432   } else{\r
 433     pgStartJob_ADDCMD(sbSDE1);\r
 434     if(printJob.attr.duplex == EPS_DUPLEX_SHORT){\r
 435       pgStartJob_ADDCMD(sbBDE1);\r
 436     } else{\r
 437       pgStartJob_ADDCMD(sbBDE0);\r
 438     }\r
 439   }\r
 440 \r
 441   /* Set paper direction */\r
 442   pgStartJob_ADDCMD(sbPDS);\r
 443 \r
 444   /* Set Manual Feed */\r
 445   if(printJob.attr.manualFeed == 1)\r
 446   {\r
 447     pgStartJob_ADDCMD(sbIUE0);  /* manual */\r
 448   } else{\r
 449     switch(printJob.attr.paperSource){\r
 450     case IPS_MPTID_AUTO:\r
 451       pgStartJob_ADDCMD(sbIUE1);  \r
 452       break;\r
 453     case IPS_MPTID_TRAY1:\r
 454       pgStartJob_ADDCMD(sbIUE2);\r
 455       break;\r
 456     case IPS_MPTID_TRAY2:\r
 457       pgStartJob_ADDCMD(sbIUE3);\r
 458       break;\r
 459     case IPS_MPTID_TRAY3:\r
 460       pgStartJob_ADDCMD(sbIUE4);\r
 461       break;\r
 462     case IPS_MPTID_TRAY4:\r
 463       pgStartJob_ADDCMD(sbIUE5);\r
 464       break;\r
 465     case IPS_MPTID_TRAY5:\r
 466       pgStartJob_ADDCMD(sbIUE6);\r
 467       break;\r
 468     case IPS_MPTID_TRAY6:\r
 469       pgStartJob_ADDCMD(sbIUE7);\r
 470       break;\r
 471     case IPS_MPTID_TRAY7:\r
 472       pgStartJob_ADDCMD(sbIUE8);\r
 473       break;\r
 474     case IPS_MPTID_TRAY8:\r
 475       pgStartJob_ADDCMD(sbIUE9);\r
 476       break;\r
 477     case IPS_MPTID_TRAY9:\r
 478       pgStartJob_ADDCMD(sbIUE10);\r
 479       break;\r
 480     case IPS_MPTID_TRAY10:\r
 481       pgStartJob_ADDCMD(sbIUE11);\r
 482       break;\r
 483     case IPS_MPTID_TRAY11:\r
 484       pgStartJob_ADDCMD(sbIUE12);\r
 485       break;\r
 486     case IPS_MPTID_TRAY12:\r
 487       pgStartJob_ADDCMD(sbIUE13);\r
 488       break;\r
 489     case IPS_MPTID_TRAY13:\r
 490       pgStartJob_ADDCMD(sbIUE14);\r
 491       break;\r
 492     case IPS_MPTID_TRAY14:\r
 493       pgStartJob_ADDCMD(sbIUE15);\r
 494       break;\r
 495     case IPS_MPTID_TRAY15:\r
 496       pgStartJob_ADDCMD(sbIUE16);\r
 497       break;\r
 498     default:\r
 499       pgStartJob_ADDCMD(sbIUE1);\r
 500       break;\r
 501     }\r
 502   } \r
 503 \r
 504   /* Select Imaging device */\r
 505   pgStartJob_ADDCMD(sbPDDO);\r
 506 \r
 507   /* Select color space */\r
 508   pgStartJob_ADDCMD(sbCSE);\r
 509 \r
 510   /* cancel color controle */\r
 511   pgStartJob_ADDCMD(sbCMME_0);\r
 512 \r
 513   /* Select color collect */\r
 514   pgStartJob_ADDCMD(sbCCME);\r
 515 \r
 516   /* Select color condition */\r
 517   pgStartJob_ADDCMD(sbCAME);\r
 518 \r
 519   /* Select screening */\r
 520   pgStartJob_ADDCMD(sbRAE_1);\r
 521   pgStartJob_ADDCMD(sbRAE_2);\r
 522   pgStartJob_ADDCMD(sbRAE_3);\r
 523 \r
 524   /* set color controle */\r
 525   pgStartJob_ADDCMD(sbCMME_1);\r
 526 \r
 527   pgStartJob_ADDCMD(sbCLFP);\r
 528 \r
 529   /* set logical operation */\r
 530   pgStartJob_ADDCMD(sbWFE);\r
 531   \r
 532   switch( band.compressType )\r
 533   {\r
 534   case EP_COMPRESS20:\r
 535     pgStartJob_ADDCMD(sbBCTI20);  /* set compless table */\r
 536     pgStartJob_ADDCMD(sbC20);   /* set data format */\r
 537     break;\r
 538   default:/* for 8bpp */\r
 539     break;\r
 540   }\r
 541   ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 542 \r
 543     pageCount = 0;\r
 544 \r
 545   EPS_RETURN( ret )\r
 546 }\r
 547 \r
 548 \r
 549 /*******************************************|********************************************/\r
 550 /*                                                                                      */\r
 551 /* Function name:   pageEndJob_C()                            */\r
 552 /*                                                                                      */\r
 553 /* Arguments                                                                            */\r
 554 /* ---------                                                                            */\r
 555 /* Name:    Type:         Description:                                    */\r
 556 /* N/A                                          */\r
 557 /*                                                                                      */\r
 558 /* Return value:                                                                        */\r
 559 /*      EPS_ERR_NONE                    - Success                   */\r
 560 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 561 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 562 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 563 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 564 /*                                                                                      */\r
 565 /* Description:                                                                         */\r
 566 /*      Send ESC/Page end job commands.                                         */\r
 567 /*                                                                                      */\r
 568 /*******************************************|********************************************/\r
 569 EPS_ERR_CODE pageEndJob_C()\r
 570 {\r
 571   EPS_ERR_CODE  ret = EPS_ERR_NONE;           /* Return status of internal calls  */\r
 572   EPS_UINT32      retBufSize = 0;\r
 573 \r
 574   EPS_LOG_FUNCIN\r
 575 \r
 576   cmdBuf.len = 0; /* reset */\r
 577 \r
 578   /* end color image drawing */\r
 579   memcpy((EPS_INT8*)cmdBuf.p, sbECRI, sizeof(sbECRI));\r
 580   cmdBuf.len += sizeof(sbECRI);\r
 581 \r
 582   /*** Make EJL Command ***/\r
 583   ret = ejlEnd(&cmdBuf, CmdBuffGrow, pageCount);\r
 584   if( EPS_ERR_NONE != ret){\r
 585     EPS_RETURN( ret )\r
 586   }\r
 587 \r
 588   ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 589 \r
 590   EPS_RETURN( ret )\r
 591 }\r
 592 \r
 593 \r
 594 /*******************************************|********************************************/\r
 595 /*                                                                                      */\r
 596 /* Function name:   pageStartPage_C()                         */\r
 597 /*                                                                                      */\r
 598 /* Arguments                                                                            */\r
 599 /* ---------                                                                            */\r
 600 /* Name:    Type:         Description:                                    */\r
 601 /* N/A                                          */\r
 602 /*                                                                                      */\r
 603 /* Return value:                                                                        */\r
 604 /*      EPS_ERR_NONE                    - Success                   */\r
 605 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 606 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 607 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 608 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 609 /*                                                                                      */\r
 610 /* Description:                                                                         */\r
 611 /*      Send ESC/Page start page commands.                                      */\r
 612 /*                                                                                      */\r
 613 /*******************************************|********************************************/\r
 614 EPS_ERR_CODE pageStartPage_C()\r
 615 {\r
 616   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 617   EPS_UINT32  retBufSize = 0;\r
 618 \r
 619   EPS_LOG_FUNCIN\r
 620 \r
 621   cmdBuf.len = 0; /* reset */\r
 622   if( 0 == pageCount ){\r
 623     if (printJob.attr.colorPlane == EPS_CP_256COLOR){\r
 624       ret = RegisterPalette(printJob.attr.paletteSize, printJob.attr.paletteData,\r
 625               &cmdBuf);\r
 626     }\r
 627   } else{\r
 628     memcpy(cmdBuf.p, sbFF, sizeof(sbFF));\r
 629     cmdBuf.len += sizeof(sbFF);\r
 630 \r
 631     ret = ejlPageEsc(&cmdBuf, CmdBuffGrow);\r
 632   }\r
 633   if( EPS_ERR_NONE != ret){\r
 634     EPS_RETURN( ret )\r
 635   }\r
 636 \r
 637   if(cmdBuf.len > 0){\r
 638     ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 639   }\r
 640 \r
 641   emitRowCount = 0;\r
 642   pageCount++;\r
 643 \r
 644   EPS_RETURN( ret )\r
 645 }\r
 646 \r
 647 \r
 648 /*******************************************|********************************************/\r
 649 /*                                                                                      */\r
 650 /* Function name:   pageEndPage_C()                           */\r
 651 /*                                                                                      */\r
 652 /* Arguments                                                                            */\r
 653 /* ---------                                                                            */\r
 654 /* Name:    Type:         Description:                                    */\r
 655 /* N/A                                          */\r
 656 /*                                                                                      */\r
 657 /* Return value:                                                                        */\r
 658 /*      EPS_ERR_NONE                    - Success                   */\r
 659 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 660 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 661 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 662 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 663 /*                                                                                      */\r
 664 /* Description:                                                                         */\r
 665 /*      Send ESC/Page end page commands.                                      */\r
 666 /*                                                                                      */\r
 667 /*******************************************|********************************************/\r
 668 EPS_ERR_CODE pageEndPage_C()\r
 669 {\r
 670   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 671 \r
 672   EPS_LOG_FUNCIN\r
 673 \r
 674   if( EP_COMPRESS0 != band.compressType ){\r
 675     BandCompress(&band, printJob.bpp*8);\r
 676     if( band.encDataSize > 0 ) {\r
 677       ret = BandEmit(&band);\r
 678     }\r
 679   } else{\r
 680     if( band.scanDataSize > 0 ){\r
 681       ret = BandEmit(&band);\r
 682     }\r
 683   }\r
 684 \r
 685   if( EPS_ERR_NONE == ret){\r
 686     BandClear(&band);\r
 687   }\r
 688 \r
 689   EPS_RETURN( ret )\r
 690 }\r
 691 \r
 692 \r
 693 /*******************************************|********************************************/\r
 694 /*                                                                                      */\r
 695 /* Function name:   pageColorRow_C()                          */\r
 696 /*                                                                                      */\r
 697 /* Arguments                                                                            */\r
 698 /* ---------                                                                            */\r
 699 /* Name:    Type:         Description:                                    */\r
 700 /* N/A                                          */\r
 701 /*                                                                                      */\r
 702 /* Return value:                                                                        */\r
 703 /*      EPS_ERR_NONE                    - Success                   */\r
 704 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 705 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 706 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 707 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 708 /*                                                                                      */\r
 709 /* Description:                                                                         */\r
 710 /*      Send ESC/Page raster commands.                                        */\r
 711 /*                                                                                      */\r
 712 /*******************************************|********************************************/\r
 713 EPS_ERR_CODE pageColorRow_C(        \r
 714               \r
 715     const EPS_BANDBMP*  pInBmp,\r
 716         EPS_RECT*           pBandRec\r
 717 \r
 718 ){\r
 719   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 720     EPS_UINT16      linePixelSize;\r
 721     EPS_UINT16      widthBytes;\r
 722 \r
 723   EPS_LOG_FUNCIN\r
 724     debug_msg("pBandRec->right = %d\n", pBandRec->right);\r
 725     debug_msg("pBandRec->left = %d\n", pBandRec->left);\r
 726     if( (EPS_UINT32)(pBandRec->right - pBandRec->left) <= printJob.printableAreaWidth){\r
 727         linePixelSize = (EPS_UINT16)(pBandRec->right - pBandRec->left);\r
 728         debug_msg("check linePixe \n");\r
 729     } else{\r
 730         linePixelSize = (EPS_UINT16) printJob.printableAreaWidth;\r
 731     }\r
 732   widthBytes = linePixelSize * printJob.bpp;\r
 733   debug_msg("printJob.bpp = %d\n", printJob.bpp);\r
 734   band.currentWidthInPixels = linePixelSize;\r
 735   /* reset scan size from current line size */\r
 736   band.scanLineSize = widthBytes;\r
 737   if( band.scanLineSize & 3 ){\r
 738     /* 4bite align */\r
 739     band.scanLineSize = (band.scanLineSize & ~3) + 4;\r
 740   }\r
 741   BandSetScanData(&band, pInBmp->bits, widthBytes);\r
 742 \r
 743   if(EP_COMPRESS0 != band.compressType){\r
 744     if( (band.rasterRow >= EPS_PAGE_RASTER )) {\r
 745       BandCompress(&band, printJob.bpp*8);\r
 746       if( band.encDataSize > 0 ) {\r
 747         ret = BandEmit(&band);\r
 748       }\r
 749       debug_msg("band.rasterRow = %d\n", band.rasterRow);\r
 750       emitRowCount += band.rasterRow;\r
 751       if( EPS_ERR_NONE == ret){\r
 752         //debug_msg("check reset band\n");\r
 753         BandClear(&band);   /* reset */\r
 754       }\r
 755     }\r
 756   } else{\r
 757     ret = BandEmit(&band);\r
 758     emitRowCount += band.rasterRow;\r
 759     if( EPS_ERR_NONE == ret){\r
 760       BandClear(&band);   /* reset */\r
 761     }\r
 762   }\r
 763 \r
 764   EPS_RETURN( ret )\r
 765 }\r
 766 \r
 767 \r
 768 /*******************************************|********************************************/\r
 769 /*                                                                                      */\r
 770 /* Function name:   pageSendLeftovers_C()                       */\r
 771 /*                                                                                      */\r
 772 /* Arguments                                                                            */\r
 773 /* ---------                                                                            */\r
 774 /* Name:    Type:         Description:                                    */\r
 775 /* N/A                                          */\r
 776 /*                                                                                      */\r
 777 /* Return value:                                                                        */\r
 778 /*      EPS_ERR_NONE                    - Success                   */\r
 779 /*      EPS_ERR_INVALID_CALL            - This call was unnecessary                     */\r
 780 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 781 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 782 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 783 /*                                                                                      */\r
 784 /* Description:                                                                         */\r
 785 /*      send leftovers data.                                                            */\r
 786 /*                                                                                      */\r
 787 /*******************************************|********************************************/\r
 788 EPS_ERR_CODE pageSendLeftovers_C(\r
 789                  \r
 790        void\r
 791                  \r
 792 ){\r
 793   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
 794   EPS_UINT32      retBufSize = 0;\r
 795 \r
 796   EPS_LOG_FUNCIN\r
 797 \r
 798   if( NULL != printJob.contData.sendData && 0 < printJob.contData.sendDataSize){\r
 799     /* send command */\r
 800     ret = SendCommand(printJob.contData.sendData, \r
 801                 printJob.contData.sendDataSize, &retBufSize, TRUE);\r
 802 \r
 803     if( EPS_ERR_NONE == ret ){\r
 804       if( band.dataSent ){\r
 805         /* send encode data */\r
 806         if( EP_COMPRESS0 != band.compressType ){\r
 807           debug_msg("band.pEncData = %d\n", band.pEncData);\r
 808           debug_msg("band.encDataSize = %d\n", band.encDataSize);\r
 809           ret = SendCommand(band.pEncData, band.encDataSize, &retBufSize, TRUE);\r
 810         } else{\r
 811           ret = SendCommand(band.pScanData, band.scanDataSize, &retBufSize, TRUE);\r
 812         }\r
 813 \r
 814         band.dataSent = FALSE;\r
 815       }\r
 816       if( EPS_ERR_NONE == ret){\r
 817         BandClear(&band);\r
 818       }\r
 819     }\r
 820   } else{\r
 821     ret = EPS_ERR_INVALID_CALL;\r
 822   }\r
 823   \r
 824   EPS_RETURN( ret )\r
 825 }\r
 826 \r
 827 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 828 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 829 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 830 /*--------------------               Local Functions               ---------------------*/\r
 831 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 832 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 833 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 834 \r
 835 \r
 836 /*******************************************|********************************************/\r
 837 /*                                                                                      */\r
 838 /* Function name:   CmdBuffInit()                           */\r
 839 /*                                                                                      */\r
 840 /* Arguments                                                                            */\r
 841 /* ---------                                                                            */\r
 842 /* Name:    Type:         Description:                                    */\r
 843 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 844 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
 845 /*                                                                                      */\r
 846 /* Return value:                                                                        */\r
 847 /*      EPS_ERR_NONE                    - Success                   */\r
 848 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 849 /*                                                                                      */\r
 850 /* Description:                                                                         */\r
 851 /*      Allocate command buffer.                                                  */\r
 852 /*                                                                                      */\r
 853 /*******************************************|********************************************/\r
 854 static EPS_ERR_CODE CmdBuffInit(\r
 855                 \r
 856     EPS_COMMAND_BUFFER* pCmdBuff, \r
 857     EPS_PAGE_BAND*    pBand\r
 858     \r
 859 ){\r
 860   pCmdBuff->pExtent = pBand;\r
 861 \r
 862   if(EP_COMPRESS0 == pBand->compressType){\r
 863     pCmdBuff->size = EPS_EJL_LINEMAX;\r
 864     pCmdBuff->p = EPS_ALLOC(pCmdBuff->size);\r
 865     if( NULL == pCmdBuff->p){\r
 866       return EPS_ERR_MEMORY_ALLOCATION;\r
 867     }\r
 868 \r
 869   } else{\r
 870     /* use scan-buffer as command-buffer */\r
 871     pCmdBuff->size  = pBand->scanBuffSize;\r
 872     pCmdBuff->p   = (EPS_INT8*)pBand->pScanData;\r
 873   }\r
 874 \r
 875   pCmdBuff->len = 0;\r
 876 \r
 877   return EPS_ERR_NONE;\r
 878 }\r
 879 \r
 880 \r
 881 /*******************************************|********************************************/\r
 882 /*                                                                                      */\r
 883 /* Function name:   CmdBuffGrow()                           */\r
 884 /*                                                                                      */\r
 885 /* Arguments                                                                            */\r
 886 /* ---------                                                                            */\r
 887 /* Name:    Type:         Description:                                    */\r
 888 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 889 /* addSize      EPS_INT32         I: growing size                                 */\r
 890 /*                                                                                      */\r
 891 /* Return value:                                                                        */\r
 892 /*      EPS_ERR_NONE                    - Success                   */\r
 893 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 894 /*                                                                                      */\r
 895 /* Description:                                                                         */\r
 896 /*      ReAllocate command buffer.                                                  */\r
 897 /*                                                                                      */\r
 898 /*******************************************|********************************************/\r
 899 static EPS_ERR_CODE CmdBuffGrow(\r
 900                 \r
 901     EPS_COMMAND_BUFFER* pCmdBuff, \r
 902     EPS_INT32     addSize\r
 903     \r
 904 ){\r
 905   EPS_INT32 block, sizeNew;\r
 906   EPS_PAGE_BAND *pBand = (EPS_PAGE_BAND*)pCmdBuff->pExtent;\r
 907 \r
 908   if(pCmdBuff->size < pCmdBuff->len + addSize){\r
 909     block = (((pCmdBuff->len+addSize) / EPS_PAGE_CMDBUFF_SIZE) + 1);\r
 910     sizeNew = block * EPS_PAGE_CMDBUFF_SIZE;\r
 911     pCmdBuff->p =  memRealloc(pCmdBuff->p, pCmdBuff->size, sizeNew);\r
 912     if( NULL == pCmdBuff->p){\r
 913       return EPS_ERR_MEMORY_ALLOCATION;\r
 914     }\r
 915     pCmdBuff->size = sizeNew;\r
 916 \r
 917     if(EP_COMPRESS0 != pBand->compressType){\r
 918       pBand->scanBuffSize = cmdBuf.size;\r
 919       pBand->pScanData  = (EPS_UINT8*)cmdBuf.p;\r
 920     }\r
 921   }\r
 922 \r
 923   return EPS_ERR_NONE;\r
 924 }\r
 925 \r
 926 \r
 927 /*******************************************|********************************************/\r
 928 /*                                                                                      */\r
 929 /* Function name:   CmdBuffTerm()                           */\r
 930 /*                                                                                      */\r
 931 /* Arguments                                                                            */\r
 932 /* ---------                                                                            */\r
 933 /* Name:    Type:         Description:                                    */\r
 934 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 935 /*                                                                                      */\r
 936 /* Return value:                                                                        */\r
 937 /* N/A                                          */\r
 938 /*                                                                                      */\r
 939 /* Description:                                                                         */\r
 940 /*      Free command buffer.                                                    */\r
 941 /*                                                                                      */\r
 942 /*******************************************|********************************************/\r
 943 static void CmdBuffTerm   (\r
 944                    \r
 945     EPS_COMMAND_BUFFER* pCmdBuff\r
 946                    \r
 947 ){\r
 948   EPS_PAGE_BAND* pBand = (EPS_PAGE_BAND*)pCmdBuff->pExtent;\r
 949 \r
 950   if( NULL != pBand ){\r
 951     if(EP_COMPRESS0 == pBand->compressType){\r
 952       EPS_SAFE_RELEASE(pCmdBuff->p);\r
 953     } else{\r
 954       pCmdBuff->p = NULL;\r
 955     }\r
 956   }\r
 957 \r
 958   pCmdBuff->len = 0;\r
 959   pCmdBuff->size = 0;\r
 960   pCmdBuff->pExtent = NULL;\r
 961 }\r
 962 \r
 963 \r
 964 /*******************************************|********************************************/\r
 965 /*                                                                                      */\r
 966 /* Function name:   RegisterPalette()                         */\r
 967 /*                                                                                      */\r
 968 /* Arguments                                                                            */\r
 969 /* ---------                                                                            */\r
 970 /* Name:    Type:         Description:                                    */\r
 971 /* paletteSize  EPS_UINT16          I: Palette Size                 */\r
 972 /* paletteData  EPS_UINT8*          I: Palette Size                 */\r
 973 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 974 /*                                                                                      */\r
 975 /* Return value:                                                                        */\r
 976 /*      EPS_ERR_NONE                    - Success                   */\r
 977 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 978 /*                                                                                      */\r
 979 /* Description:                                                                         */\r
 980 /*      Register the palette for Printer.                                               */\r
 981 /*                                                                                      */\r
 982 /*******************************************|********************************************/\r
 983 static EPS_ERR_CODE RegisterPalette(  \r
 984 \r
 985     EPS_UINT16      paletteSize,\r
 986     EPS_UINT8*      paletteData,\r
 987     EPS_COMMAND_BUFFER* pCmdBuff\r
 988 \r
 989 ){\r
 990   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 991   EPS_INT8  *p = NULL;\r
 992   EPS_UINT16  entryNum = paletteSize / 3; /* 3 = RGB */\r
 993   EPS_INT32 i = 0;\r
 994 \r
 995   EPS_LOG_FUNCIN\r
 996 \r
 997 #ifdef GCOMSW_DEBUG\r
 998   if(pCmdBuff->len+EPS_EJL_LINEMAX > pCmdBuff->size){EPS_DBGPRINT(("Command buffer not enough!\r\n"))}\r
 999 #endif\r
1000   p = pCmdBuff->p + pCmdBuff->len;\r
1001 \r
1002   sprintf(p, sbplrBE, entryNum*4);    /* 4 = RGBA */\r
1003   pCmdBuff->len += (EPS_UINT32)strlen(p);\r
1004 \r
1005   /* expand for palette data */\r
1006   ret = CmdBuffGrow(pCmdBuff, entryNum*4);\r
1007   if( EPS_ERR_NONE != ret){\r
1008     EPS_RETURN( ret )\r
1009   }\r
1010   p = pCmdBuff->p + pCmdBuff->len;\r
1011 \r
1012   /* set palette */\r
1013   for(i = 0; i < paletteSize; i+=3){\r
1014     *p++ = paletteData[i+2];  /* B */\r
1015     *p++ = paletteData[i+1];  /* G */\r
1016     *p++ = paletteData[i];    /* R */\r
1017     *p++ = 0;         /* dummy */\r
1018   }\r
1019   pCmdBuff->len = (EPS_INT32)(p - pCmdBuff->p);\r
1020 \r
1021   EPS_RETURN( ret )\r
1022 }\r
1023 \r
1024 \r
1025 /*******************************************|********************************************/\r
1026 /*                                                                                      */\r
1027 /* Function name:   BandInit()                              */\r
1028 /*                                                                                      */\r
1029 /* Arguments                                                                            */\r
1030 /* ---------                                                                            */\r
1031 /* Name:    Type:         Description:                                    */\r
1032 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1033 /*                                                                                      */\r
1034 /* Return value:                                                                        */\r
1035 /*      EPS_ERR_NONE                    - Success                   */\r
1036 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1037 /*                                                                                      */\r
1038 /* Description:                                                                         */\r
1039 /*      Allocate band data buffers.                           */\r
1040 /*                                                                                      */\r
1041 /*******************************************|********************************************/\r
1042 EPS_ERR_CODE BandInit(\r
1043             \r
1044     EPS_PAGE_BAND*  pBand\r
1045     \r
1046 ){\r
1047   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1048 \r
1049   EPS_LOG_FUNCIN\r
1050 \r
1051   memset(pBand, 0, sizeof(EPS_PAGE_BAND));\r
1052   pBand->compressType   = GetEncodeMode( printJob.attr.colorPlane );  /* Set compless mode */\r
1053   pBand->widthInPixels  = printJob.printableAreaWidth;\r
1054   pBand->scanDataSize   = 0;\r
1055   pBand->encDataSize    = 0;\r
1056   pBand->emited     = FALSE;\r
1057   pBand->dataSent     = FALSE;\r
1058 \r
1059 \r
1060   debug_msg("pBand->compressType = %d\n", pBand->compressType);\r
1061   if(EP_COMPRESS0 == pBand->compressType){\r
1062     pBand->scanLineSize = pBand->widthInPixels * printJob.bpp;\r
1063     pBand->scanBuffSize = pBand->scanLineSize;  /* one line buffering */\r
1064   } else{\r
1065     debug_msg("check compresstype bands \n");\r
1066     pBand->scanLineSize = (pBand->widthInPixels * printJob.bpp);\r
1067     if( pBand->scanLineSize & 3 ){\r
1068       debug_msg("check band scanline & 3 \n");\r
1069       /* 4bite align */\r
1070       pBand->scanLineSize = (pBand->scanLineSize & ~3) + 4;\r
1071     }\r
1072     pBand->scanBuffSize = pBand->scanLineSize * EPS_PAGE_RASTER;\r
1073   }\r
1074   debug_msg("pBand->scanBuffSize = %d\n", pBand->scanBuffSize);\r
1075   pBand->pScanData = (EPS_UINT8*)EPS_ALLOC( pBand->scanBuffSize );\r
1076   if( NULL == pBand->pScanData ){\r
1077     EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1078   }\r
1079 \r
1080   EPS_RETURN( ret )\r
1081 }\r
1082 \r
1083 \r
1084 /*******************************************|********************************************/\r
1085 /*                                                                                      */\r
1086 /* Function name:   BandTerm()                              */\r
1087 /*                                                                                      */\r
1088 /* Arguments                                                                            */\r
1089 /* ---------                                                                            */\r
1090 /* Name:    Type:         Description:                                    */\r
1091 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1092 /*                                                                                      */\r
1093 /* Return value:                                                                        */\r
1094 /* N/A                                          */\r
1095 /*                                                                                      */\r
1096 /* Description:                                                                         */\r
1097 /*      free band data buffers.                             */\r
1098 /*                                                                                      */\r
1099 /*******************************************|********************************************/\r
1100 static void BandTerm(\r
1101            \r
1102     EPS_PAGE_BAND* pBand\r
1103     \r
1104 ){\r
1105   EPS_LOG_FUNCIN\r
1106 \r
1107   EPS_SAFE_RELEASE(pBand->pScanData);\r
1108   BandClear(pBand);\r
1109 \r
1110   EPS_RETURN_VOID\r
1111 }\r
1112 \r
1113 \r
1114 /*******************************************|********************************************/\r
1115 /*                                                                                      */\r
1116 /* Function name:   BandEmit()                              */\r
1117 /*                                                                                      */\r
1118 /* Arguments                                                                            */\r
1119 /* ---------                                                                            */\r
1120 /* Name:    Type:         Description:                                    */\r
1121 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1122 /*                                                                                      */\r
1123 /* Return value:                                                                        */\r
1124 /*      EPS_ERR_NONE                    - Success                   */\r
1125 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1126 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1127 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1128 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
1129 /*                                                                                      */\r
1130 /* Description:                                                                         */\r
1131 /*      Emit data to printer.                             */\r
1132 /*                                                                                      */\r
1133 /*******************************************|********************************************/\r
1134 static EPS_ERR_CODE BandEmit(\r
1135                \r
1136     EPS_PAGE_BAND*  pBand\r
1137     \r
1138 ){\r
1139   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
1140   EPS_INT8    *p = NULL;\r
1141   EPS_UINT32      retBufSize = 0;\r
1142 \r
1143   EPS_LOG_FUNCIN\r
1144 \r
1145   cmdBuf.len = 0; /* reset */\r
1146   p = (EPS_INT8*)cmdBuf.p;\r
1147 \r
1148   if( pBand->emited ){\r
1149     /* end color image drawing for previous data */\r
1150     memcpy(p, sbECRI, sizeof(sbECRI));\r
1151     p += sizeof(sbECRI);\r
1152   } else{\r
1153     pBand->emited = TRUE;\r
1154   }\r
1155 \r
1156   /* Reset the current absolute position */\r
1157   strcpy(p, "\x1D""0X");\r
1158   p += strlen(p);\r
1159 \r
1160   EPS_DBGPRINT(("Emit Y pos = %d \r\n", emitRowCount));\r
1161   sprintf(p, "\x1D%dY", emitRowCount);\r
1162   p += strlen(p);\r
1163 \r
1164   /* ----- stretch color image -----  */\r
1165   if(printJob.attr.colorPlane == EPS_CP_256COLOR){\r
1166     strcpy(p, "\x1D""2;204;0;");    /* Indirectly RGB8, palett=0 */\r
1167   } else{\r
1168     strcpy(p, "\x1D""2;102;0;");    /* RGB888 */\r
1169   }\r
1170   p += strlen(p);\r
1171 \r
1172   switch(pBand->compressType){\r
1173   case EP_COMPRESS20:\r
1174     strcpy(p, "20;");\r
1175     break;\r
1176   case EP_COMPRESS0:\r
1177   default:\r
1178     strcpy(p, "0;");\r
1179     break;\r
1180   }\r
1181   p += strlen(p);\r
1182 \r
1183   sprintf(p, "%d;%d;%d;%d;0%s", pBand->currentWidthInPixels, pBand->rasterRow, \r
1184           pBand->currentWidthInPixels, pBand->rasterRow, sbSCRI);\r
1185   p += strlen(p);\r
1186 \r
1187   /*** Draw color image ***/ \r
1188   if(EP_COMPRESS20 == pBand->compressType){\r
1189     /* Number of data bytes */\r
1190     /* Bit image width */\r
1191     //debug_msg("pBand->rasterRow = %d\n",pBand->rasterRow);\r
1192     sprintf(p, sbCRI, pBand->encDataSize, pBand->rasterRow);\r
1193     p += strlen(p);\r
1194     ret = SendCommand((EPS_UINT8*)cmdBuf.p, (EPS_INT32)(p - (EPS_INT8*)cmdBuf.p), &retBufSize, TRUE);\r
1195 \r
1196     pBand->dataSent = TRUE;     /* encode date until send  */\r
1197     if( EPS_ERR_NONE == ret){\r
1198       debug_msg("ret = err_none \n");\r
1199       ret = SendCommand(pBand->pEncData, pBand->encDataSize, &retBufSize, TRUE);\r
1200       pBand->dataSent = FALSE;  /* encode date has sent */\r
1201     }\r
1202 \r
1203   } else{ /* non compless */\r
1204     /* Number of data bytes */\r
1205     /* Bit image width */\r
1206     sprintf(p, "\x1D""%d;%d%s", pBand->scanDataSize, pBand->rasterRow, sbCUI);\r
1207     p += strlen(p);\r
1208 \r
1209     ret = SendCommand((EPS_UINT8*)cmdBuf.p, (EPS_INT32)(p - (EPS_INT8*)cmdBuf.p), &retBufSize, TRUE);\r
1210 \r
1211     pBand->dataSent = TRUE;     /* encode date until send  */\r
1212     if( EPS_ERR_NONE == ret){\r
1213       ret = SendCommand(pBand->pScanData, pBand->scanDataSize, &retBufSize, TRUE);\r
1214       pBand->dataSent = FALSE;  /* encode date has sent */\r
1215     }\r
1216   }\r
1217 \r
1218   EPS_RETURN( ret )\r
1219 }\r
1220 \r
1221 \r
1222 /*******************************************|********************************************/\r
1223 /*                                                                                      */\r
1224 /* Function name:   BandSetScanData()                         */\r
1225 /*                                                                                      */\r
1226 /* Arguments                                                                            */\r
1227 /* ---------                                                                            */\r
1228 /* Name:    Type:         Description:                                    */\r
1229 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1230 /* Row      const EPS_UINT8*        I: band data                                    */\r
1231 /* DeltaByte  EPS_UINT32        I: number of data bytes             */\r
1232 /*                                                                                      */\r
1233 /* Return value:                                                                        */\r
1234 /*      EPS_ERR_NONE                    - Success                   */\r
1235 /*                                                                                      */\r
1236 /* Description:                                                                         */\r
1237 /*      save band data.                                 */\r
1238 /*                                                                                      */\r
1239 /*******************************************|********************************************/\r
1240 static EPS_ERR_CODE BandSetScanData(\r
1241                   \r
1242     EPS_PAGE_BAND*    pBand, \r
1243     const EPS_UINT8*  Row, \r
1244     EPS_UINT32      DeltaByte\r
1245     \r
1246 ){\r
1247   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1248 \r
1249   EPS_LOG_FUNCIN\r
1250 \r
1251   pBand->rasterRow++;\r
1252 \r
1253   if(EP_COMPRESS0 != pBand->compressType){\r
1254     debug_msg("DeltaByte = %d\n", DeltaByte);\r
1255     debug_msg("pBand->rasterRow = %d\n", pBand->rasterRow);\r
1256     memcpy(pBand->pScanData + (pBand->scanLineSize * (EPS_PAGE_RASTER - pBand->rasterRow)), Row, DeltaByte);\r
1257   } else{\r
1258     memcpy(pBand->pScanData, Row, DeltaByte);\r
1259   }\r
1260   //debug_msg("pBand->scanDataSize = %d\n", pBand->scanDataSize);\r
1261   pBand->scanDataSize += DeltaByte;\r
1262 \r
1263   EPS_RETURN( ret )\r
1264 }\r
1265 \r
1266 \r
1267 /*******************************************|********************************************/\r
1268 /*                                                                                      */\r
1269 /* Function name:   BandCompress()                            */\r
1270 /*                                                                                      */\r
1271 /* Arguments                                                                            */\r
1272 /* ---------                                                                            */\r
1273 /* Name:    Type:         Description:                                    */\r
1274 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1275 /* WidthBytes EPS_INT32           I: data length                                  */\r
1276 /* bitCount   EPS_INT32       I: image bit count                              */\r
1277 /*                                                                                      */\r
1278 /* Return value:                                                                        */\r
1279 /*      EPS_ERR_NONE                    - Success                   */\r
1280 /*                                                                                      */\r
1281 /* Description:                                                                         */\r
1282 /*      Data is compressed.                               */\r
1283 /*                                                                                      */\r
1284 /*******************************************|********************************************/\r
1285 static EPS_ERR_CODE BandCompress(\r
1286                  \r
1287     EPS_PAGE_BAND*  pBand, \r
1288     EPS_INT32   bitCount\r
1289     \r
1290 ){\r
1291   debug_msg("check compress \n");\r
1292   EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1293   EPS_BITMAPINFO    BitMapInfo;\r
1294   EPS_UINT32      lCompressType;\r
1295   EPS_UINT32      lImageSize = 0;\r
1296   EPS_RECT rect;\r
1297   EPS_UINT8*  pRealBits;\r
1298 \r
1299   EPS_LOG_FUNCIN\r
1300   \r
1301   memset(&BitMapInfo, 0, sizeof(EPS_BITMAPINFO));\r
1302 \r
1303   BitMapInfo.biWidth = pBand->currentWidthInPixels;\r
1304     BitMapInfo.biHeight = pBand->rasterRow;\r
1305   BitMapInfo.biBitCount = bitCount;\r
1306 \r
1307   rect.left = rect.top = 0;\r
1308   rect.bottom = pBand->rasterRow;\r
1309   rect.right = pBand->currentWidthInPixels;\r
1310 \r
1311   pRealBits = pBand->pScanData + (pBand->scanLineSize * (EPS_PAGE_RASTER - pBand->rasterRow));\r
1312 \r
1313   pBand->pEncData = CompressBitImage(\r
1314                 &rect,\r
1315                 &BitMapInfo,\r
1316                 pRealBits,\r
1317                 pBand->compressType,\r
1318                 &lCompressType,\r
1319                 &lImageSize\r
1320               );\r
1321   pBand->encDataSize = lImageSize;\r
1322   debug_msg("lImageSize = %d\n", lImageSize);\r
1323   debug_msg("pBand->encDataSize = %d\n", pBand->encDataSize);\r
1324 \r
1325   EPS_RETURN( ret )\r
1326 }\r
1327 \r
1328 \r
1329 /*******************************************|********************************************/\r
1330 /*                                                                                      */\r
1331 /* Function name:   BandClear()                             */\r
1332 /*                                                                                      */\r
1333 /* Arguments                                                                            */\r
1334 /* ---------                                                                            */\r
1335 /* Name:    Type:         Description:                                    */\r
1336 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1337 /*                                                                                      */\r
1338 /* Return value:                                                                        */\r
1339 /*      EPS_ERR_NONE                    - Success                   */\r
1340 /*                                                                                      */\r
1341 /* Description:                                                                         */\r
1342 /*      Reset band data.                                */\r
1343 /*                                                                                      */\r
1344 /*******************************************|********************************************/\r
1345 static void BandClear(\r
1346             \r
1347     EPS_PAGE_BAND *pBand\r
1348     \r
1349 ){\r
1350   EPS_LOG_FUNCIN\r
1351   EPS_SAFE_RELEASE(pBand->pEncData);\r
1352   pBand->scanDataSize = 0;\r
1353   pBand->encDataSize = 0;\r
1354   pBand->rasterRow = 0;\r
1355 \r
1356   EPS_RETURN_VOID\r
1357 }\r
1358 \r
1359 \r
1360 /*******************************************|********************************************/\r
1361 /*                                                                                      */\r
1362 /* Function name:   GetEncodeMode()                           */\r
1363 /*                                                                                      */\r
1364 /* Arguments                                                                            */\r
1365 /* ---------                                                                            */\r
1366 /* Name:    Type:         Description:                                    */\r
1367 /* pBand    EPS_PAGE_BAND*      I: band data strcture                       */\r
1368 /*                                                                                      */\r
1369 /* Return value:                                                                        */\r
1370 /*      EPS_ERR_NONE                    compless mode                 */\r
1371 /*                                                                                      */\r
1372 /* Description:                                                                         */\r
1373 /*      choose compless mode.                             */\r
1374 /*                                                                                      */\r
1375 /*******************************************|********************************************/\r
1376 static EPS_INT32 GetEncodeMode(\r
1377 \r
1378     EPS_INT32 bpp\r
1379 \r
1380 ){\r
1381   if(bpp == EPS_CP_256COLOR){\r
1382     return EP_COMPRESS0;\r
1383   } else{ /* if EPS_CP_FULLCOLOR */\r
1384     return EP_COMPRESS20;\r
1385   }\r
1386 }\r
1387 \r
1388 /*______________________________  epson-escpage-color.c   ______________________________*/\r
1389 \r
1390 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
1391 /*       1         2         3         4         5         6         7         8        */\r
1392 /*******************************************|********************************************/\r
1393 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1394 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/\r
1395 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r