/epson-inkjet-printer-escpr/lib/epson-escpr-api.c

https://review.tizen.org/git/ · C · 5687 lines · 3128 code · 836 blank · 1723 comment · 990 complexity · c6c892ff60272920bdb72896e5f5842d MD5 · raw file 

    

  1. /*_______________________________   epson-escpr-api.c   ________________________________*/

    2. 

  2. 

    3. 

  3. /*       1         2         3         4         5         6         7         8        */

    4. 

  4. /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/

    5. 

  5. /*******************************************|********************************************/

    6. 

  6. /*

    7. 

  7.  *   Copyright (c) 2009  Seiko Epson Corporation                 All rights reserved.

    8. 

  8.  *

    9. 

  9.  *   Copyright protection claimed includes all forms and matters of

    10. 

  10.  *   copyrightable material and information now allowed by statutory or judicial

    11. 

  11.  *   law or hereinafter granted, including without limitation, material generated

    12. 

  12.  *   from the software programs which are displayed on the screen such as icons,

    13. 

  13.  *   screen display looks, etc.

    14. 

  14.  *

    15. 

  15.  */

    16. 

  16. /*******************************************|********************************************/

    17. 

  17. /*                                                                                      */

    18. 

  18. /*                             Epson ESC/P-R Library APIs                               */

    19. 

  19. /*                                                                                      */

    20. 

  20. /*                                Core Function Calls                                   */

    21. 

  21. /*                            --------------------------                                */

    22. 

  22. /*		API-0001   EPS_ERR_CODE epsInitDriver        (commMode, usbFuncPtrs,            */

    23. 

  23. /*                                                    netFuncPtrs, cmnFuncPtrs);        */

    24. 

  24. /*      API-0002   EPS_ERR_CODE epsReleaseDriver     ();                                */

    25. 

  25. /*      API-0003   EPS_ERR_CODE epsFindPrinter       (protocol, timeout);               */

    26. 

  26. /*      API-0004   EPS_ERR_CODE epsProbePrinter      (probeParam);                      */

    27. 

  27. /*      API-0005   EPS_ERR_CODE epsCancelFindPrinter ();                                */

    28. 

  28. /*      API-0006   EPS_ERR_CODE epsSetPrinter        (printer);                         */

    29. 

  29. /*      API-0007   EPS_ERR_CODE epsStartJob          (jobAttrib);                       */

    30. 

  30. /*      API-0008   EPS_ERR_CODE epsStartPage         (pageAttrib);                      */

    31. 

  31. /*      API-0009   EPS_ERR_CODE epsPrintBand         (imageData,width,,height);         */

    32. 

  32. /*      API-0010   EPS_ERR_CODE epsSendData          (prnData);                         */

    33. 

  33. /*      API-0011   EPS_ERR_CODE epsEndPage           ();                                */

    34. 

  34. /*      API-0012   EPS_ERR_CODE epsEndJob            ();                                */

    35. 

  35. /*      API-0013   EPS_ERR_CODE epsCancelJob         (reserve);                         */

    36. 

  36. /*      API-0014   EPS_ERR_CODE epsContinueJob       ();                                */

    37. 

  37. /*      API-0015   EPS_ERR_CODE epsGetStatus         (status);                          */

    38. 

  38. /*      API-0016   EPS_ERR_CODE epsGetSupportedMedia (media);                           */

    39. 

  39. /*      API-0017   EPS_ERR_CODE epsGetPrintableArea  (pageAttrib,                       */

    40. 

  40. /*                                                      printableWidth,                 */

    41. 

  41. /*                                                      printableHeight);               */

    42. 

  42. /*                                                                                      */

    43. 

  43. /*******************************************|********************************************/

    44. 

  44. 

    45. 

  45. /*------------------------------  Local Compiler Switch  -------------------------------*/

    46. 

  46. /*******************************************|********************************************/

    47. 

  47. 

    48. 

  48.     /*** 4KB Packet Data                                                                */

    49. 

  49.     /***--------------------------------------------------------------------------------*/

    50. 

  50. #define LCOMSW_PACKET_4KB           0       /* 0: Make any size packet                  */

    51. 

  51.                                             /* 1: Make 4KB packet                       */

    52. 

  52. #define LCOMSW_CANCEL_JOB           0

    53. 

  53. 

    54. 

  54. #define LCOMSW_USE_720DPI           0		/* Not support 720dpi                       */       

    55. 

  55. 

    56. 

  56. #define ESCPR_DEBUG_IMAGE_LOG       0       /* 0: OFF    1: ON                          */

    57. 

  57. 

    58. 

  58. #define LCOMSW_DUMMY_SEND			0		/* 1: Enable 0byte data sending             */

    59. 

  59. 

    60. 

  60. /*#define LCOMSW_JOBPARAM_CEHCK_OFF*/

    61. 

  61. 

    62. 

  62. /* #define LCOMSW_CMDDMP */

    63. 

  63. 

    64. 

  64. /*------------------------------------  Includes   -------------------------------------*/

    65. 

  65. /*******************************************|********************************************/

    66. 

  66. #include "epson-escpr-pvt.h"

    67. 

  67. #include "epson-escpr-services.h"

    68. 

  68. #include "epson-escpr-mem.h"

    69. 

  69. #include "epson-protocol.h"

    70. 

  70. #include "epson-layout.h"

    71. 

  71. #ifdef GCOMSW_CMD_ESCPAGE

    72. 

  72. #include "epson-escpage.h"

    73. 

  73. 	#ifdef GCOMSW_CMD_ESCPAGE_S

    74. 

  74. 	#include "epson-escpage-s.h"

    75. 

  75. 	#endif

    76. 

  76. #endif

    77. 

  77. #include "epson-escpr-api.h"

    78. 

  78. 

    79. 

  79. 

    80. 

  80. /*----------------------------  ESC/P-R Lib Global Variables  --------------------------*/

    81. 

  81. /*******************************************|********************************************/

    82. 

  82. DECRALE_DMP_FILE

    83. 

  83. 

    84. 

  84.     /*** Extern Function                                                                */

    85. 

  85.     /*** -------------------------------------------------------------------------------*/

    86. 

  86. EPS_USB_FUNC    epsUsbFnc;

    87. 

  87. EPS_NET_FUNC    epsNetFnc;

    88. 

  88. EPS_CMN_FUNC    epsCmnFnc;

    89. 

  89. 

    90. 

  90.     /*** Print Job Structure                                                            */

    91. 

  91.     /*** -------------------------------------------------------------------------------*/

    92. 

  92. EPS_PRINT_JOB   printJob;

    93. 

  93. EPS_INT32 tonerSave;

    94. 

  94. EPS_INT32 back_type;

    95. 

  95. 

    96. 

  96. EPS_INT32 lWidth;

    97. 

  97. EPS_INT32 lHeight;

    98. 

  98. 

    99. 

  99. EPS_INT32 areaWidth;

    100. 

  100. EPS_INT32 areaHeight;

    101. 

  101. 

    102. 

  102. 

    103. 

  103. /*-------------------------  Module "Local Global" Variables  --------------------------*/

    104. 

  104. /*******************************************|********************************************/

    105. 

  105.     /*** internal stock                                                                 */

    106. 

  106.     /*** -------------------------------------------------------------------------------*/

    107. 

  107. static EPS_SUPPORTED_MEDIA	g_supportedMedia;				/* Supported Media          */

    108. 

  108. 

    109. 

  109.     /*** Job function                                                                   */

    110. 

  110.     /*** -------------------------------------------------------------------------------*/

    111. 

  111. EPS_JOB_FUNCS		jobFnc;							

    112. 

  112. 

    113. 

  113. /*--------------------------------  Local Definition   ---------------------------------*/

    114. 

  114. /*******************************************|********************************************/

    115. 

  115. #ifdef EPS_LOG_MODULE_API

    116. 

  116. #define EPS_LOG_MODULE EPS_LOG_MODULE_API

    117. 

  117. #else

    118. 

  118. #define EPS_LOG_MODULE 0

    119. 

  119. #endif

    120. 

  120. 

    121. 

  121.     /*** Roop Count                                                                     */

    122. 

  122.     /*** -------------------------------------------------------------------------------*/

    123. 

  123. #define EPS_ROOP_NUM                   40       /* Send the data for "EPS_ROOP_NUM"     */

    124. 

  124.                                                 /* times and get printer status         */

    125. 

  125. 

    126. 

  126. #define EPS_TIMEOUT_NUM                20       /* retry Send the data "EPS_TIMEOUT_NUM"*/

    127. 

  127. #define EPS_TIMEOUT_SEC                1000     /* retry Send the data 1 sec */

    128. 

  128. 

    129. 

  129.     /*** Packet Size (4KB)                                                              */

    130. 

  130.     /*** -------------------------------------------------------------------------------*/

    131. 

  131. #if LCOMSW_PACKET_4KB

    132. 

  132. #define ESCPR_PACKET_SIZE_4KB        4090

    133. 

  133. #endif

    134. 

  134. 

    135. 

  135.     /*** ESC/PR Attributes not settable by developer                                    */

    136. 

  136.     /*** -------------------------------------------------------------------------------*/

    137. 

  137. #define EPS_COMP_NON                    0       /* Non compression                      */

    138. 

  138. #define EPS_COMP_RLE                    1       /* Runlength compression                */

    139. 

  139. 

    140. 

  140. #define EPS_END_PAGE                    0       /* There is no next page                */

    141. 

  141. #define EPS_NEXT_PAGE                   1       /* There is a next page                 */

    142. 

  142. 

    143. 

  143.     /*** RLE Compression States                                                         */

    144. 

  144.     /*** -------------------------------------------------------------------------------*/

    145. 

  145. #define EPS_RLE_COMPRESS_NOT_DONE       0

    146. 

  146. #define EPS_RLE_COMPRESS_DONE           1

    147. 

  147. 

    148. 

  148.     /*** Borderless Mode                                                                */

    149. 

  149.     /*** -------------------------------------------------------------------------------*/

    150. 

  150. #define EPS_BORDER_3MM_MARGINE          0

    151. 

  151. #define EPS_BORDER_CUSTOM               1

    152. 

  152. #define EPS_BORDERLESS_NORMAL           2

    153. 

  153. #define EPS_BORDERLESS_ZERO_MARGINE     3

    154. 

  154. 

    155. 

  155. 

    156. 

  156. /*---------------------------------  ESC/P-R Commands  ---------------------------------*/

    157. 

  157. /*******************************************|********************************************/

    158. 

  158.     /*** ESC/P-R Command Length                                                         */

    159. 

  159.     /*** -------------------------------------------------------------------------------*/

    160. 

  160. #define REMOTE_HEADER_LENGTH            5

    161. 

  161. #define ESCPR_CLASS_LENGTH              2    /* ESC + CLASS */

    162. 

  162. #define ESCPR_HEADER_LENGTH            10    /* ESC + CLASS + ParamLen + CmdName */

    163. 

  163. #define ESCPR_PRINT_QUALITY_LENGTH      9

    164. 

  164. #define ESCPR_SEND_DATA_LENGTH          7

    165. 

  165. #define ESCPR_SEND_JPGDATA_LENGTH       2

    166. 

  166. #define ESCPR_JPGHEAD_LENGTH            (ESCPR_HEADER_LENGTH + ESCPR_SEND_JPGDATA_LENGTH)

    167. 

  167. 

    168. 

  168.     /*** Escape Commands for Initialize/Colse Printer                                   */

    169. 

  169.     /*** -------------------------------------------------------------------------------*/

    170. 

  170. static const EPS_UINT8 ExitPacketMode[]= {

    171. 

  171.                             0x00, 0x00, 0x00, 0x1B, 0x01, 0x40, 0x45, 0x4A, 0x4C, 0x20,

    172. 

  172.                             0x31, 0x32, 0x38, 0x34, 0x2E, 0x34, 0x0A, 0x40, 0x45, 0x4A,

    173. 

  173.                             0x4C, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A                    };

    174. 

  174. 

    175. 

  175. static const EPS_UINT8 ESCPRMode[] = {

    176. 

  176. /*                            0x1B, 0x28, 0x52, 0x06, 0x00, 0x00, 0x45, 0x53, 0x43, 0x50, 0x52, };*/

    177. 

  177.                             0x1B, '(', 'R', 0x06, 0x00, 0x00, 'E', 'S', 'C', 'P', 'R' };

    178. 

  178. static const EPS_UINT8 ESCPRModeJpg[] = {

    179. 

  179.                             0x1B, '(', 'R', 0x07, 0x00, 0x00, 'E', 'S', 'C', 'P', 'R', 'J' };

    180. 

  180. 

    181. 

  181. static const EPS_UINT8 InitPrinter[] = {

    182. 

  182.                             0x1B, 0x40,                                                 };

    183. 

  183. 

    184. 

  184. static const EPS_UINT8 EnterRemoteMode[] = {

    185. 

  185.                             0x1B, 0x28, 0x52, 0x08, 0x00, 0x00, 'R', 'E', 'M', 'O', 'T', 'E', '1',  };

    186. 

  186. 

    187. 

  187. static const EPS_UINT8 RemoteJS[] = {

    188. 

  188.                             'J', 'S', 0x04, 0x00, 0x00, 

    189. 

  189. 							0x00, 0x00, 0x00 };

    190. 

  190. 

    191. 

  191. static const EPS_UINT8 RemoteTI[] = {

    192. 

  192. 		                    'T', 'I', 0x08, 0x00, 0x00,

    193. 

  193. 							0x00, 0x00, /* YYYY */

    194. 

  194. 							0x00,       /* MM */

    195. 

  195. 							0x00,       /* DD */

    196. 

  196. 							0x00,       /* hh */

    197. 

  197. 							0x00,       /* mm */

    198. 

  198. 							0x00,       /* ss */	};

    199. 

  199. 							

    200. 

  200. static const EPS_UINT8 RemoteHD[] = {

    201. 

  201.                             'H', 'D', 0x03, 0x00, 0x00, 

    202. 

  202. 							0x03, 0xFF };

    203. 

  203. 

    204. 

  204. static const EPS_UINT8 RemoteJH[] = {

    205. 

  205.                              'J',  'H', 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    206. 

  206.                             0x45, 0x53, 0x43, 0x50, 0x52, 0x4c, 0x69, 0x62              };

    207. 

  207. 

    208. 

  208. static const EPS_UINT8 RemotePP[] = {

    209. 

  209.                             'P', 'P', 0x03, 0x00, 0x00, 0x00, 0x00                      };

    210. 

  210. 

    211. 

  211. static const EPS_UINT8 RemoteDP[] = {

    212. 

  212.                             'D', 'P', 0x02, 0x00, 0x00, 0x02                            };

    213. 

  213. 

    214. 

  214. static const EPS_UINT8 RemoteLD[] = {

    215. 

  215.                             'L', 'D', 0x00, 0x00,										};

    216. 

  216. 

    217. 

  217. static const EPS_UINT8 RemoteJE[] = {

    218. 

  218.                             'J', 'E', 0x01, 0x00, 0x00,                                 };

    219. 

  219. 

    220. 

  220. static const EPS_UINT8 ExitRemoteMode[] = {

    221. 

  221.                             0x1B, 0x00, 0x00, 0x00,                                     };

    222. 

  222. #ifdef GCOMSW_EF_MAINTE

    223. 

  223. static const EPS_UINT8 RemoteCH[] = {

    224. 

  224.                             'C', 'H', 0x02, 0x00, 0x00, 0x00				};

    225. 

  225. static const EPS_UINT8 RemoteNC[] = {

    226. 

  226.                             'N', 'C', 0x02, 0x00, 0x00, 0x00				};

    227. 

  227. static const EPS_UINT8 RemoteVI[] = {

    228. 

  228.                             'V', 'I', 0x02, 0x00, 0x00, 0x00				};

    229. 

  229. 

    230. 

  230. static const EPS_UINT8 DataCR[] = {0x0D			};

    231. 

  231. static const EPS_UINT8 DataLF[] = {0x0A			};

    232. 

  232. static const EPS_UINT8 DataFF[] = {0x0C			};

    233. 

  233. #endif

    234. 

  234. 

    235. 

  235.     /*** ESC/P-R Commands (Print Quality)                                               */

    236. 

  236.     /*** -------------------------------------------------------------------------------*/

    237. 

  237. static const EPS_UINT8 PrintQualityCmd[] = {

    238. 

  238. 	                        0x1B, 'q', 0x09, 0x00, 0x00, 0x00,

    239. 

  239.                             's', 'e', 't', 'q',

    240. 

  240.                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

    241. 

  241. 

    242. 

  242.     /*** ESC/P-R Commands (APF setting)                                                 */

    243. 

  243.     /*** -------------------------------------------------------------------------------*/

    244. 

  244. static const EPS_UINT8 APFSettingCmd[]   = {

    245. 

  245. 	                        0x1B, 'a', 0x04, 0x00, 0x00, 0x00,

    246. 

  246.                             's', 'e', 't', 'a',

    247. 

  247.                             0x00, 0x00, 0x00, 0x00};

    248. 

  248. 

    249. 

  249.     /*** ESC/P-R Commands (Print Job)                                                   */

    250. 

  250.     /*** -------------------------------------------------------------------------------*/

    251. 

  251. static const EPS_UINT8 JobCmd[]          = {

    252. 

  252. 	                        0x1B, 'j', 0x16, 0x00, 0x00, 0x00,

    253. 

  253.                             's', 'e', 't', 'j',

    254. 

  254.                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    255. 

  255. 							0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

    256. 

  256. 							0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

    257. 

  257. static const EPS_UINT8 JobCmdJpg[]       = {

    258. 

  258. 	                        0x1B, 'j', 0x05, 0x00, 0x00, 0x00,

    259. 

  259.                             's', 'e', 't', 's',

    260. 

  260.                             0x00, 0x00, 0x00, 0x00, 0x00 };

    261. 

  261. 

    262. 

  262.     /*** ESC/P-R Command (Start Page)                                                   */

    263. 

  263.     /*** -------------------------------------------------------------------------------*/

    264. 

  264. static const EPS_UINT8 StartPage[]       = {

    265. 

  265. 	                        0x1B, 'p', 0x00, 0x00, 0x00, 0x00,  

    266. 

  266.                             's',  't',  't',  'p' };

    267. 

  267. 

    268. 

  268.     /*** ESC/P-R Commands (Send Data)                                                   */

    269. 

  269.     /*** -------------------------------------------------------------------------------*/

    270. 

  270. static const EPS_UINT8 SendDataCmd[2]       = {0x1B, 'd'            };

    271. 

  271. static const EPS_UINT8 SendDataName[4]      = {'d', 's', 'n', 'd'   };

    272. 

  272. static const EPS_UINT8 SendJpegDataName[4]  = {'j', 's', 'n', 'd'   };

    273. 

  273. 

    274. 

  274.     /*** ESC/P-R Command (End Page)                                                     */

    275. 

  275.     /*** -------------------------------------------------------------------------------*/

    276. 

  276. static const EPS_UINT8 EndPage[]		= {

    277. 

  277. 	                        0x1B, 'p', 0x01, 0x00, 0x00, 0x00,  

    278. 

  278.                             'e',  'n',  'd',  'p', 

    279. 

  279.                             0x00};

    280. 

  280. 

    281. 

  281.     /*** ESC/P-R Command (End Job)                                                      */

    282. 

  282.     /*** -------------------------------------------------------------------------------*/

    283. 

  283. static const EPS_UINT8 EndJob[] = {

    284. 

  284.                             0x1B,  'j', 0x00, 0x00, 0x00, 0x00,

    285. 

  285. 							'e',  'n',  'd',  'j' };

    286. 

  286. 

    287. 

  287. /*-------------------------------  Definition of Macro  --------------------------------*/

    288. 

  288. /*******************************************|********************************************/

    289. 

  289. 

    290. 

  290. 

    291. 

  291. /*---------------------------  Data Structure Declarations   ---------------------------*/

    292. 

  292. /*******************************************|********************************************/

    293. 

  293. 

    294. 

  294.     /*** Generic Image Object                                                           */

    295. 

  295.     /*** -------------------------------------------------------------------------------*/

    296. 

  296. typedef struct _tagEPS_IMAGE_ {

    297. 

  297.     const EPS_UINT8*  data;                 /* Pointer to image/raster data             */

    298. 

  298.     EPS_RECT    rect;                       /* Rect define position of image            */

    299. 

  299.     EPS_UINT32  bytesPerLine;               /* Bytes-Per-Pixel for image/raster         */

    300. 

  300. } EPS_IMAGE;

    301. 

  301. 

    302. 

  302. /*------------------------------  Local Global Variables  ------------------------------*/

    303. 

  303. /*******************************************|********************************************/

    304. 

  304.     /*** ESC/P-R LIB Status State                                                       */

    305. 

  305.     /*** -------------------------------------------------------------------------------*/

    306. 

  306. EPS_INT32    libStatus;                  /*  Library (epsInitDriver) status      */

    307. 

  307. 

    308. 

  308.     /*** Status counter                                                                 */

    309. 

  309.     /*** -------------------------------------------------------------------------------*/

    310. 

  310. static EPS_INT32    gStatusCount;   /* Variable for register the number of getting      */

    311. 

  311.                                     /* printer status                                   */

    312. 

  312. 

    313. 

  313.     /*** Buffer for Print Band                                                          */

    314. 

  314.     /*** -------------------------------------------------------------------------------*/

    315. 

  315. EPS_UINT32   sendDataBufSize = 0;

    316. 

  316. EPS_UINT8*   sendDataBuf;    /* buffer of SendCommand(save) input                */

    317. 

  317. EPS_UINT32   tmpLineBufSize;

    318. 

  318. EPS_UINT8*   tmpLineBuf;

    319. 

  319. 

    320. 

  320. /*--------------------------------  Local Functions   ----------------------------------*/

    321. 

  321. /*******************************************|********************************************/

    322. 

  322. static EPS_ERR_CODE MonitorStatus           (EPS_STATUS_INFO *                          );

    323. 

  323. static EPS_ERR_CODE SendLeftovers           (void                                       );

    324. 

  324. static EPS_ERR_CODE SendBlankBand           (void                                       );

    325. 

  325. EPS_ERR_CODE SetupJobAttrib          (const EPS_JOB_ATTRIB*                      );

    326. 

  326. static EPS_ERR_CODE SetupRGBAttrib          (void                                       );

    327. 

  327. static EPS_ERR_CODE SetupJPGAttrib          (void                                       );

    328. 

  328. EPS_ERR_CODE SendStartJob			(EPS_BOOL                                   );

    329. 

  329. EPS_ERR_CODE SendEndJob  			(EPS_BOOL                                   );

    330. 

  330. 

    331. 

  331. EPS_ERR_CODE PrintBand               (const EPS_UINT8*, EPS_UINT32, EPS_UINT32*  );

    332. 

  332. static EPS_ERR_CODE PrintChunk              (const EPS_UINT8*, EPS_UINT32*              );

    333. 

  333. static void         AdjustBasePoint         (void                                       );

    334. 

  334. static EPS_ERR_CODE PrintLine               (EPS_IMAGE*                                 );

    335. 

  335. static EPS_ERR_CODE SendLine                (const EPS_BANDBMP*, EPS_RECT*              );

    336. 

  336. static EPS_UINT16   RunLengthEncode         (const EPS_UINT8*, EPS_UINT8*, EPS_UINT16, EPS_UINT8, EPS_UINT8*);

    337. 

  337. 

    338. 

  338. static void         MakeRemoteTICmd         (EPS_UINT8*                                 );

    339. 

  339. static void         MakeQualityCmd          (EPS_UINT8*                                 );

    340. 

  340. static void         MakeAPFCmd              (EPS_UINT8*                                 );

    341. 

  341. static void         MakeJobCmd              (EPS_UINT8*                                 );

    342. 

  342. static EPS_ERR_CODE AddCmdBuff              (EPS_UINT8 **, EPS_UINT8 **, EPS_UINT32 *, 

    343. 

  343. 											const EPS_UINT8 *, EPS_UINT32               );

    344. 

  344. static EPS_ERR_CODE CreateMediaInfo			(EPS_PRINTER_INN*, EPS_UINT8*, EPS_INT32	);

    345. 

  345. static EPS_ERR_CODE	DuplSupportedMedia      (EPS_PRINTER_INN*, EPS_SUPPORTED_MEDIA*     );

    346. 

  346. static EPS_ERR_CODE	GetPaperSource          (EPS_PRINTER_INN*                           );

    347. 

  347. static EPS_ERR_CODE GetJpgMax               (EPS_PRINTER_INN*                          );

    348. 

  348. static void     	ClearSupportedMedia     (void                                      );

    349. 

  349. 

    350. 

  350. 

    351. 

  351. 

    352. 

  352. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    353. 

  353. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    354. 

  354. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    355. 

  355. /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/

    356. 

  356. /*--------------------             ESC/P-R Library API             ---------------------*/

    357. 

  357. /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/

    358. 

  358. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    359. 

  359. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    360. 

  360. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    361. 

  361. 

    362. 

  362. /*******************************************|********************************************/

    363. 

  363. /*                                                                                      */

    364. 

  364. /* Function name:     epsInitDriver()                                                   */

    365. 

  365. /*                                                                                      */

    366. 

  366. /* Arguments                                                                            */

    367. 

  367. /* ---------                                                                            */

    368. 

  368. /* Name:        Type:               Description:                                        */

    369. 

  369. /* commMode     EPS_INT8            I: Communication Mode                               */

    370. 

  370. /*                                     (Bi-Directional or Uni-Directional)              */

    371. 

  371. /* usbFuncPtrs  EPS_USB_FUNC*       I: Data structure containing function pointers to   */

    372. 

  372. /*                                     external USB I/O functions.                      */

    373. 

  373. /* netFuncPtrs  EPS_NET_FUNC*       I: Data structure containing function pointers to   */

    374. 

  374. /*                                     external network socket I/O functions.           */

    375. 

  375. /* cmnFuncPtrs  EPS_CMN_FUNC*       I: Data structure containing function pointers to   */

    376. 

  376. /*                                     external memory management functions.            */

    377. 

  377. /*                                                                                      */

    378. 

  378. /* Return value:                                                                        */

    379. 

  379. /*      << Normal >>                                                                    */

    380. 

  380. /*      EPS_ERR_NONE                     - Success                                      */

    381. 

  381. /*      << Error >>                                                                     */

    382. 

  382. /*      EPS_ERR_LIB_INTIALIZED           - Lib already initialized                      */

    383. 

  383. /*      EPS_ERR_INV_ARG_COMMMODE         - Invalid argument "commMode"                  */

    384. 

  384. /*      EPS_ERR_INV_FNCP_NULL            - Invalid function pointer structure           */

    385. 

  385. /*      EPS_ERR_INV_FNCP_FINDCALLBACK    - Invalid function pointer "findCallback"      */

    386. 

  386. /*      EPS_ERR_INV_FNCP_MEMALLOC        - Invalid function pointer "memAlloc"          */

    387. 

  387. /*      EPS_ERR_INV_FNCP_MEMFREE         - Invalid function pointer "memFree"           */

    388. 

  388. /*      EPS_ERR_INV_FNCP_SLEEP           - Invalid function pointer "sleep"             */

    389. 

  389. /*      EPS_ERR_INV_FNCP_OPENPORTAL      - Invalid function pointer "openPortal"        */

    390. 

  390. /*      EPS_ERR_INV_FNCP_CLOSEPORTAL     - Invalid function pointer "closePortal"       */

    391. 

  391. /*      EPS_ERR_INV_FNCP_READPORTAL      - Invalid function pointer "readPortal"        */

    392. 

  392. /*      EPS_ERR_INV_FNCP_WRITEPORTAL     - Invalid function pointer "writePortal"       */

    393. 

  393. /*      EPS_ERR_INV_FNCP_FINDFIRST       - Invalid function pointer "findFirst"         */

    394. 

  394. /*      EPS_ERR_INV_FNCP_FINDNEXT        - Invalid function pointer "findNext"          */

    395. 

  395. /*      EPS_ERR_INV_FNCP_FINDCLOSE       - Invalid function pointer "findClose"         */

    396. 

  396. /*      EPS_ERR_INV_FNCP_NETSOCKET       - Invalid function pointer "socket"            */

    397. 

  397. /*      EPS_ERR_INV_FNCP_NETCLOSE        - Invalid function pointer "close"             */

    398. 

  398. /*      EPS_ERR_INV_FNCP_NETCONNECT      - Invalid function pointer "connect"           */

    399. 

  399. /*      EPS_ERR_INV_FNCP_NETSHUTDOWN     - Invalid function pointer "shutdown"          */

    400. 

  400. /*      EPS_ERR_INV_FNCP_NETBIND         - Invalid function pointer "bind"              */

    401. 

  401. /*      EPS_ERR_INV_FNCP_NETLISTEN       - Invalid function pointer "listen"            */

    402. 

  402. /*      EPS_ERR_INV_FNCP_NETACCEPT       - Invalid function pointer "accept"            */

    403. 

  403. /*      EPS_ERR_INV_FNCP_NETSEND         - Invalid function pointer "send"              */

    404. 

  404. /*      EPS_ERR_INV_FNCP_NETSENDTO       - Invalid function pointer "sendTo"            */

    405. 

  405. /*      EPS_ERR_INV_FNCP_NETRECEIVE      - Invalid function pointer "receive"           */

    406. 

  406. /*      EPS_ERR_INV_FNCP_NETRECEIVEFROM  - Invalid function pointer "receiveFrom"       */

    407. 

  407. /*      EPS_ERR_INV_FNCP_NETGETSOCKNAME  - Invalid function pointer "getsockname"       */

    408. 

  408. /*      EPS_ERR_INV_FNCP_NETSETBROADCAST - Invalid function pointer "setBroadcast"      */

    409. 

  409. /*      EPS_ERR_MEMORY_ALLOCATION        - Failed to allocate memory                    */

    410. 

  410. /*                                                                                      */

    411. 

  411. /* Description:                                                                         */

    412. 

  412. /*      Registers the external functions with the device driver.                        */

    413. 

  413. /*                                                                                      */

    414. 

  414. /*******************************************|********************************************/

    415. 

  415. EPS_ERR_CODE    epsInitDriver (

    416. 

  416. 

    417. 

  417.         EPS_INT32               commMode, 

    418. 

  418. 		const EPS_USB_FUNC*     usbFuncPtrs,

    419. 

  419.         const EPS_NET_FUNC*     netFuncPtrs,

    420. 

  420.         const EPS_CMN_FUNC*	    cmnFuncPtrs

    421. 

  421. 

    422. 

  422. ){

    423. 

  423. /*** Declare Variable Local to Routine                                                  */

    424. 

  424. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls      */

    425. 

  425. 

    426. 

  426. EPS_LOG_FUNCIN

    427. 

  427. 

    428. 

  428. #ifdef GCOMSW_EPSON_SLEEP

    429. 

  429. EPS_INT32       idx, tdx;                       /* General loop/index varaible          */

    430. 

  430. EPS_INT32       sleepTime; 

    431. 

  431. struct timeb    sleepS, sleepE;

    432. 

  432. #endif /* GCOMSW_EPSON_SLEEP */

    433. 

  433. 

    434. 

  434. /*** Has a Lib been initialized                                                         */

    435. 

  435.     if (libStatus != EPS_STATUS_NOT_INITIALIZED) {

    436. 

  436.         EPS_RETURN( EPS_ERR_LIB_INTIALIZED );

    437. 

  437.     }

    438. 

  438. 

    439. 

  439. /*** Validate input parameters                                                          */

    440. 

  440. 	if( EPS_ERR_NONE != (retStatus = prtFunctionCheck(commMode, usbFuncPtrs, netFuncPtrs, cmnFuncPtrs)) ){

    441. 

  441. 		EPS_RETURN( retStatus );

    442. 

  442. 	}

    443. 

  443. 

    444. 

  444. /*** Register Functions                                                                 */

    445. 

  445. 	if( commMode & EPS_PROTOCOL_USB ){

    446. 

  446.         memcpy((void*)(&epsUsbFnc), (void*)usbFuncPtrs, sizeof(EPS_USB_FUNC));

    447. 

  447. 	} else{

    448. 

  448. 	    memset((void*)(&epsUsbFnc), 0, sizeof(EPS_USB_FUNC));

    449. 

  449. 	}

    450. 

  450. 	if( commMode & EPS_PROTOCOL_NET ){

    451. 

  451.         memcpy((void*)(&epsNetFnc), (void*)netFuncPtrs, sizeof(EPS_NET_FUNC));

    452. 

  452. 	} else{

    453. 

  453. 	    memset((void*)(&epsNetFnc), 0, sizeof(EPS_NET_FUNC));

    454. 

  454. 	}

    455. 

  455.     memcpy((void*)(&epsCmnFnc), (void*)cmnFuncPtrs, sizeof(EPS_CMN_FUNC));

    456. 

  456. 

    457. 

  457. #ifdef GCOMSW_EPSON_SLEEP

    458. 

  458.     if (epsCmnFnc.sleep == NULL)

    459. 

  459.         epsCmnFnc.sleep = serSleep;

    460. 

  460. #endif /* GCOMSW_EPSON_SLEEP */

    461. 

  461. 

    462. 

  462. 

    463. 

  463. /*** Initialize ESC/P-R Lib and Local Global Variables                                  */

    464. 

  464.     gStatusCount = 0;

    465. 

  465. 

    466. 

  466.     memset(&printJob, 0, sizeof(EPS_PRINT_JOB));

    467. 

  467.     

    468. 

  468.     printJob.jobStatus  = EPS_STATUS_NOT_INITIALIZED;

    469. 

  469.     printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;

    470. 

  470. 	printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;

    471. 

  471. 	printJob.printer    = NULL;

    472. 

  472. 	printJob.bComm		= TRUE;	

    473. 

  473. 	printJob.platform   = 0x04; /* '0x04 = linux' is default */ 

    474. 

  474. 

    475. 

  475.     libStatus   = EPS_STATUS_NOT_INITIALIZED;

    476. 

  476. 	sendDataBufSize = 0;

    477. 

  477.     sendDataBuf = NULL;

    478. 

  478. 	tmpLineBufSize = 0;

    479. 

  479.     tmpLineBuf  = NULL;

    480. 

  480. 

    481. 

  481. /*** Initialize continue buffer                                                         */

    482. 

  482. 	printJob.contData.sendData = NULL;

    483. 

  483. 	printJob.contData.sendDataSize = 0;

    484. 

  484. 

    485. 

  485. 	/* DEL printJob.additional = EPS_ADDDATA_NONE;

    486. 

  486. 	printJob.qrcode.bits = NULL;

    487. 

  487. 	printJob.qrcode.cellNum = 0;

    488. 

  488. 	printJob.qrcode.dpc = 0; */

    489. 

  489. 

    490. 

  490. 	obsClear();

    491. 

  491. 

    492. 

  492. /*** Set "Endian-ness" for the current cpu                                              */

    493. 

  493. 	memInspectEndian();

    494. 

  494. 

    495. 

  495. /*** Set Communication Mode                                                             */

    496. 

  496.     printJob.commMode = commMode;

    497. 

  497. 

    498. 

  498. /*** Change ESC/P-R Lib Status                                                          */

    499. 

  499.     libStatus = EPS_STATUS_INITIALIZED;

    500. 

  500. 

    501. 

  501. /*** Return to Caller                                                                   */

    502. 

  502.     EPS_RETURN( EPS_ERR_NONE );

    503. 

  503. }

    504. 

  504. 

    505. 

  505. 

    506. 

  506. /*******************************************|********************************************/

    507. 

  507. /*                                                                                      */

    508. 

  508. /* Function name:     epsReleaseDriver()                                                */

    509. 

  509. /*                                                                                      */

    510. 

  510. /* Arguments                                                                            */

    511. 

  511. /* ---------                                                                            */

    512. 

  512. /* Name:            Type:                   Description:                                */

    513. 

  513. /* N/A              void                                                                */

    514. 

  514. /*                                                                                      */

    515. 

  515. /* Return value:                                                                        */

    516. 

  516. /*      << Normal >>                                                                    */

    517. 

  517. /*      EPS_ERR_NONE                     - Success                                      */

    518. 

  518. /*      << Error >>                                                                     */

    519. 

  519. /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */

    520. 

  520. /*                                                                                      */

    521. 

  521. /* Description:                                                                         */

    522. 

  522. /*      Creanup Driver.                                                                 */

    523. 

  523. /*                                                                                      */

    524. 

  524. /*******************************************|********************************************/

    525. 

  525. EPS_ERR_CODE epsReleaseDriver (

    526. 

  526. 	

    527. 

  527. 		void

    528. 

  528. 

    529. 

  529. ){

    530. 

  530. 	EPS_LOG_FUNCIN;

    531. 

  531. 

    532. 

  532. /*** Has a Lib been initialized                                                         */

    533. 

  533.     if (libStatus == EPS_STATUS_NOT_INITIALIZED) {

    534. 

  534.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    535. 

  535.     }

    536. 

  536. 

    537. 

  537. 	epsEndJob();

    538. 

  538. 

    539. 

  539. /*** Clear inside supported media list                                                  */

    540. 

  540. 	ClearSupportedMedia();

    541. 

  541. 

    542. 

  542. /*** Clear inside printer list                                                          */

    543. 

  543. 	prtClearPrinterList();

    544. 

  544. 	printJob.printer = NULL;

    545. 

  545. 	obsClear();

    546. 

  546. 

    547. 

  547. /*** Clear inside additional data buffer                                                */

    548. 

  548. 	/* DEL EPS_SAFE_RELEASE( printJob.qrcode.bits ) */

    549. 

  549. 

    550. 

  550. /*** Change ESC/P-R Lib Status                                                          */

    551. 

  551. 	libStatus = EPS_STATUS_NOT_INITIALIZED;

    552. 

  552. 

    553. 

  553. 	EPS_RETURN( EPS_ERR_NONE );

    554. 

  554. }

    555. 

  555. 

    556. 

  556. 

    557. 

  557. /*******************************************|********************************************/

    558. 

  558. /*                                                                                      */

    559. 

  559. /* Function name:     epsFindPrinter()                                                  */

    560. 

  560. /*                                                                                      */

    561. 

  561. /* Arguments                                                                            */

    562. 

  562. /* ---------                                                                            */

    563. 

  563. /* Name:            Type:                   Description:                                */

    564. 

  564. /* protocol			EPS_INT32               I: Protocol to be retrieved                 */

    565. 

  565. /* timeout          EPS_UINT32              I: Network pirinter find timeout            */

    566. 

  566. /*                                                                                      */

    567. 

  567. /* Return value:                                                                        */

    568. 

  568. /*      EPS_ERR_NONE                    - Success (printer found)                       */

    569. 

  569. /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */

    570. 

  570. /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */

    571. 

  571. /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */

    572. 

  572. /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */

    573. 

  573. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    574. 

  574. /*                                                                                      */

    575. 

  575. /* Description:                                                                         */

    576. 

  576. /*      find USB and Network printer.                                                   */

    577. 

  577. /*                                                                                      */

    578. 

  578. /*******************************************|********************************************/

    579. 

  579. EPS_ERR_CODE epsFindPrinter (

    580. 

  580. 

    581. 

  581.         EPS_INT32           protocol, 

    582. 

  582.         EPS_UINT32          timeout

    583. 

  583. 

    584. 

  584. ){

    585. 

  585. /*** Declare Variable Local to Routine                                                  */

    586. 

  586.     EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */

    587. 

  587. 

    588. 

  588. 	EPS_LOG_FUNCIN;

    589. 

  589. 

    590. 

  590. /*** Has a Lib been initialized                                                         */

    591. 

  591.     if (libStatus != EPS_STATUS_INITIALIZED) {

    592. 

  592.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    593. 

  593.     }

    594. 

  594. 

    595. 

  595. /*** Is a Job already open                                                              */

    596. 

  596.     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {

    597. 

  597.         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );

    598. 

  598.     }

    599. 

  599. 

    600. 

  600. /*** Clear inside printer list                                                          */

    601. 

  601. 	prtClearPrinterList();

    602. 

  602. 	printJob.printer = NULL;

    603. 

  603. 	obsClear();

    604. 

  604. 

    605. 

  605. /*** find                                                                               */

    606. 

  606. 	printJob.findStatus = EPS_STATUS_INITIALIZED;

    607. 

  607. 	

    608. 

  608. 	retStatus = prtFindPrinter( protocol, timeout );

    609. 

  609. 

    610. 

  610. 	printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;

    611. 

  611. 

    612. 

  612. 	EPS_RETURN( retStatus );

    613. 

  613. }

    614. 

  614. 

    615. 

  615. 

    616. 

  616. /*******************************************|********************************************/

    617. 

  617. /*                                                                                      */

    618. 

  618. /* Function name:     epsProbePrinter()                                                 */

    619. 

  619. /*                                                                                      */

    620. 

  620. /* Arguments                                                                            */

    621. 

  621. /* ---------                                                                            */

    622. 

  622. /* Name:            Type:                   Description:                                */

    623. 

  623. /* probeParam       EPS_PROBE*              I: prober parameter structure               */

    624. 

  624. /*                                                                                      */

    625. 

  625. /* Return value:                                                                        */

    626. 

  626. /*      EPS_ERR_NONE                    - Success (printer found)                       */

    627. 

  627. /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */

    628. 

  628. /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */

    629. 

  629. /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */

    630. 

  630. /*      EPS_ERR_INV_ARG_PROBEINFO       - Invalid argument probe infomation             */

    631. 

  631. /*      EPS_ERR_INV_ARG_UNK_METHOD      - Invalid value "method"                        */

    632. 

  632. /*      EPS_ERR_INV_ARG_PRINTER_ID      - Invalid format "identify"                     */

    633. 

  633. /*      EPS_ERR_INV_ARG_PRINTER_ADDR    - Invalid format "address"                      */

    634. 

  634. /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */

    635. 

  635. /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */

    636. 

  636. /*      EPS_ERR_PRINTER_NOT_USEFUL      - received but not usefl                        */

    637. 

  637. /*                                                                                      */

    638. 

  638. /* Description:                                                                         */

    639. 

  639. /*      printer specified by printerID or IP Address is retrieved.                      */

    640. 

  640. /*                                                                                      */

    641. 

  641. /*******************************************|********************************************/

    642. 

  642. EPS_ERR_CODE epsProbePrinter(

    643. 

  643. 

    644. 

  644. 		const EPS_PROBE*   probeParam

    645. 

  645. 		

    646. 

  646. ){

    647. 

  647. /*** Declare Variable Local to Routine                                                  */

    648. 

  648.     EPS_ERR_CODE    retStatus = EPS_ERR_NONE;       /* Return status of internal calls  */

    649. 

  649. 

    650. 

  650. 	EPS_LOG_FUNCIN;

    651. 

  651. 

    652. 

  652. /*** Validate input parameters                                                          */

    653. 

  653. 	if (NULL == probeParam) {

    654. 

  654. 		EPS_RETURN( EPS_ERR_INV_ARG_PROBEINFO );

    655. 

  655. 	}

    656. 

  656. 

    657. 

  657. /*** Has a Lib been initialized                                                         */

    658. 

  658.     if (libStatus != EPS_STATUS_INITIALIZED) {

    659. 

  659.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    660. 

  660.     }

    661. 

  661. 

    662. 

  662. /*** Is a Job already open                                                              */

    663. 

  663.     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {

    664. 

  664.         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );

    665. 

  665.     }

    666. 

  666. 

    667. 

  667. /*** Clear inside printer list                                                          */

    668. 

  668. 	prtClearPrinterList();

    669. 

  669. 	printJob.printer = NULL;

    670. 

  670. 	obsClear();

    671. 

  671. 

    672. 

  672. /*** probe                                                                              */

    673. 

  673. 	printJob.findStatus = EPS_STATUS_INITIALIZED;

    674. 

  674. 	switch( probeParam->method ){

    675. 

  675. 		case EPS_PRB_BYID:

    676. 

  676. 			retStatus = prtProbePrinterByID( probeParam );

    677. 

  677. 			break;

    678. 

  678. 

    679. 

  679. 		case EPS_PRB_BYADDR:

    680. 

  680. 			retStatus = prtProbePrinterByAddr( probeParam );

    681. 

  681. 			break;

    682. 

  682. 

    683. 

  683. 		default:

    684. 

  684. 			retStatus = EPS_ERR_INV_ARG_UNK_METHOD;

    685. 

  685. 	}

    686. 

  686. 	printJob.findStatus = EPS_STATUS_NOT_INITIALIZED;

    687. 

  687. 

    688. 

  688. 	EPS_RETURN( retStatus );

    689. 

  689. }

    690. 

  690. 

    691. 

  691. 

    692. 

  692. /*******************************************|********************************************/

    693. 

  693. /*                                                                                      */

    694. 

  694. /* Function name:     epsCancelFindPrinter()                                            */

    695. 

  695. /*                                                                                      */

    696. 

  696. /* Arguments                                                                            */

    697. 

  697. /* ---------                                                                            */

    698. 

  698. /* Name:            Type:                   Description:                                */

    699. 

  699. /* N/A              void                                                                */

    700. 

  700. /*                                                                                      */

    701. 

  701. /* Return value:                                                                        */

    702. 

  702. /*      EPS_ERR_NONE                    - Success                                       */

    703. 

  703. /*      EPS_ERR_LIB_NOT_INITIALIZED     - not initialized                               */

    704. 

  704. /*      EPS_ERR_FIND_NOT_STARTED        - find not started                              */

    705. 

  705. /*      EPS_ERR_INVALID_CALL            - invalid called                                */

    706. 

  706. /*                                                                                      */

    707. 

  707. /* Description:                                                                         */

    708. 

  708. /*      Cancel the epsFindPrinter(), epsProbePrinter() process.                         */

    709. 

  709. /*                                                                                      */

    710. 

  710. /*******************************************|********************************************/

    711. 

  711. EPS_ERR_CODE epsCancelFindPrinter (

    712. 

  712. 

    713. 

  713. 	void

    714. 

  714. 

    715. 

  715. ){

    716. 

  716. 	EPS_LOG_FUNCIN;

    717. 

  717. 

    718. 

  718.  /*** Has a Lib been initialized                                                        */

    719. 

  719.     if (libStatus != EPS_STATUS_INITIALIZED) {

    720. 

  720.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    721. 

  721.     }

    722. 

  722. 

    723. 

  723. /*** Has a Find been started                                                            */

    724. 

  724.     if (printJob.findStatus != EPS_STATUS_INITIALIZED) {

    725. 

  725.         EPS_RETURN( EPS_ERR_FIND_NOT_STARTED );

    726. 

  726.     }

    727. 

  727. 	

    728. 

  728. 	EPS_RETURN( prtCancelFindPrinter() );

    729. 

  729. }

    730. 

  730. 

    731. 

  731. 

    732. 

  732. /*******************************************|********************************************/

    733. 

  733. /*                                                                                      */

    734. 

  734. /* Function name:     epsSetPrinter()                                                   */

    735. 

  735. /*                                                                                      */

    736. 

  736. /* Arguments                                                                            */

    737. 

  737. /* ---------                                                                            */

    738. 

  738. /* Name:            Type:                   Description:                                */

    739. 

  739. /* printer          EPS_PRINTER*            O: Pointer to a target printer              */

    740. 

  740. /*                                                                                      */

    741. 

  741. /* Return value:                                                                        */

    742. 

  742. /*      EPS_ERR_NONE                    - Success                                       */

    743. 

  743. /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */

    744. 

  744. /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */

    745. 

  745. /*      EPS_ERR_INV_ARG_PRINTER         - Illegal printer was specified                 */

    746. 

  746. /*      EPS_ERR_INV_ARG_COMMMODE        - Invalid argument "printer.protocol"           */

    747. 

  747. /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */

    748. 

  748. /*      EPS_ERR_INV_ARG_PRINTER_ADDR    - Invalid format " printer.location"            */

    749. 

  749. /*      EPS_ERR_INV_PRINT_LANGUAGE      - Invalid argument "printer.language"           */

    750. 

  750. /*                                                                                      */

    751. 

  751. /* Description:                                                                         */

    752. 

  752. /*      Selects a printer to use from detected printers.                                */

    753. 

  753. /*      Register a user specified printer.				                                */

    754. 

  754. /*                                                                                      */

    755. 

  755. /*******************************************|********************************************/

    756. 

  756. EPS_ERR_CODE    epsSetPrinter (

    757. 

  757. 

    758. 

  758.         const EPS_PRINTER*      printer

    759. 

  759. 

    760. 

  760. ){

    761. 

  761. /*** Declare Variable Local to Routine                                                  */

    762. 

  762.     EPS_ERR_CODE		ret = EPS_ERR_NONE;			/* Return status of internal calls  */

    763. 

  763. 	EPS_PRINTER_INN*	innerPrinter = NULL;

    764. 

  764. 

    765. 

  765. EPS_LOG_FUNCIN;

    766. 

  766. 

    767. 

  767. /*** Has a Lib been initialized                                                         */

    768. 

  768.     if (libStatus != EPS_STATUS_INITIALIZED) {

    769. 

  769.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    770. 

  770.     }

    771. 

  771. 

    772. 

  772. /*** Is a Job already open                                                              */

    773. 

  773.     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {

    774. 

  774.         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );

    775. 

  775.     }

    776. 

  776. 

    777. 

  777. /*** Validate input parameters                                                          */

    778. 

  778. 	if (NULL == printer){

    779. 

  779. 		EPS_RETURN( EPS_ERR_INV_ARG_PRINTER );

    780. 

  780. 	}

    781. 

  781. 

    782. 

  782. /*** convert internal structure                                                         */

    783. 

  783. 	innerPrinter = prtGetInnerPrinter(printer);

    784. 

  784. 	if( NULL == innerPrinter ){

    785. 

  785. 		ret = prtAddUsrPrinter(printer, &innerPrinter);

    786. 

  786. 		if( EPS_ERR_NONE != ret ){

    787. 

  787. 			EPS_RETURN( ret );

    788. 

  788. 		}

    789. 

  789. 	}

    790. 

  790. 

    791. 

  791. /*** Set Job target printer                                                             */

    792. 

  792. 	printJob.printer	= innerPrinter;

    793. 

  793. 	printJob.bComm		= TRUE;

    794. 

  794. 	obsSetPrinter(innerPrinter);

    795. 

  795. 	prtSetupJobFunctions(printJob.printer, &jobFnc);	/* Set Job functions */

    796. 

  796. 

    797. 

  797. 	EPS_RETURN( EPS_ERR_NONE );

    798. 

  798. }

    799. 

  799. 

    800. 

  800. 

    801. 

  801. /*******************************************|********************************************/

    802. 

  802. /*                                                                                      */

    803. 

  803. /* Function name:     epsStartJob()                                                     */

    804. 

  804. /*                                                                                      */

    805. 

  805. /* Arguments                                                                            */

    806. 

  806. /* ---------                                                                            */

    807. 

  807. /* Name:            Type:                   Description:                                */

    808. 

  808. /* jobAttr          const EPS_JOB_ATTRIB*   I: Print Job Attribute                      */

    809. 

  809. /*                                                                                      */

    810. 

  810. /* Return value:                                                                        */

    811. 

  811. /*      << Normal >>                                                                    */

    812. 

  812. /*      EPS_ERR_NONE                    - Success                                       */

    813. 

  813. /*      << Error >>                                                                     */

    814. 

  814. /*      EPS_ERR_INV_ARG_JOB_ATTRIB              - Invalid argument "jobAttr"           */

    815. 

  815. /*      EPS_ERR_INV_COLOR_PLANE                 - Invalid Color Plane                   */

    816. 

  816. /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */

    817. 

  817. /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */

    818. 

  818. /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */

    819. 

  819. /*      EPS_ERR_INV_MEDIA_TYPE                  - Invalid Media Type                    */

    820. 

  820. /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */

    821. 

  821. /*      EPS_ERR_INV_PRINT_QUALITY               - Invalid Print Quality                 */

    822. 

  822. /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */

    823. 

  823. /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */

    824. 

  824. /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */

    825. 

  825. /*      EPS_ERR_INV_BRIGHTNESS                  - Invalid Brightness                    */

    826. 

  826. /*      EPS_ERR_INV_CONTRAST                    - Invalid Contrast                      */

    827. 

  827. /*      EPS_ERR_INV_SATURATION                  - Invalid Saturation                    */

    828. 

  828. /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */

    829. 

  829. /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */

    830. 

  830. /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */

    831. 

  831. /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */

    832. 

  832. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */

    833. 

  833. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */

    834. 

  834. /*      EPS_ERR_INV_PAPER_SOURCE                - Invalid Paper source                  */

    835. 

  835. /*      EPS_ERR_INV_DUPLEX                      - Invalid duplex                        */

    836. 

  836. /*      EPS_ERR_INV_FEED_DIRECTION              - Invalid feed direction                */

    837. 

  837. /*      EPS_ERR_LANGUAGE_NOT_SUPPORTED          - Unsupported function Error (language) */

    838. 

  838. /*                                                                                      */

    839. 

  839. /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */

    840. 

  840. /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */

    841. 

  841. /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */

    842. 

  842. /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Red Eye                   */

    843. 

  843. /*                                                                                      */

    844. 

  844. /*      (Uni/Bi-Directional)                                                            */

    845. 

  845. /*      EPS_ERR_LIB_NOT_INITIALIZED     - ESC/P-R Lib is NOT initialized                */

    846. 

  846. /*      EPS_ERR_JOB_NOT_CLOSED          - JOB is NOT finished                           */

    847. 

  847. /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */

    848. 

  848. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    849. 

  849. /*      EPS_ERR_MEMORY_ALLOCATION       - Fail to memory allocation                     */

    850. 

  850. /*      (Bi-Directional Only)                                                           */

    851. 

  851. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    852. 

  852. 

    853. 

  853. /*                                                                                      */

    854. 

  854. /* Description:                                                                         */

    855. 

  855. /*      Creates a new print job.                                                        */

    856. 

  856. /*                                                                                      */

    857. 

  857. /*******************************************|********************************************/

    858. 

  858. EPS_ERR_CODE    epsStartJob (

    859. 

  859. 

    860. 

  860.         const EPS_JOB_ATTRIB*     jobAttr  /* Print Attributes for this Job            */

    861. 

  861. 

    862. 

  862. ){

    863. 

  863. 

    864. 

  864. /*** Declare Variable Local to Routine                                                  */

    865. 

  865. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;           /* Return status of internal calls  */

    866. 

  866. EPS_STATUS_INFO stInfo;

    867. 

  867. 

    868. 

  868. EPS_LOG_FUNCIN;

    869. 

  869. 

    870. 

  870. /*** Has a Lib been initialized                                                         */

    871. 

  871.     if (libStatus != EPS_STATUS_INITIALIZED) {

    872. 

  872.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    873. 

  873.     }

    874. 

  874. 

    875. 

  875. /*** Is a Job already open                                                              */

    876. 

  876.     if (printJob.jobStatus != EPS_STATUS_NOT_INITIALIZED) {

    877. 

  877.         EPS_RETURN( EPS_ERR_JOB_NOT_CLOSED );

    878. 

  878.     }

    879. 

  879. 	

    880. 

  880. /*** Has a target printer specified                                                     */

    881. 

  881. 	if(NULL == printJob.printer){

    882. 

  882. 		EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );

    883. 

  883. 	}

    884. 

  884. 

    885. 

  885. 	if(EPS_CP_JPEG == jobAttr->colorPlane ){

    886. 

  886. 		if( !(EPS_SPF_JPGPRINT & printJob.printer->supportFunc) ){

    887. 

  887. 			EPS_RETURN( EPS_ERR_INV_COLOR_PLANE );

    888. 

  888. 		}

    889. 

  889. 	}

    890. 

  890. 

    891. 

  891. /*======================================================================================*/

    892. 

  892. /*** Setup Page Attribute                                                               */

    893. 

  893. /*======================================================================================*/

    894. 

  894. 	if (jobAttr == NULL){

    895. 

  895.         EPS_RETURN( EPS_ERR_INV_ARG_JOB_ATTRIB )

    896. 

  896. 	}

    897. 

  897. 

    898. 

  898. 	if(EPS_LANG_ESCPR == printJob.printer->language ){

    899. 

  899. 		/*** ESC/P-R ***/

    900. 

  900. 		retStatus = SetupJobAttrib(jobAttr);

    901. 

  901. 	} else{

    902. 

  902. 		/*** ESC/Page ***/

    903. 

  903. #ifdef GCOMSW_CMD_ESCPAGE

    904. 

  904. 		retStatus = pageInitJob(jobAttr);

    905. 

  905. #else

    906. 

  906. 		retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    907. 

  907. #endif

    908. 

  908. 	} 

    909. 

  909. 	if (EPS_ERR_NONE != retStatus){

    910. 

  910. 		EPS_RETURN( retStatus );

    911. 

  911. 	}

    912. 

  912. 

    913. 

  913. /*** Change Job Status                                                                  */

    914. 

  914.     printJob.jobStatus = EPS_STATUS_INITIALIZED;

    915. 

  915. 	obsSetColorPlane( printJob.attr.colorPlane );

    916. 

  916. 

    917. 

  917. /*======================================================================================*/

    918. 

  918. /*** Check the printer status. (before session open)                                    */

    919. 

  919. /*======================================================================================*/

    920. 

  920. 	memset(&stInfo, 0, sizeof(stInfo));

    921. 

  921. 	if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    922. 

  922. 		retStatus = PRT_INVOKE_JOBFNC(jobFnc.GetStatus, (&stInfo, NULL, NULL));

    923. 

  923. 		if( EPS_ERR_NONE != retStatus ){

    924. 

  924. 			goto epsStartJob_END;

    925. 

  925. 		} else if(EPS_ST_IDLE != stInfo.nState){

    926. 

  926. 			retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    927. 

  927. 			goto epsStartJob_END;

    928. 

  928. 		} else if( EPS_PRNWARN_DISABLE_CLEAN & stInfo.nWarn && 

    929. 

  929. 			      EPS_MNT_CLEANING == printJob.attr.cmdType ){

    930. 

  930. 			retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    931. 

  931. 			goto epsStartJob_END;

    932. 

  932. 		}

    933. 

  933. 		/* ignore color-ink-end warning 

    934. 

  934. 		   if color print done, will occuer EPS_PRNERR_INKOUT(0x47).

    935. 

  935. 		else if( EPS_PRNWARN_COLOR_INKOUT & stInfo.nWarn ){

    936. 

  936. 			if( !((EPS_CP_FULLCOLOR == printJob.attr.colorPlane || EPS_CP_256COLOR == printJob.attr.colorPlane)

    937. 

  937. 				&& EPS_CM_MONOCHROME == printJob.attr.colorMode

    938. 

  938. 				&& EPS_MTID_PLAIN == printJob.attr.mediaTypeIdx

    939. 

  939. 				&& (EPS_MLID_BORDERS == printJob.attr.printLayout || EPS_MLID_CUSTOM == printJob.attr.printLayout)) ){

    940. 

  940. 				 color printing is impossible. (Mono/Plain/Border is possible) 

    941. 

  941. 				retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    942. 

  942. 				goto epsStartJob_END;

    943. 

  943. 			}

    944. 

  944. 		}*/

    945. 

  945. 	}

    946. 

  946. 

    947. 

  947. /*======================================================================================*/

    948. 

  948. /*** Prepar RGB buffer                                                                  */

    949. 

  949. /*======================================================================================*/

    950. 

  950. 	if(EPS_LANG_ESCPR == printJob.printer->language ){

    951. 

  951. 		/*** ESC/P-R ***/

    952. 

  952. 		if( EPS_CP_FULLCOLOR == printJob.attr.colorPlane ||

    953. 

  953. 			EPS_CP_256COLOR  == printJob.attr.colorPlane){

    954. 

  954. 			/*** Allocate buffer for "Send Data" command                                    */

    955. 

  955. 			EPS_SAFE_RELEASE(sendDataBuf );

    956. 

  956. 			EPS_SAFE_RELEASE(tmpLineBuf  );

    957. 

  957. 			

    958. 

  958. 			sendDataBufSize = (EPS_INT32)(ESCPR_HEADER_LENGTH    +

    959. 

  959. 										  ESCPR_SEND_DATA_LENGTH +

    960. 

  960. 										  (printJob.printableAreaWidth * printJob.bpp));

    961. 

  961. 			sendDataBuf = (EPS_UINT8*)EPS_ALLOC(sendDataBufSize);

    962. 

  962. 			if(sendDataBuf == NULL){

    963. 

  963. 				sendDataBufSize = 0;

    964. 

  964. 				EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );

    965. 

  965. 			}

    966. 

  966. 		    

    967. 

  967. 			memset(sendDataBuf, 0xFF, (EPS_UINT32)sendDataBufSize);

    968. 

  968. 		    

    969. 

  969. 			/*** Allocate buffer for RLE complession                                        */

    970. 

  970. 			tmpLineBufSize = (EPS_INT32)(printJob.printableAreaWidth * printJob.bpp) + 256; /* 256 is temp buffer */

    971. 

  971. 			tmpLineBuf = (EPS_UINT8*)EPS_ALLOC(tmpLineBufSize);

    972. 

  972. 			if(tmpLineBuf == NULL){

    973. 

  973. 				tmpLineBufSize = 0;

    974. 

  974. 				EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );

    975. 

  975. 			}

    976. 

  976. 			memset(tmpLineBuf, 0xFF, (EPS_UINT32)tmpLineBufSize);

    977. 

  977. 

    978. 

  978. 		} else if(EPS_CP_JPEG == printJob.attr.colorPlane){

    979. 

  979. 			if(0 == printJob.printer->JpgMax){

    980. 

  980. 				/*** get jpeg limit */

    981. 

  981. 				retStatus = GetJpgMax(printJob.printer);

    982. 

  982. 				if (retStatus != EPS_ERR_NONE) {

    983. 

  983. 					goto epsStartJob_END;

    984. 

  984. 				}

    985. 

  985. 			}

    986. 

  986. 		}

    987. 

  987. 	} else{

    988. 

  988. #ifdef GCOMSW_CMD_ESCPAGE

    989. 

  989. 		/*** ESC/Page ***/

    990. 

  990. 		retStatus = pageAllocBuffer();

    991. 

  991. #else

    992. 

  992. 		retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    993. 

  993. #endif

    994. 

  994. 		if (retStatus != EPS_ERR_NONE) {

    995. 

  995. 			goto epsStartJob_END;

    996. 

  996. 		}

    997. 

  997. 	}

    998. 

  998. 

    999. 

  999. /*======================================================================================*/

    1000. 

  1000. /*** protocol depend StartJob                                                           */

    1001. 

  1001. /*======================================================================================*/

    1002. 

  1002. 	retStatus = jobFnc.StartJob();

    1003. 

  1003. 	if (retStatus != EPS_ERR_NONE) {

    1004. 

  1004. 		goto epsStartJob_END;

    1005. 

  1005. 	}

    1006. 

  1006. 

    1007. 

  1007. /*======================================================================================*/

    1008. 

  1008. /*** Init flags                                                                         */

    1009. 

  1009. /*======================================================================================*/

    1010. 

  1010. 	printJob.transmittable = TRUE;

    1011. 

  1011. 	printJob.resetSent = EPS_RESET_NOT_SENT;

    1012. 

  1012. 	printJob.resetReq = FALSE;

    1013. 

  1013. 	printJob.bComm = TRUE;

    1014. 

  1014. 	printJob.sendJS = FALSE;

    1015. 

  1015. 	printJob.pageCount = 0;

    1016. 

  1016. 	gStatusCount = 0;

    1017. 

  1017. 

    1018. 

  1018. 	printJob.contData.savePoint = EPS_SAVEP_NONE;

    1019. 

  1019. 	printJob.contData.saveStep = 0;

    1020. 

  1020. 	printJob.contData.sendData = NULL;

    1021. 

  1021. 	printJob.contData.sendDataSize = 0;

    1022. 

  1022. 

    1023. 

  1023. /*======================================================================================*/

    1024. 

  1024. /*** Send StartJob Commands                                                             */

    1025. 

  1025. /*======================================================================================*/

    1026. 

  1026. #ifdef LCOMSW_CMDDMP

    1027. 

  1027. {

    1028. 

  1028. 	EPS_INT8 fname[256];

    1029. 

  1029. 	sprintf(fname, "%s-%s-%s.prn", (printJob.printer->language == EPS_LANG_ESCPR)?"escpr":"page",

    1030. 

  1030. 		(printJob.attr.colorMode == EPS_CM_COLOR)?"color":"mono",

    1031. 

  1031. 		(printJob.attr.colorPlane == EPS_CP_FULLCOLOR)?"24":"8");

    1032. 

  1032. 	EPS_DF_OPEN(fname)

    1033. 

  1033. }

    1034. 

  1034. #endif

    1035. 

  1035. 

    1036. 

  1036. 	if( EPS_CP_PRINTCMD != printJob.attr.colorPlane ){

    1037. 

  1037. 		if(EPS_LANG_ESCPR == printJob.printer->language ){

    1038. 

  1038. 			/*** ESC/P-R ***/

    1039. 

  1039. 			if(EPS_PM_JOB != obsGetPageMode()){

    1040. 

  1040. 				retStatus = SendStartJob(FALSE);

    1041. 

  1041. 			}

    1042. 

  1042. 		} else{

    1043. 

  1043. 			/*** ESC/Page ***/

    1044. 

  1044. #ifdef GCOMSW_CMD_ESCPAGE

    1045. 

  1045. 			retStatus = pageStartJob();

    1046. 

  1046. #else

    1047. 

  1047. 			retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    1048. 

  1048. #endif

    1049. 

  1049. 		}

    1050. 

  1050. 

    1051. 

  1051. 		if(EPS_ERR_NONE != retStatus){

    1052. 

  1052. 			goto epsStartJob_END;

    1053. 

  1053. 		}

    1054. 

  1054. 	} else{

    1055. 

  1055. 		printJob.pageStatus = EPS_STATUS_INITIALIZED;

    1056. 

  1056. 	}

    1057. 

  1057. 

    1058. 

  1058. 	printJob.jobStatus = EPS_STATUS_ESTABLISHED;

    1059. 

  1059. 

    1060. 

  1060. epsStartJob_END:

    1061. 

  1061. /*** Return to Caller                                                                   */

    1062. 

  1062. 	if (EPS_ERR_NOT_OPEN_IO == retStatus || EPS_ERR_COMM_ERROR == retStatus) {

    1063. 

  1063. 		printJob.bComm = FALSE;

    1064. 

  1064. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1065. 

  1065. 	}

    1066. 

  1066. 

    1067. 

  1067.     EPS_RETURN( retStatus );

    1068. 

  1068. }

    1069. 

  1069. 

    1070. 

  1070. 

    1071. 

  1071. /*******************************************|********************************************/

    1072. 

  1072. /*                                                                                      */

    1073. 

  1073. /* Function name:     epsStartPage()                                                    */

    1074. 

  1074. /*                                                                                      */

    1075. 

  1075. /* Arguments                                                                            */

    1076. 

  1076. /* ---------                                                                            */

    1077. 

  1077. /* Name:        Type:					Description:                                    */

    1078. 

  1078. /* pageAttr     const EPS_JOB_ATTRIB*   I: This Page Attribute                          */

    1079. 

  1079. /*                                                                                      */

    1080. 

  1080. /* Return value:                                                                        */

    1081. 

  1081. /*      << Normal >>                                                                    */

    1082. 

  1082. /*      EPS_ERR_NONE                            - Success                               */

    1083. 

  1083. /*      EPS_JOB_CANCELED                        - Cancelled operation by user           */

    1084. 

  1084. /*                                                (Do not return when Uni-Directional)  */

    1085. 

  1085. /*      << Error >>                                                                     */

    1086. 

  1086. /*      EPS_ERR_JOB_NOT_INITIALIZED             - JOB is NOT initialized                */

    1087. 

  1087. /*      EPS_ERR_PAGE_NOT_CLOSED                 - PAGE is NOT closed                    */

    1088. 

  1088. /*      EPS_ERR_PRINTER_ERR_OCCUR				- Printer Error happened                */

    1089. 

  1089. /*      EPS_ERR_OPR_FAIL                        - Internal Error                        */

    1090. 

  1090. /*      EPS_ERR_MEMORY_ALLOCATION               - Failed to allocate memory             */

    1091. 

  1091. /*                                                                                      */

    1092. 

  1092. /* Description:                                                                         */

    1093. 

  1093. /*      Starts the current page.                                                        */

    1094. 

  1094. /*                                                                                      */

    1095. 

  1095. /*******************************************|********************************************/

    1096. 

  1096. EPS_ERR_CODE    epsStartPage (

    1097. 

  1097. 

    1098. 

  1098.         const EPS_PAGE_ATTRIB* pageAttr

    1099. 

  1099. 

    1100. 

  1100. ){

    1101. 

  1101. /*** Declare Variable Local to Routine                                                  */

    1102. 

  1102. EPS_ERR_CODE    retStatus;                  /* Return status of internal calls          */

    1103. 

  1103. EPS_UINT32      retBufSize = 0;

    1104. 

  1104. EPS_STATUS_INFO stInfo;

    1105. 

  1105. 

    1106. 

  1106. EPS_LOG_FUNCIN;

    1107. 

  1107. 

    1108. 

  1108. 	(void)pageAttr;		/* unused now */

    1109. 

  1109. 

    1110. 

  1110. /*** EPS_CP_PRINTCMD not necessary call epsStartPage()                                  */

    1111. 

  1111.     if (EPS_CP_PRINTCMD == printJob.attr.colorPlane) {

    1112. 

  1112.         EPS_RETURN( EPS_ERR_NONE );

    1113. 

  1113.     }

    1114. 

  1114. 

    1115. 

  1115. /*** Has a Job been initialized                                                         */

    1116. 

  1116.     if (printJob.jobStatus != EPS_STATUS_ESTABLISHED) {

    1117. 

  1117.         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );

    1118. 

  1118.     }

    1119. 

  1119. 

    1120. 

  1120. /*** Has the Page Status been un-initialized; indicating the last page was closed       */

    1121. 

  1121.     if (printJob.pageStatus != EPS_STATUS_NOT_INITIALIZED) {

    1122. 

  1122.         EPS_RETURN( EPS_ERR_PAGE_NOT_CLOSED );

    1123. 

  1123.     }

    1124. 

  1124. 

    1125. 

  1125. /*** Check the printer status and the stacker error.                                    */

    1126. 

  1126. 	if ( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    1127. 

  1127. 		retStatus = MonitorStatus(&stInfo);

    1128. 

  1128. 

    1129. 

  1129. 		if( EPS_ERR_NONE == retStatus ){

    1130. 

  1130. 			if( EPS_PREPARE_TRAYCLOSED == stInfo.nPrepare ){

    1131. 

  1131. 				retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1132. 

  1132. 			} else if( EPS_PM_JOB == obsGetPageMode() &&

    1133. 

  1133. 					   EPS_ST_IDLE != stInfo.nState ){

    1134. 

  1134. 				/* still printing */

    1135. 

  1135. 				EPS_DBGPRINT(("*** StarPage Wait ***\n"))

    1136. 

  1136. 				retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1137. 

  1137. 			}

    1138. 

  1138. 		}

    1139. 

  1139. 		if( EPS_ERR_NONE != retStatus ){

    1140. 

  1140. 			if( EPS_ERR_COMM_ERROR != retStatus && 

    1141. 

  1141. 				EPS_PROTOCOL_USB != EPS_PRT_PROTOCOL(printJob.printer->protocol) )

    1142. 

  1142. 			{	/* Ignore error, Make buffer full state. */

    1143. 

  1143. 				EPS_DBGPRINT(("*** Ignore error on StartPage ***\n"))

    1144. 

  1144. 				retStatus = EPS_ERR_NONE;

    1145. 

  1145. 			} else{

    1146. 

  1146. 				goto epsStartPage_END;

    1147. 

  1147. 			}

    1148. 

  1148. 		}

    1149. 

  1149. 	}

    1150. 

  1150. 

    1151. 

  1151. 	if( EPS_PM_JOB == obsGetPageMode() &&

    1152. 

  1152. 		EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol) ){

    1153. 

  1153. 		retStatus = PRT_INVOKE_JOBFNC(jobFnc.StartPage, ());

    1154. 

  1154. 		if (retStatus != EPS_ERR_NONE) {

    1155. 

  1155. 			goto epsStartPage_END;

    1156. 

  1156. 		}

    1157. 

  1157. 	}

    1158. 

  1158. 	if( EPS_RESET_SENT == printJob.resetSent ){

    1159. 

  1159. 		/* If CancelPage is done, restart Job. */

    1160. 

  1160.         /*** protocol depend RestartJob                                                 */

    1161. 

  1161. 		retStatus = PRT_INVOKE_JOBFNC(jobFnc.RestartJob, ());

    1162. 

  1162. 		if (retStatus != EPS_ERR_NONE) {

    1163. 

  1163. 			goto epsStartPage_END;

    1164. 

  1164. 		}

    1165. 

  1165. 	}

    1166. 

  1166. 

    1167. 

  1167. 	if(0 == printJob.contData.saveStep){

    1168. 

  1168. 		if(EPS_LANG_ESCPR == printJob.printer->language ){

    1169. 

  1169. 			/*** ESC/P-R ***/

    1170. 

  1170. 			if( EPS_RESET_SENT == printJob.resetSent ){

    1171. 

  1171. 				/* If CancelPage is done, restart Job complete. */

    1172. 

  1172. 				printJob.resetSent = EPS_RESET_NOT_SENT;

    1173. 

  1173. 				/*** Send StartJob & StartPage Commands                                     */

    1174. 

  1174. 				retStatus = SendStartJob(TRUE);

    1175. 

  1175. 			} else if( EPS_PM_JOB == obsGetPageMode() ){

    1176. 

  1176. 				/*** Send StartJob & StartPage Commands                                     */

    1177. 

  1177. 				retStatus = SendStartJob(TRUE);

    1178. 

  1178. 			} else{

    1179. 

  1179. 				/*** Send StartPage Commands                                                */

    1180. 

  1180. 				EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, sizeof(StartPage) )

    1181. 

  1181. 				if(NULL == sendDataBuf){

    1182. 

  1182. 					sendDataBufSize = 0;

    1183. 

  1183. 					retStatus = EPS_ERR_MEMORY_ALLOCATION;

    1184. 

  1184. 					goto epsStartPage_END;

    1185. 

  1185. 				}

    1186. 

  1186. 

    1187. 

  1187. 				memcpy(sendDataBuf, StartPage, sizeof(StartPage));

    1188. 

  1188. 				retStatus = SendCommand(sendDataBuf, sizeof(StartPage), &retBufSize, TRUE);

    1189. 

  1189. 			}

    1190. 

  1190. 		} else{

    1191. 

  1191. 			/*** ESC/Page ***/

    1192. 

  1192. #ifdef GCOMSW_CMD_ESCPAGE

    1193. 

  1193. 			retStatus = pageStartPage();

    1194. 

  1194. #else

    1195. 

  1195. 			retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    1196. 

  1196. #endif

    1197. 

  1197. 		}

    1198. 

  1198. 	} else{

    1199. 

  1199. 		/* send command retry */

    1200. 

  1200. 		retStatus = SendLeftovers();

    1201. 

  1201. 		if(EPS_ERR_INVALID_CALL == retStatus){

    1202. 

  1202. 			retStatus = EPS_ERR_NONE;

    1203. 

  1203. 		}

    1204. 

  1204. 	}

    1205. 

  1205. 	if(EPS_ERR_NONE == retStatus){

    1206. 

  1206. 		printJob.contData.saveStep = 0;

    1207. 

  1207. 	} else{

    1208. 

  1208. 		printJob.contData.saveStep = 1;

    1209. 

  1209. 	}

    1210. 

  1210. 

    1211. 

  1211. epsStartPage_END:

    1212. 

  1212. 	if(EPS_ERR_NONE == retStatus){

    1213. 

  1213. 		/*** Change Page Status                                                         */

    1214. 

  1214. 		printJob.pageStatus = EPS_STATUS_INITIALIZED;

    1215. 

  1215. 		printJob.contData.savePoint = EPS_SAVEP_NONE;

    1216. 

  1216. 

    1217. 

  1217. 		/*** Set Vertical Offset                                                        */

    1218. 

  1218.         printJob.verticalOffset = 0;

    1219. 

  1219. 		printJob.contData.jpgSize = 0;

    1220. 

  1220. 		printJob.contData.epRetry = 0;

    1221. 

  1221. 		printJob.contData.skipLine = FALSE;

    1222. 

  1222. 		printJob.jpegSize = 0;

    1223. 

  1223. 		printJob.bJpgLimit = FALSE;

    1224. 

  1224. 		if( printJob.attr.duplex != EPS_DUPLEX_NONE ){

    1225. 

  1225. 			printJob.needBand = TRUE;

    1226. 

  1226. 		} else{

    1227. 

  1227. 			printJob.needBand = FALSE;

    1228. 

  1228. 		}

    1229. 

  1229. 		

    1230. 

  1230. 	} else if(EPS_ERR_COMM_ERROR == retStatus){

    1231. 

  1231. 		printJob.bComm = FALSE;

    1232. 

  1232. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1233. 

  1233. 	} else{

    1234. 

  1234. 		printJob.contData.savePoint = EPS_SAVEP_START_PAGE;

    1235. 

  1235. 	}

    1236. 

  1236. 

    1237. 

  1237. /*** Return to Caller                                                                   */

    1238. 

  1238.     EPS_RETURN( retStatus );

    1239. 

  1239. }

    1240. 

  1240. 

    1241. 

  1241. 

    1242. 

  1242. /*******************************************|********************************************/

    1243. 

  1243. /*                                                                                      */

    1244. 

  1244. /* Function name:     epsPrintBand()                                                    */

    1245. 

  1245. /*                                                                                      */

    1246. 

  1246. /* Arguments                                                                            */

    1247. 

  1247. /* ---------                                                                            */

    1248. 

  1248. /* Name:        Type:               Description:                                        */

    1249. 

  1249. /* data          EPS_UINT8*         I: Pointer to image [RGB] data                      */

    1250. 

  1250. /* widthPixels   EPS_UINT32         I: The width of the raster band (in pixels)         */

    1251. 

  1251. /* heightPixels  EPS_UINT32*        I/O: In : Height of image (image lines)  (in pixels)*/

    1252. 

  1252. /*                                     : Out: Sent Height                               */

    1253. 

  1253. /*                                                                                      */

    1254. 

  1254. /* Return value:                                                                        */

    1255. 

  1255. /*      << Normal >>                                                                    */

    1256. 

  1256. /*      EPS_ERR_NONE                    - Success                                       */

    1257. 

  1257. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    1258. 

  1258. /*                                        (Do not return when Uni-Directional)          */

    1259. 

  1259. /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */

    1260. 

  1260. /*      << Error >>                                                                     */

    1261. 

  1261. /*      EPS_ERR_PAGE_NOT_INITIALIZED    - Page is NOT initialized                       */

    1262. 

  1262. /*      EPS_ERR_INV_ARG_DATA            - Invalid argument "data"                       */

    1263. 

  1263. /*      EPS_ERR_INV_ARG_WIDTH_PIXELS    - Invalid argument "widthPixels"                */

    1264. 

  1264. /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */

    1265. 

  1265. /*      EPS_ERR_INV_ARG_DATASIZE		- data size limit								*/

    1266. 

  1266. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    1267. 

  1267. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    1268. 

  1268. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    1269. 

  1269. /*                                                                                      */

    1270. 

  1270. /* Description:                                                                         */

    1271. 

  1271. /*      Prints a band of raster data or Jpeg file data.                                 */

    1272. 

  1272. /*                                                                                      */

    1273. 

  1273. /*******************************************|********************************************/

    1274. 

  1274. EPS_ERR_CODE    epsPrintBand (

    1275. 

  1275. 

    1276. 

  1276.         const EPS_UINT8*  data,             /* Pointer to image [RGB] data              */

    1277. 

  1277.         EPS_UINT32  widthPixels,            /* Width of image [ in pixels ]             */

    1278. 

  1278.         EPS_UINT32  *heightPixels           /* Height of image (image lines)            */

    1279. 

  1279. 

    1280. 

  1280. ) {

    1281. 

  1281. /*** Declare Variable Local to Routine                                                  */

    1282. 

  1282. 	EPS_ERR_CODE    retStatus;

    1283. 

  1283. 	EPS_PRN_DATA	prnData;

    1284. 

  1284. 

    1285. 

  1285. 	prnData.version = 1;

    1286. 

  1286. 	prnData.band.data = data;

    1287. 

  1287. 	prnData.band.widthPixels = widthPixels;

    1288. 

  1288. 	prnData.band.heightPixels = *heightPixels;

    1289. 

  1289. 

    1290. 

  1290. 	retStatus = epsSendData(&prnData);

    1291. 

  1291. 

    1292. 

  1292. 	*heightPixels = prnData.band.heightPixels;

    1293. 

  1293. 

    1294. 

  1294. 	return retStatus;

    1295. 

  1295. }

    1296. 

  1296. 

    1297. 

  1297. 

    1298. 

  1298. EPS_ERR_CODE    epsSendData (

    1299. 

  1299. 

    1300. 

  1300.         EPS_PRN_DATA*  prnData				/* Pointer to image [RGB, JPEG] data        */

    1301. 

  1301. 

    1302. 

  1302. ) {

    1303. 

  1303. /*** Declare Variable Local to Routine                                                  */

    1304. 

  1304. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;

    1305. 

  1305. 

    1306. 

  1306. 	EPS_LOG_FUNCIN

    1307. 

  1307. 

    1308. 

  1308. /*** Has a Page (which also means Job) been initialized                                 */

    1309. 

  1309.     if (printJob.pageStatus == EPS_STATUS_NOT_INITIALIZED) {

    1310. 

  1310.         retStatus = EPS_ERR_PAGE_NOT_INITIALIZED;

    1311. 

  1311.     }

    1312. 

  1312. 

    1313. 

  1313. /*	printJob.pageStatus = EPS_STATUS_PROCCESSING; */

    1314. 

  1314. 

    1315. 

  1315. 	if( FALSE == printJob.bComm ){

    1316. 

  1316. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1317. 

  1317. 	}

    1318. 

  1318. 

    1319. 

  1319. /*** Validate input parameters                                                          */

    1320. 

  1320. 	if( NULL == prnData ){

    1321. 

  1321.         EPS_RETURN( EPS_ERR_INV_ARG_DATA );

    1322. 

  1322. 	}

    1323. 

  1323. 

    1324. 

  1324. 	switch(printJob.attr.colorPlane){

    1325. 

  1325. 	case EPS_CP_JPEG:

    1326. 

  1326. 		if(EPS_ERR_NONE == retStatus){

    1327. 

  1327. 			retStatus = PrintChunk(prnData->chunk.data, &prnData->chunk.dataSize);

    1328. 

  1328. 		} else{

    1329. 

  1329. 			prnData->chunk.dataSize = 0;

    1330. 

  1330. 		}

    1331. 

  1331. 		break;

    1332. 

  1332. 

    1333. 

  1333. 	case EPS_CP_FULLCOLOR:

    1334. 

  1334. 	case EPS_CP_256COLOR:

    1335. 

  1335. 		if(EPS_ERR_NONE == retStatus){

    1336. 

  1336. 			retStatus = PrintBand(prnData->band.data, prnData->band.widthPixels, &prnData->band.heightPixels);

    1337. 

  1337. 		} else{

    1338. 

  1338. 			prnData->band.heightPixels = 0;

    1339. 

  1339. 		}

    1340. 

  1340. 		break;

    1341. 

  1341. 

    1342. 

  1342. 	case EPS_CP_PRINTCMD:

    1343. 

  1343. 	default:

    1344. 

  1344. 		if(EPS_ERR_NONE == retStatus){

    1345. 

  1345. 			retStatus = SendCommand(prnData->chunk.data, prnData->chunk.dataSize, 

    1346. 

  1346. 								&prnData->chunk.dataSize, FALSE);

    1347. 

  1347. 		} else{

    1348. 

  1348. 			prnData->chunk.dataSize = 0;

    1349. 

  1349. 		}

    1350. 

  1350. 		break;

    1351. 

  1351. 	}

    1352. 

  1352. 

    1353. 

  1353. 	if(EPS_ERR_COMM_ERROR == retStatus){

    1354. 

  1354. 		printJob.bComm = FALSE;

    1355. 

  1355. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1356. 

  1356. 	}

    1357. 

  1357. 

    1358. 

  1358.     EPS_RETURN( retStatus );

    1359. 

  1359. }

    1360. 

  1360. 

    1361. 

  1361. 

    1362. 

  1362. /*******************************************|********************************************/

    1363. 

  1363. /*                                                                                      */

    1364. 

  1364. /* Function name:   epsEndPage()                                                        */

    1365. 

  1365. /*                                                                                      */

    1366. 

  1366. /* Arguments                                                                            */

    1367. 

  1367. /* ---------                                                                            */

    1368. 

  1368. /* Name:        Type:               Description:                                        */

    1369. 

  1369. /* nextPage     EPS_BOOL            Next page flag                                      */

    1370. 

  1370. /*                                                                                      */

    1371. 

  1371. /* Return value:                                                                        */

    1372. 

  1372. /*      << Normal >>                                                                    */

    1373. 

  1373. /*      EPS_ERR_NONE                    - Success                                       */

    1374. 

  1374. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    1375. 

  1375. /*                                        (Do not return when Uni-Directional)          */

    1376. 

  1376. /*      << Error >>                                                                     */

    1377. 

  1377. /*      EPS_ERR_PAGE_NOT_INITIALIZED    - PAGE is NOT initialized                       */

    1378. 

  1378. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    1379. 

  1379. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    1380. 

  1380. /*                                                                                      */

    1381. 

  1381. /* Description:                                                                         */

    1382. 

  1382. /*      Ends the current page.                                                          */

    1383. 

  1383. /*                                                                                      */

    1384. 

  1384. /*******************************************|********************************************/

    1385. 

  1385. EPS_ERR_CODE    epsEndPage (

    1386. 

  1386. 

    1387. 

  1387.         EPS_BOOL    nextPage

    1388. 

  1388. 

    1389. 

  1389. ){

    1390. 

  1390. /*** Declare Variable Local to Routine                                                  */

    1391. 

  1391. EPS_ERR_CODE    retStatus= EPS_ERR_NONE;            /* Return status of internal calls  */

    1392. 

  1392. EPS_UINT32		retBufSize = 0;

    1393. 

  1393. EPS_UINT8*		pCmd = NULL;

    1394. 

  1394. EPS_STATUS_INFO stInfo;

    1395. 

  1395. 

    1396. 

  1396. EPS_LOG_FUNCIN;

    1397. 

  1397. 

    1398. 

  1398. /*** EPS_CP_PRINTCMD not necessary call epsEndPage()                                    */

    1399. 

  1399. 	if (EPS_CP_PRINTCMD == printJob.attr.colorPlane) {

    1400. 

  1400.         EPS_RETURN( EPS_ERR_NONE );

    1401. 

  1401.     }

    1402. 

  1402. 

    1403. 

  1403. /*** Has a Page (which also means Job) been initialized                                 */

    1404. 

  1404.     if (printJob.pageStatus == EPS_STATUS_NOT_INITIALIZED) {

    1405. 

  1405.         EPS_RETURN( EPS_ERR_PAGE_NOT_INITIALIZED );

    1406. 

  1406.     }

    1407. 

  1407. 

    1408. 

  1408. 	if( FALSE == printJob.bComm ){

    1409. 

  1409. 		/*** Change the page status                                                     */

    1410. 

  1410. 		printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;

    1411. 

  1411. 		/* Do not send "EndPage" commands */

    1412. 

  1412. 		EPS_RETURN( EPS_ERR_NONE );

    1413. 

  1413. 	}

    1414. 

  1414. 

    1415. 

  1415. /*======================================================================================*/

    1416. 

  1416. /*** Check the printer status                                                           */

    1417. 

  1417. /*======================================================================================*/

    1418. 

  1418.     if ( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    1419. 

  1419.         /* Check the printer status */

    1420. 

  1420. 		retStatus = MonitorStatus(NULL);

    1421. 

  1421. 		if( EPS_JOB_CANCELED == retStatus ){

    1422. 

  1422. 			goto epsEndPage_END;

    1423. 

  1423. 		} else if(EPS_ERR_COMM_ERROR == retStatus ){

    1424. 

  1424. 			goto epsEndPage_END;

    1425. 

  1425. 		}

    1426. 

  1426. 	}

    1427. 

  1427. 

    1428. 

  1428. 	/* send command retry */

    1429. 

  1429. 	retStatus = SendLeftovers();

    1430. 

  1430. 	if(EPS_ERR_INVALID_CALL == retStatus){

    1431. 

  1431. 		retStatus = EPS_ERR_NONE;

    1432. 

  1432. 	}

    1433. 

  1433. 

    1434. 

  1434. /*** Send EndPage                                                                       */

    1435. 

  1435. 	/* step 1 : send dummy band for duplex */

    1436. 

  1436. 	if( EPS_ERR_NONE == retStatus && 0 == printJob.contData.saveStep ){

    1437. 

  1437. 		printJob.contData.saveStep++;

    1438. 

  1438. 		if(  TRUE == printJob.needBand ){

    1439. 

  1439. 			retStatus = SendBlankBand();

    1440. 

  1440. 			printJob.needBand = FALSE;

    1441. 

  1441. 		}

    1442. 

  1442. 	} 

    1443. 

  1443. 

    1444. 

  1444. 	/* step 2 : send end page command */

    1445. 

  1445. 	if( EPS_ERR_NONE == retStatus && 1 == printJob.contData.saveStep ){

    1446. 

  1446. 		printJob.contData.saveStep++;

    1447. 

  1447. 

    1448. 

  1448. 		if(EPS_LANG_ESCPR == printJob.printer->language ){

    1449. 

  1449. 			/*** ESC/P-R ***/

    1450. 

  1450. 			if( EPS_PM_JOB == obsGetPageMode() ){

    1451. 

  1451. 				/* EndPage & EndJob */

    1452. 

  1452. 				retStatus = SendEndJob(TRUE);

    1453. 

  1453. 			} else{

    1454. 

  1454. 				/* EndPage */

    1455. 

  1455. 				EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, sizeof(EndPage) )

    1456. 

  1456. 				if(NULL == sendDataBuf){

    1457. 

  1457. 					sendDataBufSize = 0;

    1458. 

  1458. 					retStatus = EPS_ERR_MEMORY_ALLOCATION;

    1459. 

  1459. 					goto epsEndPage_END;

    1460. 

  1460. 				}

    1461. 

  1461. 

    1462. 

  1462. 				pCmd = sendDataBuf;

    1463. 

  1463. 				memcpy(pCmd, EndPage, sizeof(EndPage));

    1464. 

  1464. 				if( FALSE == nextPage ){

    1465. 

  1465. 					if (EPS_DUPLEX_NONE != printJob.attr.duplex && 

    1466. 

  1466. 						0 == (printJob.pageCount & 0x01)) {

    1467. 

  1467. 						nextPage = TRUE;

    1468. 

  1468. 					}

    1469. 

  1469. 				}

    1470. 

  1470. 				if(FALSE == nextPage

    1471. 

  1471. 					|| EPS_IS_CDDVD( printJob.attr.mediaTypeIdx )){

    1472. 

  1472. 					pCmd[10] = EPS_END_PAGE;

    1473. 

  1473. 				} else{ 

    1474. 

  1474. 					pCmd[10] = EPS_NEXT_PAGE;

    1475. 

  1475. 				}

    1476. 

  1476. 

    1477. 

  1477. 				retStatus = SendCommand(sendDataBuf, sizeof(EndPage), &retBufSize, TRUE);

    1478. 

  1478. 			}

    1479. 

  1479. 		} else{

    1480. 

  1480. 			/*** ESC/Page ***/

    1481. 

  1481. #ifdef GCOMSW_CMD_ESCPAGE

    1482. 

  1482. 			retStatus = pageEndPage();

    1483. 

  1483. #else

    1484. 

  1484. 			retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    1485. 

  1485. #endif

    1486. 

  1486. 		}

    1487. 

  1487. 	}

    1488. 

  1488. 

    1489. 

  1489. 

    1490. 

  1490. epsEndPage_END:

    1491. 

  1491. /*** Return to Caller                                                                   */

    1492. 

  1492. 	if(EPS_ERR_NONE == retStatus){

    1493. 

  1493. 		/*** Change the page status */

    1494. 

  1494. 		printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;

    1495. 

  1495. 		printJob.pageCount++;

    1496. 

  1496. 		printJob.contData.savePoint = EPS_SAVEP_NONE;

    1497. 

  1497. 		printJob.contData.saveStep = 0;

    1498. 

  1498. 

    1499. 

  1499. 		if( EPS_PM_JOB == obsGetPageMode() &&

    1500. 

  1500. 			EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol) &&

    1501. 

  1501. 			printJob.contData.epRetry < 10){

    1502. 

  1502. 			/* LPR JOB mode */

    1503. 

  1503. 			retStatus = PRT_INVOKE_JOBFNC(jobFnc.EndPage, ());

    1504. 

  1504. 			if(EPS_ERR_NONE == retStatus){

    1505. 

  1505. 				if(EPS_IS_BI_PROTOCOL(printJob.printer->protocol)){

    1506. 

  1506. 					MonitorStatus(&stInfo);

    1507. 

  1507. 					if( EPS_ST_IDLE == stInfo.nState ){

    1508. 

  1508. 						/* retry this function still idle */

    1509. 

  1509. 						serDelayThread(2*_SECOND_, &epsCmnFnc);

    1510. 

  1510. 						printJob.contData.epRetry++;

    1511. 

  1511. 						printJob.contData.savePoint = EPS_SAVEP_END_PAGE;

    1512. 

  1512. 						printJob.contData.saveStep = 2;

    1513. 

  1513. 						printJob.pageStatus = EPS_STATUS_INITIALIZED;

    1514. 

  1514. 						retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1515. 

  1515. 						EPS_DBGPRINT(("*** EndPage Wait ***\n"))

    1516. 

  1516. 					}

    1517. 

  1517. 				}

    1518. 

  1518. 			} else if(EPS_ERR_COMM_ERROR == retStatus){

    1519. 

  1519. 				printJob.bComm = FALSE;

    1520. 

  1520. 				retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1521. 

  1521. 			}

    1522. 

  1522. 		}

    1523. 

  1523. 	} else if(EPS_ERR_COMM_ERROR == retStatus){

    1524. 

  1524. 		printJob.bComm = FALSE;

    1525. 

  1525. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1526. 

  1526. 	} else{

    1527. 

  1527. 		printJob.contData.savePoint = EPS_SAVEP_END_PAGE;

    1528. 

  1528. 		printJob.contData.nextPage = nextPage;

    1529. 

  1529. 	}

    1530. 

  1530. 

    1531. 

  1531.     EPS_RETURN( retStatus );

    1532. 

  1532. }

    1533. 

  1533. 

    1534. 

  1534. 

    1535. 

  1535. /*******************************************|********************************************/

    1536. 

  1536. /*                                                                                      */

    1537. 

  1537. /* Function name:   epsEndJob()                                                         */

    1538. 

  1538. /*                                                                                      */

    1539. 

  1539. /* Arguments                                                                            */

    1540. 

  1540. /* ---------                                                                            */

    1541. 

  1541. /* Name:        Type:               Description:                                        */

    1542. 

  1542. /* N/A          void                N/A                                                 */

    1543. 

  1543. /*                                                                                      */

    1544. 

  1544. /* Return value:                                                                        */

    1545. 

  1545. /*      << Normal >>                                                                    */

    1546. 

  1546. /*      EPS_ERR_NONE                    - Success                                       */

    1547. 

  1547. /*      << Error >>                                                                     */

    1548. 

  1548. /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */

    1549. 

  1549. /*                                                                                      */

    1550. 

  1550. /* Description:                                                                         */

    1551. 

  1551. /*      Ends the current print job.                                                     */

    1552. 

  1552. /*                                                                                      */

    1553. 

  1553. /*******************************************|********************************************/

    1554. 

  1554. EPS_ERR_CODE    epsEndJob (

    1555. 

  1555. 

    1556. 

  1556.         void

    1557. 

  1557. 

    1558. 

  1558. ){

    1559. 

  1559. /*** Declare Variable Local to Routine                                                  */

    1560. 

  1560. EPS_ERR_CODE    retStatus;                      /* Return status of internal calls      */

    1561. 

  1561. EPS_INT32		nRetry = 0;

    1562. 

  1562. EPS_PRINT_JOB   tempPrintJob;

    1563. 

  1563. EPS_UINT32		retBufSize = 0;

    1564. 

  1564. EPS_BOOL		sendEndpage = FALSE;

    1565. 

  1565. 

    1566. 

  1566. EPS_LOG_FUNCIN;

    1567. 

  1567. 

    1568. 

  1568. /*** Initialize Local Variables                                                         */

    1569. 

  1569.     retStatus = EPS_ERR_NONE;

    1570. 

  1570. 

    1571. 

  1571. /*** Has a Job been initialized; indicate start job was called                          */

    1572. 

  1572.     if (printJob.jobStatus == EPS_STATUS_NOT_INITIALIZED) {

    1573. 

  1573.         retStatus = EPS_ERR_JOB_NOT_INITIALIZED;

    1574. 

  1574.         goto JOBEND_END;

    1575. 

  1575.     }

    1576. 

  1576. 	

    1577. 

  1577. 	if (EPS_CP_PRINTCMD != printJob.attr.colorPlane) {

    1578. 

  1578. 	/*** If not invoked epsEndPage, invoke it                                           */

    1579. 

  1579. 		if (printJob.pageStatus != EPS_STATUS_NOT_INITIALIZED) {

    1580. 

  1580. 			epsEndPage(FALSE);

    1581. 

  1581. 		}

    1582. 

  1582. 

    1583. 

  1583. 	/*** Send backside page for ESCPR duplex                                            */

    1584. 

  1584. 		if(EPS_RESET_NOT_SENT == printJob.resetSent &&

    1585. 

  1585. 		   EPS_DUPLEX_NONE != printJob.attr.duplex && 

    1586. 

  1586. 		   EPS_LANG_ESCPR == printJob.printer->language && 

    1587. 

  1587. 		   (printJob.pageCount & 0x01) )

    1588. 

  1588. 		{

    1589. 

  1589. 			memcpy(sendDataBuf, StartPage, sizeof(StartPage));

    1590. 

  1590. 			retStatus = SendCommand(sendDataBuf, sizeof(StartPage), &retBufSize, TRUE);

    1591. 

  1591. 			for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){

    1592. 

  1592. 				if(EPS_ERR_NONE == retStatus || EPS_JOB_CANCELED == retStatus){

    1593. 

  1593. 					break;

    1594. 

  1594. 				}

    1595. 

  1595. 				retStatus = SendLeftovers();

    1596. 

  1596. 				if(EPS_ERR_INVALID_CALL == retStatus){

    1597. 

  1597. 					retStatus = EPS_ERR_NONE;

    1598. 

  1598. 				}

    1599. 

  1599. 			}

    1600. 

  1600. 

    1601. 

  1601. 			retStatus = SendBlankBand();

    1602. 

  1602. 			for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){

    1603. 

  1603. 				if(EPS_ERR_NONE == retStatus || EPS_JOB_CANCELED == retStatus){

    1604. 

  1604. 					break;

    1605. 

  1605. 				}

    1606. 

  1606. 				retStatus = SendLeftovers();

    1607. 

  1607. 				if(EPS_ERR_INVALID_CALL == retStatus){

    1608. 

  1608. 					retStatus = EPS_ERR_NONE;

    1609. 

  1609. 				}

    1610. 

  1610. 			}

    1611. 

  1611. 

    1612. 

  1612. 			sendEndpage = TRUE;

    1613. 

  1613. 		}

    1614. 

  1614. 

    1615. 

  1615. 	/*** Send EndJob                                                                    */

    1616. 

  1616. 		if (printJob.jobStatus == EPS_STATUS_ESTABLISHED &&

    1617. 

  1617. 			EPS_PM_JOB != obsGetPageMode() )

    1618. 

  1618. 		{

    1619. 

  1619. 			if(EPS_LANG_ESCPR == printJob.printer->language ){

    1620. 

  1620. 				/*** ESC/P-R ***/

    1621. 

  1621. 				retStatus = SendEndJob(sendEndpage);

    1622. 

  1622. 			} else{

    1623. 

  1623. 				/*** ESC/Page ***/

    1624. 

  1624. #ifdef GCOMSW_CMD_ESCPAGE

    1625. 

  1625. 				retStatus = pageEndJob();

    1626. 

  1626. #else

    1627. 

  1627. 				retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    1628. 

  1628. #endif

    1629. 

  1629. 			}

    1630. 

  1630. 		}

    1631. 

  1631. 

    1632. 

  1632. 		for(nRetry = 0; nRetry < 5 && printJob.bComm; nRetry++){

    1633. 

  1633. 			if(EPS_ERR_NONE == retStatus){

    1634. 

  1634. 				break;

    1635. 

  1635. 			}

    1636. 

  1636. 		

    1637. 

  1637. 			EPS_DBGPRINT(("retry ENDJOB\n"))

    1638. 

  1638. 			retStatus = SendLeftovers();

    1639. 

  1639. 			if(EPS_ERR_INVALID_CALL == retStatus){

    1640. 

  1640. 				retStatus = EPS_ERR_NONE;

    1641. 

  1641. 			}

    1642. 

  1642. 		}

    1643. 

  1643. 	}

    1644. 

  1644. 

    1645. 

  1645. /*** protocol depend EndJob                                                             */

    1646. 

  1646. 	retStatus = jobFnc.EndJob();

    1647. 

  1647. 

    1648. 

  1648. JOBEND_END:

    1649. 

  1649. /*** Clear Memory                                                                       */

    1650. 

  1650. #ifdef GCOMSW_CMD_ESCPAGE

    1651. 

  1651. 	pageRelaseBuffer();

    1652. 

  1652. #endif

    1653. 

  1653. 	EPS_SAFE_RELEASE(sendDataBuf );

    1654. 

  1654.     EPS_SAFE_RELEASE(tmpLineBuf  );

    1655. 

  1655. 	sendDataBufSize = 0;

    1656. 

  1656. 	tmpLineBufSize = 0;

    1657. 

  1657. 

    1658. 

  1658. /*** Reset continue buffer                                                              */

    1659. 

  1659. 	printJob.contData.sendData = NULL;

    1660. 

  1660. 	printJob.contData.sendDataSize = 0;

    1661. 

  1661. 

    1662. 

  1662. /*** Clear inside additional data buffer                                                */

    1663. 

  1663. 	/* DEL EPS_SAFE_RELEASE( printJob.qrcode.bits );*/

    1664. 

  1664. 

    1665. 

  1665. /*** Clear and Copy Print_Job struct                                                    */

    1666. 

  1666.     memcpy(&tempPrintJob, &printJob, sizeof(EPS_PRINT_JOB));

    1667. 

  1667.     memset(&printJob, 0, sizeof(EPS_PRINT_JOB));

    1668. 

  1668. 

    1669. 

  1669.     printJob.pageStatus       = tempPrintJob.pageStatus;

    1670. 

  1670. 	printJob.commMode         = tempPrintJob.commMode;

    1671. 

  1671. 	printJob.printer          = tempPrintJob.printer;

    1672. 

  1672. 	printJob.platform         = tempPrintJob.platform;

    1673. 

  1673. 

    1674. 

  1674. #ifdef GCOMSW_EPSON_SLEEP

    1675. 

  1675.     printJob.sleepSteps       = tempPrintJob.sleepSteps;

    1676. 

  1676. #endif

    1677. 

  1677.     

    1678. 

  1678. /*** Change the job status                                                              */

    1679. 

  1679.     printJob.jobStatus = EPS_STATUS_NOT_INITIALIZED;

    1680. 

  1680. 	printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;

    1681. 

  1681. 	printJob.bComm = TRUE;

    1682. 

  1682. 	printJob.resetReq = FALSE;

    1683. 

  1683. 

    1684. 

  1684. #if 0

    1685. 

  1685. 	if(EPS_ERR_NOT_CLOSE_IO == retStatus || EPS_ERR_COMM_ERROR == retStatus){

    1686. 

  1686. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1687. 

  1687. 	}

    1688. 

  1688. #else

    1689. 

  1689.     if (EPS_ERR_NONE != retStatus) {

    1690. 

  1690. 		EPS_DBGPRINT(("epsEndJob failed (%d)\r\n", retStatus));

    1691. 

  1691. 		retStatus = EPS_ERR_NONE;

    1692. 

  1692. 	}

    1693. 

  1693. #endif

    1694. 

  1694. 

    1695. 

  1695. #ifdef LCOMSW_CMDDMP

    1696. 

  1696. 	EPS_DF_CLOSE

    1697. 

  1697. #endif

    1698. 

  1698. 

    1699. 

  1699.     EPS_RETURN( retStatus );

    1700. 

  1700. }

    1701. 

  1701. 

    1702. 

  1702. 

    1703. 

  1703. /*******************************************|********************************************/

    1704. 

  1704. /*                                                                                      */

    1705. 

  1705. /* Function name:   epsCancelJob()                                                      */

    1706. 

  1706. /*                                                                                      */

    1707. 

  1707. /* Arguments                                                                            */

    1708. 

  1708. /* ---------                                                                            */

    1709. 

  1709. /* Name:        Type:               Description:                                        */

    1710. 

  1710. /* reserve      EPS_BOOL            I:Call epsEndJob()                                  */

    1711. 

  1711. /*                                                                                      */

    1712. 

  1712. /* Return value:                                                                        */

    1713. 

  1713. /*      EPS_ERR_NONE                    - Success                                       */

    1714. 

  1714. /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */

    1715. 

  1715. /*      EPS_ERR_CAN_NOT_RESET           - Failed to reset printer                       */

    1716. 

  1716. /*                                                                                      */

    1717. 

  1717. /* Description:                                                                         */

    1718. 

  1718. /*      Reset printer.                                                                  */

    1719. 

  1719. /*                                                                                      */

    1720. 

  1720. /*******************************************|********************************************/

    1721. 

  1721. EPS_ERR_CODE    epsCancelJob (

    1722. 

  1722. 

    1723. 

  1723.         EPS_INT32	reserve

    1724. 

  1724. 

    1725. 

  1725. ){

    1726. 

  1726. 

    1727. 

  1727. /*** Declare Variable Local to Routine                                                  */

    1728. 

  1728. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */

    1729. 

  1729. EPS_ERR_CODE    retTmp = EPS_ERR_NONE;

    1730. 

  1730. 

    1731. 

  1731. EPS_LOG_FUNCIN;

    1732. 

  1732. #if !LCOMSW_CANCEL_JOB

    1733. 

  1733. 	(void)reserve;

    1734. 

  1734. #endif

    1735. 

  1735. 

    1736. 

  1736. /*** Validate communication mode                                                        */

    1737. 

  1737. 	if(NULL == printJob.printer){

    1738. 

  1738. 		EPS_RETURN( EPS_ERR_NONE/*EPS_ERR_PRINTER_NOT_SET*/ );

    1739. 

  1739. 	}

    1740. 

  1740. 

    1741. 

  1741. 	if ( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    1742. 

  1742.         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );

    1743. 

  1743. 	}

    1744. 

  1744. 

    1745. 

  1745.     if (printJob.jobStatus == EPS_STATUS_ESTABLISHED) {

    1746. 

  1746. 		/*** Send the reset command to printer                                          */

    1747. 

  1747. 		retStatus = PRT_INVOKE_JOBFNC(jobFnc.ResetPrinter, ());

    1748. 

  1748. 		printJob.resetSent = EPS_RESET_SENT;

    1749. 

  1749. 		printJob.resetReq = FALSE;

    1750. 

  1750. 		if(EPS_ERR_NONE != retStatus){

    1751. 

  1751. 			EPS_DBGPRINT(("ResetPrinter() failed (%d)\r\n", retStatus));

    1752. 

  1752. 			retStatus = EPS_ERR_CAN_NOT_RESET;

    1753. 

  1753. 			/* return retStatus;  Force continue */

    1754. 

  1754. 		}

    1755. 

  1755. 

    1756. 

  1756. 		/*** Change the page status                                                     */

    1757. 

  1757. 		printJob.pageStatus = EPS_STATUS_NOT_INITIALIZED;

    1758. 

  1758. 	}

    1759. 

  1759. 

    1760. 

  1760. #if LCOMSW_CANCEL_JOB

    1761. 

  1761. 	if(0 == reserve){

    1762. 

  1762. #endif

    1763. 

  1763. 		/*** Invoke  epsEndJob()                                                        */

    1764. 

  1764. 		retTmp = epsEndJob();

    1765. 

  1765. 		if (retTmp != EPS_ERR_NONE) {

    1766. 

  1766. 			EPS_DBGPRINT(("epsEndJob() failed (%d)\r\n", retTmp));

    1767. 

  1767. 			/* return retStatus;  Force continue */

    1768. 

  1768. 		}

    1769. 

  1769. #if LCOMSW_CANCEL_JOB

    1770. 

  1770. 	}

    1771. 

  1771. #endif

    1772. 

  1772. 

    1773. 

  1773.     EPS_RETURN( retStatus );

    1774. 

  1774. }

    1775. 

  1775. 

    1776. 

  1776. 

    1777. 

  1777. /*******************************************|********************************************/

    1778. 

  1778. /*                                                                                      */

    1779. 

  1779. /* Function name:   epsContinueJob()                                                    */

    1780. 

  1780. /*                                                                                      */

    1781. 

  1781. /* Arguments                                                                            */

    1782. 

  1782. /* ---------                                                                            */

    1783. 

  1783. /* Name:        Type:               Description:                                        */

    1784. 

  1784. /* N/A          void                N/A                                                 */

    1785. 

  1785. /*                                                                                      */

    1786. 

  1786. /* Return value:                                                                        */

    1787. 

  1787. /*      << Normal >>                                                                    */

    1788. 

  1788. /*      EPS_ERR_NONE                    - Success                                       */

    1789. 

  1789. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    1790. 

  1790. /*                                        (Do not return when Uni-Directional)          */

    1791. 

  1791. /*      << Error >>                                                                     */

    1792. 

  1792. /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */

    1793. 

  1793. /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */

    1794. 

  1794. /*      EPS_ERR_PAGE_NOT_INITIALIZED    - PAGR is NOT initialized                       */

    1795. 

  1795. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    1796. 

  1796. /*                                                                                      */

    1797. 

  1797. /* Description:                                                                         */

    1798. 

  1798. /*      Reset printer.                                                                  */

    1799. 

  1799. /*                                                                                      */

    1800. 

  1800. /*******************************************|********************************************/

    1801. 

  1801. EPS_ERR_CODE epsContinueJob (

    1802. 

  1802. 								   

    1803. 

  1803. 		void

    1804. 

  1804. 

    1805. 

  1805. ){

    1806. 

  1806. /*** Declare Variable Local to Routine                                                  */

    1807. 

  1807. 	EPS_ERR_CODE    retStatus = EPS_ERR_NONE;		/* Return status of internal calls  */

    1808. 

  1808. 	EPS_INT32       nCnt = 0;

    1809. 

  1809. 

    1810. 

  1810. 	EPS_LOG_FUNCIN;

    1811. 

  1811. 

    1812. 

  1812. /*** Has a target printer specified                                                     */

    1813. 

  1813. 	if(NULL == printJob.printer){

    1814. 

  1814.         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );

    1815. 

  1815. 	}

    1816. 

  1816. /*** Has a Job been initialized                                                         */

    1817. 

  1817. 	if (printJob.jobStatus == EPS_STATUS_NOT_INITIALIZED){

    1818. 

  1818.         EPS_RETURN( EPS_ERR_JOB_NOT_INITIALIZED );

    1819. 

  1819. 	}

    1820. 

  1820. 

    1821. 

  1821. /*** Validate communication mode                                                        */

    1822. 

  1822. 	if( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    1823. 

  1823.         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );

    1824. 

  1824. 	}

    1825. 

  1825. 

    1826. 

  1826. /*** Recovery command                                                                   */

    1827. 

  1827. 	switch( printJob.contData.lastError ){

    1828. 

  1828. 		case EPS_PRNERR_PAPEROUT:

    1829. 

  1829. 		case EPS_PRNERR_NOTRAY:

    1830. 

  1830. 		/*case EPS_PRNERR_CDDVDCONFIG:*/

    1831. 

  1831. 			if( EPS_ERR_PRINTER_ERR_OCCUR == MonitorStatus(NULL)){

    1832. 

  1832. 				if( EPS_ERR_NONE != (retStatus = prtRecoverPE()) ){

    1833. 

  1833. 					EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    1834. 

  1834. 				}

    1835. 

  1835. 				/*serDelayThread(2*_SECOND_, &epsCmnFnc);*/

    1836. 

  1836. 

    1837. 

  1837. 				/* Status change is delayed the condition of LPR ASSIST */

    1838. 

  1838. 				if( EPS_PROTOCOL_LPR == EPS_PRT_PROTOCOL(printJob.printer->protocol)

    1839. 

  1839. 					&& EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    1840. 

  1840. 					for(nCnt = 0; nCnt < 3; nCnt++){

    1841. 

  1841. 						serDelayThread(2*_SECOND_, &epsCmnFnc);

    1842. 

  1842. 						if( EPS_ERR_NONE == MonitorStatus(NULL) ){

    1843. 

  1843. 							break;

    1844. 

  1844. 						}

    1845. 

  1845. 						EPS_DBGPRINT(("*** Recover Wait ***\n"))

    1846. 

  1846. 					}

    1847. 

  1847. 				}

    1848. 

  1848. 			}

    1849. 

  1849. 			break;

    1850. 

  1850. 

    1851. 

  1851. 		case EPS_PRNERR_INTERFACE:

    1852. 

  1852. 			/*serDelayThread(5*_SECOND_, &epsCmnFnc);*/

    1853. 

  1853. 			break;

    1854. 

  1854. 		default:

    1855. 

  1855. 			break;

    1856. 

  1856. 	}

    1857. 

  1857. 

    1858. 

  1858. /*** Check printer starus                                                               */

    1859. 

  1859. 	retStatus = MonitorStatus(NULL);

    1860. 

  1860. 	if(EPS_ERR_NONE != retStatus){

    1861. 

  1861. 		EPS_RETURN( retStatus );

    1862. 

  1862. 	}

    1863. 

  1863. 

    1864. 

  1864. /*** Send leftovers data                                                                */

    1865. 

  1865. 	switch(printJob.contData.savePoint){

    1866. 

  1866. 		case EPS_SAVEP_START_PAGE:

    1867. 

  1867. 			retStatus = epsStartPage(NULL);

    1868. 

  1868. 			break;

    1869. 

  1869. 		case EPS_SAVEP_END_PAGE:

    1870. 

  1870. 			retStatus = epsEndPage(printJob.contData.nextPage);

    1871. 

  1871. 			break;

    1872. 

  1872. 

    1873. 

  1873. 		default:

    1874. 

  1874. 			retStatus = SendLeftovers();

    1875. 

  1875. 			if(EPS_ERR_INVALID_CALL == retStatus){

    1876. 

  1876. 				retStatus = EPS_ERR_NONE;

    1877. 

  1877. 			} else if(EPS_ERR_NONE == retStatus){

    1878. 

  1878. 				printJob.contData.skipLine = TRUE;

    1879. 

  1879. 			} else {

    1880. 

  1880. 				EPS_RETURN( retStatus );

    1881. 

  1881. 			}

    1882. 

  1882. 			break;

    1883. 

  1883. 	}

    1884. 

  1884. 

    1885. 

  1885. /*** Return to Caller                                                                   */

    1886. 

  1886. 	if(EPS_ERR_COMM_ERROR == retStatus){

    1887. 

  1887. 		printJob.bComm = FALSE;

    1888. 

  1888. 		retStatus = EPS_ERR_PRINTER_ERR_OCCUR;

    1889. 

  1889. 	}

    1890. 

  1890. 

    1891. 

  1891. 	EPS_RETURN( retStatus );

    1892. 

  1892. }

    1893. 

  1893. 

    1894. 

  1894. 

    1895. 

  1895. /*******************************************|********************************************/

    1896. 

  1896. /*                                                                                      */

    1897. 

  1897. /* Function name:   epsSetAdditionalData()                                              */

    1898. 

  1898. /*                                                                                      */

    1899. 

  1899. /* Arguments                                                                            */

    1900. 

  1900. /* ---------                                                                            */

    1901. 

  1901. /* Name:        Type:               Description:                                        */

    1902. 

  1902. /* data         EPS_ADD_DATA*       I: pointer to Additional data                       */

    1903. 

  1903. /*                                                                                      */

    1904. 

  1904. /* Return value:                                                                        */

    1905. 

  1905. /*      << Normal >>                                                                    */

    1906. 

  1906. /*      EPS_ERR_NONE                    - Success                                       */

    1907. 

  1907. /*      << Error >>                                                                     */

    1908. 

  1908. /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                        */

    1909. 

  1909. /*      EPS_ERR_PAGE_NOT_CLOSED         - PAGR is initialized                           */

    1910. 

  1910. /*      EPS_ERR_INV_ARG_VALIDMEMBER     - Invalid argument "validMember"                */

    1911. 

  1911. /*      EPS_ERR_INV_ARG_ADDDATA         - Invalid argument "data"                       */

    1912. 

  1912. /*      EPS_ERR_INV_ARG_QRSOURCE        - Invalid argument "data.qrcode.source"         */

    1913. 

  1913. /*      EPS_ERR_INV_ARG_QRXPOS	        - Invalid argument "data.qrcode.xPos"           */

    1914. 

  1914. /*      EPS_ERR_INV_ARG_QRYPOS	        - Invalid argument "data.qrcode.position.y"     */

    1915. 

  1915. /*      EPS_ERR_QRSOURCE_TOO_LAGE       - source is too lage to convert QR code         */

    1916. 

  1916. /*                                                                                      */

    1917. 

  1917. /* Description:                                                                         */

    1918. 

  1918. /*      Set additional data print image.                                                */

    1919. 

  1919. /*                                                                                      */

    1920. 

  1920. /*******************************************|********************************************/

    1921. 

  1921. EPS_ERR_CODE epsSetAdditionalData (

    1922. 

  1922. 								   

    1923. 

  1923. 		EPS_UINT32	dataType,

    1924. 

  1924. 		const void*	data

    1925. 

  1925. 

    1926. 

  1926. ){

    1927. 

  1927. /*** Declare Variable Local to Routine                                                  */

    1928. 

  1928. 	EPS_LOG_FUNCIN;

    1929. 

  1929. 	 /* This Func is ineffective in the current version. */

    1930. 

  1930. 	EPS_RETURN( EPS_ERR_INVALID_CALL );

    1931. 

  1931. }

    1932. 

  1932. 

    1933. 

  1933. 

    1934. 

  1934. /*******************************************|********************************************/

    1935. 

  1935. /*                                                                                      */

    1936. 

  1936. /* Function name:   epsRemAdditionalData()                                              */

    1937. 

  1937. /*                                                                                      */

    1938. 

  1938. /* Arguments                                                                            */

    1939. 

  1939. /* ---------                                                                            */

    1940. 

  1940. /* Name:        Type:               Description:                                        */

    1941. 

  1941. /* member       EPS_UINT32          I: pointer to Additional data                       */

    1942. 

  1942. /*                                                                                      */

    1943. 

  1943. /* Return value:                                                                        */

    1944. 

  1944. /*      << Normal >>                                                                    */

    1945. 

  1945. /*      EPS_ERR_NONE                    - Success                                       */

    1946. 

  1946. /*      << Error >>                                                                     */

    1947. 

  1947. /*      EPS_ERR_INV_ARG_VALIDMEMBER     - Invalid argument "validMember"                */

    1948. 

  1948. /*                                                                                      */

    1949. 

  1949. /* Description:                                                                         */

    1950. 

  1950. /*      Release additional data setting by epsRemAdditionalData().                      */

    1951. 

  1951. /*                                                                                      */

    1952. 

  1952. /*******************************************|********************************************/

    1953. 

  1953. EPS_ERR_CODE epsRemAdditionalData (

    1954. 

  1954. 								   

    1955. 

  1955. 		EPS_UINT32 dataType

    1956. 

  1956. 

    1957. 

  1957. ){

    1958. 

  1958. 	EPS_LOG_FUNCIN;

    1959. 

  1959. 	 /* This Func is ineffective in the current version. */

    1960. 

  1960. 	EPS_RETURN( EPS_ERR_INVALID_CALL );

    1961. 

  1961. }

    1962. 

  1962. 

    1963. 

  1963. 

    1964. 

  1964. /*******************************************|********************************************/

    1965. 

  1965. /*                                                                                      */

    1966. 

  1966. /* Function name:   epsGetStatus()                                                      */

    1967. 

  1967. /*                                                                                      */

    1968. 

  1968. /* Arguments                                                                            */

    1969. 

  1969. /* ---------                                                                            */

    1970. 

  1970. /* Name:        Type:               Description:                                        */

    1971. 

  1971. /* status       EPS_STATUS*         Pointer to the printer status.                      */

    1972. 

  1972. /*                                                                                      */

    1973. 

  1973. /* Return value:                                                                        */

    1974. 

  1974. /*      << Normal >>                                                                    */

    1975. 

  1975. /*      EPS_ERR_NONE                    - Success                                       */

    1976. 

  1976. /*      << Error >>                                                                     */

    1977. 

  1977. /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */

    1978. 

  1978. /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */

    1979. 

  1979. /*      EPS_ERR_INV_ARG_STATUS          - Invalid argument                              */

    1980. 

  1980. /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */

    1981. 

  1981. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    1982. 

  1982. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    1983. 

  1983. /*                                                                                      */

    1984. 

  1984. /* Description:                                                                         */

    1985. 

  1985. /*      Gets the printer status.                                                        */

    1986. 

  1986. /*                                                                                      */

    1987. 

  1987. /*******************************************|********************************************/

    1988. 

  1988. EPS_ERR_CODE    epsGetStatus (

    1989. 

  1989. 

    1990. 

  1990. 		EPS_STATUS			*status

    1991. 

  1991. 

    1992. 

  1992. ){

    1993. 

  1993. 

    1994. 

  1994. /*** Declare Variable Local to Routine                                                  */

    1995. 

  1995. 	EPS_ERR_CODE    ret = EPS_ERR_NONE;         /* Return status of internal calls      */

    1996. 

  1996. 	EPS_STATUS_INFO	stInfo;

    1997. 

  1997.     EPS_BOOL		bIoStatus = FALSE;

    1998. 

  1998. 	EPS_BOOL		bCanceling = FALSE;

    1999. 

  1999. 

    2000. 

  2000. 	EPS_LOG_FUNCIN;

    2001. 

  2001. 

    2002. 

  2002. /*** Validate communication mode                                                        */

    2003. 

  2003. 	if( !EPS_IS_BI_PROTOCOL(printJob.commMode) ){

    2004. 

  2004.         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );

    2005. 

  2005. 	}

    2006. 

  2006. 

    2007. 

  2007. /*** Has a target printer specified                                                     */

    2008. 

  2008. 	if(NULL == printJob.printer){

    2009. 

  2009. 		EPS_RETURN(  EPS_ERR_PRINTER_NOT_SET );

    2010. 

  2010. 	}

    2011. 

  2011. 

    2012. 

  2012. /*** Validate input parameters                                                          */

    2013. 

  2013. 	if (status == NULL){

    2014. 

  2014.         EPS_RETURN( EPS_ERR_INV_ARG_STATUS );

    2015. 

  2015. 	}

    2016. 

  2016. 	

    2017. 

  2017. 	memset(status, 0, sizeof(EPS_STATUS));

    2018. 

  2018. 

    2019. 

  2019. /*** Jpeg size limitation                                                               */

    2020. 

  2020. 	if( TRUE == printJob.bJpgLimit ){

    2021. 

  2021. 		status->printerStatus = EPS_PRNST_ERROR;

    2022. 

  2022. 		status->errorCode = EPS_PRNERR_JPG_LIMIT;

    2023. 

  2023. 		status->jobContinue  = FALSE;

    2024. 

  2024. 		EPS_RETURN( EPS_ERR_NONE );

    2025. 

  2025. 	}

    2026. 

  2026. 

    2027. 

  2027. /*** Get printer status                                                                 */

    2028. 

  2028. 	memset(&stInfo, 0, sizeof(stInfo));

    2029. 

  2029. 	if( TRUE == printJob.bComm ){

    2030. 

  2030. 		ret = PRT_INVOKE_JOBFNC(jobFnc.GetStatus, 

    2031. 

  2031. 								(&stInfo, &bIoStatus, &bCanceling));

    2032. 

  2032. 

    2033. 

  2033. 		if(EPS_ERR_COMM_ERROR == ret && 

    2034. 

  2034. 			EPS_STATUS_NOT_INITIALIZED != printJob.jobStatus){

    2035. 

  2035. 			printJob.bComm = FALSE;

    2036. 

  2036. 		}

    2037. 

  2037. 	} else{

    2038. 

  2038. 		ret = EPS_ERR_COMM_ERROR;

    2039. 

  2039. 	}

    2040. 

  2040. 

    2041. 

  2041. //	EPS_DBGPRINT((" State\t: %d\n Error\t: %d\n IoStatus\t: %d\n Canceling\t: %d\n Prepare\t: %d\n", 

    2042. 

  2042. //		stInfo.nState, stInfo.nError, bIoStatus, bCanceling, stInfo.nPrepare))

    2043. 

  2043. 

    2044. 

  2044. 	if(EPS_ERR_COMM_ERROR == ret	||

    2045. 

  2045. 		EPS_ERR_NOT_OPEN_IO == ret	||

    2046. 

  2046. 		EPS_ERR_NOT_CLOSE_IO == ret	) {

    2047. 

  2047. 		status->printerStatus = EPS_PRNST_ERROR/*EPS_PRNST_OFFLINE*/;

    2048. 

  2048. 		status->errorCode = EPS_PRNERR_COMM;

    2049. 

  2049. 		status->jobContinue  = FALSE;

    2050. 

  2050. 		EPS_RETURN( EPS_ERR_NONE );

    2051. 

  2051. 	} else if (EPS_ERR_NONE != ret){

    2052. 

  2052. 		EPS_RETURN( ret );

    2053. 

  2053. 	}

    2054. 

  2054. 

    2055. 

  2055.    if(stInfo.nCancel == EPS_CAREQ_CANCEL) {

    2056. 

  2056.         EPS_DBGPRINT(("EPS SER : CANCEL REQUEST by PRINTER\r\n"));

    2057. 

  2057. 		printJob.resetReq = TRUE;

    2058. 

  2058.     }

    2059. 

  2059. #if 0

    2060. 

  2060.    if(TRUE == printJob.resetReq){

    2061. 

  2061. 		status->printerStatus = EPS_PRNST_ERROR/*EPS_PRNST_OFFLINE*/;

    2062. 

  2062. 		status->errorCode = EPS_PRNERR_COMM;

    2063. 

  2063. 		status->jobContinue  = FALSE;

    2064. 

  2064.    }

    2065. 

  2065. #endif

    2066. 

  2066. 

    2067. 

  2067. /*** Copy status data to input buffer                                                   */

    2068. 

  2068. 	status->errorCode= stInfo.nError;

    2069. 

  2069. 	printJob.contData.lastError = stInfo.nError;

    2070. 

  2070. 	switch(stInfo.nState) {

    2071. 

  2071.     	case EPS_ST_ERROR:

    2072. 

  2072. 			status->printerStatus = EPS_PRNST_ERROR;

    2073. 

  2073. 

    2074. 

  2074. 			switch(stInfo.nError){

    2075. 

  2075. 				case EPS_PRNERR_INKOUT:

    2076. 

  2076. 					/* Convert Ink error */

    2077. 

  2077. 					serGetInkError(&stInfo, &status->errorCode);

    2078. 

  2078. 					break;

    2079. 

  2079. 

    2080. 

  2080. 				case EPS_PRNERR_INTERFACE:

    2081. 

  2081. 				case EPS_PRNERR_BUSY:

    2082. 

  2082. 					if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){

    2083. 

  2083. 					/* between multi page(job of EPS_PM_JOB), it becomes busy. */

    2084. 

  2084. 						status->printerStatus = EPS_PRNST_PRINTING;

    2085. 

  2085. 						status->errorCode = EPS_PRNERR_NOERROR;

    2086. 

  2086. 					} else{

    2087. 

  2087. 						status->printerStatus = EPS_PRNST_BUSY;

    2088. 

  2088. 					}

    2089. 

  2089. 

    2090. 

  2090. 					break;

    2091. 

  2091. 

    2092. 

  2092. 				case EPS_PRNERR_PAPERJAM:

    2093. 

  2093. 					printJob.transmittable = FALSE;

    2094. 

  2094. 					break;

    2095. 

  2095. 

    2096. 

  2096. 				default:

    2097. 

  2097. 					break;

    2098. 

  2098. 			}

    2099. 

  2099. 			break;

    2100. 

  2100. 

    2101. 

  2101. 		case EPS_ST_WAITING:

    2102. 

  2102. 			status->printerStatus = EPS_PRNST_PRINTING;

    2103. 

  2103. 			break;

    2104. 

  2104. 

    2105. 

  2105. 		case EPS_ST_IDLE:

    2106. 

  2106. 			/* If printer doesn't move, it becomes idle. */

    2107. 

  2107. 			if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){

    2108. 

  2108. 				status->printerStatus = EPS_PRNST_PRINTING;

    2109. 

  2109. 			} else{

    2110. 

  2110. 				status->printerStatus = EPS_PRNST_IDLE;

    2111. 

  2111. 			}

    2112. 

  2112. 			break;

    2113. 

  2113. 

    2114. 

  2114. 		case EPS_ST_FACTORY_SHIPMENT:

    2115. 

  2115. 			status->printerStatus = EPS_PRNST_ERROR;

    2116. 

  2116. 			status->errorCode = EPS_PRNERR_FACTORY;	

    2117. 

  2117. 			break;

    2118. 

  2118. 

    2119. 

  2119. 		case EPS_ST_CLEANING:

    2120. 

  2120. 		case EPS_ST_BUSY:

    2121. 

  2121. 			if(EPS_STATUS_ESTABLISHED == printJob.jobStatus){

    2122. 

  2122. 				/* The cleaning under the print is made "printing". */

    2123. 

  2123. 				status->printerStatus = EPS_PRNST_PRINTING;

    2124. 

  2124. 				status->errorCode = EPS_PRNERR_NOERROR;

    2125. 

  2125. 			} else{

    2126. 

  2126. 				status->errorCode = EPS_PRNERR_BUSY;

    2127. 

  2127. 				status->printerStatus = EPS_PRNST_BUSY;

    2128. 

  2128. 			}

    2129. 

  2129. 			break;

    2130. 

  2130. 

    2131. 

  2131. 		default: /* The others. */

    2132. 

  2132. 			/* EPS_ST_SELF_PRINTING    */

    2133. 

  2133. 			/* EPS_ST_SHUTDOWN         */

    2134. 

  2134. 	        status->errorCode = EPS_PRNERR_BUSY;

    2135. 

  2135. 			status->printerStatus = EPS_PRNST_BUSY;

    2136. 

  2136. 			break;

    2137. 

  2137. 	}

    2138. 

  2138. 

    2139. 

  2139. 	if(EPS_PRNERR_NOERROR == status->errorCode){

    2140. 

  2140. 		/* If other errors have not occurred */

    2141. 

  2141. 		if(EPS_PREPARE_TRAYCLOSED == stInfo.nPrepare

    2142. 

  2142. 			&& EPS_STATUS_ESTABLISHED == printJob.jobStatus

    2143. 

  2143. 			&& EPS_STATUS_NOT_INITIALIZED == printJob.pageStatus){

    2144. 

  2144. 			/* between epsStartJob to epsStartPage complete */

    2145. 

  2145. 			status->errorCode = EPS_PRNERR_TRAYCLOSE;

    2146. 

  2146. 			status->printerStatus = EPS_PRNST_ERROR;

    2147. 

  2147. 

    2148. 

  2148. 		} else if(EPS_PRNWARN_DISABLE_CLEAN & stInfo.nWarn 

    2149. 

  2149. 			&& EPS_MNT_CLEANING == printJob.attr.cmdType

    2150. 

  2150. 			&& EPS_STATUS_INITIALIZED == printJob.jobStatus){

    2151. 

  2151. 			/* GetStatus failed in epsStartJob()  */

    2152. 

  2152. 			status->errorCode = EPS_PRNERR_DISABEL_CLEANING;

    2153. 

  2153. 			status->printerStatus = EPS_PRNST_ERROR;

    2154. 

  2154. 

    2155. 

  2155. 		} else if( bCanceling ){

    2156. 

  2156. 			/* Printing has been canceled by the cancel request which had been triggered 

    2157. 

  2157. 			 * by either the epsonPrintCancelJob/Page() API 

    2158. 

  2158. 			 * or a user operation on the printer panel. */

    2159. 

  2159. 			status->printerStatus = EPS_PRNST_CANCELLING;

    2160. 

  2160. 			if(EPS_PRNERR_NOERROR == status->errorCode){

    2161. 

  2161. 				status->errorCode = EPS_PRNERR_BUSY;

    2162. 

  2162. 			}

    2163. 

  2163. 		} else if( !bIoStatus ) {

    2164. 

  2164. 			/* ESC/P-R Library had sent all that is needed to print 

    2165. 

  2165. 			 * to the printer but the printer has not been completed printing yet. */

    2166. 

  2166. 			status->printerStatus = EPS_PRNST_BUSY;

    2167. 

  2167. 			if(EPS_PRNERR_NOERROR == status->errorCode){

    2168. 

  2168. 				status->errorCode = EPS_PRNERR_BUSY;

    2169. 

  2169. 			}

    2170. 

  2170. 		} 

    2171. 

  2171. 		/* ignore color-ink-end warning 

    2172. 

  2172. 		else if( EPS_PRNWARN_COLOR_INKOUT & stInfo.nWarn

    2173. 

  2173. 			&& EPS_STATUS_ESTABLISHED != printJob.jobStatus ){

    2174. 

  2174. 			 color ink out is error, when besides job. 

    2175. 

  2175. 			status->errorCode = EPS_PRNERR_INKOUT;

    2176. 

  2176. 			status->printerStatus = EPS_PRNST_ERROR;

    2177. 

  2177. 		}*/

    2178. 

  2178. 	}

    2179. 

  2179. 

    2180. 

  2180. /*** Set continue flag                                                              */

    2181. 

  2181. 	status->jobContinue = TRUE;

    2182. 

  2182. 	if( EPS_STATUS_ESTABLISHED != printJob.jobStatus ){

    2183. 

  2183.         status->jobContinue = FALSE;

    2184. 

  2184. 	} else{

    2185. 

  2185. 		switch(status->errorCode){

    2186. 

  2186. 		/* The error that it can not continue the printing job */

    2187. 

  2187. 		case EPS_PRNERR_GENERAL:

    2188. 

  2188. 		case EPS_PRNERR_FATAL:

    2189. 

  2189. 		case EPS_PRNERR_PAPERJAM:

    2190. 

  2190. 		/*case EPS_PRNERR_SIZE_TYPE_PATH:*/

    2191. 

  2191. 		case EPS_PRNERR_SERVICEREQ:

    2192. 

  2192. 		case EPS_PRNERR_CARDLOADING:

    2193. 

  2193. 		case EPS_PRNERR_BATTERYVOLTAGE:

    2194. 

  2194. 		case EPS_PRNERR_BATTERYTEMPERATURE:

    2195. 

  2195. 		case EPS_PRNERR_BATTERYEMPTY:

    2196. 

  2196.         case EPS_PRNERR_COMM:

    2197. 

  2197. 			status->jobContinue = FALSE;

    2198. 

  2198. 			break;

    2199. 

  2199. 

    2200. 

  2200. 		case EPS_PRNERR_BUSY:

    2201. 

  2201. 			if(EPS_PRNST_CANCELLING == status->printerStatus){

    2202. 

  2202. 			/* When last time page printing.

    2203. 

  2203. 			   It's state EPS_PRNST_CANCELLING & EPS_PRNERR_BUSY.*/

    2204. 

  2204. 				status->jobContinue = TRUE;

    2205. 

  2205. 			} else{

    2206. 

  2206. 				status->jobContinue = FALSE;

    2207. 

  2207. 			}

    2208. 

  2208. 			break;

    2209. 

  2209. 		}

    2210. 

  2210. 	}

    2211. 

  2211. 

    2212. 

  2212. /*** Return to Caller                                                                   */

    2213. 

  2213.     EPS_RETURN( ret );

    2214. 

  2214. }

    2215. 

  2215. 

    2216. 

  2216. 

    2217. 

  2217. /*******************************************|********************************************/

    2218. 

  2218. /*                                                                                      */

    2219. 

  2219. /* Function name:   epsGetInkInfo()                                                     */

    2220. 

  2220. /*                                                                                      */

    2221. 

  2221. /* Arguments                                                                            */

    2222. 

  2222. /* ---------                                                                            */

    2223. 

  2223. /* Name:        Type:               Description:                                        */

    2224. 

  2224. /* status       EPS_STATUS*         Pointer to the printer status.                      */

    2225. 

  2225. /*                                                                                      */

    2226. 

  2226. /* Return value:                                                                        */

    2227. 

  2227. /*      << Normal >>                                                                    */

    2228. 

  2228. /*      EPS_ERR_NONE                    - Success                                       */

    2229. 

  2229. /*      << Error >>                                                                     */

    2230. 

  2230. /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */

    2231. 

  2231. /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */

    2232. 

  2232. /*      EPS_ERR_INV_ARG_INKINFO         - Invalid argument                              */

    2233. 

  2233. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    2234. 

  2234. /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */

    2235. 

  2235. /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */

    2236. 

  2236. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    2237. 

  2237. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    2238. 

  2238. /*                                                                                      */

    2239. 

  2239. /* Description:                                                                         */

    2240. 

  2240. /*      Gets the Ink Infomation.                                                        */

    2241. 

  2241. /*                                                                                      */

    2242. 

  2242. /*******************************************|********************************************/

    2243. 

  2243. EPS_ERR_CODE    epsGetInkInfo (

    2244. 

  2244. 

    2245. 

  2245. 		EPS_INK_INFO			*info

    2246. 

  2246. 

    2247. 

  2247. ){

    2248. 

  2248. /*** Declare Variable Local to Routine                                                  */

    2249. 

  2249. 	EPS_ERR_CODE    ret = EPS_ERR_NONE;         /* Return status of internal calls      */

    2250. 

  2250. 

    2251. 

  2251. 	EPS_LOG_FUNCIN;

    2252. 

  2252. 

    2253. 

  2253. /*** Has a target printer specified                                                     */

    2254. 

  2254. 	if(NULL == printJob.printer){

    2255. 

  2255. 		EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );

    2256. 

  2256. 	}

    2257. 

  2257. 

    2258. 

  2258. /*** Validate input parameters                                                          */

    2259. 

  2259. 	if (info == NULL){

    2260. 

  2260.         EPS_RETURN( EPS_ERR_INV_ARG_INKINFO );

    2261. 

  2261. 	}

    2262. 

  2262. 

    2263. 

  2263. 	memset(info, 0, sizeof(EPS_INK_INFO));

    2264. 

  2264. 

    2265. 

  2265. /*** protocol GetStatus                                                                 */

    2266. 

  2266. 	ret = prtGetInkInfo(printJob.printer, info);

    2267. 

  2267. 

    2268. 

  2268. /*** Return to Caller                                                                   */

    2269. 

  2269. 

    2270. 

  2270. 	EPS_RETURN( ret );

    2271. 

  2271. }

    2272. 

  2272. 

    2273. 

  2273. 

    2274. 

  2274. /*******************************************|********************************************/

    2275. 

  2275. /*                                                                                      */

    2276. 

  2276. /* Function name:   epsGetSupportedMedia()                                              */

    2277. 

  2277. /*                                                                                      */

    2278. 

  2278. /* Arguments                                                                            */

    2279. 

  2279. /* ---------                                                                            */

    2280. 

  2280. /* Name:            Type:                   Description:                                */

    2281. 

  2281. /* supportedMedia   EPS_SUPPORTED_MEDIA*    Pointer to Supported Media Structure        */

    2282. 

  2282. /*                                                                                      */

    2283. 

  2283. /* Return value:                                                                        */

    2284. 

  2284. /*      << Normal >>                                                                    */

    2285. 

  2285. /*      EPS_ERR_NONE                    - Success                                       */

    2286. 

  2286. /*      << Error >>                                                                     */

    2287. 

  2287. /*      EPS_ERR_NEED_BIDIRECT           - Need Bi-Directional Communication             */

    2288. 

  2288. /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */

    2289. 

  2289. /*      EPS_ERR_INV_ARG_SUPPORTED_MEDIA - Invalid argument                              */

    2290. 

  2290. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    2291. 

  2291. /*      EPS_ERR_NOT_OPEN_IO             - Cannot Open I/O Portal                        */

    2292. 

  2292. /*      EPS_ERR_NOT_CLOSE_IO            - Cannot Close I/O Portal                       */

    2293. 

  2293. /*      EPS_ERR_PROTOCOL_NOT_SUPPORTED  - Unsupported function Error                    */

    2294. 

  2294. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    2295. 

  2295. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    2296. 

  2296. /*                                                                                      */

    2297. 

  2297. /* Description:                                                                         */

    2298. 

  2298. /*      Get supported media information from printer and save those data in             */

    2299. 

  2299. /*      "g_supportedMedia" structure.                                                   */

    2300. 

  2300. /*                                                                                      */

    2301. 

  2301. /*******************************************|********************************************/

    2302. 

  2302. EPS_ERR_CODE     epsGetSupportedMedia (

    2303. 

  2303. 

    2304. 

  2304.         EPS_SUPPORTED_MEDIA*    supportedMedia

    2305. 

  2305. 

    2306. 

  2306. ){

    2307. 

  2307. 

    2308. 

  2308. /*** Declare Variable Local to Routine                                                  */

    2309. 

  2309.     EPS_ERR_CODE    retStatus, retGetPM;        /* Return status of internal calls      */

    2310. 

  2310.     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */

    2311. 

  2311.     EPS_INT32       pmSize = EPS_PM_MAXSIZE;

    2312. 

  2312. 

    2313. 

  2313. 	EPS_PRINTER_INN* innerPrinter = NULL;

    2314. 

  2314. 

    2315. 

  2315. 	EPS_LOG_FUNCIN;

    2316. 

  2316. 

    2317. 

  2317. /*** Initialize Local Variables                                                         */

    2318. 

  2318.     retStatus = retGetPM = EPS_ERR_NONE;

    2319. 

  2319. 

    2320. 

  2320. /*** Validate communication mode                                                        */

    2321. 

  2321. 	if( !EPS_IS_BI_PROTOCOL(printJob.commMode) ){

    2322. 

  2322.         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );

    2323. 

  2323. 	}

    2324. 

  2324. 

    2325. 

  2325. /*** Has a target printer specified                                                     */

    2326. 

  2326. 	if(NULL == printJob.printer){

    2327. 

  2327. 		EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );

    2328. 

  2328. 	}

    2329. 

  2329. 	innerPrinter = printJob.printer;

    2330. 

  2330. 

    2331. 

  2331. 	if( !EPS_IS_BI_PROTOCOL(innerPrinter->protocol) ){

    2332. 

  2332.         EPS_RETURN( EPS_ERR_NEED_BIDIRECT );

    2333. 

  2333. 	}

    2334. 

  2334. 

    2335. 

  2335. /*** Validate input parameters                                                          */

    2336. 

  2336. 	if (supportedMedia == NULL){

    2337. 

  2337. 		EPS_RETURN( EPS_ERR_INV_ARG_SUPPORTED_MEDIA );

    2338. 

  2338.     }

    2339. 

  2339. 

    2340. 

  2340. #if !_VALIDATE_SUPPORTED_MEDIA_DATA_

    2341. 

  2341. /*** If already exist, return current value                                             */

    2342. 

  2342. 	if(innerPrinter->supportedMedia.numSizes > 0 

    2343. 

  2343. 		&& NULL != innerPrinter->supportedMedia.sizeList){

    2344. 

  2344. 		EPS_RETURN( DuplSupportedMedia(innerPrinter, supportedMedia) );

    2345. 

  2345. 	}

    2346. 

  2346. #endif

    2347. 

  2347. 

    2348. 

  2348. 	/* Clear the prev value                                                             */

    2349. 

  2349. 	prtClearSupportedMedia(innerPrinter);

    2350. 

  2350. 

    2351. 

  2351. 	/* Clear the Printer Model Information (Media data or "PM" data)                    */

    2352. 

  2352. 	memset(pmString,0,EPS_PM_MAXSIZE);

    2353. 

  2353. 

    2354. 

  2354. 	/*** Get PM from Printer                                                            */

    2355. 

  2355. 	retStatus = prtGetPMString(innerPrinter, 1, pmString, &pmSize);

    2356. 

  2356. 

    2357. 

  2357. 	/*** ESC/Page divergence ***/

    2358. 

  2358. 	if(EPS_LANG_ESCPR != innerPrinter->language ){

    2359. 

  2359. #ifdef GCOMSW_CMD_ESCPAGE

    2360. 

  2360. 		if( EPS_ERR_NONE == retStatus ) {

    2361. 

  2361. 			/*** Create Media Infomation                                                */

    2362. 

  2362. 			retStatus = pageCreateMediaInfo(innerPrinter, pmString, pmSize);

    2363. 

  2363. 		}

    2364. 

  2364. #else

    2365. 

  2365. 		retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    2366. 

  2366. #endif

    2367. 

  2367. 

    2368. 

  2368. 	} else {

    2369. 

  2369. 		if ( EPS_ERR_NONE == retStatus ){

    2370. 

  2370. 			/*** Create Media Infomation                                                */

    2371. 

  2371. 			retStatus = CreateMediaInfo(innerPrinter, pmString, pmSize);

    2372. 

  2372. 		}

    2373. 

  2373. 	}

    2374. 

  2374. 

    2375. 

  2375. /*** Copy the supproted media information from "printer" structure to input buffer      */

    2376. 

  2376. 	if ( EPS_ERR_NONE == retStatus ){

    2377. 

  2377. 		/* Copy to input buffer                                                         */

    2378. 

  2378. 		retStatus = DuplSupportedMedia(innerPrinter, supportedMedia);

    2379. 

  2379. 	}

    2380. 

  2380. /*** Return to Caller                                                                   */

    2381. 

  2381.     EPS_RETURN( retStatus );

    2382. 

  2382. }

    2383. 

  2383. 

    2384. 

  2384. 

    2385. 

  2385. /*******************************************|********************************************/

    2386. 

  2386. /*                                                                                      */

    2387. 

  2387. /* Function name:   epsGetPrintableArea()                                               */

    2388. 

  2388. /*                                                                                      */

    2389. 

  2389. /* Arguments                                                                            */

    2390. 

  2390. /* ---------                                                                            */

    2391. 

  2391. /* Name:            Type:                   Description:                                */

    2392. 

  2392. /* jobAttr          const EPS_JOB_ATTRIB*   I: Print Job Attribute                      */

    2393. 

  2393. /* printableWidth   EPS_INT32*              O: Printable area width.                    */

    2394. 

  2394. /* printableHeight  EPS_INT32*              O: Printable area height.                   */

    2395. 

  2395. /*                                                                                      */

    2396. 

  2396. /* Return value:                                                                        */

    2397. 

  2397. /*      << Normal >>                                                                    */

    2398. 

  2398. /*      EPS_ERR_NONE                            - Success                               */

    2399. 

  2399. /*      << Error >>                                                                     */

    2400. 

  2400. /*      EPS_ERR_LIB_NOT_INITIALIZED             - ESC/P-R Lib is NOT initialized        */

    2401. 

  2401. /*      EPS_ERR_INV_ARG_JBO_ATTRIB              - Invalid argument "jobAttr"            */

    2402. 

  2402. /*      EPS_ERR_INV_ARG_PRINTABLE_WIDTH         - Invalid argument "printableWidth"     */

    2403. 

  2403. /*      EPS_ERR_INV_ARG_PRINTABLE_HEIGHT        - Invalid argument "printableHeight"    */

    2404. 

  2404. /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */

    2405. 

  2405. /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */

    2406. 

  2406. /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */

    2407. 

  2407. /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */

    2408. 

  2408. /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */

    2409. 

  2409. /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */

    2410. 

  2410. /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */

    2411. 

  2411. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */

    2412. 

  2412. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */

    2413. 

  2413. /*      EPS_ERR_OPR_FAIL                        - Internal Error                        */

    2414. 

  2414. /*                                                                                      */

    2415. 

  2415. /* Description:                                                                         */

    2416. 

  2416. /*      Gets the printable area of the image.                                           */

    2417. 

  2417. /*                                                                                      */

    2418. 

  2418. /*******************************************|********************************************/

    2419. 

  2419. EPS_ERR_CODE    epsGetPrintableArea (

    2420. 

  2420. 

    2421. 

  2421.         EPS_JOB_ATTRIB*     jobAttr,

    2422. 

  2422.         EPS_UINT32*         printableWidth,

    2423. 

  2423.         EPS_UINT32*         printableHeight

    2424. 

  2424. 

    2425. 

  2425. ){

    2426. 

  2426. 

    2427. 

  2427. /*** Declare Variable Local to Routine                                                  */

    2428. 

  2428. EPS_INT32       idx;                                /* General loop/index varaible      */

    2429. 

  2429. EPS_ERR_CODE    retStatus;                          /* Return status of internal calls  */

    2430. 

  2430. EPS_INT32       factor;                             /* Scaling factor for dpi           */

    2431. 

  2431. EPS_INT32       tempPrintableWidth;

    2432. 

  2432. EPS_INT32       tempPrintableHeight;

    2433. 

  2433. const EPS_MEDIA_INFO* pMI = NULL;

    2434. 

  2434. EPS_INT16		minCustomBorder;

    2435. 

  2435. 

    2436. 

  2436. EPS_LOG_FUNCIN;

    2437. 

  2437. 

    2438. 

  2438. /*** Has a Lib been initialized                                                         */

    2439. 

  2439.     if (libStatus != EPS_STATUS_INITIALIZED) {

    2440. 

  2440.         EPS_RETURN( EPS_ERR_LIB_NOT_INITIALIZED );

    2441. 

  2441. 	}

    2442. 

  2442. 	if(NULL == printJob.printer){

    2443. 

  2443. 		EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );

    2444. 

  2444. 	}

    2445. 

  2445. 

    2446. 

  2446. /*** Validate input parameters                                                          */

    2447. 

  2447.     if (jobAttr == NULL)

    2448. 

  2448.         EPS_RETURN( EPS_ERR_INV_ARG_JOB_ATTRIB );

    2449. 

  2449.     

    2450. 

  2450.     if (printableWidth == NULL)

    2451. 

  2451.         EPS_RETURN( EPS_ERR_INV_ARG_PRINTABLE_WIDTH );

    2452. 

  2452.         

    2453. 

  2453.     if (printableHeight == NULL)

    2454. 

  2454.         EPS_RETURN( EPS_ERR_INV_ARG_PRINTABLE_HEIGHT );

    2455. 

  2455. 

    2456. 

  2456. 	/*** ESC/Page divergence ***/

    2457. 

  2457. 	if( EPS_LANG_ESCPR != printJob.printer->language ){

    2458. 

  2458. #ifdef GCOMSW_CMD_ESCPAGE

    2459. 

  2459. 		retStatus = pageGetPrintableArea(jobAttr, printableWidth, printableHeight);

    2460. 

  2460. #else

    2461. 

  2461. 		retStatus = EPS_ERR_LANGUAGE_NOT_SUPPORTED;

    2462. 

  2462. #endif

    2463. 

  2463. 		EPS_RETURN( retStatus );

    2464. 

  2464. 	}

    2465. 

  2465. 

    2466. 

  2466. /*** Initialize Local Variables                                                         */

    2467. 

  2467.     retStatus = EPS_ERR_NONE;

    2468. 

  2468. 

    2469. 

  2469. /*** Validate/Confirm Page Attribute Data                                               */

    2470. 

  2470.     /*** Media Size                                                                     */

    2471. 

  2471.     if (! ( ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A4              ) &&

    2472. 

  2472.               (jobAttr->mediaSizeIdx       <= EPS_MSID_HIVISION        )    ) ||

    2473. 

  2473.             ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A3NOBI          ) &&

    2474. 

  2474.               (jobAttr->mediaSizeIdx       <= EPS_MSID_12X12           )    ) ||

    2475. 

  2475.             ( (jobAttr->mediaSizeIdx       == EPS_MSID_USER            )    )    ) )

    2476. 

  2476.         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );

    2477. 

  2477. 

    2478. 

  2478. #if 0   /* These parameter are not used in this function */

    2479. 

  2479. 	/*** Media Type                                                                     */

    2480. 

  2480.     if (! ( ( (jobAttr->mediaTypeIdx       >= EPS_MTID_PLAIN           ) &&

    2481. 

  2481. /*              (jobAttr->mediaTypeIdx       <= EPS_MTID_GLOSSYHAGAKI    )    ) ||*/

    2482. 

  2482.               (jobAttr->mediaTypeIdx       <= EPS_MTID_BUSINESSCOAT    )    ) ||

    2483. 

  2483.             ( (jobAttr->mediaTypeIdx       >= EPS_MTID_CDDVD           ) &&

    2484. 

  2484.               (jobAttr->mediaTypeIdx       <= EPS_MTID_CDDVDGLOSSY     )    ) ||

    2485. 

  2485.             ( (jobAttr->mediaTypeIdx       == EPS_MTID_CLEANING        )    )    ) )

    2486. 

  2486.         EPS_RETURN( EPS_ERR_INV_MEDIA_TYPE );

    2487. 

  2487. #endif

    2488. 

  2488. 

    2489. 

  2489.     /*** Border Mode                                                                    */

    2490. 

  2490.     if (! (   (jobAttr->printLayout        == EPS_MLID_BORDERLESS      ) ||

    2491. 

  2491.               (jobAttr->printLayout        == EPS_MLID_BORDERS         ) ||

    2492. 

  2492.               (jobAttr->printLayout        == EPS_MLID_CDLABEL         ) ||

    2493. 

  2493.               (jobAttr->printLayout        == EPS_MLID_DIVIDE16        ) ||

    2494. 

  2494.               (jobAttr->printLayout        == EPS_MLID_CUSTOM          )    ) )

    2495. 

  2495.         EPS_RETURN( EPS_ERR_INV_BORDER_MODE );

    2496. 

  2496. 

    2497. 

  2497. #if 0   /* These parameter are not used in this function */

    2498. 

  2498.     /*** Print Quality                                                                  */

    2499. 

  2499.     if (! (   (jobAttr->printQuality       == EPS_MQID_DRAFT           ) ||

    2500. 

  2500.               (jobAttr->printQuality       == EPS_MQID_NORMAL          ) ||

    2501. 

  2501.               (jobAttr->printQuality       == EPS_MQID_HIGH            )    ) )

    2502. 

  2502.         EPS_RETURN( EPS_ERR_INV_PRINT_QUALITY );

    2503. 

  2503. 

    2504. 

  2504.     /*** Color Mode                                                                     */

    2505. 

  2505.     if (! (   (jobAttr->colorMode          == EPS_CM_COLOR             ) ||

    2506. 

  2506.               (jobAttr->colorMode          == EPS_CM_MONOCHROME        )    ) )

    2507. 

  2507.         EPS_RETURN( EPS_ERR_INV_COLOR_MODE );

    2508. 

  2508. #endif

    2509. 

  2509. 

    2510. 

  2510.     /*** Input Image Resolution                                                         */

    2511. 

  2511.     /*** Select table and factor                                                        */

    2512. 

  2512. 	if(jobAttr->inputResolution == EPS_IR_360X360){

    2513. 

  2513. 		pMI = epsMediaSize;

    2514. 

  2514. 	    factor = 1;

    2515. 

  2515. 		minCustomBorder = EPS_BORDERS_MARGIN_360;

    2516. 

  2516. 	} else if(jobAttr->inputResolution == EPS_IR_720X720){

    2517. 

  2517. 		pMI = epsMediaSize;

    2518. 

  2518. 		factor = 2;

    2519. 

  2519. 		minCustomBorder = EPS_BORDERS_MARGIN_360;

    2520. 

  2520. 	} else if(jobAttr->inputResolution == EPS_IR_300X300){

    2521. 

  2521. 		pMI = epsMediaSize300;

    2522. 

  2522. 	    factor = 1;

    2523. 

  2523. 		minCustomBorder = EPS_BORDERS_MARGIN_300;

    2524. 

  2524. 	} else if(jobAttr->inputResolution == EPS_IR_600X600){

    2525. 

  2525. 		pMI = epsMediaSize300;

    2526. 

  2526. 	    factor = 2;

    2527. 

  2527. 		minCustomBorder = EPS_BORDERS_MARGIN_300;

    2528. 

  2528. 	} else{

    2529. 

  2529.         EPS_RETURN( EPS_ERR_INV_INPUT_RESOLUTION )

    2530. 

  2530. 	}

    2531. 

  2531. 

    2532. 

  2532. #if 0   /* These parameter are not used in this function */

    2533. 

  2533.     /*** Printing Direction                                                             */

    2534. 

  2534.     if (! (   (jobAttr->printDirection     == EPS_PD_BIDIREC           ) ||

    2535. 

  2535.               (jobAttr->printDirection     == EPS_PD_UNIDIREC          )    ) )

    2536. 

  2536.         EPS_RETURN( EPS_ERR_INV_PRINT_DIRECTION );

    2537. 

  2537. 

    2538. 

  2538.     /*** Color Plane                                                                    */

    2539. 

  2539.     if (! (   (jobAttr->colorPlane         == EPS_CP_FULLCOLOR         ) ||

    2540. 

  2540.               (jobAttr->colorPlane         == EPS_CP_256COLOR          )    ) )

    2541. 

  2541.         EPS_RETURN( EPS_ERR_INV_COLOR_PLANE );

    2542. 

  2542. 

    2543. 

  2543.     /*** Pallette Data                                                                  */

    2544. 

  2544.     if (jobAttr->colorPlane == EPS_CP_256COLOR) {

    2545. 

  2545.         if (! ((jobAttr->paletteSize       >= 3                        ) &&

    2546. 

  2546.                (jobAttr->paletteSize       <= 768/*765*/               )    ) )

    2547. 

  2547.             EPS_RETURN( EPS_ERR_INV_PALETTE_SIZE );

    2548. 

  2548.         if (    jobAttr->paletteData       == NULL                     )

    2549. 

  2549.             EPS_RETURN( EPS_ERR_INV_PALETTE_DATA );

    2550. 

  2550.     }

    2551. 

  2551. 

    2552. 

  2552.     /*** Brightness                                                                     */

    2553. 

  2553.     if (! (   (jobAttr->brightness         >= -50                      ) &&

    2554. 

  2554.               (jobAttr->brightness         <=  50                      )    ) )

    2555. 

  2555.         EPS_RETURN( EPS_ERR_INV_BRIGHTNESS );

    2556. 

  2556. 

    2557. 

  2557.     /*** Contrast                                                                       */

    2558. 

  2558.     if (! (   (jobAttr->contrast           >= -50                      ) &&

    2559. 

  2559.               (jobAttr->contrast           <=  50                      )    ) )

    2560. 

  2560.         EPS_RETURN( EPS_ERR_INV_CONTRAST );

    2561. 

  2561. 

    2562. 

  2562.     /*** Saturation                                                                     */

    2563. 

  2563.     if (! (   (jobAttr->saturation         >= -50                      ) &&

    2564. 

  2564.               (jobAttr->saturation         <=  50                      )    ) )

    2565. 

  2565.         EPS_RETURN( EPS_ERR_INV_SATURATION );

    2566. 

  2566. #endif

    2567. 

  2567. 

    2568. 

  2568.     /*** Margin                                                                         */

    2569. 

  2569.     if (jobAttr->printLayout == EPS_MLID_CUSTOM) {

    2570. 

  2570.         if (jobAttr->topMargin    < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_TOP_MARGIN );

    2571. 

  2571.         if (jobAttr->leftMargin   < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_LEFT_MARGIN );

    2572. 

  2572.         if (jobAttr->bottomMargin < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_BOTTOM_MARGIN );

    2573. 

  2573.         if (jobAttr->rightMargin  < minCustomBorder*factor) EPS_RETURN( EPS_ERR_INV_RIGHT_MARGIN );

    2574. 

  2574.     }

    2575. 

  2575. 

    2576. 

  2576. #if 0   /* Don't need this logic */

    2577. 

  2577.     /*** If full-color mode, nullify the 256-color parameters                           */

    2578. 

  2578.     printJob.bpp = 1;

    2579. 

  2579.     if (jobAttr->colorPlane == EPS_CP_FULLCOLOR) {

    2580. 

  2580.         jobAttr->paletteSize = 0;

    2581. 

  2581.         jobAttr->paletteData = NULL;

    2582. 

  2582.         printJob.bpp          = 3;

    2583. 

  2583.     }

    2584. 

  2584. #endif

    2585. 

  2585. 

    2586. 

  2586. /*** Get Printable Area                                                                 */

    2587. 

  2587.     /*** Find the Media by ID                                                           */

    2588. 

  2588.     for (idx = 0; pMI[idx].id != -1; idx++) {

    2589. 

  2589.         if (pMI[idx].id == jobAttr->mediaSizeIdx)

    2590. 

  2590.             break;

    2591. 

  2591.     }

    2592. 

  2592.     if (pMI[idx].id == -1) {

    2593. 

  2593.         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );

    2594. 

  2594.     }

    2595. 

  2595. 

    2596. 

  2596.     /*** Initialize Printable based on printLayout                                      */

    2597. 

  2597.     switch( jobAttr->printLayout ){

    2598. 

  2598. 	case EPS_MLID_BORDERLESS:

    2599. 

  2599.         tempPrintableWidth  = pMI[idx].print_area_x_borderless * factor;

    2600. 

  2600.         tempPrintableHeight = pMI[idx].print_area_y_borderless * factor;

    2601. 

  2601. 		break;

    2602. 

  2602. 

    2603. 

  2603. 	case EPS_MLID_BORDERS:

    2604. 

  2604. 	case EPS_MLID_DIVIDE16:	/* layout processing is not done. */

    2605. 

  2605.         tempPrintableWidth  = pMI[idx].print_area_x_border * factor;

    2606. 

  2606.         tempPrintableHeight = pMI[idx].print_area_y_border * factor;

    2607. 

  2607. 		break;

    2608. 

  2608. 

    2609. 

  2609. 	case EPS_MLID_CDLABEL:

    2610. 

  2610. 		if( !( (jobAttr->cdDimOut >= EPS_CDDIM_IN_MIN   )

    2611. 

  2611. 			&& (jobAttr->cdDimOut <= EPS_CDDIM_OUT_MAX ) ) ){

    2612. 

  2612. 			EPS_RETURN( EPS_ERR_INV_CD_OUTDIM );

    2613. 

  2613. 		}

    2614. 

  2614. 

    2615. 

  2615. 		tempPrintableWidth  =

    2616. 

  2616. 			tempPrintableHeight = elGetDots(jobAttr->inputResolution, jobAttr->cdDimOut);

    2617. 

  2617. 		break;

    2618. 

  2618. 

    2619. 

  2619. 	default: /* printLayout  == EPS_MLID_CUSTOM */

    2620. 

  2620.         tempPrintableWidth  = pMI[idx].paper_x *factor -

    2621. 

  2621.                               jobAttr->leftMargin      -

    2622. 

  2622.                               jobAttr->rightMargin;

    2623. 

  2623.         tempPrintableHeight = pMI[idx].paper_y *factor -

    2624. 

  2624.                               jobAttr->topMargin       -

    2625. 

  2625.                               jobAttr->bottomMargin;

    2626. 

  2626.     }

    2627. 

  2627. 

    2628. 

  2628. /*** Validate/Confirm Magin Setting                                                     */

    2629. 

  2629.     if (jobAttr->printLayout == EPS_MLID_CUSTOM) {

    2630. 

  2630.         if (tempPrintableWidth  <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH );

    2631. 

  2631.         if (tempPrintableHeight <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT );

    2632. 

  2632.     }

    2633. 

  2633. 

    2634. 

  2634. /*** Set Printable Area to input parameter                                              */

    2635. 

  2635.     if ((tempPrintableWidth > 0) && (tempPrintableHeight > 0)) {

    2636. 

  2636.         *printableWidth  = (EPS_UINT32)tempPrintableWidth;

    2637. 

  2637.         *printableHeight = (EPS_UINT32)tempPrintableHeight;

    2638. 

  2638.     } else{

    2639. 

  2639.         EPS_RETURN( EPS_ERR_OPR_FAIL );

    2640. 

  2640.     }

    2641. 

  2641.     

    2642. 

  2642. /*** Return to Caller                                                                   */

    2643. 

  2643.     EPS_RETURN( EPS_ERR_NONE );

    2644. 

  2644. }

    2645. 

  2645. 

    2646. 

  2646. 

    2647. 

  2647. /*******************************************|********************************************/

    2648. 

  2648. /*                                                                                      */

    2649. 

  2649. /* Function name:   epsMakeMainteCmd()                                                  */

    2650. 

  2650. /*                                                                                      */

    2651. 

  2651. /* Arguments                                                                            */

    2652. 

  2652. /* ---------                                                                            */

    2653. 

  2653. /* Name:        Type:               Description:                                        */

    2654. 

  2654. /* cmd          EPS_INT32           I:maintenance command type.                         */

    2655. 

  2655. /* buffer       EPS_UINT8*          I:pointer to command buffer.                        */

    2656. 

  2656. /* buffersize   EPS_UINT32*         I: buffer size.                                     */

    2657. 

  2657. /*                                  O: need size.                                       */

    2658. 

  2658. /*                                                                                      */

    2659. 

  2659. /* Return value:                                                                        */

    2660. 

  2660. /*      << Normal >>                                                                    */

    2661. 

  2661. /*      EPS_ERR_NONE                    - Success                                       */

    2662. 

  2662. /*      << Error >>                                                                     */

    2663. 

  2663. /*      EPS_ERR_LIB_NOT_INITIALIZED		- ESC/P-R Lib is NOT initialized				*/

    2664. 

  2664. /*      EPS_ERR_INV_ARG_CMDTYPE			- Invalid argument "cmd"						*/

    2665. 

  2665. /*      EPS_ERR_OPR_FAIL				- Internal Error								*/

    2666. 

  2666. /*      EPS_ERR_MEMORY_ALLOCATION		- Failed to allocate memory						*/

    2667. 

  2667. /*      EPS_ERR_PRINTER_NOT_SET         - Target printer is not specified               */

    2668. 

  2668. /*      EPS_ERR_LANGUAGE_NOT_SUPPORTED  - Unsupported function Error (language)         */

    2669. 

  2669. /*                                                                                      */

    2670. 

  2670. /* Description:                                                                         */

    2671. 

  2671. /*      Make maintenance command.                                                       */

    2672. 

  2672. /*      Call this function as specifying NULL to buffer, so that the memory size        */

    2673. 

  2673. /*      necessary for executing the maintenance command is returned to buffersize.      */

    2674. 

  2674. /*                                                                                      */

    2675. 

  2675. /*******************************************|********************************************/

    2676. 

  2676. EPS_ERR_CODE epsMakeMainteCmd     (

    2677. 

  2677. 

    2678. 

  2678. 		EPS_INT32		cmd,

    2679. 

  2679. 		EPS_UINT8*		buffer,

    2680. 

  2680. 		EPS_UINT32*		buffersize

    2681. 

  2681. 

    2682. 

  2682. ){

    2683. 

  2683. #ifdef GCOMSW_EF_MAINTE

    2684. 

  2684. /*** Declare Variable Local to Routine                                                  */

    2685. 

  2685. 	EPS_ERR_CODE retStatus = EPS_ERR_NONE;      /* Return status of internal calls      */

    2686. 

  2686. 	EPS_UINT8 *pCmdBuf = NULL;

    2687. 

  2687. 	EPS_UINT8 *pCmdPos = NULL;

    2688. 

  2688. 	EPS_UINT32 cmdSize = 0;

    2689. 

  2689. 	EPS_UINT32 cmdBufSize = 0;

    2690. 

  2690. 

    2691. 

  2691. 	EPS_LOG_FUNCIN;

    2692. 

  2692. 

    2693. 

  2693. /*** Has a target printer specified                                                     */

    2694. 

  2694. 	if(NULL == printJob.printer){

    2695. 

  2695. 		EPS_RETURN( EPS_ERR_PRINTER_NOT_SET );

    2696. 

  2696. 	}

    2697. 

  2697. 

    2698. 

  2698. 	if(EPS_LANG_ESCPR != printJob.printer->language ){

    2699. 

  2699. 		EPS_RETURN( EPS_ERR_LANGUAGE_NOT_SUPPORTED );

    2700. 

  2700. 	}

    2701. 

  2701. 

    2702. 

  2702. 

    2703. 

  2703. 	if(buffer){

    2704. 

  2704. 		cmdBufSize = 256;

    2705. 

  2705. 		pCmdBuf = (EPS_UINT8*)EPS_ALLOC(cmdBufSize);

    2706. 

  2706. 		pCmdPos = pCmdBuf;

    2707. 

  2707. 	}

    2708. 

  2708. 

    2709. 

  2709. #define MakeMainteCmd_ADDCMD(CMD) {														\

    2710. 

  2710. 		if(buffer){																		\

    2711. 

  2711. 			retStatus = AddCmdBuff(&pCmdBuf, &pCmdPos, &cmdBufSize, CMD, sizeof(CMD));	\

    2712. 

  2712. 			if(EPS_ERR_NONE != retStatus){												\

    2713. 

  2713. 				goto epsMakeMainteCmd_END;												\

    2714. 

  2714. 			}																			\

    2715. 

  2715. 		}																				\

    2716. 

  2716. 		cmdSize += sizeof(CMD);															\

    2717. 

  2717. 	}

    2718. 

  2718. 

    2719. 

  2719. 	switch(cmd){

    2720. 

  2720. 	case EPS_MNT_NOZZLE:				/* nozzle check */

    2721. 

  2721. 		MakeMainteCmd_ADDCMD(ExitPacketMode)

    2722. 

  2722. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2723. 

  2723. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2724. 

  2724. 

    2725. 

  2725. 		MakeMainteCmd_ADDCMD(EnterRemoteMode)

    2726. 

  2726. 		if(epsCmnFnc.getLocalTime){

    2727. 

  2727. 			MakeMainteCmd_ADDCMD(RemoteTI)

    2728. 

  2728. 			if( buffer ){

    2729. 

  2729. 				MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));

    2730. 

  2730. 			}

    2731. 

  2731. 		}

    2732. 

  2732. 		MakeMainteCmd_ADDCMD(RemoteJS)

    2733. 

  2733. 		MakeMainteCmd_ADDCMD(RemoteNC)

    2734. 

  2734. 		if(pCmdPos && obsIsA3Model(EPS_MDC_NOZZLE)){

    2735. 

  2735. 			*(pCmdPos - sizeof(RemoteNC) + 5) = 0x10;

    2736. 

  2736. 		}

    2737. 

  2737. 		MakeMainteCmd_ADDCMD(ExitRemoteMode)

    2738. 

  2738. 

    2739. 

  2739. 		MakeMainteCmd_ADDCMD(DataCR)

    2740. 

  2740. 		MakeMainteCmd_ADDCMD(DataLF)

    2741. 

  2741. 		MakeMainteCmd_ADDCMD(DataCR)

    2742. 

  2742. 		MakeMainteCmd_ADDCMD(DataLF)

    2743. 

  2743. 		

    2744. 

  2744. 		MakeMainteCmd_ADDCMD(EnterRemoteMode)

    2745. 

  2745. 		MakeMainteCmd_ADDCMD(RemoteVI)

    2746. 

  2746. 		MakeMainteCmd_ADDCMD(RemoteLD)

    2747. 

  2747. 		MakeMainteCmd_ADDCMD(ExitRemoteMode)

    2748. 

  2748. 

    2749. 

  2749. 		MakeMainteCmd_ADDCMD(DataFF)

    2750. 

  2750. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2751. 

  2751. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2752. 

  2752. 		

    2753. 

  2753. 		MakeMainteCmd_ADDCMD(EnterRemoteMode)

    2754. 

  2754. 		MakeMainteCmd_ADDCMD(RemoteJE)

    2755. 

  2755. 		MakeMainteCmd_ADDCMD(ExitRemoteMode)

    2756. 

  2756. 		break;

    2757. 

  2757. 

    2758. 

  2758. 	case EPS_MNT_CLEANING:					/* head cleaning */

    2759. 

  2759. 		MakeMainteCmd_ADDCMD(ExitPacketMode)

    2760. 

  2760. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2761. 

  2761. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2762. 

  2762. 

    2763. 

  2763. 		MakeMainteCmd_ADDCMD(EnterRemoteMode)

    2764. 

  2764. 		if(epsCmnFnc.getLocalTime){

    2765. 

  2765. 			MakeMainteCmd_ADDCMD(RemoteTI)

    2766. 

  2766. 			if( buffer ){

    2767. 

  2767. 				MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));

    2768. 

  2768. 			}

    2769. 

  2769. 		}

    2770. 

  2770. 		MakeMainteCmd_ADDCMD(RemoteCH)

    2771. 

  2771. 		MakeMainteCmd_ADDCMD(ExitRemoteMode)

    2772. 

  2772. 

    2773. 

  2773. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2774. 

  2774. 		MakeMainteCmd_ADDCMD(InitPrinter)

    2775. 

  2775. 		

    2776. 

  2776. 		MakeMainteCmd_ADDCMD(EnterRemoteMode)

    2777. 

  2777. 		MakeMainteCmd_ADDCMD(RemoteJE)

    2778. 

  2778. 		MakeMainteCmd_ADDCMD(ExitRemoteMode)

    2779. 

  2779. 		break;

    2780. 

  2780. 

    2781. 

  2781. 	default:

    2782. 

  2782. 		retStatus = EPS_ERR_INV_CMDTYPE;

    2783. 

  2783. 		break;

    2784. 

  2784. 	}

    2785. 

  2785. 

    2786. 

  2786. epsMakeMainteCmd_END:

    2787. 

  2787. 	if(EPS_ERR_NONE == retStatus){

    2788. 

  2788. 		if( buffer ){

    2789. 

  2789. 			if(*buffersize > 0){

    2790. 

  2790. 				memcpy(buffer, pCmdBuf, Min(*buffersize, cmdSize));

    2791. 

  2791. 			}

    2792. 

  2792. 		} 

    2793. 

  2793. 		*buffersize = cmdSize;

    2794. 

  2794. 	}

    2795. 

  2795. 	EPS_SAFE_RELEASE(pCmdBuf);

    2796. 

  2796. 

    2797. 

  2797. 	EPS_RETURN( retStatus );

    2798. 

  2798. #else

    2799. 

  2799. 	return EPS_ERR_INVALID_CALL;

    2800. 

  2800. #endif

    2801. 

  2801. }

    2802. 

  2802. 

    2803. 

  2803. 

    2804. 

  2804. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2805. 

  2805. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2806. 

  2806. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2807. 

  2807. /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/

    2808. 

  2808. /*--------------------             Internal Processing             ---------------------*/

    2809. 

  2809. /*--------------------                     for                     ---------------------*/

    2810. 

  2810. /*--------------------                     API                     ---------------------*/

    2811. 

  2811. /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/

    2812. 

  2812. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2813. 

  2813. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2814. 

  2814. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    2815. 

  2815. 

    2816. 

  2816. /*******************************************|********************************************/

    2817. 

  2817. /*                                                                                      */

    2818. 

  2818. /* Function name:   MonitorStatus()                                                     */

    2819. 

  2819. /*                                                                                      */

    2820. 

  2820. /* Arguments                                                                            */

    2821. 

  2821. /* ---------                                                                            */

    2822. 

  2822. /* Name:        Type:               Description:                                        */

    2823. 

  2823. /* pStInfo      EPS_STATUS_INFO     I: pointer to status info strucutre                 */

    2824. 

  2824. /*                                                                                      */

    2825. 

  2825. /* Return value:                                                                        */

    2826. 

  2826. /*      EPS_ERR_NONE            - Printer settled into one of the requested state(s)    */

    2827. 

  2827. /*      EPS_JOB_CANCELED        - Cancelled operation                                   */

    2828. 

  2828. /*      EPS_ERR_OPR_FAIL        - Internal Error                                        */

    2829. 

  2829. /*      EPS_ERR_PRINTER_ERR_OCCUR  - Printer Error happened                             */

    2830. 

  2830. /*                                                                                      */

    2831. 

  2831. /* Description:                                                                         */

    2832. 

  2832. /*      Monitor the status of the printer.                                              */

    2833. 

  2833. /*                                                                                      */

    2834. 

  2834. /*******************************************|********************************************/

    2835. 

  2835. static EPS_ERR_CODE   MonitorStatus (

    2836. 

  2836. 

    2837. 

  2837.         EPS_STATUS_INFO *pStInfo

    2838. 

  2838. 

    2839. 

  2839. ){

    2840. 

  2840. /*** Declare Variable Local to Routine                                                  */

    2841. 

  2841.     EPS_INT32       retStatus;

    2842. 

  2842.     EPS_STATUS_INFO StatInfo;

    2843. 

  2843. 

    2844. 

  2844. 	EPS_LOG_FUNCIN;

    2845. 

  2845. 

    2846. 

  2846. /*** Initialize Local Variables                                                         */

    2847. 

  2847.     retStatus = EPS_ERR_NONE;

    2848. 

  2848.     memset(&StatInfo, -1, sizeof(EPS_STATUS_INFO));

    2849. 

  2849. 

    2850. 

  2850. 	retStatus = jobFnc.MonitorStatus(&StatInfo);

    2851. 

  2851.     if ( retStatus != EPS_ERR_NONE) {

    2852. 

  2852. 		if(EPS_ERR_COMM_ERROR == retStatus && 

    2853. 

  2853. 			EPS_STATUS_NOT_INITIALIZED != printJob.jobStatus){

    2854. 

  2854. 			printJob.bComm = FALSE;

    2855. 

  2855. 		}

    2856. 

  2856. 

    2857. 

  2857. 		EPS_DBGPRINT(("EPS SER: STAT MON -> Status Retr Failed. [%d]\r\n", retStatus));

    2858. 

  2858.         EPS_RETURN( retStatus );

    2859. 

  2859.     }

    2860. 

  2860. 	if( pStInfo ){

    2861. 

  2861. 		memcpy(pStInfo, &StatInfo, sizeof(EPS_STATUS_INFO));

    2862. 

  2862. 	}

    2863. 

  2863. 

    2864. 

  2864. 	if(EPS_ST_ERROR == StatInfo.nState && EPS_PRNERR_PAPERJAM == StatInfo.nError){

    2865. 

  2865. 		printJob.transmittable = FALSE;

    2866. 

  2866. 	}

    2867. 

  2867. 

    2868. 

  2868.     if(StatInfo.nCancel == EPS_CAREQ_CANCEL) {

    2869. 

  2869.         EPS_DBGPRINT(("EPS SER : CANCEL REQUEST by PRINTER\r\n"));

    2870. 

  2870. 		printJob.resetReq = TRUE;

    2871. 

  2871.         EPS_RETURN( EPS_JOB_CANCELED );

    2872. 

  2872.     }

    2873. 

  2873. 

    2874. 

  2874. /*	EPS_DBGPRINT(("M State\t: %d\n Error\t: %d\n Prepare\t: %d\n", 

    2875. 

  2875. 		StatInfo.nState, StatInfo.nError, StatInfo.nPrepare))

    2876. 

  2876. */

    2877. 

  2877. 	/* The error occurs in printer. */

    2878. 

  2878. 	printJob.contData.lastError = StatInfo.nError;

    2879. 

  2879. 

    2880. 

  2880.     /*EPS_DBGPRINT(("EPS SER: STAT MON -> Printer State [0x%x]\r\n",StatInfo.nState));*/

    2881. 

  2881.     if( StatInfo.nState & ( EPS_ST_IDLE          |

    2882. 

  2882. 							EPS_ST_WAITING       |

    2883. 

  2883. 							EPS_ST_SELF_PRINTING |

    2884. 

  2884. 							EPS_ST_CLEANING      ) ){

    2885. 

  2885.         /*EPS_DBGPRINT(("EPS SER: STAT MON -> SETTLING\r\n"));*/

    2886. 

  2886.         EPS_RETURN( EPS_ERR_NONE );

    2887. 

  2887.     }else{

    2888. 

  2888.         EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    2889. 

  2889. 	}

    2890. 

  2890. }

    2891. 

  2891. 

    2892. 

  2892. 

    2893. 

  2893. /*******************************************|********************************************/

    2894. 

  2894. /*                                                                                      */

    2895. 

  2895. /* Function name:     PrintBand()                                                       */

    2896. 

  2896. /*                                                                                      */

    2897. 

  2897. /* Arguments                                                                            */

    2898. 

  2898. /* ---------                                                                            */

    2899. 

  2899. /* Name:        Type:               Description:                                        */

    2900. 

  2900. /* data          EPS_UINT8*         I: Pointer to image [RGB] data                      */

    2901. 

  2901. /* widthPixels   EPS_UINT32         I: The width of the raster band (in pixels)         */

    2902. 

  2902. /* heightPixels  EPS_UINT32*        I/O: In : Height of image (image lines)  (in pixels)*/

    2903. 

  2903. /*                                     : Out: Sent Height                               */

    2904. 

  2904. /*                                                                                      */

    2905. 

  2905. /* Return value:                                                                        */

    2906. 

  2906. /*      << Normal >>                                                                    */

    2907. 

  2907. /*      EPS_ERR_NONE                    - Success                                       */

    2908. 

  2908. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    2909. 

  2909. /*                                        (Do not return when Uni-Directional)          */

    2910. 

  2910. /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */

    2911. 

  2911. /*      << Error >>                                                                     */

    2912. 

  2912. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    2913. 

  2913. /*      EPS_ERR_INV_ARG_WIDTH_PIXELS    - Invalid argument "widthPixels"                */

    2914. 

  2914. /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */

    2915. 

  2915. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    2916. 

  2916. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    2917. 

  2917. /*                                                                                      */

    2918. 

  2918. /* Description:                                                                         */

    2919. 

  2919. /*      Prints a band of raster data.                                                   */

    2920. 

  2920. /*      It must be noted that this function automatically positions the raster bands;   */

    2921. 

  2921. /*      all subsequent raster bands after the first one are positioned directly         */

    2922. 

  2922. /*      underneath the preceding band.                                                  */

    2923. 

  2923. /*      Horizontal orientation of the raster bands never changes.                       */

    2924. 

  2924. /*                                                                                      */

    2925. 

  2925. /*******************************************|********************************************/

    2926. 

  2926. EPS_ERR_CODE    PrintBand (

    2927. 

  2927. 

    2928. 

  2928.         const EPS_UINT8*  data,             /* Pointer to image [RGB] data              */

    2929. 

  2929.         EPS_UINT32  widthPixels,            /* Width of image [ in pixels ]             */

    2930. 

  2930.         EPS_UINT32  *heightPixels           /* Height of image (image lines)            */

    2931. 

  2931. 

    2932. 

  2932. ) {

    2933. 

  2933. 

    2934. 

  2934. /*** Declare Variable Local to Routine                                                  */

    2935. 

  2935. EPS_ERR_CODE    retStatus;

    2936. 

  2936. EPS_UINT32      idx = 0;                    /* Generl loop/index variable               */

    2937. 

  2937. EPS_IMAGE       line;                       /* Single line of image data                */

    2938. 

  2938. const EPS_UINT8*      tmpImageData;         /* Temporary image pointer                  */

    2939. 

  2939. EPS_BOOL        skipLine;                   /* Flag to skip or print current image line */

    2940. 

  2940. EPS_UINT32		linePixels;

    2941. 

  2941. EPS_UINT32		sendHeight;

    2942. 

  2942. 

    2943. 

  2943. 	EPS_LOG_FUNCIN;

    2944. 

  2944. 

    2945. 

  2945. 	if( NULL == data ){

    2946. 

  2946.         EPS_RETURN( EPS_ERR_INV_ARG_DATA );

    2947. 

  2947. 	}

    2948. 

  2948. 	if(NULL == heightPixels){

    2949. 

  2949.         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );

    2950. 

  2950. 	}

    2951. 

  2951. 	if(*heightPixels == 0){

    2952. 

  2952.         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );

    2953. 

  2953. 	}

    2954. 

  2954. 	sendHeight = *heightPixels;

    2955. 

  2955. 	*heightPixels = 0;

    2956. 

  2956. 

    2957. 

  2957. 	if( widthPixels == 0 ){

    2958. 

  2958.         EPS_RETURN( EPS_ERR_INV_ARG_WIDTH_PIXELS );

    2959. 

  2959. 	}

    2960. 

  2960.  

    2961. 

  2961. /*** Initialize Local Variables                                                         */

    2962. 

  2962.     retStatus = EPS_ERR_NONE;

    2963. 

  2963. 

    2964. 

  2964. 	if( printJob.printableAreaHeight <= (EPS_UINT32)printJob.verticalOffset ){

    2965. 

  2965.         /*** Return to Caller                                                           */

    2966. 

  2966. 		EPS_RETURN( EPS_OUT_OF_BOUNDS );

    2967. 

  2967. 	}

    2968. 

  2968.     

    2969. 

  2969. /*** Clip number is image lines if too many                                             */

    2970. 

  2970. 	if (sendHeight > (printJob.printableAreaHeight - printJob.verticalOffset)){

    2971. 

  2971.         sendHeight =  printJob.printableAreaHeight - printJob.verticalOffset;

    2972. 

  2972. 	}

    2973. 

  2973. 

    2974. 

  2974. /*** Send leftovers of last time And Skip first line of input data                      */

    2975. 

  2975. 	idx = 0;	/* Initialize line counter */

    2976. 

  2976. 

    2977. 

  2977. 	/*** Send leftovers data                                                            */

    2978. 

  2978. 	retStatus = SendLeftovers();

    2979. 

  2979. 	if(EPS_ERR_INVALID_CALL == retStatus){	/* It was unnecessary */

    2980. 

  2980. 		retStatus = EPS_ERR_NONE;

    2981. 

  2981. 		if(printJob.contData.skipLine == TRUE){

    2982. 

  2982. 			idx++;							/* skip first line of input data */

    2983. 

  2983. 			printJob.contData.skipLine = FALSE;

    2984. 

  2984. 		}

    2985. 

  2985. 	} else if(EPS_ERR_NONE == retStatus){	/* Sent leftovers */

    2986. 

  2986. 		idx++;								/* skip first line of input data */

    2987. 

  2987. 	} else{

    2988. 

  2988. 		EPS_RETURN( retStatus );

    2989. 

  2989. 	}

    2990. 

  2990. 

    2991. 

  2991. /*** The following section of code forces the core module to skip raster lines that are */

    2992. 

  2992. /*** completely white in order to minimize data size. This function is compatible with  */

    2993. 

  2993. /*** 8-bit palettized and 24-bit RGB bitmaps.                                           */

    2994. 

  2994. /*** ---------------------------------------------------------------------------------- */

    2995. 

  2995. 

    2996. 

  2996.     /*** Initialize variable                                                            */

    2997. 

  2997.     line.bytesPerLine = printJob.bpp * widthPixels;

    2998. 

  2998. 	linePixels = Min(line.bytesPerLine, printJob.bpp * printJob.printableAreaWidth);

    2999. 

  2999. 

    3000. 

  3000.     for (; idx < sendHeight; idx++) {

    3001. 

  3001.         /* Calculate position of image line                                             */

    3002. 

  3002.         //if(idx == 1){

    3003. 

  3003.         	//idx = sendHeight;

    3004. 

  3004.         	//break;

    3005. 

  3005.         //}

    3006. 

  3006.         line.data = data + idx * line.bytesPerLine;

    3007. 

  3007. 

    3008. 

  3008.         /*** Make new LineRect                                                          */

    3009. 

  3009.         line.rect.top      = (EPS_INT32)(printJob.verticalOffset + idx);

    3010. 

  3010.         line.rect.left     = 0;

    3011. 

  3011.         line.rect.bottom   = line.rect.top + 1;

    3012. 

  3012.         line.rect.right    = (EPS_INT32)(widthPixels);

    3013. 

  3013. 		

    3014. 

  3014. 		/*** Test if current image data is completely white                             */

    3015. 

  3015. 		if(EPS_LANG_ESCPR == printJob.printer->language ){

    3016. 

  3016. 			skipLine = TRUE;

    3017. 

  3017. 		} else{

    3018. 

  3018. 			skipLine = FALSE; /* esc/page need anything band */

    3019. 

  3019. 		}

    3020. 

  3020. 

    3021. 

  3021. 		/* skip blank band for ESC/P-R */

    3022. 

  3022. 		/* check blank page for duplex */

    3023. 

  3023. 		if( EPS_LANG_ESCPR == printJob.printer->language ||

    3024. 

  3024. 			(EPS_DUPLEX_NONE != printJob.attr.duplex && printJob.needBand) )

    3025. 

  3025. 		{

    3026. 

  3026. 			for (tmpImageData = line.data; 

    3027. 

  3027. 				 tmpImageData < (line.data + linePixels); 

    3028. 

  3028. 				 tmpImageData++ ) {

    3029. 

  3029. 				if(*tmpImageData != printJob.whiteColorValue) {

    3030. 

  3030. 					skipLine = FALSE;

    3031. 

  3031. 					printJob.needBand = FALSE;

    3032. 

  3032. 					break;

    3033. 

  3033. 				}

    3034. 

  3034. 			}

    3035. 

  3035. 

    3036. 

  3036. 			if (skipLine == TRUE)continue;

    3037. 

  3037. 		}

    3038. 

  3038. 		/*** Image Data not completely white - print image data                         */

    3039. 

  3039. 		//idx = sendHeight;

    3040. 

  3040. 		//break;

    3041. 

  3041. 		retStatus = PrintLine(&line);

    3042. 

  3042. 

    3043. 

  3043.         if (retStatus != EPS_ERR_NONE) {

    3044. 

  3044.             break;

    3045. 

  3045.         }

    3046. 

  3046.     }

    3047. 

  3047. 

    3048. 

  3048. /*** band positioning adds                                                              */

    3049. 

  3049. 	printJob.verticalOffset += idx;

    3050. 

  3050.     

    3051. 

  3051. /*** Return to Caller                                                                   */

    3052. 

  3052. 	*heightPixels = idx;

    3053. 

  3053. 

    3054. 

  3054.     EPS_RETURN( retStatus );

    3055. 

  3055. }

    3056. 

  3056. 

    3057. 

  3057. 

    3058. 

  3058. /*******************************************|********************************************/

    3059. 

  3059. /*                                                                                      */

    3060. 

  3060. /* Function name:     PrintChunk()                                                      */

    3061. 

  3061. /*                                                                                      */

    3062. 

  3062. /* Arguments                                                                            */

    3063. 

  3063. /* ---------                                                                            */

    3064. 

  3064. /* Name:        Type:               Description:                                        */

    3065. 

  3065. /* data         EPS_UINT8*          I: Pointer to image [RGB] data                      */

    3066. 

  3066. /* dataSize		EPS_UINT32*         I/O: In : size of image                             */

    3067. 

  3067. /*                                     : Out: Sent size                                 */

    3068. 

  3068. /*                                                                                      */

    3069. 

  3069. /* Return value:                                                                        */

    3070. 

  3070. /*      << Normal >>                                                                    */

    3071. 

  3071. /*      EPS_ERR_NONE                    - Success                                       */

    3072. 

  3072. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    3073. 

  3073. /*                                        (Do not return when Uni-Directional)          */

    3074. 

  3074. /*      EPS_OUT_OF_BOUNDS               - Print band is in out of printable area        */

    3075. 

  3075. /*      << Error >>                                                                     */

    3076. 

  3076. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    3077. 

  3077. /*      EPS_ERR_INV_ARG_HEIGHT_PIXELS   - Invalid argument "heightPixels"               */

    3078. 

  3078. /*      EPS_ERR_INV_ARG_DATASIZE		- data size limit								*/

    3079. 

  3079. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    3080. 

  3080. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    3081. 

  3081. /*                                                                                      */

    3082. 

  3082. /* Description:                                                                         */

    3083. 

  3083. /*      Prints Jpeg file data.                                                          */

    3084. 

  3084. /*                                                                                      */

    3085. 

  3085. /*******************************************|********************************************/

    3086. 

  3086. EPS_ERR_CODE    PrintChunk (

    3087. 

  3087. 

    3088. 

  3088.         const EPS_UINT8*  data,             /* Pointer to image [JPEG] data             */

    3089. 

  3089.         EPS_UINT32*       dataSize          /* size of image (chunked data)             */

    3090. 

  3090. 

    3091. 

  3091. ) {

    3092. 

  3092. /*** Declare Variable Local to Routine                                                  */

    3093. 

  3093. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;

    3094. 

  3094. EPS_UINT32      sendSize = 0;

    3095. 

  3095. EPS_UINT32      retBufSize = 0;

    3096. 

  3096. EPS_INT32       cmdBuffSize = ESCPR_HEADER_LENGTH + ESCPR_SEND_JPGDATA_LENGTH;

    3097. 

  3097. EPS_UINT8*      bufPtr = NULL;              /* Temporary buffer pointer                 */

    3098. 

  3098. EPS_INT32       paramSize = 0;              /* Size of command parameters only          */

    3099. 

  3099. 

    3100. 

  3100. EPS_INT32       i = 0;

    3101. 

  3101. #define	DUMMY_DATA_COUNT	(1000)

    3102. 

  3102. 

    3103. 

  3103. 	EPS_LOG_FUNCIN;

    3104. 

  3104. 

    3105. 

  3105. /*** Validate input parameters                                                          */

    3106. 

  3106. 	if(NULL == dataSize){

    3107. 

  3107.         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );

    3108. 

  3108. 	}

    3109. 

  3109. #if LCOMSW_DUMMY_SEND

    3110. 

  3110. 	if( *dataSize == 0 && 

    3111. 

  3111. 		(EPS_PROTOCOL_USB & printJob.printer->protocol) ){

    3112. 

  3112. 		/* USB not peform */

    3113. 

  3113.         EPS_RETURN( EPS_ERR_NONE );

    3114. 

  3114. 	}

    3115. 

  3115. #else

    3116. 

  3116. 	if( NULL == data ){

    3117. 

  3117.         EPS_RETURN( EPS_ERR_INV_ARG_DATA );

    3118. 

  3118. 	}

    3119. 

  3119. 	if(*dataSize == 0){

    3120. 

  3120.         EPS_RETURN( EPS_ERR_INV_ARG_HEIGHT_PIXELS );

    3121. 

  3121. 	}

    3122. 

  3122. #endif

    3123. 

  3123. 

    3124. 

  3124. 	sendSize = *dataSize;

    3125. 

  3125. 	*dataSize = 0;

    3126. 

  3126. 

    3127. 

  3127. #if !_VALIDATE_SUPPORTED_MEDIA_DATA_

    3128. 

  3128. 	if( EPS_JPEG_CHUNK_SIZE_MAX < sendSize){

    3129. 

  3129. 		*dataSize = 0;

    3130. 

  3130.         EPS_RETURN( EPS_ERR_INV_ARG_DATASIZE );

    3131. 

  3131. 	}

    3132. 

  3132. 

    3133. 

  3133. 	if( (EPS_UINT32)printJob.printer->JpgMax < printJob.jpegSize + sendSize){

    3134. 

  3134. 		printJob.bJpgLimit = TRUE;

    3135. 

  3135.         EPS_RETURN( EPS_ERR_INV_ARG_DATASIZE );

    3136. 

  3136. 	}

    3137. 

  3137. #endif

    3138. 

  3138. 

    3139. 

  3139. 	/************************************************************************************/

    3140. 

  3140. 	/*** Send last time leftovers data                                                  */

    3141. 

  3141. 

    3142. 

  3142. 	/*** Header                                                                         */

    3143. 

  3143. 	retStatus = SendLeftovers();

    3144. 

  3144. 	if(EPS_ERR_INVALID_CALL == retStatus){	/* It was unnecessary */

    3145. 

  3145. 		retStatus = EPS_ERR_NONE;

    3146. 

  3146. 	} else if(EPS_ERR_NONE != retStatus){

    3147. 

  3147. 		*dataSize = 0;

    3148. 

  3148. 		EPS_RETURN( retStatus );

    3149. 

  3149. 	}

    3150. 

  3150. 

    3151. 

  3151. 	/*** Data                                                                           */

    3152. 

  3152. 	if(0 < printJob.contData.jpgSize){

    3153. 

  3153. 		retBufSize = 0;

    3154. 

  3154. 		retStatus = SendCommand(data, 

    3155. 

  3155. 								Min(printJob.contData.jpgSize, sendSize),

    3156. 

  3156. 								&retBufSize, FALSE); /* not save Leftovers */

    3157. 

  3157. 		printJob.contData.jpgSize -= retBufSize;

    3158. 

  3158. 		*dataSize = retBufSize;

    3159. 

  3159. 		printJob.jpegSize += retBufSize;	/* add total size */

    3160. 

  3160. 		if( EPS_ERR_NONE != retStatus ){

    3161. 

  3161. 			EPS_RETURN( retStatus );

    3162. 

  3162. 		}

    3163. 

  3163. 

    3164. 

  3164. 		sendSize -= retBufSize;

    3165. 

  3165. 		if(0 >= sendSize ){

    3166. 

  3166. 			EPS_RETURN( EPS_ERR_NONE );

    3167. 

  3167. 		}

    3168. 

  3168. 

    3169. 

  3169. 		data += retBufSize;

    3170. 

  3170. 	}

    3171. 

  3171. 

    3172. 

  3172. 	/************************************************************************************/

    3173. 

  3173. 	/*** Send this time data                                                            */

    3174. 

  3174. 

    3175. 

  3175. 	/*** Header                                                                         */

    3176. 

  3176. 	printJob.contData.jpgSize = sendSize;

    3177. 

  3177. 

    3178. 

  3178. #if !LCOMSW_DUMMY_SEND

    3179. 

  3179. 	EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH )

    3180. 

  3180. #else

    3181. 

  3181. 	if(0 < sendSize){

    3182. 

  3182. 		EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH )

    3183. 

  3183. 	} else{

    3184. 

  3184. 		EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, ESCPR_JPGHEAD_LENGTH * DUMMY_DATA_COUNT )

    3185. 

  3185. 	}

    3186. 

  3186. #endif

    3187. 

  3187. 	if(NULL == sendDataBuf){

    3188. 

  3188. 		sendDataBufSize = 0;

    3189. 

  3189. 		EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )

    3190. 

  3190. 	}

    3191. 

  3191. 

    3192. 

  3192. 	bufPtr = sendDataBuf;

    3193. 

  3193. 	memcpy(bufPtr, SendDataCmd, sizeof(SendDataCmd));

    3194. 

  3194. 	bufPtr += sizeof(SendDataCmd);

    3195. 

  3195. 

    3196. 

  3196. 	paramSize = ESCPR_SEND_JPGDATA_LENGTH + sendSize;

    3197. 

  3197. 	memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, (EPS_UINT32)paramSize, bufPtr);

    3198. 

  3198. 	bufPtr += 4;

    3199. 

  3199. 	memcpy(bufPtr, SendJpegDataName, sizeof(SendJpegDataName));

    3200. 

  3200. 	bufPtr += sizeof(SendJpegDataName);

    3201. 

  3201.  

    3202. 

  3202. 	memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, sendSize, bufPtr);

    3203. 

  3203. 

    3204. 

  3204. 	if(0 < sendSize){

    3205. 

  3205. 		retBufSize = 0;

    3206. 

  3206. 		retStatus = SendCommand(sendDataBuf, cmdBuffSize, &retBufSize, TRUE);/* save Leftovers */

    3207. 

  3207. 		if( EPS_ERR_NONE != retStatus ){

    3208. 

  3208. 			EPS_RETURN( retStatus );

    3209. 

  3209. 		}

    3210. 

  3210. 

    3211. 

  3211. 		/*** Data                                                                           */

    3212. 

  3212. 		retBufSize = 0;

    3213. 

  3213. 		retStatus = SendCommand(data, sendSize, &retBufSize, FALSE);  /* NOT save Leftovers */

    3214. 

  3214. 

    3215. 

  3215. 		*dataSize += retBufSize;

    3216. 

  3216. 		printJob.contData.jpgSize -= retBufSize;

    3217. 

  3217. 

    3218. 

  3218. 		printJob.jpegSize += retBufSize;	/* add total size */

    3219. 

  3219. 	} else {

    3220. 

  3220. 		/*** dummy data */

    3221. 

  3221. 		bufPtr = sendDataBuf + cmdBuffSize;

    3222. 

  3222. 		for(i=1; i < DUMMY_DATA_COUNT; i++){		/* 12x1000 byte */

    3223. 

  3223. 			memcpy(bufPtr, sendDataBuf, cmdBuffSize);

    3224. 

  3224. 			bufPtr += cmdBuffSize;

    3225. 

  3225. 		}

    3226. 

  3226. 		

    3227. 

  3227. 		retStatus = SendCommand(sendDataBuf, ESCPR_JPGHEAD_LENGTH * DUMMY_DATA_COUNT, &retBufSize, TRUE);/* save Leftovers */

    3228. 

  3228. 	}

    3229. 

  3229. 

    3230. 

  3230. 	EPS_RETURN( retStatus );

    3231. 

  3231. }

    3232. 

  3232. 

    3233. 

  3233. 

    3234. 

  3234. /*******************************************|********************************************/

    3235. 

  3235. /*                                                                                      */

    3236. 

  3236. /* Function name:   SendLeftovers()                                                     */

    3237. 

  3237. /*                                                                                      */

    3238. 

  3238. /* Arguments                                                                            */

    3239. 

  3239. /* ---------                                                                            */

    3240. 

  3240. /* Name:        Type:               Description:                                        */

    3241. 

  3241. /* nStartStep   EPS_INT32           I: Step of Start Page comannds                      */

    3242. 

  3242. /*                                                                                      */

    3243. 

  3243. /* Return value:                                                                        */

    3244. 

  3244. /*      << Normal >>                                                                    */

    3245. 

  3245. /*      EPS_ERR_NONE                    - Success                                       */

    3246. 

  3246. /*      EPS_ERR_INVALID_CALL            - This call was unnecessary                     */

    3247. 

  3247. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    3248. 

  3248. /*                                        (Do not return when Uni-Directional)          */

    3249. 

  3249. /*      << Error >>                                                                     */

    3250. 

  3250. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    3251. 

  3251. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    3252. 

  3252. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    3253. 

  3253. /*                                                                                      */

    3254. 

  3254. /* Description:                                                                         */

    3255. 

  3255. /*      send leftovers data.                                                            */

    3256. 

  3256. /*                                                                                      */

    3257. 

  3257. /*******************************************|********************************************/

    3258. 

  3258. static EPS_ERR_CODE    SendLeftovers (

    3259. 

  3259. 

    3260. 

  3260. 			void 

    3261. 

  3261. 

    3262. 

  3262. ){

    3263. 

  3263. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */

    3264. 

  3264. EPS_UINT32		retBufSize = 0;

    3265. 

  3265. 

    3266. 

  3266. 	EPS_LOG_FUNCIN;

    3267. 

  3267. 

    3268. 

  3268. /*** send leftovers                                                                      */

    3269. 

  3269. #ifdef GCOMSW_CMD_ESCPAGE

    3270. 

  3270. 	if(EPS_LANG_ESCPR == printJob.printer->language ){

    3271. 

  3271. #endif

    3272. 

  3272. 		/*** ESC/P-R ***/

    3273. 

  3273. 		if( NULL != printJob.contData.sendData && 0 < printJob.contData.sendDataSize){

    3274. 

  3274. 			retStatus = SendCommand(printJob.contData.sendData, 

    3275. 

  3275. 									printJob.contData.sendDataSize, &retBufSize, TRUE);

    3276. 

  3276. 		} else{

    3277. 

  3277. 			retStatus = EPS_ERR_INVALID_CALL;

    3278. 

  3278. 		}

    3279. 

  3279. #ifdef GCOMSW_CMD_ESCPAGE

    3280. 

  3280. 	} else{

    3281. 

  3281. 		/*** ESC/Page ***/

    3282. 

  3282. 		retStatus = pageSendLeftovers();

    3283. 

  3283. 	}

    3284. 

  3284. #endif

    3285. 

  3285. 

    3286. 

  3286. 	EPS_RETURN( retStatus );

    3287. 

  3287. }

    3288. 

  3288. 

    3289. 

  3289. 

    3290. 

  3290. /*******************************************|********************************************/

    3291. 

  3291. /*                                                                                      */

    3292. 

  3292. /* Function name:   SendBlankBand()                                                     */

    3293. 

  3293. /*                                                                                      */

    3294. 

  3294. /* Arguments                                                                            */

    3295. 

  3295. /* ---------                                                                            */

    3296. 

  3296. /* Name:        Type:               Description:                                        */

    3297. 

  3297. /* nStartStep   EPS_INT32           I: Step of Start Page comannds                      */

    3298. 

  3298. /*                                                                                      */

    3299. 

  3299. /* Return value:                                                                        */

    3300. 

  3300. /*      << Normal >>                                                                    */

    3301. 

  3301. /*      EPS_ERR_NONE                    - Success                                       */

    3302. 

  3302. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    3303. 

  3303. /*                                        (Do not return when Uni-Directional)          */

    3304. 

  3304. /*      << Error >>                                                                     */

    3305. 

  3305. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    3306. 

  3306. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    3307. 

  3307. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    3308. 

  3308. /*                                                                                      */

    3309. 

  3309. /* Description:                                                                         */

    3310. 

  3310. /*      send leftovers data.                                                            */

    3311. 

  3311. /*                                                                                      */

    3312. 

  3312. /*******************************************|********************************************/

    3313. 

  3313. static EPS_ERR_CODE    SendBlankBand (

    3314. 

  3314. 

    3315. 

  3315. 			void 

    3316. 

  3316. 

    3317. 

  3317. ){

    3318. 

  3318. 	EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls      */

    3319. 

  3319. 	EPS_UINT8		pix[3*16]; /* 16=ESC/Page24 minimum unit */

    3320. 

  3320. 	EPS_IMAGE       line;

    3321. 

  3321. 

    3322. 

  3322. 	EPS_LOG_FUNCIN;

    3323. 

  3323. 

    3324. 

  3324. #ifdef GCOMSW_CMD_ESCPAGE_S

    3325. 

  3325. 	if(EPS_LANG_ESCPAGE_S == printJob.printer->language){

    3326. 

  3326. 		EPS_RETURN( EPS_ERR_NONE );

    3327. 

  3327. 	}

    3328. 

  3328. #endif

    3329. 

  3329. 

    3330. 

  3330. 	if(EPS_CP_FULLCOLOR == printJob.attr.colorPlane){

    3331. 

  3331. 		memset(pix, 0xFF, sizeof(pix));	/* white */

    3332. 

  3332. 		if(EPS_LANG_ESCPAGE == printJob.printer->language ||

    3333. 

  3333. 		   EPS_LANG_ESCPAGE_COLOR == printJob.printer->language)

    3334. 

  3334. 		{

    3335. 

  3335. 			memset(pix, 0x00, 3);		/* black dot */

    3336. 

  3336. 		}

    3337. 

  3337. 	} else{

    3338. 

  3338. 		memset(pix, printJob.whiteColorValue, sizeof(pix));

    3339. 

  3339. 		if(EPS_LANG_ESCPAGE == printJob.printer->language ||

    3340. 

  3340. 		   EPS_LANG_ESCPAGE_COLOR == printJob.printer->language)

    3341. 

  3341. 		{

    3342. 

  3342. 			if(printJob.whiteColorValue != 0){

    3343. 

  3343. 				memset(pix, 0, sizeof(pix));

    3344. 

  3344. 			} else{

    3345. 

  3345. 				memset(pix, 1, sizeof(pix));

    3346. 

  3346. 			}

    3347. 

  3347. 		}

    3348. 

  3348. 	}

    3349. 

  3349. 	line.data          = pix;

    3350. 

  3350. 	line.bytesPerLine  = printJob.bpp;

    3351. 

  3351. 	line.rect.top      = 0;

    3352. 

  3352. 	line.rect.left     = 0;

    3353. 

  3353. 	line.rect.bottom   = 1;

    3354. 

  3354. 	if(EPS_LANG_ESCPR == printJob.printer->language || 

    3355. 

  3355. 		EPS_CP_256COLOR == printJob.attr.colorPlane ){

    3356. 

  3356. 		line.rect.right= 1;

    3357. 

  3357. 	} else{

    3358. 

  3358. 		line.rect.right= 16;

    3359. 

  3359. 	}

    3360. 

  3360. 	

    3361. 

  3361. 	retStatus = PrintLine(&line);

    3362. 

  3362. 

    3363. 

  3363. 	EPS_RETURN( retStatus );

    3364. 

  3364. }

    3365. 

  3365. 

    3366. 

  3366. /*******************************************|********************************************/

    3367. 

  3367. /*                                                                                      */

    3368. 

  3368. /* Function name:     SetupJobAttrib()                                                  */

    3369. 

  3369. /*                                                                                      */

    3370. 

  3370. /* Arguments                                                                            */

    3371. 

  3371. /* ---------                                                                            */

    3372. 

  3372. /* Name:        Type:               Description:                                        */

    3373. 

  3373. /* jobAttr      EPS_JOB_ATTRIB*     I: Data structure containing job attribut settings  */

    3374. 

  3374. /*                                                                                      */

    3375. 

  3375. /* Return value:                                                                        */

    3376. 

  3376. /*      << Normal >>                                                                    */

    3377. 

  3377. /*      EPS_ERR_NONE                            - Success                               */

    3378. 

  3378. /*      << Error >>                                                                     */

    3379. 

  3379. /*      EPS_ERR_INV_COLOR_PLANE                 - Invalid Color Plane                   */

    3380. 

  3380. /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */

    3381. 

  3381. /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */

    3382. 

  3382. /*      EPS_ERR_INV_MEDIA_SIZE                  - Invalid Media Size                    */

    3383. 

  3383. /*      EPS_ERR_INV_MEDIA_TYPE                  - Invalid Media Type                    */

    3384. 

  3384. /*      EPS_ERR_INV_BORDER_MODE                 - Invalid Border Mode                   */

    3385. 

  3385. /*      EPS_ERR_INV_PRINT_QUALITY               - Invalid Print Quality                 */

    3386. 

  3386. /*      EPS_ERR_INV_PAPER_SOURCE                - Invalid Paper source                  */

    3387. 

  3387. /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */

    3388. 

  3388. /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */

    3389. 

  3389. /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */

    3390. 

  3390. /*      EPS_ERR_INV_BRIGHTNESS                  - Invalid Brightness                    */

    3391. 

  3391. /*      EPS_ERR_INV_CONTRAST                    - Invalid Contrast                      */

    3392. 

  3392. /*      EPS_ERR_INV_SATURATION                  - Invalid Saturation                    */

    3393. 

  3393. /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */

    3394. 

  3394. /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */

    3395. 

  3395. /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */

    3396. 

  3396. /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Redeye                    */

    3397. 

  3397. /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */

    3398. 

  3398. /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */

    3399. 

  3399. /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */

    3400. 

  3400. /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */

    3401. 

  3401. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */

    3402. 

  3402. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */

    3403. 

  3403. /*                                                                                      */

    3404. 

  3404. /* Description:                                                                         */

    3405. 

  3405. /*      Confirm ESC/P-R Job Attribute.                                                  */

    3406. 

  3406. /*                                                                                      */

    3407. 

  3407. /*******************************************|********************************************/

    3408. 

  3408. EPS_ERR_CODE    SetupJobAttrib (

    3409. 

  3409. 

    3410. 

  3410.         const EPS_JOB_ATTRIB*     jobAttr    /* Print Attributes for this Page         */

    3411. 

  3411. 

    3412. 

  3412. ){

    3413. 

  3413. 	EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls      */

    3414. 

  3414. 

    3415. 

  3415. EPS_LOG_FUNCIN;

    3416. 

  3416. 

    3417. 

  3417. 

    3418. 

  3418. 

    3419. 

  3419. /*** Validate input parameters                                                          */

    3420. 

  3420. #ifndef LCOMSW_JOBPARAM_CEHCK_OFF

    3421. 

  3421. /*======================================================================================*/

    3422. 

  3422. /*** Validate/Confirm Page Attribute Data                                               */

    3423. 

  3423. /*======================================================================================*/

    3424. 

  3424. 	/*** Color Plane                                                                    */

    3425. 

  3425. 	

    3426. 

  3426. 	if (! (   (jobAttr->colorPlane         == EPS_CP_FULLCOLOR         ) ||

    3427. 

  3427. 			  (jobAttr->colorPlane         == EPS_CP_256COLOR          ) ||

    3428. 

  3428. 			  (jobAttr->colorPlane         == EPS_CP_JPEG              ) ||

    3429. 

  3429. 			  (jobAttr->colorPlane         == EPS_CP_PRINTCMD          ) ) ){

    3430. 

  3430. 		EPS_RETURN( EPS_ERR_INV_COLOR_PLANE )

    3431. 

  3431. 	}

    3432. 

  3432. 

    3433. 

  3433. 	if( EPS_CP_PRINTCMD == jobAttr->colorPlane ){		/* Print command */

    3434. 

  3434. 		/*** Structure version                                                          */

    3435. 

  3435. 		if(EPS_JOB_ATTRIB_VER_2 > jobAttr->version){

    3436. 

  3436. 			EPS_RETURN( EPS_ERR_INVALID_VERSION )

    3437. 

  3437. 		}

    3438. 

  3438. 

    3439. 

  3439. 		/*** Print command type                                                         */

    3440. 

  3440. 		if (! (   (jobAttr->cmdType       == EPS_MNT_CUSTOM           ) ||

    3441. 

  3441. 				  (jobAttr->cmdType       == EPS_MNT_CLEANING         ) ||

    3442. 

  3442. 				  (jobAttr->cmdType       == EPS_MNT_NOZZLE           )    ) ){

    3443. 

  3443. 			EPS_RETURN( EPS_ERR_INV_CMDTYPE )

    3444. 

  3444. 		}

    3445. 

  3445. 

    3446. 

  3446. 	} else{												/* Image(RGB, Jpeg) */

    3447. 

  3447. 		/*** Media Size                                                                     */

    3448. 

  3448. 		if (! ( ( (jobAttr->mediaSizeIdx       >= EPS_MSID_A4              ) &&

    3449. 

  3449. 				  (jobAttr->mediaSizeIdx       <= EPS_MSID_HIVISION        )    ) ||

    3450. 

  3450. 				( (jobAttr->mediaSizeIdx       >= EPS_MSID_A3NOBI          ) &&

    3451. 

  3451. 				  (jobAttr->mediaSizeIdx       <= EPS_MSID_12X12           )    ) ||

    3452. 

  3452. 	 			( (jobAttr->mediaSizeIdx       == EPS_MSID_USER            )    )    ) ){

    3453. 

  3453. 			EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE )

    3454. 

  3454. 		}

    3455. 

  3455. 		/*** Media Type                                                                     */

    3456. 

  3456. 		if (! ( ( (jobAttr->mediaTypeIdx       >= EPS_MTID_PLAIN           ) &&

    3457. 

  3457. 	/*              (jobAttr->mediaTypeIdx       <= EPS_MTID_GLOSSYHAGAKI    )    ) ||*/

    3458. 

  3458. 				  (jobAttr->mediaTypeIdx       <= EPS_MTID_BUSINESSCOAT    )    ) ||

    3459. 

  3459. 				( (jobAttr->mediaTypeIdx       >= EPS_MTID_CDDVD           ) &&

    3460. 

  3460. 				  (jobAttr->mediaTypeIdx       <= EPS_MTID_CDDVDGLOSSY     )    ) ||

    3461. 

  3461. 				( (jobAttr->mediaTypeIdx       == EPS_MTID_CLEANING        )    )    ) ){

    3462. 

  3462. 			EPS_RETURN( EPS_ERR_INV_MEDIA_TYPE )

    3463. 

  3463. 		}

    3464. 

  3464. 		/*** Print Quality                                                                  */

    3465. 

  3465. 		if (! (   (jobAttr->printQuality       == EPS_MQID_DRAFT           ) ||

    3466. 

  3466. 				  (jobAttr->printQuality       == EPS_MQID_NORMAL          ) ||

    3467. 

  3467. 				  (jobAttr->printQuality       == EPS_MQID_HIGH            )    ) ){

    3468. 

  3468. 			EPS_RETURN( EPS_ERR_INV_PRINT_QUALITY )

    3469. 

  3469. 		}

    3470. 

  3470. 		/*** duplex                                                                         */

    3471. 

  3471. 		if( !( (jobAttr->duplex             == EPS_DUPLEX_NONE             ) ||

    3472. 

  3472. 			   (jobAttr->duplex             == EPS_DUPLEX_LONG             ) ||

    3473. 

  3473. 			   (jobAttr->duplex		        == EPS_DUPLEX_SHORT            ) ) ){

    3474. 

  3474. 			EPS_RETURN( EPS_ERR_INV_DUPLEX )

    3475. 

  3475. 		}

    3476. 

  3476. 		/*** Brightness                                                                     */

    3477. 

  3477. 		if (! (   (jobAttr->brightness         >= -50                      ) &&

    3478. 

  3478. 				  (jobAttr->brightness         <=  50                      )    ) ){

    3479. 

  3479. 			EPS_RETURN( EPS_ERR_INV_BRIGHTNESS )

    3480. 

  3480. 		}

    3481. 

  3481. 		/*** Contrast                                                                       */

    3482. 

  3482. 		if (! (   (jobAttr->contrast           >= -50                      ) &&

    3483. 

  3483. 				  (jobAttr->contrast           <=  50                      )    ) ){

    3484. 

  3484. 			EPS_RETURN( EPS_ERR_INV_CONTRAST )

    3485. 

  3485. 		}

    3486. 

  3486. 		/*** Saturation                                                                     */

    3487. 

  3487. 		if (! (   (jobAttr->saturation         >= -50                      ) &&

    3488. 

  3488. 				  (jobAttr->saturation         <=  50                      )    ) ){

    3489. 

  3489. 			EPS_RETURN( EPS_ERR_INV_SATURATION )

    3490. 

  3490. 		}

    3491. 

  3491. 		/*** Paper Source                                                                   */

    3492. 

  3492. 		if (! (   (jobAttr->paperSource        == EPS_MPID_AUTO			   ) ||

    3493. 

  3493. 				  (jobAttr->paperSource        == EPS_MPID_REAR            ) ||

    3494. 

  3494. 				  (jobAttr->paperSource        == EPS_MPID_FRONT1          ) ||

    3495. 

  3495. 				  (jobAttr->paperSource        == EPS_MPID_FRONT2          ) ||

    3496. 

  3496. 				  (jobAttr->paperSource        == EPS_MPID_FRONT3          ) ||

    3497. 

  3497. 				  (jobAttr->paperSource        == EPS_MPID_FRONT4          ) ||

    3498. 

  3498. 				  (jobAttr->paperSource        == EPS_MPID_CDTRAY          ) ||

    3499. 

  3499. 				  

    3500. 

  3500. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_MP_TRAY		) ||

    3501. 

  3501. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE1		) ||

    3502. 

  3502. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE2		) ||

    3503. 

  3503. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE3		) ||

    3504. 

  3504. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_CASSETTE4		) ||

    3505. 

  3505. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_PARAM_MANUALFEED	) ||

    3506. 

  3506. 				  (jobAttr->paperSource        == EPS_MPID_PAGE_S_AUTO_TRAY		)

    3507. 

  3507. 				     ) ){

    3508. 

  3508. 			EPS_RETURN( EPS_ERR_INV_PAPER_SOURCE )

    3509. 

  3509. 		}

    3510. 

  3510. 

    3511. 

  3511. 		if(jobAttr->printLayout == EPS_MLID_CDLABEL){

    3512. 

  3512. 			/*** CD Inside Diameter                                                     */

    3513. 

  3513. 			if( !( (jobAttr->cdDimIn >= EPS_CDDIM_IN_MIN   )

    3514. 

  3514. 				&& (jobAttr->cdDimIn <= EPS_CDDIM_IN_MAX ) ) ){

    3515. 

  3515. 				EPS_RETURN( EPS_ERR_INV_CD_INDIM )

    3516. 

  3516. 			}

    3517. 

  3517. 			/*** CD Outside Diameter                                                    */

    3518. 

  3518. 			if( !( (jobAttr->cdDimOut >= EPS_CDDIM_OUT_MIN   )

    3519. 

  3519. 				&& (jobAttr->cdDimOut <= EPS_CDDIM_OUT_MAX ) ) ){

    3520. 

  3520. 				EPS_RETURN( EPS_ERR_INV_CD_OUTDIM )

    3521. 

  3521. 			}

    3522. 

  3522. 		}

    3523. 

  3523. 

    3524. 

  3524. 		if( EPS_CP_JPEG == jobAttr->colorPlane ){

    3525. 

  3525. 			if( jobAttr->duplex != EPS_DUPLEX_NONE ){

    3526. 

  3526. 				EPS_RETURN( EPS_ERR_INV_DUPLEX )

    3527. 

  3527. 			}

    3528. 

  3528. 		}

    3529. 

  3529. 	}

    3530. 

  3530. #endif

    3531. 

  3531. 

    3532. 

  3532. 

    3533. 

  3533. 

    3534. 

  3534. /*======================================================================================*/

    3535. 

  3535. /*** Copy Input Page Attribute Data to Internal Variable                                */

    3536. 

  3536. /*======================================================================================*/

    3537. 

  3537. 	switch( jobAttr->colorPlane ){

    3538. 

  3538. 	case EPS_CP_FULLCOLOR:			/* RGB */

    3539. 

  3539. 	case EPS_CP_256COLOR:

    3540. 

  3540. 	    memcpy((void*)(&printJob.attr), (void*)jobAttr, sizeof(EPS_JOB_ATTRIB));

    3541. 

  3541. 		retStatus = SetupRGBAttrib();

    3542. 

  3542. 		if(EPS_ERR_NONE == retStatus){

    3543. 

  3543. 			_SP_ChangeSpec_DraftOnly(printJob.printer, &printJob.attr);   

    3544. 

  3544. 			/* Ignore the return value of this func */

    3545. 

  3545. 		}

    3546. 

  3546. 		break;

    3547. 

  3547. 

    3548. 

  3548. 	case EPS_CP_JPEG:				/* Jpeg */

    3549. 

  3549. 	    memcpy((void*)(&printJob.attr), (void*)jobAttr, sizeof(EPS_JOB_ATTRIB));

    3550. 

  3550. 		retStatus = SetupJPGAttrib();

    3551. 

  3551. 		if(EPS_ERR_NONE == retStatus){

    3552. 

  3552. 			_SP_ChangeSpec_DraftOnly(printJob.printer, &printJob.attr);   

    3553. 

  3553. 			/* Ignore the return value of this func */

    3554. 

  3554. 		}

    3555. 

  3555. 		break;

    3556. 

  3556. 

    3557. 

  3557. 	case EPS_CP_PRINTCMD:			/* Print command */

    3558. 

  3558. 	default:

    3559. 

  3559. 	    memset((void*)(&printJob.attr), 0, sizeof(EPS_JOB_ATTRIB));

    3560. 

  3560. 		printJob.attr.colorPlane = jobAttr->colorPlane;

    3561. 

  3561. 		printJob.attr.cmdType = jobAttr->cmdType;

    3562. 

  3562. 		break;

    3563. 

  3563. 

    3564. 

  3564. 	}

    3565. 

  3565. 

    3566. 

  3566. 	EPS_RETURN( retStatus )

    3567. 

  3567. }

    3568. 

  3568. 

    3569. 

  3569. 

    3570. 

  3570. /*******************************************|********************************************/

    3571. 

  3571. /*                                                                                      */

    3572. 

  3572. /* Function name:     SetupRGBAttrib()                                                  */

    3573. 

  3573. /*                                                                                      */

    3574. 

  3574. /* Arguments                                                                            */

    3575. 

  3575. /* ---------                                                                            */

    3576. 

  3576. /* Name:        Type:               Description:                                        */

    3577. 

  3577. /* jobAttr      EPS_JOB_ATTRIB*     I: Data structure containing page attribut settings */

    3578. 

  3578. /*                                                                                      */

    3579. 

  3579. /* Return value:                                                                        */

    3580. 

  3580. /*      << Normal >>                                                                    */

    3581. 

  3581. /*      EPS_ERR_NONE                            - Success                               */

    3582. 

  3582. /*      << Error >>                                                                     */

    3583. 

  3583. /*      EPS_ERR_INV_COLOR_MODE                  - Invalid Color Mode                    */

    3584. 

  3584. /*      EPS_ERR_INV_INPUT_RESOLUTION            - Invalid Input Resolution              */

    3585. 

  3585. /*      EPS_ERR_INV_PRINT_DIRECTION             - Invalid Print Direction               */

    3586. 

  3586. /*      EPS_ERR_INV_PALETTE_SIZE                - Invalid Palette Size                  */

    3587. 

  3587. /*      EPS_ERR_INV_PALETTE_DATA                - Invalid Palette Data                  */

    3588. 

  3588. /*      EPS_ERR_INV_TOP_MARGIN                  - Invalid Top Magirn                    */

    3589. 

  3589. /*      EPS_ERR_INV_LEFT_MARGIN                 - Invalid Left Margin                   */

    3590. 

  3590. /*      EPS_ERR_INV_BOTTOM_MARGIN               - Invalid Bottom Margin                 */

    3591. 

  3591. /*      EPS_ERR_INV_RIGHT_MARGIN                - Invalid Right Margin                  */

    3592. 

  3592. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH     - Invalid Magin Setting (Width)         */

    3593. 

  3593. /*      EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT    - Invalid Magin Setting (Height)        */

    3594. 

  3594. /*                                                                                      */

    3595. 

  3595. /* Description:                                                                         */

    3596. 

  3596. /*      Confirm RGB Attribute.                                                          */

    3597. 

  3597. /*                                                                                      */

    3598. 

  3598. /*******************************************|********************************************/

    3599. 

  3599. EPS_ERR_CODE    SetupRGBAttrib (

    3600. 

  3600. 

    3601. 

  3601. 		void

    3602. 

  3602. 

    3603. 

  3603. ){

    3604. 

  3604. /*** Declare Variable Local to Routine                                                  */

    3605. 

  3605. EPS_INT32       factor;                     /* Scaling factor for dpi                   */

    3606. 

  3606. EPS_INT32       idx;                        /* Paper size index                         */

    3607. 

  3607. EPS_INT32       tempPrintableWidth;         /* Temporary Variable                       */

    3608. 

  3608. EPS_INT32       tempPrintableHeight;        /* Temporary Variable                       */

    3609. 

  3609. const EPS_MEDIA_INFO* pMI = NULL;

    3610. 

  3610. EPS_INT16		borderPixels;

    3611. 

  3611. 

    3612. 

  3612. 	EPS_LOG_FUNCIN;

    3613. 

  3613. 

    3614. 

  3614. /*** Initialize Global/Local Variables                                                  */

    3615. 

  3615.     idx                 = -1;

    3616. 

  3616.     tempPrintableWidth  = 0;

    3617. 

  3617.     tempPrintableHeight = 0;

    3618. 

  3618. 

    3619. 

  3619. #ifndef LCOMSW_JOBPARAM_CEHCK_OFF

    3620. 

  3620. /*** Validate input parameters                                                          */

    3621. 

  3621. 	/*** Border Mode                                                                    */

    3622. 

  3622. 	if(! ((printJob.attr.printLayout == EPS_MLID_BORDERLESS      ) ||

    3623. 

  3623. 		  (printJob.attr.printLayout == EPS_MLID_BORDERS         ) ||

    3624. 

  3624. 		  (printJob.attr.printLayout == EPS_MLID_CDLABEL         ) ||

    3625. 

  3625. 		  (printJob.attr.printLayout == EPS_MLID_DIVIDE16        ) ||

    3626. 

  3626. 		  (printJob.attr.printLayout == EPS_MLID_CUSTOM          ) ) ){

    3627. 

  3627. 		EPS_RETURN( EPS_ERR_INV_BORDER_MODE )

    3628. 

  3628. 	}

    3629. 

  3629. 	/*** Color Mode                                                                 */

    3630. 

  3630.     if( !( (printJob.attr.colorMode          == EPS_CM_COLOR             ) ||

    3631. 

  3631.            (printJob.attr.colorMode          == EPS_CM_MONOCHROME        ) /*||

    3632. 

  3632.            (printJob.attr.colorMode          == EPS_CM_SEPIA             )*/ ) ){

    3633. 

  3633. 		EPS_RETURN( EPS_ERR_INV_COLOR_MODE )

    3634. 

  3634. 	}

    3635. 

  3635. 

    3636. 

  3636. 	/*** Input Image Resolution                                                     */

    3637. 

  3637.     /*** Select table and factor                                                        */

    3638. 

  3638. 	if(printJob.attr.inputResolution == EPS_IR_360X360){

    3639. 

  3639. 		pMI = epsMediaSize;

    3640. 

  3640. 	    factor = 1;

    3641. 

  3641. 		borderPixels = EPS_BORDERS_MARGIN_360;

    3642. 

  3642. 	} else if(printJob.attr.inputResolution == EPS_IR_720X720){

    3643. 

  3643. 		pMI = epsMediaSize;

    3644. 

  3644. 		factor = 2;

    3645. 

  3645. 		borderPixels = EPS_BORDERS_MARGIN_360;

    3646. 

  3646. 	} else if(printJob.attr.inputResolution == EPS_IR_300X300){

    3647. 

  3647. 		pMI = epsMediaSize300;

    3648. 

  3648. 		//pMI = epsMediaSize;

    3649. 

  3649. 		factor = 1;

    3650. 

  3650. 		borderPixels = EPS_BORDERS_MARGIN_300;

    3651. 

  3651. 		//borderPixels = EPS_BORDERS_MARGIN_360;

    3652. 

  3652. 	} else if(printJob.attr.inputResolution == EPS_IR_600X600){

    3653. 

  3653. 		pMI = epsMediaSize300;

    3654. 

  3654. 	    factor = 2;

    3655. 

  3655. 		borderPixels = EPS_BORDERS_MARGIN_300;

    3656. 

  3656. 	} else{

    3657. 

  3657.         EPS_RETURN( EPS_ERR_INV_INPUT_RESOLUTION )

    3658. 

  3658. 	}

    3659. 

  3659. 

    3660. 

  3660. 	/*** Printing Direction                                                         */

    3661. 

  3661.     if (! (   (printJob.attr.printDirection     == EPS_PD_BIDIREC           ) ||

    3662. 

  3662. 	  	      (printJob.attr.printDirection     == EPS_PD_UNIDIREC          )    ) ){

    3663. 

  3663. 		EPS_RETURN( EPS_ERR_INV_PRINT_DIRECTION )

    3664. 

  3664. 	}

    3665. 

  3665. 

    3666. 

  3666. 	/*** Pallette Data                                                              */

    3667. 

  3667. 	if (printJob.attr.colorPlane == EPS_CP_256COLOR) {

    3668. 

  3668. 		if (! ((printJob.attr.paletteSize       >= 3                        ) &&

    3669. 

  3669. 			   (printJob.attr.paletteSize       <= 768/*765*/               )    ) ){

    3670. 

  3670. 			EPS_RETURN( EPS_ERR_INV_PALETTE_SIZE )

    3671. 

  3671. 		}

    3672. 

  3672. 

    3673. 

  3673. 		if (    printJob.attr.paletteData       == NULL                     ){

    3674. 

  3674. 			EPS_RETURN( EPS_ERR_INV_PALETTE_DATA )

    3675. 

  3675. 		}

    3676. 

  3676. 	}

    3677. 

  3677. 

    3678. 

  3678.     /*** Margin                                                                     */

    3679. 

  3679. 	if (printJob.attr.printLayout == EPS_MLID_CUSTOM) {

    3680. 

  3680. 		if (printJob.attr.topMargin    < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_TOP_MARGIN );

    3681. 

  3681. 		if (printJob.attr.leftMargin   < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_LEFT_MARGIN );

    3682. 

  3682. 		if (printJob.attr.bottomMargin < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_BOTTOM_MARGIN );

    3683. 

  3683. 		if (printJob.attr.rightMargin  < borderPixels*factor) EPS_RETURN( EPS_ERR_INV_RIGHT_MARGIN );

    3684. 

  3684. 	}

    3685. 

  3685. #endif

    3686. 

  3686. 

    3687. 

  3687. /*======================================================================================*/

    3688. 

  3688. /*** Set the following parameter                                                        */

    3689. 

  3689. /***    - printJob.topMargin                                                            */

    3690. 

  3690. /***    - printJob.leftMargin                                                           */

    3691. 

  3691. /***    - printJob.printableAreaWidth                                                   */

    3692. 

  3692. /***    - printJob.printableAreaHeight                                                  */

    3693. 

  3693. /***    - printJob.borderlessModeInternal                                               */

    3694. 

  3694. /***    - printJob.verticalOffset                                                       */

    3695. 

  3695. /*======================================================================================*/

    3696. 

  3696.     /*** Find the Media by ID                                                           */

    3697. 

  3697.     for (idx = 0; pMI[idx].id != -1; idx++) {

    3698. 

  3698.         if (pMI[idx].id == printJob.attr.mediaSizeIdx)

    3699. 

  3699.             break;

    3700. 

  3700.     }

    3701. 

  3701.     if (pMI[idx].id == -1) {

    3702. 

  3702.         EPS_RETURN( EPS_ERR_INV_MEDIA_SIZE );

    3703. 

  3703.     }

    3704. 

  3704. 

    3705. 

  3705.     /*** Media Attributes                                                               */

    3706. 

  3706.     printJob.paperWidth  = pMI[idx].paper_x * factor;

    3707. 

  3707.     printJob.paperHeight = pMI[idx].paper_y * factor;

    3708. 

  3708. 

    3709. 

  3709.     /*** Initialize Printable based on border mode                                      */

    3710. 

  3710.     switch( printJob.attr.printLayout ){

    3711. 

  3711. 	case EPS_MLID_BORDERLESS:

    3712. 

  3712.         printJob.topMargin      = pMI[idx].top_margin_borderless   * factor;

    3713. 

  3713.         printJob.leftMargin     = pMI[idx].left_margin_borderless  * factor;

    3714. 

  3714.         tempPrintableWidth      = pMI[idx].print_area_x_borderless * factor;

    3715. 

  3715.         tempPrintableHeight     = pMI[idx].print_area_y_borderless * factor;

    3716. 

  3716.         printJob.borderlessMode = EPS_BORDERLESS_NORMAL;

    3717. 

  3717. 		break;

    3718. 

  3718. 

    3719. 

  3719. 	case EPS_MLID_BORDERS:

    3720. 

  3720. 	case EPS_MLID_DIVIDE16:  

    3721. 

  3721. 		  printJob.topMargin      = borderPixels * factor;

    3722. 

  3722.         printJob.leftMargin     = borderPixels * factor;

    3723. 

  3723. 

    3724. 

  3724.         tempPrintableWidth      = pMI[idx].print_area_x_border * factor;

    3725. 

  3725.         tempPrintableHeight     = pMI[idx].print_area_y_border * factor;

    3726. 

  3726.         printJob.borderlessMode = EPS_BORDER_3MM_MARGINE;

    3727. 

  3727. 		break;

    3728. 

  3728. 

    3729. 

  3729. 	case EPS_MLID_CDLABEL:

    3730. 

  3730. 		tempPrintableWidth  =

    3731. 

  3731. 		tempPrintableHeight = elGetDots(printJob.attr.inputResolution, printJob.attr.cdDimOut);

    3732. 

  3732. 		printJob.topMargin  = CDDVD_OFFSET_Y(printJob.attr.inputResolution, printJob.attr.cdDimOut);

    3733. 

  3733. 		printJob.leftMargin = CDDVD_OFFSET_X(printJob.attr.inputResolution, printJob.attr.cdDimOut);

    3734. 

  3734.         printJob.borderlessMode = EPS_BORDER_3MM_MARGINE; /* It's no meaning & no effect */

    3735. 

  3735. 

    3736. 

  3736. 		EPS_DBGPRINT(("dim: %d / top: %d / left: %d\n", printJob.attr.cdDimOut,

    3737. 

  3737. 						printJob.topMargin, printJob.leftMargin));

    3738. 

  3738. 		break;

    3739. 

  3739. 

    3740. 

  3740. 	default: /* printJob.attr.printLayout  == EPS_MLID_CUSTOM */

    3741. 

  3741.         printJob.topMargin      = printJob.attr.topMargin;

    3742. 

  3742.         printJob.leftMargin     = printJob.attr.leftMargin;

    3743. 

  3743.         tempPrintableWidth      = pMI[idx].paper_x * factor		-

    3744. 

  3744.                                   printJob.attr.leftMargin      -

    3745. 

  3745.                                   printJob.attr.rightMargin;

    3746. 

  3746.         tempPrintableHeight     = pMI[idx].paper_y * factor		-

    3747. 

  3747.                                   printJob.attr.topMargin       -

    3748. 

  3748.                                   printJob.attr.bottomMargin;

    3749. 

  3749. 		printJob.borderlessMode = EPS_BORDER_CUSTOM;

    3750. 

  3750.     }

    3751. 

  3751. 

    3752. 

  3752.     /*** Validate/Confirm Magin Setting                                                 */

    3753. 

  3753.     if (printJob.attr.printLayout == EPS_MLID_CUSTOM) {

    3754. 

  3754.         if (tempPrintableWidth  <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_WIDTH );

    3755. 

  3755.         if (tempPrintableHeight <= 0) EPS_RETURN( EPS_ERR_MARGIN_OVER_PRINTABLE_HEIGHT );

    3756. 

  3756.     }

    3757. 

  3757. 

    3758. 

  3758.     /*** Set Printable Area */

    3759. 

  3759.    EPS_INT32 lOffset = printJob.attr.inputResolution/30;

    3760. 

  3760.     //printJob.printableAreaHeight  = (EPS_UINT32)lWidth + lOffset*2;

    3761. 

  3761.     //printJob.printableAreaWidth = (EPS_UINT32)lHeight + lOffset*2;

    3762. 

  3762.     

    3763. 

  3763.     printJob.printableAreaWidth  = (EPS_UINT32)tempPrintableWidth;

    3764. 

  3764.     printJob.printableAreaHeight = (EPS_UINT32)tempPrintableHeight;

    3765. 

  3765.     //printJob.printableAreaWidth  = (EPS_UINT32)tempPrintableHeight;

    3766. 

  3766.     //printJob.printableAreaHeight = (EPS_UINT32)tempPrintableWidth;

    3767. 

  3767.     /*

    3768. 

  3768.     areaWidth = tempPrintableHeight;

    3769. 

  3769. 	 areaHeight = tempPrintableWidth;

    3770. 

  3770.     EPS_INT32 lOffset = printJob.attr.inputResolution/30;

    3771. 

  3771.     printJob.printableAreaHeight  = (EPS_UINT32)lHeight + lOffset*2;

    3772. 

  3772.     printJob.printableAreaWidth = (EPS_UINT32)lWidth + lOffset*2;

    3773. 

  3773.     */

    3774. 

  3774.     //printJob.printableAreaHeight  = (EPS_UINT32)lHeight + lOffset*2;

    3775. 

  3775.     //printJob.printableAreaWidth = (EPS_UINT32)lWidth + lOffset*2;

    3776. 

  3776. 

    3777. 

  3777. 

    3778. 

  3778.     /*** Scan through palette for the index value of white and set the global white

    3779. 

  3779.                                     value to this index for skipping white raster lines */

    3780. 

  3780.     if( printJob.attr.colorPlane == EPS_CP_256COLOR ){ 

    3781. 

  3781. 	    printJob.bpp = 1;

    3782. 

  3782. 	} else /* if(EPS_CP_FULLCOLOR) */{

    3783. 

  3783.         printJob.bpp = 3;

    3784. 

  3784. 		printJob.attr.paletteSize = 0;

    3785. 

  3785. 		printJob.attr.paletteData = NULL;

    3786. 

  3786. 	}

    3787. 

  3787. 	printJob.whiteColorValue = memSearchWhiteColorVal(printJob.attr.colorPlane, 

    3788. 

  3788. 													printJob.attr.paletteData,

    3789. 

  3789. 													printJob.attr.paletteSize);

    3790. 

  3790. 

    3791. 

  3791.     /*** Set "Base Point" Data                                                          */

    3792. 

  3792.     /*** BORDER                                                                         */

    3793. 

  3793.     printJob.border.top        =

    3794. 

  3794.     printJob.border.left       =

    3795. 

  3795.     printJob.border.bottom     =

    3796. 

  3796. 	printJob.border.right      = borderPixels * factor;

    3797. 

  3797. 

    3798. 

  3798.     AdjustBasePoint();

    3799. 

  3799. 

    3800. 

  3800. 	EPS_RETURN( EPS_ERR_NONE );

    3801. 

  3801. }

    3802. 

  3802. 

    3803. 

  3803. 

    3804. 

  3804. /*******************************************|********************************************/

    3805. 

  3805. /*                                                                                      */

    3806. 

  3806. /* Function name:     SetupJPGAttrib()                                                  */

    3807. 

  3807. /*                                                                                      */

    3808. 

  3808. /* Arguments                                                                            */

    3809. 

  3809. /* ---------                                                                            */

    3810. 

  3810. /* Name:        Type:               Description:                                        */

    3811. 

  3811. /* N/A                                                                                  */

    3812. 

  3812. /*                                                                                      */

    3813. 

  3813. /* Return value:                                                                        */

    3814. 

  3814. /*      << Normal >>                                                                    */

    3815. 

  3815. /*      EPS_ERR_NONE                            - Success                               */

    3816. 

  3816. /*      << Error >>                                                                     */

    3817. 

  3817. /*      EPS_ERR_INV_APF_FLT                     - Invalid APF Filter                    */

    3818. 

  3818. /*      EPS_ERR_INV_APF_ACT                     - Invalid APF Scene                     */

    3819. 

  3819. /*      EPS_ERR_INV_APF_SHP                     - Invalid APF Sharpness                 */

    3820. 

  3820. /*      EPS_ERR_INV_APF_RDE                     - Invalid APF Redeye                    */

    3821. 

  3821. /*                                                                                      */

    3822. 

  3822. /* Description:                                                                         */

    3823. 

  3823. /*      Confirm APF Attribute.                                                          */

    3824. 

  3824. /*                                                                                      */

    3825. 

  3825. /*******************************************|********************************************/

    3826. 

  3826. EPS_ERR_CODE    SetupJPGAttrib (

    3827. 

  3827. 

    3828. 

  3828.         void

    3829. 

  3829. 

    3830. 

  3830. ){

    3831. 

  3831. 	EPS_LOG_FUNCIN;

    3832. 

  3832. 

    3833. 

  3833. #ifndef LCOMSW_JOBPARAM_CEHCK_OFF

    3834. 

  3834. /*** Validate input parameters                                                          */

    3835. 

  3835. 	/*** Border Mode                                                                    */

    3836. 

  3836. 	if(! ((printJob.attr.printLayout == EPS_MLID_BORDERLESS      ) ||

    3837. 

  3837. 		  (printJob.attr.printLayout == EPS_MLID_BORDERS         ) ||

    3838. 

  3838. 		  (printJob.attr.printLayout == EPS_MLID_CDLABEL         ) ||

    3839. 

  3839. 		  (printJob.attr.printLayout == EPS_MLID_DIVIDE16        ) /*||

    3840. 

  3840. 		  (printJob.attr.printLayout == EPS_MLID_CUSTOM          ) */) ){

    3841. 

  3841. 		EPS_RETURN( EPS_ERR_INV_BORDER_MODE )

    3842. 

  3842. 	}

    3843. 

  3843. 	/*** Color Mode (APF Filter)                                                        */

    3844. 

  3844.     if( !( (printJob.attr.colorMode      == EPS_CM_COLOR             ) ||

    3845. 

  3845.            (printJob.attr.colorMode      == EPS_CM_MONOCHROME        ) ||

    3846. 

  3846.            (printJob.attr.colorMode      == EPS_CM_SEPIA             ) ) ){

    3847. 

  3847. 		EPS_RETURN( EPS_ERR_INV_COLOR_MODE )

    3848. 

  3848. 	}

    3849. 

  3849. 

    3850. 

  3850. 	/*** APF Scene                                                                      */

    3851. 

  3851. 	if( !( (printJob.attr.apfAutoCorrect == EPS_APF_ACT_NOTHING  ) ||

    3852. 

  3852. 		   (printJob.attr.apfAutoCorrect == EPS_APF_ACT_STANDARD ) ||

    3853. 

  3853. 		   (printJob.attr.apfAutoCorrect == EPS_APF_ACT_PIM      ) ||

    3854. 

  3854. 		   (printJob.attr.apfAutoCorrect == EPS_APF_ACT_PORTRATE ) ||

    3855. 

  3855. 		   (printJob.attr.apfAutoCorrect == EPS_APF_ACT_VIEW     ) ||

    3856. 

  3856. 		   (printJob.attr.apfAutoCorrect == EPS_APF_ACT_NIGHTVIEW) ) ){

    3857. 

  3857. 		EPS_RETURN( EPS_ERR_INV_APF_ACT );

    3858. 

  3858. 	}

    3859. 

  3859. 	/*** APF Sharpness                                                                  */

    3860. 

  3860. 	if (! ((printJob.attr.sharpness           >= -50     ) &&

    3861. 

  3861.   		   (printJob.attr.sharpness           <=  50     ) ) ){

    3862. 

  3862. 		EPS_RETURN( EPS_ERR_INV_APF_SHP );

    3863. 

  3863. 	}

    3864. 

  3864. 	/*** APF Redeye                                                                     */

    3865. 

  3865. 	if( !( (printJob.attr.redeye         == EPS_APF_RDE_NOTHING  ) ||

    3866. 

  3866. 		   (printJob.attr.redeye         == EPS_APF_RDE_CORRECT  ) ) ){

    3867. 

  3867. 		EPS_RETURN( EPS_ERR_INV_APF_RDE );

    3868. 

  3868. 	}

    3869. 

  3869. #endif

    3870. 

  3870. 

    3871. 

  3871.     printJob.bpp = 0;

    3872. 

  3872. 	printJob.attr.paletteSize = 0;

    3873. 

  3873. 	printJob.attr.paletteData = NULL;

    3874. 

  3874. 

    3875. 

  3875. 	EPS_RETURN( EPS_ERR_NONE );

    3876. 

  3876. }

    3877. 

  3877. 

    3878. 

  3878. 

    3879. 

  3879. /*******************************************|********************************************/

    3880. 

  3880. /*                                                                                      */

    3881. 

  3881. /* Function name:   AddCmdBuff()                                                        */

    3882. 

  3882. /*                                                                                      */

    3883. 

  3883. /* Arguments                                                                            */

    3884. 

  3884. /* ---------                                                                            */

    3885. 

  3885. /* Name:			Type:               Description:                                    */

    3886. 

  3886. /* pBuff            EPS_UINT8**         IO: pointer to command buffer                   */

    3887. 

  3887. /* pPos             EPS_UINT8**         IO: pointer to append position                  */

    3888. 

  3888. /* bufSize          EPS_UINT32*         IO: pointer to size of command buffer(pBuff)    */

    3889. 

  3889. /* cmd              EPS_UINT8*          I : pointer to command                          */

    3890. 

  3890. /* cmdSize          EPS_UINT32          I : size of command(cmd)                        */

    3891. 

  3891. /*                                                                                      */

    3892. 

  3892. /* Return value:                                                                        */

    3893. 

  3893. /*      EPS_ERR_NONE                    - Success                                       */

    3894. 

  3894. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    3895. 

  3895. /*                                                                                      */

    3896. 

  3896. /* Description:                                                                         */

    3897. 

  3897. /*      Append command to buffer. If the buffer is short, expand it.                    */

    3898. 

  3898. /*                                                                                      */

    3899. 

  3899. /*******************************************|********************************************/

    3900. 

  3900. EPS_ERR_CODE AddCmdBuff(

    3901. 

  3901. 						  

    3902. 

  3902. 		EPS_UINT8 **pBuff, 

    3903. 

  3903. 		EPS_UINT8 **pPos, 

    3904. 

  3904. 		EPS_UINT32 *bufSize, 

    3905. 

  3905. 		const EPS_UINT8 *cmd,

    3906. 

  3906. 		EPS_UINT32 cmdSize

    3907. 

  3907. 		

    3908. 

  3908. ){

    3909. 

  3909. 	EPS_UINT32	cmdPosDist = (EPS_UINT32)(*pPos - *pBuff);	/* command offset distance  */

    3910. 

  3910. 

    3911. 

  3911. 	EPS_LOG_FUNCIN;

    3912. 

  3912. 

    3913. 

  3913. 	EPS_MEM_GROW(EPS_UINT8*, *pBuff, bufSize, cmdPosDist + cmdSize )

    3914. 

  3914. 

    3915. 

  3915. 	if(*pBuff != NULL){

    3916. 

  3916. 		*pPos = *pBuff + cmdPosDist;

    3917. 

  3917. 		memcpy(*pPos, cmd, cmdSize);

    3918. 

  3918. 		*pPos += cmdSize;

    3919. 

  3919. 		EPS_RETURN( EPS_ERR_NONE );

    3920. 

  3920. 	} else{

    3921. 

  3921. 		EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );

    3922. 

  3922. 	}

    3923. 

  3923. }

    3924. 

  3924. 

    3925. 

  3925. 

    3926. 

  3926. /*******************************************|********************************************/

    3927. 

  3927. /*                                                                                      */

    3928. 

  3928. /* Function name:   SendStartJob()                                                      */

    3929. 

  3929. /*                                                                                      */

    3930. 

  3930. /* Arguments                                                                            */

    3931. 

  3931. /* ---------                                                                            */

    3932. 

  3932. /* Name:			Type:               Description:                                    */

    3933. 

  3933. /* bAddStartPage    EPS_BOOL            I: Append Start Page comannd                    */

    3934. 

  3934. /*                                                                                      */

    3935. 

  3935. /* Return value:                                                                        */

    3936. 

  3936. /*      << Normal >>                                                                    */

    3937. 

  3937. /*      EPS_ERR_NONE                    - Success                                       */

    3938. 

  3938. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    3939. 

  3939. /*                                        (Do not return when Uni-Directional)          */

    3940. 

  3940. /*      << Error >>                                                                     */

    3941. 

  3941. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    3942. 

  3942. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    3943. 

  3943. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    3944. 

  3944. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    3945. 

  3945. /*                                                                                      */

    3946. 

  3946. /* Description:                                                                         */

    3947. 

  3947. /*      Send Start Job (&Page) commands.                                                */

    3948. 

  3948. /*                                                                                      */

    3949. 

  3949. /*******************************************|********************************************/

    3950. 

  3950. EPS_ERR_CODE    SendStartJob (

    3951. 

  3951. 

    3952. 

  3952.         EPS_BOOL bAddStartPage 

    3953. 

  3953. 

    3954. 

  3954. ){

    3955. 

  3955. /*** Declare Variable Local to Routine                                                  */

    3956. 

  3956. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */

    3957. 

  3957. EPS_UINT8*      pCmdPos = NULL;             /* Temporary buffer pointer                 */

    3958. 

  3958. EPS_UINT32      retBufSize = 0;             /* Size of buffer written                   */

    3959. 

  3959. 

    3960. 

  3960. 	EPS_LOG_FUNCIN;

    3961. 

  3961. 

    3962. 

  3962. 	pCmdPos = sendDataBuf;

    3963. 

  3963. 

    3964. 

  3964. /*======================================================================================*/

    3965. 

  3965. /*** Initialize Printer and Set Printer in ESC/PR mode                                  */

    3966. 

  3966. /*======================================================================================*/

    3967. 

  3967. #define SendStartJob_ADDCMD_LEN(CMD, EXPLEN) {												\

    3968. 

  3968. 		retStatus = AddCmdBuff(&sendDataBuf, &pCmdPos, &sendDataBufSize, CMD, sizeof(CMD)+EXPLEN);	\

    3969. 

  3969. 		if(EPS_ERR_NONE != retStatus){														\

    3970. 

  3970. 			goto SendStartJob_END;															\

    3971. 

  3971. 		}																					\

    3972. 

  3972. 	}

    3973. 

  3973. #define SendStartJob_ADDCMD(CMD) SendStartJob_ADDCMD_LEN(CMD, 0)

    3974. 

  3974. 

    3975. 

  3975. 	/*** Exit Packet Mode                                                               */

    3976. 

  3976. 	SendStartJob_ADDCMD(ExitPacketMode)

    3977. 

  3977. 

    3978. 

  3978. 	/*** Initialize Printer                                                             */

    3979. 

  3979. 	SendStartJob_ADDCMD(InitPrinter)

    3980. 

  3980. 

    3981. 

  3981. 	/*** Enter Remote Mode                                                              */

    3982. 

  3982. 	SendStartJob_ADDCMD(EnterRemoteMode)

    3983. 

  3983. 

    3984. 

  3984. 	/*** Remote Command - TI                                                            */

    3985. 

  3985. 	if(epsCmnFnc.getLocalTime){

    3986. 

  3986. 		SendStartJob_ADDCMD(RemoteTI)

    3987. 

  3987. 		MakeRemoteTICmd(pCmdPos - sizeof(RemoteTI));

    3988. 

  3988. 	}

    3989. 

  3989. 

    3990. 

  3990. 	/*** Remote Command - JS                                                            */

    3991. 

  3991. 	SendStartJob_ADDCMD(RemoteJS)

    3992. 

  3992. 

    3993. 

  3993. 	/*** Remote Command - JH                                                            */

    3994. 

  3994. 	SendStartJob_ADDCMD(RemoteJH)

    3995. 

  3995. 

    3996. 

  3996. 	/*** Remote Command - HD                                                            */

    3997. 

  3997. 	SendStartJob_ADDCMD(RemoteHD)

    3998. 

  3998. 	*(pCmdPos - sizeof(RemoteHD) + 6) = printJob.platform;

    3999. 

  3999. 

    4000. 

  4000. 	/*** Remote Command - PP                                                            */

    4001. 

  4001. 	SendStartJob_ADDCMD(RemotePP)

    4002. 

  4002. 	pCmdPos -= sizeof(RemotePP);

    4003. 

  4003. 	

    4004. 

  4004. 	switch(printJob.attr.paperSource){

    4005. 

  4005. 	case EPS_MPID_REAR:

    4006. 

  4006. 		pCmdPos[5] = 0x01; pCmdPos[6] = 0x00; 

    4007. 

  4007. 		break;

    4008. 

  4008. 	case EPS_MPID_FRONT1:

    4009. 

  4009. 		pCmdPos[5] = 0x01; pCmdPos[6] = 0x01; 

    4010. 

  4010. 		break;

    4011. 

  4011. 	case EPS_MPID_FRONT2:

    4012. 

  4012. 		pCmdPos[5] = 0x01; pCmdPos[6] = 0x02;

    4013. 

  4013. 		break;

    4014. 

  4014. 	case EPS_MPID_CDTRAY:

    4015. 

  4015. 		pCmdPos[5] = 0x02; pCmdPos[6] = 0x01; 

    4016. 

  4016. 		break;

    4017. 

  4017. 

    4018. 

  4018. 	case EPS_MPID_AUTO:

    4019. 

  4019. 	default:

    4020. 

  4020. 		if( EPS_CP_JPEG == printJob.attr.colorPlane &&

    4021. 

  4021. 			EPS_IS_CDDVD(printJob.attr.mediaTypeIdx) ){

    4022. 

  4022. 			/* Jpeg CD print need PP  */

    4023. 

  4023. 			pCmdPos[5] = 0x02; pCmdPos[6] = 0x01; 

    4024. 

  4024. 		} else{

    4025. 

  4025. 			EPS_DBGPRINT(("Paper Sourcr AutoSelect\n"));

    4026. 

  4026. 			pCmdPos[5] = 0x01; pCmdPos[6] = 0xFF; /* auto select */

    4027. 

  4027. 		}

    4028. 

  4028. 		break;

    4029. 

  4029. 	}

    4030. 

  4030. 	

    4031. 

  4031. 	pCmdPos += sizeof(RemotePP);

    4032. 

  4032. 

    4033. 

  4033. 	/*** Remote Command - DP(duplex)                                                    */

    4034. 

  4034. 	if(EPS_DUPLEX_NONE != printJob.attr.duplex){

    4035. 

  4035. 		SendStartJob_ADDCMD(RemoteDP)

    4036. 

  4036. 	}

    4037. 

  4037. 

    4038. 

  4038. 	/*** Exit Remote Mode                                                               */

    4039. 

  4039. 	SendStartJob_ADDCMD(ExitRemoteMode)

    4040. 

  4040. 

    4041. 

  4041. 	/*** Enter ESC/P-R mode                                                             */

    4042. 

  4042. 	if( EPS_CP_JPEG != printJob.attr.colorPlane ){	/* RGB  */

    4043. 

  4043. 		SendStartJob_ADDCMD(ESCPRMode)

    4044. 

  4044. 	} else{                                         /* JPEG */

    4045. 

  4045. 		SendStartJob_ADDCMD(ESCPRModeJpg)

    4046. 

  4046. 	}

    4047. 

  4047. 

    4048. 

  4048. 	/*** ESC/PR "Print Quality" Command (Internal called Page Attributes)               */

    4049. 

  4049. 	SendStartJob_ADDCMD_LEN(PrintQualityCmd, printJob.attr.paletteSize)

    4050. 

  4050. 	MakeQualityCmd(pCmdPos - (sizeof(PrintQualityCmd) + printJob.attr.paletteSize) );

    4051. 

  4051. 

    4052. 

  4052. 	/*** ESC/PR "apf setting" Command                                                   */

    4053. 

  4053. 	if(EPS_CP_JPEG == printJob.attr.colorPlane){

    4054. 

  4054. 		SendStartJob_ADDCMD(APFSettingCmd)

    4055. 

  4055. 		MakeAPFCmd(pCmdPos-sizeof(APFSettingCmd));

    4056. 

  4056. 	}

    4057. 

  4057. 

    4058. 

  4058. 	/*** ESC/PR "Job" Command to Printer                                                */

    4059. 

  4059. 	if( EPS_CP_JPEG != printJob.attr.colorPlane ){	/* RGB  */

    4060. 

  4060. 		SendStartJob_ADDCMD(JobCmd)

    4061. 

  4061. 		MakeJobCmd(pCmdPos-sizeof(JobCmd));

    4062. 

  4062. 	} else{                                         /* JPEG */

    4063. 

  4063. 		SendStartJob_ADDCMD(JobCmdJpg)

    4064. 

  4064. 		MakeJobCmd(pCmdPos-sizeof(JobCmdJpg));

    4065. 

  4065. 	}

    4066. 

  4066. 

    4067. 

  4067. 	if(bAddStartPage){

    4068. 

  4068. 		SendStartJob_ADDCMD(StartPage)

    4069. 

  4069. 	}

    4070. 

  4070. 

    4071. 

  4071. 	retStatus = SendCommand(sendDataBuf, (EPS_UINT32)(pCmdPos - sendDataBuf), &retBufSize, TRUE);

    4072. 

  4072. 

    4073. 

  4073. SendStartJob_END:

    4074. 

  4074. 	if(EPS_ERR_NONE == retStatus){

    4075. 

  4075. 		printJob.sendJS = TRUE;

    4076. 

  4076. 	}

    4077. 

  4077. 

    4078. 

  4078.     /*** Return to Caller                                                               */

    4079. 

  4079.     EPS_RETURN( retStatus );

    4080. 

  4080. }

    4081. 

  4081. 

    4082. 

  4082. 

    4083. 

  4083. /*======================================================================================*/

    4084. 

  4084. /*** Set up Remote "TI" Command                                                         */

    4085. 

  4085. /*======================================================================================*/

    4086. 

  4086. static void    MakeRemoteTICmd (

    4087. 

  4087. 

    4088. 

  4088.         EPS_UINT8*		pBuf

    4089. 

  4089. 

    4090. 

  4090. ){

    4091. 

  4091. /*** Declare Variable Local to Routine                                                  */

    4092. 

  4092. EPS_LOCAL_TIME  locTime;

    4093. 

  4093. EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */

    4094. 

  4094. 

    4095. 

  4095. 	EPS_LOG_FUNCIN;

    4096. 

  4096. 

    4097. 

  4097. 	/* Get platform local time */

    4098. 

  4098. 	epsCmnFnc.getLocalTime(&locTime);

    4099. 

  4099. 

    4100. 

  4100. 	/*** Skip Header                                                                    */

    4101. 

  4101. 	pBuf += REMOTE_HEADER_LENGTH;

    4102. 

  4102.     

    4103. 

  4103. 	/*** Set Attributes/Values                                                          */

    4104. 

  4104. 	memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, locTime.year, array2);

    4105. 

  4105. 	memcpy(pBuf, array2, sizeof(array2));

    4106. 

  4106. 	pBuf += sizeof(array2);

    4107. 

  4107. 	*pBuf++ = locTime.mon;

    4108. 

  4108. 	*pBuf++ = locTime.day;

    4109. 

  4109. 	*pBuf++ = locTime.hour;

    4110. 

  4110. 	*pBuf++ = locTime.min;

    4111. 

  4111. 	*pBuf   = locTime.sec;

    4112. 

  4112. 

    4113. 

  4113. 	EPS_RETURN_VOID;

    4114. 

  4114. }

    4115. 

  4115. 

    4116. 

  4116. 

    4117. 

  4117. /*======================================================================================*/

    4118. 

  4118. /*** Set up ESC/PR "Print Quality" Command                                              */

    4119. 

  4119. /*======================================================================================*/

    4120. 

  4120. static void    MakeQualityCmd (

    4121. 

  4121. 

    4122. 

  4122.         EPS_UINT8*		pBuf

    4123. 

  4123. 

    4124. 

  4124. ){

    4125. 

  4125. /*** Declare Variable Local to Routine                                                  */

    4126. 

  4126. EPS_UINT8*      pCmdPosTmp = NULL;

    4127. 

  4127. EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */

    4128. 

  4128. EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */

    4129. 

  4129. 

    4130. 

  4130. 	EPS_LOG_FUNCIN;

    4131. 

  4131. 

    4132. 

  4132. 	/*** Parameter Length                                                               */

    4133. 

  4133. 	if(printJob.attr.paletteSize > 0){

    4134. 

  4134. 		pCmdPosTmp = pBuf + ESCPR_CLASS_LENGTH;

    4135. 

  4135. 		memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, 

    4136. 

  4136. 					ESCPR_PRINT_QUALITY_LENGTH + printJob.attr.paletteSize, array4);

    4137. 

  4137. 		memcpy(pCmdPosTmp, array4, sizeof(array4));

    4138. 

  4138. 	}

    4139. 

  4139. 

    4140. 

  4140. 	pBuf += ESCPR_HEADER_LENGTH;

    4141. 

  4141. 

    4142. 

  4142. 	/*** Set Attributes/Values                                                          */

    4143. 

  4143. 	*pBuf++ = (EPS_UINT8)printJob.attr.mediaTypeIdx;

    4144. 

  4144. 	switch( printJob.attr.printQuality ){

    4145. 

  4145. 		case EPS_MQID_DRAFT:

    4146. 

  4146. 			*pBuf++ = 0;

    4147. 

  4147. 			break;

    4148. 

  4148. 		case EPS_MQID_HIGH:

    4149. 

  4149. 			*pBuf++ = 2;

    4150. 

  4150. 			break;

    4151. 

  4151. 		case EPS_MQID_NORMAL:

    4152. 

  4152. 		default:

    4153. 

  4153. 			*pBuf++ = 1;

    4154. 

  4154. 			break;

    4155. 

  4155. 	}

    4156. 

  4156. 	*pBuf++ = printJob.attr.colorMode;

    4157. 

  4157. 	*pBuf++ = (EPS_UINT8)printJob.attr.brightness;

    4158. 

  4158. 	*pBuf++ = (EPS_UINT8)printJob.attr.contrast;

    4159. 

  4159. 	*pBuf++ = (EPS_UINT8)printJob.attr.saturation;

    4160. 

  4160. 	*pBuf++ = printJob.attr.colorPlane;

    4161. 

  4161.     

    4162. 

  4162. 	memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, printJob.attr.paletteSize, array2);

    4163. 

  4163. 	memcpy(pBuf, array2, sizeof(array2));

    4164. 

  4164. 

    4165. 

  4165. 	if (printJob.attr.paletteSize > 0){

    4166. 

  4166. 		pBuf += sizeof(array2);

    4167. 

  4167. 		memcpy(pBuf, printJob.attr.paletteData, printJob.attr.paletteSize);

    4168. 

  4168. 	}

    4169. 

  4169. 

    4170. 

  4170. 	EPS_RETURN_VOID;

    4171. 

  4171. }

    4172. 

  4172. 

    4173. 

  4173. 

    4174. 

  4174. /*======================================================================================*/

    4175. 

  4175. /*** Set up ESC/PR "APF setting" Command                                                */

    4176. 

  4176. /*======================================================================================*/

    4177. 

  4177. static void    MakeAPFCmd (

    4178. 

  4178. 

    4179. 

  4179.         EPS_UINT8*		pBuf

    4180. 

  4180. 

    4181. 

  4181. ){

    4182. 

  4182. 	EPS_LOG_FUNCIN;

    4183. 

  4183. 

    4184. 

  4184. 	/*** Skip Header                                                                    */

    4185. 

  4185.     pBuf += ESCPR_HEADER_LENGTH;

    4186. 

  4186. 

    4187. 

  4187. 	/*** Set Attributes/Values                                                          */

    4188. 

  4188. 	*pBuf++ = printJob.attr.colorMode;

    4189. 

  4189. 	*pBuf++ = printJob.attr.apfAutoCorrect;

    4190. 

  4190. 	*pBuf++ = printJob.attr.sharpness;

    4191. 

  4191. 	*pBuf++ = printJob.attr.redeye;

    4192. 

  4192. 

    4193. 

  4193. 	EPS_RETURN_VOID;

    4194. 

  4194. }

    4195. 

  4195. 

    4196. 

  4196. 

    4197. 

  4197. /*======================================================================================*/

    4198. 

  4198. /*** Set up ESC/PR "Job" Command                                                        */

    4199. 

  4199. /*======================================================================================*/

    4200. 

  4200. static void    MakeJobCmd (

    4201. 

  4201. 

    4202. 

  4202.         EPS_UINT8*		pBuf

    4203. 

  4203. 

    4204. 

  4204. ){

    4205. 

  4205. /*** Declare Variable Local to Routine                                                  */

    4206. 

  4206. EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */

    4207. 

  4207. EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */

    4208. 

  4208. 

    4209. 

  4209. 	EPS_LOG_FUNCIN;

    4210. 

  4210. 

    4211. 

  4211. 	/*** Skip Header                                                                    */

    4212. 

  4212.     pBuf += ESCPR_HEADER_LENGTH;

    4213. 

  4213. 

    4214. 

  4214. 	if( EPS_CP_JPEG != printJob.attr.colorPlane ){	/* RGB  */

    4215. 

  4215. 		/*EPS_DBGPRINT(("(%d, %d) / (%d, %d) / (%d, %d)\n",

    4216. 

  4216. 			 printJob.paperWidth, printJob.paperHeight,

    4217. 

  4217. 			 printJob.topMargin, printJob.leftMargin,

    4218. 

  4218. 			 printJob.printableAreaWidth, printJob.printableAreaHeight))*/

    4219. 

  4219. 		/*** Set Attributes/Values                                                      */

    4220. 

  4220. 		memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, (EPS_UINT32)printJob.paperWidth, array4);

    4221. 

  4221. 		memcpy(pBuf, array4, sizeof(array4));

    4222. 

  4222. 		pBuf += sizeof(array4);

    4223. 

  4223. 		memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, (EPS_UINT32)printJob.paperHeight, array4);

    4224. 

  4224. 		memcpy(pBuf, array4, sizeof(array4));

    4225. 

  4225. 		pBuf += sizeof(array4);

    4226. 

  4226. 		memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)printJob.topMargin, array2);

    4227. 

  4227. 		memcpy(pBuf, array2, sizeof(array2));

    4228. 

  4228. 		pBuf += sizeof(array2);

    4229. 

  4229. 		memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)printJob.leftMargin, array2);

    4230. 

  4230. 		memcpy(pBuf, array2, sizeof(array2));

    4231. 

  4231. 		pBuf += sizeof(array2);

    4232. 

  4232. 		memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, printJob.printableAreaWidth, array4);

    4233. 

  4233. 		memcpy(pBuf, array4, sizeof(array4));

    4234. 

  4234. 		pBuf += sizeof(array4);

    4235. 

  4235. 		memSetEndian(EPS_ENDIAN_BIG, EPS_4_BYTES, printJob.printableAreaHeight, array4);

    4236. 

  4236. 		memcpy(pBuf, array4, sizeof(array4));

    4237. 

  4237. 		pBuf += sizeof(array4);

    4238. 

  4238. 		switch( printJob.attr.inputResolution ){

    4239. 

  4239. 		case EPS_IR_720X720:

    4240. 

  4240. 			*pBuf++ = 0x01;

    4241. 

  4241. 			break;

    4242. 

  4242. 		case EPS_IR_300X300:

    4243. 

  4243. 			*pBuf++ = 0x02;

    4244. 

  4244. 			break;

    4245. 

  4245. 		case EPS_IR_600X600:

    4246. 

  4246. 			*pBuf++ = 0x03;

    4247. 

  4247. 			break;

    4248. 

  4248. 		case EPS_IR_360X360:

    4249. 

  4249. 		default:

    4250. 

  4250. 			*pBuf++ = 0x00;

    4251. 

  4251. 			break;

    4252. 

  4252. 		}

    4253. 

  4253. 		*pBuf   = printJob.attr.printDirection;

    4254. 

  4254. 

    4255. 

  4255. 	} else{												/* JPEG  */

    4256. 

  4256. 		/*** Set Attributes/Values                                                      */

    4257. 

  4257. 		*pBuf++ = (EPS_UINT8)printJob.attr.mediaSizeIdx;

    4258. 

  4258. 		if( EPS_IS_CDDVD( printJob.attr.mediaTypeIdx ) ){

    4259. 

  4259. 			*pBuf++ = 0x0A;

    4260. 

  4260. 		} else{

    4261. 

  4261. 			switch( printJob.attr.printLayout ){

    4262. 

  4262. 			case EPS_MLID_BORDERLESS:

    4263. 

  4263. 				*pBuf++ = 0x01;

    4264. 

  4264. 				break;

    4265. 

  4265. 			case EPS_MLID_CDLABEL:

    4266. 

  4266. 				*pBuf++ = 0x0A;

    4267. 

  4267. 				break;

    4268. 

  4268. 			case EPS_MLID_DIVIDE16:

    4269. 

  4269. 				*pBuf++ = 0x90;

    4270. 

  4270. 				break;

    4271. 

  4271. 			default: /* FIXED, CUSTOM */

    4272. 

  4272. 				*pBuf++ = 0x00;

    4273. 

  4273. 			}

    4274. 

  4274. 		}

    4275. 

  4275. 		*pBuf++ = printJob.attr.cdDimIn;

    4276. 

  4276. 		*pBuf++ = printJob.attr.cdDimOut;

    4277. 

  4277. 		*pBuf   = printJob.attr.printDirection;

    4278. 

  4278. 	}

    4279. 

  4279. 

    4280. 

  4280. 	EPS_RETURN_VOID;

    4281. 

  4281. }

    4282. 

  4282. 

    4283. 

  4283. 

    4284. 

  4284. /*******************************************|********************************************/

    4285. 

  4285. /*                                                                                      */

    4286. 

  4286. /* Function name:   SendEndJob()                                                        */

    4287. 

  4287. /*                                                                                      */

    4288. 

  4288. /* Arguments                                                                            */

    4289. 

  4289. /* ---------                                                                            */

    4290. 

  4290. /* Name:        Type:               Description:                                        */

    4291. 

  4291. /* bAddEndPage  EPS_BOOL            I: Append End Page comannd                          */

    4292. 

  4292. /*                                                                                      */

    4293. 

  4293. /* Return value:                                                                        */

    4294. 

  4294. /*      << Normal >>                                                                    */

    4295. 

  4295. /*      EPS_ERR_NONE                    - Success                                       */

    4296. 

  4296. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    4297. 

  4297. /*                                        (Do not return when Uni-Directional)          */

    4298. 

  4298. /*      << Error >>                                                                     */

    4299. 

  4299. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    4300. 

  4300. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    4301. 

  4301. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    4302. 

  4302. /*                                                                                      */

    4303. 

  4303. /* Description:                                                                         */

    4304. 

  4304. /*      Send End Page commands.                                                         */

    4305. 

  4305. /*                                                                                      */

    4306. 

  4306. /*******************************************|********************************************/

    4307. 

  4307. EPS_ERR_CODE    SendEndJob (

    4308. 

  4308. 

    4309. 

  4309.         EPS_BOOL bAddEndPage

    4310. 

  4310. 

    4311. 

  4311. ){

    4312. 

  4312. /*** Declare Variable Local to Routine                                                  */

    4313. 

  4313. EPS_ERR_CODE    retStatus = EPS_ERR_NONE;   /* Return status of internal calls          */

    4314. 

  4314. EPS_UINT8*      pCmdPos = NULL;

    4315. 

  4315. EPS_UINT32      retBufSize;                         /* Size of buffer written           */

    4316. 

  4316. 

    4317. 

  4317. 	EPS_LOG_FUNCIN

    4318. 

  4318. 

    4319. 

  4319. 	EPS_MEM_GROW(EPS_UINT8*, sendDataBuf, &sendDataBufSize, 

    4320. 

  4320. 				(sizeof(EndPage)+ sizeof(EndJob) + sizeof(InitPrinter)

    4321. 

  4321. 				+ sizeof(EnterRemoteMode) + sizeof(RemoteLD) + sizeof(RemoteJE)+ sizeof(ExitRemoteMode)))

    4322. 

  4322. 	if(NULL == sendDataBuf){

    4323. 

  4323. 		EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION )

    4324. 

  4324. 	}

    4325. 

  4325. 

    4326. 

  4326. 	pCmdPos = sendDataBuf;

    4327. 

  4327. 

    4328. 

  4328. 	if(bAddEndPage){

    4329. 

  4329. 		memcpy(pCmdPos, EndPage, sizeof(EndPage));

    4330. 

  4330. 		pCmdPos[10] = EPS_END_PAGE;

    4331. 

  4331. 		pCmdPos += sizeof(EndPage);

    4332. 

  4332. 	}

    4333. 

  4333. 

    4334. 

  4334. 	/*** End Job                                                                        */

    4335. 

  4335. 	memcpy(pCmdPos, EndJob, sizeof(EndJob));

    4336. 

  4336. 	pCmdPos += sizeof(EndJob);

    4337. 

  4337. 

    4338. 

  4338. 	/*** Initialize                                                                     */

    4339. 

  4339. 	memcpy(pCmdPos, InitPrinter, sizeof(InitPrinter));

    4340. 

  4340. 	pCmdPos += sizeof(InitPrinter);

    4341. 

  4341. 

    4342. 

  4342. 	memcpy(pCmdPos, EnterRemoteMode, sizeof(EnterRemoteMode));

    4343. 

  4343. 	pCmdPos += sizeof(EnterRemoteMode);

    4344. 

  4344. 

    4345. 

  4345. 	if(EPS_DUPLEX_NONE != printJob.attr.duplex){

    4346. 

  4346. 		memcpy(pCmdPos, RemoteLD, sizeof(RemoteLD));

    4347. 

  4347. 		pCmdPos += sizeof(RemoteLD);

    4348. 

  4348. 	}

    4349. 

  4349. 

    4350. 

  4350. 	/*** Remote Command - JE                                                            */

    4351. 

  4351. 	memcpy(pCmdPos, RemoteJE, sizeof(RemoteJE));

    4352. 

  4352. 	pCmdPos += sizeof(RemoteJE);

    4353. 

  4353. 

    4354. 

  4354.   	/*** Exit Remote Mode                                                               */

    4355. 

  4355. 	memcpy(pCmdPos, ExitRemoteMode, sizeof(ExitRemoteMode));

    4356. 

  4356. 	pCmdPos += sizeof(ExitRemoteMode);

    4357. 

  4357. 

    4358. 

  4358. 	retStatus = SendCommand(sendDataBuf, (EPS_UINT32)(pCmdPos - sendDataBuf), &retBufSize, TRUE);

    4359. 

  4359. 

    4360. 

  4360. 	if(EPS_JOB_CANCELED == retStatus){

    4361. 

  4361. 		retStatus = EPS_ERR_NONE;

    4362. 

  4362. 	}

    4363. 

  4363. 

    4364. 

  4364. 	/*printJob.sendJS = FALSE;*/

    4365. 

  4365. 

    4366. 

  4366.     /*** Return to Caller                                                               */

    4367. 

  4367.     EPS_RETURN( retStatus );

    4368. 

  4368. }

    4369. 

  4369. 

    4370. 

  4370. 

    4371. 

  4371. /*******************************************|********************************************/

    4372. 

  4372. /*                                                                                      */

    4373. 

  4373. /* Function name:   SendCommand()                                                       */

    4374. 

  4374. /*                                                                                      */

    4375. 

  4375. /* Arguments                                                                            */

    4376. 

  4376. /* ---------                                                                            */

    4377. 

  4377. /* Name:        Type:               Description:                                        */

    4378. 

  4378. /* Buffer       EPS_INT8*           I: Print Data Buffer                                */

    4379. 

  4379. /* BuffLen      EPS_UINT32          I: Print Data Buffer Size                           */

    4380. 

  4380. /* pSize        EPS_UINT32          O: Actual Length Transferred                        */

    4381. 

  4381. /*                                                                                      */

    4382. 

  4382. /* Return value:                                                                        */

    4383. 

  4383. /*      EPS_ERR_NONE                    - Sent the data successfully                    */

    4384. 

  4384. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    4385. 

  4385. /*                                        (Do not return when Uni-Directional)          */

    4386. 

  4386. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    4387. 

  4387. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    4388. 

  4388. /*      EPS_ERR_PRINTER_ERR_OCCUR       - Printer Error happened                        */

    4389. 

  4389. /*                                                                                      */

    4390. 

  4390. /* Description:                                                                         */

    4391. 

  4391. /*      Send print data to the active printer                                           */

    4392. 

  4392. /*                                                                                      */

    4393. 

  4393. /*******************************************|********************************************/

    4394. 

  4394. EPS_ERR_CODE  SendCommand (

    4395. 

  4395. 

    4396. 

  4396.         const EPS_UINT8*    Buffer,

    4397. 

  4397.         EPS_UINT32          BuffLen,

    4398. 

  4398.         EPS_UINT32*         pSize,

    4399. 

  4399.         EPS_BOOL            bSave

    4400. 

  4400. 

    4401. 

  4401. ){

    4402. 

  4402. 

    4403. 

  4403. #ifdef EPS_FILTER

    4404. 

  4404. 	//long int i;

    4405. 

  4405. 	EPS_UINT32 i;

    4406. 

  4406. 	FILE* outfp = stdout;

    4407. 

  4407. 	for (i = 0; i < BuffLen; i++){

    4408. 

  4408. 		putc(*(Buffer + i), outfp);

    4409. 

  4409. 	}

    4410. 

  4410. 	*pSize = BuffLen;

    4411. 

  4411. 	return EPS_ERR_NONE;

    4412. 

  4412. #endif	

    4413. 

  4413. /*** Declare Variable Local to Routine                                                  */

    4414. 

  4414.     EPS_ERR_CODE  Ret = EPS_ERR_NONE;

    4415. 

  4415.     EPS_INT32  retStatus;

    4416. 

  4416.     EPS_UINT32 sendSize;

    4417. 

  4417.     EPS_UINT32 sentSize;

    4418. 

  4418. 	EPS_INT32  nRetry = 0;

    4419. 

  4419. 	EPS_UINT32 tmStart, tmNow, tmSpan;

    4420. 

  4420.     EPS_INT32  nDlySpan = 10;				/* first 10 ms */

    4421. 

  4421.     EPS_INT32  nDlyTotal = EPS_TIMEOUT_SEC;	/* total 1000 ms */

    4422. 

  4422. 

    4423. 

  4423. 	EPS_LOG_FUNCIN;

    4424. 

  4424. 

    4425. 

  4425. /*** Validate input parameters                                                          */

    4426. 

  4426.     if ((Buffer  == NULL) || (BuffLen == 0))

    4427. 

  4427.         EPS_RETURN( EPS_ERR_OPR_FAIL );

    4428. 

  4428. 

    4429. 

  4429. /*** Initialize Global/Local Variables                                                  */

    4430. 

  4430.     retStatus = EPS_ERR_NONE;

    4431. 

  4431.     sentSize  = 0;

    4432. 

  4432.     sendSize  = BuffLen;

    4433. 

  4433.     *pSize    = 0;

    4434. 

  4434. 

    4435. 

  4435. 	tmStart = tmNow = tmSpan = 0;

    4436. 

  4436. 

    4437. 

  4437. 	if( FALSE == printJob.bComm){

    4438. 

  4438. 		EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    4439. 

  4439. 	}

    4440. 

  4440. 

    4441. 

  4441. 	if( EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){

    4442. 

  4442. /***------------------------------------------------------------------------------------*/

    4443. 

  4443. /*** Bi-Directional Mode                                                                */

    4444. 

  4444. /***------------------------------------------------------------------------------------*/

    4445. 

  4445. 	/*** If printer reset command was already sent, don't send command any more.        */

    4446. 

  4446. 	/*** When paper jam error happened, don't send command any more.                    */

    4447. 

  4447. 	/*** "transmittable == FLSE" means "paper jam error happened".                      */

    4448. 

  4448. 		if( printJob.resetSent == EPS_RESET_SENT || TRUE == printJob.resetReq ){

    4449. 

  4449. 			EPS_RETURN( EPS_JOB_CANCELED );

    4450. 

  4450. 		} else if(FALSE == printJob.transmittable){

    4451. 

  4451. 			EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    4452. 

  4452. 		}

    4453. 

  4453.         

    4454. 

  4454. 	/*** Send command                                                                   */

    4455. 

  4455. 		if(epsCmnFnc.getTime){

    4456. 

  4456. 			tmStart = epsCmnFnc.getTime();

    4457. 

  4457. 			tmNow = tmSpan = 0;

    4458. 

  4458. 		}

    4459. 

  4459. 

    4460. 

  4460. 		while(nDlyTotal > 0){

    4461. 

  4461. 			if(gStatusCount == EPS_ROOP_NUM){

    4462. 

  4462. 				gStatusCount = 0;

    4463. 

  4463. 				if ((Ret = MonitorStatus(NULL) ) != EPS_ERR_NONE){

    4464. 

  4464. 					EPS_DBGPRINT(("MonitorStatus=%d\n", Ret));

    4465. 

  4465. 

    4466. 

  4466. 					if(Ret == EPS_JOB_CANCELED){

    4467. 

  4467. 						EPS_RETURN( Ret );

    4468. 

  4468. 					} else if(Ret == EPS_ERR_COMM_ERROR){

    4469. 

  4469. 						EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    4470. 

  4470. 					} else {

    4471. 

  4471. 						/*anoter error*/

    4472. 

  4472. 						if ( EPS_PROTOCOL_USB & printJob.printer->protocol ){

    4473. 

  4473. 							break;

    4474. 

  4474. 						} else{

    4475. 

  4475. 							/* Net continue to buffer full. */

    4476. 

  4476. 						}

    4477. 

  4477. 					} 

    4478. 

  4478. 				}

    4479. 

  4479. 			}

    4480. 

  4480. 			gStatusCount++;

    4481. 

  4481. 

    4482. 

  4482. 			Ret = jobFnc.WriteData(Buffer, sendSize, &sentSize);

    4483. 

  4483. 			*pSize += sentSize;

    4484. 

  4484. #ifdef LCOMSW_CMDDMP

    4485. 

  4485. 	EPS_DF_WRITE(Buffer, sentSize)

    4486. 

  4486. #endif

    4487. 

  4487. 

    4488. 

  4488. 			if (Ret != EPS_ERR_NONE){

    4489. 

  4489. 				if (Ret == EPS_JOB_CANCELED) {

    4490. 

  4490. 					/* UPnP Job turned idle */

    4491. 

  4491. 					printJob.resetReq = TRUE;

    4492. 

  4492. 					EPS_RETURN( Ret );

    4493. 

  4493. 				} else if (Ret != EPS_COM_TINEOUT){

    4494. 

  4494. 					EPS_DBGPRINT(("PRINT--> Print Failed [%d]\r\n",Ret));

    4495. 

  4495. 					EPS_RETURN( EPS_ERR_COMM_ERROR );

    4496. 

  4496. 				} else if(sendSize > sentSize){

    4497. 

  4497. 					Buffer  += sentSize;

    4498. 

  4498. 					sendSize -= sentSize;

    4499. 

  4499. 				}

    4500. 

  4500. 			} else if (sendSize > sentSize){     /* CBT returned OK, but size is less */

    4501. 

  4501. 				Ret = EPS_COM_TINEOUT;

    4502. 

  4502. 				Buffer  += sentSize;

    4503. 

  4503. 				sendSize -= sentSize;

    4504. 

  4504. 			} else {

    4505. 

  4505. 				sendSize -= sentSize;

    4506. 

  4506. 				break;

    4507. 

  4507. 			}

    4508. 

  4508. 	

    4509. 

  4509. 			if( !(EPS_PROTOCOL_USB & printJob.printer->protocol)

    4510. 

  4510. 				|| NULL == epsCmnFnc.getTime ){

    4511. 

  4511. 				/* The count is made an upper bound. */

    4512. 

  4512. 				if(nRetry++ > EPS_TIMEOUT_NUM){

    4513. 

  4513. 					break;

    4514. 

  4514. 				}

    4515. 

  4515. 			} else{

    4516. 

  4516. 				/* The elapsed time is made an upper bound. */

    4517. 

  4517. 				tmNow = epsCmnFnc.getTime();

    4518. 

  4518. 				tmSpan = (EPS_UINT32)(tmNow - tmStart);

    4519. 

  4519. 				if( tmSpan >= EPS_TIMEOUT_SEC ){

    4520. 

  4520. 					break;

    4521. 

  4521. 				}

    4522. 

  4522. 

    4523. 

  4523. 				/* Wait */

    4524. 

  4524. 				nDlyTotal -= nDlySpan;

    4525. 

  4525. 				if(nDlySpan < 200){

    4526. 

  4526. 					nDlySpan += nDlySpan/2;

    4527. 

  4527. 					if(nDlySpan > 200){

    4528. 

  4528. 						nDlySpan = 200;		/* max 200ms */

    4529. 

  4529. 					}

    4530. 

  4530. 				}

    4531. 

  4531. 				serDelayThread(nDlySpan, &epsCmnFnc);

    4532. 

  4532. 			}

    4533. 

  4533. 		}

    4534. 

  4534. 

    4535. 

  4535. 		if(0 < sendSize){

    4536. 

  4536. 			if(TRUE == bSave){

    4537. 

  4537. 				/* save the leftovers */

    4538. 

  4538. 				/*EPS_DBGPRINT(("%d / Save %d byte\r\n", Ret, sendSize));*/

    4539. 

  4539. 				printJob.contData.sendDataSize = sendSize;

    4540. 

  4540. 				printJob.contData.sendData = Buffer;

    4541. 

  4541. 			}

    4542. 

  4542. 

    4543. 

  4543. 			Ret = MonitorStatus(NULL);

    4544. 

  4544. 			if (Ret == EPS_JOB_CANCELED) {

    4545. 

  4545. 				EPS_RETURN( Ret );

    4546. 

  4546. 			} else{

    4547. 

  4547. 				EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    4548. 

  4548. 			}

    4549. 

  4549. 		} else{

    4550. 

  4550. 			printJob.contData.sendDataSize = 0;

    4551. 

  4551. 		}

    4552. 

  4552. 

    4553. 

  4553. 		if(Ret != EPS_ERR_NONE){

    4554. 

  4554. 			EPS_RETURN( EPS_ERR_PRINTER_ERR_OCCUR );

    4555. 

  4555. 		}

    4556. 

  4556. 

    4557. 

  4557. 	} else{

    4558. 

  4558. /***------------------------------------------------------------------------------------*/

    4559. 

  4559. /*** Uni-Directional Communication Mode                                                 */

    4560. 

  4560. /***------------------------------------------------------------------------------------*/

    4561. 

  4561. 		retStatus = jobFnc.WriteData(Buffer, BuffLen, &sentSize);

    4562. 

  4562. 

    4563. 

  4563.         if ((retStatus == 0) && (sendSize == sentSize)) {

    4564. 

  4564.             *pSize = sentSize;

    4565. 

  4565.         } else {

    4566. 

  4566.             EPS_RETURN( EPS_ERR_COMM_ERROR );

    4567. 

  4567.         }

    4568. 

  4568. 	}

    4569. 

  4569. 

    4570. 

  4570. /*** Return to Caller                                                                   */

    4571. 

  4571.     EPS_RETURN( EPS_ERR_NONE );

    4572. 

  4572. }

    4573. 

  4573. 

    4574. 

  4574. 

    4575. 

  4575. /*******************************************|********************************************/

    4576. 

  4576. /*                                                                                      */

    4577. 

  4577. /* Function name:     AdjustBasePoint()                                                 */

    4578. 

  4578. /*                                                                                      */

    4579. 

  4579. /* Arguments                                                                            */

    4580. 

  4580. /* ---------                                                                            */

    4581. 

  4581. /* Name:        Type:               Description:                                        */

    4582. 

  4582. /* N/A          void                N/A                                                 */

    4583. 

  4583. /*                                                                                      */

    4584. 

  4584. /* Return value:    N/A                                                                 */

    4585. 

  4585. /*                                                                                      */

    4586. 

  4586. /* Description:     Change the base point setting and the printable area value for      */

    4587. 

  4587. /*                  the custum border mode.                                             */

    4588. 

  4588. /*                                                                                      */

    4589. 

  4589. /*******************************************|********************************************/

    4590. 

  4590. static void     AdjustBasePoint (

    4591. 

  4591. 

    4592. 

  4592.         void

    4593. 

  4593. 

    4594. 

  4594. ){

    4595. 

  4595.     /* temporary variables for max PAW/PAL */

    4596. 

  4596.     EPS_UINT32  maxPAWidthBorder;

    4597. 

  4597.     EPS_UINT32  maxPAHeightBorder;

    4598. 

  4598.     EPS_UINT32  RightMargin;

    4599. 

  4599.     EPS_UINT32  BottomMargin;

    4600. 

  4600.     

    4601. 

  4601. 	EPS_LOG_FUNCIN;

    4602. 

  4602.     

    4603. 

  4603.     printJob.offset_x = 0;

    4604. 

  4604.     printJob.offset_y = 0;

    4605. 

  4605.     

    4606. 

  4606. 

    4607. 

  4607. /*** Adjust the base point for custum border printing mode                              */

    4608. 

  4608. /*** (In case that left margin = 42 and top margin = 42 are NOT inputed)                */

    4609. 

  4609.     if (printJob.borderlessMode == EPS_BORDER_CUSTOM) {

    4610. 

  4610.         if ( (printJob.attr.leftMargin > printJob.border.left) ||

    4611. 

  4611.              (printJob.attr.topMargin  > printJob.border.top )    ) {

    4612. 

  4612. 

    4613. 

  4613.             printJob.offset_x = (EPS_INT16)(printJob.attr.leftMargin - printJob.border.left);

    4614. 

  4614.             printJob.offset_y = (EPS_INT16)(printJob.attr.topMargin  - printJob.border.top);

    4615. 

  4615. 

    4616. 

  4616.             RightMargin  = printJob.paperWidth

    4617. 

  4617.                                 - printJob.attr.leftMargin - printJob.printableAreaWidth;

    4618. 

  4618.             BottomMargin = printJob.paperHeight

    4619. 

  4619.                                 - printJob.attr.topMargin  - printJob.printableAreaHeight;

    4620. 

  4620. 

    4621. 

  4621.             printJob.printableAreaWidth  = printJob.paperWidth

    4622. 

  4622.                                                 - printJob.border.left - RightMargin;

    4623. 

  4623.             printJob.printableAreaHeight = printJob.paperHeight

    4624. 

  4624.                                                 - printJob.border.top  - BottomMargin;

    4625. 

  4625. 

    4626. 

  4626.             printJob.leftMargin = (EPS_INT16)(printJob.border.left);

    4627. 

  4627.             printJob.topMargin  = (EPS_INT16)(printJob.border.top);

    4628. 

  4628. 

    4629. 

  4629.             /* max PAW/PAL */

    4630. 

  4630.             maxPAHeightBorder = (EPS_UINT32)(printJob.paperHeight 

    4631. 

  4631.                                     - printJob.border.top  - printJob.border.bottom);

    4632. 

  4632.             maxPAWidthBorder  = (EPS_UINT32)(printJob.paperWidth 

    4633. 

  4633.                                     - printJob.border.left - printJob.border.right);

    4634. 

  4634. 

    4635. 

  4635.             if (printJob.printableAreaHeight > maxPAHeightBorder) {

    4636. 

  4636.                 printJob.printableAreaHeight = maxPAHeightBorder;

    4637. 

  4637.             }

    4638. 

  4638. 

    4639. 

  4639.             if (printJob.printableAreaWidth > maxPAWidthBorder) {

    4640. 

  4640.                 printJob.printableAreaWidth = maxPAWidthBorder;

    4641. 

  4641.             }

    4642. 

  4642.         }

    4643. 

  4643.     }

    4644. 

  4644. 

    4645. 

  4645. 	EPS_RETURN_VOID;

    4646. 

  4646. }

    4647. 

  4647. 

    4648. 

  4648. 

    4649. 

  4649. /*******************************************|********************************************/

    4650. 

  4650. /*                                                                                      */

    4651. 

  4651. /* Function name:   PrintLine()                                                         */

    4652. 

  4652. /*                                                                                      */

    4653. 

  4653. /* Arguments                                                                            */

    4654. 

  4654. /* ---------                                                                            */

    4655. 

  4655. /* Name:        Type:               Description:                                        */

    4656. 

  4656. /* line         EPS_IMAGE*          I: Image Data Structure                             */

    4657. 

  4657. /*                                                                                      */

    4658. 

  4658. /* Return value:                                                                        */

    4659. 

  4659. /*      EPS_ERR_NONE                    - Success                                       */

    4660. 

  4660. /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */

    4661. 

  4661. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    4662. 

  4662. /*                                        (Do not return when Uni-Directional)          */

    4663. 

  4663. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    4664. 

  4664. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    4665. 

  4665. /*                                                                                      */

    4666. 

  4666. /* Description:                                                                         */

    4667. 

  4667. /*      Filter Print Raster Data.                                                       */

    4668. 

  4668. /*                                                                                      */

    4669. 

  4669. /*******************************************|********************************************/

    4670. 

  4670. static EPS_ERR_CODE     PrintLine (

    4671. 

  4671. 

    4672. 

  4672.         EPS_IMAGE*  line

    4673. 

  4673. 

    4674. 

  4674. ){

    4675. 

  4675.     EPS_RECT        AdjBandRec;     /* Rectangle after BasePointAdjustment              */

    4676. 

  4676.     EPS_BANDBMP     InBmp;          /* Input band data                                  */

    4677. 

  4677. 	EPS_LOG_FUNCIN;

    4678. 

  4678.     /* Initialize input image structure */

    4679. 

  4679.     InBmp.bits       = line->data;

    4680. 

  4680.     InBmp.widthBytes = line->bytesPerLine;

    4681. 

  4681. 

    4682. 

  4682.     /* change rectangle due to base point adjustment */

    4683. 

  4683.     AdjBandRec.top    = line->rect.top    + printJob.offset_y;

    4684. 

  4684.     AdjBandRec.left   = line->rect.left   + printJob.offset_x;

    4685. 

  4685.     AdjBandRec.bottom = line->rect.bottom + printJob.offset_y;

    4686. 

  4686.     AdjBandRec.right  = line->rect.right  + printJob.offset_x;

    4687. 

  4687.     

    4688. 

  4688.     /* band is not visible */

    4689. 

  4689.     if ((EPS_UINT32)AdjBandRec.bottom > printJob.printableAreaHeight){

    4690. 

  4690.         EPS_RETURN( EPS_ERR_NONE );

    4691. 

  4691.     }

    4692. 

  4692. 

    4693. 

  4693.     if ((EPS_UINT32)AdjBandRec.right > printJob.printableAreaWidth){

    4694. 

  4694.         AdjBandRec.right = (EPS_INT32)printJob.printableAreaWidth;

    4695. 

  4695.     }

    4696. 

  4696. 

    4697. 

  4697. #ifdef GCOMSW_CMD_ESCPAGE

    4698. 

  4698. 	if(EPS_LANG_ESCPR == printJob.printer->language ){

    4699. 

  4699. #endif

    4700. 

  4700. 		/*** ESC/P-R ***/

    4701. 

  4701. 		EPS_RETURN( SendLine(&InBmp, &AdjBandRec) );

    4702. 

  4702. #ifdef GCOMSW_CMD_ESCPAGE

    4703. 

  4703. 	} else{

    4704. 

  4704. 		/*** ESC/Page ***/

    4705. 

  4705. 		EPS_RETURN( pageColorRow(&InBmp, &AdjBandRec) );

    4706. 

  4706. 	}

    4707. 

  4707. #endif

    4708. 

  4708. 

    4709. 

  4709. }

    4710. 

  4710. 

    4711. 

  4711. /*******************************************|********************************************/

    4712. 

  4712. /*                                                                                      */

    4713. 

  4713. /* Function name:   SendLine()                                                          */

    4714. 

  4714. /*                                                                                      */

    4715. 

  4715. /* Arguments                                                                            */

    4716. 

  4716. /* ---------                                                                            */

    4717. 

  4717. /* Name:        Type:               Description:                                        */

    4718. 

  4718. /* pInBmp       const EPS_BANDBMP   I: [RGB] Image Data                                 */

    4719. 

  4719. /* pBandRec     EPS_RECT            I: Band rectangle information                       */

    4720. 

  4720. /*                                                                                      */

    4721. 

  4721. /* Return value:                                                                        */

    4722. 

  4722. /*      EPS_ERR_NONE                    - Sent the data successfully                    */

    4723. 

  4723. /*      EPS_JOB_CANCELED                - Cancelled operation by user                   */

    4724. 

  4724. /*                                        (Do not return when Uni-Directional)          */

    4725. 

  4725. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    4726. 

  4726. /*      EPS_ERR_COMM_ERROR              - Communication Error                           */

    4727. 

  4727. /*                                                                                      */

    4728. 

  4728. /* Description:                                                                         */

    4729. 

  4729. /*      Send a line data to printer.                                                    */

    4730. 

  4730. /*                                                                                      */

    4731. 

  4731. /*******************************************|********************************************/

    4732. 

  4732. static EPS_ERR_CODE     SendLine (

    4733. 

  4733. 

    4734. 

  4734.         const EPS_BANDBMP*  pInBmp,

    4735. 

  4735.         EPS_RECT*           pBandRec

    4736. 

  4736.         

    4737. 

  4737. ){

    4738. 

  4738. /*** Declare Variable Local to Routine                                                  */

    4739. 

  4739.     EPS_ERR_CODE    retStatus;                  /* Return status of internal calls          */

    4740. 

  4740.     EPS_UINT32      retBufSize;                 /* Size of buffer written                   */

    4741. 

  4741.     EPS_UINT32      cmdSize;                    /* All Size of Print Job Command            */

    4742. 

  4742.     EPS_UINT32      cpyCount;                   /* Counter for Set Command                  */

    4743. 

  4743.     EPS_UINT16      compDataSize;               /* Raster Data Size                         */

    4744. 

  4744.     EPS_UINT16      linePixelSize;              /* Raster Pixel Size                        */

    4745. 

  4745.     EPS_UINT8       compFlag;                   /* Compression flg (1:done compression  0:undone compression) */

    4746. 

  4746.     EPS_UINT32      paramSize;                  /* Parameter Length                         */

    4747. 

  4747.     EPS_UINT8       array2[2] = {0, 0};         /* Temporary Buffer for 2 byte Big Endian   */

    4748. 

  4748.     EPS_UINT8       array4[4] = {0, 0, 0, 0};   /* Temporary Buffer for 4 byte Big Endian   */

    4749. 

  4749.     EPS_UINT8*      compData;                   /* Compression Data Pointer                 */

    4750. 

  4750.     EPS_UINT8*      sdBuf;                      /* Send Data Buffer Pointer                 */

    4751. 

  4751. 	const EPS_UINT8* srcAddr;

    4752. 

  4752.     

    4753. 

  4753. #if LCOMSW_PACKET_4KB

    4754. 

  4754.     EPS_INT32       rest_size;

    4755. 

  4755.     EPS_INT32       idx;

    4756. 

  4756. #endif

    4757. 

  4757. 

    4758. 

  4758. 	EPS_LOG_FUNCIN;

    4759. 

  4759. 

    4760. 

  4760. /*** Initialize Local Variables                                                         */

    4761. 

  4761.     compFlag = EPS_RLE_COMPRESS_DONE;

    4762. 

  4762. 

    4763. 

  4763. /*** Initialize global valiable                                                         */

    4764. 

  4764.     memset(sendDataBuf, 0xFF, (EPS_UINT32)sendDataBufSize);

    4765. 

  4765.     memset(tmpLineBuf,  0xFF, (EPS_UINT32)tmpLineBufSize );

    4766. 

  4766. 

    4767. 

  4767. /*** Initialize valiable                                                                */

    4768. 

  4768.     sdBuf    = sendDataBuf;

    4769. 

  4769.     compData = tmpLineBuf;

    4770. 

  4770. 

    4771. 

  4771. 

    4772. 

  4772. /*    EPS_DBGPRINT(("MakeOneRasterData: T,B,L,R [%d,%d,%d,%d]\r\n", 

    4773. 

  4773.             pBandRec->top, pBandRec->bottom, pBandRec->left, pBandRec->right));

    4774. 

  4774. */

    4775. 

  4775.     if( (EPS_UINT32)(pBandRec->right - pBandRec->left) <= printJob.printableAreaWidth){

    4776. 

  4776.         linePixelSize = (EPS_UINT16)(pBandRec->right - pBandRec->left);

    4777. 

  4777.     } else{

    4778. 

  4778.         linePixelSize = (EPS_UINT16) printJob.printableAreaWidth;

    4779. 

  4779.     }

    4780. 

  4780. 

    4781. 

  4781. #if ESCPR_DEBUG_IMAGE_LOG

    4782. 

  4782.     EPS_DBGPRINT(("ESCPRCMD : ImageData\r\n")

    4783. 

  4783. 	EPS_DUMP(pInBmp->bits, (pBandRec->right - pBandRec->left) * 3)

    4784. 

  4784. #endif

    4785. 

  4785.     

    4786. 

  4786. 	/*** Layout Filter */

    4787. 

  4787. 	if(EPS_MLID_CDLABEL == printJob.attr.printLayout){

    4788. 

  4788. #ifdef GCOMSW_EL_CDLABEL

    4789. 

  4789. 		elCDClipping(pInBmp->bits, sdBuf, printJob.bpp, pBandRec);

    4790. 

  4790. 		srcAddr = sdBuf;

    4791. 

  4791. #else

    4792. 

  4792. 		srcAddr = pInBmp->bits;

    4793. 

  4793. #endif

    4794. 

  4794. 

    4795. 

  4795. 	} else{

    4796. 

  4796. 		srcAddr = pInBmp->bits;

    4797. 

  4797. 	}

    4798. 

  4798. 

    4799. 

  4799. 	/*** RunLength Encode */

    4800. 

  4800. 	

    4801. 

  4801. 	compDataSize = RunLengthEncode(srcAddr,

    4802. 

  4802.                             compData,

    4803. 

  4803.                             linePixelSize,

    4804. 

  4804.                             printJob.bpp,

    4805. 

  4805.                             &compFlag);

    4806. 

  4806. 

    4807. 

  4807. 	//compFlag = EPS_RLE_COMPRESS_NOT_DONE;

    4808. 

  4808. 	if(compDataSize < 0){

    4809. 

  4809. 		//return compDataSize;

    4810. 

  4810. 	}

    4811. 

  4811. 	

    4812. 

  4812. 	/* Set Parameter Length */

    4813. 

  4813.     paramSize = (EPS_UINT32)(ESCPR_SEND_DATA_LENGTH + compDataSize);

    4814. 

  4814.     cmdSize   = ESCPR_HEADER_LENGTH + paramSize;

    4815. 

  4815.     

    4816. 

  4816. /*** Set Parameter                                                                      */

    4817. 

  4817.     cpyCount = 0;

    4818. 

  4818.     

    4819. 

  4819.     /* Header */

    4820. 

  4820.     memcpy(sdBuf, SendDataCmd, sizeof(SendDataCmd));

    4821. 

  4821.     cpyCount += sizeof(SendDataCmd);

    4822. 

  4822. 

    4823. 

  4823.     /* Parameter Length */

    4824. 

  4824.     memSetEndian(EPS_ENDIAN_LITTLE, EPS_4_BYTES, (EPS_UINT32)paramSize, array4);

    4825. 

  4825.     memcpy(sdBuf + cpyCount, array4, sizeof(array4));

    4826. 

  4826.     cpyCount += sizeof(array4);

    4827. 

  4827.     

    4828. 

  4828.     /* Command Name */

    4829. 

  4829.     memcpy(sdBuf + cpyCount, SendDataName, sizeof(SendDataName));

    4830. 

  4830.     cpyCount += sizeof(SendDataName);

    4831. 

  4831. 

    4832. 

  4832.     /* lXoffset */

    4833. 

  4833.     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)pBandRec->left, array2);

    4834. 

  4834.     memcpy((sdBuf + cpyCount), array2, sizeof(array2));

    4835. 

  4835.     cpyCount += sizeof(array2);

    4836. 

  4836. 

    4837. 

  4837.     /* lYoffset */

    4838. 

  4838. 	memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)pBandRec->top, array2);

    4839. 

  4839.     memcpy((sdBuf + cpyCount), array2, sizeof(array2));

    4840. 

  4840.     cpyCount += sizeof(array2);

    4841. 

  4841.     

    4842. 

  4842.     /* Compression Mode */

    4843. 

  4843.     if(compFlag == EPS_RLE_COMPRESS_DONE){

    4844. 

  4844.         *(sdBuf + cpyCount) = EPS_COMP_RLE;

    4845. 

  4845.     } else{

    4846. 

  4846.         *(sdBuf + cpyCount) = EPS_COMP_NON;

    4847. 

  4847.     }

    4848. 

  4848.     cpyCount += sizeof(EPS_UINT8);

    4849. 

  4849.     

    4850. 

  4850.     /* Raster Data Size */

    4851. 

  4851.     memSetEndian(EPS_ENDIAN_BIG, EPS_2_BYTES, (EPS_UINT32)compDataSize, array2);

    4852. 

  4852.     memcpy((sdBuf + cpyCount), array2, sizeof(array2));

    4853. 

  4853.     cpyCount += sizeof(array2);

    4854. 

  4854. 

    4855. 

  4855.     /* RGB Raster Data */

    4856. 

  4856.     memcpy((sdBuf + cpyCount), compData, compDataSize);

    4857. 

  4857.     cpyCount += compDataSize;

    4858. 

  4858.     

    4859. 

  4859.     if (cmdSize != cpyCount) {

    4860. 

  4860.         EPS_RETURN( EPS_ERR_OPR_FAIL );

    4861. 

  4861.     }

    4862. 

  4862.     

    4863. 

  4863.     

    4864. 

  4864.     /* Send Print Quality Command to Printer */

    4865. 

  4865. /*** -----------------------------------------------------*/

    4866. 

  4866. #if LCOMSW_PACKET_4KB   /* Set 1 packett size in 4096byte */

    4867. 

  4867. /*** -----------------------------------------------------*/

    4868. 

  4868.     if(cmdSize > ESCPR_PACKET_SIZE_4KB) {

    4869. 

  4869.         /* Send 4090 bytes Data                                                         */

    4870. 

  4870.         for(idx = 0; idx < (EPS_INT32)(cmdSize / ESCPR_PACKET_SIZE_4KB); idx++){

    4871. 

  4871. 

    4872. 

  4872. #if ESCPR_DEBUG_IMAGE_LOG

    4873. 

  4873. 			EPS_DUMP(sdBuf, ESCPR_PACKET_SIZE_4KB)

    4874. 

  4874. #endif /*  ESCPR_DEBUG_IMAGE_LOG */

    4875. 

  4875. 

    4876. 

  4876.             retBufSize = 0;

    4877. 

  4877. 

    4878. 

  4878.             retStatus = SendCommand(sdBuf, ESCPR_PACKET_SIZE_4KB, &retBufSize, TRUE);

    4879. 

  4879.             if (!((retStatus == EPS_ERR_NONE) && (ESCPR_PACKET_SIZE_4KB == retBufSize))) {

    4880. 

  4880.                 EPS_RETURN( retStatus );

    4881. 

  4881.             }

    4882. 

  4882.             sdBuf += ESCPR_PACKET_SIZE_4KB;

    4883. 

  4883.         }

    4884. 

  4884.         

    4885. 

  4885.         /* Send Rest Data                                                               */

    4886. 

  4886.         rest_size  = cmdSize - ((EPS_INT32)(cmdSize / ESCPR_PACKET_SIZE_4KB)) * ESCPR_PACKET_SIZE_4KB;

    4887. 

  4887.         retBufSize = 0;

    4888. 

  4888. 

    4889. 

  4889.         retStatus = SendCommand(sdBuf, rest_size, &retBufSize, TRUE);

    4890. 

  4890.         if (!((retStatus == EPS_ERR_NONE) && (rest_size == retBufSize))) {

    4891. 

  4891.             EPS_RETURN( retStatus );

    4892. 

  4892.         }

    4893. 

  4893. 

    4894. 

  4894. #if ESCPR_DEBUG_IMAGE_LOG

    4895. 

  4895. 		EPS_DUMP(sdBuf, rest_size)

    4896. 

  4896. #endif /*  ESCPR_DEBUG_IMAGE_LOG */

    4897. 

  4897. 

    4898. 

  4898.     } else /* if(cmdSize <= ESCPR_PACKET_SIZE_4KB) */{

    4899. 

  4899. 

    4900. 

  4900. #if ESCPR_DEBUG_IMAGE_LOG

    4901. 

  4901. 		EPS_DUMP(sdBuf, cmdSize)

    4902. 

  4902. #endif /*  ESCPR_DEBUG_IMAGE_LOG */

    4903. 

  4903. 

    4904. 

  4904.         retBufSize = 0;

    4905. 

  4905. 

    4906. 

  4906.         retStatus = SendCommand(sdBuf, cmdSize, &retBufSize, TRUE);

    4907. 

  4907.         if (!((retStatus == EPS_ERR_NONE) && (cmdSize == retBufSize))) {

    4908. 

  4908.             EPS_RETURN( retStatus );

    4909. 

  4909.         }

    4910. 

  4910. 

    4911. 

  4911.     }

    4912. 

  4912. 

    4913. 

  4913. /*** -----------------------------------------------------*/

    4914. 

  4914. #else /*  LCOMSW_PACKET_4KB */

    4915. 

  4915. /*** -----------------------------------------------------*/

    4916. 

  4916. 

    4917. 

  4917. #if ESCPR_DEBUG_IMAGE_LOG

    4918. 

  4918. 	EPS_DUMP(sdBuf, cpyCount)

    4919. 

  4919. #endif /*  ESCPR_DEBUG_IMAGE_LOG */

    4920. 

  4920. 

    4921. 

  4921.     retBufSize = 0;

    4922. 

  4922.     retStatus = SendCommand(sdBuf, cmdSize, &retBufSize, TRUE);

    4923. 

  4923.     if (!((retStatus == EPS_ERR_NONE) && (cmdSize == retBufSize))) {

    4924. 

  4924.         EPS_RETURN( retStatus );

    4925. 

  4925.     }

    4926. 

  4926. 

    4927. 

  4927. /*** -----------------------------------------------------*/

    4928. 

  4928. #endif /* LCOMSW_PACKET_4KB */

    4929. 

  4929. /*** -----------------------------------------------------*/

    4930. 

  4930. 

    4931. 

  4931.     EPS_RETURN( EPS_ERR_NONE );

    4932. 

  4932. }

    4933. 

  4933. 

    4934. 

  4934. 

    4935. 

  4935. /*******************************************|********************************************/

    4936. 

  4936. /*                                                                                      */

    4937. 

  4937. /* Function name:   RunLengthEncode()                                                   */

    4938. 

  4938. /*                                                                                      */

    4939. 

  4939. /* Arguments                                                                            */

    4940. 

  4940. /* ---------                                                                            */

    4941. 

  4941. /* Name:        Type:               Description:                                        */

    4942. 

  4942. /* pSrcAddr     const EPS_UINT8*    I: An address of original raster                    */

    4943. 

  4943. /* pDstAddr     EPS_UINT8*          O: An address of compressed raster                  */

    4944. 

  4944. /* pixel        EPS_INT16           I: Original Raster Size                             */

    4945. 

  4945. /* bpp          EPS_UINT8           I: Bytes Per Pixel                                  */

    4946. 

  4946. /* pCompress    EPS_UINT8*          O: Compression Flag                                 */

    4947. 

  4947. /*                                                                                      */

    4948. 

  4948. /* Return value:                                                                        */

    4949. 

  4949. /*      Compressed Data Size (byte)                                                     */

    4950. 

  4950. /*                                                                                      */

    4951. 

  4951. /* Description:                                                                         */

    4952. 

  4952. /*      Runlength Compression for RGB Data.                                             */

    4953. 

  4953. /*                                                                                      */

    4954. 

  4954. /*******************************************|********************************************/

    4955. 

  4955. static EPS_UINT16    RunLengthEncode (

    4956. 

  4956. 

    4957. 

  4957.         const EPS_UINT8*    pSrcAddr,

    4958. 

  4958.         EPS_UINT8*          pDstAddr,

    4959. 

  4959.         EPS_UINT16          pixel,

    4960. 

  4960.         EPS_UINT8           bpp,

    4961. 

  4961.         EPS_UINT8*          pCompress

    4962. 

  4962. 

    4963. 

  4963. ){

    4964. 

  4964. 	const EPS_UINT8* pSrcPos = pSrcAddr;           /* pointer to srcBuffer               */

    4965. 

  4965. 	EPS_UINT8*   pDstPos     = pDstAddr;           /* pointer to destBuffer              */

    4966. 

  4966.     EPS_UINT16   srcCnt      = 0;                  /* counter                            */

    4967. 

  4967.     EPS_UINT16   repCnt      = 0;                  /* replay conter                      */

    4968. 

  4968.     EPS_UINT16   retCnt      = 0;                  /* conpressed data size               */

    4969. 

  4969.     EPS_UINT32   copySize    = 0;

    4970. 

  4970.     EPS_UINT16   widthPixels = pixel * bpp;

    4971. 

  4971. 	EPS_BOOL     bCompress   = TRUE;

    4972. 

  4972. 

    4973. 

  4973. 	EPS_LOG_FUNCIN;

    4974. 

  4974. int i_index = 0;

    4975. 

  4975.     while (srcCnt < pixel) {

    4976. 

  4976.         /* In case of replay data                                                       */

    4977. 

  4977.         if ((srcCnt + 1 < pixel) && (!memcmp(pSrcPos, pSrcPos + bpp, bpp))) {

    4978. 

  4978.             repCnt = 2;

    4979. 

  4979.             while ((srcCnt + repCnt < pixel)                                              &&

    4980. 

  4980.                    (repCnt < 0x81)                                                        &&

    4981. 

  4981.                    (!memcmp(pSrcPos + (repCnt - 1) * bpp, pSrcPos + repCnt * bpp, bpp))    ) {

    4982. 

  4982.                 repCnt++;

    4983. 

  4983.             }

    4984. 

  4984. 		

    4985. 

  4985.             /* Renewal compressed data size counter */

    4986. 

  4986.             retCnt += 1 + bpp;

    4987. 

  4987. 

    4988. 

  4988. 			/* If compressed data size is bigger than original data size,               */

    4989. 

  4989. 			/* stop compression process.                                                */

    4990. 

  4990. 			if( retCnt > widthPixels ){

    4991. 

  4991. 				bCompress  = FALSE;

    4992. 

  4992. 				retCnt -= 1 + bpp;		/* rewind counter */

    4993. 

  4993. 				break;

    4994. 

  4994. 			}

    4995. 

  4995. 

    4996. 

  4996. 			/* Set replay count and data                                                */

    4997. 

  4997.             /* Set data counter                     */

    4998. 

  4998.              if(pDstPos == NULL || (pDstPos+1) == NULL || (pDstPos + bpp) == NULL || pSrcPos == NULL ||( pSrcPos + bpp * repCnt) == NULL){

    4999. 

  4999.             	return i_index * (-1);

    5000. 

  5000.             }

    5001. 

  5001.             *pDstPos++ = (EPS_UINT8)(0xFF - repCnt + 2 );

    5002. 

  5002.             

    5003. 

  5003.             /* Set data                             */

    5004. 

  5004.             memcpy(pDstPos, pSrcPos, bpp);

    5005. 

  5005. 

    5006. 

  5006.             /* Renewal data size counter            */

    5007. 

  5007.             srcCnt += repCnt;

    5008. 

  5008.             i_index += bpp * repCnt;

    5009. 

  5009. 

    5010. 

  5010.             /* Renewal original data address        */

    5011. 

  5011.             if((pSrcPos + bpp * repCnt) == NULL){

    5012. 

  5012.             	return i_index * (-1);

    5013. 

  5013.             }

    5014. 

  5014.             pSrcPos += bpp * repCnt;

    5015. 

  5015. 

    5016. 

  5016.             /* Renewal compressed data address      */

    5017. 

  5017.             pDstPos += bpp;

    5018. 

  5018. 

    5019. 

  5019. 

    5020. 

  5020.         }

    5021. 

  5021. 

    5022. 

  5022.         /* In case of non replay data                                                   */

    5023. 

  5023.         else {

    5024. 

  5024.             copySize = 0;

    5025. 

  5025.             repCnt   = 1;

    5026. 

  5026. 

    5027. 

  5027.             /* compare next data with next and next data                                */

    5028. 

  5028.             while ((srcCnt + repCnt + 1< pixel)                                          &&

    5029. 

  5029.                    (repCnt < 0x80)                                                       &&

    5030. 

  5030.                    (memcmp(pSrcPos + repCnt * bpp, pSrcPos + (repCnt + 1) * bpp, bpp))    ){

    5031. 

  5031.                 repCnt++;

    5032. 

  5032.             }

    5033. 

  5033.             

    5034. 

  5034.             /* Renewal compressed data size counter */

    5035. 

  5035.             retCnt += 1 + repCnt * bpp;

    5036. 

  5036. 

    5037. 

  5037. 			/* If compressed data size is bigger than original data size,               */

    5038. 

  5038. 			/* stop compression process.                                                */

    5039. 

  5039. 			if( retCnt > widthPixels ){

    5040. 

  5040. 				bCompress  = FALSE;

    5041. 

  5041. 				retCnt -= 1 + repCnt * bpp;	/* rewind counter */

    5042. 

  5042. 				break;

    5043. 

  5043. 			}

    5044. 

  5044. 

    5045. 

  5045. 			/* Set data counter                     */

    5046. 

  5046. 			if(pDstPos == NULL || (pDstPos +1) == NULL){

    5047. 

  5047. 				return i_index *(-1);

    5048. 

  5048. 			}

    5049. 

  5049.             *pDstPos++ = (EPS_UINT8)(repCnt - 1);

    5050. 

  5050.             /* Renewal data size counter            */

    5051. 

  5051. 

    5052. 

  5052.             /* Size of non replay data (byte)       */

    5053. 

  5053.             srcCnt  += repCnt;

    5054. 

  5054.             copySize = (EPS_UINT32)(repCnt * bpp);

    5055. 

  5055. 		if(pDstPos == NULL || (pDstPos +1) == NULL || (pDstPos + copySize) == NULL || (pSrcPos + copySize) == NULL || pSrcPos == NULL){

    5056. 

  5056.             			return i_index * (-1);

    5057. 

  5057.             		}

    5058. 

  5058.             		

    5059. 

  5059.             /* Set data                             */

    5060. 

  5060.             memcpy(pDstPos, pSrcPos, copySize);

    5061. 

  5061. 

    5062. 

  5062.             /* Renewal original data address        */

    5063. 

  5063.             pSrcPos += copySize;

    5064. 

  5064. 

    5065. 

  5065.             /* Renewal compressed data address      */

    5066. 

  5066.             pDstPos += copySize;

    5067. 

  5067.             i_index += copySize;

    5068. 

  5068.         }

    5069. 

  5069.     }

    5070. 

  5070. 

    5071. 

  5071. 	if(TRUE == bCompress){

    5072. 

  5072. 	    *pCompress = EPS_RLE_COMPRESS_DONE;

    5073. 

  5073. 	} else{

    5074. 

  5074. 		retCnt = widthPixels;

    5075. 

  5075. 		memcpy(pDstAddr, pSrcAddr, widthPixels);

    5076. 

  5076. 	    *pCompress = EPS_RLE_COMPRESS_NOT_DONE;

    5077. 

  5077. 	}

    5078. 

  5078.     

    5079. 

  5079.     EPS_RETURN( retCnt );

    5080. 

  5080. }

    5081. 

  5081. 

    5082. 

  5082. 

    5083. 

  5083. /*******************************************|********************************************/

    5084. 

  5084. /*                                                                                      */

    5085. 

  5085. /* Function name:   CreateMediaInfo()                                                   */

    5086. 

  5086. /*                                                                                      */

    5087. 

  5087. /* Arguments                                                                            */

    5088. 

  5088. /* ---------                                                                            */

    5089. 

  5089. /* Name:            Type:               Description:									*/

    5090. 

  5090. /* innerPrinter     EPS_PRINTER_INN*    I: printer that it has original structure		*/

    5091. 

  5091. /* pmString			EPS_INT8*			I: PM reply string								*/

    5092. 

  5092. /* pmSize			EPS_INT32			I: size of PM reply string						*/

    5093. 

  5093. /*                                                                                      */

    5094. 

  5094. /* Return value:                                                                        */

    5095. 

  5095. /*      EPS_ERR_NONE                    - Success                                       */

    5096. 

  5096. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    5097. 

  5097. /*      EPS_ERR_MEMORY_ALLOCATION       - Alloc memory failed                           */

    5098. 

  5098. /*                                                                                      */

    5099. 

  5099. /* Description:                                                                         */

    5100. 

  5100. /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */

    5101. 

  5101. /*                                                                                      */

    5102. 

  5102. /*******************************************|********************************************/

    5103. 

  5103. EPS_ERR_CODE    CreateMediaInfo(

    5104. 

  5104. 	

    5105. 

  5105. 		EPS_PRINTER_INN*	innerPrinter,

    5106. 

  5106. 		EPS_UINT8*			pmString,

    5107. 

  5107. 		EPS_INT32			pmSize

    5108. 

  5108. 	

    5109. 

  5109. ){

    5110. 

  5110. 	EPS_ERR_CODE	retStatus = EPS_ERR_NONE;

    5111. 

  5111.     EPS_UINT8*      cmdField;                   /* Pointer of pm command field          */

    5112. 

  5112.     EPS_INT32       pmIdx;                      /* pm string index                      */

    5113. 

  5113.     EPS_UINT32      idx;                        /* Index                                */

    5114. 

  5114.     EPS_INT32       sIdx = 0;                   /* Media size index                     */

    5115. 

  5115.     EPS_INT32       tIdx = 0;                   /* Media type index                     */

    5116. 

  5116.     EPS_INT32       num_mType = 0;              /* Media type number                    */

    5117. 

  5117.     EPS_INT32       num_mSize = 0;              /* Media size number                    */

    5118. 

  5118. 	EPS_BOOL		extPaper = FALSE;			/* extend paper source is exist         */

    5119. 

  5119. 

    5120. 

  5120. 	EPS_LOG_FUNCIN;

    5121. 

  5121. 

    5122. 

  5122. 	/*** Is this really "PM" data                                                       */

    5123. 

  5123. 	cmdField = (EPS_UINT8*)strstr((const char*)pmString,"PM");

    5124. 

  5124. 	if (cmdField == NULL ) {

    5125. 

  5125. 		EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n",pmString));

    5126. 

  5126. 		EPS_RETURN( EPS_ERR_OPR_FAIL );

    5127. 

  5127. 	}

    5128. 

  5128. EPS_DUMP(pmString, 256);

    5129. 

  5129. 

    5130. 

  5130. #if _VALIDATE_SUPPORTED_MEDIA_DATA_

    5131. 

  5131. 	if(innerPrinter->supportedMedia.numSizes != -1){

    5132. 

  5132. 		/*** "Filter" Raw "PM" data (Remake the correct pm stirng)                      */

    5133. 

  5133. 		retStatus = _SP_ChangeSpec_UpdatePMReply(innerPrinter, pmString, pmSize);

    5134. 

  5134. 		if (retStatus != EPS_ERR_NONE) {

    5135. 

  5135. 			EPS_RETURN( retStatus );

    5136. 

  5136. 		}

    5137. 

  5137. 	}

    5138. 

  5138. #else

    5139. 

  5139. /*** "Filter" Raw "PM" data (Remake the correct pm stirng)                              */

    5140. 

  5140.     retStatus = _SP_ChangeSpec_UpdatePMReply(innerPrinter, pmString, pmSize);

    5141. 

  5141.     if (retStatus != EPS_ERR_NONE) {

    5142. 

  5142.         EPS_RETURN( EPS_ERR_OPR_FAIL );  /* Invalid format */

    5143. 

  5143.     }

    5144. 

  5144. #endif

    5145. 

  5145. 

    5146. 

  5146. /*** Create the structure of the support media                                          */

    5147. 

  5147. 	innerPrinter->supportedMedia.resolution = EPS_IR_360X360;	/* default support */

    5148. 

  5148. 

    5149. 

  5149.     /*** Count "Paper Size" field  & check format */

    5150. 

  5150. 	pmIdx = EPS_PM_HEADER_LEN;				/* skip the command header of pm string     */

    5151. 

  5151.     while( pmIdx < EPS_PM_MAXSIZE ) {

    5152. 

  5152.         switch(pmString[pmIdx]) {

    5153. 

  5153. 		case 'R':

    5154. 

  5154. 			if( 720 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){

    5155. 

  5155. 				innerPrinter->supportedMedia.resolution |= EPS_IR_720X720;

    5156. 

  5156. 			} else if( 600 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){

    5157. 

  5157. 				innerPrinter->supportedMedia.resolution |= EPS_IR_300X300 | EPS_IR_600X600;

    5158. 

  5158. 			} else if( 300 == ((pmString[pmIdx+1] << 8) + pmString[pmIdx+2]) ){

    5159. 

  5159. 				innerPrinter->supportedMedia.resolution |= EPS_IR_300X300;

    5160. 

  5160. 			}

    5161. 

  5161. 			pmIdx += 6;

    5162. 

  5162. 			break;

    5163. 

  5163. 

    5164. 

  5164. 		case 'M':

    5165. 

  5165. 			innerPrinter->supportedMedia.JpegSizeLimit = 

    5166. 

  5166. 				(pmString[pmIdx+1] << 24) + (pmString[pmIdx+2] << 16) + (pmString[pmIdx+3] << 8) + pmString[pmIdx+4]; 

    5167. 

  5167. 			innerPrinter->JpgMax = innerPrinter->supportedMedia.JpegSizeLimit;

    5168. 

  5168. 			pmIdx += 6;

    5169. 

  5169. 			break;

    5170. 

  5170. 

    5171. 

  5171. 		case 'S':

    5172. 

  5172. 			/* move T field */

    5173. 

  5173. 			if(pmIdx < EPS_PM_MAXSIZE-2){

    5174. 

  5174. 				pmIdx += 2;

    5175. 

  5175. 			} else{

    5176. 

  5176. 				EPS_RETURN( EPS_ERR_OPR_FAIL );

    5177. 

  5177. 			}

    5178. 

  5178. 

    5179. 

  5179. 			num_mSize++;

    5180. 

  5180. 

    5181. 

  5181. 			for(; pmIdx < EPS_PM_MAXSIZE-4; pmIdx += 4) {	/* 4 = T x x / */

    5182. 

  5182. 				if(pmString[pmIdx] == '/'){

    5183. 

  5183. 					pmIdx += 1;

    5184. 

  5184. 					break;

    5185. 

  5185. 				} else if(pmString[pmIdx] != 'T') {

    5186. 

  5186. 					EPS_RETURN( EPS_ERR_OPR_FAIL );

    5187. 

  5187. 				}

    5188. 

  5188. 			}

    5189. 

  5189. 			if(pmIdx >= EPS_PM_MAXSIZE-4){

    5190. 

  5190. 				EPS_RETURN( EPS_ERR_OPR_FAIL );

    5191. 

  5191. 			}

    5192. 

  5192. 			break;

    5193. 

  5193. 

    5194. 

  5194. 		default:

    5195. 

  5195. 			EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5196. 

  5196. 		}

    5197. 

  5197. 

    5198. 

  5198. 		/* If we run into an occurrence of carriage return followed by line feed,

    5199. 

  5199. 		 * we have found the terminating characters of the string. */

    5200. 

  5200. 		if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {

    5201. 

  5201. 			break;

    5202. 

  5202. 		}

    5203. 

  5203. 	}                      

    5204. 

  5204. 	if(pmIdx >= EPS_PM_MAXSIZE){

    5205. 

  5205. 		EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5206. 

  5206. 	}

    5207. 

  5207.     

    5208. 

  5208.     /* Allocate memory for the media size list. */

    5209. 

  5209.     innerPrinter->supportedMedia.sizeList =

    5210. 

  5210.             (EPS_MEDIA_SIZE*)EPS_ALLOC( sizeof(EPS_MEDIA_SIZE) * num_mSize );   

    5211. 

  5211.     if( innerPrinter->supportedMedia.sizeList == NULL ){

    5212. 

  5212.         EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );

    5213. 

  5213.     }

    5214. 

  5214. 	memset(innerPrinter->supportedMedia.sizeList, 0, sizeof(EPS_MEDIA_SIZE) * num_mSize);

    5215. 

  5215.     innerPrinter->supportedMedia.numSizes = num_mSize;

    5216. 

  5216.     

    5217. 

  5217. 	pmIdx = EPS_PM_HEADER_LEN;				/* skip the command header of pm string     */

    5218. 

  5218.     for(sIdx = 0; sIdx < num_mSize; sIdx++) {

    5219. 

  5219. 		if(pmString[pmIdx] == 'M' || pmString[pmIdx] == 'R') {

    5220. 

  5220. 			pmIdx += 6;

    5221. 

  5221. 			sIdx--;

    5222. 

  5222. 			continue;

    5223. 

  5223. 		}

    5224. 

  5224. 

    5225. 

  5225.         innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID = pmString[pmIdx+1];

    5226. 

  5226. /*		EPS_DBGPRINT(("Size=%d\r\n", pmString[pmIdx+1]));*/

    5227. 

  5227. 		pmIdx += 2;

    5228. 

  5228. 

    5229. 

  5229.         /* For the given paper type, iterate through the paper type to get the number

    5230. 

  5230.          * of media types contained in it */

    5231. 

  5231.         num_mType = 0;

    5232. 

  5232. 		for(idx = pmIdx; idx < EPS_PM_MAXSIZE-4; idx += 4) {

    5233. 

  5233. 			if(pmString[idx] == '/'){

    5234. 

  5234. 				idx += 1;

    5235. 

  5235. 				break;

    5236. 

  5236. 			}

    5237. 

  5237. 			num_mType++;

    5238. 

  5238. 		}

    5239. 

  5239. 

    5240. 

  5240.         /* Allocate memory for the media type array. */

    5241. 

  5241.         innerPrinter->supportedMedia.sizeList[sIdx].typeList = 

    5242. 

  5242.             (EPS_MEDIA_TYPE*)EPS_ALLOC( sizeof(EPS_MEDIA_TYPE) * num_mType );

    5243. 

  5243.         

    5244. 

  5244.         if (innerPrinter->supportedMedia.sizeList[sIdx].typeList == NULL) {

    5245. 

  5245.             EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );

    5246. 

  5246.         }

    5247. 

  5247.         

    5248. 

  5248. 		memset(innerPrinter->supportedMedia.sizeList[sIdx].typeList, 0, sizeof(EPS_MEDIA_TYPE) * num_mType);

    5249. 

  5249.         innerPrinter->supportedMedia.sizeList[sIdx].numTypes = num_mType;

    5250. 

  5250. 

    5251. 

  5251. 		for(tIdx = 0; tIdx < num_mType; tIdx++) {

    5252. 

  5252.             innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].mediaTypeID       = pmString[pmIdx+1];

    5253. 

  5253. /*            EPS_DBGPRINT(("\tType=%d (%02X)\r\n", pmString[pmIdx+1], pmString[pmIdx+2]));*/

    5254. 

  5254.                                

    5255. 

  5255.             /* Bitwise OR with 10000000 - Check for borderless */

    5256. 

  5256.             if( pmString[pmIdx+2] & 0x80 ){

    5257. 

  5257.                 innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].layout |= EPS_MLID_BORDERLESS;

    5258. 

  5258.             }

    5259. 

  5259.             /* Bitwise OR with 01000000 - Check for border "disable" mode */

    5260. 

  5260.             if( !(pmString[pmIdx+2] & 0x40) ){

    5261. 

  5261. 				innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].layout |= EPS_MLID_BORDERS;

    5262. 

  5262.             }

    5263. 

  5263. 

    5264. 

  5264.             /* set quality */

    5265. 

  5265.             innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].quality |= (pmString[pmIdx+2] & EPS_MQID_ALL);

    5266. 

  5266. 

    5267. 

  5267. 			/* set duplex */

    5268. 

  5268.             if( pmString[pmIdx+2] & 0x10 &&

    5269. 

  5269. 				obsEnableDuplex(innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID) ){

    5270. 

  5270. 				innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].duplex = EPS_DUPLEX_ENABLE;/*EPS_DUPLEX_SHORT*/;

    5271. 

  5271. 			} else{

    5272. 

  5272. 				innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].duplex = EPS_DUPLEX_DISABLE;

    5273. 

  5273. 			}

    5274. 

  5274. 

    5275. 

  5275. 			/* Bitwise OR with 00001000 - Check for extend paper source */

    5276. 

  5276. #if _VALIDATE_SUPPORTED_MEDIA_DATA_

    5277. 

  5277.             if( pmString[pmIdx+2] & 0x08 ){

    5278. 

  5278.                 extPaper = TRUE;

    5279. 

  5279. 			} else {

    5280. 

  5280. 				/* DEFAULT. All printer support rear paper source */

    5281. 

  5281. 				innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].paperSource = EPS_MPID_REAR;

    5282. 

  5282. 			}

    5283. 

  5283. 

    5284. 

  5284. 			/* param2 value check */

    5285. 

  5285. 			if( !(pmString[pmIdx+2] & (0x01 | 0x02 | 0x04)) ){

    5286. 

  5286. 				printf("\n\n!!!!!!!!!  Quality is not described. !!!!!!!!!\n"

    5287. 

  5287. 						"SizeID=0x%02X / TypeID=0x%02X / param2=0x%02X\n", 

    5288. 

  5288. 						innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID,

    5289. 

  5289. 						pmString[pmIdx+1], pmString[pmIdx+2]);

    5290. 

  5290. 			} 

    5291. 

  5291. 			if( !(pmString[pmIdx+2] & 0x80) && (pmString[pmIdx+2] & 0x40) ){

    5292. 

  5292. 				printf("\n\n!!!!!!!!!  Layout is not described. !!!!!!!!!\n"

    5293. 

  5293. 						"SizeID=0x%02X / TypeID=0x%02X / param2=0x%02X\n", 

    5294. 

  5294. 						innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID,

    5295. 

  5295. 						pmString[pmIdx+1], pmString[pmIdx+2]);

    5296. 

  5296. 			}

    5297. 

  5297. 

    5298. 

  5298. #else

    5299. 

  5299.             if( pmString[pmIdx+2] & 0x08 ){

    5300. 

  5300.                 extPaper = TRUE;

    5301. 

  5301. 			}

    5302. 

  5302. 			/* DEFAULT. All printer support rear paper source */

    5303. 

  5303. 			innerPrinter->supportedMedia.sizeList[sIdx].typeList[tIdx].paperSource = EPS_MPID_REAR;

    5304. 

  5304. #endif

    5305. 

  5305. 			pmIdx += 4;	/* move next field */

    5306. 

  5306. 		}

    5307. 

  5307. 		pmIdx += 1;	/* skip terminater */

    5308. 

  5308. 	}

    5309. 

  5309. 

    5310. 

  5310. /*** Add extend infomation                                                              */

    5311. 

  5311. 	if( EPS_ERR_NONE == retStatus && TRUE == extPaper ){

    5312. 

  5312. 		retStatus = GetPaperSource(innerPrinter);

    5313. 

  5313. 		if( EPS_ERR_NONE != retStatus){

    5314. 

  5314. 			prtClearSupportedMedia(innerPrinter);

    5315. 

  5315. 		}

    5316. 

  5316. 	}

    5317. 

  5317. 

    5318. 

  5318. 	serAppendMedia(&innerPrinter->supportedMedia);

    5319. 

  5319. 

    5320. 

  5320. 	EPS_RETURN( retStatus );

    5321. 

  5321. }

    5322. 

  5322. 

    5323. 

  5323. 

    5324. 

  5324. /*******************************************|********************************************/

    5325. 

  5325. /*                                                                                      */

    5326. 

  5326. /* Function name:   GetPaperSource()                                                    */

    5327. 

  5327. /*                                                                                      */

    5328. 

  5328. /* Arguments                                                                            */

    5329. 

  5329. /* ---------                                                                            */

    5330. 

  5330. /* Name:            Type:                  Description:                                 */

    5331. 

  5331. /* innerPrinter     EPS_PRINTER_INN*       I: printer that it has original structure    */

    5332. 

  5332. /*                                                                                      */

    5333. 

  5333. /* Return value:                                                                        */

    5334. 

  5334. /*      EPS_ERR_NONE                    - Success                                       */

    5335. 

  5335. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    5336. 

  5336. /*                                                                                      */

    5337. 

  5337. /* Description:                                                                         */

    5338. 

  5338. /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */

    5339. 

  5339. /*                                                                                      */

    5340. 

  5340. /*******************************************|********************************************/

    5341. 

  5341. EPS_ERR_CODE    GetPaperSource(

    5342. 

  5342. 	

    5343. 

  5343. 		EPS_PRINTER_INN*		innerPrinter

    5344. 

  5344. 	

    5345. 

  5345. ){

    5346. 

  5346. 	EPS_ERR_CODE	ret = EPS_ERR_NONE;

    5347. 

  5347.     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */

    5348. 

  5348.     EPS_INT32       pmSize = EPS_PM_MAXSIZE;

    5349. 

  5349.     EPS_UINT32      pmIdx;                      /* pm string index                      */

    5350. 

  5350.     EPS_INT32       sIdx = 0;                   /* Media size index                     */

    5351. 

  5351.     EPS_INT32       tIdx = 0;                   /* Media type index                     */

    5352. 

  5352. 	EPS_MEDIA_SIZE  *pMSize = NULL;

    5353. 

  5353. 

    5354. 

  5354. 	EPS_LOG_FUNCIN;

    5355. 

  5355. 

    5356. 

  5356. 	/* Clear the Printer Model Information (Media data or "PM" data)                    */

    5357. 

  5357.     memset(pmString, 0, EPS_PM_MAXSIZE);

    5358. 

  5358. 

    5359. 

  5359. /*** Get PM2 from Printer                                                               */

    5360. 

  5360. 	ret = prtGetPMString(innerPrinter, 2, pmString, &pmSize);

    5361. 

  5361. 	if(ret == EPS_ERR_PROTOCOL_NOT_SUPPORTED){

    5362. 

  5362. 		EPS_RETURN( EPS_ERR_NONE );

    5363. 

  5363. 	} else if(ret != EPS_ERR_NONE){

    5364. 

  5364. 		EPS_RETURN( ret );

    5365. 

  5365. 	}

    5366. 

  5366. 

    5367. 

  5367. 	/*** Is this really "PM" data                                                       */

    5368. 

  5368. 	if( strstr((const char*)pmString, "PM") == NULL ) {

    5369. 

  5369. 		EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n", pmString));

    5370. 

  5370. 		EPS_RETURN( EPS_ERR_OPR_FAIL );

    5371. 

  5371. 	}

    5372. 

  5372. 

    5373. 

  5373. 	/* Delete the command header of pm string                                           */

    5374. 

  5374. 	pmIdx = EPS_PM_HEADER_LEN;				/* skip the command header of pm string     */

    5375. 

  5375. 

    5376. 

  5376. /*** Check to make sure the PM reply has a valid beginning                              */

    5377. 

  5377.     if(pmString[pmIdx] != 'S' && pmString[pmIdx+2] != 'T') {

    5378. 

  5378.         EPS_RETURN( EPS_ERR_OPR_FAIL );

    5379. 

  5379.     }

    5380. 

  5380.     

    5381. 

  5381. /*** Create the structure of the support media                                          */

    5382. 

  5382.     /*** Count "Paper Size" field  & check format */

    5383. 

  5383.     for(; pmIdx < EPS_PM_MAXSIZE-7; ) {		/* 7 = S x T x x // */

    5384. 

  5384.         if(pmString[pmIdx] != 'S') {

    5385. 

  5385. 			EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5386. 

  5386. 		}

    5387. 

  5387. 		

    5388. 

  5388. 		/* search size ID */

    5389. 

  5389. 		pmIdx++;

    5390. 

  5390. 		pMSize = NULL;

    5391. 

  5391. 	    for(sIdx = 0; sIdx < innerPrinter->supportedMedia.numSizes; sIdx++){

    5392. 

  5392. 			if(pmString[pmIdx] == innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID){

    5393. 

  5393. 				pMSize = &innerPrinter->supportedMedia.sizeList[sIdx];

    5394. 

  5394. /*				EPS_DBGPRINT(("Size = %d\n", innerPrinter->supportedMedia.sizeList[sIdx].mediaSizeID))*/

    5395. 

  5395. 				break;

    5396. 

  5396. 			}

    5397. 

  5397. 		}

    5398. 

  5398. 

    5399. 

  5399. 		pmIdx++;	/* move next field */

    5400. 

  5400. 

    5401. 

  5401. 		while( pmIdx < EPS_PM_MAXSIZE-4 ){	/* 4 = T x x / */

    5402. 

  5402. 			if(pmString[pmIdx] == 'T'){

    5403. 

  5403. 				if(NULL != pMSize){

    5404. 

  5404. 					/* search type ID */

    5405. 

  5405. 					pmIdx++;

    5406. 

  5406. 					for(tIdx = 0; tIdx < pMSize->numTypes; tIdx++){

    5407. 

  5407. 						if(pmString[pmIdx] == pMSize->typeList[tIdx].mediaTypeID){

    5408. 

  5408. 							pMSize->typeList[tIdx].paperSource = pmString[pmIdx+1];

    5409. 

  5409. #if !_VALIDATE_SUPPORTED_MEDIA_DATA_

    5410. 

  5410. 							pMSize->typeList[tIdx].paperSource &= EPS_MPID_ALL_ESCPR;

    5411. 

  5411. #endif

    5412. 

  5412. 							pmIdx += 3;

    5413. 

  5413. 							break;

    5414. 

  5414. 						}

    5415. 

  5415. 					}

    5416. 

  5416. 					if(tIdx >= pMSize->numTypes){

    5417. 

  5417. 						/* Skip unknown T */

    5418. 

  5418. #if _VALIDATE_SUPPORTED_MEDIA_DATA_

    5419. 

  5419. 						printf("\n\n!!!!!!!!! pm2 contains TypeID(0x%02X) that doesn't exist in pm1.  !!!!!!!!!\n", pmString[pmIdx]);

    5420. 

  5420. #endif

    5421. 

  5421. 						pmIdx += 3;

    5422. 

  5422. 					}

    5423. 

  5423. 				} else{

    5424. 

  5424. 					/* Skip unknown S */

    5425. 

  5425. #if _VALIDATE_SUPPORTED_MEDIA_DATA_

    5426. 

  5426. 						printf("\n\n!!!!!!!!! pm2 contains SizeID(0x%02X) that doesn't exist in pm1.  !!!!!!!!!\n", pmString[pmIdx]);

    5427. 

  5427. #endif

    5428. 

  5428. 					pmIdx += 4;

    5429. 

  5429. 				}

    5430. 

  5430. 			} else if(pmString[pmIdx] == '/') {

    5431. 

  5431. 				pmIdx++;

    5432. 

  5432. 				break;

    5433. 

  5433. 			} else{

    5434. 

  5434. 				EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5435. 

  5435. 			}

    5436. 

  5436. 		}

    5437. 

  5437. 		if(pmIdx >= EPS_PM_MAXSIZE-4){

    5438. 

  5438. 			EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5439. 

  5439. 		}

    5440. 

  5440. 		

    5441. 

  5441. 		/* If we run into an occurrence of carriage return followed by line feed,

    5442. 

  5442. 		 * we have found the terminating characters of the string. */

    5443. 

  5443. 		if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {

    5444. 

  5444. 			break;

    5445. 

  5445. 		}

    5446. 

  5446. 	}                      

    5447. 

  5447. 	if(pmIdx >= EPS_PM_MAXSIZE){

    5448. 

  5448. 		EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5449. 

  5449. 	}

    5450. 

  5450. 

    5451. 

  5451. 	EPS_RETURN( ret );

    5452. 

  5452. }

    5453. 

  5453. 

    5454. 

  5454. 

    5455. 

  5455. /*******************************************|********************************************/

    5456. 

  5456. /*                                                                                      */

    5457. 

  5457. /* Function name:   GetJpgMax()                                                         */

    5458. 

  5458. /*                                                                                      */

    5459. 

  5459. /* Arguments                                                                            */

    5460. 

  5460. /* ---------                                                                            */

    5461. 

  5461. /* Name:            Type:                  Description:                                 */

    5462. 

  5462. /* innerPrinter     EPS_PRINTER_INN*       IO: printer that it has original structure   */

    5463. 

  5463. /*                                                                                      */

    5464. 

  5464. /* Return value:                                                                        */

    5465. 

  5465. /*      EPS_ERR_NONE                    - Success                                       */

    5466. 

  5466. /*      EPS_ERR_OPR_FAIL                - Internal Error                                */

    5467. 

  5467. /*                                                                                      */

    5468. 

  5468. /* Description:                                                                         */

    5469. 

  5469. /*      Marge paper source to EPS_SUPPORTED_MEDIA.                                      */

    5470. 

  5470. /*                                                                                      */

    5471. 

  5471. /*******************************************|********************************************/

    5472. 

  5472. EPS_ERR_CODE    GetJpgMax(

    5473. 

  5473. 	

    5474. 

  5474. 		EPS_PRINTER_INN*		printer

    5475. 

  5475. 	

    5476. 

  5476. ){

    5477. 

  5477. 	EPS_ERR_CODE	ret = EPS_ERR_NONE;

    5478. 

  5478.     EPS_UINT8       pmString[EPS_PM_MAXSIZE];   /* Retrieved PM data from printer       */

    5479. 

  5479.     EPS_INT32       pmSize = EPS_PM_MAXSIZE;

    5480. 

  5480.     EPS_UINT32      pmIdx;                      /* pm string index                      */

    5481. 

  5481. 

    5482. 

  5482. 	EPS_LOG_FUNCIN;

    5483. 

  5483. 

    5484. 

  5484. 	if( !EPS_IS_BI_PROTOCOL(printJob.printer->protocol) ){	/* Uni direction */

    5485. 

  5485. 		/* set unlimited(2GB) */

    5486. 

  5486. 		printer->JpgMax = EPS_JPEG_SIZE_UNLIMIT;

    5487. 

  5487. 		EPS_RETURN( EPS_ERR_NONE )

    5488. 

  5488. 	}

    5489. 

  5489. 

    5490. 

  5490. 	/* Clear the Printer Model Information (Media data or "PM" data)                    */

    5491. 

  5491.     memset(pmString, 0, EPS_PM_MAXSIZE);

    5492. 

  5492. 

    5493. 

  5493. /*** Get PM1 from Printer                                                               */

    5494. 

  5494. 	ret = prtGetPMString(printer, 1, pmString, &pmSize);

    5495. 

  5495. 	if(ret == EPS_ERR_PROTOCOL_NOT_SUPPORTED){

    5496. 

  5496. 		/* set unlimited(2GB) */

    5497. 

  5497. 		printer->JpgMax = EPS_JPEG_SIZE_UNLIMIT;

    5498. 

  5498. 		EPS_RETURN( EPS_ERR_NONE )

    5499. 

  5499. 	} else if(ret != EPS_ERR_NONE){

    5500. 

  5500. 		EPS_RETURN( ret );

    5501. 

  5501. 	}

    5502. 

  5502. 

    5503. 

  5503. /*** "Filter" Raw "PM" data (Remake the correct pm stirng)                              */

    5504. 

  5504.     ret = _SP_ChangeSpec_UpdatePMReply(printer, pmString, pmSize);

    5505. 

  5505.     if (ret != EPS_ERR_NONE) {

    5506. 

  5506.         EPS_RETURN( EPS_ERR_OPR_FAIL );  /* Invalid format */

    5507. 

  5507.     }

    5508. 

  5508. 

    5509. 

  5509. 	/*** Is this really "PM" data                                                       */

    5510. 

  5510. 	if( strstr((const char*)pmString, "PM") == NULL ) {

    5511. 

  5511. 		EPS_DBGPRINT(("Get Model Info faild : ModelInfo = [%s]\r\n", pmString));

    5512. 

  5512. 		EPS_RETURN( EPS_ERR_OPR_FAIL );

    5513. 

  5513. 	}

    5514. 

  5514. 

    5515. 

  5515. 	/* Delete the command header of pm string                                           */

    5516. 

  5516. 	pmIdx = EPS_PM_HEADER_LEN;				/* skip the command header of pm string     */

    5517. 

  5517.     while( pmIdx < EPS_PM_MAXSIZE ) {

    5518. 

  5518.         switch(pmString[pmIdx]) {

    5519. 

  5519. 		case 'M':

    5520. 

  5520. 			printer->JpgMax = 

    5521. 

  5521. 				(pmString[pmIdx+1] << 24) + (pmString[pmIdx+2] << 16) + (pmString[pmIdx+3] << 8) + pmString[pmIdx+4]; 

    5522. 

  5522. 

    5523. 

  5523. 			pmIdx += 6;

    5524. 

  5524. 			break;

    5525. 

  5525. 

    5526. 

  5526. 		case 'R':

    5527. 

  5527. 			pmIdx += 6;

    5528. 

  5528. 			break;

    5529. 

  5529. 

    5530. 

  5530. 		case 'S':

    5531. 

  5531. 			/* move T field */

    5532. 

  5532. 			if(pmIdx < EPS_PM_MAXSIZE-2){

    5533. 

  5533. 				pmIdx += 2;

    5534. 

  5534. 			} else{

    5535. 

  5535. 				EPS_RETURN( EPS_ERR_OPR_FAIL );

    5536. 

  5536. 			}

    5537. 

  5537. 

    5538. 

  5538. 			for(; pmIdx < EPS_PM_MAXSIZE-4; pmIdx += 4) {	/* 4 = T x x / */

    5539. 

  5539. 				if(pmString[pmIdx] == '/'){

    5540. 

  5540. 					pmIdx += 1;

    5541. 

  5541. 					break;

    5542. 

  5542. 				} else if(pmString[pmIdx] != 'T') {

    5543. 

  5543. 					EPS_RETURN( EPS_ERR_OPR_FAIL );

    5544. 

  5544. 				}

    5545. 

  5545. 			}

    5546. 

  5546. 			if(pmIdx >= EPS_PM_MAXSIZE-4){

    5547. 

  5547. 				EPS_RETURN( EPS_ERR_OPR_FAIL );

    5548. 

  5548. 			}

    5549. 

  5549. 			break;

    5550. 

  5550. 

    5551. 

  5551. 		default:

    5552. 

  5552. 			EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5553. 

  5553. 		}

    5554. 

  5554. 

    5555. 

  5555. 		/* If we run into an occurrence of carriage return followed by line feed,

    5556. 

  5556. 		 * we have found the terminating characters of the string. */

    5557. 

  5557. 		if(pmString[pmIdx] == 0x0D && pmString[pmIdx+1] == 0x0A) {

    5558. 

  5558. 			break;

    5559. 

  5559. 		}

    5560. 

  5560. 	}                      

    5561. 

  5561. 	if(pmIdx >= EPS_PM_MAXSIZE || 0 == printer->JpgMax){

    5562. 

  5562. 		EPS_RETURN( EPS_ERR_OPR_FAIL ); /* bad format */

    5563. 

  5563. 	}

    5564. 

  5564. 

    5565. 

  5565. 	EPS_RETURN( ret );

    5566. 

  5566. }

    5567. 

  5567. 

    5568. 

  5568. 

    5569. 

  5569. /*******************************************|********************************************/

    5570. 

  5570. /*                                                                                      */

    5571. 

  5571. /* Function name:   DuplSupportedMedia()                                                */

    5572. 

  5572. /*                                                                                      */

    5573. 

  5573. /* Arguments                                                                            */

    5574. 

  5574. /* ---------                                                                            */

    5575. 

  5575. /* Name:            Type:                  Description:                                 */

    5576. 

  5576. /* innerPrinter     EPS_PRINTER_INN*       I: printer that it has original structure    */

    5577. 

  5577. /* pMedia           EPS_SUPPORTED_MEDIA*   O: pointer to a distination                  */

    5578. 

  5578. /*                                                                                      */

    5579. 

  5579. /* Return value:                                                                        */

    5580. 

  5580. /*      EPS_ERR_NONE                    - Success                                       */

    5581. 

  5581. /*      EPS_ERR_MEMORY_ALLOCATION       - Alloc memory failed                           */

    5582. 

  5582. /*                                                                                      */

    5583. 

  5583. /* Description:                                                                         */

    5584. 

  5584. /*      Duplicate EPS_SUPPORTED_MEDIA to user buffer.                                   */

    5585. 

  5585. /*                                                                                      */

    5586. 

  5586. /*******************************************|********************************************/

    5587. 

  5587. EPS_ERR_CODE    DuplSupportedMedia(

    5588. 

  5588. 	

    5589. 

  5589. 		EPS_PRINTER_INN*		innerPrinter,

    5590. 

  5590. 		EPS_SUPPORTED_MEDIA*    pMedia

    5591. 

  5591. 	

    5592. 

  5592. ){

    5593. 

  5593. 	EPS_ERR_CODE	ret = EPS_ERR_NONE;

    5594. 

  5594.     EPS_INT32       idx;

    5595. 

  5595. 

    5596. 

  5596. 	EPS_LOG_FUNCIN;

    5597. 

  5597. 

    5598. 

  5598. 	ClearSupportedMedia();

    5599. 

  5599. 

    5600. 

  5600. 	g_supportedMedia.JpegSizeLimit = innerPrinter->supportedMedia.JpegSizeLimit;

    5601. 

  5601. 	g_supportedMedia.resolution = innerPrinter->supportedMedia.resolution;

    5602. 

  5602.     g_supportedMedia.numSizes = innerPrinter->supportedMedia.numSizes;

    5603. 

  5603.     g_supportedMedia.sizeList = (EPS_MEDIA_SIZE*)EPS_ALLOC( sizeof(EPS_MEDIA_SIZE) * innerPrinter->supportedMedia.numSizes );

    5604. 

  5604. 	if( g_supportedMedia.sizeList ){

    5605. 

  5605. 		for(idx = 0; idx < innerPrinter->supportedMedia.numSizes; idx++) {

    5606. 

  5606. 			g_supportedMedia.sizeList[idx].mediaSizeID = innerPrinter->supportedMedia.sizeList[idx].mediaSizeID;

    5607. 

  5607. 			g_supportedMedia.sizeList[idx].numTypes    = innerPrinter->supportedMedia.sizeList[idx].numTypes;

    5608. 

  5608. 			g_supportedMedia.sizeList[idx].typeList = 

    5609. 

  5609.                     (EPS_MEDIA_TYPE*)EPS_ALLOC( sizeof(EPS_MEDIA_TYPE) * innerPrinter->supportedMedia.sizeList[idx].numTypes );

    5610. 

  5610. 			if( g_supportedMedia.sizeList[idx].typeList ){

    5611. 

  5611. 				memcpy(g_supportedMedia.sizeList[idx].typeList, 

    5612. 

  5612. 						innerPrinter->supportedMedia.sizeList[idx].typeList,

    5613. 

  5613. 						sizeof(EPS_MEDIA_TYPE) * innerPrinter->supportedMedia.sizeList[idx].numTypes);

    5614. 

  5614. 			} else{

    5615. 

  5615. 				ret = EPS_ERR_MEMORY_ALLOCATION;

    5616. 

  5616. 				break;

    5617. 

  5617. 			}

    5618. 

  5618. 		}

    5619. 

  5619. 	} else{

    5620. 

  5620. 		ret = EPS_ERR_MEMORY_ALLOCATION;

    5621. 

  5621. 	}

    5622. 

  5622. 

    5623. 

  5623. 	if(EPS_ERR_NONE == ret){

    5624. 

  5624. 		/* Copy to out param */

    5625. 

  5625.         pMedia->JpegSizeLimit = g_supportedMedia.JpegSizeLimit;

    5626. 

  5626.  		pMedia->resolution = g_supportedMedia.resolution;

    5627. 

  5627. 		pMedia->numSizes = g_supportedMedia.numSizes;

    5628. 

  5628.         pMedia->sizeList = g_supportedMedia.sizeList;

    5629. 

  5629. 

    5630. 

  5630. 	} else{

    5631. 

  5631. 		/* If error occur, unwind. */

    5632. 

  5632. 		for(idx = 0; idx < g_supportedMedia.numSizes; idx++) {

    5633. 

  5633. 			EPS_SAFE_RELEASE(g_supportedMedia.sizeList[idx].typeList);

    5634. 

  5634. 		}

    5635. 

  5635. 		EPS_SAFE_RELEASE(g_supportedMedia.sizeList);

    5636. 

  5636. 		g_supportedMedia.numSizes = 0;

    5637. 

  5637. 	}

    5638. 

  5638. 

    5639. 

  5639. 	EPS_RETURN( ret );

    5640. 

  5640. }

    5641. 

  5641. 

    5642. 

  5642. 

    5643. 

  5643. /*******************************************|********************************************/

    5644. 

  5644. /*                                                                                      */

    5645. 

  5645. /* Function name:     ClearSupportedMedia()                                             */

    5646. 

  5646. /*                                                                                      */

    5647. 

  5647. /* Arguments                                                                            */

    5648. 

  5648. /* ---------                                                                            */

    5649. 

  5649. /* Name:            Type:                   Description:                                */

    5650. 

  5650. /* (none)                                                                               */

    5651. 

  5651. /*                                                                                      */

    5652. 

  5652. /* Return value:                                                                        */

    5653. 

  5653. /*      void                                                                            */

    5654. 

  5654. /*                                                                                      */

    5655. 

  5655. /* Description:                                                                         */

    5656. 

  5656. /*      Crean up inside list of supported media structure.                              */

    5657. 

  5657. /*                                                                                      */

    5658. 

  5658. /*******************************************|********************************************/

    5659. 

  5659. void ClearSupportedMedia(

    5660. 

  5660. 							

    5661. 

  5661. 	void

    5662. 

  5662. 

    5663. 

  5663. ){

    5664. 

  5664.     EPS_INT32       idx;

    5665. 

  5665. 

    5666. 

  5666. 	EPS_LOG_FUNCIN;

    5667. 

  5667. 

    5668. 

  5668. 	/* Clear "supportedMedia"                                              */

    5669. 

  5669. 	if( NULL != g_supportedMedia.sizeList){

    5670. 

  5670. 		for(idx = 0; idx < g_supportedMedia.numSizes; idx++) {

    5671. 

  5671. 			EPS_SAFE_RELEASE(g_supportedMedia.sizeList[idx].typeList);

    5672. 

  5672. 		}

    5673. 

  5673. 		EPS_SAFE_RELEASE(g_supportedMedia.sizeList);

    5674. 

  5674. 		g_supportedMedia.numSizes = 0;

    5675. 

  5675. 	}

    5676. 

  5676. 

    5677. 

  5677. 	EPS_RETURN_VOID;

    5678. 

  5678. }

    5679. 

  5679. 

    5680. 

  5680. /*_______________________________   epson-escpr-api.c   ________________________________*/

    5681. 

  5681. 

    5682. 

  5682. /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/

    5683. 

  5683. /*       1         2         3         4         5         6         7         8        */

    5684. 

  5684. /*******************************************|********************************************/

    5685. 

  5685. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

    5686. 

  5686. /***** End of File *** End of File *** End of File *** End of File *** End of File ******/

    5687. 

  5687. /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
    5688.