cmsio1.c

Linux下的无线网卡通用驱动程序

}


const char* LCMSEXPORT cmsTakeCopyright(cmsHPROFILE hProfile)
{

    static char Copyright[512] = "";

       Copyright[0] = 0;   

       if (cmsIsTag(hProfile, icSigCopyrightTag)) {

            cmsReadICCText(hProfile, icSigCopyrightTag, Copyright);
       }

    return Copyright;
}


// We compute name with model - manufacturer

const char*  LCMSEXPORT cmsTakeProductName(cmsHPROFILE hProfile)
{
    static char Name[2048];
    char Manufacturer[512], Model[512];
    
    Name[0] = '\0';
    Manufacturer[0] = Model[0] = '\0';
    
    if (cmsIsTag(hProfile, icSigDeviceMfgDescTag)) {
        
        cmsReadICCText(hProfile, icSigDeviceMfgDescTag, Manufacturer);
    }
    
    if (cmsIsTag(hProfile, icSigDeviceModelDescTag)) {
        
        cmsReadICCText(hProfile, icSigDeviceModelDescTag, Model);
    }
    
    if (!Manufacturer[0] && !Model[0]) {
        
        if (cmsIsTag(hProfile, icSigProfileDescriptionTag)) {
            
            cmsReadICCText(hProfile, icSigProfileDescriptionTag, Name);
            return Name;
        }
        else return "{no name}";
    }
    
    
    if (!Manufacturer[0] || 
            strncmp(Model, Manufacturer, 8) == 0 || strlen(Model) > 30)
        strcpy(Name, Model);
    else
        sprintf(Name, "%s - %s", Model, Manufacturer);
    
    return Name;
    
}


// We compute desc with manufacturer - model

const char*  LCMSEXPORT cmsTakeProductDesc(cmsHPROFILE hProfile)
{
       static char Name[2048];

       if (cmsIsTag(hProfile, icSigProfileDescriptionTag)) {

              cmsReadICCText(hProfile, icSigProfileDescriptionTag, Name);
       }
       else return cmsTakeProductName(hProfile);

       if (strncmp(Name, "Copyrig", 7) == 0)
              return cmsTakeProductName(hProfile);

       return Name;
}


const char*  LCMSEXPORT cmsTakeProductInfo(cmsHPROFILE hProfile)
{       
       LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;

       static char Info[4096];

       Info[0] = '\0';

       if (cmsIsTag(hProfile, icSigProfileDescriptionTag))
       {
       char Desc[1024];

       cmsReadICCText(hProfile, icSigProfileDescriptionTag, Desc);
       strcat(Info, Desc);
       strcat(Info, "\r\n\r\n");
       }


       if (cmsIsTag(hProfile, icSigCopyrightTag))
       {
       char Copyright[2048];

       cmsReadICCText(hProfile, icSigCopyrightTag, Copyright);
       strcat(Info, Copyright);
       strcat(Info, "\r\n\r\n");
       }



// KODAK private tag... But very useful

#define K007         (icTagSignature)0x4B303037

       // MonCal

       if (cmsIsTag(hProfile, K007))
       {
       char MonCal[1024];

       cmsReadICCText(hProfile, K007, MonCal);
       strcat(Info, MonCal);
       strcat(Info, "\r\n\r\n");
       }
       else
       {
       cmsCIEXYZ WhitePt;
       char WhiteStr[1024];

       cmsTakeMediaWhitePoint(&WhitePt, hProfile);
       _cmsIdentifyWhitePoint(WhiteStr, &WhitePt);
       strcat(WhiteStr, "\r\n\r\n");
       strcat(Info, WhiteStr);
       }


       if (Icc -> stream) {
              strcat(Info, Icc -> PhysicalFile);
       }
       return Info;
}

// Extract the target data as a big string. Does not signal if tag is not present.

BOOL LCMSEXPORT cmsTakeCharTargetData(cmsHPROFILE hProfile, char** Data, size_t* len)
{
    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
    int n;

    *Data = NULL;
    *len  = 0;

    n = _cmsSearchTag(Icc, icSigCharTargetTag, FALSE);
    if (n < 0) return FALSE;                


    *len =  Icc -> TagSizes[n];
    *Data = (char*) malloc(*len + 1);

    if (!*Data) {

        cmsSignalError(LCMS_ERRC_ABORTED, "Out of memory allocating CharTarget space!");
        return FALSE;
    }

    if (cmsReadICCText(hProfile, icSigCharTargetTag, *Data) < 0) 
        return FALSE;

    (*Data)[*len] = 0;  // Force a zero marker. Shouldn't be needed, but is 
                        // here to simplify things.

    return TRUE;    
}




