hpiom.c

HP喷墨打印机驱动代码 HP内部资料！ 珍贵 珍贵 珍贵

   {  
      rlen = ma.length;
      memcpy(buf, ma.data, rlen);
   }

mordor:

   return rlen;
}

int OpenChannel(int hd, char *sn)
{
   char message[512];  
   int len=0, channel=-1;
   MsgAttributes ma;

   len = sprintf(message, "msg=ChannelOpen\ndevice-id=%d\nservice-name=%s\n", hd, sn);

   if (send(hpiod_socket, message, len, 0) == -1) 
   {  
      bug("unable to send ChannelOpen: %m\n");  
      goto mordor;  
   }  

   if ((len = recv(hpiod_socket, message, sizeof(message), 0)) == -1) 
   {  
      bug("unable to receive ChannelOpenResult: %m\n");  
      goto mordor;
   }  

   message[len] = 0;

   ParseMsg(message, len, &ma);
   if (ma.result == R_AOK)
      channel = ma.channel;

mordor:

   return channel;
}

int CloseChannel(int hd, int channel)
{
   char message[512];  
   int len=0;

   len = sprintf(message, "msg=ChannelClose\ndevice-id=%d\nchannel-id=%d\n", hd, channel);
 
   if (send(hpiod_socket, message, len, 0) == -1) 
   {  
      bug("unable to send ChannelClose: %m\n");  
      goto mordor;  
   }  

   if ((len = recv(hpiod_socket, message, sizeof(message), 0)) == -1) 
   {  
      bug("unable to receive ChannelCloseResult: %m\n");  
      goto mordor;
   }  

   message[len] = 0;

mordor:

   return 0;
}

/*
 * Lidil commands.
 */

int EncodeCommand
(
   unsigned char *lpBuffer,
   unsigned short wBufferSize,
   unsigned char unUnitNumber,
   int ePacketType,
   int eCommandNumber,
   char *lpData,
   unsigned short wDataLength,
   unsigned char *lpCommandOptions,
   unsigned short wCommandOptionsSize,
   int *dPacketSize,
   unsigned short wRefNum
)
{
   int x;
   int lNumPaddingNeeded = 0;
   unsigned char *lpTemp = NULL;

   memset( lpBuffer, 0, wBufferSize );
   lpBuffer [ gUV8FrameOffset ]         = gcFrameMarker;
   lpBuffer [ gUV8UnitNumberOffset ]    = unUnitNumber;
   lpBuffer [ gE8PacketTypeOffset ]     = ePacketType;
   lpBuffer [ gUV8CommandNumberOffset ] = eCommandNumber;
   *(short *)(lpBuffer + gUV16DataLengthOffset) = htons(wDataLength);

   if ( wCommandOptionsSize > 0 )
   {   
      if ( lpCommandOptions )
      {
         // copy command options to the buffer
         memcpy(( lpBuffer + gUV8CommandOptionsOffset ), lpCommandOptions, wCommandOptionsSize);
      }
      else
      {
         // command option is null, fill the buffer with zeros
         memset(( lpBuffer + gUV8CommandOptionsOffset ), 0, wCommandOptionsSize );
      }
   }

   // calculate command length and padding if needed
   *dPacketSize = gnRequiredSize + wCommandOptionsSize;
   lNumPaddingNeeded = gnMinCommandSize - *dPacketSize;

   if ( lNumPaddingNeeded > 0 )
   {
      // move the pointer to the beginning of the padding
      lpTemp = lpBuffer + gUV8CommandOptionsOffset + wCommandOptionsSize;

      for (x = 0; x < lNumPaddingNeeded; x++, lpTemp++ )
      {
         *lpTemp = gnPadding;
      }
            
      *dPacketSize = gnMinCommandSize;
   }

   *(short *)(lpBuffer + gUV16CommandLengthOffset) = htons(*dPacketSize);
   *(short *)(lpBuffer + gUV16ReferenceNumberOffset) = htons(wRefNum ? wRefNum : 1);

   // add the trailing frame marker
   lpBuffer[ *dPacketSize - 1 ] = gcFrameMarker;

   if ( wDataLength )
   {            
      if ((*dPacketSize + wDataLength) > wBufferSize)
      {
          bug("unable to fill data buffer EncodeCommand size=%d\n", wDataLength);
          return 1;
      }   

      if ( lpData )
      {
          // copy the data to the end of the command
          memcpy( lpBuffer + *dPacketSize, lpData, wDataLength );
      }
      else
      {
          // NULL data pointer, fill the buffer with zeros
          memset( lpBuffer + *dPacketSize, 0, wDataLength );
      }

      *dPacketSize += wDataLength;
   }

   return 0;
}

