lib/epson-escpage-mono.c

   1 /*_______________________________  epson-escpage-mono.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-mono.h"\r
  24 \r
  25 /*-----------------------------  Local Macro Definitions -------------------------------*/\r
  26 /*******************************************|********************************************/\r
  27 #ifdef EPS_LOG_MODULE_PAGE\r
  28 #define EPS_LOG_MODULE  EPS_LOG_MODULE_PAGE\r
  29 #else\r
  30 #define EPS_LOG_MODULE  0\r
  31 #endif\r
  32 \r
  33 /*--------------------------------  ESC/PAGE commands ----------------------------------*/\r
  34 /*******************************************|********************************************/\r
  35 const static EPS_UINT8 sbCR[]       = {0x0D};                                                                                   /* Carriage return "CR" */\r
  36 const static EPS_UINT8 sbFF[]           = {0x0C};                                                                                       /* Form Feed "FF" */\r
  37 const static EPS_UINT8 sbIP[]           = {0x1D, 'r', 'h', 'E'};\r
  38 \r
  39 const static EPS_UINT8 sbCSE[]          = {0x1D, '1', 'c', 's', 'E'};   \r
  40 \r
  41                                                 /* Initialize printer */\r
  42 const static EPS_UINT8 sbSU150[]    = {0x1D, '0', ';', '.', '4', '8', 'm', 'u', 'E'};   /* Set unit to 150 */\r
  43 const static EPS_UINT8 sbSU300[]    = {0x1D, '0', ';', '.', '2', '4', 'm', 'u', 'E'};   /* Set unit to 300 */\r
  44 const static EPS_UINT8 sbSU600[]    = {0x1D, '0', ';', '.', '1', '2', 'm', 'u', 'E'};   /* Set unit to 600 */\r
  45 const static EPS_UINT8 sbSU1200[]   = {0x1D, '0', ';', '.', '0', '6', 'm', 'u', 'E'};   /* Set unit to 1200 */\r
  46 \r
  47 const static EPS_UINT8 sbHTME300[] = {0x1D, '1', ';', '4', '5', ';', '7', '1', 'h', 't', 'm', 'E'};\r
  48 const static EPS_UINT8 sbHTME600[] = {0x1D, '1', ';', '4', '5', ';', '1', '0', '6', 'h', 't', 'm', 'E'};\r
  49 const static EPS_UINT8 sbHTME1200[] = {0x1D, '1', ';', '4', '5', ';', '1', '5', '6', 'h', 't', 'm', 'E'};\r
  50 \r
  51 const static EPS_UINT8 sbBGPG[]         = {0x1D, '1', 'b', 'g', 'p', 'G'};\r
  52 \r
  53 const static EPS_UINT8 sbCAPG[]         = {0x1D, '1', ';', '2', 'c', 'a', 'p', 'G'};\r
  54 \r
  55 \r
  56 const static EPS_UINT8 sbSDE0[]     = {0x1D, '0', 's', 'd', 'E'};                                               /* Set Duplex OFF */\r
  57 const static EPS_UINT8 sbSDE1[]     = {0x1D, '1', 's', 'd', 'E'};                                               /* Set Duplex ON */\r
  58 const static EPS_UINT8 sbBDE0[]     = {0x1D, '0', 'b', 'd', 'E'};                                               /* Set Duplex long */\r
  59 const static EPS_UINT8 sbBDE1[]     = {0x1D, '1', 'b', 'd', 'E'};                                               /* Set Duplex short */\r
  60 \r
  61 const static EPS_UINT8 sbPSSL[]     = {0x1D, '3', '0', 'p', 's', 'E'};                                  /* Set Letter paper */\r
  62 const static EPS_UINT8 sbPSSA4[]        = {0x1D, '1', '4', 'p', 's', 'E'};                                      /* Set A4 paper */\r
  63 const static EPS_UINT8 sbPSSB5[]    = {0x1D, '2', '5', 'p', 's', 'E'};                                  /* Set B5 paper */\r
  64 const static EPS_UINT8 sbPSSLE[]        = {0x1D, '3', '2', 'p', 's', 'E'};                                      /* Set Legal paper */\r
  65 const static EPS_UINT8 sbPSSA3[]        = {0x1D, '1', '3', 'p', 's', 'E'};                                      /* Set A3 paper */\r
  66 const static EPS_UINT8 sbPSSB4[]    = {0x1D, '2', '4', 'p', 's', 'E'};                                  /* Set B4 paper */\r
  67 const static EPS_UINT8 sbPSSPS[]    = {0x1D, '3', '8', 'p', 's', 'E'};                                  /* Set B4 paper */\r
  68 const static EPS_UINT8 sbPSSF4[]    = {0x1D, '3', '7', 'p', 's', 'E'};                                  /* Set F4 paper */\r
  69 const static EPS_UINT8 sbPSSA5[]    = {0x1D, '1', '5', 'p', 's', 'E'};                                  /* Set A5 paper */\r
  70 const static EPS_UINT8 sbPSSHLT[]    = {0x1D, '3', '1', 'p', 's', 'E'};                                 /* Set HLT paper */\r
  71 const static EPS_UINT8 sbPSSEXE[]    = {0x1D, '3', '3', 'p', 's', 'E'};                                 /* Set EXE paper */\r
  72 const static EPS_UINT8 sbPSSB[]    = {0x1D, '3', '6', 'p', 's', 'E'};                                   /* Set B paper */\r
  73 const static EPS_UINT8 sbPSSGLT[]    = {0x1D, '3', '5', 'p', 's', 'E'};                                 /* Set GLT paper */\r
  74 const static EPS_UINT8 sbPSSGLG[]    = {0x1D, '3', '4', 'p', 's', 'E'};                                 /* Set GLG paper */\r
  75 const static EPS_UINT8 sbPSSMON[]    = {0x1D, '8', '0', 'p', 's', 'E'};                                 /* Set MON paper */\r
  76 const static EPS_UINT8 sbPSSC10[]    = {0x1D, '8', '1', 'p', 's', 'E'};                                 /* Set C10 paper */\r
  77 const static EPS_UINT8 sbPSSDL[]    = {0x1D, '9', '0', 'p', 's', 'E'};                                  /* Set DL paper */\r
  78 const static EPS_UINT8 sbPSSC5[]    = {0x1D, '9', '1', 'p', 's', 'E'};                                  /* Set C5 paper */\r
  79 const static EPS_UINT8 sbPSSC6[]    = {0x1D, '9', '2', 'p', 's', 'E'};                                  /* Set C6 paper */\r
  80 const static EPS_UINT8 sbPSSIB5[]    = {0x1D, '9', '9', 'p', 's', 'E'};                                 /* Set IB5 paper */\r
  81 \r
  82 \r
  83 const static EPS_UINT8 sbIUE1[]    = {0x1D, '0', ';', '0', 'i', 'u', 'E'};\r
  84 const static EPS_UINT8 sbIUE0[]    = {0x1D, '1', '6', ';', '1', 'i', 'u', 'E'};\r
  85 const static EPS_UINT8 sbIUE2[]    = {0x1D, '1', ';', '1', 'i', 'u', 'E'};\r
  86 const static EPS_UINT8 sbIUE3[]    = {0x1D, '2', ';', '1', 'i', 'u', 'E'};\r
  87 const static EPS_UINT8 sbIUE4[]    = {0x1D, '3', ';', '1', 'i', 'u', 'E'};\r
  88 const static EPS_UINT8 sbIUE5[]    = {0x1D, '4', ';', '1', 'i', 'u', 'E'};\r
  89 const static EPS_UINT8 sbIUE6[]    = {0x1D, '5', ';', '1', 'i', 'u', 'E'};\r
  90 const static EPS_UINT8 sbIUE7[]    = {0x1D, '6', ';', '1', 'i', 'u', 'E'};\r
  91 const static EPS_UINT8 sbIUE8[]    = {0x1D, '7', ';', '1', 'i', 'u', 'E'};\r
  92 const static EPS_UINT8 sbIUE9[]    = {0x1D, '8', ';', '1', 'i', 'u', 'E'};\r
  93 const static EPS_UINT8 sbIUE10[]    = {0x1D, '9', ';', '1', 'i', 'u', 'E'};\r
  94 const static EPS_UINT8 sbIUE11[]    = {0x1D, '1', '0', ';', '1', 'i', 'u', 'E'};\r
  95 const static EPS_UINT8 sbIUE12[]    = {0x1D, '1', '1', ';', '1', 'i', 'u', 'E'};\r
  96 const static EPS_UINT8 sbIUE13[]    = {0x1D, '1', '2', ';', '1', 'i', 'u', 'E'};\r
  97 const static EPS_UINT8 sbIUE14[]    = {0x1D, '1', '3',';', '1', 'i', 'u', 'E'};\r
  98 const static EPS_UINT8 sbIUE15[]    = {0x1D, '2', '4',';', '1', 'i', 'u', 'E'};\r
  99 const static EPS_UINT8 sbIUE16[]    = {0x1D, '2', '5',';', '1', 'i', 'u', 'E'};\r
 100 \r
 101 \r
 102 const static EPS_UINT8 sbPTE0[]         = {0x1D, '0', 'p', 't', 'E'};                                           /* select paper type 0:other */\r
 103 const static EPS_UINT8 sbPTE1[]         = {0x1D, '1', 'p', 't', 'E'};                                           /* select paper type 1:plane */\r
 104 const static EPS_UINT8 sbPTE2[]         = {0x1D, '1', '3', 'p', 't', 'E'};                                              /* select paper type 1:semi thick */\r
 105 const static EPS_UINT8 sbPTE3[]         = {0x1D, '2', 'p', 't', 'E'};                                           /* select paper type 1:preprinter */\r
 106 const static EPS_UINT8 sbPTE4[]         = {0x1D, '3', 'p', 't', 'E'};                                           /* select paper type 1:letterhead */\r
 107 const static EPS_UINT8 sbPTE5[]         = {0x1D, '6', 'p', 't', 'E'};                                           /* select paper type 1:Recycled */\r
 108 const static EPS_UINT8 sbPTE6[]         = {0x1D, '7', 'p', 't', 'E'};                                           /* select paper type 1:color */\r
 109 const static EPS_UINT8 sbPTE7[]         = {0x1D, '9', 'p', 't', 'E'};                                           /* select paper type 1:labels */\r
 110 const static EPS_UINT8 sbPTE8[]         = {0x1D, '1', '2', 'p', 't', 'E'};                                              /* select paper type 1:thick */\r
 111 const static EPS_UINT8 sbPTE9[]         = {0x1D, '1', '6', 'p', 't', 'E'};                                              /* select paper type 1:coated */\r
 112 const static EPS_UINT8 sbPTE10[]                = {0x1D, '1', '0', 'p', 't', 'E'};                                              /* select paper type 1:special */\r
 113 const static EPS_UINT8 sbPTE11[]                = {0x1D, '1', '7', 'p', 't', 'E'};                                              /* select paper type 1:transparent */\r
 114 \r
 115 \r
 116 \r
 117 const static EPS_UINT8 sbCMS[]      = {0x1D, '1', 'c', 'm', 'E'};       /* Clip Mode Set */\r
 118 const static EPS_UINT8 sbSDS300[]   = {0x1D, '0', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'};       /* Select Dot Size(300) */\r
 119 const static EPS_UINT8 sbSDS600[]   = {0x1D, '0', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'};       /* Select Dot Size(600) */\r
 120 const static EPS_UINT8 sbSDS1200[]   = {0x1D, '0', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};    /* Select Dot Size(600) */\r
 121 const static EPS_UINT8 sbSDS150[]   = {0x1D, '0', ';', '1', '5', '0', ';', '1', '5', '0', 'd', 'r', 'E'};       /* Select Dot Size(150) */\r
 122 const static EPS_UINT8 sbSDS300_0[]   = {0x1D, '0', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(300) */\r
 123 const static EPS_UINT8 sbSDS300_1[]   = {0x1D, '1', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(300) */\r
 124 const static EPS_UINT8 sbSDS300_2[]   = {0x1D, '2', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(300) */\r
 125 const static EPS_UINT8 sbSDS300_9[]   = {0x1D, '9', ';', '3', '0', '0', ';', '3', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(300) */\r
 126 const static EPS_UINT8 sbSDS600_0[]   = {0x1D, '0', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(600) */\r
 127 const static EPS_UINT8 sbSDS600_1[]   = {0x1D, '1', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(600) */\r
 128 const static EPS_UINT8 sbSDS600_2[]   = {0x1D, '2', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(600) */\r
 129 const static EPS_UINT8 sbSDS600_9[]   = {0x1D, '9', ';', '6', '0', '0', ';', '6', '0', '0', 'd', 'r', 'E'};     /* Select Dot Size(600) */\r
 130 const static EPS_UINT8 sbSDS1200_0[]   = {0x1D, '0', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};\r
 131 const static EPS_UINT8 sbSDS1200_1[]   = {0x1D, '1', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};\r
 132 const static EPS_UINT8 sbSDS1200_2[]   = {0x1D, '2', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};\r
 133 const static EPS_UINT8 sbSDS1200_9[]   = {0x1D, '9', ';', '1', '2', '0', '0', ';', '1', '2', '0', '0', 'd', 'r', 'E'};\r
 134 const static EPS_UINT8 sbSS1200[]          = {0x1D, '1', ';', '1', ';', 'r', 'a', 'E'};\r
 135 \r
 136 const static EPS_UINT8 sbMMS[]          = {0x1D, '0', 'm', 'm', 'E'};                                           /* Select Page memory mode */\r
 137 const static EPS_UINT8 sbPDS0[]      = {0x1D, '0', 'p', 'o', 'E'};                                              /* Set paper direction to normal */\r
 138 const static EPS_UINT8 sbPDS1[]      = {0x1D, '1', 'p', 'o', 'E'};                                              /* Set paper direction to rotate */\r
 139 const static EPS_UINT8 sbACRLFS[]       = {0x1D, '0', 'a', 'l', 'f', 'P'};                                      /* Does not perform auto carriage return */\r
 140 const static EPS_UINT8 sbAFFS[]         = {0x1D, '0', 'a', 'f', 'f', 'P'};                      \r
 141 \r
 142 const static EPS_UINT8 sbCLFP[] = {0x1D, '0', ';', '0', ';', '0', 'c', 'l', 'f', 'P'};                  \r
 143                 /* Does not perform auto Form Feed */\r
 144 const static EPS_UINT8 sbABPS[]         = {0x1D, '0', 'a', 'b', 'P'};                                           /* Set current position to 0 after bit image draw */\r
 145 const static EPS_UINT8 sbSARGAS[]       = {0x1D, '0', 's', 'a', 'r', 'G'};                                      /* Set Absolute Graph Coordinate mode */\r
 146 const static EPS_UINT8 sbPMPPS[]        = {0x1D, '1', 'p', 'm', 'P'};                                           /* Set current move mode to print pitch mode */\r
 147 \r
 148 const static EPS_UINT8 sbSPRCS[]        = {0x1D, '1', '6', '0', 'i', 's', 'E'};                         /* Screen Pattern Record Count set to 160 */\r
 149 const static EPS_UINT8 sbFASCS[]        = {0x1D, '7', 'i', 'a', 'F'};                                           /* Font Attribute Store Count set to 7 */\r
 150 const static EPS_UINT8 sbCPSCS[]        = {0x1D, '5', 'i', 'p', 'P'};                                           /* Current Position Store Count set to 5 */\r
 151 const static EPS_UINT8 sbMRCS[]         = {0x1D, '1', '6', '0', 'i', 'm', 'M'};                         /* Macro Record Store Count set to 160 */\r
 152 const static EPS_UINT8 sbBIRCS[]        = {0x1D, '2', '3', '2', '8', 'i', 'b', 'I'};            /* Bit Image Count Store Count set to 2328 */\r
 153 const static EPS_UINT8 sbBIOS[]         = {0x1D, '0', 'b', 'o', 'P'};                                           /* Set the bit image drawing offset to 0 */\r
 154 const static EPS_UINT8 sbILGS[]         = {0x1D, '1', '6', '0', 'i', 'l', 'G'};                         /* Set line type record count to 160 */\r
 155 const static EPS_UINT8 sbTSESS[]        = {0x1D, '1', 't', 's', 'E'};                                           /* Set Screen Mode */\r
 156 const static EPS_UINT8 sbSPES[]         = {0x1D, '1', ';', '0', ';', '1', '0', '0', 's', 'p', 'E'};     /* Set Screen Pattern */\r
 157 const static EPS_UINT8 sbOWES[]         = {0x1D, '2', 'o', 'w', 'E'};                                           /* Set Superimpose Mode */\r
 158 \r
 159 const static EPS_UINT8 sbCCE[]          = {0x1D, '1', ';', '0', ';', '0', 'c', 'c', 'E'};\r
 160 \r
 161 const static EPS_UINT8 sbBCI1S[]        = {0x1D, '1', 'b', 'c', 'I'};                                           /* Select Data\r
 162  compression type #1 */\r
 163 \r
 164 const static EPS_UINT8 sbMLG[]          = {0x1D, '1', ';', '1', '0', 'm', 'l', 'G'};\r
 165 \r
 166 const static EPS_INT8 sbBID[]      = "\x1D""%d;%d;1;0bi{I";                                                             /* Output data */\r
 167 \r
 168 /*-----------------------------  Local Macro Definitions -------------------------------*/\r
 169 /*******************************************|********************************************/\r
 170 #define EPS_EJL_LINEMAX                         (256)\r
 171 #define EPS_PAGE_CMDBUFF_SIZE           EPS_EJL_LINEMAX\r
 172 \r
 173 #define EMIT_TIFF_REPEAT(n, x)          \\r
 174 {                                       \\r
 175     nRowTIFF += 3;                      \\r
 176     if (RowTIFF)                        \\r
 177     {                                   \\r
 178                 *RowTIFF++ = x;                 \\r
 179                 *RowTIFF++ = x;                 \\r
 180                 *RowTIFF++ = (EPS_UINT8)n;              \\r
 181     }                                   \\r
 182 }\r
 183 \r
 184 #define EMIT_TIFF_LITERAL(n, p)         \\r
 185 {                                       \\r
 186     nRowTIFF += n;                      \\r
 187     if (RowTIFF)                        \\r
 188     {                                   \\r
 189         memcpy(RowTIFF, p, n);          \\r
 190         RowTIFF += n;                   \\r
 191     }                                   \\r
 192 }\r
 193 \r
 194 #define TIFF_MAXIMUM_LITERAL 128\r
 195 #define TIFF_MAXIMUM_REPEAT  129\r
 196 \r
 197 #define CALCULATE_INTENSITY(r,g,b)  (((((b)<<8) * 11)/100 + (((g)<<8) * 59)/100 + (((r)<<8) * 30)/100)/256)\r
 198 #define MAX_8           ((1 << 8) - 1)\r
 199 #define DOT_K           100\r
 200 #define E_MAX           (1 << 13)\r
 201 #define E_MID           (E_MAX >> 1)\r
 202 \r
 203 /* The following table is used to convert a from an intensity we desire */\r
 204 /* to an intensity to tell the device. It is calibrated for the                 */\r
 205 /* error-diffusion code.                                                                                                */\r
 206 const EPS_UINT8 Intensity2Intensity[256] = \r
 207 {\r
 208         0,  3,  7,  10,  14,  17,  21,  24,  28,  35,  42,  49,  56,  63,  70,  77,  \r
 209  85,  88,  92,  95,  99,  103,  106,  110,  114,  117,  121,  125,  129,  132,  136,  140,  \r
 210  144,  144,  144,  144,  145,  145,  145,  145,  146,  147,  149,  151,  153,  154,  156,  158,  \r
 211  160,  161,  163,  164,  166,  167,  169,  170,  172,  173,  174,  175,  176,  177,  178,  179,  \r
 212  180,  181,  182,  183,  184,  185,  186,  187,  188,  188,  189,  190,  191,  192,  193,  194,  \r
 213  195,  195,  196,  196,  197,  198,  198,  199,  200,  200,  201,  202,  203,  203,  204,  205,  \r
 214  206,  206,  206,  206,  207,  207,  207,  207,  208,  208,  208,  208,  209,  209,  209,  209,  \r
 215  210,  210,  211,  211,  212,  212,  213,  213,  214,  214,  214,  214,  215,  215,  215,  215,  \r
 216  216,  216,  217,  217,  218,  218,  219,  219,  220,  220,  220,  220,  221,  221,  221,  221,  \r
 217  222,  222,  222,  222,  223,  223,  223,  223,  224,  224,  225,  225,  226,  226,  227,  227,  \r
 218  228,  228,  228,  228,  229,  229,  229,  229,  230,  230,  230,  230,  231,  231,  231,  231,  \r
 219  232,  232,  232,  232,  233,  233,  233,  233,  234,  234,  234,  234,  235,  235,  235,  235,  \r
 220  236,  236,  236,  236,  237,  237,  237,  237,  238,  238,  239,  239,  240,  240,  241,  241,  \r
 221  242,  242,  242,  242,  243,  243,  243,  243,  244,  244,  244,  244,  245,  245,  245,  245,  \r
 222  246,  246,  246,  246,  247,  247,  247,  247,  248,  248,  248,  248,  249,  249,  249,  249,  \r
 223  250,  250,  251,  251,  252,  252,  253,  253,  254,  254,  254,  254,  254,  254,  255,  255\r
 224 };\r
 225 \r
 226 /* Used in color correction */\r
 227 const static EPS_INT32 BitMask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };\r
 228 \r
 229 \r
 230 /*---------------------------  Data Structure Declarations   ---------------------------*/\r
 231 /*******************************************|********************************************/\r
 232 /* Band data */\r
 233 typedef struct _tagEPS_PAGE_BAND_M_ {\r
 234     EPS_INT32   WidthInBytes;\r
 235     EPS_INT32   WidthInPixels;\r
 236         EPS_INT32       currentWidthInPixels;\r
 237     EPS_UINT8   *pRasterData;\r
 238     EPS_UINT8   *pIntensity;\r
 239     EPS_INT32   encDataSize;\r
 240     EPS_UINT8   *pEncData;\r
 241         EPS_UINT8       *pZeroRow;\r
 242 }EPS_PAGE_BAND_M;\r
 243 \r
 244 /* Error Diffusion */\r
 245 typedef struct tagHT_PARAM{\r
 246         EPS_INT32       iDK;\r
 247         EPS_INT16       *pEK;\r
 248         EPS_INT32       iOrder;\r
 249         EPS_INT32       iScanPels;\r
 250 }   HT_PARAM;\r
 251 \r
 252 \r
 253 /*----------------------------  ESC/P-R Lib Global Variables  --------------------------*/\r
 254 /*******************************************|********************************************/\r
 255 extern EPS_CMN_FUNC             epsCmnFnc;\r
 256 extern EPS_PRINT_JOB    printJob;\r
 257 \r
 258 /*----------------------------------   Local Variables  --------------------------------*/\r
 259 /*******************************************|********************************************/\r
 260 static EPS_PAGE_BAND_M          band;\r
 261 static EPS_COMMAND_BUFFER       cmdBuf;\r
 262 static EPS_UINT8*                       Palette2DeviceIntensity = NULL;\r
 263 static EPS_INT32                        iRow = 0;\r
 264 static EPS_INT32                        iNumBytes = 0;\r
 265 static EPS_INT32                        iNumDots = 0;\r
 266 static EPS_INT32                        pageCount = 0;  /* Current Page number */\r
 267 \r
 268 #if EPS_PAGE_HT_ERR_DIFFUSION\r
 269 HT_PARAM        htParam;\r
 270 #else\r
 271 EPS_UINT8 * pP = 0;\r
 272 EPS_INT32 iOrder;\r
 273 EPS_INT32 iScanPels;\r
 274 #endif\r
 275 \r
 276 /*--------------------------  Local Functions Declaration   ----------------------------*/\r
 277 /*******************************************|********************************************/\r
 278 static EPS_ERR_CODE CmdBuffInit         (EPS_COMMAND_BUFFER *pCmdBuff);\r
 279 static EPS_ERR_CODE CmdBuffGrow         (EPS_COMMAND_BUFFER *pCmdBuff, EPS_INT32 addSize);\r
 280 static void                     CmdBuffTerm             (EPS_COMMAND_BUFFER *pCmdBuff);\r
 281 \r
 282 static void                     ConvertBYTE2Intensity   (const EPS_BANDBMP* pInBmp, EPS_PAGE_BAND_M *pBand);\r
 283 static EPS_ERR_CODE ConvertPaletteToIntensity(EPS_UINT16 paletteSize, EPS_UINT8 *paletteData);\r
 284 \r
 285 static EPS_ERR_CODE BandInit            (EPS_PAGE_BAND_M *pBand, EPS_INT32 widthInPixels);\r
 286 static void                     BandTerm                (EPS_PAGE_BAND_M* pBand);\r
 287 static void                     BandEncode              (EPS_PAGE_BAND_M* pBand);\r
 288 static EPS_ERR_CODE BandEmit            (EPS_PAGE_BAND_M *pBand, EPS_INT32 iNByte, EPS_INT32 iNDot);    \r
 289 \r
 290 static EPS_ERR_CODE HT_Init                     (EPS_INT32 WidthPixels);\r
 291 static void                     HT_End                  (void);\r
 292 static void                     HT_StartPage    (void);\r
 293 static void                     HT_Scan                 (EPS_UINT8 *Con, EPS_UINT8 *Bin, EPS_INT32 widthInPixels);\r
 294 \r
 295 static EPS_INT32 DoDeltaRow                     (EPS_UINT8 *Row, EPS_INT32 nRow, EPS_UINT8 *RowDeltaRow, EPS_UINT8 *Seed);\r
 296 \r
 297 \r
 298 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 299 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 300 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 301 /*--------------------              Public Functions               ---------------------*/\r
 302 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 303 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 304 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 305 \r
 306 /*******************************************|********************************************/\r
 307 /*                                                                                      */\r
 308 /* Function name:   pageAllocBuffer_M()                                                         */\r
 309 /*                                                                                      */\r
 310 /* Arguments                                                                            */\r
 311 /* ---------                                                                            */\r
 312 /* Name:                Type:                                   Description:                                    */\r
 313 /* N/A                                                                                                                                                                  */\r
 314 /*                                                                                      */\r
 315 /* Return value:                                                                        */\r
 316 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 317 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 318 /*                                                                                      */\r
 319 /* Description:                                                                         */\r
 320 /*      Allocate buffer for ESC/Page Job.                                                                                               */\r
 321 /*                                                                                      */\r
 322 /*******************************************|********************************************/\r
 323 EPS_ERR_CODE pageAllocBuffer_M(void)\r
 324 {\r
 325         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
 326 \r
 327         EPS_LOG_FUNCIN\r
 328 \r
 329         ret = BandInit(&band, printJob.printableAreaWidth);\r
 330         if ( EPS_ERR_NONE != ret ) {\r
 331                 EPS_RETURN( ret )\r
 332         }\r
 333         \r
 334         if (printJob.attr.colorPlane == EPS_CP_256COLOR){\r
 335                 ret = ConvertPaletteToIntensity(printJob.attr.paletteSize, printJob.attr.paletteData);\r
 336                 if ( EPS_ERR_NONE != ret ) {\r
 337                         EPS_RETURN( ret )\r
 338                 }\r
 339         }\r
 340 \r
 341         /* Halftoning Initialization */\r
 342         ret = HT_Init( printJob.printableAreaWidth );\r
 343         if ( EPS_ERR_NONE != ret ) {\r
 344                 EPS_RETURN( ret )\r
 345         }\r
 346 \r
 347         ret = CmdBuffInit(&cmdBuf);\r
 348 \r
 349         EPS_RETURN( ret )\r
 350 }\r
 351 \r
 352 \r
 353 /*******************************************|********************************************/\r
 354 /*                                                                                      */\r
 355 /* Function name:   pageRelaseBuffer_M()                                                        */\r
 356 /*                                                                                      */\r
 357 /* Arguments                                                                            */\r
 358 /* ---------                                                                            */\r
 359 /* Name:                Type:                                   Description:                                    */\r
 360 /* N/A                                                                                                                                                                  */\r
 361 /*                                                                                      */\r
 362 /* Return value:                                                                        */\r
 363 /*      N/A                                                                             */\r
 364 /*                                                                                      */\r
 365 /* Description:                                                                         */\r
 366 /*      Free buffer for ESC/Page Job.                                                           */\r
 367 /*                                                                                      */\r
 368 /*******************************************|********************************************/\r
 369 void pageRelaseBuffer_M(void)\r
 370 {\r
 371         EPS_LOG_FUNCIN\r
 372 \r
 373         BandTerm(&band);\r
 374         \r
 375         EPS_SAFE_RELEASE( Palette2DeviceIntensity );\r
 376 \r
 377         CmdBuffTerm(&cmdBuf);\r
 378 \r
 379         /* Halftoning Ending process */\r
 380         HT_End();\r
 381 \r
 382         EPS_RETURN_VOID\r
 383 }\r
 384 \r
 385 \r
 386 /*******************************************|********************************************/\r
 387 /*                                                                                      */\r
 388 /* Function name:   pageStartJob_M()                                                                                                    */\r
 389 /*                                                                                      */\r
 390 /* Arguments                                                                            */\r
 391 /* ---------                                                                            */\r
 392 /* Name:                Type:                                   Description:                                    */\r
 393 /* N/A                                                                                                                                                                  */\r
 394 /*                                                                                      */\r
 395 /* Return value:                                                                        */\r
 396 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 397 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 398 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 399 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 400 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 401 /*                                                                                      */\r
 402 /* Description:                                                                         */\r
 403 /*      Send ESC/Page start job commands.                                                               */\r
 404 /*                                                                                      */\r
 405 /*******************************************|********************************************/\r
 406 EPS_ERR_CODE pageStartJob_M(void)\r
 407 {\r
 408         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
 409         EPS_UINT32      retBufSize = 0;\r
 410 \r
 411         EPS_LOG_FUNCIN\r
 412 \r
 413 #define pgStartJob_ADDCMD(CMD) {                                                        \\r
 414                 ret = CmdBuffGrow(&cmdBuf, sizeof(CMD) );                       \\r
 415                 if( EPS_ERR_NONE != ret){EPS_RETURN( ret )}                     \\r
 416                 memcpy(cmdBuf.p + cmdBuf.len, CMD, sizeof(CMD));        \\r
 417                 cmdBuf.len += sizeof(CMD);                                                      \\r
 418         }\r
 419 \r
 420         cmdBuf.len = 0; /* reset */\r
 421         debug_msg("start Job MONO\n");\r
 422         ret = ejlStart(&cmdBuf, CmdBuffGrow);\r
 423         if( EPS_ERR_NONE != ret){\r
 424                 EPS_RETURN( ret )\r
 425         }\r
 426         debug_msg("step 10.0\n");\r
 427     /* Step 1 - Start Job */\r
 428     /* Initialize the printer. */\r
 429         pgStartJob_ADDCMD(sbIP)\r
 430         /* Set Memory Mode Selection to Page memory mode */\r
 431         pgStartJob_ADDCMD(sbMMS);\r
 432         pgStartJob_ADDCMD(sbCSE);\r
 433     /* Set the minimum Unit Setting (600 or 300 resolution)      */\r
 434         /* Dot Pattern Resolution Selection                                              */\r
 435         if(       EPS_IR_600X600 == printJob.attr.inputResolution) {\r
 436                 \r
 437                 pgStartJob_ADDCMD(sbSU600);\r
 438                 pgStartJob_ADDCMD(sbHTME600);\r
 439                 pgStartJob_ADDCMD(sbSDS600_9);\r
 440                 pgStartJob_ADDCMD(sbSDS600_2);\r
 441                 pgStartJob_ADDCMD(sbSDS600_1);\r
 442                 pgStartJob_ADDCMD(sbSDS600_0);\r
 443         } \r
 444         else if(EPS_IR_1200X1200 == printJob.attr.inputResolution) {\r
 445                 \r
 446                 pgStartJob_ADDCMD(sbSU1200);\r
 447                 pgStartJob_ADDCMD(sbHTME1200);  \r
 448                 pgStartJob_ADDCMD(sbSDS1200_9);\r
 449                 pgStartJob_ADDCMD(sbSDS1200_2);\r
 450                 pgStartJob_ADDCMD(sbSDS1200_1);\r
 451                 pgStartJob_ADDCMD(sbSDS1200_0); \r
 452                 pgStartJob_ADDCMD(sbSS1200);\r
 453         }\r
 454         else if(EPS_IR_300X300 == printJob.attr.inputResolution) {\r
 455                 \r
 456                 pgStartJob_ADDCMD(sbSU300);\r
 457                 pgStartJob_ADDCMD(sbHTME300);   \r
 458                 pgStartJob_ADDCMD(sbSDS300_9);\r
 459                 pgStartJob_ADDCMD(sbSDS300_2);\r
 460                 pgStartJob_ADDCMD(sbSDS300_1);\r
 461                 pgStartJob_ADDCMD(sbSDS300_0);\r
 462         }else{\r
 463                 pgStartJob_ADDCMD(sbSU150);\r
 464                 pgStartJob_ADDCMD(sbSDS150);\r
 465         }\r
 466 \r
 467         /* Set Screen Mode */\r
 468 \r
 469         pgStartJob_ADDCMD(sbTSESS);\r
 470 \r
 471                 \r
 472         /* Set Screen Pattern */\r
 473         pgStartJob_ADDCMD(sbOWES);\r
 474 \r
 475         \r
 476 \r
 477                 /* Does not perform automatic carriage return line feed */\r
 478         pgStartJob_ADDCMD(sbACRLFS);\r
 479 \r
 480         /* Does not perform automatic Form Feed */\r
 481         pgStartJob_ADDCMD(sbAFFS);\r
 482         \r
 483         pgStartJob_ADDCMD(sbCLFP);\r
 484         \r
 485                 /* Set current position move mode to print pitch */\r
 486         pgStartJob_ADDCMD(sbPMPPS);\r
 487         \r
 488         /* Set Bit Image Record Store Count */\r
 489         pgStartJob_ADDCMD(sbBIRCS);\r
 490 \r
 491                 /* Set Clip Mode */\r
 492         pgStartJob_ADDCMD(sbCMS);\r
 493 \r
 494            /* Select compression type */\r
 495         pgStartJob_ADDCMD(sbBCI1S);\r
 496 \r
 497         pgStartJob_ADDCMD(sbMLG);\r
 498 \r
 499                 /* Set Absolute graph coordinate mode */\r
 500         pgStartJob_ADDCMD(sbSARGAS);\r
 501 \r
 502                 /* Set Screen Pattern */\r
 503         pgStartJob_ADDCMD(sbSPES);\r
 504 \r
 505         pgStartJob_ADDCMD(sbCCE);\r
 506 \r
 507         if(             EPS_IR_1200X1200 == printJob.attr.inputResolution){\r
 508                 pgStartJob_ADDCMD(sbHTME1200);  \r
 509         }\r
 510         else if(EPS_IR_300X300 == printJob.attr.inputResolution){\r
 511                 pgStartJob_ADDCMD(sbHTME300);\r
 512         }\r
 513         else if(EPS_IR_600X600 == printJob.attr.inputResolution){\r
 514                 pgStartJob_ADDCMD(sbHTME600);\r
 515         }\r
 516 \r
 517         //pgStartJob_ADDCMD(sbBGPG);\r
 518 \r
 519         pgStartJob_ADDCMD(sbCAPG);\r
 520 \r
 521         /* set duplex */\r
 522         if(printJob.attr.duplex == EPS_DUPLEX_NONE){\r
 523                 pgStartJob_ADDCMD(sbSDE0);\r
 524         } else{\r
 525                 pgStartJob_ADDCMD(sbSDE1);\r
 526                 if(printJob.attr.duplex == EPS_DUPLEX_SHORT){\r
 527                         pgStartJob_ADDCMD(sbBDE1);\r
 528                 } else{\r
 529                         pgStartJob_ADDCMD(sbBDE0);\r
 530                 }\r
 531         }\r
 532 \r
 533 \r
 534 \r
 535         /* Set Screen Record Count */\r
 536         pgStartJob_ADDCMD(sbSPRCS);\r
 537         \r
 538         /* Set Font Attribute Store Count */\r
 539         pgStartJob_ADDCMD(sbFASCS);\r
 540 \r
 541         /* Set Current Position Store Count */\r
 542         pgStartJob_ADDCMD(sbCPSCS);\r
 543         \r
 544         \r
 545 \r
 546         /* Set Macro Record Store Count */\r
 547         pgStartJob_ADDCMD(sbMRCS);\r
 548         \r
 549         \r
 550         /* Set Manual Feed */\r
 551         if(printJob.attr.manualFeed == 1)\r
 552         {\r
 553                 pgStartJob_ADDCMD(sbIUE0);      /* manual */\r
 554         } else{\r
 555                 switch(printJob.attr.paperSource){\r
 556                 case IPS_MPTID_AUTO:\r
 557                         pgStartJob_ADDCMD(sbIUE1);      \r
 558                         break;\r
 559                 case IPS_MPTID_TRAY1:\r
 560                         pgStartJob_ADDCMD(sbIUE2);\r
 561                         break;\r
 562                 case IPS_MPTID_TRAY2:\r
 563                         pgStartJob_ADDCMD(sbIUE3);\r
 564                         break;\r
 565                 case IPS_MPTID_TRAY3:\r
 566                         pgStartJob_ADDCMD(sbIUE4);\r
 567                         break;\r
 568                 case IPS_MPTID_TRAY4:\r
 569                         pgStartJob_ADDCMD(sbIUE5);\r
 570                         break;\r
 571                 case IPS_MPTID_TRAY5:\r
 572                         pgStartJob_ADDCMD(sbIUE6);\r
 573                         break;\r
 574                 case IPS_MPTID_TRAY6:\r
 575                         pgStartJob_ADDCMD(sbIUE7);\r
 576                         break;\r
 577                 case IPS_MPTID_TRAY7:\r
 578                         pgStartJob_ADDCMD(sbIUE8);\r
 579                         break;\r
 580                 case IPS_MPTID_TRAY8:\r
 581                         pgStartJob_ADDCMD(sbIUE9);\r
 582                         break;\r
 583                 case IPS_MPTID_TRAY9:\r
 584                         pgStartJob_ADDCMD(sbIUE10);\r
 585                         break;\r
 586                 case IPS_MPTID_TRAY10:\r
 587                         pgStartJob_ADDCMD(sbIUE11);\r
 588                         break;\r
 589                 case IPS_MPTID_TRAY11:\r
 590                         pgStartJob_ADDCMD(sbIUE12);\r
 591                         break;\r
 592                 case IPS_MPTID_TRAY12:\r
 593                         pgStartJob_ADDCMD(sbIUE13);\r
 594                         break;\r
 595                 case IPS_MPTID_TRAY13:\r
 596                         pgStartJob_ADDCMD(sbIUE14);\r
 597                         break;\r
 598                 case IPS_MPTID_TRAY14:\r
 599                         pgStartJob_ADDCMD(sbIUE15);\r
 600                         break;\r
 601                 case IPS_MPTID_TRAY15:\r
 602                         pgStartJob_ADDCMD(sbIUE16);\r
 603                         break;\r
 604                 default:\r
 605                         pgStartJob_ADDCMD(sbIUE1);\r
 606                         break;\r
 607                 }\r
 608         } \r
 609 \r
 610 \r
 611 \r
 612         debug_msg("step 1\n");\r
 613         /* Set Paper Size */\r
 614         switch ( printJob.attr.mediaSizeIdx ) {\r
 615         case EPS_MSID_A4:                               pgStartJob_ADDCMD(sbPSSA4);     break;\r
 616         case EPS_MSID_A5:                       pgStartJob_ADDCMD(sbPSSA5);     break;\r
 617         case EPS_MSID_HLT:                      pgStartJob_ADDCMD(sbPSSHLT);    break;\r
 618         case EPS_MSID_EXECUTIVE:        pgStartJob_ADDCMD(sbPSSEXE);    break;\r
 619         case EPS_MSID_B:                                pgStartJob_ADDCMD(sbPSSB);              break;\r
 620         case EPS_MSID_GLT:                      pgStartJob_ADDCMD(sbPSSGLT);    break;\r
 621         case EPS_MSID_GLG:                      pgStartJob_ADDCMD(sbPSSGLG);    break;\r
 622         case EPS_MSID_MON:                      pgStartJob_ADDCMD(sbPSSMON);    break;\r
 623         case EPS_MSID_C10:                      pgStartJob_ADDCMD(sbPSSC10);    break;\r
 624         case EPS_MSID_DL:                               pgStartJob_ADDCMD(sbPSSDL);     break;\r
 625         case EPS_MSID_C5:                               pgStartJob_ADDCMD(sbPSSC5);     break;\r
 626         case EPS_MSID_C6:                               pgStartJob_ADDCMD(sbPSSC6);     break;\r
 627         case EPS_MSID_IB5:                      pgStartJob_ADDCMD(sbPSSIB5);    break;\r
 628         case EPS_MSID_F4:                               pgStartJob_ADDCMD(sbPSSF4);     break;\r
 629         case EPS_MSID_B5:                               pgStartJob_ADDCMD(sbPSSB5);     break;\r
 630         case EPS_MSID_B4:                               pgStartJob_ADDCMD(sbPSSB4);     break;  \r
 631         case EPS_MSID_A3:                               pgStartJob_ADDCMD(sbPSSA3);     break;\r
 632         case EPS_MSID_LETTER:           pgStartJob_ADDCMD(sbPSSL);      break;\r
 633         case EPS_MSID_LEGAL:                    pgStartJob_ADDCMD(sbPSSLE);     break;\r
 634         //case EPS_MSID_POSTCARD:       pgStartJob_ADDCMD(sbPSSPS);     break;\r
 635         default:                                                        pgStartJob_ADDCMD(sbPSSA4);     break;\r
 636         }\r
 637 \r
 638         /* select paper type */\r
 639 \r
 640         switch(printJob.attr.mediaTypeIdx){\r
 641         case EPS_MTID_PLAIN:            pgStartJob_ADDCMD(sbPTE1);      break;\r
 642         case EPS_MTID_SEMITHICK:        pgStartJob_ADDCMD(sbPTE2);      break;\r
 643         case EPS_MTID_PREPRINTED:       pgStartJob_ADDCMD(sbPTE3);      break;\r
 644         case EPS_MTID_LETTERHEAD:       pgStartJob_ADDCMD(sbPTE4);      break;\r
 645         case EPS_MTID_RECYCLED:         pgStartJob_ADDCMD(sbPTE5);      break;\r
 646         case EPS_MTID_COLOR:            pgStartJob_ADDCMD(sbPTE6);      break;\r
 647         case EPS_MTID_LABEL:            pgStartJob_ADDCMD(sbPTE7);      break;\r
 648         case EPS_MTID_THICK:            pgStartJob_ADDCMD(sbPTE8);      break;\r
 649         case EPS_MTID_COATED:           pgStartJob_ADDCMD(sbPTE9);      break;\r
 650         case EPS_MTID_SPECIAL:          pgStartJob_ADDCMD(sbPTE10);     break;\r
 651         case EPS_MTID_TRANSPARENT:      pgStartJob_ADDCMD(sbPTE11);     break;\r
 652         case EPS_MTID_UNSPECIFIED:      pgStartJob_ADDCMD(sbPTE0);      break;\r
 653         default:                                                        pgStartJob_ADDCMD(sbPTE0);              break;\r
 654         }\r
 655 \r
 656         /* Set paper direction */\r
 657         if(printJob.attr.orienTation == 1) \r
 658         {\r
 659                 pgStartJob_ADDCMD(sbPDS1);  /* Landscape */\r
 660         } else{\r
 661                 pgStartJob_ADDCMD(sbPDS0);      /* Potrait */\r
 662         }\r
 663 \r
 664         ret = ejlPageEsc(&cmdBuf, CmdBuffGrow);\r
 665         if( EPS_ERR_NONE != ret){\r
 666                 EPS_RETURN( ret )\r
 667         }\r
 668         debug_msg("step 2\n");\r
 669 \r
 670         \r
 671 \r
 672         /* Set the bit image drawing offset to 0 */\r
 673         pgStartJob_ADDCMD(sbBIOS);\r
 674 \r
 675         /* Set current position to 0 after Bit image draw */\r
 676         pgStartJob_ADDCMD(sbABPS);\r
 677 \r
 678         /* Set line type record count to 160 */\r
 679         pgStartJob_ADDCMD(sbILGS);\r
 680 \r
 681     /* Step 4 - Adjust Vertical Print Position (if necessary) */\r
 682     /* CR */\r
 683     pgStartJob_ADDCMD(sbCR);\r
 684     \r
 685  \r
 686 \r
 687 \r
 688 \r
 689 \r
 690 \r
 691 \r
 692         ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 693 \r
 694     pageCount = 0;\r
 695 \r
 696         EPS_RETURN( ret )\r
 697 }\r
 698 \r
 699 \r
 700 /*******************************************|********************************************/\r
 701 /*                                                                                      */\r
 702 /* Function name:   pageEndJob_M()                                                                                                              */\r
 703 /*                                                                                      */\r
 704 /* Arguments                                                                            */\r
 705 /* ---------                                                                            */\r
 706 /* Name:                Type:                                   Description:                                    */\r
 707 /* N/A                                                                                                                                                                  */\r
 708 /*                                                                                      */\r
 709 /* Return value:                                                                        */\r
 710 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 711 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 712 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 713 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 714 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 715 /*                                                                                      */\r
 716 /* Description:                                                                         */\r
 717 /*      Send ESC/Page end job commands.                                                                 */\r
 718 /*                                                                                      */\r
 719 /*******************************************|********************************************/\r
 720 EPS_ERR_CODE pageEndJob_M()\r
 721 {\r
 722         EPS_ERR_CODE    ret = EPS_ERR_NONE;           /* Return status of internal calls  */\r
 723         EPS_UINT32      retBufSize = 0;\r
 724 \r
 725         EPS_LOG_FUNCIN\r
 726 \r
 727         cmdBuf.len = 0; /* reset */\r
 728 \r
 729         /* Check empty document */\r
 730         if( iRow != 0 ) {\r
 731                 /* Formfeed (FF) */\r
 732                 memcpy((EPS_INT8*)cmdBuf.p, sbFF, sizeof(sbFF));\r
 733                 cmdBuf.len += sizeof(sbFF);\r
 734 \r
 735                 /* Send command to initialize the printer. */\r
 736                 memcpy((EPS_INT8*)cmdBuf.p+cmdBuf.len, sbIP, sizeof(sbIP));\r
 737                 cmdBuf.len += sizeof(sbIP);\r
 738         }\r
 739 \r
 740         /*** Make EJL Command ***/\r
 741         ret = ejlEnd(&cmdBuf, CmdBuffGrow, pageCount);\r
 742         if( EPS_ERR_NONE != ret){\r
 743                 EPS_RETURN( ret )\r
 744         }\r
 745 \r
 746         ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 747 \r
 748         EPS_RETURN( ret )\r
 749 }\r
 750 \r
 751 \r
 752 /*******************************************|********************************************/\r
 753 /*                                                                                      */\r
 754 /* Function name:   pageStartPage_M()                                                                                                   */\r
 755 /*                                                                                      */\r
 756 /* Arguments                                                                            */\r
 757 /* ---------                                                                            */\r
 758 /* Name:                Type:                                   Description:                                    */\r
 759 /* N/A                                                                                                                                                                  */\r
 760 /*                                                                                      */\r
 761 /* Return value:                                                                        */\r
 762 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 763 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 764 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 765 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 766 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 767 /*                                                                                      */\r
 768 /* Description:                                                                         */\r
 769 /*      Send ESC/Page start page commands.                                                                  */\r
 770 /*                                                                                      */\r
 771 /*******************************************|********************************************/\r
 772 EPS_ERR_CODE pageStartPage_M()\r
 773 {\r
 774         debug_msg("check call function pageStartPage_M \n");\r
 775         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 776         EPS_UINT32  retBufSize = 0;\r
 777 \r
 778         EPS_LOG_FUNCIN\r
 779 \r
 780         HT_StartPage();\r
 781     iRow = 0;\r
 782 \r
 783         if (pageCount++) {\r
 784 \r
 785                 cmdBuf.len = 0; /* reset */\r
 786 \r
 787                 memcpy(cmdBuf.p, sbFF, sizeof(sbFF));\r
 788                 cmdBuf.len += sizeof(sbFF);\r
 789 \r
 790                 ret = ejlPageEsc(&cmdBuf, CmdBuffGrow);\r
 791                 if( EPS_ERR_NONE != ret){\r
 792                         EPS_RETURN( ret )\r
 793                 }\r
 794 \r
 795                 ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
 796     }\r
 797 \r
 798         EPS_RETURN( ret );\r
 799 }\r
 800 \r
 801 \r
 802 /*******************************************|********************************************/\r
 803 /*                                                                                      */\r
 804 /* Function name:   pageColorRow_M()                                                                                                    */\r
 805 /*                                                                                      */\r
 806 /* Arguments                                                                            */\r
 807 /* ---------                                                                            */\r
 808 /* Name:                Type:                                   Description:                                    */\r
 809 /* N/A                                                                                                                                                                  */\r
 810 /*                                                                                      */\r
 811 /* Return value:                                                                        */\r
 812 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 813 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 814 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 815 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 816 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 817 /*                                                                                      */\r
 818 /* Description:                                                                         */\r
 819 /*      Send ESC/Page raster commands.                                                                      */\r
 820 /*                                                                                      */\r
 821 /*******************************************|********************************************/\r
 822 EPS_ERR_CODE pageColorRow_M(        \r
 823                                                   \r
 824                 const EPS_BANDBMP*  pInBmp,\r
 825         EPS_RECT*           pBandRec\r
 826 \r
 827 ){\r
 828         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
 829 \r
 830         EPS_LOG_FUNCIN\r
 831 \r
 832     if( (EPS_UINT32)(pBandRec->right - pBandRec->left) <= printJob.printableAreaWidth){\r
 833         band.currentWidthInPixels = (EPS_UINT16)(pBandRec->right - pBandRec->left);\r
 834     } else{\r
 835         band.currentWidthInPixels = (EPS_UINT16) printJob.printableAreaWidth;\r
 836     }\r
 837 \r
 838         ConvertBYTE2Intensity( pInBmp, &band );\r
 839 \r
 840     memset( band.pRasterData, 0, band.WidthInBytes);\r
 841         HT_Scan( band.pIntensity, (EPS_UINT8*)band.pRasterData, band.currentWidthInPixels);\r
 842 \r
 843         iNumBytes = 0;\r
 844         iNumDots = 0;\r
 845 \r
 846         BandEncode(&band);\r
 847 \r
 848     if( band.encDataSize ) {\r
 849                 ret = BandEmit(&band, iNumBytes, iNumDots);\r
 850     }\r
 851 \r
 852         iRow++;\r
 853 \r
 854         EPS_RETURN( ret )\r
 855 }\r
 856 \r
 857 \r
 858 /*******************************************|********************************************/\r
 859 /*                                                                                      */\r
 860 /* Function name:   pageSendLeftovers_M()                                                                                               */\r
 861 /*                                                                                      */\r
 862 /* Arguments                                                                            */\r
 863 /* ---------                                                                            */\r
 864 /* Name:                Type:                                   Description:                                    */\r
 865 /* N/A                                                                                                                                                                  */\r
 866 /*                                                                                      */\r
 867 /* Return value:                                                                        */\r
 868 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 869 /*      EPS_ERR_INVALID_CALL            - This call was unnecessary                     */\r
 870 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 871 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 872 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 873 /*                                                                                      */\r
 874 /* Description:                                                                         */\r
 875 /*      send leftovers data.                                                            */\r
 876 /*                                                                                      */\r
 877 /*******************************************|********************************************/\r
 878 EPS_ERR_CODE pageSendLeftovers_M(\r
 879                                                            \r
 880                    void\r
 881                                                            \r
 882 ){\r
 883         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
 884         EPS_UINT32      retBufSize = 0;\r
 885 \r
 886         EPS_LOG_FUNCIN\r
 887 \r
 888         if( NULL != printJob.contData.sendData && 0 < printJob.contData.sendDataSize){\r
 889                 /* send command */\r
 890                 ret = SendCommand(printJob.contData.sendData, \r
 891                                                                 printJob.contData.sendDataSize, &retBufSize, TRUE);\r
 892         } else{\r
 893                 ret = EPS_ERR_INVALID_CALL;\r
 894         }\r
 895         \r
 896         EPS_RETURN( ret )\r
 897 }\r
 898 \r
 899 \r
 900 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 901 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 902 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 903 /*--------------------               Local Functions               ---------------------*/\r
 904 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 905 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 906 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 907 \r
 908 /*******************************************|********************************************/\r
 909 /*                                                                                      */\r
 910 /* Function name:   CmdBuffInit()                                                                                                               */\r
 911 /*                                                                                      */\r
 912 /* Arguments                                                                            */\r
 913 /* ---------                                                                            */\r
 914 /* Name:                Type:                                   Description:                                    */\r
 915 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 916 /*                                                                                      */\r
 917 /* Return value:                                                                        */\r
 918 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 919 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 920 /*                                                                                      */\r
 921 /* Description:                                                                         */\r
 922 /*      Allocate command buffer.                                                                    */\r
 923 /*                                                                                      */\r
 924 /*******************************************|********************************************/\r
 925 static EPS_ERR_CODE CmdBuffInit(\r
 926                                                                 \r
 927                 EPS_COMMAND_BUFFER *pCmdBuff\r
 928                 \r
 929 ){\r
 930         pCmdBuff->size = EPS_EJL_LINEMAX*2;\r
 931         pCmdBuff->p = (EPS_INT8*)EPS_ALLOC(pCmdBuff->size);\r
 932         if( NULL == pCmdBuff->p){\r
 933                 return EPS_ERR_MEMORY_ALLOCATION;\r
 934         }\r
 935 \r
 936         pCmdBuff->len = 0;\r
 937 \r
 938         return EPS_ERR_NONE;\r
 939 }\r
 940 \r
 941 \r
 942 /*******************************************|********************************************/\r
 943 /*                                                                                      */\r
 944 /* Function name:   CmdBuffGrow()                                                                                                               */\r
 945 /*                                                                                      */\r
 946 /* Arguments                                                                            */\r
 947 /* ---------                                                                            */\r
 948 /* Name:                Type:                                   Description:                                    */\r
 949 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 950 /* addSize      EPS_INT32                           I: growing size                                 */\r
 951 /*                                                                                      */\r
 952 /* Return value:                                                                        */\r
 953 /*      EPS_ERR_NONE                    - Success                                                                               */\r
 954 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 955 /*                                                                                      */\r
 956 /* Description:                                                                         */\r
 957 /*      ReAllocate command buffer.                                                                  */\r
 958 /*                                                                                      */\r
 959 /*******************************************|********************************************/\r
 960 static EPS_ERR_CODE CmdBuffGrow(\r
 961                                                                 \r
 962                 EPS_COMMAND_BUFFER *pCmdBuff, \r
 963                 EPS_INT32                       addSize\r
 964                 \r
 965 ){\r
 966         EPS_INT32       block, sizeNew;\r
 967 \r
 968         if(pCmdBuff->size < pCmdBuff->len + addSize){\r
 969                 block = (((pCmdBuff->len+addSize) / EPS_PAGE_CMDBUFF_SIZE) + 1);\r
 970                 sizeNew = block * EPS_PAGE_CMDBUFF_SIZE;\r
 971                 pCmdBuff->p =  memRealloc(pCmdBuff->p, pCmdBuff->size, sizeNew);\r
 972                 if( NULL == pCmdBuff->p){\r
 973                         return EPS_ERR_MEMORY_ALLOCATION;\r
 974                 }\r
 975                 pCmdBuff->size = sizeNew;\r
 976         }\r
 977 \r
 978         return EPS_ERR_NONE;\r
 979 }\r
 980 \r
 981 \r
 982 /*******************************************|********************************************/\r
 983 /*                                                                                      */\r
 984 /* Function name:   CmdBuffTerm()                                                                                                               */\r
 985 /*                                                                                      */\r
 986 /* Arguments                                                                            */\r
 987 /* ---------                                                                            */\r
 988 /* Name:                Type:                                   Description:                                    */\r
 989 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
 990 /*                                                                                      */\r
 991 /* Return value:                                                                        */\r
 992 /* N/A                                                                                                                                                                  */\r
 993 /*                                                                                      */\r
 994 /* Description:                                                                         */\r
 995 /*      Free command buffer.                                                                        */\r
 996 /*                                                                                      */\r
 997 /*******************************************|********************************************/\r
 998 static void CmdBuffTerm         (\r
 999                                                                          \r
1000                 EPS_COMMAND_BUFFER      *pCmdBuff\r
1001                                                                          \r
1002 ){\r
1003         EPS_SAFE_RELEASE(pCmdBuff->p);\r
1004         pCmdBuff->len = 0;\r
1005         pCmdBuff->size = 0;\r
1006         pCmdBuff->pExtent = NULL;\r
1007 }\r
1008 \r
1009 \r
1010 /*******************************************|********************************************/\r
1011 /*                                                                                      */\r
1012 /* Function name:   ConvertBYTE2Intensity()                                                                                             */\r
1013 /*                                                                                      */\r
1014 /* Arguments                                                                            */\r
1015 /* ---------                                                                            */\r
1016 /* Name:                Type:                                   Description:                                    */\r
1017 /* paletteSize  EPS_UINT16                          I: Palette Size                                                                     */\r
1018 /* paletteData  EPS_UINT8*                          I: Palette Size                                                                     */\r
1019 /*                                                                                      */\r
1020 /* Return value:                                                                        */\r
1021 /* N/A                                                                                                                                                                  */\r
1022 /*                                                                                      */\r
1023 /* Description:                                                                         */\r
1024 /*      Convert palette to Intensity.                                                                                                   */\r
1025 /*                                                                                      */\r
1026 /*******************************************|********************************************/\r
1027 static void ConvertBYTE2Intensity(\r
1028                                                                   \r
1029                 const EPS_BANDBMP* pInBmp, \r
1030                 EPS_PAGE_BAND_M *pBand\r
1031                 \r
1032 ){\r
1033         EPS_UINT32 idx;\r
1034         EPS_INT32 i, j, widthBytes;\r
1035 \r
1036         EPS_LOG_FUNCIN;\r
1037 \r
1038         widthBytes = pBand->currentWidthInPixels * printJob.bpp;\r
1039         j = 0;\r
1040                 \r
1041         debug_msg("printJob.bpp = %d\n", printJob.bpp);\r
1042         if(printJob.bpp == 3){\r
1043                 for (i = 0; i < widthBytes; i += printJob.bpp) {\r
1044                         /* idx = CALCULATE_INTENSITY(pInBmp->bits[i], pInBmp->bits[i+1], pInBmp->bits[i+2]);*/\r
1045                         idx = pInBmp->bits[i];\r
1046                         idx = 255 - idx;\r
1047                         if (idx > 255) idx = 255;\r
1048 \r
1049                         pBand->pIntensity[j++] = 255-Intensity2Intensity[255-idx];\r
1050 \r
1051                         if(j >= pBand->WidthInPixels){\r
1052                                 break;\r
1053                         }\r
1054            }\r
1055         } else{\r
1056                 for (i = 0; i < widthBytes; i += printJob.bpp) {\r
1057                         idx = pInBmp->bits[i];\r
1058                         pBand->pIntensity[j++] = Palette2DeviceIntensity[idx];\r
1059                         if(j >= pBand->WidthInPixels){\r
1060                                 break;\r
1061                         }\r
1062                 }\r
1063         }\r
1064  \r
1065    EPS_RETURN_VOID\r
1066 }\r
1067 \r
1068 \r
1069 /*******************************************|********************************************/\r
1070 /*                                                                                      */\r
1071 /* Function name:   ConvertPaletteToIntensity()                                                                                 */\r
1072 /*                                                                                      */\r
1073 /* Arguments                                                                            */\r
1074 /* ---------                                                                            */\r
1075 /* Name:                Type:                                   Description:                                    */\r
1076 /* paletteSize  EPS_UINT16                          I: Palette Size                                                                     */\r
1077 /* paletteData  EPS_UINT8*                          I: Palette Size                                                                     */\r
1078 /*                                                                                      */\r
1079 /* Return value:                                                                        */\r
1080 /*      EPS_ERR_NONE                    - Success                                                                               */\r
1081 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1082 /*                                                                                      */\r
1083 /* Description:                                                                         */\r
1084 /*      Convert palette to Intensity.                                                                                                   */\r
1085 /*                                                                                      */\r
1086 /*******************************************|********************************************/\r
1087 static EPS_ERR_CODE ConvertPaletteToIntensity(\r
1088 \r
1089                 EPS_UINT16  paletteSize,\r
1090                 EPS_UINT8       *paletteData\r
1091                                            \r
1092 ){\r
1093         EPS_UINT32 idx;\r
1094         EPS_UINT32 i, j;\r
1095         EPS_LOG_FUNCIN;\r
1096 \r
1097         Palette2DeviceIntensity = (EPS_UINT8*)EPS_ALLOC( (paletteSize/3)*sizeof(EPS_UINT8) );\r
1098         if (!Palette2DeviceIntensity) {\r
1099                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1100         }\r
1101         j = 0;\r
1102     for (i = 0; i < paletteSize; i += 3) {\r
1103                 /* idx = CALCULATE_INTENSITY(paletteData[i], paletteData[i+1], paletteData[i+2]); */\r
1104                 idx = paletteData[i];\r
1105                 idx = 255 - idx;\r
1106         if (idx > 255) idx = 255;\r
1107                 Palette2DeviceIntensity[j++] = Intensity2Intensity[idx];\r
1108         }\r
1109 \r
1110         EPS_RETURN( EPS_ERR_NONE )\r
1111 }\r
1112 \r
1113 \r
1114 /*******************************************|********************************************/\r
1115 /*                                                                                      */\r
1116 /* Function name:   BandInit()                                                                                                                  */\r
1117 /*                                                                                      */\r
1118 /* Arguments                                                                            */\r
1119 /* ---------                                                                            */\r
1120 /* Name:                Type:                                   Description:                                    */\r
1121 /* pBand                EPS_PAGE_BAND_M*                I: band data strcture                               */\r
1122 /* widthInPixels EPS_INT32                          I: width in Pixels                                                          */\r
1123 /*                                                                                      */\r
1124 /* Return value:                                                                        */\r
1125 /*      EPS_ERR_NONE                    - Success                                                                               */\r
1126 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1127 /*                                                                                      */\r
1128 /* Description:                                                                         */\r
1129 /*      Allocate band data buffers.                                                                                                             */\r
1130 /*                                                                                      */\r
1131 /*******************************************|********************************************/\r
1132 static EPS_ERR_CODE BandInit(\r
1133                                                          \r
1134                 EPS_PAGE_BAND_M*        pBand, \r
1135                 EPS_INT32               widthInPixels\r
1136                 \r
1137 ){\r
1138         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
1139         EPS_INT32 maxEpsonEncodedData;\r
1140 \r
1141         EPS_LOG_FUNCIN;\r
1142 \r
1143         memset(pBand, 0, sizeof(pBand));\r
1144 \r
1145     pBand->WidthInPixels = widthInPixels;\r
1146     pBand->WidthInBytes = (pBand->WidthInPixels+7)/8;\r
1147 \r
1148     /* We leave room for an entire TIFF literal -plus- room     */\r
1149     /* for the longest possible XFER header (3 bytes).          */\r
1150     maxEpsonEncodedData = 256 + 3 + pBand->WidthInBytes\r
1151         + (pBand->WidthInBytes + TIFF_MAXIMUM_LITERAL - 1)/TIFF_MAXIMUM_LITERAL;\r
1152 \r
1153     pBand->pRasterData       = (EPS_UINT8*)EPS_ALLOC(pBand->WidthInBytes);\r
1154     if (NULL == pBand->pRasterData) {\r
1155                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1156     }\r
1157 \r
1158         pBand->pEncData = (EPS_UINT8*)EPS_ALLOC(maxEpsonEncodedData);\r
1159     if (NULL == pBand->pEncData) {\r
1160                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1161     }\r
1162 \r
1163         pBand->pZeroRow                  = (EPS_UINT8*)EPS_ALLOC(pBand->WidthInBytes);\r
1164     if (NULL == pBand->pZeroRow) {\r
1165                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1166     }\r
1167     memset(pBand->pZeroRow, 0, pBand->WidthInBytes);\r
1168 \r
1169     pBand->pIntensity        = (EPS_UINT8*)EPS_ALLOC(pBand->WidthInPixels);\r
1170         if (!pBand->pIntensity){\r
1171                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1172         }\r
1173 \r
1174         EPS_RETURN(ret)\r
1175 }\r
1176 \r
1177 \r
1178 /*******************************************|********************************************/\r
1179 /*                                                                                      */\r
1180 /* Function name:   BandTerm()                                                                                                                  */\r
1181 /*                                                                                      */\r
1182 /* Arguments                                                                            */\r
1183 /* ---------                                                                            */\r
1184 /* Name:                Type:                                   Description:                                    */\r
1185 /* pBand                EPS_PAGE_BAND_M*                I: band data strcture                               */\r
1186 /*                                                                                      */\r
1187 /* Return value:                                                                        */\r
1188 /* N/A                                                                                                                                                                  */\r
1189 /*                                                                                      */\r
1190 /* Description:                                                                         */\r
1191 /*      free band data buffers.                                                                                                                 */\r
1192 /*                                                                                      */\r
1193 /*******************************************|********************************************/\r
1194 static void BandTerm(\r
1195                                          \r
1196                 EPS_PAGE_BAND_M* pBand\r
1197                 \r
1198 ){\r
1199         EPS_LOG_FUNCIN\r
1200 \r
1201         EPS_SAFE_RELEASE( pBand->pRasterData );\r
1202         EPS_SAFE_RELEASE( pBand->pEncData );\r
1203         EPS_SAFE_RELEASE( pBand->pZeroRow );\r
1204         EPS_SAFE_RELEASE( pBand->pIntensity );\r
1205 \r
1206         EPS_RETURN_VOID\r
1207 }\r
1208 \r
1209 \r
1210 /*******************************************|********************************************/\r
1211 /*                                                                                      */\r
1212 /* Function name:   BandEmit()                                                                                                                  */\r
1213 /*                                                                                      */\r
1214 /* Arguments                                                                            */\r
1215 /* ---------                                                                            */\r
1216 /* Name:                Type:                                   Description:                                    */\r
1217 /* pBand                EPS_PAGE_BAND_M*                I: band data strcture                               */\r
1218 /* pCmdBuff     EPS_COMMAND_BUFFER*     I: command buffer strcture                      */\r
1219 /* iNByte               EPS_INT32                               I: number of data bytes                                                 */\r
1220 /* iNDot                EPS_INT32                               I: number of data dots                                                  */\r
1221 /*                                                                                      */\r
1222 /* Return value:                                                                        */\r
1223 /*      EPS_ERR_NONE                    - Success                                                                               */\r
1224 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
1225 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1226 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1227 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
1228 /*                                                                                      */\r
1229 /* Description:                                                                         */\r
1230 /*      Emit data to printer.                                                                                                                   */\r
1231 /*                                                                                      */\r
1232 /*******************************************|********************************************/\r
1233 static EPS_ERR_CODE BandEmit(\r
1234                                                          \r
1235                 EPS_PAGE_BAND_M*                pBand, \r
1236                 EPS_INT32                       iNByte, \r
1237                 EPS_INT32                       iNDot\r
1238                                                          \r
1239 ){\r
1240         EPS_ERR_CODE    ret = EPS_ERR_NONE;\r
1241         EPS_INT8                *p;\r
1242         EPS_UINT32      retBufSize = 0;\r
1243 \r
1244         EPS_LOG_FUNCIN\r
1245 \r
1246         cmdBuf.len = 0; /* reset */\r
1247         p = (EPS_INT8*)cmdBuf.p;\r
1248 \r
1249         EPS_DBGPRINT(("Y = %d \r\n", iRow));\r
1250         sprintf(p, "\x1D%dY", iRow);\r
1251         p += strlen(p);\r
1252 \r
1253         /* Number of data bytes  */\r
1254         /* Bit image width               */\r
1255         /* Bit image height              */\r
1256         /* Angle of rotation     */\r
1257         sprintf(p, sbBID, iNByte, iNDot);\r
1258         p += strlen(p);\r
1259 \r
1260         cmdBuf.len += (EPS_UINT32)(p - cmdBuf.p);       \r
1261         ret = CmdBuffGrow(&cmdBuf, pBand->encDataSize);\r
1262         if( EPS_ERR_NONE != ret){\r
1263                 EPS_RETURN( ret )\r
1264         }\r
1265         p = cmdBuf.p + cmdBuf.len;\r
1266 \r
1267         memcpy(p, pBand->pEncData, pBand->encDataSize);\r
1268         cmdBuf.len += pBand->encDataSize;\r
1269 \r
1270         pBand->encDataSize = 0;\r
1271 \r
1272         ret = SendCommand((EPS_UINT8*)cmdBuf.p, cmdBuf.len, &retBufSize, TRUE);\r
1273 \r
1274         EPS_RETURN(ret)\r
1275 }\r
1276 \r
1277 \r
1278 /*******************************************|********************************************/\r
1279 /*                                                                                      */\r
1280 /* Function name:   BandEncode()                                                                                                                */\r
1281 /*                                                                                      */\r
1282 /* Arguments                                                                            */\r
1283 /* ---------                                                                            */\r
1284 /* Name:                Type:                                   Description:                                    */\r
1285 /* pBand                EPS_PAGE_BAND_M*                I: band data strcture                               */\r
1286 /*                                                                                      */\r
1287 /* Return value:                                                                        */\r
1288 /* N/A                                                                                                                                                                  */\r
1289 /*                                                                                      */\r
1290 /* Description:                                                                         */\r
1291 /*      Do Compression.                                                                                                                                 */\r
1292 /*                                                                                      */\r
1293 /*******************************************|********************************************/\r
1294 static void BandEncode(\r
1295                                            \r
1296                 EPS_PAGE_BAND_M* pBand\r
1297                 \r
1298 ){\r
1299         EPS_BOOL isZero = FALSE;\r
1300     EPS_INT32 widthInBytes = (pBand->currentWidthInPixels+7)/8;\r
1301 \r
1302         EPS_LOG_FUNCIN\r
1303 \r
1304         /* Check blank line */\r
1305         isZero = (memcmp(pBand->pRasterData, pBand->pZeroRow, widthInBytes) == 0)?TRUE:FALSE;\r
1306 \r
1307         /* No compression for blank line */\r
1308         if( isZero ) {\r
1309                 pBand->encDataSize = 0;\r
1310         } else{\r
1311         pBand->encDataSize = DoDeltaRow( pBand->pRasterData,\r
1312                                     widthInBytes,\r
1313                                     pBand->pEncData,\r
1314                                     pBand->pZeroRow\r
1315                                   );\r
1316         }\r
1317 \r
1318         EPS_RETURN_VOID\r
1319 }\r
1320 \r
1321 \r
1322 /*=========================================================*/\r
1323 /*                                                         */\r
1324 /* Function:                                               */\r
1325 /*                                                         */\r
1326 /*      HT_Init                                                                                    */\r
1327 /*                                                         */\r
1328 /* Description:                                            */\r
1329 /*                                                         */\r
1330 /*      Halftoning initialization                                                  */\r
1331 /*                                                         */\r
1332 /*=========================================================*/\r
1333 static EPS_ERR_CODE HT_Init(EPS_INT32 WidthPixels)\r
1334 {\r
1335         EPS_LOG_FUNCIN\r
1336          \r
1337         srand(119);\r
1338 \r
1339     htParam.pEK                 = NULL;\r
1340     htParam.iScanPels   = WidthPixels;\r
1341     htParam.iOrder              = 5;\r
1342     htParam.iDK                 = DOT_K * E_MAX / 100;\r
1343 \r
1344         htParam.pEK = (EPS_INT16*)EPS_ALLOC((htParam.iScanPels + 2)*sizeof(EPS_INT16));\r
1345         if( NULL == htParam.pEK){\r
1346                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
1347         }\r
1348 \r
1349         EPS_RETURN( EPS_ERR_NONE )\r
1350 }\r
1351 \r
1352 \r
1353 /*=========================================================*/\r
1354 /*                                                         */\r
1355 /* Function:                                               */\r
1356 /*                                                         */\r
1357 /*      HT_End                                                                                     */\r
1358 /*                                                         */\r
1359 /* Description:                                            */\r
1360 /*                                                         */\r
1361 /*      Halftoning Ending process                                                  */\r
1362 /*                                                         */\r
1363 /*=========================================================*/\r
1364 static void HT_End()\r
1365 {\r
1366 EPS_LOG_FUNCIN\r
1367         EPS_SAFE_RELEASE( htParam.pEK );\r
1368 EPS_RETURN_VOID\r
1369 }\r
1370 \r
1371 \r
1372 /*=========================================================*/\r
1373 /*                                                         */\r
1374 /* Function:                                               */\r
1375 /*                                                         */\r
1376 /*      HT_StartPage                                                                       */\r
1377 /*                                                         */\r
1378 /* Description:                                            */\r
1379 /*                                                         */\r
1380 /*      Halftoning start page process                                      */\r
1381 /*                                                         */\r
1382 /*=========================================================*/\r
1383 static void HT_StartPage()\r
1384 {\r
1385         EPS_LOG_FUNCIN\r
1386 \r
1387         if (htParam.pEK){\r
1388         memset(htParam.pEK, 0, (htParam.iScanPels + 2) * sizeof(EPS_INT16));\r
1389         }\r
1390 \r
1391         EPS_RETURN_VOID\r
1392 }\r
1393 \r
1394 \r
1395 /*=========================================================*/\r
1396 /*                                                         */\r
1397 /* Function:                                               */\r
1398 /*                                                         */\r
1399 /*      HT_Scan                                                                                    */\r
1400 /*                                                         */\r
1401 /* Description:                                            */\r
1402 /*                                                         */\r
1403 /*      Check halftoning method                                                    */\r
1404 /*                                                         */\r
1405 /*=========================================================*/\r
1406 static void HT_Scan(EPS_UINT8 *Con, EPS_UINT8 *Bin, EPS_INT32 widthInPixels)\r
1407 {\r
1408 /*      Error Diffusion                                                                    */\r
1409     EPS_INT32 i, j, k;\r
1410     EPS_INT32 iE, iE1, iE3, iE5, iE7, iR;\r
1411     EPS_INT32 iCon;\r
1412     EPS_INT32 iDot;\r
1413         EPS_INT32 iF;\r
1414     EPS_INT16 *p;\r
1415 \r
1416         EPS_LOG_FUNCIN\r
1417 \r
1418         p    = htParam.pEK + 1;\r
1419         iDot = htParam.iDK;\r
1420 \r
1421     iE1 = 0;\r
1422     iE7 = 0;\r
1423     iR  = 0;\r
1424 \r
1425         i = 0;\r
1426         j = 1;\r
1427     \r
1428     for (k = 0; k < widthInPixels; k++) {\r
1429         if (Con[i] == 0) {\r
1430         } else if (Con[i] == MAX_8) {\r
1431             Bin[i >> 3] |= BitMask[i & 7];\r
1432         } else {\r
1433             iCon = Con[i] * (E_MAX / (MAX_8 + 1));\r
1434 \r
1435             iE = rand() * (iCon - E_MID) / RAND_MAX;\r
1436             if (((iR > 0) && (iE > 0)) || ((iR < 0) && (iE < 0))) {\r
1437                 iE = -iE;\r
1438                         }\r
1439             iR = iE;\r
1440 \r
1441             iCon += p[i] + iE7;\r
1442             \r
1443             if (iCon + iR > E_MID) {\r
1444                 Bin[i >> 3] |= BitMask[i & 7];\r
1445                 iE = iCon - iDot;\r
1446             } else {\r
1447                 iE = iCon;\r
1448             }\r
1449 \r
1450                         iF = iE / 16;\r
1451             iE3 = iF * 3;\r
1452             iE5 = iF * 5;\r
1453 \r
1454             p[i]      = iE5 + iE1;\r
1455             p[i - j] += iE3;\r
1456 \r
1457             iE1 = iF;\r
1458             iE7 = iE - iE1 - iE3 - iE5;\r
1459         }\r
1460 \r
1461         i += j;\r
1462     }\r
1463 \r
1464     p[i - j] += iE7 + iE1;\r
1465 \r
1466     p[0] += p[-1];\r
1467     p[htParam.iScanPels - 1] += p[htParam.iScanPels];\r
1468 \r
1469     p[-1] = 0;\r
1470     p[htParam.iScanPels] = 0;\r
1471         \r
1472         EPS_RETURN_VOID\r
1473 }\r
1474 \r
1475 \r
1476 /*=========================================================*/\r
1477 /*                                                         */\r
1478 /* Function:                                               */\r
1479 /*                                                         */\r
1480 /*      DoTIFF                                             */\r
1481 /*                                                         */\r
1482 /* Description:                                            */\r
1483 /*                                                         */\r
1484 /*      Do TIFF compression                                */\r
1485 /*                                                         */\r
1486 /*=========================================================*/\r
1487 EPS_INT32 DoTIFF(EPS_UINT8 *Row, EPS_INT32 nRow, EPS_UINT8 *RowTIFF)\r
1488 {\r
1489     EPS_INT32 nRowTIFF = 0;      /* Total size of TIFF encoded row. */\r
1490     EPS_INT32 nLiteral = 0;      /* Count of literal bytes. */\r
1491     EPS_INT32 nRepeat  = 0;      /* Count of repeated byte. */\r
1492         EPS_UINT8 ch; \r
1493         EPS_INT32 n;\r
1494 \r
1495     /* Load first byte from row into parser. */\r
1496     nRepeat++;\r
1497         nLiteral++;\r
1498     ch = *Row++;\r
1499 \r
1500     for( ; nRow--; ch = *Row++ ) {\r
1501         if( nLiteral > TIFF_MAXIMUM_LITERAL ) {\r
1502             /* Literal part has grown too large, emit the largest literal pattern we can. */\r
1503             EMIT_TIFF_LITERAL( TIFF_MAXIMUM_LITERAL, Row-nLiteral );\r
1504             nLiteral -= TIFF_MAXIMUM_LITERAL;\r
1505         } else if( nRepeat > TIFF_MAXIMUM_REPEAT ) {\r
1506             /* Repeated part has grown too large, emit the literal (if present) and then  */\r
1507                         /* emit the largest repeated pattern we can. */\r
1508                         EMIT_TIFF_REPEAT( TIFF_MAXIMUM_REPEAT, ch );\r
1509             nRepeat -= TIFF_MAXIMUM_REPEAT;\r
1510         }\r
1511         if( ch == *Row ) {\r
1512                         if( nLiteral ) {\r
1513                                 if( nLiteral >= 2 ) {\r
1514 \r
1515                                         EMIT_TIFF_LITERAL( nLiteral-1, Row-nLiteral );\r
1516                                 }\r
1517                                 nLiteral = 1;\r
1518                         }\r
1519             nRepeat++;\r
1520         } else {\r
1521                         if( nRepeat >= 2 ) {\r
1522                                 EMIT_TIFF_REPEAT( nRepeat, ch );\r
1523                                 nRepeat = 1;\r
1524                                 nLiteral = 0;\r
1525                         }\r
1526                         nLiteral++;\r
1527         }\r
1528     }\r
1529     if( nRepeat == 1 ) {\r
1530         nRepeat  = 0;\r
1531     }\r
1532         if( nLiteral == 1 && nRepeat >= 2 ) {\r
1533         nLiteral = 0;\r
1534     }\r
1535 \r
1536     while (nLiteral) {\r
1537         n = nLiteral;\r
1538         if (n > TIFF_MAXIMUM_LITERAL) {\r
1539             n = TIFF_MAXIMUM_LITERAL;\r
1540         }\r
1541                 if( nRepeat ) {\r
1542                         EMIT_TIFF_LITERAL(n-1, Row-nLiteral);\r
1543                 } else {\r
1544                         EMIT_TIFF_LITERAL(n-1, Row-nLiteral);\r
1545                 }\r
1546         nLiteral -= n;\r
1547     }\r
1548 \r
1549     while (nRepeat) {\r
1550         n = nRepeat;\r
1551         if (n > TIFF_MAXIMUM_REPEAT)  {\r
1552             n = TIFF_MAXIMUM_REPEAT;\r
1553         }\r
1554         EMIT_TIFF_REPEAT(n, ch);\r
1555         nRepeat -= n;\r
1556     }\r
1557 \r
1558         return nRowTIFF;\r
1559 }\r
1560 \r
1561 \r
1562 /*=========================================================*/\r
1563 /*                                                         */\r
1564 /* Function:                                               */\r
1565 /*                                                         */\r
1566 /*      DeltaRowEmitXFER                                   */\r
1567 /*                                                         */\r
1568 /* Description:                                            */\r
1569 /*                                                         */\r
1570 /*      Construct DeltaRow control code and data           */\r
1571 /*                                                         */\r
1572 /*=========================================================*/\r
1573 void DeltaRowEmitXFER(EPS_UINT8 *Row, EPS_INT32 nXFER, EPS_INT32 nXFERTIFF, EPS_INT32 *nRowDeltaRow, EPS_UINT8 **RowDeltaRow)\r
1574 {\r
1575         EPS_LOG_FUNCIN;\r
1576 \r
1577     /* Get data length and send before all data of the current row */\r
1578     iNumBytes += nXFERTIFF;\r
1579         iNumDots += nXFER * 8;\r
1580 \r
1581     /* TIFF data for XFER */\r
1582     *nRowDeltaRow += nXFERTIFF;\r
1583     if (*RowDeltaRow)\r
1584     {\r
1585         DoTIFF(Row, nXFER, *RowDeltaRow);\r
1586         *RowDeltaRow += nXFERTIFF;\r
1587     }\r
1588 \r
1589         EPS_RETURN_VOID\r
1590 }\r
1591 \r
1592 /*=========================================================*/\r
1593 /*                                                         */\r
1594 /* Function:                                               */\r
1595 /*                                                         */\r
1596 /*      DeltaRowEmitMOVX                                   */\r
1597 /*                                                         */\r
1598 /* Description:                                            */\r
1599 /*                                                         */\r
1600 /*      Construct DeltaRow horizontal position movement    */\r
1601 /*                                                         */\r
1602 /*=========================================================*/\r
1603 void DeltaRowEmitMOVX(EPS_INT32 nSkip, EPS_INT32 *nRowDeltaRow, EPS_UINT8 **RowDeltaRow)\r
1604 {\r
1605     EPS_UINT8 N;\r
1606     EPS_INT32 num=0;\r
1607     EPS_INT32 num1=0;\r
1608 \r
1609         EPS_LOG_FUNCIN;\r
1610 \r
1611     /* Send repeat "00" instead. Send 255 "00" the most each time */\r
1612     if( nSkip == 0 ) {\r
1613                 EPS_RETURN_VOID\r
1614     }\r
1615     \r
1616     if( nSkip > 255 ) {\r
1617         num1 = nSkip - 255;\r
1618         num = 255;\r
1619     } else {\r
1620         num = nSkip;\r
1621     }\r
1622     *nRowDeltaRow += 3;\r
1623     iNumBytes += 3;\r
1624         iNumDots += num * 8;\r
1625 \r
1626     if (*RowDeltaRow) {\r
1627         N = num;\r
1628         *((*RowDeltaRow)++) = 0x00;\r
1629                 *((*RowDeltaRow)++) = 0x00;\r
1630                 *((*RowDeltaRow)++) = N;\r
1631     }\r
1632     if( num1 > 255 ) {\r
1633         /* Still have more than 255 "00" */\r
1634         DeltaRowEmitMOVX(num1, nRowDeltaRow, RowDeltaRow);\r
1635     } else {\r
1636         if( num1 > 0 ) {\r
1637             *nRowDeltaRow += 3;\r
1638             iNumBytes += 3;\r
1639                         iNumDots += num1 * 8;\r
1640             if (*RowDeltaRow)\r
1641             {\r
1642                 N = num1;\r
1643                 *((*RowDeltaRow)++) = 0x00;\r
1644                                 *((*RowDeltaRow)++) = 0x00;\r
1645                                 *((*RowDeltaRow)++) = N;\r
1646             }\r
1647         }\r
1648     }\r
1649 \r
1650         EPS_RETURN_VOID\r
1651 }\r
1652 \r
1653 \r
1654 /*=========================================================*/\r
1655 /*                                                         */\r
1656 /* Function:                                               */\r
1657 /*                                                         */\r
1658 /*      DeltaRowEmitReduce                                 */\r
1659 /*                                                         */\r
1660 /* Description:                                            */\r
1661 /*                                                         */\r
1662 /*                                                         */\r
1663 /*                                                         */\r
1664 /*=========================================================*/\r
1665 void DeltaRowEmitReduce(EPS_UINT8 *Row, EPS_INT32 *nDelta0, EPS_INT32 *nSkip, EPS_INT32 *nDelta1, EPS_INT32 *nRowDeltaRow, EPS_UINT8 **RowDeltaRow)\r
1666 {\r
1667     EPS_INT32 nDelta0TIFF, nDelta1TIFF, nDeltaTIFF, SizeofDSD, SizeofD;\r
1668 \r
1669         EPS_LOG_FUNCIN;\r
1670         \r
1671         if (*nDelta0) {\r
1672         /* (DSD) state. */\r
1673         nDelta0TIFF = DoTIFF(Row - *nDelta1 - *nSkip - *nDelta0, *nDelta0, 0);\r
1674         nDelta1TIFF = DoTIFF(Row - *nDelta1,                     *nDelta1, 0);\r
1675         nDeltaTIFF  = DoTIFF(Row - *nDelta1 - *nSkip - *nDelta0, *nDelta0 + *nSkip + *nDelta1, 0);\r
1676 \r
1677         SizeofDSD = nDelta0TIFF + nDelta1TIFF + (nDelta0TIFF>15?1:0)\r
1678             + (nDelta0TIFF>255?1:0) + (nDelta1TIFF>15?1:0)\r
1679             + (nDelta1TIFF>255?1:0) + (*nSkip>7?1:0) + (*nSkip>127?1:0) + 3;\r
1680         SizeofD = nDeltaTIFF + (nDeltaTIFF>15?1:0) + (nDeltaTIFF>255?1:0) + 1;\r
1681 \r
1682     } else {\r
1683         /* (-SD) state. */\r
1684         nDelta0TIFF = 0;\r
1685         nDelta1TIFF = DoTIFF(Row - *nDelta1, *nDelta1, 0);\r
1686         nDeltaTIFF  = DoTIFF(Row - *nDelta1 - *nSkip, *nSkip + *nDelta1, 0);\r
1687 \r
1688         SizeofDSD = nDelta1TIFF + (nDelta1TIFF>15?1:0)\r
1689             + (nDelta1TIFF>255?1:0) + (*nSkip>7?1:0) + (*nSkip>127?1:0) + 2;\r
1690         SizeofD = nDeltaTIFF + (nDeltaTIFF>15?1:0) + (nDeltaTIFF>255?1:0) + 1;\r
1691     }\r
1692 \r
1693     if (SizeofD <= SizeofDSD) {\r
1694         /* Turn the delta/skip/delta into a single delta. */\r
1695         *nDelta0 += *nSkip + *nDelta1;\r
1696         *nSkip = 0;\r
1697         *nDelta1 = 0;\r
1698 \r
1699     } else {\r
1700         /* Emit a delta, then a skip, and the shift the leftover delta. */\r
1701         if (*nDelta0) {\r
1702             DeltaRowEmitXFER(Row- *nDelta0 - *nSkip - *nDelta1, *nDelta0, nDelta0TIFF, nRowDeltaRow, RowDeltaRow);\r
1703         }\r
1704         DeltaRowEmitMOVX(*nSkip, nRowDeltaRow, RowDeltaRow);\r
1705 \r
1706         /* Shift remaining delta */\r
1707         *nDelta0 = *nDelta1;\r
1708         *nSkip = 0;\r
1709         *nDelta1 = 0;\r
1710     }\r
1711 \r
1712         EPS_RETURN_VOID\r
1713 }\r
1714 \r
1715 \r
1716 /*=========================================================*/\r
1717 /*                                                         */\r
1718 /* Function:                                               */\r
1719 /*                                                         */\r
1720 /*      DoDeltaRow                                         */\r
1721 /*                                                         */\r
1722 /* Description:                                            */\r
1723 /*                                                         */\r
1724 /*      Do DeltaRow compression                            */\r
1725 /*                                                         */\r
1726 /*=========================================================*/\r
1727 static EPS_INT32 DoDeltaRow(EPS_UINT8 *Row, EPS_INT32 nRow, EPS_UINT8 *RowDeltaRow, EPS_UINT8 *Seed)\r
1728 {\r
1729         EPS_INT32 nRowDeltaRow = 0;\r
1730     EPS_INT32 nSkip        = 0;\r
1731     EPS_INT32 nDelta1      = 0;\r
1732     EPS_INT32 nDelta0      = 0;\r
1733         EPS_INT32 nDelta0TIFF;\r
1734 \r
1735     for ( ; nRow--; Row++, Seed++) {\r
1736                 if (*Row != *Seed) {\r
1737                         nDelta1++;\r
1738                 }\r
1739         else\r
1740         {\r
1741             if (nDelta1)\r
1742             {\r
1743                 if (nDelta0 == 0 && nSkip ==0)\r
1744                 {\r
1745                     nDelta0 = nDelta1;\r
1746                     nDelta1 = 0;\r
1747                 }\r
1748                 else\r
1749                 {\r
1750                     if (nSkip <= 3)\r
1751                     {\r
1752                         nDelta0 += nSkip + nDelta1;\r
1753                         nSkip = 0;\r
1754                         nDelta1 = 0;\r
1755                     }\r
1756                     else\r
1757                     {\r
1758                        DeltaRowEmitReduce(Row, &nDelta0, &nSkip, &nDelta1,\r
1759                             &nRowDeltaRow, &RowDeltaRow);\r
1760                     }\r
1761                 }\r
1762             }\r
1763             nSkip++;\r
1764         }\r
1765     }\r
1766 \r
1767     /* Have reached the end of the line. */\r
1768     if (nDelta0)\r
1769     {\r
1770         if (nDelta1)\r
1771         {\r
1772             DeltaRowEmitReduce(Row, &nDelta0, &nSkip, &nDelta1, &nRowDeltaRow, &RowDeltaRow);\r
1773             nDelta0TIFF = DoTIFF(Row-nDelta0, nDelta0, 0);\r
1774             DeltaRowEmitXFER(Row-nDelta0, nDelta0, nDelta0TIFF, &nRowDeltaRow, &RowDeltaRow);\r
1775         }\r
1776         else\r
1777         {\r
1778             nDelta0TIFF = DoTIFF(Row-nSkip-nDelta0, nDelta0, 0);\r
1779             DeltaRowEmitXFER(Row-nDelta0-nSkip, nDelta0, nDelta0TIFF, &nRowDeltaRow, &RowDeltaRow);\r
1780         }\r
1781     }\r
1782     else if (nDelta1)\r
1783     {\r
1784         if (nSkip)\r
1785         {\r
1786             DeltaRowEmitReduce(Row, &nDelta0, &nSkip, &nDelta1, &nRowDeltaRow, &RowDeltaRow);\r
1787             nDelta0TIFF = DoTIFF(Row-nDelta0, nDelta0, 0);\r
1788             DeltaRowEmitXFER(Row-nDelta0, nDelta0, nDelta0TIFF, &nRowDeltaRow, &RowDeltaRow);\r
1789         }\r
1790         else\r
1791         {\r
1792             nDelta0TIFF = DoTIFF(Row-nDelta1, nDelta1, 0);\r
1793             DeltaRowEmitXFER(Row-nDelta1, nDelta1, nDelta0TIFF, &nRowDeltaRow, &RowDeltaRow);\r
1794         }\r
1795     }\r
1796 \r
1797     return nRowDeltaRow;\r
1798 }\r
1799 \r
1800 /*_______________________________  epson-escpage-mono.c   ______________________________*/\r
1801 \r
1802 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
1803 /*       1         2         3         4         5         6         7         8        */\r
1804 /*******************************************|********************************************/\r
1805 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1806 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/\r
1807 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r