lib/epson-escpr-api.c

   1 /*_______________________________   epson-escpr-api.c   ________________________________*/\r
   2 \r
   3 /*       1         2         3         4         5         6         7         8        */\r
   4 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
   5 /*******************************************|********************************************/\r
   6 /*\r
   7  *   Copyright (c) 2009  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 /*                                                                                      */\r
  18 /*                             Epson ESC/P-R Library APIs                               */\r
  19 /*                                                                                      */\r
  20 /*                                Core Function Calls                                   */\r
  21 /*                            --------------------------                                */\r
  22 /*    API-0001   EPS_ERR_CODE epsInitDriver        (commMode, usbFuncPtrs,            */\r
  23 /*                                                    netFuncPtrs, cmnFuncPtrs);        */\r
  24 /*      API-0002   EPS_ERR_CODE epsReleaseDriver     ();                                */\r
  25 /*      API-0003   EPS_ERR_CODE epsFindPrinter       (protocol, timeout);               */\r
  26 /*      API-0004   EPS_ERR_CODE epsProbePrinter      (probeParam);                      */\r
  27 /*      API-0005   EPS_ERR_CODE epsCancelFindPrinter ();                                */\r
  28 /*      API-0006   EPS_ERR_CODE epsSetPrinter        (printer);                         */\r
  29 /*      API-0007   EPS_ERR_CODE epsStartJob          (jobAttrib);                       */\r
  30 /*      API-0008   EPS_ERR_CODE epsStartPage         (pageAttrib);                      */\r
  31 /*      API-0009   EPS_ERR_CODE epsPrintBand         (imageData,width,,height);         */\r
  32 /*      API-0010   EPS_ERR_CODE epsSendData          (prnData);                         */\r
  33 /*      API-0011   EPS_ERR_CODE epsEndPage           ();                                */\r
  34 /*      API-0012   EPS_ERR_CODE epsEndJob            ();                                */\r
  35 /*      API-0013   EPS_ERR_CODE epsCancelJob         (reserve);                         */\r
  36 /*      API-0014   EPS_ERR_CODE epsContinueJob       ();                                */\r
  37 /*      API-0015   EPS_ERR_CODE epsGetStatus         (status);                          */\r
  38 /*      API-0016   EPS_ERR_CODE epsGetSupportedMedia (media);                           */\r
  39 /*      API-0017   EPS_ERR_CODE epsGetPrintableArea  (pageAttrib,                       */\r
  40 /*                                                      printableWidth,                 */\r
  41 /*                                                      printableHeight);               */\r
  42 /*                                                                                      */\r
  43 /*******************************************|********************************************/\r
  44 \r
  45 /*------------------------------  Local Compiler Switch  -------------------------------*/\r
  46 /*******************************************|********************************************/\r
  47 \r
  48     /*** 4KB Packet Data                                                                */\r
  49     /***--------------------------------------------------------------------------------*/\r
  50 #define LCOMSW_PACKET_4KB           0       /* 0: Make any size packet                  */\r
  51                                             /* 1: Make 4KB packet                       */\r
  52 #define LCOMSW_CANCEL_JOB           0\r
  53 \r
  54 #define LCOMSW_USE_720DPI           0   /* Not support 720dpi                       */       \r
  55 \r
  56 #define ESCPR_DEBUG_IMAGE_LOG       0       /* 0: OFF    1: ON                          */\r
  57 \r
  58 #define LCOMSW_DUMMY_SEND     0   /* 1: Enable 0byte data sending             */\r
  59 \r
  60 /*#define LCOMSW_JOBPARAM_CEHCK_OFF*/\r
  61 \r
  62 /* #define LCOMSW_CMDDMP */\r
  63 \r
  64 /*------------------------------------  Includes   -------------------------------------*/\r
  65 /*******************************************|********************************************/\r
  66 #include "epson-escpr-pvt.h"\r
  67 #include "epson-escpr-services.h"\r
  68 #include "epson-escpr-mem.h"\r
  69 #include "epson-protocol.h"\r
  70 #include "epson-layout.h"\r
  71 #ifdef GCOMSW_CMD_ESCPAGE\r
  72 #include "epson-escpage.h"\r
  73   #ifdef GCOMSW_CMD_ESCPAGE_S\r
  74   #include "epson-escpage-s.h"\r
  75   #endif\r
  76 #endif\r
  77 #include "epson-escpr-api.h"\r
  78 \r
  79 \r
  80 /*----------------------------  ESC/P-R Lib Global Variables  --------------------------*/\r
  81 /*******************************************|********************************************/\r
  82 DECRALE_DMP_FILE\r
  83 \r
  84     /*** Extern Function                                                                */\r
  85     /*** -------------------------------------------------------------------------------*/\r
  86 EPS_USB_FUNC    epsUsbFnc;\r
  87 EPS_NET_FUNC    epsNetFnc;\r
  88 EPS_CMN_FUNC    epsCmnFnc;\r
  89 \r
  90     /*** Print Job Structure                                                            */\r
  91     /*** -------------------------------------------------------------------------------*/\r
  92 EPS_PRINT_JOB   printJob;\r
  93 EPS_INT32 tonerSave;\r
  94 EPS_INT32 back_type;\r
  95 \r
  96 EPS_INT32 lWidth;\r
  97 EPS_INT32 lHeight;\r
  98 \r
  99 EPS_INT32 areaWidth;\r
 100 EPS_INT32 areaHeight;\r
 101 \r
 102 \r
 103 /*-------------------------  Module "Local Global" Variables  --------------------------*/\r
 104 /*******************************************|********************************************/\r
 105     /*** internal stock                                                                 */\r
 106     /*** -------------------------------------------------------------------------------*/\r
 107 static EPS_SUPPORTED_MEDIA  g_supportedMedia;       /* Supported Media          */\r
 108 \r
 109     /*** Job function                                                                   */\r
 110     /*** -------------------------------------------------------------------------------*/\r
 111 EPS_JOB_FUNCS   jobFnc;             \r
 112 \r
 113 /*--------------------------------  Local Definition   ---------------------------------*/\r
 114 /*******************************************|********************************************/\r
 115 #ifdef EPS_LOG_MODULE_API\r
 116 #define EPS_LOG_MODULE EPS_LOG_MODULE_API\r
 117 #else\r
 118 #define EPS_LOG_MODULE 0\r
 119 #endif\r
 120 \r
 121     /*** Roop Count                                                                     */\r
 122     /*** -------------------------------------------------------------------------------*/\r
 123 #define EPS_ROOP_NUM                   40       /* Send the data for "EPS_ROOP_NUM"     */\r
 124                                                 /* times and get printer status         */\r
 125 \r
 126 #define EPS_TIMEOUT_NUM                20       /* retry Send the data "EPS_TIMEOUT_NUM"*/\r
 127 #define EPS_TIMEOUT_SEC                1000     /* retry Send the data 1 sec */\r
 128 \r
 129     /*** Packet Size (4KB)                                                              */\r
 130     /*** -------------------------------------------------------------------------------*/\r
 131 #if LCOMSW_PACKET_4KB\r
 132 #define ESCPR_PACKET_SIZE_4KB        4090\r
 133 #endif\r
 134 \r
 135     /*** ESC/PR Attributes not settable by developer                                    */\r
 136     /*** -------------------------------------------------------------------------------*/\r
 137 #define EPS_COMP_NON                    0       /* Non compression                      */\r
 138 #define EPS_COMP_RLE                    1       /* Runlength compression                */\r
 139 \r
 140 #define EPS_END_PAGE                    0       /* There is no next page                */\r
 141 #define EPS_NEXT_PAGE                   1       /* There is a next page                 */\r
 142 \r
 143     /*** RLE Compression States                                                         */\r
 144     /*** -------------------------------------------------------------------------------*/\r
 145 #define EPS_RLE_COMPRESS_NOT_DONE       0\r
 146 #define EPS_RLE_COMPRESS_DONE           1\r
 147 \r
 148     /*** Borderless Mode                                                                */\r
 149     /*** -------------------------------------------------------------------------------*/\r
 150 #define EPS_BORDER_3MM_MARGINE          0\r
 151 #define EPS_BORDER_CUSTOM               1\r
 152 #define EPS_BORDERLESS_NORMAL           2\r
 153 #define EPS_BORDERLESS_ZERO_MARGINE     3\r
 154 \r
 155 \r
 156 /*---------------------------------  ESC/P-R Commands  ---------------------------------*/\r
 157 /*******************************************|********************************************/\r
 158     /*** ESC/P-R Command Length                                                         */\r
 159     /*** -------------------------------------------------------------------------------*/\r
 160 #define REMOTE_HEADER_LENGTH            5\r
 161 #define ESCPR_CLASS_LENGTH              2    /* ESC + CLASS */\r
 162 #define ESCPR_HEADER_LENGTH            10    /* ESC + CLASS + ParamLen + CmdName */\r
 163 #define ESCPR_PRINT_QUALITY_LENGTH      9\r
 164 #define ESCPR_SEND_DATA_LENGTH          7\r
 165 #define ESCPR_SEND_JPGDATA_LENGTH       2\r
 166 #define ESCPR_JPGHEAD_LENGTH            (ESCPR_HEADER_LENGTH + ESCPR_SEND_JPGDATA_LENGTH)\r
 167 \r
 168     /*** Escape Commands for Initialize/Colse Printer                                   */\r
 169     /*** -------------------------------------------------------------------------------*/\r
 170 static const EPS_UINT8 ExitPacketMode[]= {\r
 171                             0x00, 0x00, 0x00, 0x1B, 0x01, 0x40, 0x45, 0x4A, 0x4C, 0x20,\r
 172                             0x31, 0x32, 0x38, 0x34, 0x2E, 0x34, 0x0A, 0x40, 0x45, 0x4A,\r
 173                             0x4C, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A                    };\r
 174 \r
 175 static const EPS_UINT8 ESCPRMode[] = {\r
 176 /*                            0x1B, 0x28, 0x52, 0x06, 0x00, 0x00, 0x45, 0x53, 0x43, 0x50, 0x52, };*/\r
 177                             0x1B, '(', 'R', 0x06, 0x00, 0x00, 'E', 'S', 'C', 'P', 'R' };\r
 178 static const EPS_UINT8 ESCPRModeJpg[] = {\r
 179                             0x1B, '(', 'R', 0x07, 0x00, 0x00, 'E', 'S', 'C', 'P', 'R', 'J' };\r
 180 \r
 181 static const EPS_UINT8 InitPrinter[] = {\r
 182                             0x1B, 0x40,                                                 };\r
 183 \r
 184 static const EPS_UINT8 EnterRemoteMode[] = {\r
 185                             0x1B, 0x28, 0x52, 0x08, 0x00, 0x00, 'R', 'E', 'M', 'O', 'T', 'E', '1',  };\r
 186 \r
 187 static const EPS_UINT8 RemoteJS[] = {\r
 188                             'J', 'S', 0x04, 0x00, 0x00, \r
 189               0x00, 0x00, 0x00 };\r
 190 \r
 191 static const EPS_UINT8 RemoteTI[] = {\r
 192                         'T', 'I', 0x08, 0x00, 0x00,\r
 193               0x00, 0x00, /* YYYY */\r
 194               0x00,       /* MM */\r
 195               0x00,       /* DD */\r
 196               0x00,       /* hh */\r
 197               0x00,       /* mm */\r
 198               0x00,       /* ss */  };\r
 199               \r
 200 static const EPS_UINT8 RemoteHD[] = {\r
 201                             'H', 'D', 0x03, 0x00, 0x00, \r
 202               0x03, 0xFF };\r
 203 \r
 204 static const EPS_UINT8 RemoteJH[] = {\r
 205                              'J',  'H', 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
 206                             0x45, 0x53, 0x43, 0x50, 0x52, 0x4c, 0x69, 0x62              };\r
 207 \r
 208 static const EPS_UINT8 RemotePP[] = {\r
 209                             'P', 'P', 0x03, 0x00, 0x00, 0x00, 0x00                      };\r
 210 \r
 211 static const EPS_UINT8 RemoteDP[] = {\r
 212                             'D', 'P', 0x02, 0x00, 0x00, 0x02                            };\r
 213 \r
 214 static const EPS_UINT8 RemoteLD[] = {\r
 215                             'L', 'D', 0x00, 0x00,                   };\r
 216 \r
 217 static const EPS_UINT8 RemoteJE[] = {\r
 218                             'J', 'E', 0x01, 0x00, 0x00,                                 };\r
 219 \r
 220 static const EPS_UINT8 ExitRemoteMode[] = {\r
 221                             0x1B, 0x00, 0x00, 0x00,                                     };\r
 222 #ifdef GCOMSW_EF_MAINTE\r
 223 static const EPS_UINT8 RemoteCH[] = {\r
 224                             'C', 'H', 0x02, 0x00, 0x00, 0x00        };\r
 225 static const EPS_UINT8 RemoteNC[] = {\r
 226                             'N', 'C', 0x02, 0x00, 0x00, 0x00        };\r
 227 static const EPS_UINT8 RemoteVI[] = {\r
 228                             'V', 'I', 0x02, 0x00, 0x00, 0x00        };\r
 229 \r
 230 static const EPS_UINT8 DataCR[] = {0x0D     };\r
 231 static const EPS_UINT8 DataLF[] = {0x0A     };\r
 232 static const EPS_UINT8 DataFF[] = {0x0C     };\r
 233 #endif\r
 234 \r
 235     /*** ESC/P-R Commands (Print Quality)                                               */\r
 236     /*** -------------------------------------------------------------------------------*/\r
 237 static const EPS_UINT8 PrintQualityCmd[] = {\r
 238                           0x1B, 'q', 0x09, 0x00, 0x00, 0x00,\r
 239                             's', 'e', 't', 'q',\r
 240                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
 241 \r
 242     /*** ESC/P-R Commands (APF setting)                                                 */\r
 243     /*** -------------------------------------------------------------------------------*/\r
 244 static const EPS_UINT8 APFSettingCmd[]   = {\r
 245                           0x1B, 'a', 0x04, 0x00, 0x00, 0x00,\r
 246                             's', 'e', 't', 'a',\r
 247                             0x00, 0x00, 0x00, 0x00};\r
 248 \r
 249     /*** ESC/P-R Commands (Print Job)                                                   */\r
 250     /*** -------------------------------------------------------------------------------*/\r
 251 static const EPS_UINT8 JobCmd[]          = {\r
 252                           0x1B, 'j', 0x16, 0x00, 0x00, 0x00,\r
 253                             's', 'e', 't', 'j',\r
 254                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
 255               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
 256               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
 257 static const EPS_UINT8 JobCmdJpg[]       = {\r
 258                           0x1B, 'j', 0x05, 0x00, 0x00, 0x00,\r
 259                             's', 'e', 't', 's',\r
 260                             0x00, 0x00, 0x00, 0x00, 0x00 };\r
 261 \r
 262     /*** ESC/P-R Command (Start Page)                                                   */\r
 263     /*** -------------------------------------------------------------------------------*/\r
 264 static const EPS_UINT8 StartPage[]       = {\r
 265                           0x1B, 'p', 0x00, 0x00, 0x00, 0x00,  \r
 266                             's',  't',  't',  'p' };\r
 267 \r
 268     /*** ESC/P-R Commands (Send Data)                                                   */\r
 269     /*** -------------------------------------------------------------------------------*/\r
 270 static const EPS_UINT8 SendDataCmd[2]       = {0x1B, 'd'            };\r
 271 static const EPS_UINT8 SendDataName[4]      = {'d', 's', 'n', 'd'   };\r
 272 static const EPS_UINT8 SendJpegDataName[4]  = {'j', 's', 'n', 'd'   };\r
 273 \r
 274     /*** ESC/P-R Command (End Page)                                                     */\r
 275     /*** -------------------------------------------------------------------------------*/\r
 276 static const EPS_UINT8 EndPage[]    = {\r
 277                           0x1B, 'p', 0x01, 0x00, 0x00, 0x00,  \r
 278                             'e',  'n',  'd',  'p', \r
 279                             0x00};\r
 280 \r
 281     /*** ESC/P-R Command (End Job)                                                      */\r
 282     /*** -------------------------------------------------------------------------------*/\r
 283 static const EPS_UINT8 EndJob[] = {\r
 284                             0x1B,  'j', 0x00, 0x00, 0x00, 0x00,\r
 285               'e',  'n',  'd',  'j' };\r
 286 \r
 287 /*-------------------------------  Definition of Macro  --------------------------------*/\r
 288 /*******************************************|********************************************/\r
 289 \r
 290 \r
 291 /*---------------------------  Data Structure Declarations   ---------------------------*/\r
 292 /*******************************************|********************************************/\r
 293 \r
 294     /*** Generic Image Object                                                           */\r
 295     /*** -------------------------------------------------------------------------------*/\r
 296 typedef struct _tagEPS_IMAGE_ {\r
 297     const EPS_UINT8*  data;                 /* Pointer to image/raster data             */\r
 298     EPS_RECT    rect;                       /* Rect define position of image            */\r
 299     EPS_UINT32  bytesPerLine;               /* Bytes-Per-Pixel for image/raster         */\r
 300 } EPS_IMAGE;\r
 301 \r
 302 /*------------------------------  Local Global Variables  ------------------------------*/\r
 303 /*******************************************|********************************************/\r
 304     /*** ESC/P-R LIB Status State                                                       */\r
 305     /*** -------------------------------------------------------------------------------*/\r
 306 EPS_INT32    libStatus;                  /*  Library (epsInitDriver) status      */\r
 307 \r
 308     /*** Status counter                                                                 */\r
 309     /*** -------------------------------------------------------------------------------*/\r
 310 static EPS_INT32    gStatusCount;   /* Variable for register the number of getting      */\r
 311                                     /* printer status                                   */\r
 312 \r
 313     /*** Buffer for Print Band                                                          */\r
 314     /*** -------------------------------------------------------------------------------*/\r
 315 EPS_UINT32   sendDataBufSize = 0;\r
 316 EPS_UINT8*   sendDataBuf;    /* buffer of SendCommand(save) input                */\r
 317 EPS_UINT32   tmpLineBufSize;\r
 318 EPS_UINT8*   tmpLineBuf;\r
 319 \r
 320 /*--------------------------------  Local Functions   ----------------------------------*/\r
 321 /*******************************************|********************************************/\r
 322 static EPS_ERR_CODE MonitorStatus           (EPS_STATUS_INFO *                          );\r
 323 static EPS_ERR_CODE SendLeftovers           (void                                       );\r
 324 static EPS_ERR_CODE SendBlankBand           (void                                       );\r
 325 EPS_ERR_CODE SetupJobAttrib          (const EPS_JOB_ATTRIB*                      );\r
 326 static EPS_ERR_CODE SetupRGBAttrib          (void                                       );\r
 327 static EPS_ERR_CODE SetupJPGAttrib          (void                                       );\r
 328 EPS_ERR_CODE SendStartJob     (EPS_BOOL                                   );\r
 329 EPS_ERR_CODE SendEndJob       (EPS_BOOL                                   );\r
 330 \r
 331 EPS_ERR_CODE PrintBand               (const EPS_UINT8*, EPS_UINT32, EPS_UINT32*  );\r
 332 static EPS_ERR_CODE PrintChunk              (const EPS_UINT8*, EPS_UINT32*              );\r
 333 static void         AdjustBasePoint         (void                                       );\r
 334 static EPS_ERR_CODE PrintLine               (EPS_IMAGE*                                 );\r
 335 static EPS_ERR_CODE SendLine                (const EPS_BANDBMP*, EPS_RECT*              );\r
 336 static EPS_UINT16   RunLengthEncode         (const EPS_UINT8*, EPS_UINT8*, EPS_UINT16, EPS_UINT8, EPS_UINT8*);\r
 337 \r
 338 static void         MakeRemoteTICmd         (EPS_UINT8*                                 );\r
 339 static void         MakeQualityCmd          (EPS_UINT8*                                 );\r
 340 static void         MakeAPFCmd              (EPS_UINT8*                                 );\r
 341 static void         MakeJobCmd              (EPS_UINT8*                                 );\r
 342 static EPS_ERR_CODE AddCmdBuff              (EPS_UINT8 **, EPS_UINT8 **, EPS_UINT32 *, \r
 343                       const EPS_UINT8 *, EPS_UINT32               );\r
 344 static EPS_ERR_CODE CreateMediaInfo     (EPS_PRINTER_INN*, EPS_UINT8*, EPS_INT32  );\r
 345 static EPS_ERR_CODE DuplSupportedMedia      (EPS_PRINTER_INN*, EPS_SUPPORTED_MEDIA*     );\r
 346 static EPS_ERR_CODE GetPaperSource          (EPS_PRINTER_INN*                           );\r
 347 static EPS_ERR_CODE GetJpgMax               (EPS_PRINTER_INN*                          );\r
 348 static void       ClearSupportedMedia     (void                                      );\r
 349 \r
 350 \r
 351 \r
 352 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 353 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 354 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 355 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 356 /*--------------------             ESC/P-R Library API             ---------------------*/\r
 357 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 358 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 359 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 360 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 361 \r
 362 /*******************************************|********************************************/\r
 363 /*                                                                                      */\r
 364 /* Function name:     epsInitDriver()                                                   */\r
 365 /*                                                                                      */\r
 366 /* Arguments                                                                            */\r
 367 /* ---------                                                                            */\r
 368 /* Name:        Type:               Description:                                        */\r
 369 /* commMode     EPS_INT8            I: Communication Mode                               */\r
 370 /*                                     (Bi-Directional or Uni-Directional)              */\r
 371 /* usbFuncPtrs  EPS_USB_FUNC*       I: Data structure containing function pointers to   */\r
 372 /*                                     external USB I/O functions.                      */\r
 373 /* netFuncPtrs  EPS_NET_FUNC*       I: Data structure containing function pointers to   */\r
 374 /*                                     external network socket I/O functions.           */\r
 375 /* cmnFuncPtrs  EPS_CMN_FUNC*       I: Data structure containing function pointers to   */\r
 376 /*                                     external memory management functions.            */\r
 377 /*                                                                                      */\r
 378 /* Return value:                                                                        */\r
 379 /*      << Normal >>                                                                    */\r
 380 /*      EPS_ERR_NONE                     - Success                                      */\r
 381 /*      << Error >>                                                                     */\r
 382 /*      EPS_ERR_LIB_INTIALIZED           - Lib already initialized                      */\r
 383 /*      EPS_ERR_INV_ARG_COMMMODE         - Invalid argument "commMode"                  */\r
 384 /*      EPS_ERR_INV_FNCP_NULL            - Invalid function pointer structure           */\r
 385 /*      EPS_ERR_INV_FNCP_FINDCALLBACK    - Invalid function pointer "findCallback"      */\r
 386 /*      EPS_ERR_INV_FNCP_MEMALLOC        - Invalid function pointer "memAlloc"          */\r
 387 /*      EPS_ERR_INV_FNCP_MEMFREE         - Invalid function pointer "memFree"           */\r
 388 /*      EPS_ERR_INV_FNCP_SLEEP           - Invalid function pointer "sleep"             */\r
 389 /*      EPS_ERR_INV_FNCP_OPENPORTAL      - Invalid function pointer "openPortal"        */\r
 390 /*      EPS_ERR_INV_FNCP_CLOSEPORTAL     - Invalid function pointer "closePortal"       */\r
 391 /*      EPS_ERR_INV_FNCP_READPORTAL      - Invalid function pointer "readPortal"        */\r
 392 /*      EPS_ERR_INV_FNCP_WRITEPORTAL     - Invalid function pointer "writePortal"       */\r
 393 /*      EPS_ERR_INV_FNCP_FINDFIRST       - Invalid function pointer "findFirst"         */\r
 394 /*      EPS_ERR_INV_FNCP_FINDNEXT        - Invalid function pointer "findNext"          */\r
 395 /*      EPS_ERR_INV_FNCP_FINDCLOSE       - Invalid function pointer "findClose"         */\r
 396 /*      EPS_ERR_INV_FNCP_NETSOCKET       - Invalid function pointer "socket"            */\r
 397 /*      EPS_ERR_INV_FNCP_NETCLOSE        - Invalid function pointer "close"             */\r
 398 /*      EPS_ERR_INV_FNCP_NETCONNECT      - Invalid function pointer "connect"           */\r
 399 /*      EPS_ERR_INV_FNCP_NETSHUTDOWN     - Invalid function pointer "shutdown"          */\r
 400 /*      EPS_ERR_INV_FNCP_NETBIND         - Invalid function pointer "bind"              */\r
 401 /*      EPS_ERR_INV_FNCP_NETLISTEN       - Invalid function pointer "listen"            */\r
 402 /*      EPS_ERR_INV_FNCP_NETACCEPT       - Invalid function pointer "accept"            */\r
 403 /*      EPS_ERR_INV_FNCP_NETSEND         - Invalid function pointer "send"              */\r
 404 /*      EPS_ERR_INV_FNCP_NETSENDTO       - Invalid function pointer "sendTo"            */\r
 405 /*      EPS_ERR_INV_FNCP_NETRECEIVE      - Invalid function pointer "receive"           */\r
 406 /*      EPS_ERR_INV_FNCP_NETRECEIVEFROM  - Invalid function pointer "receiveFrom"       */\r
 407 /*      EPS_ERR_INV_FNCP_NETGETSOCKNAME  - Invalid function pointer "getsockname"       */\r
 408 /*      EPS_ERR_INV_FNCP_NETSETBROADCAST - Invalid function pointer "setBroadcast"      */\r
 409 /*      EPS_ERR_MEMORY_ALLOCATION        - Failed to allocate memory                    */\r
 410 /*                                                                                      */\r
 411 /* Description:                                                                         */\r
 412 /*      Registers the external functions with the device driver.                        */\r
 413 /*                                                                                      */\r
 414 /*******************************************|********************************************/\r
 415 EPS_ERR_CODE    epsInitDriver (\r
 416 \r
 417         EPS_INT32               commMode, \r
 418     const EPS_USB_FUNC*     usbFuncPtrs,\r
 419         const EPS_NET_FUNC*     netFuncPtrs,\r
 420         const EPS_CMN_FUNC*     cmnFuncPtrs\r
 421 \r
 422 ){\r
 423 /*** Declare Variable Local to Routine                                                  */\r
 424 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls      */\r
 425 \r
 426 EPS_LOG_FUNCIN\r
 427 \r
 428 #ifdef GCOMSW_EPSON_SLEEP\r
 429 EPS_INT32       idx, tdx;                       /* General loop/index varaible          */\r
 430 EPS_INT32       sleepTime; \r
 431 struct timeb    sleepS, sleepE;\r
 432 #endif /* GCOMSW_EPSON_SLEEP */\r
 433 \r
 434 /*** Has a Lib been initialized                                                         */\r
 435     if (libStatus != EPS_STATUS_NOT_INITIALIZED) {\r
 436         EPS_RETURN( EPS_ERR_LIB_INTIALIZED );\r
 437     }\r
 438 \r
 439 /*** Validate input parameters                                                          */\r
 440   if( EPS_ERR_NONE != (retStatus = prtFunctionCheck(commMode, usbFuncPtrs, netFuncPtrs, cmnFuncPtrs)) ){\r
 441     EPS_RETURN( retStatus );\r
 442   }\r
 443 \r
 444 /*** Register Functions                                                                 */\r
 445   if( commMode & EPS_PROTOCOL_USB ){\r
 446         memcpy((void*)(&epsUsbFnc), (void*)usbFuncPtrs, sizeof(EPS_USB_FUNC));\r
 447   } else{\r
 448       memset((void*)(&epsUsbFnc), 0, sizeof(EPS_USB_FUNC));\r
 449   }\r
 450   if( commMode & EPS_PROTOCOL_NET ){\r
 451         memcpy((void*)(&epsNetFnc), (void*)netFuncPtrs, sizeof(EPS_NET_FUNC));\r
 452   } else{\r
 453       memset((void*)(&epsNetFnc), 0, sizeof(EPS_NET_FUNC));\r
 454   }\r
 455     memcpy((void*)(&epsCmnFnc), (void*)cmnFuncPtrs, sizeof(EPS_CMN_FUNC));\r
 456 \r
 457 #ifdef GCOMSW_EPSON_SLEEP\r
 458     if (epsCmnFnc.sleep == NULL)\r
 459         epsCmnFnc.sleep = serSleep;\r
 460 #endif /* GCOMSW_EPSON_SLEEP */\r
 461 \r
 462 \r
 463 /*** Initialize ESC/P-R Lib and Local Global Variables                                  */\r
 464     gStatusCount = 0;\r
 465 \r
 466     memset(&printJob, 0, sizeof(EPS_PRINT_JOB));\r
 467     \r
 468     printJob.jobStatus  = EPS_STATUS_NOT_INITIALIZED;\r
 469     printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;\r
 470   printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;\r
 471   printJob.printer    = NULL;\r
 472   printJob.bComm    = TRUE; \r
 473   printJob.platform   = 0x04; /* '0x04 = linux' is default */ \r
 474 \r
 475     libStatus   = EPS_STATUS_NOT_INITIALIZED;\r
 476   sendDataBufSize = 0;\r
 477     sendDataBuf = NULL;\r
 478   tmpLineBufSize = 0;\r
 479     tmpLineBuf  = NULL;\r
 480 \r
 481 /*** Initialize continue buffer                                                         */\r
 482   printJob.contData.sendData = NULL;\r
 483   printJob.contData.sendDataSize = 0;\r
 484 \r
 485   /* DEL printJob.additional = EPS_ADDDATA_NONE;\r
 486   printJob.qrcode.bits = NULL;\r
 487   printJob.qrcode.cellNum = 0;\r
 488   printJob.qrcode.dpc = 0; */\r
 489 \r
 490   obsClear();\r
 491 \r
 492 /*** Set "Endian-ness" for the current cpu                                              */\r
 493   memInspectEndian();\r
 494 \r
 495 /*** Set Communication Mode                                                             */\r
 496     printJob.commMode = commMode;\r
 497 \r
 498 /*** Change ESC/P-R Lib Status                                                          */\r
 499     libStatus = EPS_STATUS_INITIALIZED;\r
 500 \r
 501 /*** Return to Caller                                                                   */\r
 502     EPS_RETURN( EPS_ERR_NONE );\r
 503 }\r
 504 \r
 505 \r
 506 /*******************************************|********************************************/\r
 507 /*                                                                                      */\r
 508 /* Function name:     epsReleaseDriver()                                                */\r
 509 /*                                                                                      */\r
 510 /* Arguments                                                                            */\r
 511 /* ---------                                                                            */\r
 512 /* Name:            Type:                   Description:                                */\r
 513 /* N/A              void                                                                */\r
 514 /*                                                                                      */\r
 515 /* Return value:                                                                        */\r
 516 /*      << Normal >>                                                                    */\r
 517 /*      EPS_ERR_NONE                     - Success                                      */\r
 518 /*      << Error >>                                                                     */\r
 519 /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */\r
 520 /*                                                                                      */\r
 521 /* Description:                                                                         */\r
 522 /*      Creanup Driver.                                                                 */\r
 523 /*                                                                                      */\r
 524 /*******************************************|********************************************/\r
 525 EPS_ERR_CODE epsReleaseDriver (\r
 526   \r
 527     void\r
 528 \r
 529 ){\r
 530   EPS_LOG_FUNCIN;\r
 531 \r
 532 /*** Has a Lib been initialized                                                         */\r
 533     if (libStatus == EPS_STATUS_NOT_INITIALIZED) {\r
 534         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 535     }\r
 536 \r
 537   epsEndJob();\r
 538 \r
 539 /*** Clear inside supported media list                                                  */\r
 540   ClearSupportedMedia();\r
 541 \r
 542 /*** Clear inside printer list                                                          */\r
 543   prtClearPrinterList();\r
 544   printJob.printer = NULL;\r
 545   obsClear();\r
 546 \r
 547 /*** Clear inside additional data buffer                                                */\r
 548   /* DEL EPS_SAFE_RELEASE( printJob.qrcode.bits ) */\r
 549 \r
 550 /*** Change ESC/P-R Lib Status                                                          */\r
 551   libStatus = EPS_STATUS_NOT_INITIALIZED;\r
 552 \r
 553   EPS_RETURN( EPS_ERR_NONE );\r
 554 }\r
 555 \r
 556 \r
 557 /*******************************************|********************************************/\r
 558 /*                                                                                      */\r
 559 /* Function name:     epsFindPrinter()                                                  */\r
 560 /*                                                                                      */\r
 561 /* Arguments                                                                            */\r
 562 /* ---------                                                                            */\r
 563 /* Name:            Type:                   Description:                                */\r
 564 /* protocol     EPS_INT32               I: Protocol to be retrieved                 */\r
 565 /* timeout          EPS_UINT32              I: Network pirinter find timeout            */\r
 566 /*                                                                                      */\r
 567 /* Return value:                                                                        */\r
 568 /*      EPS_ERR_NONE                    - Success (printer found)                       */\r
 569 /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */\r
 570 /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */\r
 571 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
 572 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 573 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 574 /*                                                                                      */\r
 575 /* Description:                                                                         */\r
 576 /*      find USB and Network printer.                                                   */\r
 577 /*                                                                                      */\r
 578 /*******************************************|********************************************/\r
 579 EPS_ERR_CODE epsFindPrinter (\r
 580 \r
 581         EPS_INT32           protocol, \r
 582         EPS_UINT32          timeout\r
 583 \r
 584 ){\r
 585 /*** Declare Variable Local to Routine                                                  */\r
 586     EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */\r
 587 \r
 588   EPS_LOG_FUNCIN;\r
 589 \r
 590 /*** Has a Lib been initialized                                                         */\r
 591     if (libStatus != EPS_STATUS_INITIALIZED) {\r
 592         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 593     }\r
 594 \r
 595 /*** Is a Job already open                                                              */\r
 596     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {\r
 597         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );\r
 598     }\r
 599 \r
 600 /*** Clear inside printer list                                                          */\r
 601   prtClearPrinterList();\r
 602   printJob.printer = NULL;\r
 603   obsClear();\r
 604 \r
 605 /*** find                                                                               */\r
 606   printJob.findStatus = EPS_STATUS_INITIALIZED;\r
 607   \r
 608   retStatus = prtFindPrinter( protocol, timeout );\r
 609 \r
 610   printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;\r
 611 \r
 612   EPS_RETURN( retStatus );\r
 613 }\r
 614 \r
 615 \r
 616 /*******************************************|********************************************/\r
 617 /*                                                                                      */\r
 618 /* Function name:     epsProbePrinter()                                                 */\r
 619 /*                                                                                      */\r
 620 /* Arguments                                                                            */\r
 621 /* ---------                                                                            */\r
 622 /* Name:            Type:                   Description:                                */\r
 623 /* probeParam       EPS_PROBE*              I: prober parameter structure               */\r
 624 /*                                                                                      */\r
 625 /* Return value:                                                                        */\r
 626 /*      EPS_ERR_NONE                    - Success (printer found)                       */\r
 627 /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */\r
 628 /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */\r
 629 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
 630 /*      EPS_ERR_INV_ARG_PROBEINFO       - Invalid argument probe infomation             */\r
 631 /*      EPS_ERR_INV_ARG_UNK_METHOD      - Invalid value "method"                        */\r
 632 /*      EPS_ERR_INV_ARG_PRINTER_ID      - Invalid format "identify"                     */\r
 633 /*      EPS_ERR_INV_ARG_PRINTER_ADDR    - Invalid format "address"                      */\r
 634 /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */\r
 635 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 636 /*      EPS_ERR_PRINTER_NOT_USEFUL      - received but not usefl                        */\r
 637 /*                                                                                      */\r
 638 /* Description:                                                                         */\r
 639 /*      printer specified by printerID or IP Address is retrieved.                      */\r
 640 /*                                                                                      */\r
 641 /*******************************************|********************************************/\r
 642 EPS_ERR_CODE epsProbePrinter(\r
 643 \r
 644     const EPS_PROBE*   probeParam\r
 645     \r
 646 ){\r
 647 /*** Declare Variable Local to Routine                                                  */\r
 648     EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */\r
 649 \r
 650   EPS_LOG_FUNCIN;\r
 651 \r
 652 /*** Validate input parameters                                                          */\r
 653   if (NULL == probeParam) {\r
 654     EPS_RETURN( EPS_ERR_INV_ARG_PROBEINFO );\r
 655   }\r
 656 \r
 657 /*** Has a Lib been initialized                                                         */\r
 658     if (libStatus != EPS_STATUS_INITIALIZED) {\r
 659         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 660     }\r
 661 \r
 662 /*** Is a Job already open                                                              */\r
 663     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {\r
 664         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );\r
 665     }\r
 666 \r
 667 /*** Clear inside printer list                                                          */\r
 668   prtClearPrinterList();\r
 669   printJob.printer = NULL;\r
 670   obsClear();\r
 671 \r
 672 /*** probe                                                                              */\r
 673   printJob.findStatus = EPS_STATUS_INITIALIZED;\r
 674   switch( probeParam->method ){\r
 675     case EPS_PRB_BYID:\r
 676       retStatus = prtProbePrinterByID( probeParam );\r
 677       break;\r
 678 \r
 679     case EPS_PRB_BYADDR:\r
 680       retStatus = prtProbePrinterByAddr( probeParam );\r
 681       break;\r
 682 \r
 683     default:\r
 684       retStatus = EPS_ERR_INV_ARG_UNK_METHOD;\r
 685   }\r
 686   printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;\r
 687 \r
 688   EPS_RETURN( retStatus );\r
 689 }\r
 690 \r
 691 \r
 692 /*******************************************|********************************************/\r
 693 /*                                                                                      */\r
 694 /* Function name:     epsCancelFindPrinter()                                            */\r
 695 /*                                                                                      */\r
 696 /* Arguments                                                                            */\r
 697 /* ---------                                                                            */\r
 698 /* Name:            Type:                   Description:                                */\r
 699 /* N/A              void                                                                */\r
 700 /*                                                                                      */\r
 701 /* Return value:                                                                        */\r
 702 /*      EPS_ERR_NONE                    - Success                                       */\r
 703 /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */\r
 704 /*      EPS_ERR_FIND_NOT_STARTED        - find not started                              */\r
 705 /*      EPS_ERR_INVALID_CALL            - invalid called                                */\r
 706 /*                                                                                      */\r
 707 /* Description:                                                                         */\r
 708 /*      Cancel the epsFindPrinter(), epsProbePrinter() process.                         */\r
 709 /*                                                                                      */\r
 710 /*******************************************|********************************************/\r
 711 EPS_ERR_CODE epsCancelFindPrinter (\r
 712 \r
 713   void\r
 714 \r
 715 ){\r
 716   EPS_LOG_FUNCIN;\r
 717 \r
 718  /*** Has a Lib been initialized                                                        */\r
 719     if (libStatus != EPS_STATUS_INITIALIZED) {\r
 720         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 721     }\r
 722 \r
 723 /*** Has a Find been started                                                            */\r
 724     if (printJob.findStatus != EPS_STATUS_INITIALIZED) {\r
 725         EPS_RETURN( EPS_ERR_FIND_NOT_STARTED );\r
 726     }\r
 727   \r
 728   EPS_RETURN( prtCancelFindPrinter() );\r
 729 }\r
 730 \r
 731 \r
 732 /*******************************************|********************************************/\r
 733 /*                                                                                      */\r
 734 /* Function name:     epsSetPrinter()                                                   */\r
 735 /*                                                                                      */\r
 736 /* Arguments                                                                            */\r
 737 /* ---------                                                                            */\r
 738 /* Name:            Type:                   Description:                                */\r
 739 /* printer          EPS_PRINTER*            O: Pointer to a target printer              */\r
 740 /*                                                                                      */\r
 741 /* Return value:                                                                        */\r
 742 /*      EPS_ERR_NONE                    - Success                                       */\r
 743 /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */\r
 744 /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */\r
 745 /*      EPS_ERR_INV_ARG_PRINTER         - Illegal printer was specified                 */\r
 746 /*      EPS_ERR_INV_ARG_COMMMODE        - Invalid argument "printer.protocol"           */\r
 747 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 748 /*      EPS_ERR_INV_ARG_PRINTER_ADDR    - Invalid format " printer.location"            */\r
 749 /*      EPS_ERR_INV_PRINT_LANGUAGE      - Invalid argument "printer.language"           */\r
 750 /*                                                                                      */\r
 751 /* Description:                                                                         */\r
 752 /*      Selects a printer to use from detected printers.                                */\r
 753 /*      Register a user specified printer.                                        */\r
 754 /*                                                                                      */\r
 755 /*******************************************|********************************************/\r
 756 EPS_ERR_CODE    epsSetPrinter (\r
 757 \r
 758         const EPS_PRINTER*      printer\r
 759 \r
 760 ){\r
 761 /*** Declare Variable Local to Routine                                                  */\r
 762     EPS_ERR_CODE    ret = EPS_ERR_NONE;     /* Return status of internal calls  */\r
 763   EPS_PRINTER_INN*  innerPrinter = NULL;\r
 764 \r
 765 EPS_LOG_FUNCIN;\r
 766 \r
 767 /*** Has a Lib been initialized                                                         */\r
 768     if (libStatus != EPS_STATUS_INITIALIZED) {\r
 769         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 770     }\r
 771 \r
 772 /*** Is a Job already open                                                              */\r
 773     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {\r
 774         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );\r
 775     }\r
 776 \r
 777 /*** Validate input parameters                                                          */\r
 778   if (NULL == printer){\r
 779     EPS_RETURN( EPS_ERR_INV_ARG_PRINTER );\r
 780   }\r
 781 \r
 782 /*** convert internal structure                                                         */\r
 783   innerPrinter = prtGetInnerPrinter(printer);\r
 784   if( NULL == innerPrinter ){\r
 785     ret = prtAddUsrPrinter(printer, &innerPrinter);\r
 786     if( EPS_ERR_NONE != ret ){\r
 787       EPS_RETURN( ret );\r
 788     }\r
 789   }\r
 790 \r
 791 /*** Set Job target printer                                                             */\r
 792   printJob.printer  = innerPrinter;\r
 793   printJob.bComm    = TRUE;\r
 794   obsSetPrinter(innerPrinter);\r
 795   prtSetupJobFunctions(printJob.printer, &jobFnc);  /* Set Job functions */\r
 796 \r
 797   EPS_RETURN( EPS_ERR_NONE );\r
 798 }\r
 799 \r
 800 \r
 801 /*******************************************|********************************************/\r
 802 /*                                                                                      */\r
 803 /* Function name:     epsStartJob()                                                     */\r
 804 /*                                                                                      */\r
 805 /* Arguments                                                                            */\r
 806 /* ---------                                                                            */\r
 807 /* Name:            Type:                   Description:                                */\r
 808 /* jobAttr          const EPS_JOB_ATTRIB*   I: Print Job Attribute                      */\r
 809 /*                                                                                      */\r
 810 /* Return value:                                                                        */\r
 811 /*      << Normal >>                                                                    */\r
 812 /*      EPS_ERR_NONE                    - Success                                       */\r
 813 /*      << Error >>                                                                     */\r
 814 /*      EPS_ERR_INV_ARG_JOB_ATTRIB              - Invalid argument "jobAttr"           */\r
 815 /*      EPS_ERR_INV_COLOR_PLANE                 - Invalid Color Plane                   */\r
 816 /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */\r
 817 /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */\r
 818 /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */\r
 819 /*      EPS_ERR_INV_MEDIA_TYPE                  - Invalid Media Type                    */\r
 820 /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */\r
 821 /*      EPS_ERR_INV_PRINT_QUALITY               - Invalid Print Quality                 */\r
 822 /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */\r
 823 /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */\r
 824 /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */\r
 825 /*      EPS_ERR_INV_BRIGHTNESS                  - Invalid Brightness                    */\r
 826 /*      EPS_ERR_INV_CONTRAST                    - Invalid Contrast                      */\r
 827 /*      EPS_ERR_INV_SATURATION                  - Invalid Saturation                    */\r
 828 /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */\r
 829 /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */\r
 830 /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */\r
 831 /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */\r
 832 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */\r
 833 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */\r
 834 /*      EPS_ERR_INV_PAPER_SOURCE                - Invalid Paper source                  */\r
 835 /*      EPS_ERR_INV_DUPLEX                      - Invalid duplex                        */\r
 836 /*      EPS_ERR_INV_FEED_DIRECTION              - Invalid feed direction                */\r
 837 /*      EPS_ERR_LANGUAGE_NOT_SUPPORTED          - Unsupported function Error (language) */\r
 838 /*                                                                                      */\r
 839 /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */\r
 840 /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */\r
 841 /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */\r
 842 /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Red Eye                   */\r
 843 /*                                                                                      */\r
 844 /*      (Uni/Bi-Directional)                                                            */\r
 845 /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */\r
 846 /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */\r
 847 /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */\r
 848 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
 849 /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */\r
 850 /*      (Bi-Directional Only)                                                           */\r
 851 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
 852 /*                                                                                      */\r
 853 /* Description:                                                                         */\r
 854 /*      Creates a new print job.                                                        */\r
 855 /*                                                                                      */\r
 856 /*******************************************|********************************************/\r
 857 EPS_ERR_CODE    epsStartJob (\r
 858 \r
 859         const EPS_JOB_ATTRIB*     jobAttr  /* Print Attributes for this Job            */\r
 860 \r
 861 ){\r
 862 \r
 863 /*** Declare Variable Local to Routine                                                  */\r
 864 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;           /* Return status of internal calls  */\r
 865 EPS_STATUS_INFO stInfo;\r
 866 \r
 867 EPS_LOG_FUNCIN;\r
 868 \r
 869 /*** Has a Lib been initialized                                                         */\r
 870     if (libStatus != EPS_STATUS_INITIALIZED) {\r
 871         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
 872     }\r
 873 \r
 874 /*** Is a Job already open                                                              */\r
 875     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {\r
 876         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );\r
 877     }\r
 878   \r
 879 /*** Has a target printer specified                                                     */\r
 880   if(NULL == printJob.printer){\r
 881     EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );\r
 882   }\r
 883 \r
 884   if(EPS_CP_JPEG == jobAttr->colorPlane ){\r
 885     if( !(EPS_SPF_JPGPRINT & printJob.printer->supportFunc) ){\r
 886       EPS_RETURN( EPS_ERR_INV_COLOR_PLANE );\r
 887     }\r
 888   }\r
 889 \r
 890 /*======================================================================================*/\r
 891 /*** Setup Page Attribute                                                               */\r
 892 /*======================================================================================*/\r
 893   if (jobAttr == NULL){\r
 894         EPS_RETURN( EPS_ERR_INV_ARG_JOB_ATTRIB )\r
 895   }\r
 896 \r
 897   if(EPS_LANG_ESCPR == printJob.printer->language ){\r
 898     /*** ESC/P-R ***/\r
 899     retStatus = SetupJobAttrib(jobAttr);\r
 900   } else{\r
 901     /*** ESC/Page ***/\r
 902 #ifdef GCOMSW_CMD_ESCPAGE\r
 903     retStatus = pageInitJob(jobAttr);\r
 904 #else\r
 905     retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
 906 #endif\r
 907   } \r
 908   if (EPS_ERR_NONE != retStatus){\r
 909     EPS_RETURN( retStatus );\r
 910   }\r
 911 \r
 912 /*** Change Job Status                                                                  */\r
 913     printJob.jobStatus = EPS_STATUS_INITIALIZED;\r
 914   obsSetColorPlane( printJob.attr.colorPlane );\r
 915 \r
 916 /*======================================================================================*/\r
 917 /*** Check the printer status. (before session open)                                    */\r
 918 /*======================================================================================*/\r
 919   memset(&stInfo, 0, sizeof(stInfo));\r
 920   if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
 921     retStatus = PRT_INVOKE_JOBFNC(jobFnc.GetStatus, (&stInfo, NULL, NULL));\r
 922     if( EPS_ERR_NONE != retStatus ){\r
 923       goto epsStartJob_END;\r
 924     } else if(EPS_ST_IDLE != stInfo.nState){\r
 925       retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
 926       goto epsStartJob_END;\r
 927     } else if( EPS_PRNWARN_DISABLE_CLEAN & stInfo.nWarn && \r
 928             EPS_MNT_CLEANING == printJob.attr.cmdType ){\r
 929       retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
 930       goto epsStartJob_END;\r
 931     }\r
 932     /* ignore color-ink-end warning \r
 933        if color print done, will occuer EPS_PRNERR_INKOUT(0x47).\r
 934     else if( EPS_PRNWARN_COLOR_INKOUT & stInfo.nWarn ){\r
 935       if( !((EPS_CP_FULLCOLOR == printJob.attr.colorPlane || EPS_CP_256COLOR == printJob.attr.colorPlane)\r
 936         && EPS_CM_MONOCHROME == printJob.attr.colorMode\r
 937         && EPS_MTID_PLAIN == printJob.attr.mediaTypeIdx\r
 938         && (EPS_MLID_BORDERS == printJob.attr.printLayout || EPS_MLID_CUSTOM == printJob.attr.printLayout)) ){\r
 939          color printing is impossible. (Mono/Plain/Border is possible) \r
 940         retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
 941         goto epsStartJob_END;\r
 942       }\r
 943     }*/\r
 944   }\r
 945 \r
 946 /*======================================================================================*/\r
 947 /*** Prepar RGB buffer                                                                  */\r
 948 /*======================================================================================*/\r
 949   if(EPS_LANG_ESCPR == printJob.printer->language ){\r
 950     /*** ESC/P-R ***/\r
 951     if( EPS_CP_FULLCOLOR == printJob.attr.colorPlane ||\r
 952       EPS_CP_256COLOR  == printJob.attr.colorPlane){\r
 953       /*** Allocate buffer for "Send Data" command                                    */\r
 954       EPS_SAFE_RELEASE(sendDataBuf );\r
 955       EPS_SAFE_RELEASE(tmpLineBuf  );\r
 956       \r
 957       sendDataBufSize = (EPS_INT32)(ESCPR_HEADER_LENGTH    +\r
 958                       ESCPR_SEND_DATA_LENGTH +\r
 959                       (printJob.printableAreaWidth * printJob.bpp));\r
 960       sendDataBuf = (EPS_UINT8*)EPS_ALLOC(sendDataBufSize);\r
 961       if(sendDataBuf == NULL){\r
 962         sendDataBufSize = 0;\r
 963         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
 964       }\r
 965         \r
 966       memset(sendDataBuf, 0xFF, (EPS_UINT32)sendDataBufSize);\r
 967         \r
 968       /*** Allocate buffer for RLE complession                                        */\r
 969       tmpLineBufSize = (EPS_INT32)(printJob.printableAreaWidth * printJob.bpp) + 256; /* 256 is temp buffer */\r
 970       tmpLineBuf = (EPS_UINT8*)EPS_ALLOC(tmpLineBufSize);\r
 971       if(tmpLineBuf == NULL){\r
 972         tmpLineBufSize = 0;\r
 973         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
 974       }\r
 975       memset(tmpLineBuf, 0xFF, (EPS_UINT32)tmpLineBufSize);\r
 976 \r
 977     } else if(EPS_CP_JPEG == printJob.attr.colorPlane){\r
 978       if(0 == printJob.printer->JpgMax){\r
 979         /*** get jpeg limit */\r
 980         retStatus = GetJpgMax(printJob.printer);\r
 981         if (retStatus != EPS_ERR_NONE) {\r
 982           goto epsStartJob_END;\r
 983         }\r
 984       }\r
 985     }\r
 986   } else{\r
 987 #ifdef GCOMSW_CMD_ESCPAGE\r
 988     /*** ESC/Page ***/\r
 989     retStatus = pageAllocBuffer();\r
 990 #else\r
 991     retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
 992 #endif\r
 993     if (retStatus != EPS_ERR_NONE) {\r
 994       goto epsStartJob_END;\r
 995     }\r
 996   }\r
 997 \r
 998 /*======================================================================================*/\r
 999 /*** protocol depend StartJob                                                           */\r