BOOL LCMSEXPORT cmsTakeCalibrationDateTime(struct tm *Dest, cmsHPROFILE hProfile)
{
    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;    
    int n;
    
    n = _cmsSearchTag(Icc, icSigCalibrationDateTimeTag, FALSE);
    if (n < 0) return FALSE;
    
    if (!Icc ->stream)
    {
        CopyMemory(Dest, Icc ->TagPtrs[n],  sizeof(struct tm));
    }
    else
    {
        icDateTimeNumber timestamp;

        if (Icc -> Seek(Icc, Icc -> TagOffsets[n] + sizeof(icTagBase)))
            return FALSE;
        
        if (Icc ->Read(&timestamp, 1, sizeof(icDateTimeNumber), Icc) != sizeof(icDateTimeNumber))
            return FALSE;
        
        DecodeDateTimeNumber(&timestamp, Dest);
    }

    
    return TRUE;
}



// PSEQ Tag, used in devicelink profiles

LPcmsSEQ LCMSEXPORT cmsReadProfileSequenceDescription(cmsHPROFILE hProfile)
{
    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
    int n;
    icUInt32Number     i, Count;
    icDescStruct       DescStruct;    
    icTagTypeSignature BaseType;
    size_t             size, offset;
    LPcmsSEQ           OutSeq;


    n = _cmsSearchTag(Icc, icSigProfileSequenceDescTag, FALSE);
    if (n < 0) return NULL;                
    
    size   = Icc -> TagSizes[n]; 
    if (size < 12)  return NULL;

    if (!Icc -> stream) {
                                   
            OutSeq = (LPcmsSEQ) malloc(size);           
            CopyMemory(OutSeq, Icc ->TagPtrs[n], size);    
            return OutSeq;
    }

    offset = Icc -> TagOffsets[n];
    
    if (Icc -> Seek(Icc, offset))
            return NULL;

    BaseType = ReadBase(Icc);
    
    if (BaseType != icSigProfileSequenceDescType) return NULL;

    Icc ->Read(&Count, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &Count);
    
    size = sizeof(int) + Count * sizeof(cmsPSEQDESC);
    OutSeq = (LPcmsSEQ) malloc(size);

    OutSeq ->n = Count;
    
    // Get structures as well

    for (i=0; i < Count; i++) {
        
        LPcmsPSEQDESC sec = &OutSeq -> seq[i];

        Icc -> Read(&DescStruct, sizeof(icDescStruct) - SIZEOF_UINT8_ALIGNED, 1, Icc);

        AdjustEndianess32((LPBYTE) &DescStruct.deviceMfg);
        AdjustEndianess32((LPBYTE) &DescStruct.deviceModel);
        AdjustEndianess32((LPBYTE) &DescStruct.technology);
        AdjustEndianess32((LPBYTE) &DescStruct.attributes[0]);
        AdjustEndianess32((LPBYTE) &DescStruct.attributes[1]);

        sec ->attributes[0] = DescStruct.attributes[0];
        sec ->attributes[1] = DescStruct.attributes[1];
        sec ->deviceMfg     = DescStruct.deviceMfg;
        sec ->deviceModel   = DescStruct.deviceModel;
        sec ->technology    = DescStruct.technology;

        if (ReadEmbeddedTextTag(Icc, size, sec ->Manufacturer) < 0) return NULL;
        if (ReadEmbeddedTextTag(Icc, size, sec ->Model) < 0) return NULL;

    }

    return OutSeq;
}



// Extended gamut -- an HP extension


