src/evolis.c

   1 \r
   2 /*\r
   3  *\r
   4  * Contents:\r
   5  *\r
   6  */\r
   7 #include <string.h>\r
   8 #include <stdlib.h>\r
   9 #include <stdio.h>\r
  10 #include "evoliserror.h"\r
  11 \r
  12 // Macros...\r
  13 #define RgbToGray(r, g, b) (((long) (r)*74L + (long)(g)*155L +(long)(b)*27L) >> 8)\r
  14 // Globals...\r
  15 // Globals...\r
  16 int           STATUS=0; //0 means succes, 1 means failure\r
  17 unsigned char *lpMem;\r
  18 unsigned char *lpRecto,*lpVerso;\r
  19 int           Model;                    /* Model number */\r
  20 long          dwSizeNeeded;             // taille mmoire du lpMem en octets\r
  21 \r
  22 char\r
  23   ColorSmooth[15],\r
  24   OverlayPannel[10],\r
  25   OverlayBackPannel[10],\r
  26   TreatementK[10],\r
  27   TestCard[10],\r
  28   EjectCard[10],\r
  29   SelfClean[10],\r
  30   AdjPrinter[10],\r
  31   BlackIn[10],\r
  32   Soften[10];\r
  33 \r
  34 int Brightness, Contrast, SensibilityK, QualityK, SensibilityO;\r
  35 int TB,LB,BB,RB,TW,LW,BW,RW;\r
  36 int DetectAuto,StartDist;\r
  37 int colorspace,levelB;\r
  38 \r
  39 \r
  40 \r
  41 // *3.5\r
  42 int DitherPattern1[8][8] = {\r
  43         {0, 112, 28, 140, 7, 119, 35, 147},\r
  44         {168, 56, 196, 84, 175, 63, 203, 78},\r
  45         {42, 154, 14, 126, 49, 161, 21, 114},\r
  46         {210, 98, 182, 70, 217, 105, 189, 77},\r
  47         {11, 123, 39, 151, 4, 116, 32, 143},\r
  48         {179, 67, 207, 95, 172, 59, 200, 88},\r
  49         {53, 165, 24, 137, 46, 158, 18, 111},\r
  50         {221, 109, 193, 81, 214, 102, 159, 74}\r
  51 };\r
  52 \r
  53 // Prototypes...\r
  54 \r
  55 // Compress and format data for the printer\r
  56 long ReduceBlack(unsigned char *lpMemIn, unsigned char *lpMemOut,int nbrline);\r
  57 long ReduceColor(unsigned char *lpMemIn, unsigned char *lpMemOut, int uiBitComp);//,int nbrline);\r
  58 //int CutPage(long *stop);\r
  59 \r
  60 // Download functions\r
  61 int DBNC(int col,int bl,int ov);//,int line);\r
  62 int DB32NC(long lPos, char color);      //y,m,c pannels 5 bits per color\r
  63 int DB64NC(long lPos, char color);      //y,m,c pannels 6 bits per color\r
  64 int DB128NC(long lPos, char color);     //y,m,c pannels 7 bits per color\r
  65 /*int DB32NCS(long lPos, char color,int line);  //y,m,c pannels 5 bits per color\r
  66 int DB64NCS(long lPos, char color,int line);    //y,m,c pannels 6 bits per color\r
  67 int DB128NCS(long lPos, char color,int line);   //y,m,c pannels 7 bits per color*/\r
  68 int DB2NC(long lPos, char pannel[10]);  // k,o panel 2 levels\r
  69 int DB2MNC(long lPos);          // k panel 2 levels\r
  70 \r
  71 // Convert RVB to k functions\r
  72 void RVBtoGray(unsigned char *lpMemIn, unsigned char *lpMemOut, long lNbrByte);\r
  73 void KinYMC(long Height, long Width);\r
  74 void GrayToFloyd(unsigned char *lpMemIn, unsigned char *lpMemOut, long Width, long Height);\r
  75 void GrayToDither(unsigned char *lpMemIn, unsigned char *lpMemOut, long Width, long Height);\r
  76 void GrayToThreshold(unsigned char *lpMemIn, unsigned char *lpMemOut, long lNbrByte);\r
  77 void ConvertRVBtoK(unsigned char *lpbRVB, long RVBSize, long Height, long Width, unsigned char *lpBlack);\r
  78 void GetFirstYMCDot(long Height, long Width , int *x, int *y);\r
  79 \r
  80 \r
  81 //===============================================================================//\r
  82 // Reduce color data from 8 bits to uiBitComp.\r
  83 \r
  84 // Entree : 1 color panel (1016 * 648 octets)\r
  85 // Sortie : 1 color panel with usable data ((1016*648)*uiBitComp)/8\r
  86 //===============================================================================//\r
  87 \r
  88 \r
  89 long ReduceColor(unsigned char *lpMemIn, unsigned char *lpMemOut, int uiBitComp)//,int nbrline)\r
  90 {\r
  91         long lIndex = 0, lIndex1 = 0;\r
  92         unsigned char *lpbBuf, *lpbData, *lpbDataOut;\r
  93         long lComp = 0;\r
  94         long lNbrByte = (1016*648);\r
  95 \r
  96         //Reservation m�oire pour traitement d'une ligne\r
  97 \r
  98         lpbBuf = malloc(8);\r
  99 \r
 100         if (!lpbBuf)\r
 101         {\r
 102 \r
 103                 //fprintf(stderr, "**************** EVOLIS ReduceColor manque de memoire pour lpBuf: taille demande 8 octets... \n");\r
 104                 fatal("ReduceColor Fails memory lpBuf: requested size 8 bytes...");\r
 105                 \r
 106                 /// sortir de l'impression....\r
 107                 return (0);\r
 108         }\r
 109 \r
 110         //lpbData ppV mem bmp brute\r
 111         lpbData = &lpMemIn[0];\r
 112 \r
 113         lpbDataOut = &lpMemOut[0];\r
 114         // pour toutes les donnees\r
 115         while (lIndex < lNbrByte)\r
 116         {\r
 117                 //Traite byte par 8\r
 118                 for (lIndex1 = 0; lIndex1 < 8; lIndex1++)\r
 119                 {\r
 120                         if (lIndex < lNbrByte)\r
 121                         {\r
 122                                 //decalage donnees utiles\r
 123                                 lpbBuf[lIndex1] = *(lpbData++) >> (8 - uiBitComp);\r
 124                                 lIndex++;\r
 125                         }\r
 126                         else\r
 127                         {\r
 128 \r
 129                                 lpbBuf[lIndex1] = 0x00;\r
 130                         }\r
 131                 }\r
 132 \r
 133                 switch (uiBitComp)\r
 134                 {\r
 135                         case 6:\r
 136                                 *(lpbDataOut++) = (lpbBuf[0] << 2) | (lpbBuf[1] >> 4);\r
 137                                 *(lpbDataOut++) = (lpbBuf[1] << 4) | (lpbBuf[2] >> 2);\r
 138                                 *(lpbDataOut++) = (lpbBuf[2] << 6) | (lpbBuf[3]);\r
 139                                 *(lpbDataOut++) = (lpbBuf[4] << 2) | (lpbBuf[5] >> 4);\r
 140                                 *(lpbDataOut++) = (lpbBuf[5] << 4) | (lpbBuf[6] >> 2);\r
 141                                 *(lpbDataOut++) = (lpbBuf[6] << 6) | (lpbBuf[7]);\r
 142                                 break;\r
 143                         case 7:\r
 144                                 *(lpbDataOut++) = (lpbBuf[0] << 1) | (lpbBuf[1] >> 6);\r
 145                                 *(lpbDataOut++) = (lpbBuf[1] << 2) | (lpbBuf[2] >> 5);\r
 146                                 *(lpbDataOut++) = (lpbBuf[2] << 3) | (lpbBuf[3] >> 4);\r
 147                                 *(lpbDataOut++) = (lpbBuf[3] << 4) | (lpbBuf[4] >> 3);\r
 148 \r
 149                                 *(lpbDataOut++) = (lpbBuf[4] << 5) | (lpbBuf[5] >> 2);\r
 150                                 *(lpbDataOut++) = (lpbBuf[5] << 6) | (lpbBuf[6] >> 1);\r
 151                                 *(lpbDataOut++) = (lpbBuf[6] << 7) | (lpbBuf[7]);\r
 152                                 break;\r
 153 \r
 154                         default:        //5 bits\r
 155                                 *(lpbDataOut++) = (lpbBuf[0] << 3) | (lpbBuf[1] >> 2);\r
 156                                 *(lpbDataOut++) = (lpbBuf[1] << 6) | (lpbBuf[2] << 1) | (lpbBuf[3] >> 4);\r
 157                                 *(lpbDataOut++) = (lpbBuf[3] << 4) | (lpbBuf[4] >> 1);\r
 158 \r
 159                                 *(lpbDataOut++) = (lpbBuf[4] << 7) | (lpbBuf[5] << 2) | (lpbBuf[6] >> 3);\r
 160                                 *(lpbDataOut++) = (lpbBuf[6] << 5) | (lpbBuf[7]);\r
 161                                 //break;\r
 162                 }\r
 163         }\r
 164         free(lpbBuf);\r
 165         lComp = (((lNbrByte * 10) / 8) * uiBitComp);\r
 166         lComp /= 10;\r
 167         if (lNbrByte % 8)\r
 168                 lComp++;\r
 169 \r
 170 \r
 171         return (lComp);\r
 172 }\r
 173 \r
 174 //===================================================//\r
 175 // fonction pour le panneau noir & overlay uniquement\r
 176 // entree : 1 octect = 1 points\r
 177 // sortie : 1 octect = 8 points \r
 178 //===================================================//\r
 179 long ReduceBlack(unsigned char *lpMemIn, unsigned char *lpMemOut,int nbrline)\r
 180 {\r
 181         long lIndex = 0, lIndex1 = 0;\r
 182         unsigned char *lpbData, *lpbDataOut;\r
 183         long lComp = 0;\r
 184         unsigned char bBuf = 0x00;\r
 185 \r
 186         unsigned char Mask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };\r
 187         long lNbrByte = nbrline * 648;\r
 188 \r
 189 \r
 190         //lpbData ppV mem bmp brute\r
 191         lpbData = &lpMemIn[0];\r
 192         lpbDataOut = &lpMemOut[0];\r
 193         // pour toutes les donnees\r
 194 \r
 195         while (lIndex < lNbrByte)\r
 196         {\r
 197 \r
 198 \r
 199                 //Traite byte par 8\r
 200                 for (lIndex1 = 0; lIndex1 < 8; lIndex1++)\r
 201 \r
 202                 {\r
 203                         if (lIndex < lNbrByte)\r
 204                         {\r
 205                                 if (*(lpbData++) == 0xFF)\r
 206                                 {\r
 207                                         bBuf |= Mask[lIndex1];\r
 208                                 }\r
 209                                 lIndex++;\r
 210                         }\r
 211                 }\r
 212                 *(lpbDataOut++) = bBuf;\r
 213                 bBuf = 0x00;\r
 214                 lComp++;\r
 215         }\r
 216         return (lComp);\r
 217 }\r
 218 \r
 219  //=====================================================================\r
 220  //   Convert bitmap RVB data to evolis data format                             \r
 221  //=====================================================================\r
 222 \r
 223  \r
 224 int DBNC(int col,int bl,int ov)//,int line)\r
 225 {\r
 226     //output("\033Ss\015");     // debut sequence + CR\r
 227     \r
 228     if(col == 1) {\r
 229         DB32NC(0 * (dwSizeNeeded / 5), 'y');\r
 230         DB32NC(1 * (dwSizeNeeded / 5), 'm');\r
 231         DB32NC(2 * (dwSizeNeeded / 5), 'c');\r
 232     }\r
 233     else if (col == 2) {\r
 234         DB64NC(0 * (dwSizeNeeded / 5), 'y');\r
 235         DB64NC(1 * (dwSizeNeeded / 5), 'm');\r
 236         DB64NC(2 * (dwSizeNeeded / 5), 'c');\r
 237     }\r
 238     else if (col == 3) {\r
 239         DB128NC(0 * (dwSizeNeeded / 5), 'y');\r
 240         DB128NC(1 * (dwSizeNeeded / 5), 'm');\r
 241         DB128NC(2 * (dwSizeNeeded / 5), 'c');\r
 242         }\r
 243 \r
 244     if(bl){\r
 245         DB2NC(3 * (dwSizeNeeded / 5), "ABP");\r
 246     }\r
 247     \r
 248         if(ov){\r
 249                 if(ov == 1){//overlay at front\r
 250                         DB2NC(0, OverlayPannel);\r
 251                 }\r
 252                 else {\r
 253                         DB2NC(0, OverlayBackPannel);\r
 254                 }\r
 255         }\r
 256         \r
 257 \r
 258     //output("\033Se\015.....................................");        // fin sequence + CR\r
 259 \r
 260 }\r
 261 \r
 262 //===============================================================//\r
 263 // Telechargement d'un panneau non compresse 5 bits\r
 264 // Input : ucData / raw data\r
 265 //         color /y,m or c      \r
 266 // Return:      0 si OK\r
 267 //              -1 si erreur ecriture  \r
 268 //===============================================================//\r
 269 int DB32NC(long lPos, char color)\r
 270 {\r
 271         unsigned char *ucCommand, *ucCol;\r
 272         long lCommandSize = ((1016 * 648) * 5) / 8;\r
 273         long lComp = 0;\r
 274         int  numwritten = 0;\r
 275 \r
 276         //Reservation memoire pour une commande de telechargement\r
 277         ucCommand = malloc(lCommandSize + 12);\r
 278         if (!ucCommand) {\r
 279                 fatal("DP32NC Error: Fails malloc... ");\r
 280                 return (-1);\r
 281         }\r
 282                 \r
 283         ucCol = &lpMem[lPos];\r
 284         strcpy(ucCommand, "\033Db;y;32;");\r
 285         strncpy(&ucCommand[4], &color, 1);\r
 286         \r
 287         lComp = ReduceColor(ucCol, &ucCommand[9], 5);//,1016);\r
 288         lCommandSize += 10;\r
 289         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 290         if (numwritten != lCommandSize) {\r
 291                 fatal("DP32NC Error: Fails printf %d... \n", numwritten);\r
 292                 free(ucCommand);\r
 293                 return (-1);\r
 294         }\r
 295         /*lComp += 10;\r
 296         while(lComp > 4096) {\r
 297                 numwritten += fwrite(&ucCommand[numwritten], sizeof(unsigned char), 4096, stdout);\r
 298                 lComp -= 4096;          \r
 299         }\r
 300         debug("NuwWritten %d", numwritten);\r
 301         if(lComp > 0) {\r
 302                 numwritten += fwrite(&ucCommand[numwritten], sizeof(unsigned char), lComp, stdout);\r
 303         }\r
 304         debug("lComp %d numwritten %d lCommandSize %d", lComp,numwritten,lCommandSize);\r
 305         if (numwritten != lCommandSize) {\r
 306                 fatal("DP32NC Error: Fails printf %d... \n", numwritten);\r
 307                 free(ucCommand);\r
 308                 return (-1);\r
 309         }*/\r
 310         \r
 311         \r
 312         free(ucCommand);\r
 313         return (0);\r
 314 }\r
 315 \r
 316  //===============================================================//\r
 317 // Telechargement d'un panneau non compresse 6 bits\r
 318 // Input : ucData / raw data\r
 319 //         color /y,m or c      \r
 320 // Return:      0 si OK\r
 321 //              -1 si erreur ecriture  \r
 322 //===============================================================//\r
 323 \r
 324 int DB64NC(long lPos, char color)\r
 325 {\r
 326         unsigned char *ucCommand, *ucCol;\r
 327 \r
 328 \r
 329         long lCommandSize = ((1016 * 648) * 6) / 8;\r
 330         long lComp;\r
 331         int numwritten = 0;\r
 332 \r
 333 \r
 334         //Reservation memoire pour une commande de telechargement\r
 335         ucCommand = malloc(lCommandSize + 10);\r
 336         debug("DP64NC Size for one panel: %d... \n", (lCommandSize + 10));\r
 337         \r
 338         if (!ucCommand)\r
 339         {\r
 340 \r
 341                 fatal("DP64NC Error: Fails malloc...");\r
 342                 \r
 343                 free(ucCommand);\r
 344                 return (-1);\r
 345 \r
 346         }\r
 347         ucCol = &lpMem[lPos];\r
 348         strcpy(ucCommand, "\033Db;y;64;");\r
 349         strncpy(&ucCommand[4], &color, 1);\r
 350 \r
 351 \r
 352         lComp = ReduceColor(ucCol, &ucCommand[9], 6);//,1016);\r
 353         //fprintf(stderr, "**************** EVOLIS DP64NC taille apres compression %d... \n",lComp);\r
 354         strncpy(&ucCommand[lCommandSize + 9], "\015", 1);\r
 355         lCommandSize += 10;\r
 356         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 357         if (numwritten != lCommandSize)\r
 358         {\r
 359                 fatal("DP64NC Error: Fails fwrite %d... \n", numwritten);\r
 360                 \r
 361                 free(ucCommand);\r
 362                 return (-1);\r
 363         }\r
 364 \r
 365         free(ucCommand);\r
 366 \r
 367         return (0);\r
 368 }\r
 369 \r
 370 \r
 371  //===============================================================//\r
 372 // Telechargement d'un panneau non compresse 7 bits\r
 373 // Input : ucData / raw data\r
 374 //         color /y,m or c      \r
 375 // Return:      0 si OK\r
 376 //              -1 si erreur ecriture  \r
 377 //===============================================================//\r
 378 int DB128NC(long lPos, char color)\r
 379 \r
 380 {\r
 381         unsigned char *ucCommand, *ucCol;\r
 382         long lCommandSize = ((1016 * 648) * 7) / 8;\r
 383         long lComp;\r
 384         int numwritten = 0;\r
 385 \r
 386         //Reservation memoire pour une commande de telechargement\r
 387         ucCommand = malloc(lCommandSize + 11);\r
 388         debug("DP128NC Size for one panel: %d... ", (lCommandSize + 11));\r
 389         if (!ucCommand)\r
 390         {\r
 391                 fatal("DP128NC Error: Fails malloc... ");\r
 392                 \r
 393                 free(ucCommand);\r
 394                 return (-1);\r
 395         }\r
 396         ucCol = &lpMem[lPos];\r
 397         strcpy(ucCommand, "\033Db;y;128;");\r
 398         strncpy(&ucCommand[4], &color, 1);\r
 399         lComp = ReduceColor(ucCol, &ucCommand[10], 7);//,1016);\r
 400         strncpy(&ucCommand[lCommandSize + 10], "\015", 1);\r
 401         lCommandSize += 11;\r
 402         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 403         if (numwritten != lCommandSize)\r
 404         {\r
 405                 fatal("DP128NC Error: Fails fwrite %d... \n", numwritten);\r
 406                 \r
 407                 free(ucCommand);\r
 408                 return (-1);\r
 409         }\r
 410         free(ucCommand);\r
 411         return (0);\r
 412 }\r
 413 //===============================================================//\r
 414 // Telechargement d'un panneau non compresse 5 bits YMCKOS\r
 415 // Input : ucData / raw data\r
 416 //         color /y,m or c\r
 417 // Return:      0 si OK\r
 418 //              -1 si erreur ecriture\r
 419 //===============================================================//\r
 420 /*int DB32NCS(long lPos, char color,int line)\r
 421 {\r
 422         unsigned char *ucCommand, *ucCol;\r
 423         long lCommandSize = ((1016 * 648) * 5) / 8;\r
 424         long lComp = 0;\r
 425         int numwritten = 0;\r
 426 \r
 427         //Reservation memoire pour une commande de telechargement\r
 428         ucCommand = malloc(lCommandSize + 20);\r
 429         //fprintf(stderr, "**************** EVOLIS DP32NC Size for one panel: %d... \n", (lCommandSize+10));\r
 430         if (!ucCommand)\r
 431         {\r
 432                 //fprintf(stderr, "**************** EVOLIS DP32NC Error: Fails malloc... \n");\r
 433                 fatal("DP32NC Error: Fails malloc... ");\r
 434 \r
 435                 return (-1);\r
 436         }\r
 437         ucCol = &lpMem[lPos];\r
 438         //strcpy(ucCommand, "\033Dbc;y;32;");\r
 439   //nbroct = 540 * 648;\r
 440   lCommandSize = ((520 * 648) * 5) / 8;\r
 441   sprintf(ucCommand, "\033Dbc;y;32;%.4d;%.6d;",line,lCommandSize);\r
 442   strncpy(&ucCommand[5], &color, 1);\r
 443 \r
 444   info("%s",ucCommand);\r
 445   lComp = ReduceColor(ucCol, &ucCommand[22], 5, 520);\r
 446         strncpy(&ucCommand[lCommandSize + 22], "\015", 1);\r
 447         lCommandSize += 23;\r
 448   \r
 449         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 450   //info("%d  %s", numwritten,ucCommand);\r
 451   if (numwritten != lCommandSize)\r
 452         {\r
 453                 //fprintf(stderr, "**************** EVOLIS DP32NC Error: Fails printf %d... \n",numwritten);\r
 454     fatal("DP32NC Error: Fails printf %d... \n", numwritten);\r
 455                 free(ucCommand);\r
 456                 return (-1);\r
 457         }\r
 458         free(ucCommand);\r
 459         return (0);\r
 460 }\r
 461 \r
 462  //===============================================================//\r
 463 // Telechargement d'un panneau non compresse 6 bits YMCKOS\r
 464 // Input : ucData / raw data\r
 465 //         color /y,m or c\r
 466 // Return:      0 si OK\r
 467 //              -1 si erreur ecriture\r
 468 //===============================================================//\r
 469 \r
 470 int DB64NCS(long lPos, char color,int line)\r
 471 {\r
 472         unsigned char *ucCommand, *ucCol;\r
 473 \r
 474         long lCommandSize = ((1016 * 648) * 6) / 8;\r
 475         long lComp;\r
 476         int numwritten = 0;\r
 477 \r
 478 \r
 479 \r
 480         //Reservation memoire pour une commande de telechargement\r
 481         ucCommand = malloc(lCommandSize + 10);\r
 482         debug("DP64NC Size for one panel: %d... \n", (lCommandSize + 10));\r
 483 \r
 484         if (!ucCommand)\r
 485         {\r
 486 \r
 487                 fatal("DP64NC Error: Fails malloc...");\r
 488 \r
 489                 free(ucCommand);\r
 490                 return (-1);\r
 491 \r
 492         }\r
 493         ucCol = &lpMem[lPos];\r
 494         strcpy(ucCommand, "\033Db;y;64;");\r
 495         strncpy(&ucCommand[4], &color, 1);\r
 496 \r
 497 \r
 498         lComp = ReduceColor(ucCol, &ucCommand[9], 6, 540);\r
 499         //fprintf(stderr, "**************** EVOLIS DP64NC taille apres compression %d... \n",lComp);\r
 500         strncpy(&ucCommand[lCommandSize + 9], "\015", 1);\r
 501         lCommandSize += 10;\r
 502         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 503         if (numwritten != lCommandSize)\r
 504         {\r
 505                 fatal("DP64NC Error: Fails fwrite %d... \n", numwritten);\r
 506 \r
 507                 free(ucCommand);\r
 508                 return (-1);\r
 509         }\r
 510 \r
 511         free(ucCommand);\r
 512 \r
 513         return (0);\r
 514 }\r
 515 \r
 516 \r
 517  //===============================================================//\r
 518 // Telechargement d'un panneau non compresse 7 bits YMCKOS\r
 519 // Input : ucData / raw data\r
 520 //         color /y,m or c\r
 521 // Return:      0 si OK\r
 522 //              -1 si erreur ecriture\r
 523 //===============================================================//\r
 524 int DB128NCS(long lPos, char color,int line)\r
 525 \r
 526 {\r
 527         unsigned char *ucCommand, *ucCol;\r
 528         long lCommandSize = ((1016 * 648) * 7) / 8;\r
 529         long lComp;\r
 530         int numwritten = 0;\r
 531 \r
 532         //Reservation memoire pour une commande de telechargement\r
 533         ucCommand = malloc(lCommandSize + 11);\r
 534         //fprintf(stderr, "**************** EVOLIS DP128NC Size for one panel: %d... \n", (lCommandSize+11));\r
 535         debug("DP128NC Size for one panel: %d... ", (lCommandSize + 11));\r
 536 \r
 537 \r
 538         if (!ucCommand)\r
 539         {\r
 540                 fatal("DP128NC Error: Fails malloc... ");\r
 541 \r
 542                 free(ucCommand);\r
 543                 return (-1);\r
 544         }\r
 545         ucCol = &lpMem[lPos];\r
 546         strcpy(ucCommand, "\033Db;y;128;");\r
 547         strncpy(&ucCommand[4], &color, 1);\r
 548         lComp = ReduceColor(ucCol, &ucCommand[10], 7, 540);\r
 549         //fprintf(stderr, "**************** EVOLIS DP128NC taille apres compression %d... \n",lComp);\r
 550         strncpy(&ucCommand[lCommandSize + 10], "\015", 1);\r
 551         lCommandSize += 11;\r
 552         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 553         if (numwritten != lCommandSize)\r
 554         {\r
 555                 fatal("DP128NC Error: Fails fwrite %d... \n", numwritten);\r
 556 \r
 557                 free(ucCommand);\r
 558                 return (-1);\r
 559         }\r
 560         free(ucCommand);\r
 561         return (0);\r
 562 } */\r
 563 //===============================================================//\r
 564 // Telechargement d'un panneau non compresse overlay noir\r
 565 // Input : ucData / raw datal978\r
 566 //         color /      k: noir\r
 567 //                      f: full varnish \r
 568 // Return:      0 si OK\r
 569 //              -1 si erreur ecriture  \r
 570 //===============================================================//\r
 571 \r
 572 int DB2NC(long lPos, char pannel[10])\r
 573 {\r
 574         unsigned char *ucCommand, *ucCol;\r
 575         long lComp;\r
 576 \r
 577         long lCommandSize = ((1016 * 648)) / 8;\r
 578         int numwritten = 0;\r
 579         int B, T, L, R, i = 0, j = 0;\r
 580         int pB, pT, ModuloB, ModuloT;\r
 581 \r
 582         //unsigned char        MaskB[8] = { 0x00,0x80,0xC0,0xE0,0xF0,0x7F,0x3F,0x1F};\r
 583         //unsigned char        MaskT[8] = { 0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F};\r
 584         unsigned char MaskB[8] = { 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE };\r
 585         unsigned char MaskT[8] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F };\r
 586 \r
 587 \r
 588         //Reservation memoire pour une commande de telechargement\r
 589 \r
 590         ucCommand = malloc(lCommandSize + 9);\r
 591 \r
 592         //debug("DP2NC Size for one panel: %d... ", (lCommandSize + 9));\r
 593         \r
 594 \r
 595         if (!ucCommand)\r
 596         {\r
 597                 fatal("DP2NC Error: Fails malloc... ");\r
 598                 free(ucCommand);\r
 599                 return (-1);\r
 600         }\r
 601 \r
 602         if (!(strcmp(pannel, "ABP")))// == NULL)\r
 603         {                       // panneau noir\r
 604                 ucCol = &lpMem[lPos];\r
 605                 strcpy(ucCommand, "\033Db;k;2;");\r
 606                 lComp = ReduceBlack(ucCol, &ucCommand[8],1016);\r
 607                 strncpy(&ucCommand[lCommandSize + 8], "\015", 1);\r
 608                 lCommandSize += 9;\r
 609                 numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 610                 if (numwritten != lCommandSize)\r
 611         {\r
 612                         fatal("DP2NC Error: Fails fprintf %d... ", numwritten);\r
 613                 \r
 614                         free(ucCommand);\r
 615                         return (-1);\r
 616                 }\r
 617         }\r
 618         else if (!(strcmp(pannel, "NO")))// == NULL)\r
 619         {               //No Varnish\r
 620                         memset(ucCommand, 0x00, lCommandSize);\r
 621                         strcpy(ucCommand, "\033Db;o;2;");\r
 622                         strncpy(&ucCommand[lCommandSize + 8], "\015", 1);\r
 623                         lCommandSize += 9;\r
 624                         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 625                         if (numwritten != lCommandSize)\r
 626                         {\r
 627                                 fatal("DP2NC Error: Fails fwrite %d... ", numwritten);\r
 628                                 free(ucCommand);\r
 629                                 return (-1);\r
 630                         }\r
 631         }\r
 632         else if (!(strcmp(pannel, "FO")))// == NULL)\r
 633         {       //Full Varnish\r
 634                           memset(ucCommand, 0xFF, lCommandSize);\r
 635                                 strcpy(ucCommand, "\033Db;o;2;");\r
 636                                 strncpy(&ucCommand[lCommandSize + 8], "\015", 1);\r
 637                                 lCommandSize += 9;\r
 638                                 numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 639                                 if (numwritten != lCommandSize)\r
 640                                 {\r
 641                                         fatal("DP2NC Error: Fails fwrite %d... ", numwritten);\r
 642                                         free(ucCommand);\r
 643                                         return (-1);\r
 644                                 }\r
 645         }\r
 646         else\r
 647   {\r
 648 \r
 649   if (!(strcmp(pannel, "OA")))// == NULL)\r
 650   {\r
 651     //Cover Overlay\r
 652     B = BB * 12;\r
 653           T = TB * 12;\r
 654                 L = LB * 12;\r
 655                 R = RB * 12;\r
 656                 debug("DP2NC OA... ");\r
 657     memset(ucCommand, 0x00, lCommandSize);\r
 658     \r
 659 \r
 660     for (j = L; j <= R; j++)\r
 661 \r
 662                 {\r
 663                   pB = (j * 648) + (648 - B);\r
 664                         ModuloB = pB % 8;\r
 665                         pB /= 8;\r
 666                         if (ModuloB)\r
 667                           pB++;\r
 668                         ucCommand[pB + 7] = MaskB[ModuloB];\r
 669                         pB++;\r
 670                         pT = (j * 648) + (648 - T);\r
 671                         ModuloT = pT % 8;\r
 672                         pT /= 8;\r
 673                         if (ModuloT)\r
 674                           pT++;\r
 675                         ucCommand[pT + 7] = MaskT[ModuloT];\r
 676                         pT--;\r
 677                         for (i = (pB); i <= (pT); i++)\r
 678                         {\r
 679                           ucCommand[i + 7] = 0xFF;\r
 680                         }\r
 681                 }\r
 682     B = BW * 12;\r
 683                 T = TW * 12;\r
 684                 L = LW * 12;\r
 685                 R = RW * 12;\r
 686   }\r
 687   else if (!(strcmp(pannel, "SCI")))// == NULL)\r
 688         {\r
 689           B = 319;\r
 690                 T = 106;\r
 691                 L = 71;\r
 692                 R = 307;\r
 693     \r
 694     memset(ucCommand, 0xFF, lCommandSize);\r
 695                 debug("DP2NC SCI... ");\r
 696         }\r
 697   else if (!(strcmp(pannel, "SCA")))// == NULL)\r
 698         {\r
 699                   B = 354;\r
 700                   T = 177;\r
 701                   L = 71;\r
 702                   R = 283;\r
 703      \r
 704       memset(ucCommand, 0xFF, lCommandSize);\r
 705                   debug("DP2NC SCA... ");\r
 706         } \r
 707         else if (!(strcmp(pannel, "MS")))// == NULL)\r
 708   {\r
 709                   B = 216;\r
 710                   T = 60;\r
 711                   L = 0;\r
 712                   R = 1016;\r
 713       \r
 714       memset(ucCommand, 0xFF, lCommandSize);\r
 715                   debug("DP2NC MS... ");\r
 716   }\r
 717     //White part\r
 718     for (j = L; j <= R; j++)\r
 719           {\r
 720             pB = (j * 648) + (648 - B);\r
 721             ModuloB = pB % 8;\r
 722             pB /= 8;\r
 723             if (ModuloB)\r
 724             pB++;\r
 725             ucCommand[pB + 7] = MaskB[ModuloB];\r
 726             pB++;\r
 727             pT = (j * 648) + (648 - T);\r
 728             ModuloT = pT % 8;\r
 729             pT /= 8;\r
 730             if (ModuloT)\r
 731             pT++;\r
 732             ucCommand[pT + 7] = MaskT[ModuloT];\r
 733             pT--;\r
 734             for (i = (pB); i <= (pT); i++)\r
 735             {\r
 736                     ucCommand[i + 7] = 0x00;\r
 737             }\r
 738     }//end of white part\r
 739 \r
 740   strcpy(ucCommand, "\033Db;o;2;");\r
 741 \r
 742         strncpy(&ucCommand[lCommandSize + 8], "\015", 1);\r
 743         lCommandSize += 9;\r
 744         numwritten = fwrite(ucCommand, sizeof(unsigned char), lCommandSize, stdout);\r
 745         if (numwritten != lCommandSize)\r
 746         {\r
 747                         fatal("DP2NC Error: Fails fwrite %d... ", numwritten);\r
 748                         free(ucCommand);\r
 749                         return (-1);\r
 750         }\r
 751  \r
 752 \r
 753 }\r
 754 \r
 755   free(ucCommand);\r
 756         return (0);\r
 757 }\r
 758 \r
 759 //=====================================================================\r
 760 //   Convert color bitmap to monochrome bitmap                         \r
 761 //=====================================================================\r
 762 \r
 763 //////////////////////////////////////////////////////////////////////////////////////\r
 764 ///////                                                         RVB TO GRAY  \r
 765 /////// Input parameters\r
 766 ///////                         lpMemIn : RVB data (3 byte by dot)\r
 767 ///////                         lNbrByte: number of byte to deal\r
 768 /////// Output parameter\r
 769 ///////                         lpMemOut: pointer on the gray data, result of the conversion\r
 770 \r
 771 \r
 772 //////////////////////////////////////////////////////////////////////////////////////\r
 773 \r
 774 void RVBtoGray(unsigned char *lpMemIn, unsigned char *lpMemOut, long lNbrByte)\r
 775 {\r
 776 \r
 777         long lIndex = 0;\r
 778         unsigned char *lpbData, *lpbDataOut;\r
 779         unsigned char red, green, blue;\r
 780         long d;\r
 781 \r
 782         //lpbData ppV mem bmp brute\r
 783         lpbData = &lpMemIn[0];\r
 784         lpbDataOut = &lpMemOut[0];\r
 785         // pour toutes les donnees\r
 786         while (lIndex < lNbrByte)\r
 787         {\r
 788                 blue  = lpbData[(lIndex * 3)];\r
 789                 green = lpbData[(lIndex * 3) + 1];\r
 790                 red   = lpbData[(lIndex * 3) + 2];\r
 791                 d     = RgbToGray(red, green, blue);\r
 792                 lpbDataOut[lIndex] = (unsigned char) d;\r
 793                 lIndex++;\r
 794         }\r
 795 \r
 796 }\r
 797 \r
 798 \r
 799 //////////////////////////////////////////////////////////////////////////////////////\r
 800 ///////                                                         GRAY  THRESHOLD\r
 801 /////// Input parameters\r
 802 ///////                         lpMemIn : gray data (1 byte by dot)\r
 803 ///////                         lNbrByte: number of byte to deal\r
 804 \r
 805 \r
 806 \r
 807 /////// Output parameter\r
 808 ///////                         lpMemOut: pointer on the monochrome data, result of the gray conversion\r
 809 \r
 810 //////////////////////////////////////////////////////////////////////////////////////\r
 811 \r
 812 void GrayToThreshold(unsigned char *lpMemIn, unsigned char *lpMemOut, long lNbrByte)\r
 813 {\r
 814         long lIndex = 0;\r
 815         unsigned char *lpbData, *lpbDataOut;\r
 816         int gray, k;\r
 817 \r
 818         //lpbData ppV mem bmp brute\r
 819         lpbData = &lpMemIn[0];\r
 820         lpbDataOut = &lpMemOut[0];\r
 821         // pour toutes les donnees\r
 822         while (lIndex < lNbrByte)\r
 823 \r
 824 \r
 825         {\r
 826                 gray = lpbData[lIndex];\r
 827                 k = 0xff - gray;\r
 828                 if (k > 128)\r
 829                         gray = 0xFF;\r
 830                 else\r
 831                         gray = 0x00;\r
 832                 lpbDataOut[lIndex] = (unsigned char) gray;\r
 833                 lIndex++;\r
 834         }\r
 835 }\r
 836 \r
 837 \r
 838 \r
 839 \r
 840 //////////////////////////////////////////////////////////////////////////////////////\r
 841 ///////                                                         GRAY  DITHER\r
 842 /////// Input parameters\r
 843 ///////                         lpMemIn : gray data (1 byte by dot)\r
 844 ///////                         Height  : height of the BMP image (648)\r
 845 ///////                         Width   : width of the BMP image (1016)\r
 846 \r
 847 /////// Output parameter\r
 848 ///////                         lpMemOut: pointer on the monochrome data, result of the gray conversion\r
 849 //////////////////////////////////////////////////////////////////////////////////////\r
 850 \r
 851 void GrayToDither(unsigned char *lpMemIn, unsigned char *lpMemOut, long Width, long Height)\r
 852 {\r
 853         long index_line = 0, index_dot = 0;\r
 854         unsigned char *lpbData, *lpbDataOut;\r
 855         int gray, k;\r
 856 \r
 857 \r
 858         //lpbData ppV mem bmp brute\r
 859         lpbData = &lpMemIn[0];\r
 860 \r
 861         lpbDataOut = &lpMemOut[0];\r
 862         // pour toutes les donnees\r
 863         if (Height < Width)\r
 864         {\r
 865                 index_line = Width;\r
 866                 Width = Height;\r
 867                 Height = index_line;\r
 868         }\r
 869 \r
 870 \r
 871         for (index_line = 0; index_line < Height; index_line++)\r
 872         {\r
 873                 for (index_dot = 0; index_dot < Width; index_dot++)\r
 874                 {\r
 875                         gray = lpbData[index_dot + (index_line * Width)];\r
 876                         k = 0xff - gray;\r
 877                         if (k > DitherPattern1[index_line % 8][index_dot % 8])\r
 878                                 gray = 0xFF;\r
 879                         else\r
 880                                 gray = 0x00;\r
 881                         lpbDataOut[index_dot + (index_line * Width)] = (unsigned char) gray;\r
 882                 }\r
 883         }\r
 884 \r
 885 }\r
 886 \r
 887 //////////////////////////////////////////////////////////////////////////////////////\r
 888 ///////                                                         GRAY  FLOYD\r
 889 /////// Input parameters\r
 890 ///////                         lpMemIn : gray data (1 byte by dot)\r
 891 ///////                         Height  : height of the BMP image (648)\r
 892 ///////                         Width   : width of the BMP image (1016)\r
 893 /////// Output parameter\r
 894 ///////                         lpMemOut: pointer on the monochrome data, result of the gray conversion\r
 895 //////////////////////////////////////////////////////////////////////////////////////\r
 896 \r
 897 void GrayToFloyd(unsigned char *lpMemIn, unsigned char *lpMemOut, long Width, long Height)\r
 898 {\r
 899         long index_line = 0, index_dot = 0;\r
 900         unsigned char *lpbData, *lpbDataOut;\r
 901         int gray, k, l;\r
 902         int Error[1032];\r
 903         int NextError[1032];\r
 904         int Cerror;\r
 905         int CE3, CE5, CE7, CE1;\r
 906 \r
 907         if (Height < Width)\r
 908         {\r
 909                 index_line = Width;\r
 910 \r
 911                 Width = Height;\r
 912                 Height = index_line;\r
 913 \r
 914         }\r
 915 \r
 916         for (index_line = 0; index_line < 1032; index_line++)\r
 917         {\r
 918                 Error[index_line] = NextError[index_line] = 0;\r
 919         }\r
 920         //lpbData ppV mem bmp brute\r
 921 \r
 922 \r
 923         lpbData = &lpMemIn[0];\r
 924         lpbDataOut = &lpMemOut[0];\r
 925         // pour toutes les donnees\r
 926         for (index_line = 0; index_line < Height; index_line++)\r
 927 \r
 928         {\r
 929                 //for(index_dot = Width ; index_dot > 0; index_dot--)\r
 930                 for (index_dot = 0; index_dot < Width; index_dot++)\r
 931                 {\r
 932                         gray = lpbData[index_dot + (index_line * Width)];\r
 933 \r
 934                         k = (gray + (int) Error[index_dot]);\r
 935                         if (k > -128 && k < 128)\r
 936                                 l = 0x00;\r
 937 \r
 938                         else\r
 939                                 l = 0xFF;\r
 940 \r
 941 \r
 942                         lpbDataOut[index_dot + (index_line * Width)] = 0xFF - (unsigned char) l;\r
 943 \r
 944 \r
 945 \r
 946                         Cerror = k - l;\r
 947                         CE3 = (Cerror * 3 / 16);\r
 948                         CE5 = (Cerror * 5 / 16);\r
 949                         CE7 = (Cerror * 7 / 16);\r
 950                         CE1 = Cerror - CE3 - CE5 - CE7;\r
 951 \r
 952                         NextError[index_dot] += CE5;\r
 953                         if (index_dot < 1031)\r
 954                         {\r
 955                                 Error[index_dot + 1] += CE7;\r
 956                                 NextError[index_dot + 1] += CE1;\r
 957                         }\r
 958                         if (index_dot > 0)\r
 959                                 NextError[index_dot - 1] += CE3;\r
 960                 }\r
 961                 for (index_dot = 0; index_dot < 1032; index_dot++)\r
 962                 {\r
 963                         Error[index_dot] = NextError[index_dot];\r
 964                         NextError[index_dot] = 0;\r
 965                 }\r
 966         }\r
 967 }\r
 968 \r
 969 \r
 970 ////////////////////////////////////////////////////////////////////////////////////\r
 971 \r
 972 ///////                                         RVB  to K\r
 973 /////// Input parameters\r
 974 ///////                         lpbRVB  : rvb color data from a 24 bits 1 panel BMP file\r
 975 ///////                         RVBSize : number of byte for the color data [(1016*648)]*3\r
 976 \r
 977 ///////                         Height  : height of the BMP image (648)\r
 978 ///////                         Width   : width of the BMP image (1016)\r
 979 ///////                         Type    : type of monochrome dealing (threshold, floyd or dither)\r
 980 \r
 981 /////// Output parameter\r
 982 \r
 983 ///////                         lpBlack : pointer on the monochrome data, result of the color conversion\r
 984 //////////////////////////////////////////////////////////////////////////////////////\r
 985 void ConvertRVBtoK(unsigned char *lpbRVB, long RVBSize, long Height, long Width, unsigned char *lpBlack)\r
 986 {\r
 987         //long  y = 0,x = 0;\r
 988         //long  index_line = 0 , index_dot = 0;\r
 989 \r
 990         if (!(strcmp(TreatementK, "GE")))// == NULL)\r
 991         {\r
 992                 GrayToFloyd(lpbRVB, lpBlack, Width, Height);\r
 993         }\r
 994         else if (!(strcmp(TreatementK, "LM")))// == NULL)\r
 995         {\r
 996                 GrayToThreshold(lpbRVB, lpBlack, (RVBSize / 5));\r
 997         }\r
 998 \r
 999 \r
1000 }\r
1001 \r
1002 //========================================================//\r
1003 // OPTION : Not real black printed\r
1004 // Insert sublimable black from K panel to Y,M & C panels\r
1005 //========================================================//\r
1006 void KinYMC(long Height, long Width)\r
1007 {\r
1008         long dwSize, i;\r
1009         unsigned char *lpYellow, *lpMagenta, *lpCyan, *lpBlack;\r
1010 \r
1011 \r
1012         dwSize = Width * Height;\r
1013         lpYellow = &lpMem[0];\r
1014         lpMagenta = &lpMem[dwSize];\r
1015         lpCyan = &lpMem[2 * dwSize];\r
1016         lpBlack = &lpMem[3 * dwSize];\r
1017         for (i = 0; i < dwSize; i++)\r
1018         {\r
1019                 if (lpBlack[i])\r
1020                 {\r
1021                         lpYellow[i] |= lpBlack[i];\r
1022                         lpMagenta[i] |= lpBlack[i];\r
1023                         lpCyan[i] |= lpBlack[i];\r
1024                 }\r
1025         }\r
1026 }\r
1027  \r
1028 //========================================================//\r
1029 // OPTION : Get the first YMC printed dots\r
1030 //========================================================//\r
1031 void GetFirstYMCDot(long Height, long Width , int *x, int *y)\r
1032 {\r
1033         long dwSize, i=0;\r
1034         unsigned char *lpYellow, *lpMagenta, *lpCyan, *lpBlack;\r
1035   int fi = 0;\r
1036 \r
1037         dwSize = Width * Height;\r
1038         lpYellow = &lpMem[0];\r
1039         lpMagenta = &lpMem[dwSize];\r
1040         lpCyan = &lpMem[2 * dwSize];\r
1041         //for (i = 0; i < dwSize; i++)\r
1042   while(i < dwSize && !fi)\r
1043         {\r
1044                         if(lpYellow[i] || lpMagenta[i] || lpCyan[i] )\r
1045         fi = 1;\r
1046       i++;\r
1047         }\r
1048   *x = i % Width;\r
1049   *y = i / Width;\r
1050 }\r
1051                   \r
1052 // End of "evolis.c,v 1.0  ".\r