1000 /*======================================================================================*/\r
1001   retStatus = jobFnc.StartJob();\r
1002   if (retStatus != EPS_ERR_NONE) {\r
1003     goto epsStartJob_END;\r
1004   }\r
1005 \r
1006 /*======================================================================================*/\r
1007 /*** Init flags                                                                         */\r
1008 /*======================================================================================*/\r
1009   printJob.transmittable = TRUE;\r
1010   printJob.resetSent = EPS_RESET_NOT_SENT;\r
1011   printJob.resetReq = FALSE;\r
1012   printJob.bComm = TRUE;\r
1013   printJob.sendJS = FALSE;\r
1014   printJob.pageCount = 0;\r
1015   gStatusCount = 0;\r
1016 \r
1017   printJob.contData.savePoint = EPS_SAVEP_NONE;\r
1018   printJob.contData.saveStep = 0;\r
1019   printJob.contData.sendData = NULL;\r
1020   printJob.contData.sendDataSize = 0;\r
1021 \r
1022 /*======================================================================================*/\r
1023 /*** Send StartJob Commands                                                             */\r
1024 /*======================================================================================*/\r
1025 #ifdef LCOMSW_CMDDMP\r
1026 {\r
1027   EPS_INT8 fname[256];\r
1028   sprintf(fname, "%s-%s-%s.prn", (printJob.printer->language == EPS_LANG_ESCPR)?"escpr":"page",\r
1029     (printJob.attr.colorMode == EPS_CM_COLOR)?"color":"mono",\r
1030     (printJob.attr.colorPlane == EPS_CP_FULLCOLOR)?"24":"8");\r
1031   EPS_DF_OPEN(fname)\r
1032 }\r
1033 #endif\r
1034 \r
1035   if( EPS_CP_PRINTCMD != printJob.attr.colorPlane ){\r
1036     if(EPS_LANG_ESCPR == printJob.printer->language ){\r
1037       /*** ESC/P-R ***/\r
1038       if(EPS_PM_JOB != obsGetPageMode()){\r
1039         retStatus = SendStartJob(FALSE);\r
1040       }\r
1041     } else{\r
1042       /*** ESC/Page ***/\r
1043 #ifdef GCOMSW_CMD_ESCPAGE\r
1044       retStatus = pageStartJob();\r
1045 #else\r
1046       retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
1047 #endif\r
1048     }\r
1049 \r
1050     if(EPS_ERR_NONE != retStatus){\r
1051       goto epsStartJob_END;\r
1052     }\r
1053   } else{\r
1054     printJob.pageStatus = EPS_STATUS_INITIALIZED;\r
1055   }\r
1056 \r
1057   printJob.jobStatus = EPS_STATUS_ESTABLISHED;\r
1058 \r
1059 epsStartJob_END:\r
1060 /*** Return to Caller                                                                   */\r
1061   if (EPS_ERR_NOT_OPEN_IO == retStatus || EPS_ERR_COMM_ERROR == retStatus) {\r
1062     printJob.bComm = FALSE;\r
1063     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1064   }\r
1065 \r
1066     EPS_RETURN( retStatus );\r
1067 }\r
1068 \r
1069 \r
1070 /*******************************************|********************************************/\r
1071 /*                                                                                      */\r
1072 /* Function name:     epsStartPage()                                                    */\r
1073 /*                                                                                      */\r
1074 /* Arguments                                                                            */\r
1075 /* ---------                                                                            */\r
1076 /* Name:        Type:         Description:                                    */\r
1077 /* pageAttr     const EPS_JOB_ATTRIB*   I: This Page Attribute                          */\r
1078 /*                                                                                      */\r
1079 /* Return value:                                                                        */\r
1080 /*      << Normal >>                                                                    */\r
1081 /*      EPS_ERR_NONE                            - Success                               */\r
1082 /*      EPS_JOB_CANCELED                        - Cancelled operation by user           */\r
1083 /*                                                (Do not return when Uni-Directional)  */\r
1084 /*      << Error >>                                                                     */\r
1085 /*      EPS_ERR_JOB_NOT_INITIALIZED             - JOB is NOT initialized                */\r
1086 /*      EPS_ERR_PAGE_NOT_CLOSED                 - PAGE is NOT closed                    */\r
1087 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                */\r
1088 /*      EPS_ERR_OPR_FAIL                        - Internal Error                        */\r
1089 /*      EPS_ERR_MEMORY_ALLOCATION               - Failed to allocate memory             */\r
1090 /*                                                                                      */\r
1091 /* Description:                                                                         */\r
1092 /*      Starts the current page.                                                        */\r
1093 /*                                                                                      */\r
1094 /*******************************************|********************************************/\r
1095 EPS_ERR_CODE    epsStartPage (\r
1096 \r
1097         const EPS_PAGE_ATTRIB* pageAttr\r
1098 \r
1099 ){\r
1100 /*** Declare Variable Local to Routine                                                  */\r
1101 EPS_ERR_CODE    retStatus;                  /* Return status of internal calls          */\r
1102 EPS_UINT32      retBufSize = 0;\r
1103 EPS_STATUS_INFO stInfo;\r
1104 \r
1105 EPS_LOG_FUNCIN;\r
1106 \r
1107   (void)pageAttr;   /* unused now */\r
1108 \r
1109 /*** EPS_CP_PRINTCMD not necessary call epsStartPage()                                  */\r
1110     if (EPS_CP_PRINTCMD == printJob.attr.colorPlane) {\r
1111         EPS_RETURN( EPS_ERR_NONE );\r
1112     }\r
1113 \r
1114 /*** Has a Job been initialized                                                         */\r
1115     if (printJob.jobStatus != EPS_STATUS_ESTABLISHED) {\r
1116         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
1117     }\r
1118 \r
1119 /*** Has the Page Status been un-initialized; indicating the last page was closed       */\r
1120     if (printJob.pageStatus != EPS_STATUS_NOT_INITIALIZED) {\r
1121         EPS_RETURN( EPS_ERR_PAGE_NOT_CLOSED );\r
1122     }\r
1123 \r
1124 /*** Check the printer status and the stacker error.                                    */\r
1125   if ( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
1126     retStatus = MonitorStatus(&stInfo);\r
1127 \r
1128     if( EPS_ERR_NONE == retStatus ){\r
1129       if( EPS_PREPARE_TRAYCLOSED == stInfo.nPrepare ){\r
1130         retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1131       } else if( EPS_PM_JOB == obsGetPageMode() &&\r
1132              EPS_ST_IDLE != stInfo.nState ){\r
1133         /* still printing */\r
1134         EPS_DBGPRINT(("*** StarPage Wait ***\n"))\r
1135         retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1136       }\r
1137     }\r
1138     if( EPS_ERR_NONE != retStatus ){\r
1139       if( EPS_ERR_COMM_ERROR != retStatus && \r
1140         EPS_PROTOCOL_USB != EPS_PRT_PROTOCOL(printJob.printer->protocol) )\r
1141       { /* Ignore error, Make buffer full state. */\r
1142         EPS_DBGPRINT(("*** Ignore error on StartPage ***\n"))\r
1143         retStatus = EPS_ERR_NONE;\r
1144       } else{\r
1145         goto epsStartPage_END;\r
1146       }\r
1147     }\r
1148   }\r
1149 \r
1150   if( EPS_PM_JOB == obsGetPageMode() &&\r
1151     EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol) ){\r
1152     retStatus = PRT_INVOKE_JOBFNC(jobFnc.StartPage, ());\r
1153     if (retStatus != EPS_ERR_NONE) {\r
1154       goto epsStartPage_END;\r
1155     }\r
1156   }\r
1157   if( EPS_RESET_SENT == printJob.resetSent ){\r
1158     /* If CancelPage is done, restart Job. */\r
1159         /*** protocol depend RestartJob                                                 */\r
1160     retStatus = PRT_INVOKE_JOBFNC(jobFnc.RestartJob, ());\r
1161     if (retStatus != EPS_ERR_NONE) {\r
1162       goto epsStartPage_END;\r
1163     }\r
1164   }\r
1165 \r
1166   if(0 == printJob.contData.saveStep){\r
1167     if(EPS_LANG_ESCPR == printJob.printer->language ){\r
1168       /*** ESC/P-R ***/\r
1169       if( EPS_RESET_SENT == printJob.resetSent ){\r
1170         /* If CancelPage is done, restart Job complete. */\r
1171         printJob.resetSent = EPS_RESET_NOT_SENT;\r
1172         /*** Send StartJob & StartPage Commands                                     */\r
1173         retStatus = SendStartJob(TRUE);\r
1174       } else if( EPS_PM_JOB == obsGetPageMode() ){\r
1175         /*** Send StartJob & StartPage Commands                                     */\r
1176         retStatus = SendStartJob(TRUE);\r
1177       } else{\r
1178         /*** Send StartPage Commands                                                */\r
1179         EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, sizeof(StartPage) )\r
1180         if(NULL == sendDataBuf){\r
1181           sendDataBufSize = 0;\r
1182           retStatus = EPS_ERR_MEMORY_ALLOCATION;\r
1183           goto epsStartPage_END;\r
1184         }\r
1185 \r
1186         memcpy(sendDataBuf, StartPage, sizeof(StartPage));\r
1187         retStatus = SendCommand(sendDataBuf, sizeof(StartPage), &retBufSize, TRUE);\r
1188       }\r
1189     } else{\r
1190       /*** ESC/Page ***/\r
1191 #ifdef GCOMSW_CMD_ESCPAGE\r
1192       retStatus = pageStartPage();\r
1193 #else\r
1194       retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
1195 #endif\r
1196     }\r
1197   } else{\r
1198     /* send command retry */\r
1199     retStatus = SendLeftovers();\r
1200     if(EPS_ERR_INVALID_CALL == retStatus){\r
1201       retStatus = EPS_ERR_NONE;\r
1202     }\r
1203   }\r
1204   if(EPS_ERR_NONE == retStatus){\r
1205     printJob.contData.saveStep = 0;\r
1206   } else{\r
1207     printJob.contData.saveStep = 1;\r
1208   }\r
1209 \r
1210 epsStartPage_END:\r
1211   if(EPS_ERR_NONE == retStatus){\r
1212     /*** Change Page Status                                                         */\r
1213     printJob.pageStatus = EPS_STATUS_INITIALIZED;\r
1214     printJob.contData.savePoint = EPS_SAVEP_NONE;\r
1215 \r
1216     /*** Set Vertical Offset                                                        */\r
1217         printJob.verticalOffset = 0;\r
1218     printJob.contData.jpgSize = 0;\r
1219     printJob.contData.epRetry = 0;\r
1220     printJob.contData.skipLine = FALSE;\r
1221     printJob.jpegSize = 0;\r
1222     printJob.bJpgLimit = FALSE;\r
1223     if( printJob.attr.duplex != EPS_DUPLEX_NONE ){\r
1224       printJob.needBand = TRUE;\r
1225     } else{\r
1226       printJob.needBand = FALSE;\r
1227     }\r
1228     \r
1229   } else if(EPS_ERR_COMM_ERROR == retStatus){\r
1230     printJob.bComm = FALSE;\r
1231     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1232   } else{\r
1233     printJob.contData.savePoint = EPS_SAVEP_START_PAGE;\r
1234   }\r
1235 \r
1236 /*** Return to Caller                                                                   */\r
1237     EPS_RETURN( retStatus );\r
1238 }\r
1239 \r
1240 \r
1241 /*******************************************|********************************************/\r
1242 /*                                                                                      */\r
1243 /* Function name:     epsPrintBand()                                                    */\r
1244 /*                                                                                      */\r
1245 /* Arguments                                                                            */\r
1246 /* ---------                                                                            */\r
1247 /* Name:        Type:               Description:                                        */\r
1248 /* data          EPS_UINT8*         I: Pointer to image [RGB] data                      */\r
1249 /* widthPixels   EPS_UINT32         I: The width of the raster band (in pixels)         */\r
1250 /* heightPixels  EPS_UINT32*        I/O: In : Height of image (image lines)  (in pixels)*/\r
1251 /*                                     : Out: Sent Height                               */\r
1252 /*                                                                                      */\r
1253 /* Return value:                                                                        */\r
1254 /*      << Normal >>                                                                    */\r
1255 /*      EPS_ERR_NONE                    - Success                                       */\r
1256 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
1257 /*                                        (Do not return when Uni-Directional)          */\r
1258 /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */\r
1259 /*      << Error >>                                                                     */\r
1260 /*      EPS_ERR_PAGE_NOT_INITIALIZED    - Page is NOT initialized                       */\r
1261 /*      EPS_ERR_INV_ARG_DATA            - Invalid argument "data"                       */\r
1262 /*      EPS_ERR_INV_ARG_WIDTH_PIXELS    - Invalid argument "widthPixels"                */\r
1263 /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */\r
1264 /*      EPS_ERR_INV_ARG_DATASIZE    - data size limit               */\r
1265 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
1266 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1267 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1268 /*                                                                                      */\r
1269 /* Description:                                                                         */\r
1270 /*      Prints a band of raster data or Jpeg file data.                                 */\r
1271 /*                                                                                      */\r
1272 /*******************************************|********************************************/\r
1273 EPS_ERR_CODE    epsPrintBand (\r
1274 \r
1275         const EPS_UINT8*  data,             /* Pointer to image [RGB] data              */\r
1276         EPS_UINT32  widthPixels,            /* Width of image [ in pixels ]             */\r
1277         EPS_UINT32  *heightPixels           /* Height of image (image lines)            */\r
1278 \r
1279 ) {\r
1280 /*** Declare Variable Local to Routine                                                  */\r
1281   EPS_ERR_CODE    retStatus;\r
1282   EPS_PRN_DATA  prnData;\r
1283 \r
1284   prnData.version = 1;\r
1285   prnData.band.data = data;\r
1286   prnData.band.widthPixels = widthPixels;\r
1287   prnData.band.heightPixels = *heightPixels;\r
1288 \r
1289   retStatus = epsSendData(&prnData);\r
1290 \r
1291   *heightPixels = prnData.band.heightPixels;\r
1292 \r
1293   return retStatus;\r
1294 }\r
1295 \r
1296 \r
1297 EPS_ERR_CODE    epsSendData (\r
1298 \r
1299         EPS_PRN_DATA*  prnData        /* Pointer to image [RGB, JPEG] data        */\r
1300 \r
1301 ) {\r
1302 /*** Declare Variable Local to Routine                                                  */\r
1303 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;\r
1304 \r
1305   EPS_LOG_FUNCIN\r
1306 \r
1307 /*** Has a Page (which also means Job) been initialized                                 */\r
1308     if (printJob.pageStatus == EPS_STATUS_NOT_INITIALIZED) {\r
1309         retStatus = EPS_ERR_PAGE_NOT_INITIALIZED;\r
1310     }\r
1311 \r
1312 /*  printJob.pageStatus = EPS_STATUS_PROCCESSING; */\r
1313 \r
1314   if( FALSE == printJob.bComm ){\r
1315     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1316   }\r
1317 \r
1318 /*** Validate input parameters                                                          */\r
1319   if( NULL == prnData ){\r
1320         EPS_RETURN( EPS_ERR_INV_ARG_DATA );\r
1321   }\r
1322 \r
1323   switch(printJob.attr.colorPlane){\r
1324   case EPS_CP_JPEG:\r
1325     if(EPS_ERR_NONE == retStatus){\r
1326       retStatus = PrintChunk(prnData->chunk.data, &prnData->chunk.dataSize);\r
1327     } else{\r
1328       prnData->chunk.dataSize = 0;\r
1329     }\r
1330     break;\r
1331 \r
1332   case EPS_CP_FULLCOLOR:\r
1333   case EPS_CP_256COLOR:\r
1334     if(EPS_ERR_NONE == retStatus){\r
1335       retStatus = PrintBand(prnData->band.data, prnData->band.widthPixels, &prnData->band.heightPixels);\r
1336     } else{\r
1337       prnData->band.heightPixels = 0;\r
1338     }\r
1339     break;\r
1340 \r
1341   case EPS_CP_PRINTCMD:\r
1342   default:\r
1343     if(EPS_ERR_NONE == retStatus){\r
1344       retStatus = SendCommand(prnData->chunk.data, prnData->chunk.dataSize, \r
1345                 &prnData->chunk.dataSize, FALSE);\r
1346     } else{\r
1347       prnData->chunk.dataSize = 0;\r
1348     }\r
1349     break;\r
1350   }\r
1351 \r
1352   if(EPS_ERR_COMM_ERROR == retStatus){\r
1353     printJob.bComm = FALSE;\r
1354     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1355   }\r
1356 \r
1357     EPS_RETURN( retStatus );\r
1358 }\r
1359 \r
1360 \r
1361 /*******************************************|********************************************/\r
1362 /*                                                                                      */\r
1363 /* Function name:   epsEndPage()                                                        */\r
1364 /*                                                                                      */\r
1365 /* Arguments                                                                            */\r
1366 /* ---------                                                                            */\r
1367 /* Name:        Type:               Description:                                        */\r
1368 /* nextPage     EPS_BOOL            Next page flag                                      */\r
1369 /*                                                                                      */\r
1370 /* Return value:                                                                        */\r
1371 /*      << Normal >>                                                                    */\r
1372 /*      EPS_ERR_NONE                    - Success                                       */\r
1373 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
1374 /*                                        (Do not return when Uni-Directional)          */\r
1375 /*      << Error >>                                                                     */\r
1376 /*      EPS_ERR_PAGE_NOT_INITIALIZED    - PAGE is NOT initialized                       */\r
1377 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
1378 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1379 /*                                                                                      */\r
1380 /* Description:                                                                         */\r
1381 /*      Ends the current page.                                                          */\r
1382 /*                                                                                      */\r
1383 /*******************************************|********************************************/\r
1384 EPS_ERR_CODE    epsEndPage (\r
1385 \r
1386         EPS_BOOL    nextPage\r
1387 \r
1388 ){\r
1389 /*** Declare Variable Local to Routine                                                  */\r
1390 EPS_ERR_CODE    retStatus= EPS_ERR_NONE;            /* Return status of internal calls  */\r
1391 EPS_UINT32    retBufSize = 0;\r
1392 EPS_UINT8*    pCmd = NULL;\r
1393 EPS_STATUS_INFO stInfo;\r
1394 \r
1395 EPS_LOG_FUNCIN;\r
1396 \r
1397 /*** EPS_CP_PRINTCMD not necessary call epsEndPage()                                    */\r
1398   if (EPS_CP_PRINTCMD == printJob.attr.colorPlane) {\r
1399         EPS_RETURN( EPS_ERR_NONE );\r
1400     }\r
1401 \r
1402 /*** Has a Page (which also means Job) been initialized                                 */\r
1403     if (printJob.pageStatus == EPS_STATUS_NOT_INITIALIZED) {\r
1404         EPS_RETURN( EPS_ERR_PAGE_NOT_INITIALIZED );\r
1405     }\r
1406 \r
1407   if( FALSE == printJob.bComm ){\r
1408     /*** Change the page status                                                     */\r
1409     printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;\r
1410     /* Do not send "EndPage" commands */\r
1411     EPS_RETURN( EPS_ERR_NONE );\r
1412   }\r
1413 \r
1414 /*======================================================================================*/\r
1415 /*** Check the printer status                                                           */\r
1416 /*======================================================================================*/\r
1417     if ( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
1418         /* Check the printer status */\r
1419     retStatus = MonitorStatus(NULL);\r
1420     if( EPS_JOB_CANCELED == retStatus ){\r
1421       goto epsEndPage_END;\r
1422     } else if(EPS_ERR_COMM_ERROR == retStatus ){\r
1423       goto epsEndPage_END;\r
1424     }\r
1425   }\r
1426 \r
1427   /* send command retry */\r
1428   retStatus = SendLeftovers();\r
1429   if(EPS_ERR_INVALID_CALL == retStatus){\r
1430     retStatus = EPS_ERR_NONE;\r
1431   }\r
1432 \r
1433 /*** Send EndPage                                                                       */\r
1434   /* step 1 : send dummy band for duplex */\r
1435   if( EPS_ERR_NONE == retStatus && 0 == printJob.contData.saveStep ){\r
1436     printJob.contData.saveStep++;\r
1437     if(  TRUE == printJob.needBand ){\r
1438       retStatus = SendBlankBand();\r
1439       printJob.needBand = FALSE;\r
1440     }\r
1441   } \r
1442 \r
1443   /* step 2 : send end page command */\r
1444   if( EPS_ERR_NONE == retStatus && 1 == printJob.contData.saveStep ){\r
1445     printJob.contData.saveStep++;\r
1446 \r
1447     if(EPS_LANG_ESCPR == printJob.printer->language ){\r
1448       /*** ESC/P-R ***/\r
1449       if( EPS_PM_JOB == obsGetPageMode() ){\r
1450         /* EndPage & EndJob */\r
1451         retStatus = SendEndJob(TRUE);\r
1452       } else{\r
1453         /* EndPage */\r
1454         EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, sizeof(EndPage) )\r
1455         if(NULL == sendDataBuf){\r
1456           sendDataBufSize = 0;\r
1457           retStatus = EPS_ERR_MEMORY_ALLOCATION;\r
1458           goto epsEndPage_END;\r
1459         }\r
1460 \r
1461         pCmd = sendDataBuf;\r
1462         memcpy(pCmd, EndPage, sizeof(EndPage));\r
1463         if( FALSE == nextPage ){\r
1464           if (EPS_DUPLEX_NONE != printJob.attr.duplex && \r
1465             0 == (printJob.pageCount & 0x01)) {\r
1466             nextPage = TRUE;\r
1467           }\r
1468         }\r
1469         if(FALSE == nextPage\r
1470           || EPS_IS_CDDVD( printJob.attr.mediaTypeIdx )){\r
1471           pCmd[10] = EPS_END_PAGE;\r
1472         } else{ \r
1473           pCmd[10] = EPS_NEXT_PAGE;\r
1474         }\r
1475 \r
1476         retStatus = SendCommand(sendDataBuf, sizeof(EndPage), &retBufSize, TRUE);\r
1477       }\r
1478     } else{\r
1479       /*** ESC/Page ***/\r
1480 #ifdef GCOMSW_CMD_ESCPAGE\r
1481       retStatus = pageEndPage();\r
1482 #else\r
1483       retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
1484 #endif\r
1485     }\r
1486   }\r
1487 \r
1488 \r
1489 epsEndPage_END:\r
1490 /*** Return to Caller                                                                   */\r
1491   if(EPS_ERR_NONE == retStatus){\r
1492     /*** Change the page status */\r
1493     printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;\r
1494     printJob.pageCount++;\r
1495     printJob.contData.savePoint = EPS_SAVEP_NONE;\r
1496     printJob.contData.saveStep = 0;\r
1497 \r
1498     if( EPS_PM_JOB == obsGetPageMode() &&\r
1499       EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol) &&\r
1500       printJob.contData.epRetry < 10){\r
1501       /* LPR JOB mode */\r
1502       retStatus = PRT_INVOKE_JOBFNC(jobFnc.EndPage, ());\r
1503       if(EPS_ERR_NONE == retStatus){\r
1504         if(EPS_IS_BI_PROTOCOL(printJob.printer->protocol)){\r
1505           MonitorStatus(&stInfo);\r
1506           if( EPS_ST_IDLE == stInfo.nState ){\r
1507             /* retry this function still idle */\r
1508             serDelayThread(2*_SECOND_, &epsCmnFnc);\r
1509             printJob.contData.epRetry++;\r
1510             printJob.contData.savePoint = EPS_SAVEP_END_PAGE;\r
1511             printJob.contData.saveStep = 2;\r
1512             printJob.pageStatus = EPS_STATUS_INITIALIZED;\r
1513             retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1514             EPS_DBGPRINT(("*** EndPage Wait ***\n"))\r
1515           }\r
1516         }\r
1517       } else if(EPS_ERR_COMM_ERROR == retStatus){\r
1518         printJob.bComm = FALSE;\r
1519         retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1520       }\r
1521     }\r
1522   } else if(EPS_ERR_COMM_ERROR == retStatus){\r
1523     printJob.bComm = FALSE;\r
1524     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1525   } else{\r
1526     printJob.contData.savePoint = EPS_SAVEP_END_PAGE;\r
1527     printJob.contData.nextPage = nextPage;\r
1528   }\r
1529 \r
1530     EPS_RETURN( retStatus );\r
1531 }\r
1532 \r
1533 \r
1534 /*******************************************|********************************************/\r
1535 /*                                                                                      */\r
1536 /* Function name:   epsEndJob()                                                         */\r
1537 /*                                                                                      */\r
1538 /* Arguments                                                                            */\r
1539 /* ---------                                                                            */\r
1540 /* Name:        Type:               Description:                                        */\r
1541 /* N/A          void                N/A                                                 */\r
1542 /*                                                                                      */\r
1543 /* Return value:                                                                        */\r
1544 /*      << Normal >>                                                                    */\r
1545 /*      EPS_ERR_NONE                    - Success                                       */\r
1546 /*      << Error >>                                                                     */\r
1547 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */\r
1548 /*                                                                                      */\r
1549 /* Description:                                                                         */\r
1550 /*      Ends the current print job.                                                     */\r
1551 /*                                                                                      */\r
1552 /*******************************************|********************************************/\r
1553 EPS_ERR_CODE    epsEndJob (\r
1554 \r
1555         void\r
1556 \r
1557 ){\r
1558 /*** Declare Variable Local to Routine                                                  */\r
1559 EPS_ERR_CODE    retStatus;                      /* Return status of internal calls      */\r
1560 EPS_INT32   nRetry = 0;\r
1561 EPS_PRINT_JOB   tempPrintJob;\r
1562 EPS_UINT32    retBufSize = 0;\r
1563 EPS_BOOL    sendEndpage = FALSE;\r
1564 \r
1565 EPS_LOG_FUNCIN;\r
1566 \r
1567 /*** Initialize Local Variables                                                         */\r
1568     retStatus = EPS_ERR_NONE;\r
1569 \r
1570 /*** Has a Job been initialized; indicate start job was called                          */\r
1571     if (printJob.jobStatus == EPS_STATUS_NOT_INITIALIZED) {\r
1572         retStatus = EPS_ERR_JOB_NOT_INITIALIZED;\r
1573         goto JOBEND_END;\r
1574     }\r
1575   \r
1576   if (EPS_CP_PRINTCMD != printJob.attr.colorPlane) {\r
1577   /*** If not invoked epsEndPage, invoke it                                           */\r
1578     if (printJob.pageStatus != EPS_STATUS_NOT_INITIALIZED) {\r
1579       epsEndPage(FALSE);\r
1580     }\r
1581 \r
1582   /*** Send backside page for ESCPR duplex                                            */\r
1583     if(EPS_RESET_NOT_SENT == printJob.resetSent &&\r
1584        EPS_DUPLEX_NONE != printJob.attr.duplex && \r
1585        EPS_LANG_ESCPR == printJob.printer->language && \r
1586        (printJob.pageCount & 0x01) )\r
1587     {\r
1588       memcpy(sendDataBuf, StartPage, sizeof(StartPage));\r
1589       retStatus = SendCommand(sendDataBuf, sizeof(StartPage), &retBufSize, TRUE);\r
1590       for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){\r
1591         if(EPS_ERR_NONE == retStatus || EPS_JOB_CANCELED == retStatus){\r
1592           break;\r
1593         }\r
1594         retStatus = SendLeftovers();\r
1595         if(EPS_ERR_INVALID_CALL == retStatus){\r
1596           retStatus = EPS_ERR_NONE;\r
1597         }\r
1598       }\r
1599 \r
1600       retStatus = SendBlankBand();\r
1601       for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){\r
1602         if(EPS_ERR_NONE == retStatus || EPS_JOB_CANCELED == retStatus){\r
1603           break;\r
1604         }\r
1605         retStatus = SendLeftovers();\r
1606         if(EPS_ERR_INVALID_CALL == retStatus){\r
1607           retStatus = EPS_ERR_NONE;\r
1608         }\r
1609       }\r
1610 \r
1611       sendEndpage = TRUE;\r
1612     }\r
1613 \r
1614   /*** Send EndJob                                                                    */\r
1615     if (printJob.jobStatus == EPS_STATUS_ESTABLISHED &&\r
1616       EPS_PM_JOB != obsGetPageMode() )\r
1617     {\r
1618       if(EPS_LANG_ESCPR == printJob.printer->language ){\r
1619         /*** ESC/P-R ***/\r
1620         retStatus = SendEndJob(sendEndpage);\r
1621       } else{\r
1622         /*** ESC/Page ***/\r
1623 #ifdef GCOMSW_CMD_ESCPAGE\r
1624         retStatus = pageEndJob();\r
1625 #else\r
1626         retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
1627 #endif\r
1628       }\r
1629     }\r
1630 \r
1631     for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){\r
1632       if(EPS_ERR_NONE == retStatus){\r
1633         break;\r
1634       }\r
1635     \r
1636       EPS_DBGPRINT(("retry ENDJOB\n"))\r
1637       retStatus = SendLeftovers();\r
1638       if(EPS_ERR_INVALID_CALL == retStatus){\r
1639         retStatus = EPS_ERR_NONE;\r
1640       }\r
1641     }\r
1642   }\r
1643 \r
1644 /*** protocol depend EndJob                                                             */\r
1645   retStatus = jobFnc.EndJob();\r
1646 \r
1647 JOBEND_END:\r
1648 /*** Clear Memory                                                                       */\r
1649 #ifdef GCOMSW_CMD_ESCPAGE\r
1650   pageRelaseBuffer();\r
1651 #endif\r
1652   EPS_SAFE_RELEASE(sendDataBuf );\r
1653     EPS_SAFE_RELEASE(tmpLineBuf  );\r
1654   sendDataBufSize = 0;\r
1655   tmpLineBufSize = 0;\r
1656 \r
1657 /*** Reset continue buffer                                                              */\r
1658   printJob.contData.sendData = NULL;\r
1659   printJob.contData.sendDataSize = 0;\r
1660 \r
1661 /*** Clear inside additional data buffer                                                */\r
1662   /* DEL EPS_SAFE_RELEASE( printJob.qrcode.bits );*/\r
1663 \r
1664 /*** Clear and Copy Print_Job struct                                                    */\r
1665     memcpy(&tempPrintJob, &printJob, sizeof(EPS_PRINT_JOB));\r
1666     memset(&printJob, 0, sizeof(EPS_PRINT_JOB));\r
1667 \r
1668     printJob.pageStatus       = tempPrintJob.pageStatus;\r
1669   printJob.commMode         = tempPrintJob.commMode;\r
1670   printJob.printer          = tempPrintJob.printer;\r
1671   printJob.platform         = tempPrintJob.platform;\r
1672 \r
1673 #ifdef GCOMSW_EPSON_SLEEP\r
1674     printJob.sleepSteps       = tempPrintJob.sleepSteps;\r
1675 #endif\r
1676     \r
1677 /*** Change the job status                                                              */\r
1678     printJob.jobStatus = EPS_STATUS_NOT_INITIALIZED;\r
1679   printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;\r
1680   printJob.bComm = TRUE;\r
1681   printJob.resetReq = FALSE;\r
1682 \r
1683 #if 0\r
1684   if(EPS_ERR_NOT_CLOSE_IO == retStatus || EPS_ERR_COMM_ERROR == retStatus){\r
1685     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1686   }\r
1687 #else\r
1688     if (EPS_ERR_NONE != retStatus) {\r
1689     EPS_DBGPRINT(("epsEndJob failed (%d)\r\n", retStatus));\r
1690     retStatus = EPS_ERR_NONE;\r
1691   }\r
1692 #endif\r
1693 \r
1694 #ifdef LCOMSW_CMDDMP\r
1695   EPS_DF_CLOSE\r
1696 #endif\r
1697 \r
1698     EPS_RETURN( retStatus );\r
1699 }\r
1700 \r
1701 \r
1702 /*******************************************|********************************************/\r
1703 /*                                                                                      */\r
1704 /* Function name:   epsCancelJob()                                                      */\r
1705 /*                                                                                      */\r
1706 /* Arguments                                                                            */\r
1707 /* ---------                                                                            */\r
1708 /* Name:        Type:               Description:                                        */\r
1709 /* reserve      EPS_BOOL            I:Call epsEndJob()                                  */\r
1710 /*                                                                                      */\r
1711 /* Return value:                                                                        */\r
1712 /*      EPS_ERR_NONE                    - Success                                       */\r
1713 /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */\r
1714 /*      EPS_ERR_CAN_NOT_RESET           - Failed to reset printer                       */\r
1715 /*                                                                                      */\r
1716 /* Description:                                                                         */\r
1717 /*      Reset printer.                                                                  */\r
1718 /*                                                                                      */\r
1719 /*******************************************|********************************************/\r
1720 EPS_ERR_CODE    epsCancelJob (\r
1721 \r
1722         EPS_INT32 reserve\r
1723 \r
1724 ){\r
1725 \r
1726 /*** Declare Variable Local to Routine                                                  */\r
1727 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */\r
1728 EPS_ERR_CODE    retTmp = EPS_ERR_NONE;\r
1729 \r
1730 EPS_LOG_FUNCIN;\r
1731 #if !LCOMSW_CANCEL_JOB\r
1732   (void)reserve;\r
1733 #endif\r
1734 \r
1735 /*** Validate communication mode                                                        */\r
1736   if(NULL == printJob.printer){\r
1737     EPS_RETURN( EPS_ERR_NONE/*EPS_ERR_PRINTER_NOT_SET*/ );\r
1738   }\r
1739 \r
1740   if ( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
1741         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
1742   }\r
1743 \r
1744     if (printJob.jobStatus == EPS_STATUS_ESTABLISHED) {\r
1745     /*** Send the reset command to printer                                          */\r
1746     retStatus = PRT_INVOKE_JOBFNC(jobFnc.ResetPrinter, ());\r
1747     printJob.resetSent = EPS_RESET_SENT;\r
1748     printJob.resetReq = FALSE;\r
1749     if(EPS_ERR_NONE != retStatus){\r
1750       EPS_DBGPRINT(("ResetPrinter() failed (%d)\r\n", retStatus));\r
1751       retStatus = EPS_ERR_CAN_NOT_RESET;\r
1752       /* return retStatus;  Force continue */\r
1753     }\r
1754 \r
1755     /*** Change the page status                                                     */\r
1756     printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;\r
1757   }\r
1758 \r
1759 #if LCOMSW_CANCEL_JOB\r
1760   if(0 == reserve){\r
1761 #endif\r
1762     /*** Invoke  epsEndJob()                                                        */\r
1763     retTmp = epsEndJob();\r
1764     if (retTmp != EPS_ERR_NONE) {\r
1765       EPS_DBGPRINT(("epsEndJob() failed (%d)\r\n", retTmp));\r
1766       /* return retStatus;  Force continue */\r
1767     }\r
1768 #if LCOMSW_CANCEL_JOB\r
1769   }\r
1770 #endif\r
1771 \r
1772     EPS_RETURN( retStatus );\r
1773 }\r
1774 \r
1775 \r
1776 /*******************************************|********************************************/\r
1777 /*                                                                                      */\r
1778 /* Function name:   epsContinueJob()                                                    */\r
1779 /*                                                                                      */\r
1780 /* Arguments                                                                            */\r
1781 /* ---------                                                                            */\r
1782 /* Name:        Type:               Description:                                        */\r
1783 /* N/A          void                N/A                                                 */\r
1784 /*                                                                                      */\r
1785 /* Return value:                                                                        */\r
1786 /*      << Normal >>                                                                    */\r
1787 /*      EPS_ERR_NONE                    - Success                                       */\r
1788 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
1789 /*                                        (Do not return when Uni-Directional)          */\r
1790 /*      << Error >>                                                                     */\r
1791 /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */\r
1792 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */\r
1793 /*      EPS_ERR_PAGE_NOT_INITIALIZED    - PAGR is NOT initialized                       */\r
1794 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
1795 /*                                                                                      */\r
1796 /* Description:                                                                         */\r
1797 /*      Reset printer.                                                                  */\r
1798 /*                                                                                      */\r
1799 /*******************************************|********************************************/\r
1800 EPS_ERR_CODE epsContinueJob (\r
1801                    \r
1802     void\r
1803 \r
1804 ){\r
1805 /*** Declare Variable Local to Routine                                                  */\r
1806   EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls  */\r
1807   EPS_INT32       nCnt = 0;\r
1808 \r
1809   EPS_LOG_FUNCIN;\r
1810 \r
1811 /*** Has a target printer specified                                                     */\r
1812   if(NULL == printJob.printer){\r
1813         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
1814   }\r
1815 /*** Has a Job been initialized                                                         */\r
1816   if (printJob.jobStatus == EPS_STATUS_NOT_INITIALIZED){\r
1817         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );\r
1818   }\r
1819 \r
1820 /*** Validate communication mode                                                        */\r
1821   if( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
1822         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
1823   }\r
1824 \r
1825 /*** Recovery command                                                                   */\r
1826   switch( printJob.contData.lastError ){\r
1827     case EPS_PRNERR_PAPEROUT:\r
1828     case EPS_PRNERR_NOTRAY:\r
1829     /*case EPS_PRNERR_CDDVDCONFIG:*/\r
1830       if( EPS_ERR_PRINTER_ERR_OCCUR == MonitorStatus(NULL)){\r
1831         if( EPS_ERR_NONE != (retStatus = prtRecoverPE()) ){\r
1832           EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
1833         }\r
1834         /*serDelayThread(2*_SECOND_, &epsCmnFnc);*/\r
1835 \r
1836         /* Status change is delayed the condition of LPR ASSIST */\r
1837         if( EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol)\r
1838           && EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
1839           for(nCnt = 0; nCnt < 3; nCnt++){\r
1840             serDelayThread(2*_SECOND_, &epsCmnFnc);\r
1841             if( EPS_ERR_NONE == MonitorStatus(NULL) ){\r
1842               break;\r
1843             }\r
1844             EPS_DBGPRINT(("*** Recover Wait ***\n"))\r
1845           }\r
1846         }\r
1847       }\r
1848       break;\r
1849 \r
1850     case EPS_PRNERR_INTERFACE:\r
1851       /*serDelayThread(5*_SECOND_, &epsCmnFnc);*/\r
1852       break;\r
1853     default:\r
1854       break;\r
1855   }\r
1856 \r
1857 /*** Check printer starus                                                               */\r
1858   retStatus = MonitorStatus(NULL);\r
1859   if(EPS_ERR_NONE != retStatus){\r
1860     EPS_RETURN( retStatus );\r
1861   }\r
1862 \r
1863 /*** Send leftovers data                                                                */\r
1864   switch(printJob.contData.savePoint){\r
1865     case EPS_SAVEP_START_PAGE:\r
1866       retStatus = epsStartPage(NULL);\r
1867       break;\r
1868     case EPS_SAVEP_END_PAGE:\r
1869       retStatus = epsEndPage(printJob.contData.nextPage);\r
1870       break;\r
1871 \r
1872     default:\r
1873       retStatus = SendLeftovers();\r
1874       if(EPS_ERR_INVALID_CALL == retStatus){\r
1875         retStatus = EPS_ERR_NONE;\r
1876       } else if(EPS_ERR_NONE == retStatus){\r
1877         printJob.contData.skipLine = TRUE;\r
1878       } else {\r
1879         EPS_RETURN( retStatus );\r
1880       }\r
1881       break;\r
1882   }\r
1883 \r
1884 /*** Return to Caller                                                                   */\r
1885   if(EPS_ERR_COMM_ERROR == retStatus){\r
1886     printJob.bComm = FALSE;\r
1887     retStatus = EPS_ERR_PRINTER_ERR_OCCUR;\r
1888   }\r
1889 \r
1890   EPS_RETURN( retStatus );\r
1891 }\r
1892 \r
1893 \r
1894 /*******************************************|********************************************/\r
1895 /*                                                                                      */\r
1896 /* Function name:   epsSetAdditionalData()                                              */\r
1897 /*                                                                                      */\r
1898 /* Arguments                                                                            */\r
1899 /* ---------                                                                            */\r
1900 /* Name:        Type:               Description:                                        */\r
1901 /* data         EPS_ADD_DATA*       I: pointer to Additional data                       */\r
1902 /*                                                                                      */\r
1903 /* Return value:                                                                        */\r
1904 /*      << Normal >>                                                                    */\r
1905 /*      EPS_ERR_NONE                    - Success                                       */\r
1906 /*      << Error >>                                                                     */\r
1907 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */\r
1908 /*      EPS_ERR_PAGE_NOT_CLOSED         - PAGR is initialized                           */\r
1909 /*      EPS_ERR_INV_ARG_VALIDMEMBER     - Invalid argument "validMember"                */\r
1910 /*      EPS_ERR_INV_ARG_ADDDATA         - Invalid argument "data"                       */\r
1911 /*      EPS_ERR_INV_ARG_QRSOURCE        - Invalid argument "data.qrcode.source"         */\r
1912 /*      EPS_ERR_INV_ARG_QRXPOS          - Invalid argument "data.qrcode.xPos"           */\r
1913 /*      EPS_ERR_INV_ARG_QRYPOS          - Invalid argument "data.qrcode.position.y"     */\r
1914 /*      EPS_ERR_QRSOURCE_TOO_LAGE       - source is too lage to convert QR code         */\r
1915 /*                                                                                      */\r
1916 /* Description:                                                                         */\r
1917 /*      Set additional data print image.                                                */\r
1918 /*                                                                                      */\r
1919 /*******************************************|********************************************/\r
1920 EPS_ERR_CODE epsSetAdditionalData (\r
1921                    \r
1922     EPS_UINT32  dataType,\r
1923     const void* data\r
1924 \r
1925 ){\r
1926 /*** Declare Variable Local to Routine                                                  */\r
1927   EPS_LOG_FUNCIN;\r
1928    /* This Func is ineffective in the current version. */\r
1929   EPS_RETURN( EPS_ERR_INVALID_CALL );\r
1930 }\r
1931 \r
1932 \r
1933 /*******************************************|********************************************/\r
1934 /*                                                                                      */\r
1935 /* Function name:   epsRemAdditionalData()                                              */\r
1936 /*                                                                                      */\r
1937 /* Arguments                                                                            */\r
1938 /* ---------                                                                            */\r
1939 /* Name:        Type:               Description:                                        */\r
1940 /* member       EPS_UINT32          I: pointer to Additional data                       */\r
1941 /*                                                                                      */\r
1942 /* Return value:                                                                        */\r
1943 /*      << Normal >>                                                                    */\r
1944 /*      EPS_ERR_NONE                    - Success                                       */\r
1945 /*      << Error >>                                                                     */\r
1946 /*      EPS_ERR_INV_ARG_VALIDMEMBER     - Invalid argument "validMember"                */\r
1947 /*                                                                                      */\r
1948 /* Description:                                                                         */\r
1949 /*      Release additional data setting by epsRemAdditionalData().                      */\r
1950 /*                                                                                      */\r
1951 /*******************************************|********************************************/\r
1952 EPS_ERR_CODE epsRemAdditionalData (\r
1953                    \r
1954     EPS_UINT32 dataType\r
1955 \r
1956 ){\r
1957   EPS_LOG_FUNCIN;\r
1958    /* This Func is ineffective in the current version. */\r
1959   EPS_RETURN( EPS_ERR_INVALID_CALL );\r
1960 }\r
1961 \r
1962 \r
1963 /*******************************************|********************************************/\r
1964 /*                                                                                      */\r
1965 /* Function name:   epsGetStatus()                                                      */\r
1966 /*                                                                                      */\r
1967 /* Arguments                                                                            */\r
1968 /* ---------                                                                            */\r
1969 /* Name:        Type:               Description:                                        */\r
1970 /* status       EPS_STATUS*         Pointer to the printer status.                      */\r
1971 /*                                                                                      */\r
1972 /* Return value:                                                                        */\r
1973 /*      << Normal >>                                                                    */\r
1974 /*      EPS_ERR_NONE                    - Success                                       */\r
1975 /*      << Error >>                                                                     */\r
1976 /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */\r
1977 /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */\r
1978 /*      EPS_ERR_INV_ARG_STATUS          - Invalid argument                              */\r
1979 /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */\r
1980 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
1981 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1982 /*                                                                                      */\r
1983 /* Description:                                                                         */\r
1984 /*      Gets the printer status.                                                        */\r
1985 /*                                                                                      */\r
1986 /*******************************************|********************************************/\r
1987 EPS_ERR_CODE    epsGetStatus (\r
1988 \r
1989     EPS_STATUS      *status\r
1990 \r
1991 ){\r
1992 \r
1993 /*** Declare Variable Local to Routine                                                  */\r
1994   EPS_ERR_CODE    ret = EPS_ERR_NONE;         /* Return status of internal calls      */\r
1995   EPS_STATUS_INFO stInfo;\r
1996     EPS_BOOL    bIoStatus = FALSE;\r
1997   EPS_BOOL    bCanceling = FALSE;\r
1998 \r
1999   EPS_LOG_FUNCIN;\r
2000 \r
2001 /*** Validate communication mode                                                        */\r
2002   if( !EPS_IS_BI_PROTOCOL(printJob.commMode) ){\r
2003         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
2004   }\r
2005 \r
2006 /*** Has a target printer specified                                                     */\r
2007   if(NULL == printJob.printer){\r
2008     EPS_RETURN(  EPS_ERR_PRINTER_NOT_SET );\r
2009   }\r
2010 \r
2011 /*** Validate input parameters                                                          */\r
2012   if (status == NULL){\r
2013         EPS_RETURN( EPS_ERR_INV_ARG_STATUS );\r
2014   }\r
2015   \r
2016   memset(status, 0, sizeof(EPS_STATUS));\r
2017 \r
2018 /*** Jpeg size limitation                                                               */\r
2019   if( TRUE == printJob.bJpgLimit ){\r
2020     status->printerStatus = EPS_PRNST_ERROR;\r
2021     status->errorCode = EPS_PRNERR_JPG_LIMIT;\r
2022     status->jobContinue  = FALSE;\r
2023     EPS_RETURN( EPS_ERR_NONE );\r
2024   }\r
2025 \r
2026 /*** Get printer status                                                                 */\r
2027   memset(&stInfo, 0, sizeof(stInfo));\r
2028   if( TRUE == printJob.bComm ){\r
2029     ret = PRT_INVOKE_JOBFNC(jobFnc.GetStatus, \r
2030                 (&stInfo, &bIoStatus, &bCanceling));\r
2031 \r
2032     if(EPS_ERR_COMM_ERROR == ret && \r
2033       EPS_STATUS_NOT_INITIALIZED != printJob.jobStatus){\r
2034       printJob.bComm = FALSE;\r
2035     }\r
2036   } else{\r
2037     ret = EPS_ERR_COMM_ERROR;\r
2038   }\r
2039 \r
2040 //  EPS_DBGPRINT((" State\t: %d\n Error\t: %d\n IoStatus\t: %d\n Canceling\t: %d\n Prepare\t: %d\n", \r
2041 //    stInfo.nState, stInfo.nError, bIoStatus, bCanceling, stInfo.nPrepare))\r
2042 \r
2043   if(EPS_ERR_COMM_ERROR == ret  ||\r
2044     EPS_ERR_NOT_OPEN_IO == ret  ||\r
2045     EPS_ERR_NOT_CLOSE_IO == ret ) {\r
2046     status->printerStatus = EPS_PRNST_ERROR/*EPS_PRNST_OFFLINE*/;\r
2047     status->errorCode = EPS_PRNERR_COMM;\r
2048     status->jobContinue  = FALSE;\r
2049     EPS_RETURN( EPS_ERR_NONE );\r
2050   } else if (EPS_ERR_NONE != ret){\r
2051     EPS_RETURN( ret );\r
2052   }\r
2053 \r
2054    if(stInfo.nCancel == EPS_CAREQ_CANCEL) {\r
2055         EPS_DBGPRINT(("EPS SER : CANCEL REQUEST by PRINTER\r\n"));\r
2056     printJob.resetReq = TRUE;\r
2057     }\r
2058 #if 0\r
2059    if(TRUE == printJob.resetReq){\r
2060     status->printerStatus = EPS_PRNST_ERROR/*EPS_PRNST_OFFLINE*/;\r
2061     status->errorCode = EPS_PRNERR_COMM;\r
2062     status->jobContinue  = FALSE;\r
2063    }\r
2064 #endif\r
2065 \r
2066 /*** Copy status data to input buffer                                                   */\r
2067   status->errorCode= stInfo.nError;\r
2068   printJob.contData.lastError = stInfo.nError;\r
2069   switch(stInfo.nState) {\r
2070       case EPS_ST_ERROR:\r
2071       status->printerStatus = EPS_PRNST_ERROR;\r
2072 \r
2073       switch(stInfo.nError){\r
2074         case EPS_PRNERR_INKOUT:\r
2075           /* Convert Ink error */\r
2076           serGetInkError(&stInfo, &status->errorCode);\r
2077           break;\r
2078 \r
2079         case EPS_PRNERR_INTERFACE:\r
2080         case EPS_PRNERR_BUSY:\r
2081           if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){\r
2082           /* between multi page(job of EPS_PM_JOB), it becomes busy. */\r
2083             status->printerStatus = EPS_PRNST_PRINTING;\r
2084             status->errorCode = EPS_PRNERR_NOERROR;\r
2085           } else{\r
2086             status->printerStatus = EPS_PRNST_BUSY;\r
2087           }\r
2088 \r
2089           break;\r
2090 \r
2091         case EPS_PRNERR_PAPERJAM:\r
2092           printJob.transmittable = FALSE;\r
2093           break;\r
2094 \r
2095         default:\r
2096           break;\r
2097       }\r
2098       break;\r
2099 \r
2100     case EPS_ST_WAITING:\r
2101       status->printerStatus = EPS_PRNST_PRINTING;\r
2102       break;\r
2103 \r
2104     case EPS_ST_IDLE:\r
2105       /* If printer doesn't move, it becomes idle. */\r
2106       if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){\r
2107         status->printerStatus = EPS_PRNST_PRINTING;\r
2108       } else{\r
2109         status->printerStatus = EPS_PRNST_IDLE;\r
2110       }\r
2111       break;\r
2112 \r
2113     case EPS_ST_FACTORY_SHIPMENT:\r
2114       status->printerStatus = EPS_PRNST_ERROR;\r
2115       status->errorCode = EPS_PRNERR_FACTORY; \r
2116       break;\r
2117 \r
2118     case EPS_ST_CLEANING:\r
2119     case EPS_ST_BUSY:\r
2120       if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){\r
2121         /* The cleaning under the print is made "printing". */\r
2122         status->printerStatus = EPS_PRNST_PRINTING;\r
2123         status->errorCode = EPS_PRNERR_NOERROR;\r
2124       } else{\r
2125         status->errorCode = EPS_PRNERR_BUSY;\r
2126         status->printerStatus = EPS_PRNST_BUSY;\r
2127       }\r
2128       break;\r
2129 \r
2130     default: /* The others. */\r
2131       /* EPS_ST_SELF_PRINTING    */\r
2132       /* EPS_ST_SHUTDOWN         */\r
2133           status->errorCode = EPS_PRNERR_BUSY;\r
2134       status->printerStatus = EPS_PRNST_BUSY;\r
2135       break;\r
2136   }\r
2137 \r
2138   if(EPS_PRNERR_NOERROR == status->errorCode){\r
2139     /* If other errors have not occurred */\r
2140     if(EPS_PREPARE_TRAYCLOSED == stInfo.nPrepare\r
2141       && EPS_STATUS_ESTABLISHED == printJob.jobStatus\r
2142       && EPS_STATUS_NOT_INITIALIZED == printJob.pageStatus){\r
2143       /* between epsStartJob to epsStartPage complete */\r
2144       status->errorCode = EPS_PRNERR_TRAYCLOSE;\r
2145       status->printerStatus = EPS_PRNST_ERROR;\r
2146 \r
2147     } else if(EPS_PRNWARN_DISABLE_CLEAN & stInfo.nWarn \r
2148       && EPS_MNT_CLEANING == printJob.attr.cmdType\r
2149       && EPS_STATUS_INITIALIZED == printJob.jobStatus){\r
2150       /* GetStatus failed in epsStartJob()  */\r
2151       status->errorCode = EPS_PRNERR_DISABEL_CLEANING;\r
2152       status->printerStatus = EPS_PRNST_ERROR;\r
2153 \r
2154     } else if( bCanceling ){\r
2155       /* Printing has been canceled by the cancel request which had been triggered \r
2156        * by either the epsonPrintCancelJob/Page() API \r
2157        * or a user operation on the printer panel. */\r
2158       status->printerStatus = EPS_PRNST_CANCELLING;\r
2159       if(EPS_PRNERR_NOERROR == status->errorCode){\r
2160         status->errorCode = EPS_PRNERR_BUSY;\r
2161       }\r
2162     } else if( !bIoStatus ) {\r
2163       /* ESC/P-R Library had sent all that is needed to print \r
2164        * to the printer but the printer has not been completed printing yet. */\r
2165       status->printerStatus = EPS_PRNST_BUSY;\r
2166       if(EPS_PRNERR_NOERROR == status->errorCode){\r
2167         status->errorCode = EPS_PRNERR_BUSY;\r
2168       }\r
2169     } \r
2170     /* ignore color-ink-end warning \r
2171     else if( EPS_PRNWARN_COLOR_INKOUT & stInfo.nWarn\r
2172       && EPS_STATUS_ESTABLISHED != printJob.jobStatus ){\r
2173        color ink out is error, when besides job. \r
2174       status->errorCode = EPS_PRNERR_INKOUT;\r
2175       status->printerStatus = EPS_PRNST_ERROR;\r
2176     }*/\r
2177   }\r
2178 \r
2179 /*** Set continue flag                                                              */\r
2180   status->jobContinue = TRUE;\r
2181   if( EPS_STATUS_ESTABLISHED != printJob.jobStatus ){\r
2182         status->jobContinue = FALSE;\r
2183   } else{\r
2184     switch(status->errorCode){\r
2185     /* The error that it can not continue the printing job */\r
2186     case EPS_PRNERR_GENERAL:\r
2187     case EPS_PRNERR_FATAL:\r
2188     case EPS_PRNERR_PAPERJAM:\r
2189     /*case EPS_PRNERR_SIZE_TYPE_PATH:*/\r
2190     case EPS_PRNERR_SERVICEREQ:\r
2191     case EPS_PRNERR_CARDLOADING:\r
2192     case EPS_PRNERR_BATTERYVOLTAGE:\r
2193     case EPS_PRNERR_BATTERYTEMPERATURE:\r
2194     case EPS_PRNERR_BATTERYEMPTY:\r
2195         case EPS_PRNERR_COMM:\r
2196       status->jobContinue = FALSE;\r
2197       break;\r
2198 \r
2199     case EPS_PRNERR_BUSY:\r
2200       if(EPS_PRNST_CANCELLING == status->printerStatus){\r
2201       /* When last time page printing.\r
2202          It's state EPS_PRNST_CANCELLING & EPS_PRNERR_BUSY.*/\r
2203         status->jobContinue = TRUE;\r
2204       } else{\r
2205         status->jobContinue = FALSE;\r
2206       }\r
2207       break;\r
2208     }\r
2209   }\r
2210 \r
2211 /*** Return to Caller                                                                   */\r
2212     EPS_RETURN( ret );\r
2213 }\r
2214 \r
2215 \r
2216 /*******************************************|********************************************/\r
2217 /*                                                                                      */\r
2218 /* Function name:   epsGetInkInfo()                                                     */\r
2219 /*                                                                                      */\r
2220 /* Arguments                                                                            */\r
2221 /* ---------                                                                            */\r
2222 /* Name:        Type:               Description:                                        */\r
2223 /* status       EPS_STATUS*         Pointer to the printer status.                      */\r
2224 /*                                                                                      */\r
2225 /* Return value:                                                                        */\r
2226 /*      << Normal >>                                                                    */\r
2227 /*      EPS_ERR_NONE                    - Success                                       */\r
2228 /*      << Error >>                                                                     */\r
2229 /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */\r
2230 /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */\r
2231 /*      EPS_ERR_INV_ARG_INKINFO         - Invalid argument                              */\r
2232 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
2233 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
2234 /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */\r
2235 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
2236 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2237 /*                                                                                      */\r
2238 /* Description:                                                                         */\r
2239 /*      Gets the Ink Infomation.                                                        */\r
2240 /*                                                                                      */\r
2241 /*******************************************|********************************************/\r
2242 EPS_ERR_CODE    epsGetInkInfo (\r
2243 \r
2244     EPS_INK_INFO      *info\r
2245 \r
2246 ){\r
2247 /*** Declare Variable Local to Routine                                                  */\r
2248   EPS_ERR_CODE    ret = EPS_ERR_NONE;         /* Return status of internal calls      */\r
2249 \r
2250   EPS_LOG_FUNCIN;\r
2251 \r
2252 /*** Has a target printer specified                                                     */\r
2253   if(NULL == printJob.printer){\r
2254     EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );\r
2255   }\r
2256 \r
2257 /*** Validate input parameters                                                          */\r
2258   if (info == NULL){\r
2259         EPS_RETURN( EPS_ERR_INV_ARG_INKINFO );\r
2260   }\r
2261 \r
2262   memset(info, 0, sizeof(EPS_INK_INFO));\r
2263 \r
2264 /*** protocol GetStatus                                                                 */\r
2265   ret = prtGetInkInfo(printJob.printer, info);\r
2266 \r
2267 /*** Return to Caller                                                                   */\r
2268 \r
2269   EPS_RETURN( ret );\r
2270 }\r
2271 \r
2272 \r
2273 /*******************************************|********************************************/\r
2274 /*                                                                                      */\r
2275 /* Function name:   epsGetSupportedMedia()                                              */\r
2276 /*                                                                                      */\r
2277 /* Arguments                                                                            */\r
2278 /* ---------                                                                            */\r
2279 /* Name:            Type:                   Description:                                */\r
2280 /* supportedMedia   EPS_SUPPORTED_MEDIA*    Pointer to Supported Media Structure        */\r
2281 /*                                                                                      */\r
2282 /* Return value:                                                                        */\r
2283 /*      << Normal >>                                                                    */\r
2284 /*      EPS_ERR_NONE                    - Success                                       */\r
2285 /*      << Error >>                                                                     */\r
2286 /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */\r
2287 /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */\r
2288 /*      EPS_ERR_INV_ARG_SUPPORTED_MEDIA - Invalid argument                              */\r
2289 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
2290 /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */\r
2291 /*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */\r
2292 /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */\r
2293 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
2294 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2295 /*                                                                                      */\r
2296 /* Description:                                                                         */\r
2297 /*      Get supported media information from printer and save those data in             */\r
2298 /*      "g_supportedMedia" structure.                                                   */\r
2299 /*                                                                                      */\r
2300 /*******************************************|********************************************/\r
2301 EPS_ERR_CODE     epsGetSupportedMedia (\r
2302 \r
2303         EPS_SUPPORTED_MEDIA*    supportedMedia\r
2304 \r
2305 ){\r
2306 \r
2307 /*** Declare Variable Local to Routine                                                  */\r
2308     EPS_ERR_CODE    retStatus, retGetPM;        /* Return status of internal calls      */\r
2309     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */\r
2310     EPS_INT32       pmSize = EPS_PM_MAXSIZE;\r
2311 \r
2312   EPS_PRINTER_INN* innerPrinter = NULL;\r
2313 \r
2314   EPS_LOG_FUNCIN;\r
2315 \r
2316 /*** Initialize Local Variables                                                         */\r
2317     retStatus = retGetPM = EPS_ERR_NONE;\r
2318 \r
2319 /*** Validate communication mode                                                        */\r
2320   if( !EPS_IS_BI_PROTOCOL(printJob.commMode) ){\r
2321         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
2322   }\r
2323 \r
2324 /*** Has a target printer specified                                                     */\r
2325   if(NULL == printJob.printer){\r
2326     EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );\r
2327   }\r
2328   innerPrinter = printJob.printer;\r
2329 \r
2330   if( !EPS_IS_BI_PROTOCOL(innerPrinter->protocol) ){\r
2331         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );\r
2332   }\r
2333 \r
2334 /*** Validate input parameters                                                          */\r
2335   if (supportedMedia == NULL){\r
2336     EPS_RETURN( EPS_ERR_INV_ARG_SUPPORTED_MEDIA );\r
2337     }\r
2338 \r
2339 #if !_VALIDATE_SUPPORTED_MEDIA_DATA_\r
2340 /*** If already exist, return current value                                             */\r
2341   if(innerPrinter->supportedMedia.numSizes > 0 \r
2342     && NULL != innerPrinter->supportedMedia.sizeList){\r
2343     EPS_RETURN( DuplSupportedMedia(innerPrinter, supportedMedia) );\r
2344   }\r
2345 #endif\r
2346 \r
2347   /* Clear the prev value                                                             */\r
2348   prtClearSupportedMedia(innerPrinter);\r
2349 \r
2350   /* Clear the Printer Model Information (Media data or "PM" data)                    */\r
2351   memset(pmString,0,EPS_PM_MAXSIZE);\r
2352 \r
2353   /*** Get PM from Printer                                                            */\r
2354   retStatus = prtGetPMString(innerPrinter, 1, pmString, &pmSize);\r
2355 \r
2356   /*** ESC/Page divergence ***/\r
2357   if(EPS_LANG_ESCPR != innerPrinter->language ){\r
2358 #ifdef GCOMSW_CMD_ESCPAGE\r
2359     if( EPS_ERR_NONE == retStatus ) {\r
2360       /*** Create Media Infomation                                                */\r
2361       retStatus = pageCreateMediaInfo(innerPrinter, pmString, pmSize);\r
2362     }\r
2363 #else\r
2364     retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
2365 #endif\r
2366 \r
2367   } else {\r
2368     if ( EPS_ERR_NONE == retStatus ){\r
2369       /*** Create Media Infomation                                                */\r
2370       retStatus = CreateMediaInfo(innerPrinter, pmString, pmSize);\r
2371     }\r
2372   }\r
2373 \r
2374 /*** Copy the supproted media information from "printer" structure to input buffer      */\r
2375   if ( EPS_ERR_NONE == retStatus ){\r
2376     /* Copy to input buffer                                                         */\r
2377     retStatus = DuplSupportedMedia(innerPrinter, supportedMedia);\r
2378   }\r
2379 /*** Return to Caller                                                                   */\r
2380     EPS_RETURN( retStatus );\r
2381 }\r
2382 \r
2383 \r
2384 /*******************************************|********************************************/\r
2385 /*                                                                                      */\r
2386 /* Function name:   epsGetPrintableArea()                                               */\r
2387 /*                                                                                      */\r
2388 /* Arguments                                                                            */\r
2389 /* ---------                                                                            */\r
2390 /* Name:            Type:                   Description:                                */\r
2391 /* jobAttr          const EPS_JOB_ATTRIB*   I: Print Job Attribute                      */\r
2392 /* printableWidth   EPS_INT32*              O: Printable area width.                    */\r
2393 /* printableHeight  EPS_INT32*              O: Printable area height.                   */\r
2394 /*                                                                                      */\r
2395 /* Return value:                                                                        */\r
2396 /*      << Normal >>                                                                    */\r
2397 /*      EPS_ERR_NONE                            - Success                               */\r
2398 /*      << Error >>                                                                     */\r
2399 /*      EPS_ERR_LIB_NOT_INITIALIZED             - ESC/P-R Lib is NOT initialized        */\r
2400 /*      EPS_ERR_INV_ARG_JBO_ATTRIB              - Invalid argument "jobAttr"            */\r
2401 /*      EPS_ERR_INV_ARG_PRINTABLE_WIDTH         - Invalid argument "printableWidth"     */\r
2402 /*      EPS_ERR_INV_ARG_PRINTABLE_HEIGHT        - Invalid argument "printableHeight"    */\r
2403 /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */\r
2404 /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */\r
2405 /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */\r
2406 /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */\r
2407 /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */\r
2408 /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */\r
2409 /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */\r
2410 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */\r
2411 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */\r
2412 /*      EPS_ERR_OPR_FAIL                        - Internal Error                        */\r
2413 /*                                                                                      */\r
2414 /* Description:                                                                         */\r
2415 /*      Gets the printable area of the image.                                           */\r
2416 /*                                                                                      */\r
2417 /*******************************************|********************************************/\r
2418 EPS_ERR_CODE    epsGetPrintableArea (\r
2419 \r
2420         EPS_JOB_ATTRIB*     jobAttr,\r
2421         EPS_UINT32*         printableWidth,\r
2422         EPS_UINT32*         printableHeight\r
2423 \r
2424 ){\r
2425 \r
2426 /*** Declare Variable Local to Routine                                                  */\r
2427 EPS_INT32       idx;                                /* General loop/index varaible      */\r
2428 EPS_ERR_CODE    retStatus;                          /* Return status of internal calls  */\r
2429 EPS_INT32       factor;                             /* Scaling factor for dpi           */\r
2430 EPS_INT32       tempPrintableWidth;\r
2431 EPS_INT32       tempPrintableHeight;\r
2432 const EPS_MEDIA_INFO* pMI = NULL;\r
2433 EPS_INT16   minCustomBorder;\r
2434 \r
2435 EPS_LOG_FUNCIN;\r
2436 \r
2437 /*** Has a Lib been initialized                                                         */\r
2438     if (libStatus != EPS_STATUS_INITIALIZED) {\r
2439         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );\r
2440   }\r
2441   if(NULL == printJob.printer){\r
2442     EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );\r
2443   }\r
2444 \r
2445 /*** Validate input parameters                                                          */\r
2446     if (jobAttr == NULL)\r
2447         EPS_RETURN( EPS_ERR_INV_ARG_JOB_ATTRIB );\r
2448     \r
2449     if (printableWidth == NULL)\r
2450         EPS_RETURN( EPS_ERR_INV_ARG_PRINTABLE_WIDTH );\r
2451         \r
2452     if (printableHeight == NULL)\r
2453         EPS_RETURN( EPS_ERR_INV_ARG_PRINTABLE_HEIGHT );\r
2454 \r
2455   /*** ESC/Page divergence ***/\r
2456   if( EPS_LANG_ESCPR != printJob.printer->language ){\r
2457 #ifdef GCOMSW_CMD_ESCPAGE\r
2458     retStatus = pageGetPrintableArea(jobAttr, printableWidth, printableHeight);\r
2459 #else\r
2460     retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;\r
2461 #endif\r
2462     EPS_RETURN( retStatus );\r
2463   }\r
2464 \r
2465 /*** Initialize Local Variables                                                         */\r
2466     retStatus = EPS_ERR_NONE;\r
2467 \r
2468 /*** Validate/Confirm Page Attribute Data                                               */\r
2469     /*** Media Size                                                                     */\r
2470     if (! ( ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A4              ) &&\r
2471               (jobAttr->mediaSizeIdx       <= EPS_MSID_HIVISION        )    ) ||\r
2472             ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A3NOBI          ) &&\r
2473               (jobAttr->mediaSizeIdx       <= EPS_MSID_12X12           )    ) ||\r
2474             ( (jobAttr->mediaSizeIdx       == EPS_MSID_USER            )    )    ) )\r
2475         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );\r
2476 \r
2477 #if 0   /* These parameter are not used in this function */\r
2478   /*** Media Type                                                                     */\r
2479     if (! ( ( (jobAttr->mediaTypeIdx       >= EPS_MTID_PLAIN           ) &&\r
2480 /*              (jobAttr->mediaTypeIdx       <= EPS_MTID_GLOSSYHAGAKI    )    ) ||*/\r
2481               (jobAttr->mediaTypeIdx       <= EPS_MTID_BUSINESSCOAT    )    ) ||\r
2482             ( (jobAttr->mediaTypeIdx       >= EPS_MTID_CDDVD           ) &&\r
2483               (jobAttr->mediaTypeIdx       <= EPS_MTID_CDDVDGLOSSY     )    ) ||\r
2484             ( (jobAttr->mediaTypeIdx       == EPS_MTID_CLEANING        )    )    ) )\r
2485         EPS_RETURN( EPS_ERR_INV_MEDIA_TYPE );\r
2486 #endif\r
2487 \r
2488     /*** Border Mode                                                                    */\r
2489     if (! (   (jobAttr->printLayout        == EPS_MLID_BORDERLESS      ) ||\r
2490               (jobAttr->printLayout        == EPS_MLID_BORDERS         ) ||\r
2491               (jobAttr->printLayout        == EPS_MLID_CDLABEL         ) ||\r
2492               (jobAttr->printLayout        == EPS_MLID_DIVIDE16        ) ||\r
2493               (jobAttr->printLayout        == EPS_MLID_CUSTOM          )    ) )\r
2494         EPS_RETURN( EPS_ERR_INV_BORDER_MODE );\r
2495 \r
2496 #if 0   /* These parameter are not used in this function */\r
2497     /*** Print Quality                                                                  */\r
2498     if (! (   (jobAttr->printQuality       == EPS_MQID_DRAFT           ) ||\r
2499               (jobAttr->printQuality       == EPS_MQID_NORMAL          ) ||\r
2500               (jobAttr->printQuality       == EPS_MQID_HIGH            )    ) )\r
2501         EPS_RETURN( EPS_ERR_INV_PRINT_QUALITY );\r
2502 \r
2503     /*** Color Mode                                                                     */\r
2504     if (! (   (jobAttr->colorMode          == EPS_CM_COLOR             ) ||\r
2505               (jobAttr->colorMode          == EPS_CM_MONOCHROME        )    ) )\r
2506         EPS_RETURN( EPS_ERR_INV_COLOR_MODE );\r
2507 #endif\r
2508 \r
2509     /*** Input Image Resolution                                                         */\r
2510     /*** Select table and factor                                                        */\r
2511   if(jobAttr->inputResolution == EPS_IR_360X360){\r
2512     pMI = epsMediaSize;\r
2513       factor = 1;\r
2514     minCustomBorder = EPS_BORDERS_MARGIN_360;\r
2515   } else if(jobAttr->inputResolution == EPS_IR_720X720){\r
2516     pMI = epsMediaSize;\r
2517     factor = 2;\r
2518     minCustomBorder = EPS_BORDERS_MARGIN_360;\r
2519   } else if(jobAttr->inputResolution == EPS_IR_300X300){\r
2520     pMI = epsMediaSize300;\r
2521       factor = 1;\r
2522     minCustomBorder = EPS_BORDERS_MARGIN_300;\r
2523   } else if(jobAttr->inputResolution == EPS_IR_1200X1200){\r
2524     pMI = epsMediaSize300;\r
2525       factor = 4;\r
2526     minCustomBorder = EPS_BORDERS_MARGIN_300;\r
2527   } else if(jobAttr->inputResolution == EPS_IR_600X600){\r
2528     pMI = epsMediaSize300;\r
2529       factor = 2;\r
2530     minCustomBorder = EPS_BORDERS_MARGIN_300;\r
2531   } else{\r
2532         EPS_RETURN( EPS_ERR_INV_INPUT_RESOLUTION )\r
2533   }\r
2534 \r
2535 #if 0   /* These parameter are not used in this function */\r
2536     /*** Printing Direction                                                             */\r
2537     if (! (   (jobAttr->printDirection     == EPS_PD_BIDIREC           ) ||\r
2538               (jobAttr->printDirection     == EPS_PD_UNIDIREC          )    ) )\r
2539         EPS_RETURN( EPS_ERR_INV_PRINT_DIRECTION );\r
2540 \r
2541     /*** Color Plane                                                                    */\r
2542     if (! (   (jobAttr->colorPlane         == EPS_CP_FULLCOLOR         ) ||\r
2543               (jobAttr->colorPlane         == EPS_CP_256COLOR          )    ) )\r
2544         EPS_RETURN( EPS_ERR_INV_COLOR_PLANE );\r
2545 \r
2546     /*** Pallette Data                                                                  */\r
2547     if (jobAttr->colorPlane == EPS_CP_256COLOR) {\r
2548         if (! ((jobAttr->paletteSize       >= 3                        ) &&\r
2549                (jobAttr->paletteSize       <= 768/*765*/               )    ) )\r
2550             EPS_RETURN( EPS_ERR_INV_PALETTE_SIZE );\r
2551         if (    jobAttr->paletteData       == NULL                     )\r
2552             EPS_RETURN( EPS_ERR_INV_PALETTE_DATA );\r
2553     }\r
2554 \r
2555     /*** Brightness                                                                     */\r
2556     if (! (   (jobAttr->brightness         >= -50                      ) &&\r
2557               (jobAttr->brightness         <=  50                      )    ) )\r
2558         EPS_RETURN( EPS_ERR_INV_BRIGHTNESS );\r
2559 \r
2560     /*** Contrast                                                                       */\r
2561     if (! (   (jobAttr->contrast           >= -50                      ) &&\r
2562               (jobAttr->contrast           <=  50                      )    ) )\r
2563         EPS_RETURN( EPS_ERR_INV_CONTRAST );\r
2564 \r
2565     /*** Saturation                                                                     */\r
2566     if (! (   (jobAttr->saturation         >= -50                      ) &&\r
2567               (jobAttr->saturation         <=  50                      )    ) )\r
2568         EPS_RETURN( EPS_ERR_INV_SATURATION );\r
2569 #endif\r
2570 \r
2571     /*** Margin                                                                         */\r
2572     if (jobAttr->printLayout == EPS_MLID_CUSTOM) {\r
2573         if (jobAttr->topMargin    < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_TOP_MARGIN );\r
2574         if (jobAttr->leftMargin   < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_LEFT_MARGIN );\r
2575         if (jobAttr->bottomMargin < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_BOTTOM_MARGIN );\r
2576         if (jobAttr->rightMargin  < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_RIGHT_MARGIN );\r
2577     }\r
2578 \r
2579 #if 0   /* Don't need this logic */\r
2580     /*** If full-color mode, nullify the 256-color parameters                           */\r
2581     printJob.bpp = 1;\r
2582     if (jobAttr->colorPlane == EPS_CP_FULLCOLOR) {\r
2583         jobAttr->paletteSize = 0;\r
2584         jobAttr->paletteData = NULL;\r
2585         printJob.bpp          = 3;\r
2586     }\r
2587 #endif\r
2588 \r
2589 /*** Get Printable Area                                                                 */\r
2590     /*** Find the Media by ID                                                           */\r
2591     for (idx = 0; pMI[idx].id != -1; idx++) {\r
2592         if (pMI[idx].id == jobAttr->mediaSizeIdx)\r
2593             break;\r
2594     }\r
2595     if (pMI[idx].id == -1) {\r
2596         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );\r
2597     }\r
2598 \r
2599     /*** Initialize Printable based on printLayout                                      */\r
2600     switch( jobAttr->printLayout ){\r
2601   case EPS_MLID_BORDERLESS:\r
2602         tempPrintableWidth  = pMI[idx].print_area_x_borderless * factor;\r
2603         tempPrintableHeight = pMI[idx].print_area_y_borderless * factor;\r
2604     break;\r
2605 \r
2606   case EPS_MLID_BORDERS:\r
2607   case EPS_MLID_DIVIDE16: /* layout processing is not done. */\r
2608         tempPrintableWidth  = pMI[idx].print_area_x_border * factor;\r
2609         tempPrintableHeight = pMI[idx].print_area_y_border * factor;\r
2610     break;\r
2611 \r
2612   case EPS_MLID_CDLABEL:\r
2613     if( !( (jobAttr->cdDimOut >= EPS_CDDIM_IN_MIN   )\r
2614       && (jobAttr->cdDimOut <= EPS_CDDIM_OUT_MAX ) ) ){\r
2615       EPS_RETURN( EPS_ERR_INV_CD_OUTDIM );\r
2616     }\r
2617 \r
2618     tempPrintableWidth  =\r
2619       tempPrintableHeight = elGetDots(jobAttr->inputResolution, jobAttr->cdDimOut);\r
2620     break;\r
2621 \r
2622   default: /* printLayout  == EPS_MLID_CUSTOM */\r
2623         tempPrintableWidth  = pMI[idx].paper_x *factor -\r
2624                               jobAttr->leftMargin      -\r
2625                               jobAttr->rightMargin;\r
2626         tempPrintableHeight = pMI[idx].paper_y *factor -\r
2627                               jobAttr->topMargin       -\r
2628                               jobAttr->bottomMargin;\r
2629     }\r
2630 \r
2631 /*** Validate/Confirm Magin Setting                                                     */\r
2632     if (jobAttr->printLayout == EPS_MLID_CUSTOM) {\r
2633         if (tempPrintableWidth  <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH );\r
2634         if (tempPrintableHeight <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT );\r
2635     }\r
2636 \r
2637 /*** Set Printable Area to input parameter                                              */\r
2638     if ((tempPrintableWidth > 0) && (tempPrintableHeight > 0)) {\r
2639         *printableWidth  = (EPS_UINT32)tempPrintableWidth;\r
2640         *printableHeight = (EPS_UINT32)tempPrintableHeight;\r
2641     } else{\r
2642         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
2643     }\r
2644     \r
2645 /*** Return to Caller                                                                   */\r
2646     EPS_RETURN( EPS_ERR_NONE );\r
2647 }\r
2648 \r
2649 \r
2650 /*******************************************|********************************************/\r
2651 /*                                                                                      */\r
2652 /* Function name:   epsMakeMainteCmd()                                                  */\r
2653 /*                                                                                      */\r
2654 /* Arguments                                                                            */\r
2655 /* ---------                                                                            */\r
2656 /* Name:        Type:               Description:                                        */\r
2657 /* cmd          EPS_INT32           I:maintenance command type.                         */\r
2658 /* buffer       EPS_UINT8*          I:pointer to command buffer.                        */\r
2659 /* buffersize   EPS_UINT32*         I: buffer size.                                     */\r
2660 /*                                  O: need size.                                       */\r
2661 /*                                                                                      */\r
2662 /* Return value:                                                                        */\r
2663 /*      << Normal >>                                                                    */\r
2664 /*      EPS_ERR_NONE                    - Success                                       */\r
2665 /*      << Error >>                                                                     */\r
2666 /*      EPS_ERR_LIB_NOT_INITIALIZED   - ESC/P-R Lib is NOT initialized        */\r
2667 /*      EPS_ERR_INV_ARG_CMDTYPE     - Invalid argument "cmd"            */\r
2668 /*      EPS_ERR_OPR_FAIL        - Internal Error                */\r
2669 /*      EPS_ERR_MEMORY_ALLOCATION   - Failed to allocate memory           */\r
2670 /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */\r
2671 /*      EPS_ERR_LANGUAGE_NOT_SUPPORTED  - Unsupported function Error (language)         */\r
2672 /*                                                                                      */\r
2673 /* Description:                                                                         */\r
2674 /*      Make maintenance command.                                                       */\r
2675 /*      Call this function as specifying NULL to buffer, so that the memory size        */\r
2676 /*      necessary for executing the maintenance command is returned to buffersize.      */\r
2677 /*                                                                                      */\r
2678 /*******************************************|********************************************/\r
2679 EPS_ERR_CODE epsMakeMainteCmd     (\r
2680 \r
2681     EPS_INT32   cmd,\r
2682     EPS_UINT8*    buffer,\r
2683     EPS_UINT32*   buffersize\r
2684 \r
2685 ){\r
2686 #ifdef GCOMSW_EF_MAINTE\r
2687 /*** Declare Variable Local to Routine                                                  */\r
2688   EPS_ERR_CODE retStatus = EPS_ERR_NONE;      /* Return status of internal calls      */\r
2689   EPS_UINT8 *pCmdBuf = NULL;\r
2690   EPS_UINT8 *pCmdPos = NULL;\r
2691   EPS_UINT32 cmdSize = 0;\r
2692   EPS_UINT32 cmdBufSize = 0;\r
2693 \r
2694   EPS_LOG_FUNCIN;\r
2695 \r
2696 /*** Has a target printer specified                                                     */\r
2697   if(NULL == printJob.printer){\r
2698     EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );\r
2699   }\r
2700 \r
2701   if(EPS_LANG_ESCPR != printJob.printer->language ){\r
2702     EPS_RETURN( EPS_ERR_LANGUAGE_NOT_SUPPORTED );\r
2703   }\r
2704 \r
2705 \r
2706   if(buffer){\r
2707     cmdBufSize = 256;\r
2708     pCmdBuf = (EPS_UINT8*)EPS_ALLOC(cmdBufSize);\r
2709     pCmdPos = pCmdBuf;\r
2710   }\r
2711 \r
2712 #define MakeMainteCmd_ADDCMD(CMD) {                           \\r
2713     if(buffer){                                   \\r
2714       retStatus = AddCmdBuff(&pCmdBuf, &pCmdPos, &cmdBufSize, CMD, sizeof(CMD));  \\r
2715       if(EPS_ERR_NONE != retStatus){                        \\r
2716         goto epsMakeMainteCmd_END;                        \\r
2717       }                                     \\r
2718     }                                       \\r
2719     cmdSize += sizeof(CMD);                             \\r
2720   }\r
2721 \r
2722   switch(cmd){\r
2723   case EPS_MNT_NOZZLE:        /* nozzle check */\r
2724     MakeMainteCmd_ADDCMD(ExitPacketMode)\r
2725     MakeMainteCmd_ADDCMD(InitPrinter)\r
2726     MakeMainteCmd_ADDCMD(InitPrinter)\r
2727 \r
2728     MakeMainteCmd_ADDCMD(EnterRemoteMode)\r
2729     if(epsCmnFnc.getLocalTime){\r
2730       MakeMainteCmd_ADDCMD(RemoteTI)\r
2731       if( buffer ){\r
2732         MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));\r
2733       }\r
2734     }\r
2735     MakeMainteCmd_ADDCMD(RemoteJS)\r
2736     MakeMainteCmd_ADDCMD(RemoteNC)\r
2737     if(pCmdPos && obsIsA3Model(EPS_MDC_NOZZLE)){\r
2738       *(pCmdPos - sizeof(RemoteNC) + 5) = 0x10;\r
2739     }\r
2740     MakeMainteCmd_ADDCMD(ExitRemoteMode)\r
2741 \r
2742     MakeMainteCmd_ADDCMD(DataCR)\r
2743     MakeMainteCmd_ADDCMD(DataLF)\r
2744     MakeMainteCmd_ADDCMD(DataCR)\r
2745     MakeMainteCmd_ADDCMD(DataLF)\r
2746     \r
2747     MakeMainteCmd_ADDCMD(EnterRemoteMode)\r
2748     MakeMainteCmd_ADDCMD(RemoteVI)\r
2749     MakeMainteCmd_ADDCMD(RemoteLD)\r
2750     MakeMainteCmd_ADDCMD(ExitRemoteMode)\r
2751 \r
2752     MakeMainteCmd_ADDCMD(DataFF)\r
2753     MakeMainteCmd_ADDCMD(InitPrinter)\r
2754     MakeMainteCmd_ADDCMD(InitPrinter)\r
2755     \r
2756     MakeMainteCmd_ADDCMD(EnterRemoteMode)\r
2757     MakeMainteCmd_ADDCMD(RemoteJE)\r
2758     MakeMainteCmd_ADDCMD(ExitRemoteMode)\r
2759     break;\r
2760 \r
2761   case EPS_MNT_CLEANING:          /* head cleaning */\r
2762     MakeMainteCmd_ADDCMD(ExitPacketMode)\r
2763     MakeMainteCmd_ADDCMD(InitPrinter)\r
2764     MakeMainteCmd_ADDCMD(InitPrinter)\r
2765 \r
2766     MakeMainteCmd_ADDCMD(EnterRemoteMode)\r
2767     if(epsCmnFnc.getLocalTime){\r
2768       MakeMainteCmd_ADDCMD(RemoteTI)\r
2769       if( buffer ){\r
2770         MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));\r
2771       }\r
2772     }\r
2773     MakeMainteCmd_ADDCMD(RemoteCH)\r
2774     MakeMainteCmd_ADDCMD(ExitRemoteMode)\r
2775 \r
2776     MakeMainteCmd_ADDCMD(InitPrinter)\r
2777     MakeMainteCmd_ADDCMD(InitPrinter)\r
2778     \r
2779     MakeMainteCmd_ADDCMD(EnterRemoteMode)\r
2780     MakeMainteCmd_ADDCMD(RemoteJE)\r
2781     MakeMainteCmd_ADDCMD(ExitRemoteMode)\r
2782     break;\r
2783 \r
2784   default:\r
2785     retStatus = EPS_ERR_INV_CMDTYPE;\r
2786     break;\r
2787   }\r
2788 \r
2789 epsMakeMainteCmd_END:\r
2790   if(EPS_ERR_NONE == retStatus){\r
2791     if( buffer ){\r
2792       if(*buffersize > 0){\r
2793         memcpy(buffer, pCmdBuf, Min(*buffersize, cmdSize));\r
2794       }\r
2795     } \r
2796     *buffersize = cmdSize;\r
2797   }\r
2798   EPS_SAFE_RELEASE(pCmdBuf);\r
2799 \r
2800   EPS_RETURN( retStatus );\r
2801 #else\r
2802   return EPS_ERR_INVALID_CALL;\r
2803 #endif\r
2804 }\r
2805 \r
2806 \r
2807 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2808 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2809 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2810 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
2811 /*--------------------             Internal Processing             ---------------------*/\r
2812 /*--------------------                     for                     ---------------------*/\r
2813 /*--------------------                     API                     ---------------------*/\r
2814 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
2815 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2816 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2817 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2818 \r
2819 /*******************************************|********************************************/\r
2820 /*                                                                                      */\r
2821 /* Function name:   MonitorStatus()                                                     */\r
2822 /*                                                                                      */\r
2823 /* Arguments                                                                            */\r
2824 /* ---------                                                                            */\r
2825 /* Name:        Type:               Description:                                        */\r
2826 /* pStInfo      EPS_STATUS_INFO     I: pointer to status info strucutre                 */\r
2827 /*                                                                                      */\r
2828 /* Return value:                                                                        */\r
2829 /*      EPS_ERR_NONE            - Printer settled into one of the requested state(s)    */\r
2830 /*      EPS_JOB_CANCELED        - Cancelled operation                                   */\r
2831 /*      EPS_ERR_OPR_FAIL        - Internal Error                                        */\r
2832 /*      EPS_ERR_PRINTER_ERR_OCCUR  - Printer Error happened                             */\r
2833 /*                                                                                      */\r
2834 /* Description:                                                                         */\r
2835 /*      Monitor the status of the printer.                                              */\r
2836 /*                                                                                      */\r
2837 /*******************************************|********************************************/\r
2838 static EPS_ERR_CODE   MonitorStatus (\r
2839 \r
2840         EPS_STATUS_INFO *pStInfo\r
2841 \r
2842 ){\r
2843 /*** Declare Variable Local to Routine                                                  */\r
2844     EPS_INT32       retStatus;\r
2845     EPS_STATUS_INFO StatInfo;\r
2846 \r
2847   EPS_LOG_FUNCIN;\r
2848 \r
2849 /*** Initialize Local Variables                                                         */\r
2850     retStatus = EPS_ERR_NONE;\r
2851     memset(&StatInfo, -1, sizeof(EPS_STATUS_INFO));\r
2852 \r
2853   retStatus = jobFnc.MonitorStatus(&StatInfo);\r
2854     if ( retStatus != EPS_ERR_NONE) {\r
2855     if(EPS_ERR_COMM_ERROR == retStatus && \r
2856       EPS_STATUS_NOT_INITIALIZED != printJob.jobStatus){\r
2857       printJob.bComm = FALSE;\r
2858     }\r
2859 \r
2860     EPS_DBGPRINT(("EPS SER: STAT MON -> Status Retr Failed. [%d]\r\n", retStatus));\r
2861         EPS_RETURN( retStatus );\r
2862     }\r
2863   if( pStInfo ){\r
2864     memcpy(pStInfo, &StatInfo, sizeof(EPS_STATUS_INFO));\r
2865   }\r
2866 \r
2867   if(EPS_ST_ERROR == StatInfo.nState && EPS_PRNERR_PAPERJAM == StatInfo.nError){\r
2868     printJob.transmittable = FALSE;\r
2869   }\r
2870 \r
2871     if(StatInfo.nCancel == EPS_CAREQ_CANCEL) {\r
2872         EPS_DBGPRINT(("EPS SER : CANCEL REQUEST by PRINTER\r\n"));\r
2873     printJob.resetReq = TRUE;\r
2874         EPS_RETURN( EPS_JOB_CANCELED );\r
2875     }\r
2876 \r
2877 /*  EPS_DBGPRINT(("M State\t: %d\n Error\t: %d\n Prepare\t: %d\n", \r
2878     StatInfo.nState, StatInfo.nError, StatInfo.nPrepare))\r
2879 */\r
2880   /* The error occurs in printer. */\r
2881   printJob.contData.lastError = StatInfo.nError;\r
2882 \r
2883     /*EPS_DBGPRINT(("EPS SER: STAT MON -> Printer State [0x%x]\r\n",StatInfo.nState));*/\r
2884     if( StatInfo.nState & ( EPS_ST_IDLE          |\r
2885               EPS_ST_WAITING       |\r
2886               EPS_ST_SELF_PRINTING |\r
2887               EPS_ST_CLEANING      ) ){\r
2888         /*EPS_DBGPRINT(("EPS SER: STAT MON -> SETTLING\r\n"));*/\r
2889         EPS_RETURN( EPS_ERR_NONE );\r
2890     }else{\r
2891         EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
2892   }\r
2893 }\r
2894 \r
2895 \r
2896 /*******************************************|********************************************/\r
2897 /*                                                                                      */\r
2898 /* Function name:     PrintBand()                                                       */\r
2899 /*                                                                                      */\r
2900 /* Arguments                                                                            */\r
2901 /* ---------                                                                            */\r
2902 /* Name:        Type:               Description:                                        */\r
2903 /* data          EPS_UINT8*         I: Pointer to image [RGB] data                      */\r
2904 /* widthPixels   EPS_UINT32         I: The width of the raster band (in pixels)         */\r
2905 /* heightPixels  EPS_UINT32*        I/O: In : Height of image (image lines)  (in pixels)*/\r
2906 /*                                     : Out: Sent Height                               */\r
2907 /*                                                                                      */\r
2908 /* Return value:                                                                        */\r
2909 /*      << Normal >>                                                                    */\r
2910 /*      EPS_ERR_NONE                    - Success                                       */\r
2911 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
2912 /*                                        (Do not return when Uni-Directional)          */\r
2913 /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */\r
2914 /*      << Error >>                                                                     */\r
2915 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
2916 /*      EPS_ERR_INV_ARG_WIDTH_PIXELS    - Invalid argument "widthPixels"                */\r
2917 /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */\r
2918 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
2919 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2920 /*                                                                                      */\r
2921 /* Description:                                                                         */\r
2922 /*      Prints a band of raster data.                                                   */\r
2923 /*      It must be noted that this function automatically positions the raster bands;   */\r
2924 /*      all subsequent raster bands after the first one are positioned directly         */\r
2925 /*      underneath the preceding band.                                                  */\r
2926 /*      Horizontal orientation of the raster bands never changes.                       */\r
2927 /*                                                                                      */\r
2928 /*******************************************|********************************************/\r
2929 EPS_ERR_CODE    PrintBand (\r
2930 \r
2931         const EPS_UINT8*  data,             /* Pointer to image [RGB] data              */\r
2932         EPS_UINT32  widthPixels,            /* Width of image [ in pixels ]             */\r
2933         EPS_UINT32  *heightPixels           /* Height of image (image lines)            */\r
2934 \r
2935 ) {\r
2936 \r
2937 /*** Declare Variable Local to Routine                                                  */\r
2938 EPS_ERR_CODE    retStatus;\r
2939 EPS_UINT32      idx = 0;                    /* Generl loop/index variable               */\r
2940 EPS_IMAGE       line;                       /* Single line of image data                */\r
2941 const EPS_UINT8*      tmpImageData;         /* Temporary image pointer                  */\r
2942 EPS_BOOL        skipLine;                   /* Flag to skip or print current image line */\r
2943 EPS_UINT32    linePixels;\r
2944 EPS_UINT32    sendHeight;\r
2945 \r
2946   EPS_LOG_FUNCIN;\r
2947 \r
2948   if( NULL == data ){\r
2949         EPS_RETURN( EPS_ERR_INV_ARG_DATA );\r
2950   }\r
2951   if(NULL == heightPixels){\r
2952         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );\r
2953   }\r
2954   if(*heightPixels == 0){\r
2955         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );\r
2956   }\r
2957   sendHeight = *heightPixels;\r
2958   *heightPixels = 0;\r
2959 \r
2960   if( widthPixels == 0 ){\r
2961         EPS_RETURN( EPS_ERR_INV_ARG_WIDTH_PIXELS );\r
2962   }\r
2963  \r
2964 /*** Initialize Local Variables                                                         */\r
2965     retStatus = EPS_ERR_NONE;\r
2966 \r
2967   if( printJob.printableAreaHeight <= (EPS_UINT32)printJob.verticalOffset ){\r
2968         /*** Return to Caller                                                           */\r
2969     EPS_RETURN( EPS_OUT_OF_BOUNDS );\r
2970   }\r
2971     \r
2972 /*** Clip number is image lines if too many                                             */\r
2973   if (sendHeight > (printJob.printableAreaHeight - printJob.verticalOffset)){\r
2974         sendHeight =  printJob.printableAreaHeight - printJob.verticalOffset;\r
2975   }\r
2976 \r
2977 /*** Send leftovers of last time And Skip first line of input data                      */\r
2978   idx = 0;  /* Initialize line counter */\r
2979 \r
2980   /*** Send leftovers data                                                            */\r
2981   retStatus = SendLeftovers();\r
2982   if(EPS_ERR_INVALID_CALL == retStatus){  /* It was unnecessary */\r
2983     retStatus = EPS_ERR_NONE;\r
2984     if(printJob.contData.skipLine == TRUE){\r
2985       idx++;              /* skip first line of input data */\r
2986       printJob.contData.skipLine = FALSE;\r
2987     }\r
2988   } else if(EPS_ERR_NONE == retStatus){ /* Sent leftovers */\r
2989     idx++;                /* skip first line of input data */\r
2990   } else{\r
2991     EPS_RETURN( retStatus );\r
2992   }\r
2993 \r
2994 /*** The following section of code forces the core module to skip raster lines that are */\r
2995 /*** completely white in order to minimize data size. This function is compatible with  */\r
2996 /*** 8-bit palettized and 24-bit RGB bitmaps.                                           */\r
2997 /*** ---------------------------------------------------------------------------------- */\r
2998 \r
2999     /*** Initialize variable                                                            */\r
3000     line.bytesPerLine = printJob.bpp * widthPixels;\r
3001   linePixels = Min(line.bytesPerLine, printJob.bpp * printJob.printableAreaWidth);\r
3002     for (; idx < sendHeight; idx++) {\r
3003         /* Calculate position of image line                                             */\r
3004         line.data = data + idx * line.bytesPerLine;\r
3005         \r
3006         /*** Make new LineRect                                                          */\r
3007         line.rect.top      = (EPS_INT32)(printJob.verticalOffset + idx);\r
3008         line.rect.left     = 0;\r
3009         line.rect.bottom   = line.rect.top + 1;\r
3010         line.rect.right    = (EPS_INT32)(widthPixels);\r
3011       \r
3012     /*** Test if current image data is completely white                             */\r
3013     if(EPS_LANG_ESCPR == printJob.printer->language ){\r
3014       skipLine = TRUE;\r
3015     } else{\r
3016       skipLine = FALSE; /* esc/page need anything band */\r
3017     }\r
3018 \r
3019     /* skip blank band for ESC/P-R */\r
3020     /* check blank page for duplex */\r
3021     if( EPS_LANG_ESCPR == printJob.printer->language ||\r
3022       (EPS_DUPLEX_NONE != printJob.attr.duplex && printJob.needBand) )\r
3023     {\r
3024       for (tmpImageData = line.data; \r
3025          tmpImageData < (line.data + linePixels); \r
3026          tmpImageData++ ) {\r
3027         if(*tmpImageData != printJob.whiteColorValue) {\r
3028           skipLine = FALSE;\r
3029           printJob.needBand = FALSE;\r
3030           break;\r
3031         }\r
3032       }\r
3033 \r
3034       if (skipLine == TRUE)continue;\r
3035     }\r
3036 \r
3037     /*** Image Data not completely white - print image data                         */\r
3038     retStatus = PrintLine(&line);\r
3039 \r
3040         if (retStatus != EPS_ERR_NONE) {\r
3041             break;\r
3042         }\r
3043     }\r
3044 \r
3045 /*** band positioning adds                                                              */\r
3046   printJob.verticalOffset += idx;\r
3047     \r
3048 /*** Return to Caller                                                                   */\r
3049   *heightPixels = idx;\r
3050 \r
3051     EPS_RETURN( retStatus );\r
3052 }\r
3053 \r
3054 \r
3055 /*******************************************|********************************************/\r
3056 /*                                                                                      */\r
3057 /* Function name:     PrintChunk()                                                      */\r
3058 /*                                                                                      */\r
3059 /* Arguments                                                                            */\r
3060 /* ---------                                                                            */\r
3061 /* Name:        Type:               Description:                                        */\r
3062 /* data         EPS_UINT8*          I: Pointer to image [RGB] data                      */\r
3063 /* dataSize   EPS_UINT32*         I/O: In : size of image                             */\r
3064 /*                                     : Out: Sent size                                 */\r
3065 /*                                                                                      */\r
3066 /* Return value:                                                                        */\r
3067 /*      << Normal >>                                                                    */\r
3068 /*      EPS_ERR_NONE                    - Success                                       */\r
3069 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
3070 /*                                        (Do not return when Uni-Directional)          */\r
3071 /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */\r
3072 /*      << Error >>                                                                     */\r
3073 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
3074 /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */\r
3075 /*      EPS_ERR_INV_ARG_DATASIZE    - data size limit               */\r
3076 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
3077 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
3078 /*                                                                                      */\r
3079 /* Description:                                                                         */\r
3080 /*      Prints Jpeg file data.                                                          */\r
3081 /*                                                                                      */\r
3082 /*******************************************|********************************************/\r
3083 EPS_ERR_CODE    PrintChunk (\r
3084 \r
3085         const EPS_UINT8*  data,             /* Pointer to image [JPEG] data             */\r
3086         EPS_UINT32*       dataSize          /* size of image (chunked data)             */\r
3087 \r
3088 ) {\r
3089 /*** Declare Variable Local to Routine                                                  */\r
3090 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;\r
3091 EPS_UINT32      sendSize = 0;\r
3092 EPS_UINT32      retBufSize = 0;\r
3093 EPS_INT32       cmdBuffSize = ESCPR_HEADER_LENGTH + ESCPR_SEND_JPGDATA_LENGTH;\r
3094 EPS_UINT8*      bufPtr = NULL;              /* Temporary buffer pointer                 */\r
3095 EPS_INT32       paramSize = 0;              /* Size of command parameters only          */\r
3096 \r
3097 EPS_INT32       i = 0;\r
3098 #define DUMMY_DATA_COUNT  (1000)\r
3099 \r
3100   EPS_LOG_FUNCIN;\r
3101 \r
3102 /*** Validate input parameters                                                          */\r
3103   if(NULL == dataSize){\r
3104         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );\r
3105   }\r
3106 #if LCOMSW_DUMMY_SEND\r
3107   if( *dataSize == 0 && \r
3108     (EPS_PROTOCOL_USB & printJob.printer->protocol) ){\r
3109     /* USB not peform */\r
3110         EPS_RETURN( EPS_ERR_NONE );\r
3111   }\r
3112 #else\r
3113   if( NULL == data ){\r
3114         EPS_RETURN( EPS_ERR_INV_ARG_DATA );\r
3115   }\r
3116   if(*dataSize == 0){\r
3117         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );\r
3118   }\r
3119 #endif\r
3120 \r
3121   sendSize = *dataSize;\r
3122   *dataSize = 0;\r
3123 \r
3124 #if !_VALIDATE_SUPPORTED_MEDIA_DATA_\r
3125   if( EPS_JPEG_CHUNK_SIZE_MAX < sendSize){\r
3126     *dataSize = 0;\r
3127         EPS_RETURN( EPS_ERR_INV_ARG_DATASIZE );\r
3128   }\r
3129 \r
3130   if( (EPS_UINT32)printJob.printer->JpgMax < printJob.jpegSize + sendSize){\r
3131     printJob.bJpgLimit = TRUE;\r
3132         EPS_RETURN( EPS_ERR_INV_ARG_DATASIZE );\r
3133   }\r
3134 #endif\r
3135 \r
3136   /************************************************************************************/\r
3137   /*** Send last time leftovers data                                                  */\r
3138 \r
3139   /*** Header                                                                         */\r
3140   retStatus = SendLeftovers();\r
3141   if(EPS_ERR_INVALID_CALL == retStatus){  /* It was unnecessary */\r
3142     retStatus = EPS_ERR_NONE;\r
3143   } else if(EPS_ERR_NONE != retStatus){\r
3144     *dataSize = 0;\r
3145     EPS_RETURN( retStatus );\r
3146   }\r
3147 \r
3148   /*** Data                                                                           */\r
3149   if(0 < printJob.contData.jpgSize){\r
3150     retBufSize = 0;\r
3151     retStatus = SendCommand(data, \r
3152                 Min(printJob.contData.jpgSize, sendSize),\r
3153                 &retBufSize, FALSE); /* not save Leftovers */\r
3154     printJob.contData.jpgSize -= retBufSize;\r
3155     *dataSize = retBufSize;\r
3156     printJob.jpegSize += retBufSize;  /* add total size */\r
3157     if( EPS_ERR_NONE != retStatus ){\r
3158       EPS_RETURN( retStatus );\r
3159     }\r
3160 \r
3161     sendSize -= retBufSize;\r
3162     if(0 >= sendSize ){\r
3163       EPS_RETURN( EPS_ERR_NONE );\r
3164     }\r
3165 \r
3166     data += retBufSize;\r
3167   }\r
3168 \r
3169   /************************************************************************************/\r
3170   /*** Send this time data                                                            */\r
3171 \r
3172   /*** Header                                                                         */\r
3173   printJob.contData.jpgSize = sendSize;\r
3174 \r
3175 #if !LCOMSW_DUMMY_SEND\r
3176   EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH )\r
3177 #else\r
3178   if(0 < sendSize){\r
3179     EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH )\r
3180   } else{\r
3181     EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH * DUMMY_DATA_COUNT )\r
3182   }\r
3183 #endif\r
3184   if(NULL == sendDataBuf){\r
3185     sendDataBufSize = 0;\r
3186     EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
3187   }\r
3188 \r
3189   bufPtr = sendDataBuf;\r
3190   memcpy(bufPtr, SendDataCmd, sizeof(SendDataCmd));\r
3191   bufPtr += sizeof(SendDataCmd);\r
3192 \r
3193   paramSize = ESCPR_SEND_JPGDATA_LENGTH + sendSize;\r
3194   memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, (EPS_UINT32)paramSize, bufPtr);\r
3195   bufPtr += 4;\r
3196   memcpy(bufPtr, SendJpegDataName, sizeof(SendJpegDataName));\r
3197   bufPtr += sizeof(SendJpegDataName);\r
3198  \r
3199   memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, sendSize, bufPtr);\r
3200 \r
3201   if(0 < sendSize){\r
3202     retBufSize = 0;\r
3203     retStatus = SendCommand(sendDataBuf, cmdBuffSize, &retBufSize, TRUE);/* save Leftovers */\r
3204     if( EPS_ERR_NONE != retStatus ){\r
3205       EPS_RETURN( retStatus );\r
3206     }\r
3207 \r
3208     /*** Data                                                                           */\r
3209     retBufSize = 0;\r
3210     retStatus = SendCommand(data, sendSize, &retBufSize, FALSE);  /* NOT save Leftovers */\r
3211 \r
3212     *dataSize += retBufSize;\r
3213     printJob.contData.jpgSize -= retBufSize;\r
3214 \r
3215     printJob.jpegSize += retBufSize;  /* add total size */\r
3216   } else {\r
3217     /*** dummy data */\r
3218     bufPtr = sendDataBuf + cmdBuffSize;\r
3219     for(i=1; i < DUMMY_DATA_COUNT; i++){    /* 12x1000 byte */\r
3220       memcpy(bufPtr, sendDataBuf, cmdBuffSize);\r
3221       bufPtr += cmdBuffSize;\r
3222     }\r
3223     \r
3224     retStatus = SendCommand(sendDataBuf, ESCPR_JPGHEAD_LENGTH * DUMMY_DATA_COUNT, &retBufSize, TRUE);/* save Leftovers */\r
3225   }\r
3226 \r
3227   EPS_RETURN( retStatus );\r
3228 }\r
3229 \r
3230 \r
3231 /*******************************************|********************************************/\r
3232 /*                                                                                      */\r
3233 /* Function name:   SendLeftovers()                                                     */\r
3234 /*                                                                                      */\r
3235 /* Arguments                                                                            */\r
3236 /* ---------                                                                            */\r
3237 /* Name:        Type:               Description:                                        */\r
3238 /* nStartStep   EPS_INT32           I: Step of Start Page comannds                      */\r
3239 /*                                                                                      */\r
3240 /* Return value:                                                                        */\r
3241 /*      << Normal >>                                                                    */\r
3242 /*      EPS_ERR_NONE                    - Success                                       */\r
3243 /*      EPS_ERR_INVALID_CALL            - This call was unnecessary                     */\r
3244 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
3245 /*                                        (Do not return when Uni-Directional)          */\r
3246 /*      << Error >>                                                                     */\r
3247 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
3248 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
3249 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
3250 /*                                                                                      */\r
3251 /* Description:                                                                         */\r
3252 /*      send leftovers data.                                                            */\r
3253 /*                                                                                      */\r
3254 /*******************************************|********************************************/\r
3255 static EPS_ERR_CODE    SendLeftovers (\r
3256 \r
3257       void \r
3258 \r
3259 ){\r
3260 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */\r
3261 EPS_UINT32    retBufSize = 0;\r
3262 \r
3263   EPS_LOG_FUNCIN;\r
3264 \r
3265 /*** send leftovers                                                                      */\r
3266 #ifdef GCOMSW_CMD_ESCPAGE\r
3267   if(EPS_LANG_ESCPR == printJob.printer->language ){\r
3268 #endif\r
3269     /*** ESC/P-R ***/\r
3270     if( NULL != printJob.contData.sendData && 0 < printJob.contData.sendDataSize){\r
3271       retStatus = SendCommand(printJob.contData.sendData, \r
3272                   printJob.contData.sendDataSize, &retBufSize, TRUE);\r
3273     } else{\r
3274       retStatus = EPS_ERR_INVALID_CALL;\r
3275     }\r
3276 #ifdef GCOMSW_CMD_ESCPAGE\r
3277   } else{\r
3278     /*** ESC/Page ***/\r
3279     retStatus = pageSendLeftovers();\r
3280   }\r
3281 #endif\r
3282 \r
3283   EPS_RETURN( retStatus );\r
3284 }\r
3285 \r
3286 \r
3287 /*******************************************|********************************************/\r
3288 /*                                                                                      */\r
3289 /* Function name:   SendBlankBand()                                                     */\r
3290 /*                                                                                      */\r
3291 /* Arguments                                                                            */\r
3292 /* ---------                                                                            */\r
3293 /* Name:        Type:               Description:                                        */\r
3294 /* nStartStep   EPS_INT32           I: Step of Start Page comannds                      */\r
3295 /*                                                                                      */\r
3296 /* Return value:                                                                        */\r
3297 /*      << Normal >>                                                                    */\r
3298 /*      EPS_ERR_NONE                    - Success                                       */\r
3299 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
3300 /*                                        (Do not return when Uni-Directional)          */\r
3301 /*      << Error >>                                                                     */\r
3302 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
3303 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
3304 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
3305 /*                                                                                      */\r
3306 /* Description:                                                                         */\r
3307 /*      send leftovers data.                                                            */\r
3308 /*                                                                                      */\r
3309 /*******************************************|********************************************/\r
3310 static EPS_ERR_CODE    SendBlankBand (\r
3311 \r
3312       void \r
3313 \r
3314 ){\r
3315   EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls      */\r
3316   EPS_UINT8   pix[3*16]; /* 16=ESC/Page24 minimum unit */\r
3317   EPS_IMAGE       line;\r
3318 \r
3319   EPS_LOG_FUNCIN;\r
3320 \r
3321 #ifdef GCOMSW_CMD_ESCPAGE_S\r
3322   if(EPS_LANG_ESCPAGE_S == printJob.printer->language){\r
3323     EPS_RETURN( EPS_ERR_NONE );\r
3324   }\r
3325 #endif\r
3326 \r
3327   if(EPS_CP_FULLCOLOR == printJob.attr.colorPlane){\r
3328     memset(pix, 0xFF, sizeof(pix)); /* white */\r
3329     if(EPS_LANG_ESCPAGE == printJob.printer->language ||\r
3330        EPS_LANG_ESCPAGE_COLOR == printJob.printer->language)\r
3331     {\r
3332       memset(pix, 0x00, 3);   /* black dot */\r
3333     }\r
3334   } else{\r
3335     memset(pix, printJob.whiteColorValue, sizeof(pix));\r
3336     if(EPS_LANG_ESCPAGE == printJob.printer->language ||\r
3337        EPS_LANG_ESCPAGE_COLOR == printJob.printer->language)\r
3338     {\r
3339       if(printJob.whiteColorValue != 0){\r
3340         memset(pix, 0, sizeof(pix));\r
3341       } else{\r
3342         memset(pix, 1, sizeof(pix));\r
3343       }\r
3344     }\r
3345   }\r
3346   line.data          = pix;\r
3347   line.bytesPerLine  = printJob.bpp;\r
3348   line.rect.top      = 0;\r
3349   line.rect.left     = 0;\r
3350   line.rect.bottom   = 1;\r
3351   if(EPS_LANG_ESCPR == printJob.printer->language || \r
3352     EPS_CP_256COLOR == printJob.attr.colorPlane ){\r
3353     line.rect.right= 1;\r
3354   } else{\r
3355     line.rect.right= 16;\r
3356   }\r
3357   \r
3358   retStatus = PrintLine(&line);\r
3359 \r
3360   EPS_RETURN( retStatus );\r
3361 }\r
3362 \r
3363 /*******************************************|********************************************/\r
3364 /*                                                                                      */\r
3365 /* Function name:     SetupJobAttrib()                                                  */\r
3366 /*                                                                                      */\r
3367 /* Arguments                                                                            */\r
3368 /* ---------                                                                            */\r
3369 /* Name:        Type:               Description:                                        */\r
3370 /* jobAttr      EPS_JOB_ATTRIB*     I: Data structure containing job attribut settings  */\r
3371 /*                                                                                      */\r
3372 /* Return value:                                                                        */\r
3373 /*      << Normal >>                                                                    */\r
3374 /*      EPS_ERR_NONE                            - Success                               */\r
3375 /*      << Error >>                                                                     */\r
3376 /*      EPS_ERR_INV_COLOR_PLANE                 - Invalid Color Plane                   */\r
3377 /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */\r
3378 /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */\r
3379 /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */\r
3380 /*      EPS_ERR_INV_MEDIA_TYPE                  - Invalid Media Type                    */\r
3381 /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */\r
3382 /*      EPS_ERR_INV_PRINT_QUALITY               - Invalid Print Quality                 */\r
3383 /*      EPS_ERR_INV_PAPER_SOURCE                - Invalid Paper source                  */\r
3384 /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */\r
3385 /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */\r
3386 /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */\r
3387 /*      EPS_ERR_INV_BRIGHTNESS                  - Invalid Brightness                    */\r
3388 /*      EPS_ERR_INV_CONTRAST                    - Invalid Contrast                      */\r
3389 /*      EPS_ERR_INV_SATURATION                  - Invalid Saturation                    */\r
3390 /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */\r
3391 /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */\r
3392 /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */\r
3393 /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Redeye                    */\r
3394 /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */\r
3395 /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */\r
3396 /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */\r
3397 /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */\r
3398 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */\r
3399 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */\r
3400 /*                                                                                      */\r
3401 /* Description:                                                                         */\r
3402 /*      Confirm ESC/P-R Job Attribute.                                                  */\r
3403 /*                                                                                      */\r
3404 /*******************************************|********************************************/\r
3405 EPS_ERR_CODE    SetupJobAttrib (\r
3406 \r
3407         const EPS_JOB_ATTRIB*     jobAttr    /* Print Attributes for this Page         */\r
3408 \r
3409 ){\r
3410   debug_msg("ccheck call function start Job \n");\r
3411   EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls      */\r
3412   \r
3413 EPS_LOG_FUNCIN;\r
3414 /*** Validate input parameters                                                          */\r
3415 #ifndef LCOMSW_JOBPARAM_CEHCK_OFF\r
3416 /*======================================================================================*/\r
3417 /*** Validate/Confirm Page Attribute Data                                               */\r
3418 /*======================================================================================*/\r
3419   /*** Color Plane                                                                    */\r
3420   if (! (   (jobAttr->colorPlane         == EPS_CP_FULLCOLOR         ) ||\r
3421         (jobAttr->colorPlane         == EPS_CP_256COLOR          ) ||\r
3422         (jobAttr->colorPlane         == EPS_CP_JPEG              ) ||\r
3423         (jobAttr->colorPlane         == EPS_CP_PRINTCMD          ) ) ){\r
3424     EPS_RETURN( EPS_ERR_INV_COLOR_PLANE )\r
3425   }\r
3426   if( EPS_CP_PRINTCMD == jobAttr->colorPlane ){   /* Print command */\r
3427     /*** Structure version                                                          */\r
3428     debug_msg("Checking here \n");\r
3429     if(EPS_JOB_ATTRIB_VER_2 > jobAttr->version){\r
3430       EPS_RETURN( EPS_ERR_INVALID_VERSION )\r
3431     }\r
3432 \r
3433     /*** Print command type                                                         */\r
3434     if (! (   (jobAttr->cmdType       == EPS_MNT_CUSTOM           ) ||\r
3435           (jobAttr->cmdType       == EPS_MNT_CLEANING         ) ||\r
3436           (jobAttr->cmdType       == EPS_MNT_NOZZLE           )    ) ){\r
3437       EPS_RETURN( EPS_ERR_INV_CMDTYPE )\r
3438     }\r
3439 \r
3440   } else{                       /* Image(RGB, Jpeg) */\r
3441     /*** Media Size                                                                     */\r
3442 \r
3443     debug_msg("Checking here 0.1 \n");\r
3444     if (! ( ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A4              ) &&\r
3445           (jobAttr->mediaSizeIdx       <= EPS_MSID_HIVISION        )    ) ||\r
3446         ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A3NOBI          ) &&\r
3447           (jobAttr->mediaSizeIdx       <= EPS_MSID_12X12           )    ) ||\r
3448         ( (jobAttr->mediaSizeIdx       == EPS_MSID_USER            )    )    ) ){\r
3449       EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE )\r
3450     }\r
3451     debug_msg("Checking here 0.2 \n");\r
3452     /*** Media Type                                                                     */\r
3453     if (! ( ( (jobAttr->mediaTypeIdx       >= EPS_MTID_PLAIN           ) &&\r
3454   /*              (jobAttr->mediaTypeIdx       <= EPS_MTID_GLOSSYHAGAKI    )    ) ||*/\r
3455           (jobAttr->mediaTypeIdx       <= EPS_MTID_BUSINESSCOAT    )    ) ||\r
3456         ( (jobAttr->mediaTypeIdx       >= EPS_MTID_CDDVD           ) &&\r
3457           (jobAttr->mediaTypeIdx       <= EPS_MTID_CDDVDGLOSSY     )    ) ||\r
3458         ( (jobAttr->mediaTypeIdx       == EPS_MTID_CLEANING        )    )    ) ){\r
3459       EPS_RETURN( EPS_ERR_INV_MEDIA_TYPE )\r
3460     }\r
3461     debug_msg("Checking here 0.3 \n");\r
3462     /*** Print Quality                                                                  */\r
3463     if (! (   (jobAttr->printQuality       == EPS_MQID_DRAFT           ) ||\r
3464           (jobAttr->printQuality       == EPS_MQID_NORMAL          ) ||\r
3465           (jobAttr->printQuality       == EPS_MQID_HIGH            )    ) ){\r
3466       \r
3467       EPS_RETURN( EPS_ERR_INV_PRINT_QUALITY )\r
3468     }\r
3469     debug_msg("Checking here 0.4 \n");\r
3470     /*** duplex                                                                         */\r
3471     if( !( (jobAttr->duplex             == EPS_DUPLEX_NONE             ) ||\r
3472          (jobAttr->duplex             == EPS_DUPLEX_LONG             ) ||\r
3473          (jobAttr->duplex           == EPS_DUPLEX_SHORT            ) ) ){\r
3474       \r
3475       EPS_RETURN( EPS_ERR_INV_DUPLEX )\r
3476     }\r
3477     debug_msg("Checking here 0.5 \n");\r
3478     /*** Brightness                                                                     */\r
3479     if (! (   (jobAttr->brightness         >= -50                      ) &&\r
3480           (jobAttr->brightness         <=  50                      )    ) ){\r
3481       \r
3482       EPS_RETURN( EPS_ERR_INV_BRIGHTNESS )\r
3483     }\r
3484     debug_msg("Checking here 0.6 \n");\r
3485     /*** Contrast                                                                       */\r
3486     if (! (   (jobAttr->contrast           >= -50                      ) &&\r
3487           (jobAttr->contrast           <=  50                      )    ) ){\r
3488       \r
3489       EPS_RETURN( EPS_ERR_INV_CONTRAST )\r
3490     }\r
3491     debug_msg("Checking here 0.7 \n");\r
3492     /*** Saturation                                                                     */\r
3493     if (! (   (jobAttr->saturation         >= -50                      ) &&\r
3494           (jobAttr->saturation         <=  50                      )    ) ){\r
3495       \r
3496       EPS_RETURN( EPS_ERR_INV_SATURATION )\r
3497     }\r
3498     debug_msg("Checking here 0.8 \n");\r
3499     /*** Paper Source                                                                   */\r
3500     if (! (   (jobAttr->paperSource    == EPS_MPID_AUTO            ) ||\r
3501           (jobAttr->paperSource        == EPS_MPID_REAR            ) ||\r
3502           (jobAttr->paperSource        == EPS_MPID_FRONT1          ) ||\r
3503           (jobAttr->paperSource        == EPS_MPID_FRONT2          ) ||\r
3504           (jobAttr->paperSource        == EPS_MPID_FRONT3          ) ||\r
3505           (jobAttr->paperSource        == EPS_MPID_FRONT4          ) ||\r
3506           (jobAttr->paperSource        == EPS_MPID_CDTRAY          ) ||\r
3507 \r
3508           (jobAttr->paperSource        == IPS_MPTID_TRAY1          ) ||\r
3509           (jobAttr->paperSource        == IPS_MPTID_TRAY2          ) ||\r
3510           (jobAttr->paperSource        == IPS_MPTID_TRAY3          ) ||\r
3511           (jobAttr->paperSource        == IPS_MPTID_TRAY4          ) ||\r
3512           (jobAttr->paperSource        == IPS_MPTID_TRAY5          ) ||\r
3513           (jobAttr->paperSource        == IPS_MPTID_TRAY6          ) ||\r
3514           (jobAttr->paperSource        == IPS_MPTID_TRAY7          ) ||\r
3515           (jobAttr->paperSource        == IPS_MPTID_TRAY8          ) ||\r
3516           (jobAttr->paperSource        == IPS_MPTID_TRAY9          ) ||\r
3517           (jobAttr->paperSource        == IPS_MPTID_TRAY10          ) ||\r
3518           (jobAttr->paperSource        == IPS_MPTID_TRAY11          ) ||\r
3519           (jobAttr->paperSource        == IPS_MPTID_TRAY12          ) ||\r
3520           (jobAttr->paperSource        == IPS_MPTID_TRAY13          ) ||\r
3521           (jobAttr->paperSource        == IPS_MPTID_TRAY14          ) ||\r
3522           (jobAttr->paperSource        == IPS_MPTID_TRAY15          ) ||\r
3523               \r
3524           \r
3525           (jobAttr->paperSource        == EPS_MPID_PAGE_S_MP_TRAY   ) ||\r
3526           (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE1   ) ||\r
3527           (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE2   ) ||\r
3528           (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE3   ) ||\r
3529           (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE4   ) ||\r
3530           (jobAttr->paperSource        == EPS_MPID_PAGE_S_PARAM_MANUALFEED  ) ||\r
3531           (jobAttr->paperSource        == EPS_MPID_PAGE_S_AUTO_TRAY   )\r
3532              ) ){\r
3533       debug_msg("Invalid paper source: jobAttr->paperSource = %d\n", jobAttr->paperSource);\r
3534       EPS_RETURN( EPS_ERR_INV_PAPER_SOURCE )\r
3535     }\r
3536     debug_msg("Checking here 0.9 \n");\r
3537     if(jobAttr->printLayout == EPS_MLID_CDLABEL){\r
3538       /*** CD Inside Diameter                                                     */\r
3539       if( !( (jobAttr->cdDimIn >= EPS_CDDIM_IN_MIN   )\r
3540         && (jobAttr->cdDimIn <= EPS_CDDIM_IN_MAX ) ) ){\r
3541         EPS_RETURN( EPS_ERR_INV_CD_INDIM )\r
3542       }\r
3543       /*** CD Outside Diameter                                                    */\r
3544       if( !( (jobAttr->cdDimOut >= EPS_CDDIM_OUT_MIN   )\r
3545         && (jobAttr->cdDimOut <= EPS_CDDIM_OUT_MAX ) ) ){\r
3546         EPS_RETURN( EPS_ERR_INV_CD_OUTDIM )\r
3547       }\r
3548     }\r
3549     debug_msg("Checking here 1 \n");\r
3550     if( EPS_CP_JPEG == jobAttr->colorPlane ){\r
3551       if( jobAttr->duplex != EPS_DUPLEX_NONE ){\r
3552         EPS_RETURN( EPS_ERR_INV_DUPLEX )\r
3553       }\r
3554     }\r
3555   }\r
3556 #endif\r
3557 /*======================================================================================*/\r
3558 /*** Copy Input Page Attribute Data to Internal Variable                                */\r
3559 /*======================================================================================*/\r
3560   switch( jobAttr->colorPlane ){\r
3561   case EPS_CP_FULLCOLOR:      /* RGB */\r
3562   case EPS_CP_256COLOR:\r
3563       memcpy((void*)(&printJob.attr), (void*)jobAttr, sizeof(EPS_JOB_ATTRIB));\r
3564     retStatus = SetupRGBAttrib();\r
3565     if(EPS_ERR_NONE == retStatus){\r
3566       _SP_ChangeSpec_DraftOnly(printJob.printer, &printJob.attr);   \r
3567       /* Ignore the return value of this func */\r
3568     }\r
3569     break;\r
3570 \r
3571   case EPS_CP_JPEG:       /* Jpeg */\r
3572       memcpy((void*)(&printJob.attr), (void*)jobAttr, sizeof(EPS_JOB_ATTRIB));\r
3573     retStatus = SetupJPGAttrib();\r
3574     if(EPS_ERR_NONE == retStatus){\r
3575       _SP_ChangeSpec_DraftOnly(printJob.printer, &printJob.attr);   \r
3576       /* Ignore the return value of this func */\r
3577     }\r
3578     break;\r
3579 \r
3580   case EPS_CP_PRINTCMD:     /* Print command */\r
3581   default:\r
3582       memset((void*)(&printJob.attr), 0, sizeof(EPS_JOB_ATTRIB));\r
3583     printJob.attr.colorPlane = jobAttr->colorPlane;\r
3584     printJob.attr.cmdType = jobAttr->cmdType;\r
3585     break;\r
3586 \r
3587   }\r
3588 \r
3589   EPS_RETURN( retStatus )\r
3590 }\r
3591 \r
3592 \r
3593 /*******************************************|********************************************/\r
3594 /*                                                                                      */\r
3595 /* Function name:     SetupRGBAttrib()                                                  */\r
3596 /*                                                                                      */\r
3597 /* Arguments                                                                            */\r
3598 /* ---------                                                                            */\r
3599 /* Name:        Type:               Description:                                        */\r
3600 /* jobAttr      EPS_JOB_ATTRIB*     I: Data structure containing page attribut settings */\r
3601 /*                                                                                      */\r
3602 /* Return value:                                                                        */\r
3603 /*      << Normal >>                                                                    */\r
3604 /*      EPS_ERR_NONE                            - Success                               */\r
3605 /*      << Error >>                                                                     */\r
3606 /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */\r
3607 /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */\r
3608 /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */\r
3609 /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */\r
3610 /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */\r
3611 /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */\r
3612 /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */\r
3613 /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */\r
3614 /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */\r
3615 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */\r
3616 /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */\r
3617 /*                                                                                      */\r
3618 /* Description:                                                                         */\r
3619 /*      Confirm RGB Attribute.                                                          */\r
3620 /*                                                                                      */\r
3621 /*******************************************|********************************************/\r
3622 EPS_ERR_CODE    SetupRGBAttrib (\r
3623 \r
3624     void\r
3625 \r
3626 ){\r
3627 /*** Declare Variable Local to Routine                                                  */\r
3628 EPS_INT32       factor;                     /* Scaling factor for dpi                   */\r
3629 EPS_INT32       idx;                        /* Paper size index                         */\r
3630 EPS_INT32       tempPrintableWidth;         /* Temporary Variable                       */\r
3631 EPS_INT32       tempPrintableHeight;        /* Temporary Variable                       */\r
3632 const EPS_MEDIA_INFO* pMI = NULL;\r
3633 EPS_INT16   borderPixels;\r
3634 \r
3635   EPS_LOG_FUNCIN;\r
3636 \r
3637 /*** Initialize Global/Local Variables                                                  */\r
3638     idx                 = -1;\r
3639     tempPrintableWidth  = 0;\r
3640     tempPrintableHeight = 0;\r
3641 \r
3642 #ifndef LCOMSW_JOBPARAM_CEHCK_OFF\r
3643 /*** Validate input parameters                                                          */\r
3644   /*** Border Mode                                                                    */\r
3645   if(! ((printJob.attr.printLayout == EPS_MLID_BORDERLESS      ) ||\r
3646       (printJob.attr.printLayout == EPS_MLID_BORDERS         ) ||\r
3647       (printJob.attr.printLayout == EPS_MLID_CDLABEL         ) ||\r
3648       (printJob.attr.printLayout == EPS_MLID_DIVIDE16        ) ||\r
3649       (printJob.attr.printLayout == EPS_MLID_CUSTOM          ) ) ){\r
3650     EPS_RETURN( EPS_ERR_INV_BORDER_MODE )\r
3651   }\r
3652   /*** Color Mode                                                                 */\r
3653     if( !( (printJob.attr.colorMode          == EPS_CM_COLOR             ) ||\r
3654            (printJob.attr.colorMode          == EPS_CM_MONOCHROME        ) /*||\r
3655            (printJob.attr.colorMode          == EPS_CM_SEPIA             )*/ ) ){\r
3656     EPS_RETURN( EPS_ERR_INV_COLOR_MODE )\r
3657   }\r
3658 \r
3659   /*** Input Image Resolution                                                     */\r
3660     /*** Select table and factor                                                        */\r
3661   if(printJob.attr.inputResolution == EPS_IR_360X360){\r
3662     pMI = epsMediaSize;\r
3663       factor = 1;\r
3664     borderPixels = EPS_BORDERS_MARGIN_360;\r
3665   } else if(printJob.attr.inputResolution == EPS_IR_720X720){\r
3666     pMI = epsMediaSize;\r
3667     factor = 2;\r
3668     borderPixels = EPS_BORDERS_MARGIN_360;\r
3669   } else if(printJob.attr.inputResolution == EPS_IR_300X300){\r
3670     pMI = epsMediaSize300;\r
3671       factor = 1;\r
3672     borderPixels = EPS_BORDERS_MARGIN_300;\r
3673   } else if(printJob.attr.inputResolution == EPS_IR_1200X1200){\r
3674     pMI = epsMediaSize300;\r
3675       factor = 4;\r
3676     borderPixels = EPS_BORDERS_MARGIN_300;\r
3677   } else if(printJob.attr.inputResolution == EPS_IR_600X600){\r
3678     pMI = epsMediaSize300;\r
3679       factor = 2;\r
3680     borderPixels = EPS_BORDERS_MARGIN_300;\r
3681   } else{\r
3682         EPS_RETURN( EPS_ERR_INV_INPUT_RESOLUTION )\r
3683   }\r
3684 \r
3685   /*** Printing Direction                                                         */\r
3686     if (! (   (printJob.attr.printDirection     == EPS_PD_BIDIREC           ) ||\r
3687             (printJob.attr.printDirection     == EPS_PD_UNIDIREC          )    ) ){\r
3688     EPS_RETURN( EPS_ERR_INV_PRINT_DIRECTION )\r
3689   }\r
3690 \r
3691   /*** Pallette Data                                                              */\r
3692   if (printJob.attr.colorPlane == EPS_CP_256COLOR) {\r
3693     if (! ((printJob.attr.paletteSize       >= 3                        ) &&\r
3694          (printJob.attr.paletteSize       <= 768/*765*/               )    ) ){\r
3695       EPS_RETURN( EPS_ERR_INV_PALETTE_SIZE )\r
3696     }\r
3697 \r
3698     if (    printJob.attr.paletteData       == NULL                     ){\r
3699       EPS_RETURN( EPS_ERR_INV_PALETTE_DATA )\r
3700     }\r
3701   }\r
3702 \r
3703     /*** Margin                                                                     */\r
3704   if (printJob.attr.printLayout == EPS_MLID_CUSTOM) {\r
3705     if (printJob.attr.topMargin    < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_TOP_MARGIN );\r
3706     if (printJob.attr.leftMargin   < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_LEFT_MARGIN );\r
3707     if (printJob.attr.bottomMargin < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_BOTTOM_MARGIN );\r
3708     if (printJob.attr.rightMargin  < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_RIGHT_MARGIN );\r
3709   }\r
3710 #endif\r
3711 \r
3712 /*======================================================================================*/\r
3713 /*** Set the following parameter                                                        */\r
3714 /***    - printJob.topMargin                                                            */\r
3715 /***    - printJob.leftMargin                                                           */\r
3716 /***    - printJob.printableAreaWidth                                                   */\r
3717 /***    - printJob.printableAreaHeight                                                  */\r
3718 /***    - printJob.borderlessModeInternal                                               */\r
3719 /***    - printJob.verticalOffset                                                       */\r
3720 /*======================================================================================*/\r
3721     /*** Find the Media by ID                                                           */\r
3722     for (idx = 0; pMI[idx].id != -1; idx++) {\r
3723         if (pMI[idx].id == printJob.attr.mediaSizeIdx)\r
3724             break;\r
3725     }\r
3726     if (pMI[idx].id == -1) {\r
3727         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );\r
3728     }\r
3729 \r
3730     /*** Media Attributes                                                               */\r
3731     printJob.paperWidth  = pMI[idx].paper_x * factor;\r
3732     printJob.paperHeight = pMI[idx].paper_y * factor;\r
3733 \r
3734     /*** Initialize Printable based on border mode                                      */\r
3735     switch( printJob.attr.printLayout ){\r
3736   case EPS_MLID_BORDERLESS:\r
3737         printJob.topMargin      = pMI[idx].top_margin_borderless   * factor;\r
3738         printJob.leftMargin     = pMI[idx].left_margin_borderless  * factor;\r
3739         tempPrintableWidth      = pMI[idx].print_area_x_borderless * factor;\r
3740         tempPrintableHeight     = pMI[idx].print_area_y_borderless * factor;\r
3741         printJob.borderlessMode = EPS_BORDERLESS_NORMAL;\r
3742     break;\r
3743 \r
3744   case EPS_MLID_BORDERS:\r
3745   case EPS_MLID_DIVIDE16:  \r
3746     printJob.topMargin      = borderPixels * factor;\r
3747         printJob.leftMargin     = borderPixels * factor;\r
3748         tempPrintableWidth      = pMI[idx].print_area_x_border * factor;\r
3749         tempPrintableHeight     = pMI[idx].print_area_y_border * factor;\r
3750         printJob.borderlessMode = EPS_BORDER_3MM_MARGINE;\r
3751     break;\r
3752 \r
3753   case EPS_MLID_CDLABEL:\r
3754     tempPrintableWidth  =\r
3755     tempPrintableHeight = elGetDots(printJob.attr.inputResolution, printJob.attr.cdDimOut);\r
3756     printJob.topMargin  = CDDVD_OFFSET_Y(printJob.attr.inputResolution, printJob.attr.cdDimOut);\r
3757     printJob.leftMargin = CDDVD_OFFSET_X(printJob.attr.inputResolution, printJob.attr.cdDimOut);\r
3758         printJob.borderlessMode = EPS_BORDER_3MM_MARGINE; /* It's no meaning & no effect */\r
3759 \r
3760     EPS_DBGPRINT(("dim: %d / top: %d / left: %d\n", printJob.attr.cdDimOut,\r
3761             printJob.topMargin, printJob.leftMargin));\r
3762     break;\r
3763 \r
3764   default: /* printJob.attr.printLayout  == EPS_MLID_CUSTOM */\r
3765         printJob.topMargin      = printJob.attr.topMargin;\r
3766         printJob.leftMargin     = printJob.attr.leftMargin;\r
3767         tempPrintableWidth      = pMI[idx].paper_x * factor   -\r
3768                                   printJob.attr.leftMargin      -\r
3769                                   printJob.attr.rightMargin;\r
3770         tempPrintableHeight     = pMI[idx].paper_y * factor   -\r
3771                                   printJob.attr.topMargin       -\r
3772                                   printJob.attr.bottomMargin;\r
3773     printJob.borderlessMode = EPS_BORDER_CUSTOM;\r
3774     }\r
3775 \r
3776     /*** Validate/Confirm Magin Setting                                                 */\r
3777     if (printJob.attr.printLayout == EPS_MLID_CUSTOM) {\r
3778         if (tempPrintableWidth  <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH );\r
3779         if (tempPrintableHeight <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT );\r
3780     }\r
3781 \r
3782     /*** Set Printable Area                                                             */\r
3783     printJob.printableAreaWidth  = (EPS_UINT32)tempPrintableWidth;\r
3784     printJob.printableAreaHeight = (EPS_UINT32)tempPrintableHeight;\r
3785 \r
3786     /*** Scan through palette for the index value of white and set the global white\r
3787                                     value to this index for skipping white raster lines */\r
3788     if( printJob.attr.colorPlane == EPS_CP_256COLOR ){ \r
3789       printJob.bpp = 1;\r
3790   } else /* if(EPS_CP_FULLCOLOR) */{\r
3791         printJob.bpp = 3;\r
3792     printJob.attr.paletteSize = 0;\r
3793     printJob.attr.paletteData = NULL;\r
3794   }\r
3795   printJob.whiteColorValue = memSearchWhiteColorVal(printJob.attr.colorPlane, \r
3796                           printJob.attr.paletteData,\r
3797                           printJob.attr.paletteSize);\r
3798 \r
3799     /*** Set "Base Point" Data                                                          */\r
3800     /*** BORDER                                                                         */\r
3801     printJob.border.top        =\r
3802     printJob.border.left       =\r
3803     printJob.border.bottom     =\r
3804   printJob.border.right      = borderPixels * factor;\r
3805 \r
3806     AdjustBasePoint();\r
3807 \r
3808   EPS_RETURN( EPS_ERR_NONE );\r
3809 }\r
3810 \r
3811 \r
3812 /*******************************************|********************************************/\r
3813 /*                                                                                      */\r
3814 /* Function name:     SetupJPGAttrib()                                                  */\r
3815 /*                                                                                      */\r
3816 /* Arguments                                                                            */\r
3817 /* ---------                                                                            */\r
3818 /* Name:        Type:               Description:                                        */\r
3819 /* N/A                                                                                  */\r
3820 /*                                                                                      */\r
3821 /* Return value:                                                                        */\r
3822 /*      << Normal >>                                                                    */\r
3823 /*      EPS_ERR_NONE                            - Success                               */\r
3824 /*      << Error >>                                                                     */\r
3825 /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */\r
3826 /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */\r
3827 /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */\r
3828 /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Redeye                    */\r
3829 /*                                                                                      */\r
3830 /* Description:                                                                         */\r
3831 /*      Confirm APF Attribute.                                                          */\r
3832 /*                                                                                      */\r
3833 /*******************************************|********************************************/\r
3834 EPS_ERR_CODE    SetupJPGAttrib (\r
3835 \r
3836         void\r
3837 \r
3838 ){\r
3839   EPS_LOG_FUNCIN;\r
3840 \r
3841 #ifndef LCOMSW_JOBPARAM_CEHCK_OFF\r
3842 /*** Validate input parameters                                                          */\r
3843   /*** Border Mode                                                                    */\r
3844   if(! ((printJob.attr.printLayout == EPS_MLID_BORDERLESS      ) ||\r
3845       (printJob.attr.printLayout == EPS_MLID_BORDERS         ) ||\r
3846       (printJob.attr.printLayout == EPS_MLID_CDLABEL         ) ||\r
3847       (printJob.attr.printLayout == EPS_MLID_DIVIDE16        ) /*||\r
3848       (printJob.attr.printLayout == EPS_MLID_CUSTOM          ) */) ){\r
3849     EPS_RETURN( EPS_ERR_INV_BORDER_MODE )\r
3850   }\r
3851   /*** Color Mode (APF Filter)                                                        */\r
3852     if( !( (printJob.attr.colorMode      == EPS_CM_COLOR             ) ||\r
3853            (printJob.attr.colorMode      == EPS_CM_MONOCHROME        ) ||\r
3854            (printJob.attr.colorMode      == EPS_CM_SEPIA             ) ) ){\r
3855     EPS_RETURN( EPS_ERR_INV_COLOR_MODE )\r
3856   }\r
3857 \r
3858   /*** APF Scene                                                                      */\r
3859   if( !( (printJob.attr.apfAutoCorrect == EPS_APF_ACT_NOTHING  ) ||\r
3860        (printJob.attr.apfAutoCorrect == EPS_APF_ACT_STANDARD ) ||\r
3861        (printJob.attr.apfAutoCorrect == EPS_APF_ACT_PIM      ) ||\r
3862        (printJob.attr.apfAutoCorrect == EPS_APF_ACT_PORTRATE ) ||\r
3863        (printJob.attr.apfAutoCorrect == EPS_APF_ACT_VIEW     ) ||\r
3864        (printJob.attr.apfAutoCorrect == EPS_APF_ACT_NIGHTVIEW) ) ){\r
3865     EPS_RETURN( EPS_ERR_INV_APF_ACT );\r
3866   }\r
3867   /*** APF Sharpness                                                                  */\r
3868   if (! ((printJob.attr.sharpness           >= -50     ) &&\r
3869          (printJob.attr.sharpness           <=  50     ) ) ){\r
3870     EPS_RETURN( EPS_ERR_INV_APF_SHP );\r
3871   }\r
3872   /*** APF Redeye                                                                     */\r
3873   if( !( (printJob.attr.redeye         == EPS_APF_RDE_NOTHING  ) ||\r
3874        (printJob.attr.redeye         == EPS_APF_RDE_CORRECT  ) ) ){\r
3875     EPS_RETURN( EPS_ERR_INV_APF_RDE );\r
3876   }\r
3877 #endif\r
3878 \r
3879     printJob.bpp = 0;\r
3880   printJob.attr.paletteSize = 0;\r
3881   printJob.attr.paletteData = NULL;\r
3882 \r
3883   EPS_RETURN( EPS_ERR_NONE );\r
3884 }\r
3885 \r
3886 \r
3887 /*******************************************|********************************************/\r
3888 /*                                                                                      */\r
3889 /* Function name:   AddCmdBuff()                                                        */\r
3890 /*                                                                                      */\r
3891 /* Arguments                                                                            */\r
3892 /* ---------                                                                            */\r
3893 /* Name:      Type:               Description:                                    */\r
3894 /* pBuff            EPS_UINT8**         IO: pointer to command buffer                   */\r
3895 /* pPos             EPS_UINT8**         IO: pointer to append position                  */\r
3896 /* bufSize          EPS_UINT32*         IO: pointer to size of command buffer(pBuff)    */\r
3897 /* cmd              EPS_UINT8*          I : pointer to command                          */\r
3898 /* cmdSize          EPS_UINT32          I : size of command(cmd)                        */\r
3899 /*                                                                                      */\r
3900 /* Return value:                                                                        */\r
3901 /*      EPS_ERR_NONE                    - Success                                       */\r
3902 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
3903 /*                                                                                      */\r
3904 /* Description:                                                                         */\r
3905 /*      Append command to buffer. If the buffer is short, expand it.                    */\r
3906 /*                                                                                      */\r
3907 /*******************************************|********************************************/\r
3908 EPS_ERR_CODE AddCmdBuff(\r
3909               \r
3910     EPS_UINT8 **pBuff, \r
3911     EPS_UINT8 **pPos, \r
3912     EPS_UINT32 *bufSize, \r
3913     const EPS_UINT8 *cmd,\r
3914     EPS_UINT32 cmdSize\r
3915     \r
3916 ){\r
3917   EPS_UINT32  cmdPosDist = (EPS_UINT32)(*pPos - *pBuff);  /* command offset distance  */\r
3918 \r
3919   EPS_LOG_FUNCIN;\r
3920 \r
3921   EPS_MEM_GROW(EPS_UINT8*, *pBuff, bufSize, cmdPosDist + cmdSize )\r
3922 \r
3923   if(*pBuff != NULL){\r
3924     *pPos = *pBuff + cmdPosDist;\r
3925     memcpy(*pPos, cmd, cmdSize);\r
3926     *pPos += cmdSize;\r
3927     EPS_RETURN( EPS_ERR_NONE );\r
3928   } else{\r
3929     EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
3930   }\r
3931 }\r
3932 \r
3933 \r
3934 /*******************************************|********************************************/\r
3935 /*                                                                                      */\r
3936 /* Function name:   SendStartJob()                                                      */\r
3937 /*                                                                                      */\r
3938 /* Arguments                                                                            */\r
3939 /* ---------                                                                            */\r
3940 /* Name:      Type:               Description:                                    */\r
3941 /* bAddStartPage    EPS_BOOL            I: Append Start Page comannd                    */\r
3942 /*                                                                                      */\r
3943 /* Return value:                                                                        */\r
3944 /*      << Normal >>                                                                    */\r
3945 /*      EPS_ERR_NONE                    - Success                                       */\r
3946 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
3947 /*                                        (Do not return when Uni-Directional)          */\r
3948 /*      << Error >>                                                                     */\r
3949 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
3950 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
3951 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
3952 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
3953 /*                                                                                      */\r
3954 /* Description:                                                                         */\r
3955 /*      Send Start Job (&Page) commands.                                                */\r
3956 /*                                                                                      */\r
3957 /*******************************************|********************************************/\r
3958 EPS_ERR_CODE    SendStartJob (\r
3959 \r
3960         EPS_BOOL bAddStartPage \r
3961 \r
3962 ){\r
3963 /*** Declare Variable Local to Routine                                                  */\r
3964 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */\r
3965 EPS_UINT8*      pCmdPos = NULL;             /* Temporary buffer pointer                 */\r
3966 EPS_UINT32      retBufSize = 0;             /* Size of buffer written                   */\r
3967 \r
3968   EPS_LOG_FUNCIN;\r
3969 \r
3970   pCmdPos = sendDataBuf;\r
3971 \r
3972 /*======================================================================================*/\r
3973 /*** Initialize Printer and Set Printer in ESC/PR mode                                  */\r
3974 /*======================================================================================*/\r
3975 #define SendStartJob_ADDCMD_LEN(CMD, EXPLEN) {                        \\r
3976     retStatus = AddCmdBuff(&sendDataBuf, &pCmdPos, &sendDataBufSize, CMD, sizeof(CMD)+EXPLEN);  \\r
3977     if(EPS_ERR_NONE != retStatus){                            \\r
3978       goto SendStartJob_END;                              \\r
3979     }                                         \\r
3980   }\r
3981 #define SendStartJob_ADDCMD(CMD) SendStartJob_ADDCMD_LEN(CMD, 0)\r
3982 \r
3983   /*** Exit Packet Mode                                                               */\r
3984   SendStartJob_ADDCMD(ExitPacketMode)\r
3985 \r
3986   /*** Initialize Printer                                                             */\r
3987   SendStartJob_ADDCMD(InitPrinter)\r
3988 \r
3989   /*** Enter Remote Mode                                                              */\r
3990   SendStartJob_ADDCMD(EnterRemoteMode)\r
3991 \r
3992   /*** Remote Command - TI                                                            */\r
3993   if(epsCmnFnc.getLocalTime){\r
3994     SendStartJob_ADDCMD(RemoteTI)\r
3995     MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));\r
3996   }\r
3997 \r
3998   /*** Remote Command - JS                                                            */\r
3999   SendStartJob_ADDCMD(RemoteJS)\r
4000 \r
4001   /*** Remote Command - JH                                                            */\r
4002   SendStartJob_ADDCMD(RemoteJH)\r
4003 \r
4004   /*** Remote Command - HD                                                            */\r
4005   SendStartJob_ADDCMD(RemoteHD)\r
4006   *(pCmdPos - sizeof(RemoteHD) + 6) = printJob.platform;\r
4007 \r
4008   /*** Remote Command - PP                                                            */\r
4009   SendStartJob_ADDCMD(RemotePP)\r
4010   pCmdPos -= sizeof(RemotePP);\r
4011   switch(printJob.attr.paperSource){\r
4012   case EPS_MPID_REAR:\r
4013     pCmdPos[5] = 0x01; pCmdPos[6] = 0x00; \r
4014     break;\r
4015   case EPS_MPID_FRONT1:\r
4016     pCmdPos[5] = 0x01; pCmdPos[6] = 0x01; \r
4017     break;\r
4018   case EPS_MPID_FRONT2:\r
4019     pCmdPos[5] = 0x01; pCmdPos[6] = 0x02;\r
4020     break;\r
4021   case EPS_MPID_CDTRAY:\r
4022     pCmdPos[5] = 0x02; pCmdPos[6] = 0x01; \r
4023     break;\r
4024 \r
4025   case EPS_MPID_AUTO:\r
4026   default:\r
4027     if( EPS_CP_JPEG == printJob.attr.colorPlane &&\r
4028       EPS_IS_CDDVD(printJob.attr.mediaTypeIdx) ){\r
4029       /* Jpeg CD print need PP  */\r
4030       pCmdPos[5] = 0x02; pCmdPos[6] = 0x01; \r
4031     } else{\r
4032       EPS_DBGPRINT(("Paper Sourcr AutoSelect\n"));\r
4033       pCmdPos[5] = 0x01; pCmdPos[6] = 0xFF; /* auto select */\r
4034     }\r
4035     break;\r
4036   }\r
4037   pCmdPos += sizeof(RemotePP);\r
4038 \r
4039   /*** Remote Command - DP(duplex)                                                    */\r
4040   if(EPS_DUPLEX_NONE != printJob.attr.duplex){\r
4041     SendStartJob_ADDCMD(RemoteDP)\r
4042   }\r
4043 \r
4044   /*** Exit Remote Mode                                                               */\r
4045   SendStartJob_ADDCMD(ExitRemoteMode)\r
4046 \r
4047   /*** Enter ESC/P-R mode                                                             */\r
4048   if( EPS_CP_JPEG != printJob.attr.colorPlane ){  /* RGB  */\r
4049     SendStartJob_ADDCMD(ESCPRMode)\r
4050   } else{                                         /* JPEG */\r
4051     SendStartJob_ADDCMD(ESCPRModeJpg)\r
4052   }\r
4053 \r
4054   /*** ESC/PR "Print Quality" Command (Internal called Page Attributes)               */\r
4055   SendStartJob_ADDCMD_LEN(PrintQualityCmd, printJob.attr.paletteSize)\r
4056   MakeQualityCmd(pCmdPos - (sizeof(PrintQualityCmd) + printJob.attr.paletteSize) );\r
4057 \r
4058   /*** ESC/PR "apf setting" Command                                                   */\r
4059   if(EPS_CP_JPEG == printJob.attr.colorPlane){\r
4060     SendStartJob_ADDCMD(APFSettingCmd)\r
4061     MakeAPFCmd(pCmdPos-sizeof(APFSettingCmd));\r
4062   }\r
4063 \r
4064   /*** ESC/PR "Job" Command to Printer                                                */\r
4065   if( EPS_CP_JPEG != printJob.attr.colorPlane ){  /* RGB  */\r
4066     SendStartJob_ADDCMD(JobCmd)\r
4067     MakeJobCmd(pCmdPos-sizeof(JobCmd));\r
4068   } else{                                         /* JPEG */\r
4069     SendStartJob_ADDCMD(JobCmdJpg)\r
4070     MakeJobCmd(pCmdPos-sizeof(JobCmdJpg));\r
4071   }\r
4072 \r
4073   if(bAddStartPage){\r
4074     SendStartJob_ADDCMD(StartPage)\r
4075   }\r
4076 \r
4077   retStatus = SendCommand(sendDataBuf, (EPS_UINT32)(pCmdPos - sendDataBuf), &retBufSize, TRUE);\r
4078 \r
4079 SendStartJob_END:\r
4080   if(EPS_ERR_NONE == retStatus){\r
4081     printJob.sendJS = TRUE;\r
4082   }\r
4083 \r
4084     /*** Return to Caller                                                               */\r
4085     EPS_RETURN( retStatus );\r
4086 }\r
4087 \r
4088 \r
4089 /*======================================================================================*/\r
4090 /*** Set up Remote "TI" Command                                                         */\r
4091 /*======================================================================================*/\r
4092 static void    MakeRemoteTICmd (\r
4093 \r
4094         EPS_UINT8*    pBuf\r
4095 \r
4096 ){\r
4097 /*** Declare Variable Local to Routine                                                  */\r
4098 EPS_LOCAL_TIME  locTime;\r
4099 EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */\r
4100 \r
4101   EPS_LOG_FUNCIN;\r
4102 \r
4103   /* Get platform local time */\r
4104   epsCmnFnc.getLocalTime(&locTime);\r
4105 \r
4106   /*** Skip Header                                                                    */\r
4107   pBuf += REMOTE_HEADER_LENGTH;\r
4108     \r
4109   /*** Set Attributes/Values                                                          */\r
4110   memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, locTime.year, array2);\r
4111   memcpy(pBuf, array2, sizeof(array2));\r
4112   pBuf += sizeof(array2);\r
4113   *pBuf++ = locTime.mon;\r
4114   *pBuf++ = locTime.day;\r
4115   *pBuf++ = locTime.hour;\r
4116   *pBuf++ = locTime.min;\r
4117   *pBuf   = locTime.sec;\r
4118 \r
4119   EPS_RETURN_VOID;\r
4120 }\r
4121 \r
4122 \r
4123 /*======================================================================================*/\r
4124 /*** Set up ESC/PR "Print Quality" Command                                              */\r
4125 /*======================================================================================*/\r
4126 static void    MakeQualityCmd (\r
4127 \r
4128         EPS_UINT8*    pBuf\r
4129 \r
4130 ){\r
4131 /*** Declare Variable Local to Routine                                                  */\r
4132 EPS_UINT8*      pCmdPosTmp = NULL;\r
4133 EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */\r
4134 EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */\r
4135 \r
4136   EPS_LOG_FUNCIN;\r
4137 \r
4138   /*** Parameter Length                                                               */\r
4139   if(printJob.attr.paletteSize > 0){\r
4140     pCmdPosTmp = pBuf + ESCPR_CLASS_LENGTH;\r
4141     memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, \r
4142           ESCPR_PRINT_QUALITY_LENGTH + printJob.attr.paletteSize, array4);\r
4143     memcpy(pCmdPosTmp, array4, sizeof(array4));\r
4144   }\r
4145 \r
4146   pBuf += ESCPR_HEADER_LENGTH;\r
4147 \r
4148   /*** Set Attributes/Values                                                          */\r
4149   *pBuf++ = (EPS_UINT8)printJob.attr.mediaTypeIdx;\r
4150   switch( printJob.attr.printQuality ){\r
4151     case EPS_MQID_DRAFT:\r
4152       *pBuf++ = 0;\r
4153       break;\r
4154     case EPS_MQID_HIGH:\r
4155       *pBuf++ = 2;\r
4156       break;\r
4157     case EPS_MQID_NORMAL:\r
4158     default:\r
4159       *pBuf++ = 1;\r
4160       break;\r
4161   }\r
4162   *pBuf++ = printJob.attr.colorMode;\r
4163   *pBuf++ = (EPS_UINT8)printJob.attr.brightness;\r
4164   *pBuf++ = (EPS_UINT8)printJob.attr.contrast;\r
4165   *pBuf++ = (EPS_UINT8)printJob.attr.saturation;\r
4166   *pBuf++ = printJob.attr.colorPlane;\r
4167     \r
4168   memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, printJob.attr.paletteSize, array2);\r
4169   memcpy(pBuf, array2, sizeof(array2));\r
4170 \r
4171   if (printJob.attr.paletteSize > 0){\r
4172     pBuf += sizeof(array2);\r
4173     memcpy(pBuf, printJob.attr.paletteData, printJob.attr.paletteSize);\r
4174   }\r
4175 \r
4176   EPS_RETURN_VOID;\r
4177 }\r
4178 \r
4179 \r
4180 /*======================================================================================*/\r
4181 /*** Set up ESC/PR "APF setting" Command                                                */\r
4182 /*======================================================================================*/\r
4183 static void    MakeAPFCmd (\r
4184 \r
4185         EPS_UINT8*    pBuf\r
4186 \r
4187 ){\r
4188   EPS_LOG_FUNCIN;\r
4189 \r
4190   /*** Skip Header                                                                    */\r
4191     pBuf += ESCPR_HEADER_LENGTH;\r
4192 \r
4193   /*** Set Attributes/Values                                                          */\r
4194   *pBuf++ = printJob.attr.colorMode;\r
4195   *pBuf++ = printJob.attr.apfAutoCorrect;\r
4196   *pBuf++ = printJob.attr.sharpness;\r
4197   *pBuf++ = printJob.attr.redeye;\r
4198 \r
4199   EPS_RETURN_VOID;\r
4200 }\r
4201 \r
4202 \r
4203 /*======================================================================================*/\r
4204 /*** Set up ESC/PR "Job" Command                                                        */\r
4205 /*======================================================================================*/\r
4206 static void    MakeJobCmd (\r
4207 \r
4208         EPS_UINT8*    pBuf\r
4209 \r
4210 ){\r
4211 /*** Declare Variable Local to Routine                                                  */\r
4212 EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */\r
4213 EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */\r
4214 \r
4215   EPS_LOG_FUNCIN;\r
4216 \r
4217   /*** Skip Header                                                                    */\r
4218     pBuf += ESCPR_HEADER_LENGTH;\r
4219 \r
4220   if( EPS_CP_JPEG != printJob.attr.colorPlane ){  /* RGB  */\r
4221     /*EPS_DBGPRINT(("(%d, %d) / (%d, %d) / (%d, %d)\n",\r
4222        printJob.paperWidth, printJob.paperHeight,\r
4223        printJob.topMargin, printJob.leftMargin,\r
4224        printJob.printableAreaWidth, printJob.printableAreaHeight))*/\r
4225     /*** Set Attributes/Values                                                      */\r
4226     memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, (EPS_UINT32)printJob.paperWidth, array4);\r
4227     memcpy(pBuf, array4, sizeof(array4));\r
4228     pBuf += sizeof(array4);\r
4229     memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, (EPS_UINT32)printJob.paperHeight, array4);\r
4230     memcpy(pBuf, array4, sizeof(array4));\r
4231     pBuf += sizeof(array4);\r
4232     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)printJob.topMargin, array2);\r
4233     memcpy(pBuf, array2, sizeof(array2));\r
4234     pBuf += sizeof(array2);\r
4235     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)printJob.leftMargin, array2);\r
4236     memcpy(pBuf, array2, sizeof(array2));\r
4237     pBuf += sizeof(array2);\r
4238     memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, printJob.printableAreaWidth, array4);\r
4239     memcpy(pBuf, array4, sizeof(array4));\r
4240     pBuf += sizeof(array4);\r
4241     memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, printJob.printableAreaHeight, array4);\r
4242     memcpy(pBuf, array4, sizeof(array4));\r
4243     pBuf += sizeof(array4);\r
4244     switch( printJob.attr.inputResolution ){\r
4245     case EPS_IR_720X720:\r
4246       *pBuf++ = 0x01;\r
4247       break;\r
4248     case EPS_IR_300X300:\r
4249       *pBuf++ = 0x02;\r
4250       break;\r
4251     case EPS_IR_600X600:\r
4252       *pBuf++ = 0x03;\r
4253       break;\r
4254     case EPS_IR_1200X1200:\r
4255       *pBuf++ = 0x04;\r
4256       break;\r
4257     case EPS_IR_360X360:\r
4258     default:\r
4259       *pBuf++ = 0x00;\r
4260       break;\r
4261     }\r
4262     *pBuf   = printJob.attr.printDirection;\r
4263 \r
4264   } else{                       /* JPEG  */\r
4265     /*** Set Attributes/Values                                                      */\r
4266     *pBuf++ = (EPS_UINT8)printJob.attr.mediaSizeIdx;\r
4267     if( EPS_IS_CDDVD( printJob.attr.mediaTypeIdx ) ){\r
4268       *pBuf++ = 0x0A;\r
4269     } else{\r
4270       switch( printJob.attr.printLayout ){\r
4271       case EPS_MLID_BORDERLESS:\r
4272         *pBuf++ = 0x01;\r
4273         break;\r
4274       case EPS_MLID_CDLABEL:\r
4275         *pBuf++ = 0x0A;\r
4276         break;\r
4277       case EPS_MLID_DIVIDE16:\r
4278         *pBuf++ = 0x90;\r
4279         break;\r
4280       default: /* FIXED, CUSTOM */\r
4281         *pBuf++ = 0x00;\r
4282       }\r
4283     }\r
4284     *pBuf++ = printJob.attr.cdDimIn;\r
4285     *pBuf++ = printJob.attr.cdDimOut;\r
4286     *pBuf   = printJob.attr.printDirection;\r
4287   }\r
4288 \r
4289   EPS_RETURN_VOID;\r
4290 }\r
4291 \r
4292 \r
4293 /*******************************************|********************************************/\r
4294 /*                                                                                      */\r
4295 /* Function name:   SendEndJob()                                                        */\r
4296 /*                                                                                      */\r
4297 /* Arguments                                                                            */\r
4298 /* ---------                                                                            */\r
4299 /* Name:        Type:               Description:                                        */\r
4300 /* bAddEndPage  EPS_BOOL            I: Append End Page comannd                          */\r
4301 /*                                                                                      */\r
4302 /* Return value:                                                                        */\r
4303 /*      << Normal >>                                                                    */\r
4304 /*      EPS_ERR_NONE                    - Success                                       */\r
4305 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
4306 /*                                        (Do not return when Uni-Directional)          */\r
4307 /*      << Error >>                                                                     */\r
4308 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
4309 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
4310 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
4311 /*                                                                                      */\r
4312 /* Description:                                                                         */\r
4313 /*      Send End Page commands.                                                         */\r
4314 /*                                                                                      */\r
4315 /*******************************************|********************************************/\r
4316 EPS_ERR_CODE    SendEndJob (\r
4317 \r
4318         EPS_BOOL bAddEndPage\r
4319 \r
4320 ){\r
4321 /*** Declare Variable Local to Routine                                                  */\r
4322 EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */\r
4323 EPS_UINT8*      pCmdPos = NULL;\r
4324 EPS_UINT32      retBufSize;                         /* Size of buffer written           */\r
4325 \r
4326   EPS_LOG_FUNCIN\r
4327 \r
4328   EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, \r
4329         (sizeof(EndPage)+ sizeof(EndJob) + sizeof(InitPrinter)\r
4330         + sizeof(EnterRemoteMode) + sizeof(RemoteLD) + sizeof(RemoteJE)+ sizeof(ExitRemoteMode)))\r
4331   if(NULL == sendDataBuf){\r
4332     EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )\r
4333   }\r
4334 \r
4335   pCmdPos = sendDataBuf;\r
4336 \r
4337   if(bAddEndPage){\r
4338     memcpy(pCmdPos, EndPage, sizeof(EndPage));\r
4339     pCmdPos[10] = EPS_END_PAGE;\r
4340     pCmdPos += sizeof(EndPage);\r
4341   }\r
4342 \r
4343   /*** End Job                                                                        */\r
4344   memcpy(pCmdPos, EndJob, sizeof(EndJob));\r
4345   pCmdPos += sizeof(EndJob);\r
4346 \r
4347   /*** Initialize                                                                     */\r
4348   memcpy(pCmdPos, InitPrinter, sizeof(InitPrinter));\r
4349   pCmdPos += sizeof(InitPrinter);\r
4350 \r
4351   memcpy(pCmdPos, EnterRemoteMode, sizeof(EnterRemoteMode));\r
4352   pCmdPos += sizeof(EnterRemoteMode);\r
4353 \r
4354   if(EPS_DUPLEX_NONE != printJob.attr.duplex){\r
4355     memcpy(pCmdPos, RemoteLD, sizeof(RemoteLD));\r
4356     pCmdPos += sizeof(RemoteLD);\r
4357   }\r
4358 \r
4359   /*** Remote Command - JE                                                            */\r
4360   memcpy(pCmdPos, RemoteJE, sizeof(RemoteJE));\r
4361   pCmdPos += sizeof(RemoteJE);\r
4362 \r
4363     /*** Exit Remote Mode                                                               */\r
4364   memcpy(pCmdPos, ExitRemoteMode, sizeof(ExitRemoteMode));\r
4365   pCmdPos += sizeof(ExitRemoteMode);\r
4366 \r
4367   retStatus = SendCommand(sendDataBuf, (EPS_UINT32)(pCmdPos - sendDataBuf), &retBufSize, TRUE);\r
4368 \r
4369   if(EPS_JOB_CANCELED == retStatus){\r
4370     retStatus = EPS_ERR_NONE;\r
4371   }\r
4372 \r
4373   /*printJob.sendJS = FALSE;*/\r
4374 \r
4375     /*** Return to Caller                                                               */\r
4376     EPS_RETURN( retStatus );\r
4377 }\r
4378 \r
4379 \r
4380 /*******************************************|********************************************/\r
4381 /*                                                                                      */\r
4382 /* Function name:   SendCommand()                                                       */\r
4383 /*                                                                                      */\r
4384 /* Arguments                                                                            */\r
4385 /* ---------                                                                            */\r
4386 /* Name:        Type:               Description:                                        */\r
4387 /* Buffer       EPS_INT8*           I: Print Data Buffer                                */\r
4388 /* BuffLen      EPS_UINT32          I: Print Data Buffer Size                           */\r
4389 /* pSize        EPS_UINT32          O: Actual Length Transferred                        */\r
4390 /*                                                                                      */\r
4391 /* Return value:                                                                        */\r
4392 /*      EPS_ERR_NONE                    - Sent the data successfully                    */\r
4393 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
4394 /*                                        (Do not return when Uni-Directional)          */\r
4395 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
4396 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
4397 /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */\r
4398 /*                                                                                      */\r
4399 /* Description:                                                                         */\r
4400 /*      Send print data to the active printer                                           */\r
4401 /*                                                                                      */\r
4402 /*******************************************|********************************************/\r
4403 EPS_ERR_CODE  SendCommand (\r
4404 \r
4405         const EPS_UINT8*    Buffer,\r
4406         EPS_UINT32          BuffLen,\r
4407         EPS_UINT32*         pSize,\r
4408         EPS_BOOL            bSave\r
4409 \r
4410 ){\r
4411 \r
4412 #ifdef EPS_FILTER\r
4413   //long int i;\r
4414   EPS_UINT32 i;\r
4415   FILE* outfp = stdout;\r
4416   for (i = 0; i < BuffLen; i++){\r
4417     putc(*(Buffer + i), outfp);\r
4418   }\r
4419   *pSize = BuffLen;\r
4420   return EPS_ERR_NONE;\r
4421 #endif  \r
4422 /*** Declare Variable Local to Routine                                                  */\r
4423     EPS_ERR_CODE  Ret = EPS_ERR_NONE;\r
4424     EPS_INT32  retStatus;\r
4425     EPS_UINT32 sendSize;\r
4426     EPS_UINT32 sentSize;\r
4427   EPS_INT32  nRetry = 0;\r
4428   EPS_UINT32 tmStart, tmNow, tmSpan;\r
4429     EPS_INT32  nDlySpan = 10;       /* first 10 ms */\r
4430     EPS_INT32  nDlyTotal = EPS_TIMEOUT_SEC; /* total 1000 ms */\r
4431 \r
4432   EPS_LOG_FUNCIN;\r
4433 \r
4434 /*** Validate input parameters                                                          */\r
4435     if ((Buffer  == NULL) || (BuffLen == 0))\r
4436         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
4437 \r
4438 /*** Initialize Global/Local Variables                                                  */\r
4439     retStatus = EPS_ERR_NONE;\r
4440     sentSize  = 0;\r
4441     sendSize  = BuffLen;\r
4442     *pSize    = 0;\r
4443 \r
4444   tmStart = tmNow = tmSpan = 0;\r
4445 \r
4446   if( FALSE == printJob.bComm){\r
4447     EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
4448   }\r
4449 \r
4450   if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){\r
4451 /***------------------------------------------------------------------------------------*/\r
4452 /*** Bi-Directional Mode                                                                */\r
4453 /***------------------------------------------------------------------------------------*/\r
4454   /*** If printer reset command was already sent, don't send command any more.        */\r
4455   /*** When paper jam error happened, don't send command any more.                    */\r
4456   /*** "transmittable == FLSE" means "paper jam error happened".                      */\r
4457     if( printJob.resetSent == EPS_RESET_SENT || TRUE == printJob.resetReq ){\r
4458       EPS_RETURN( EPS_JOB_CANCELED );\r
4459     } else if(FALSE == printJob.transmittable){\r
4460       EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
4461     }\r
4462         \r
4463   /*** Send command                                                                   */\r
4464     if(epsCmnFnc.getTime){\r
4465       tmStart = epsCmnFnc.getTime();\r
4466       tmNow = tmSpan = 0;\r
4467     }\r
4468 \r
4469     while(nDlyTotal > 0){\r
4470       if(gStatusCount == EPS_ROOP_NUM){\r
4471         gStatusCount = 0;\r
4472         if ((Ret = MonitorStatus(NULL) ) != EPS_ERR_NONE){\r
4473           EPS_DBGPRINT(("MonitorStatus=%d\n", Ret));\r
4474 \r
4475           if(Ret == EPS_JOB_CANCELED){\r
4476             EPS_RETURN( Ret );\r
4477           } else if(Ret == EPS_ERR_COMM_ERROR){\r
4478             EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
4479           } else {\r
4480             /*anoter error*/\r
4481             if ( EPS_PROTOCOL_USB & printJob.printer->protocol ){\r
4482               break;\r
4483             } else{\r
4484               /* Net continue to buffer full. */\r
4485             }\r
4486 \r
4487           } \r
4488         }\r
4489       }\r
4490       gStatusCount++;\r
4491 \r
4492       Ret = jobFnc.WriteData(Buffer, sendSize, &sentSize);\r
4493       *pSize += sentSize;\r
4494 #ifdef LCOMSW_CMDDMP\r
4495   EPS_DF_WRITE(Buffer, sentSize)\r
4496 #endif\r
4497 \r
4498       if (Ret != EPS_ERR_NONE){\r
4499         if (Ret == EPS_JOB_CANCELED) {\r
4500           /* UPnP Job turned idle */\r
4501           printJob.resetReq = TRUE;\r
4502           EPS_RETURN( Ret );\r
4503         } else if (Ret != EPS_COM_TINEOUT){\r
4504           EPS_DBGPRINT(("PRINT--> Print Failed [%d]\r\n",Ret));\r
4505           EPS_RETURN( EPS_ERR_COMM_ERROR );\r
4506         } else if(sendSize > sentSize){\r
4507           Buffer  += sentSize;\r
4508           sendSize -= sentSize;\r
4509         }\r
4510       } else if (sendSize > sentSize){     /* CBT returned OK, but size is less */\r
4511         Ret = EPS_COM_TINEOUT;\r
4512         Buffer  += sentSize;\r
4513         sendSize -= sentSize;\r
4514       } else {\r
4515         sendSize -= sentSize;\r
4516         break;\r
4517       }\r
4518   \r
4519       if( !(EPS_PROTOCOL_USB & printJob.printer->protocol)\r
4520         || NULL == epsCmnFnc.getTime ){\r
4521         /* The count is made an upper bound. */\r
4522         if(nRetry++ > EPS_TIMEOUT_NUM){\r
4523           break;\r
4524         }\r
4525       } else{\r
4526         /* The elapsed time is made an upper bound. */\r
4527         tmNow = epsCmnFnc.getTime();\r
4528         tmSpan = (EPS_UINT32)(tmNow - tmStart);\r
4529         if( tmSpan >= EPS_TIMEOUT_SEC ){\r
4530           break;\r
4531         }\r
4532 \r
4533         /* Wait */\r
4534         nDlyTotal -= nDlySpan;\r
4535         if(nDlySpan < 200){\r
4536           nDlySpan += nDlySpan/2;\r
4537           if(nDlySpan > 200){\r
4538             nDlySpan = 200;   /* max 200ms */\r
4539           }\r
4540         }\r
4541         serDelayThread(nDlySpan, &epsCmnFnc);\r
4542       }\r
4543     }\r
4544 \r
4545     if(0 < sendSize){\r
4546       if(TRUE == bSave){\r
4547         /* save the leftovers */\r
4548         /*EPS_DBGPRINT(("%d / Save %d byte\r\n", Ret, sendSize));*/\r
4549         printJob.contData.sendDataSize = sendSize;\r
4550         printJob.contData.sendData = Buffer;\r
4551       }\r
4552 \r
4553       Ret = MonitorStatus(NULL);\r
4554       if (Ret == EPS_JOB_CANCELED) {\r
4555         EPS_RETURN( Ret );\r
4556       } else{\r
4557         EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
4558       }\r
4559     } else{\r
4560       printJob.contData.sendDataSize = 0;\r
4561     }\r
4562 \r
4563     if(Ret != EPS_ERR_NONE){\r
4564       EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );\r
4565     }\r
4566 \r
4567   } else{\r
4568 /***------------------------------------------------------------------------------------*/\r
4569 /*** Uni-Directional Communication Mode                                                 */\r
4570 /***------------------------------------------------------------------------------------*/\r
4571     retStatus = jobFnc.WriteData(Buffer, BuffLen, &sentSize);\r
4572 \r
4573         if ((retStatus == 0) && (sendSize == sentSize)) {\r
4574             *pSize = sentSize;\r
4575         } else {\r
4576             EPS_RETURN( EPS_ERR_COMM_ERROR );\r
4577         }\r
4578   }\r
4579 \r
4580 /*** Return to Caller                                                                   */\r
4581     EPS_RETURN( EPS_ERR_NONE );\r
4582 }\r
4583 \r
4584 \r
4585 /*******************************************|********************************************/\r
4586 /*                                                                                      */\r
4587 /* Function name:     AdjustBasePoint()                                                 */\r
4588 /*                                                                                      */\r
4589 /* Arguments                                                                            */\r
4590 /* ---------                                                                            */\r
4591 /* Name:        Type:               Description:                                        */\r
4592 /* N/A          void                N/A                                                 */\r
4593 /*                                                                                      */\r
4594 /* Return value:    N/A                                                                 */\r
4595 /*                                                                                      */\r
4596 /* Description:     Change the base point setting and the printable area value for      */\r
4597 /*                  the custum border mode.                                             */\r
4598 /*                                                                                      */\r
4599 /*******************************************|********************************************/\r
4600 static void     AdjustBasePoint (\r
4601 \r
4602         void\r
4603 \r
4604 ){\r
4605     /* temporary variables for max PAW/PAL */\r
4606     EPS_UINT32  maxPAWidthBorder;\r
4607     EPS_UINT32  maxPAHeightBorder;\r
4608     EPS_UINT32  RightMargin;\r
4609     EPS_UINT32  BottomMargin;\r
4610     \r
4611   EPS_LOG_FUNCIN;\r
4612     \r
4613     printJob.offset_x = 0;\r
4614     printJob.offset_y = 0;\r
4615 \r
4616 /*** Adjust the base point for custum border printing mode                              */\r
4617 /*** (In case that left margin = 42 and top margin = 42 are NOT inputed)                */\r
4618     if (printJob.borderlessMode == EPS_BORDER_CUSTOM) {\r
4619         if ( (printJob.attr.leftMargin > printJob.border.left) ||\r
4620              (printJob.attr.topMargin  > printJob.border.top )    ) {\r
4621 \r
4622             printJob.offset_x = (EPS_INT16)(printJob.attr.leftMargin - printJob.border.left);\r
4623             printJob.offset_y = (EPS_INT16)(printJob.attr.topMargin  - printJob.border.top);\r
4624 \r
4625             RightMargin  = printJob.paperWidth\r
4626                                 - printJob.attr.leftMargin - printJob.printableAreaWidth;\r
4627             BottomMargin = printJob.paperHeight\r
4628                                 - printJob.attr.topMargin  - printJob.printableAreaHeight;\r
4629 \r
4630             printJob.printableAreaWidth  = printJob.paperWidth\r
4631                                                 - printJob.border.left - RightMargin;\r
4632             printJob.printableAreaHeight = printJob.paperHeight\r
4633                                                 - printJob.border.top  - BottomMargin;\r
4634 \r
4635             printJob.leftMargin = (EPS_INT16)(printJob.border.left);\r
4636             printJob.topMargin  = (EPS_INT16)(printJob.border.top);\r
4637 \r
4638             /* max PAW/PAL */\r
4639             maxPAHeightBorder = (EPS_UINT32)(printJob.paperHeight \r
4640                                     - printJob.border.top  - printJob.border.bottom);\r
4641             maxPAWidthBorder  = (EPS_UINT32)(printJob.paperWidth \r
4642                                     - printJob.border.left - printJob.border.right);\r
4643 \r
4644             if (printJob.printableAreaHeight > maxPAHeightBorder) {\r
4645                 printJob.printableAreaHeight = maxPAHeightBorder;\r
4646             }\r
4647 \r
4648             if (printJob.printableAreaWidth > maxPAWidthBorder) {\r
4649                 printJob.printableAreaWidth = maxPAWidthBorder;\r
4650             }\r
4651         }\r
4652     }\r
4653 \r
4654   EPS_RETURN_VOID;\r
4655 }\r
4656 \r
4657 \r
4658 /*******************************************|********************************************/\r
4659 /*                                                                                      */\r
4660 /* Function name:   PrintLine()                                                         */\r
4661 /*                                                                                      */\r
4662 /* Arguments                                                                            */\r
4663 /* ---------                                                                            */\r
4664 /* Name:        Type:               Description:                                        */\r
4665 /* line         EPS_IMAGE*          I: Image Data Structure                             */\r
4666 /*                                                                                      */\r
4667 /* Return value:                                                                        */\r
4668 /*      EPS_ERR_NONE                    - Success                                       */\r
4669 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
4670 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
4671 /*                                        (Do not return when Uni-Directional)          */\r
4672 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
4673 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
4674 /*                                                                                      */\r
4675 /* Description:                                                                         */\r
4676 /*      Filter Print Raster Data.                                                       */\r
4677 /*                                                                                      */\r
4678 /*******************************************|********************************************/\r
4679 static EPS_ERR_CODE     PrintLine (\r
4680 \r
4681         EPS_IMAGE*  line\r
4682 \r
4683 ){\r
4684     EPS_RECT        AdjBandRec;     /* Rectangle after BasePointAdjustment              */\r
4685     EPS_BANDBMP     InBmp;          /* Input band data                                  */\r
4686 \r
4687   EPS_LOG_FUNCIN;\r
4688 \r
4689     /* Initialize input image structure */\r
4690     InBmp.bits       = line->data;\r
4691     InBmp.widthBytes = line->bytesPerLine;\r
4692 \r
4693     /* change rectangle due to base point adjustment */\r
4694     AdjBandRec.top    = line->rect.top    + printJob.offset_y;\r
4695     AdjBandRec.left   = line->rect.left   + printJob.offset_x;\r
4696     AdjBandRec.bottom = line->rect.bottom + printJob.offset_y;\r
4697     AdjBandRec.right  = line->rect.right  + printJob.offset_x;\r
4698 \r
4699     /* band is not visible */\r
4700     if ((EPS_UINT32)AdjBandRec.bottom > printJob.printableAreaHeight){\r
4701         EPS_RETURN( EPS_ERR_NONE );\r
4702     }\r
4703 \r
4704     if ((EPS_UINT32)AdjBandRec.right > printJob.printableAreaWidth){\r
4705         AdjBandRec.right = (EPS_INT32)printJob.printableAreaWidth;\r
4706     }\r
4707 \r
4708 #ifdef GCOMSW_CMD_ESCPAGE\r
4709   debug_msg("enable GCOMSW_CMD_ESCPAGE lable\n");\r
4710   if(EPS_LANG_ESCPR == printJob.printer->language ){\r
4711 #endif\r
4712     /*** ESC/P-R ***/\r
4713     EPS_RETURN( SendLine(&InBmp, &AdjBandRec) );\r
4714 #ifdef GCOMSW_CMD_ESCPAGE\r
4715   } else{\r
4716     /*** ESC/Page ***/\r
4717     EPS_RETURN( pageColorRow(&InBmp, &AdjBandRec) );\r
4718   }\r
4719 #endif\r
4720 \r
4721 }\r
4722 \r
4723 /*******************************************|********************************************/\r
4724 /*                                                                                      */\r
4725 /* Function name:   SendLine()                                                          */\r
4726 /*                                                                                      */\r
4727 /* Arguments                                                                            */\r
4728 /* ---------                                                                            */\r
4729 /* Name:        Type:               Description:                                        */\r
4730 /* pInBmp       const EPS_BANDBMP   I: [RGB] Image Data                                 */\r
4731 /* pBandRec     EPS_RECT            I: Band rectangle information                       */\r
4732 /*                                                                                      */\r
4733 /* Return value:                                                                        */\r
4734 /*      EPS_ERR_NONE                    - Sent the data successfully                    */\r
4735 /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */\r
4736 /*                                        (Do not return when Uni-Directional)          */\r
4737 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
4738 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
4739 /*                                                                                      */\r
4740 /* Description:                                                                         */\r
4741 /*      Send a line data to printer.                                                    */\r
4742 /*                                                                                      */\r
4743 /*******************************************|********************************************/\r
4744 static EPS_ERR_CODE     SendLine (\r
4745 \r
4746         const EPS_BANDBMP*  pInBmp,\r
4747         EPS_RECT*           pBandRec\r
4748         \r
4749 ){\r
4750 /*** Declare Variable Local to Routine                                                  */\r
4751     EPS_ERR_CODE    retStatus;                  /* Return status of internal calls          */\r
4752     EPS_UINT32      retBufSize;                 /* Size of buffer written                   */\r
4753     EPS_UINT32      cmdSize;                    /* All Size of Print Job Command            */\r
4754     EPS_UINT32      cpyCount;                   /* Counter for Set Command                  */\r
4755     EPS_UINT16      compDataSize;               /* Raster Data Size                         */\r
4756     EPS_UINT16      linePixelSize;              /* Raster Pixel Size                        */\r
4757     EPS_UINT8       compFlag;                   /* Compression flg (1:done compression  0:undone compression) */\r
4758     EPS_UINT32      paramSize;                  /* Parameter Length                         */\r
4759     EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */\r
4760     EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */\r
4761     EPS_UINT8*      compData;                   /* Compression Data Pointer                 */\r
4762     EPS_UINT8*      sdBuf;                      /* Send Data Buffer Pointer                 */\r
4763   const EPS_UINT8* srcAddr;\r
4764     \r
4765 #if LCOMSW_PACKET_4KB\r
4766     EPS_INT32       rest_size;\r
4767     EPS_INT32       idx;\r
4768 #endif\r
4769 \r
4770   EPS_LOG_FUNCIN;\r
4771 \r
4772 /*** Initialize Local Variables                                                         */\r
4773     compFlag = EPS_RLE_COMPRESS_DONE;\r
4774 \r
4775 /*** Initialize global valiable                                                         */\r
4776     memset(sendDataBuf, 0xFF, (EPS_UINT32)sendDataBufSize);\r
4777     memset(tmpLineBuf,  0xFF, (EPS_UINT32)tmpLineBufSize );\r
4778 \r
4779 /*** Initialize valiable                                                                */\r
4780     sdBuf    = sendDataBuf;\r
4781     compData = tmpLineBuf;\r
4782 \r
4783 /*    EPS_DBGPRINT(("MakeOneRasterData: T,B,L,R [%d,%d,%d,%d]\r\n", \r
4784             pBandRec->top, pBandRec->bottom, pBandRec->left, pBandRec->right));\r
4785 */\r
4786     if( (EPS_UINT32)(pBandRec->right - pBandRec->left) <= printJob.printableAreaWidth){\r
4787         linePixelSize = (EPS_UINT16)(pBandRec->right - pBandRec->left);\r
4788     } else{\r
4789         linePixelSize = (EPS_UINT16) printJob.printableAreaWidth;\r
4790     }\r
4791 \r
4792 #if ESCPR_DEBUG_IMAGE_LOG\r
4793     EPS_DBGPRINT(("ESCPRCMD : ImageData\r\n")\r
4794   EPS_DUMP(pInBmp->bits, (pBandRec->right - pBandRec->left) * 3)\r
4795 #endif\r
4796     \r
4797   /*** Layout Filter */\r
4798   if(EPS_MLID_CDLABEL == printJob.attr.printLayout){\r
4799 #ifdef GCOMSW_EL_CDLABEL\r
4800     elCDClipping(pInBmp->bits, sdBuf, printJob.bpp, pBandRec);\r
4801     srcAddr = sdBuf;\r
4802 #else\r
4803     srcAddr = pInBmp->bits;\r
4804 #endif\r
4805 \r
4806   } else{\r
4807     srcAddr = pInBmp->bits;\r
4808   }\r
4809 \r
4810   /*** RunLength Encode */\r
4811   compDataSize = RunLengthEncode(srcAddr,\r
4812                             compData,\r
4813                             linePixelSize,\r
4814                             printJob.bpp,\r
4815                             &compFlag);\r
4816 \r
4817   /* Set Parameter Length */\r
4818     paramSize = (EPS_UINT32)(ESCPR_SEND_DATA_LENGTH + compDataSize);\r
4819     cmdSize   = ESCPR_HEADER_LENGTH + paramSize;\r
4820     \r
4821 /*** Set Parameter                                                                      */\r
4822     cpyCount = 0;\r
4823     \r
4824     /* Header */\r
4825     memcpy(sdBuf, SendDataCmd, sizeof(SendDataCmd));\r
4826     cpyCount += sizeof(SendDataCmd);\r
4827     \r
4828     /* Parameter Length */\r
4829     memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, (EPS_UINT32)paramSize, array4);\r
4830     memcpy(sdBuf + cpyCount, array4, sizeof(array4));\r
4831     cpyCount += sizeof(array4);\r
4832     \r
4833     /* Command Name */\r
4834     memcpy(sdBuf + cpyCount, SendDataName, sizeof(SendDataName));\r
4835     cpyCount += sizeof(SendDataName);\r
4836     \r
4837     /* lXoffset */\r
4838     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)pBandRec->left, array2);\r
4839     memcpy((sdBuf + cpyCount), array2, sizeof(array2));\r
4840     cpyCount += sizeof(array2);\r
4841 \r
4842     /* lYoffset */\r
4843   memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)pBandRec->top, array2);\r
4844     memcpy((sdBuf + cpyCount), array2, sizeof(array2));\r
4845     cpyCount += sizeof(array2);\r
4846     \r
4847     /* Compression Mode */\r
4848     if(compFlag == EPS_RLE_COMPRESS_DONE){\r
4849         *(sdBuf + cpyCount) = EPS_COMP_RLE;\r
4850     } else{\r
4851         *(sdBuf + cpyCount) = EPS_COMP_NON;\r
4852     }\r
4853     cpyCount += sizeof(EPS_UINT8);\r
4854     \r
4855     /* Raster Data Size */\r
4856     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)compDataSize, array2);\r
4857     memcpy((sdBuf + cpyCount), array2, sizeof(array2));\r
4858     cpyCount += sizeof(array2);\r
4859     \r
4860     /* RGB Raster Data */\r
4861     memcpy((sdBuf + cpyCount), compData, compDataSize);\r
4862     cpyCount += compDataSize;\r
4863     \r
4864     if (cmdSize != cpyCount) {\r
4865         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
4866     }\r
4867     \r
4868     /* Send Print Quality Command to Printer */\r
4869 /*** -----------------------------------------------------*/\r
4870 #if LCOMSW_PACKET_4KB   /* Set 1 packett size in 4096byte */\r
4871 /*** -----------------------------------------------------*/\r
4872     if(cmdSize > ESCPR_PACKET_SIZE_4KB) {\r
4873         /* Send 4090 bytes Data                                                         */\r
4874         for(idx = 0; idx < (EPS_INT32)(cmdSize / ESCPR_PACKET_SIZE_4KB); idx++){\r
4875 \r
4876 #if ESCPR_DEBUG_IMAGE_LOG\r
4877       EPS_DUMP(sdBuf, ESCPR_PACKET_SIZE_4KB)\r
4878 #endif /*  ESCPR_DEBUG_IMAGE_LOG */\r
4879 \r
4880             retBufSize = 0;\r
4881 \r
4882             retStatus = SendCommand(sdBuf, ESCPR_PACKET_SIZE_4KB, &retBufSize, TRUE);\r
4883             if (!((retStatus == EPS_ERR_NONE) && (ESCPR_PACKET_SIZE_4KB == retBufSize))) {\r
4884                 EPS_RETURN( retStatus );\r
4885             }\r
4886             sdBuf += ESCPR_PACKET_SIZE_4KB;\r
4887         }\r
4888         \r
4889         /* Send Rest Data                                                               */\r
4890         rest_size  = cmdSize - ((EPS_INT32)(cmdSize / ESCPR_PACKET_SIZE_4KB)) * ESCPR_PACKET_SIZE_4KB;\r
4891         retBufSize = 0;\r
4892 \r
4893         retStatus = SendCommand(sdBuf, rest_size, &retBufSize, TRUE);\r
4894         if (!((retStatus == EPS_ERR_NONE) && (rest_size == retBufSize))) {\r
4895             EPS_RETURN( retStatus );\r
4896         }\r
4897 \r
4898 #if ESCPR_DEBUG_IMAGE_LOG\r
4899     EPS_DUMP(sdBuf, rest_size)\r
4900 #endif /*  ESCPR_DEBUG_IMAGE_LOG */\r
4901 \r
4902     } else /* if(cmdSize <= ESCPR_PACKET_SIZE_4KB) */{\r
4903 \r
4904 #if ESCPR_DEBUG_IMAGE_LOG\r
4905     EPS_DUMP(sdBuf, cmdSize)\r
4906 #endif /*  ESCPR_DEBUG_IMAGE_LOG */\r
4907 \r
4908         retBufSize = 0;\r
4909 \r
4910         retStatus = SendCommand(sdBuf, cmdSize, &retBufSize, TRUE);\r
4911         if (!((retStatus == EPS_ERR_NONE) && (cmdSize == retBufSize))) {\r
4912             EPS_RETURN( retStatus );\r
4913         }\r
4914 \r
4915     }\r
4916 \r
4917 /*** -----------------------------------------------------*/\r
4918 #else /*  LCOMSW_PACKET_4KB */\r
4919 /*** -----------------------------------------------------*/\r
4920 \r
4921 #if ESCPR_DEBUG_IMAGE_LOG\r
4922   EPS_DUMP(sdBuf, cpyCount)\r
4923 #endif /*  ESCPR_DEBUG_IMAGE_LOG */\r
4924 \r
4925     retBufSize = 0;\r
4926 \r
4927     retStatus = SendCommand(sdBuf, cmdSize, &retBufSize, TRUE);\r
4928     if (!((retStatus == EPS_ERR_NONE) && (cmdSize == retBufSize))) {\r
4929         EPS_RETURN( retStatus );\r
4930     }\r
4931 \r
4932 /*** -----------------------------------------------------*/\r
4933 #endif /* LCOMSW_PACKET_4KB */\r
4934 /*** -----------------------------------------------------*/\r
4935 \r
4936     EPS_RETURN( EPS_ERR_NONE );\r
4937 }\r
4938 \r
4939 \r
4940 /*******************************************|********************************************/\r
4941 /*                                                                                      */\r
4942 /* Function name:   RunLengthEncode()                                                   */\r
4943 /*                                                                                      */\r
4944 /* Arguments                                                                            */\r
4945 /* ---------                                                                            */\r
4946 /* Name:        Type:               Description:                                        */\r
4947 /* pSrcAddr     const EPS_UINT8*    I: An address of original raster                    */\r
4948 /* pDstAddr     EPS_UINT8*          O: An address of compressed raster                  */\r
4949 /* pixel        EPS_INT16           I: Original Raster Size                             */\r
4950 /* bpp          EPS_UINT8           I: Bytes Per Pixel                                  */\r
4951 /* pCompress    EPS_UINT8*          O: Compression Flag                                 */\r
4952 /*                                                                                      */\r
4953 /* Return value:                                                                        */\r
4954 /*      Compressed Data Size (byte)                                                     */\r
4955 /*                                                                                      */\r
4956 /* Description:                                                                         */\r
4957 /*      Runlength Compression for RGB Data.                                             */\r
4958 /*                                                                                      */\r
4959 /*******************************************|********************************************/\r
4960 static EPS_UINT16    RunLengthEncode (\r
4961 \r
4962         const EPS_UINT8*    pSrcAddr,\r
4963         EPS_UINT8*          pDstAddr,\r
4964         EPS_UINT16          pixel,\r
4965         EPS_UINT8           bpp,\r
4966         EPS_UINT8*          pCompress\r
4967 \r
4968 ){\r
4969   const EPS_UINT8* pSrcPos = pSrcAddr;           /* pointer to srcBuffer               */\r
4970   EPS_UINT8*   pDstPos     = pDstAddr;           /* pointer to destBuffer              */\r
4971     EPS_UINT16   srcCnt      = 0;                  /* counter                            */\r
4972     EPS_UINT16   repCnt      = 0;                  /* replay conter                      */\r
4973     EPS_UINT16   retCnt      = 0;                  /* conpressed data size               */\r
4974     EPS_UINT32   copySize    = 0;\r
4975     EPS_UINT16   widthPixels = pixel * bpp;\r
4976   EPS_BOOL     bCompress   = TRUE;\r
4977 \r
4978   EPS_LOG_FUNCIN;\r
4979 \r
4980     while (srcCnt < pixel) {\r
4981         /* In case of replay data                                                       */\r
4982         if ((srcCnt + 1 < pixel) && (!memcmp(pSrcPos, pSrcPos + bpp, bpp))) {\r
4983             repCnt = 2;\r
4984             while ((srcCnt + repCnt < pixel)                                              &&\r
4985                    (repCnt < 0x81)                                                        &&\r
4986                    (!memcmp(pSrcPos + (repCnt - 1) * bpp, pSrcPos + repCnt * bpp, bpp))    ) {\r
4987                 repCnt++;\r
4988             }\r
4989 \r
4990             /* Renewal compressed data size counter */\r
4991             retCnt += 1 + bpp;\r
4992 \r
4993       /* If compressed data size is bigger than original data size,               */\r
4994       /* stop compression process.                                                */\r
4995       if( retCnt > widthPixels ){\r
4996         bCompress  = FALSE;\r
4997         retCnt -= 1 + bpp;    /* rewind counter */\r
4998         break;\r
4999       }\r
5000 \r
5001       /* Set replay count and data                                                */\r
5002             /* Set data counter                     */\r
5003             *pDstPos++ = (EPS_UINT8)(0xFF - repCnt + 2 );\r
5004 \r
5005             /* Set data                             */\r
5006             memcpy(pDstPos, pSrcPos, bpp);\r
5007 \r
5008             /* Renewal data size counter            */\r
5009             srcCnt += repCnt;\r
5010 \r
5011             /* Renewal original data address        */\r
5012             pSrcPos += bpp * repCnt;\r
5013 \r
5014             /* Renewal compressed data address      */\r
5015             pDstPos += bpp;\r
5016         }\r
5017 \r
5018         /* In case of non replay data                                                   */\r
5019         else {\r
5020             copySize = 0;\r
5021             repCnt   = 1;\r
5022 \r
5023             /* compare next data with next and next data                                */\r
5024             while ((srcCnt + repCnt + 1< pixel)                                          &&\r
5025                    (repCnt < 0x80)                                                       &&\r
5026                    (memcmp(pSrcPos + repCnt * bpp, pSrcPos + (repCnt + 1) * bpp, bpp))    ){\r
5027                 repCnt++;\r
5028             }\r
5029             \r
5030             /* Renewal compressed data size counter */\r
5031             retCnt += 1 + repCnt * bpp;\r
5032 \r
5033       /* If compressed data size is bigger than original data size,               */\r
5034       /* stop compression process.                                                */\r
5035       if( retCnt > widthPixels ){\r
5036         bCompress  = FALSE;\r
5037         retCnt -= 1 + repCnt * bpp; /* rewind counter */\r
5038         break;\r
5039       }\r
5040 \r
5041       /* Set data counter                     */\r
5042             *pDstPos++ = (EPS_UINT8)(repCnt - 1);\r
5043 \r
5044             /* Renewal data size counter            */\r
5045 \r
5046             /* Size of non replay data (byte)       */\r
5047             srcCnt  += repCnt;\r
5048             copySize = (EPS_UINT32)(repCnt * bpp);\r
5049 \r
5050             /* Set data                             */\r
5051             memcpy(pDstPos, pSrcPos, copySize);\r
5052 \r
5053             /* Renewal original data address        */\r
5054             pSrcPos += copySize;\r
5055 \r
5056             /* Renewal compressed data address      */\r
5057             pDstPos += copySize;\r
5058         }\r
5059     }\r
5060 \r
5061 \r
5062   if(TRUE == bCompress){\r
5063       *pCompress = EPS_RLE_COMPRESS_DONE;\r
5064   } else{\r
5065     retCnt = widthPixels;\r
5066     memcpy(pDstAddr, pSrcAddr, widthPixels);\r
5067       *pCompress = EPS_RLE_COMPRESS_NOT_DONE;\r
5068   }\r
5069     \r
5070     EPS_RETURN( retCnt );\r
5071 }\r
5072 \r
5073 \r
5074 /*******************************************|********************************************/\r
5075 /*                                                                                      */\r
5076 /* Function name:   CreateMediaInfo()                                                   */\r
5077 /*                                                                                      */\r
5078 /* Arguments                                                                            */\r
5079 /* ---------                                                                            */\r
5080 /* Name:            Type:               Description:                  */\r
5081 /* innerPrinter     EPS_PRINTER_INN*    I: printer that it has original structure   */\r
5082 /* pmString     EPS_INT8*     I: PM reply string                */\r
5083 /* pmSize     EPS_INT32     I: size of PM reply string            */\r
5084 /*                                                                                      */\r
5085 /* Return value:                                                                        */\r
5086 /*      EPS_ERR_NONE                    - Success                                       */\r
5087 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
5088 /*      EPS_ERR_MEMORY_ALLOCATION       - Alloc memory failed                           */\r
5089 /*                                                                                      */\r
5090 /* Description:                                                                         */\r
5091 /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */\r
5092 /*                                                                                      */\r
5093 /*******************************************|********************************************/\r
5094 EPS_ERR_CODE    CreateMediaInfo(\r
5095   \r
5096     EPS_PRINTER_INN*  innerPrinter,\r
5097     EPS_UINT8*      pmString,\r
5098     EPS_INT32     pmSize\r
5099   \r
5100 ){\r
5101   EPS_ERR_CODE  retStatus = EPS_ERR_NONE;\r
5102     EPS_UINT8*      cmdField;                   /* Pointer of pm command field          */\r
5103     EPS_INT32       pmIdx;                      /* pm string index                      */\r
5104     EPS_UINT32      idx;                        /* Index                                */\r
5105     EPS_INT32       sIdx = 0;                   /* Media size index                     */\r
5106     EPS_INT32       tIdx = 0;                   /* Media type index                     */\r
5107     EPS_INT32       num_mType = 0;              /* Media type number                    */\r
5108     EPS_INT32       num_mSize = 0;              /* Media size number                    */\r
5109   EPS_BOOL    extPaper = FALSE;     /* extend paper source is exist         */\r
5110 \r
5111   EPS_LOG_FUNCIN;\r
5112 \r
5113   /*** Is this really "PM" data                                                       */\r
5114   cmdField = (EPS_UINT8*)strstr((const char*)pmString,"PM");\r
5115   if (cmdField == NULL ) {\r
5116     EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n",pmString));\r
5117     EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5118   }\r
5119 EPS_DUMP(pmString, 256);\r
5120 \r
5121 #if _VALIDATE_SUPPORTED_MEDIA_DATA_\r
5122   if(innerPrinter->supportedMedia.numSizes != -1){\r
5123     /*** "Filter" Raw "PM" data (Remake the correct pm stirng)                      */\r
5124     retStatus = _SP_ChangeSpec_UpdatePMReply(innerPrinter, pmString, pmSize);\r
5125     if (retStatus != EPS_ERR_NONE) {\r
5126       EPS_RETURN( retStatus );\r
5127     }\r
5128   }\r
5129 #else\r
5130 /*** "Filter" Raw "PM" data (Remake the correct pm stirng)                              */\r
5131     retStatus = _SP_ChangeSpec_UpdatePMReply(innerPrinter, pmString, pmSize);\r
5132     if (retStatus != EPS_ERR_NONE) {\r
5133         EPS_RETURN( EPS_ERR_OPR_FAIL );  /* Invalid format */\r
5134     }\r
5135 #endif\r
5136 \r
5137 /*** Create the structure of the support media                                          */\r
5138   innerPrinter->supportedMedia.resolution = EPS_IR_360X360; /* default support */\r
5139 \r
5140     /*** Count "Paper Size" field  & check format */\r
5141   pmIdx = EPS_PM_HEADER_LEN;        /* skip the command header of pm string     */\r
5142     while( pmIdx < EPS_PM_MAXSIZE ) {\r
5143         switch(pmString[pmIdx]) {\r
5144     case 'R':\r
5145       if( 720 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){\r
5146         innerPrinter->supportedMedia.resolution |= EPS_IR_720X720;\r
5147       } else if( 600 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){\r
5148         innerPrinter->supportedMedia.resolution |= EPS_IR_300X300 | EPS_IR_600X600 | EPS_IR_1200X1200;\r
5149       } else if( 300 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){\r
5150         innerPrinter->supportedMedia.resolution |= EPS_IR_300X300;\r
5151       }\r
5152       pmIdx += 6;\r
5153       break;\r
5154 \r
5155     case 'M':\r
5156       innerPrinter->supportedMedia.JpegSizeLimit = \r
5157         (pmString[pmIdx+1] << 24) + (pmString[pmIdx+2] << 16) + (pmString[pmIdx+3] << 8) + pmString[pmIdx+4]; \r
5158       innerPrinter->JpgMax = innerPrinter->supportedMedia.JpegSizeLimit;\r
5159       pmIdx += 6;\r
5160       break;\r
5161 \r
5162     case 'S':\r
5163       /* move T field */\r
5164       if(pmIdx < EPS_PM_MAXSIZE-2){\r
5165         pmIdx += 2;\r
5166       } else{\r
5167         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5168       }\r
5169 \r
5170       num_mSize++;\r
5171 \r
5172       for(; pmIdx < EPS_PM_MAXSIZE-4; pmIdx += 4) { /* 4 = T x x / */\r
5173         if(pmString[pmIdx] == '/'){\r
5174           pmIdx += 1;\r
5175           break;\r
5176         } else if(pmString[pmIdx] != 'T') {\r
5177           EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5178         }\r
5179       }\r
5180       if(pmIdx >= EPS_PM_MAXSIZE-4){\r
5181         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5182       }\r
5183       break;\r
5184 \r
5185     default:\r
5186       EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5187     }\r
5188 \r
5189     /* If we run into an occurrence of carriage return followed by line feed,\r
5190      * we have found the terminating characters of the string. */\r
5191     if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {\r
5192       break;\r
5193     }\r
5194   }                      \r
5195   if(pmIdx >= EPS_PM_MAXSIZE){\r
5196     EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5197   }\r
5198     \r
5199     /* Allocate memory for the media size list. */\r
5200     innerPrinter->supportedMedia.sizeList =\r
5201             (EPS_MEDIA_SIZE*)EPS_ALLOC( sizeof(EPS_MEDIA_SIZE) * num_mSize );   \r
5202     if( innerPrinter->supportedMedia.sizeList == NULL ){\r
5203         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
5204     }\r
5205   memset(innerPrinter->supportedMedia.sizeList, 0, sizeof(EPS_MEDIA_SIZE) * num_mSize);\r
5206     innerPrinter->supportedMedia.numSizes = num_mSize;\r
5207     \r
5208   pmIdx = EPS_PM_HEADER_LEN;        /* skip the command header of pm string     */\r
5209     for(sIdx = 0; sIdx < num_mSize; sIdx++) {\r
5210     if(pmString[pmIdx] == 'M' || pmString[pmIdx] == 'R') {\r
5211       pmIdx += 6;\r
5212       sIdx--;\r
5213       continue;\r
5214     }\r
5215 \r
5216         innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID = pmString[pmIdx+1];\r
5217 /*    EPS_DBGPRINT(("Size=%d\r\n", pmString[pmIdx+1]));*/\r
5218     pmIdx += 2;\r
5219 \r
5220         /* For the given paper type, iterate through the paper type to get the number\r
5221          * of media types contained in it */\r
5222         num_mType = 0;\r
5223     for(idx = pmIdx; idx < EPS_PM_MAXSIZE-4; idx += 4) {\r
5224       if(pmString[idx] == '/'){\r
5225         idx += 1;\r
5226         break;\r
5227       }\r
5228       num_mType++;\r
5229     }\r
5230 \r
5231         /* Allocate memory for the media type array. */\r
5232         innerPrinter->supportedMedia.sizeList[sIdx].typeList = \r
5233             (EPS_MEDIA_TYPE*)EPS_ALLOC( sizeof(EPS_MEDIA_TYPE) * num_mType );\r
5234         \r
5235         if (innerPrinter->supportedMedia.sizeList[sIdx].typeList == NULL) {\r
5236             EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
5237         }\r
5238         \r
5239     memset(innerPrinter->supportedMedia.sizeList[sIdx].typeList, 0, sizeof(EPS_MEDIA_TYPE) * num_mType);\r
5240         innerPrinter->supportedMedia.sizeList[sIdx].numTypes = num_mType;\r
5241 \r
5242     for(tIdx = 0; tIdx < num_mType; tIdx++) {\r
5243             innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].mediaTypeID       = pmString[pmIdx+1];\r
5244 /*            EPS_DBGPRINT(("\tType=%d (%02X)\r\n", pmString[pmIdx+1], pmString[pmIdx+2]));*/\r
5245                                \r
5246             /* Bitwise OR with 10000000 - Check for borderless */\r
5247             if( pmString[pmIdx+2] & 0x80 ){\r
5248                 innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].layout |= EPS_MLID_BORDERLESS;\r
5249             }\r
5250             /* Bitwise OR with 01000000 - Check for border "disable" mode */\r
5251             if( !(pmString[pmIdx+2] & 0x40) ){\r
5252         innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].layout |= EPS_MLID_BORDERS;\r
5253             }\r
5254 \r
5255             /* set quality */\r
5256             innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].quality |= (pmString[pmIdx+2] & EPS_MQID_ALL);\r
5257 \r
5258       /* set duplex */\r
5259             if( pmString[pmIdx+2] & 0x10 &&\r
5260         obsEnableDuplex(innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID) ){\r
5261         innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].duplex = EPS_DUPLEX_ENABLE;/*EPS_DUPLEX_SHORT*/;\r
5262       } else{\r
5263         innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].duplex = EPS_DUPLEX_DISABLE;\r
5264       }\r
5265 \r
5266       /* Bitwise OR with 00001000 - Check for extend paper source */\r
5267 #if _VALIDATE_SUPPORTED_MEDIA_DATA_\r
5268             if( pmString[pmIdx+2] & 0x08 ){\r
5269                 extPaper = TRUE;\r
5270       } else {\r
5271         /* DEFAULT. All printer support rear paper source */\r
5272         innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].paperSource = EPS_MPID_REAR;\r
5273       }\r
5274 \r
5275       /* param2 value check */\r
5276       if( !(pmString[pmIdx+2] & (0x01 | 0x02 | 0x04)) ){\r
5277         printf("\n\n!!!!!!!!!  Quality is not described. !!!!!!!!!\n"\r
5278             "SizeID=0x%02X / TypeID=0x%02X / param2=0x%02X\n", \r
5279             innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID,\r
5280             pmString[pmIdx+1], pmString[pmIdx+2]);\r
5281       } \r
5282       if( !(pmString[pmIdx+2] & 0x80) && (pmString[pmIdx+2] & 0x40) ){\r
5283         printf("\n\n!!!!!!!!!  Layout is not described. !!!!!!!!!\n"\r
5284             "SizeID=0x%02X / TypeID=0x%02X / param2=0x%02X\n", \r
5285             innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID,\r
5286             pmString[pmIdx+1], pmString[pmIdx+2]);\r
5287       }\r
5288 \r
5289 #else\r
5290             if( pmString[pmIdx+2] & 0x08 ){\r
5291                 extPaper = TRUE;\r
5292       }\r
5293       /* DEFAULT. All printer support rear paper source */\r
5294       innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].paperSource = EPS_MPID_REAR;\r
5295 #endif\r
5296       pmIdx += 4; /* move next field */\r
5297     }\r
5298     pmIdx += 1; /* skip terminater */\r
5299   }\r
5300 \r
5301 /*** Add extend infomation                                                              */\r
5302   if( EPS_ERR_NONE == retStatus && TRUE == extPaper ){\r
5303     retStatus = GetPaperSource(innerPrinter);\r
5304     if( EPS_ERR_NONE != retStatus){\r
5305       prtClearSupportedMedia(innerPrinter);\r
5306     }\r
5307   }\r
5308 \r
5309   serAppendMedia(&innerPrinter->supportedMedia);\r
5310 \r
5311   EPS_RETURN( retStatus );\r
5312 }\r
5313 \r
5314 \r
5315 /*******************************************|********************************************/\r
5316 /*                                                                                      */\r
5317 /* Function name:   GetPaperSource()                                                    */\r
5318 /*                                                                                      */\r
5319 /* Arguments                                                                            */\r
5320 /* ---------                                                                            */\r
5321 /* Name:            Type:                  Description:                                 */\r
5322 /* innerPrinter     EPS_PRINTER_INN*       I: printer that it has original structure    */\r
5323 /*                                                                                      */\r
5324 /* Return value:                                                                        */\r
5325 /*      EPS_ERR_NONE                    - Success                                       */\r
5326 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
5327 /*                                                                                      */\r
5328 /* Description:                                                                         */\r
5329 /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */\r
5330 /*                                                                                      */\r
5331 /*******************************************|********************************************/\r
5332 EPS_ERR_CODE    GetPaperSource(\r
5333   \r
5334     EPS_PRINTER_INN*    innerPrinter\r
5335   \r
5336 ){\r
5337   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
5338     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */\r
5339     EPS_INT32       pmSize = EPS_PM_MAXSIZE;\r
5340     EPS_UINT32      pmIdx;                      /* pm string index                      */\r
5341     EPS_INT32       sIdx = 0;                   /* Media size index                     */\r
5342     EPS_INT32       tIdx = 0;                   /* Media type index                     */\r
5343   EPS_MEDIA_SIZE  *pMSize = NULL;\r
5344 \r
5345   EPS_LOG_FUNCIN;\r
5346 \r
5347   /* Clear the Printer Model Information (Media data or "PM" data)                    */\r
5348     memset(pmString, 0, EPS_PM_MAXSIZE);\r
5349 \r
5350 /*** Get PM2 from Printer                                                               */\r
5351   ret = prtGetPMString(innerPrinter, 2, pmString, &pmSize);\r
5352   if(ret == EPS_ERR_PROTOCOL_NOT_SUPPORTED){\r
5353     EPS_RETURN( EPS_ERR_NONE );\r
5354   } else if(ret != EPS_ERR_NONE){\r
5355     EPS_RETURN( ret );\r
5356   }\r
5357 \r
5358   /*** Is this really "PM" data                                                       */\r
5359   if( strstr((const char*)pmString, "PM") == NULL ) {\r
5360     EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n", pmString));\r
5361     EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5362   }\r
5363 \r
5364   /* Delete the command header of pm string                                           */\r
5365   pmIdx = EPS_PM_HEADER_LEN;        /* skip the command header of pm string     */\r
5366 \r
5367 /*** Check to make sure the PM reply has a valid beginning                              */\r
5368     if(pmString[pmIdx] != 'S' && pmString[pmIdx+2] != 'T') {\r
5369         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5370     }\r
5371     \r
5372 /*** Create the structure of the support media                                          */\r
5373     /*** Count "Paper Size" field  & check format */\r
5374     for(; pmIdx < EPS_PM_MAXSIZE-7; ) {   /* 7 = S x T x x // */\r
5375         if(pmString[pmIdx] != 'S') {\r
5376       EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5377     }\r
5378     \r
5379     /* search size ID */\r
5380     pmIdx++;\r
5381     pMSize = NULL;\r
5382       for(sIdx = 0; sIdx < innerPrinter->supportedMedia.numSizes; sIdx++){\r
5383       if(pmString[pmIdx] == innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID){\r
5384         pMSize = &innerPrinter->supportedMedia.sizeList[sIdx];\r
5385 /*        EPS_DBGPRINT(("Size = %d\n", innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID))*/\r
5386         break;\r
5387       }\r
5388     }\r
5389 \r
5390     pmIdx++;  /* move next field */\r
5391 \r
5392     while( pmIdx < EPS_PM_MAXSIZE-4 ){  /* 4 = T x x / */\r
5393       if(pmString[pmIdx] == 'T'){\r
5394         if(NULL != pMSize){\r
5395           /* search type ID */\r
5396           pmIdx++;\r
5397           for(tIdx = 0; tIdx < pMSize->numTypes; tIdx++){\r
5398             if(pmString[pmIdx] == pMSize->typeList[tIdx].mediaTypeID){\r
5399               pMSize->typeList[tIdx].paperSource = pmString[pmIdx+1];\r
5400 #if !_VALIDATE_SUPPORTED_MEDIA_DATA_\r
5401               pMSize->typeList[tIdx].paperSource &= EPS_MPID_ALL_ESCPR;\r
5402 #endif\r
5403               pmIdx += 3;\r
5404               break;\r
5405             }\r
5406           }\r
5407           if(tIdx >= pMSize->numTypes){\r
5408             /* Skip unknown T */\r
5409 #if _VALIDATE_SUPPORTED_MEDIA_DATA_\r
5410             printf("\n\n!!!!!!!!! pm2 contains TypeID(0x%02X) that doesn't exist in pm1.  !!!!!!!!!\n", pmString[pmIdx]);\r
5411 #endif\r
5412             pmIdx += 3;\r
5413           }\r
5414         } else{\r
5415           /* Skip unknown S */\r
5416 #if _VALIDATE_SUPPORTED_MEDIA_DATA_\r
5417             printf("\n\n!!!!!!!!! pm2 contains SizeID(0x%02X) that doesn't exist in pm1.  !!!!!!!!!\n", pmString[pmIdx]);\r
5418 #endif\r
5419           pmIdx += 4;\r
5420         }\r
5421       } else if(pmString[pmIdx] == '/') {\r
5422         pmIdx++;\r
5423         break;\r
5424       } else{\r
5425         EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5426       }\r
5427     }\r
5428     if(pmIdx >= EPS_PM_MAXSIZE-4){\r
5429       EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5430     }\r
5431     \r
5432     /* If we run into an occurrence of carriage return followed by line feed,\r
5433      * we have found the terminating characters of the string. */\r
5434     if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {\r
5435       break;\r
5436     }\r
5437   }                      \r
5438   if(pmIdx >= EPS_PM_MAXSIZE){\r
5439     EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5440   }\r
5441 \r
5442   EPS_RETURN( ret );\r
5443 }\r
5444 \r
5445 \r
5446 /*******************************************|********************************************/\r
5447 /*                                                                                      */\r
5448 /* Function name:   GetJpgMax()                                                         */\r
5449 /*                                                                                      */\r
5450 /* Arguments                                                                            */\r
5451 /* ---------                                                                            */\r
5452 /* Name:            Type:                  Description:                                 */\r
5453 /* innerPrinter     EPS_PRINTER_INN*       IO: printer that it has original structure   */\r
5454 /*                                                                                      */\r
5455 /* Return value:                                                                        */\r
5456 /*      EPS_ERR_NONE                    - Success                                       */\r
5457 /*      EPS_ERR_OPR_FAIL                - Internal Error                                */\r
5458 /*                                                                                      */\r
5459 /* Description:                                                                         */\r
5460 /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */\r
5461 /*                                                                                      */\r
5462 /*******************************************|********************************************/\r
5463 EPS_ERR_CODE    GetJpgMax(\r
5464   \r
5465     EPS_PRINTER_INN*    printer\r
5466   \r
5467 ){\r
5468   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
5469     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */\r
5470     EPS_INT32       pmSize = EPS_PM_MAXSIZE;\r
5471     EPS_UINT32      pmIdx;                      /* pm string index                      */\r
5472 \r
5473   EPS_LOG_FUNCIN;\r
5474 \r
5475   if( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){  /* Uni direction */\r
5476     /* set unlimited(2GB) */\r
5477     printer->JpgMax = EPS_JPEG_SIZE_UNLIMIT;\r
5478     EPS_RETURN( EPS_ERR_NONE )\r
5479   }\r
5480 \r
5481   /* Clear the Printer Model Information (Media data or "PM" data)                    */\r
5482     memset(pmString, 0, EPS_PM_MAXSIZE);\r
5483 \r
5484 /*** Get PM1 from Printer                                                               */\r
5485   ret = prtGetPMString(printer, 1, pmString, &pmSize);\r
5486   if(ret == EPS_ERR_PROTOCOL_NOT_SUPPORTED){\r
5487     /* set unlimited(2GB) */\r
5488     printer->JpgMax = EPS_JPEG_SIZE_UNLIMIT;\r
5489     EPS_RETURN( EPS_ERR_NONE )\r
5490   } else if(ret != EPS_ERR_NONE){\r
5491     EPS_RETURN( ret );\r
5492   }\r
5493 \r
5494 /*** "Filter" Raw "PM" data (Remake the correct pm stirng)                              */\r
5495     ret = _SP_ChangeSpec_UpdatePMReply(printer, pmString, pmSize);\r
5496     if (ret != EPS_ERR_NONE) {\r
5497         EPS_RETURN( EPS_ERR_OPR_FAIL );  /* Invalid format */\r
5498     }\r
5499 \r
5500   /*** Is this really "PM" data                                                       */\r
5501   if( strstr((const char*)pmString, "PM") == NULL ) {\r
5502     EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n", pmString));\r
5503     EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5504   }\r
5505 \r
5506   /* Delete the command header of pm string                                           */\r
5507   pmIdx = EPS_PM_HEADER_LEN;        /* skip the command header of pm string     */\r
5508     while( pmIdx < EPS_PM_MAXSIZE ) {\r
5509         switch(pmString[pmIdx]) {\r
5510     case 'M':\r
5511       printer->JpgMax = \r
5512         (pmString[pmIdx+1] << 24) + (pmString[pmIdx+2] << 16) + (pmString[pmIdx+3] << 8) + pmString[pmIdx+4]; \r
5513 \r
5514       pmIdx += 6;\r
5515       break;\r
5516 \r
5517     case 'R':\r
5518       pmIdx += 6;\r
5519       break;\r
5520 \r
5521     case 'S':\r
5522       /* move T field */\r
5523       if(pmIdx < EPS_PM_MAXSIZE-2){\r
5524         pmIdx += 2;\r
5525       } else{\r
5526         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5527       }\r
5528 \r
5529       for(; pmIdx < EPS_PM_MAXSIZE-4; pmIdx += 4) { /* 4 = T x x / */\r
5530         if(pmString[pmIdx] == '/'){\r
5531           pmIdx += 1;\r
5532           break;\r
5533         } else if(pmString[pmIdx] != 'T') {\r
5534           EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5535         }\r
5536       }\r
5537       if(pmIdx >= EPS_PM_MAXSIZE-4){\r
5538         EPS_RETURN( EPS_ERR_OPR_FAIL );\r
5539       }\r
5540       break;\r
5541 \r
5542     default:\r
5543       EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5544     }\r
5545 \r
5546     /* If we run into an occurrence of carriage return followed by line feed,\r
5547      * we have found the terminating characters of the string. */\r
5548     if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {\r
5549       break;\r
5550     }\r
5551   }                      \r
5552   if(pmIdx >= EPS_PM_MAXSIZE || 0 == printer->JpgMax){\r
5553     EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */\r
5554   }\r
5555 \r
5556   EPS_RETURN( ret );\r
5557 }\r
5558 \r
5559 \r
5560 /*******************************************|********************************************/\r
5561 /*                                                                                      */\r
5562 /* Function name:   DuplSupportedMedia()                                                */\r
5563 /*                                                                                      */\r
5564 /* Arguments                                                                            */\r
5565 /* ---------                                                                            */\r
5566 /* Name:            Type:                  Description:                                 */\r
5567 /* innerPrinter     EPS_PRINTER_INN*       I: printer that it has original structure    */\r
5568 /* pMedia           EPS_SUPPORTED_MEDIA*   O: pointer to a distination                  */\r
5569 /*                                                                                      */\r
5570 /* Return value:                                                                        */\r
5571 /*      EPS_ERR_NONE                    - Success                                       */\r
5572 /*      EPS_ERR_MEMORY_ALLOCATION       - Alloc memory failed                           */\r
5573 /*                                                                                      */\r
5574 /* Description:                                                                         */\r
5575 /*      Duplicate EPS_SUPPORTED_MEDIA to user buffer.                                   */\r
5576 /*                                                                                      */\r
5577 /*******************************************|********************************************/\r
5578 EPS_ERR_CODE    DuplSupportedMedia(\r
5579   \r
5580     EPS_PRINTER_INN*    innerPrinter,\r
5581     EPS_SUPPORTED_MEDIA*    pMedia\r
5582   \r
5583 ){\r
5584   EPS_ERR_CODE  ret = EPS_ERR_NONE;\r
5585     EPS_INT32       idx;\r
5586 \r
5587   EPS_LOG_FUNCIN;\r
5588 \r
5589   ClearSupportedMedia();\r
5590 \r
5591   g_supportedMedia.JpegSizeLimit = innerPrinter->supportedMedia.JpegSizeLimit;\r
5592   g_supportedMedia.resolution = innerPrinter->supportedMedia.resolution;\r
5593     g_supportedMedia.numSizes = innerPrinter->supportedMedia.numSizes;\r
5594     g_supportedMedia.sizeList = (EPS_MEDIA_SIZE*)EPS_ALLOC( sizeof(EPS_MEDIA_SIZE) * innerPrinter->supportedMedia.numSizes );\r
5595   if( g_supportedMedia.sizeList ){\r
5596     for(idx = 0; idx < innerPrinter->supportedMedia.numSizes; idx++) {\r
5597       g_supportedMedia.sizeList[idx].mediaSizeID = innerPrinter->supportedMedia.sizeList[idx].mediaSizeID;\r
5598       g_supportedMedia.sizeList[idx].numTypes    = innerPrinter->supportedMedia.sizeList[idx].numTypes;\r
5599       g_supportedMedia.sizeList[idx].typeList = \r
5600                     (EPS_MEDIA_TYPE*)EPS_ALLOC( sizeof(EPS_MEDIA_TYPE) * innerPrinter->supportedMedia.sizeList[idx].numTypes );\r
5601       if( g_supportedMedia.sizeList[idx].typeList ){\r
5602         memcpy(g_supportedMedia.sizeList[idx].typeList, \r
5603             innerPrinter->supportedMedia.sizeList[idx].typeList,\r
5604             sizeof(EPS_MEDIA_TYPE) * innerPrinter->supportedMedia.sizeList[idx].numTypes);\r
5605       } else{\r
5606         ret = EPS_ERR_MEMORY_ALLOCATION;\r
5607         break;\r
5608       }\r
5609     }\r
5610   } else{\r
5611     ret = EPS_ERR_MEMORY_ALLOCATION;\r
5612   }\r
5613 \r
5614   if(EPS_ERR_NONE == ret){\r
5615     /* Copy to out param */\r
5616         pMedia->JpegSizeLimit = g_supportedMedia.JpegSizeLimit;\r
5617     pMedia->resolution = g_supportedMedia.resolution;\r
5618     pMedia->numSizes = g_supportedMedia.numSizes;\r
5619         pMedia->sizeList = g_supportedMedia.sizeList;\r
5620 \r
5621   } else{\r
5622     /* If error occur, unwind. */\r
5623     for(idx = 0; idx < g_supportedMedia.numSizes; idx++) {\r
5624       EPS_SAFE_RELEASE(g_supportedMedia.sizeList[idx].typeList);\r
5625     }\r
5626     EPS_SAFE_RELEASE(g_supportedMedia.sizeList);\r
5627     g_supportedMedia.numSizes = 0;\r
5628   }\r
5629 \r
5630   EPS_RETURN( ret );\r
5631 }\r
5632 \r
5633 \r
5634 /*******************************************|********************************************/\r
5635 /*                                                                                      */\r
5636 /* Function name:     ClearSupportedMedia()                                             */\r
5637 /*                                                                                      */\r
5638 /* Arguments                                                                            */\r
5639 /* ---------                                                                            */\r
5640 /* Name:            Type:                   Description:                                */\r
5641 /* (none)                                                                               */\r
5642 /*                                                                                      */\r
5643 /* Return value:                                                                        */\r
5644 /*      void                                                                            */\r
5645 /*                                                                                      */\r
5646 /* Description:                                                                         */\r
5647 /*      Crean up inside list of supported media structure.                              */\r
5648 /*                                                                                      */\r
5649 /*******************************************|********************************************/\r
5650 void ClearSupportedMedia(\r
5651               \r
5652   void\r
5653 \r
5654 ){\r
5655     EPS_INT32       idx;\r
5656 \r
5657   EPS_LOG_FUNCIN;\r
5658 \r
5659   /* Clear "supportedMedia"                                              */\r
5660   if( NULL != g_supportedMedia.sizeList){\r
5661     for(idx = 0; idx < g_supportedMedia.numSizes; idx++) {\r
5662       EPS_SAFE_RELEASE(g_supportedMedia.sizeList[idx].typeList);\r
5663     }\r
5664     EPS_SAFE_RELEASE(g_supportedMedia.sizeList);\r
5665     g_supportedMedia.numSizes = 0;\r
5666   }\r
5667 \r
5668   EPS_RETURN_VOID;\r
5669 }\r
5670 \r
5671 /*_______________________________   epson-escpr-api.c   ________________________________*/\r
5672 \r
5673 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
5674 /*       1         2         3         4         5         6         7         8        */\r
5675 /*******************************************|********************************************/\r
5676 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
5677 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/\r
5678 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r