LPcmsGAMUTEX LCMSEXPORT cmsReadExtendedGamut(cmsHPROFILE hProfile, int index)
{
    LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;    
    size_t size, offset;
    icUInt32Number off_samp, off_desc, off_vc;
    int n;
    icTagTypeSignature     BaseType;
    icColorSpaceSignature  CoordSig;
    icUInt16Number         Method, Usage;
    icUInt32Number         GamutCount, SamplesCount;
    LPcmsGAMUTEX gex;
    size_t                 Offsets[256];
    size_t                 i, Actual, Loc;
    icS15Fixed16Number     Num;
    icUInt16Number         Surround;
    

    n = _cmsSearchTag(Icc, icSigHPGamutDescTag, FALSE);
    if (n < 0) return NULL;
    
    if (!Icc ->stream) return NULL;     // In memory is not supported
  
    // Read the header

    offset = Icc -> TagOffsets[n];

    if (Icc -> Seek(Icc, offset))
            return NULL;

    // Here is the beginning of tag
    Actual   = Icc ->Tell(Icc);


    BaseType = ReadBase(Icc);
    
    if (BaseType != icSigHPGamutDescType) {
            cmsSignalError(LCMS_ERRC_ABORTED, "Bad tag signature '%lx' found.", BaseType);
            return NULL;
    }


    // Read the gamut descriptors count
    Icc ->Read(&GamutCount, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &GamutCount); 


    if (GamutCount >= 256) {
            cmsSignalError(LCMS_ERRC_ABORTED, "Too many gamut structures '%d'.", GamutCount);
            return NULL;
    }
    
    // Read the directory

    for (i=0; i < GamutCount; i++) {

        Icc ->Read(&Offsets[i], sizeof(icUInt32Number), 1, Icc);
        AdjustEndianess32((LPBYTE) &Offsets[i]); 
    }

    
    // Is there such element?
    if (index >= (int) GamutCount) return NULL; 
    Loc = Actual + Offsets[index];


    // Go to specified index
    if (Icc -> Seek(Icc, Loc))
            return NULL;
   

    // Read all members
    Icc ->Read(&CoordSig, sizeof(icColorSpaceSignature), 1, Icc);
    AdjustEndianess32((LPBYTE) &CoordSig); 

    Icc ->Read(&Method, sizeof(icUInt16Number), 1, Icc);
    AdjustEndianess16((LPBYTE) &Method); 

    Icc ->Read(&Usage, sizeof(icUInt16Number), 1, Icc);
    AdjustEndianess16((LPBYTE) &Usage); 

    Icc ->Read(&SamplesCount, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &SamplesCount); 

    Icc ->Read(&off_samp, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &off_samp); 

    Icc ->Read(&off_desc, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &off_desc); 

    Icc ->Read(&off_vc, sizeof(icUInt32Number), 1, Icc);
    AdjustEndianess32((LPBYTE) &off_vc); 
    

    size = sizeof(cmsGAMUTEX) + (SamplesCount - 1) * sizeof(double);

    gex = (LPcmsGAMUTEX) malloc(size);
	if (gex == NULL) return NULL;


    gex ->CoordSig = CoordSig;
    gex ->Method   = Method;
    gex ->Usage    = Usage;
	gex ->Count    = SamplesCount;


    // Read data
    if (Icc -> Seek(Icc, Loc + off_samp))
            return NULL;

    for (i=0; i < SamplesCount; i++) {          
                Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
                gex ->Data[i] = Convert15Fixed16(Num);
    }


    // Read mluc
    if (Icc -> Seek(Icc, Loc + off_desc)) {

			free(gex);
            return NULL;
	}

    ReadEmbeddedTextTag(Icc, 256, gex ->Description);


    // Read viewing conditions
    if (Icc -> Seek(Icc, Loc + off_vc)) {
			free(gex);
            return NULL;
	}


    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.whitePoint.X = Convert15Fixed16(Num);

    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.whitePoint.Y = Convert15Fixed16(Num);

    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.whitePoint.Z = Convert15Fixed16(Num);

    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.La = Convert15Fixed16(Num);

    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.Yb = Convert15Fixed16(Num);

    Icc -> Read(&Num, sizeof(icS15Fixed16Number), 1, Icc);
    gex ->Vc.D_value = Convert15Fixed16(Num);

    Icc -> Read(&Surround, sizeof(icUInt16Number), 1, Icc);
    AdjustEndianess16((LPBYTE) &Surround); 
    gex ->Vc.surround = Surround;


    // All OK
    return gex;

}



void LCMSEXPORT cmsFreeExtendedGamut(LPcmsGAMUTEX gex)
{
    if (gex) 
        free(gex);
}


// Read a few tags that are hardly required


static
void ReadCriticalTags(LPLCMSICCPROFILE Icc)
{
    cmsHPROFILE hProfile = (cmsHPROFILE) Icc;
     
    if (Icc ->Version >= 0x4000000) {

        // v4 profiles

        MAT3 ChrmCanonical;

         if (ReadICCXYZ(hProfile, 
                      icSigMediaWhitePointTag, 
                      &Icc ->MediaWhitePoint, FALSE) < 0) {

              Icc ->MediaWhitePoint = *cmsD50_XYZ();              
       }

       // Read media black

       if (ReadICCXYZ(hProfile, 
                      icSigMediaBlackPointTag, 
                      &Icc ->MediaBlackPoint, FALSE) < 0) {

              Icc ->MediaBla