int Synch(int hd, int chan)
{
    int bRet = 0;
    int dPacketSize = 0;
    unsigned char buf[4096];

    // create the Synch command, send it to the device, 
    // and retrieve absolute credit data from the device.
    EncodeCommand(buf, sizeof(buf)
                     , 0            
                     , eSynch
                     , eCommandUnknown
                     , NULL
                     , gnMaxDataSize
                     , NULL
                     , gnMaxCmdOptionSize
                     , &dPacketSize
                     , gwSynchRefNum
                     );

    bRet = WriteHP(hd, chan, buf, dPacketSize );

    return( bRet );
}

int SynchComplete(int hd, int chan)
{
    int bRet = 0;
    int dPacketSize = 0;
    unsigned char buf[32];

        // create the SynchComplete command, send it to the device, 
        // and retrieve absolute credit data from the device.
        EncodeCommand(buf, sizeof(buf)
                     , 0            
                     , eSynchComplete
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , gwSynchCompleteRefNum
                     );

    bRet = WriteHP(hd, chan, buf, dPacketSize );

    return( bRet );
}

int Reset(int hd, int chan)
{
    int bRet = 0;
    int dPacketSize = 0;
    unsigned char buf[32];

        // create the Reset command, send it to the device, 
        // and retrieve absolute credit data from the device.
        //
        EncodeCommand(buf, sizeof(buf)
                     , 0            
                     , eResetLidil
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , gwResetRefNum
                     );

        bRet = WriteHP(hd, chan, buf, dPacketSize );

    return( bRet );
}

int RetrieveAlignmentValues038(int hd, int chan, LDLGenAlign *pG)
{
   int n;
   int dPacketSize = 0;
   unsigned char buf[256];
   LDLResponseAlign038 *pA;

   /* Enable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eEnableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Write alignment query. */
   EncodeCommand(buf, sizeof(buf)
                     , 0             // device 0
                     , eCommand
                     , eQuery
                     , NULL
                     , 0
                     , gpAlignmentQuery
                     , gnPrinterQueryOptionsSize  
                     , &dPacketSize
                     , gwAlignmentQueryRefNum
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Disable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eDiableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );
 
   /* Read query response. */
   n = ReadHP(hd, chan, buf, sizeof(buf));
   pA = (LDLResponseAlign038 *)buf;
   memset(pG, 0, sizeof(LDLGenAlign));
   if (pA->h.packet_type == 16)
   {
      pG->nPens = 2;
      /* Except for bi, convert values from relative to black pen to relative to color. */
      pG->pen[0].color = 0;
      pG->pen[0].vert = -pA->c[0];
      pG->pen[0].horz = -pA->c[1];
      pG->pen[0].bi = pA->k[2];
      pG->pen[1].color = 1;
      pG->pen[1].vert = pA->k[0];
      pG->pen[1].horz = pA->k[1];
      pG->pen[1].bi = pA->c[2];
   }

   return 0;
}

int RetrieveAlignmentValues043(int hd, int chan, LDLGenAlign *pG)
{
   int n=0;
   int dPacketSize = 0;
   char buf[256];
   LDLResponseAlign043 *pA;

   /* Enable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eEnableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Write alignment query. */
   EncodeCommand(buf, sizeof(buf)
                     , 0             // device 0
                     , eCommand
                     , eQuery
                     , NULL
                     , 0
                     , gpPenAlignmentQuery 
                     , gnPrinterQueryOptionsSize  
                     , &dPacketSize
                     , gwAlignmentQueryRefNum
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Disable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eDiableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   n = ReadHP(hd, chan, buf, sizeof(buf));
   pA = (LDLResponseAlign043 *)buf;
   memset(pG, 0, sizeof(LDLGenAlign));
   if (pA->h.packet_type == 16)
   {
      memcpy(pG, &pA->g, sizeof(LDLGenAlign));
   }

   return 0;
}

uint32_t RetrieveVersion(int hd, int chan)
{
   int n, version=0;
   int dPacketSize = 0;
   char buf[256];
   LDLResponseVersion *pV;

   /* Enable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eEnableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Write lidil version query. */
   EncodeCommand(buf, sizeof(buf)
                     , 0             // device 0
                     , eCommand
                     , eQuery
                     , NULL
                     , 0
                     , gpPrinterVersionQuery
                     , gnPrinterQueryOptionsSize  
                     , &dPacketSize
                     , gwAlignmentQueryRefNum
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

   /* Disable responses. */
   EncodeCommand(buf, sizeof(buf)
                     , 0
                     , eDiableResponses
                     , eCommandUnknown
                     , NULL
                     , 0
                     , NULL
                     , 0
                     , &dPacketSize
                     , 0
                     );
   n = WriteHP(hd, chan, buf, dPacketSize );

        n = ReadHP(hd, chan, buf, sizeof(buf));
        pV = (LDLResponseVersion *)buf;
        if (pV->h.packet_type == 16)
        {
           version = ntohl(pV->ldlversion);
           fprintf(stdout, "lidil version = %x\n", version);
        }

    return(version);
}

/*
 * Return value = (black | photo) to color vertical alignment offset, error = -1.
 *
 * All alignment values may be zero if pen(s) were never aligned. Valid values
 * may range from -30 to +30.
 */
int ReadHPVertAlign(int hd)
{
   int channel, n, i, x2colorVert=-1;
   uint32_t ver;
   LDLGenAlign ga;

   if ((channel = OpenChannel(hd, "PRINT")) < 0)
   {
      bug("unable to open print channel ReadHPVertAlign\n");
      goto bugout;
   }

   if (Synch(hd, channel)==0)
   {  
      bug("unable to write sync ReadHPVertAlign\n");  
      goto bugout;  
   }  

   if (SynchComplete(hd, channel)==0)
   {  
      bug("unable to write sync complete ReadHPVertAlign\n");  
      goto bugout;  
   }  

   if (Reset(hd, channel)==0)
   {  
      bug("unable to write reset ReadHPVertAlign\n");  
      goto bugout;  
   }  

   if ((ver = RetrieveVersion(hd, channel))==0)
   {  
      bug("unable to read version ReadHPVertAlign\n");  
      goto bugout;  
   }  

   if (ver > 0x308)
      RetrieveAlignmentValues043(hd, channel, &ga);
   else 
      RetrieveAlignmentValues038(hd, channel, &ga);

   if (!(n = ga.nPens))
      goto bugout;

   for (i=0; i<n; i++)
   {
      if (ga.pen[i].color == 0 || ga.pen[i].color == 2)
      {
         x2colorVert = ga.pen[i].vert;  /* (black | photo) to color offset */
         bug("%s alignment: vert=%d horz=%d bi=%d x2c=%d\n", (ga.pen[i].color==0) ? "black" : "photo", ga.pen[i].vert, ga.pen[i].horz, ga.pen[i].bi, x2colorVert);
      }
   }

   Reset(hd, channel);

bugout: 
   if (channel >= 0)
      CloseChannel(hd, channel);

   return x2colorVert;
}