since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

since: 1.5 -

 ICC_Profile(long ID) 
{
    /* XYZNumber X */
        this.ID = ID;
}

Constructs an ICC_Profile object with a given ID.

 ICC_Profile(ProfileDeferralInfo pdi) 
{
        this.deferralInfo = pdi;
        this.profileActivator = new ProfileActivator() {
            public void activate() {
                activateDeferredProfile();
            }
        };
        ProfileDeferralMgr.registerDeferral(this.profileActivator);
}

Constructs an ICC_Profile object whose loading will be deferred. The ID will be 0 until the profile is loaded.

  void activateDeferredProfile() 
{
    byte profileData[];
    FileInputStream fis;
    String fileName = deferralInfo.filename;
        profileActivator = null;
        deferralInfo = null;
        if ((fis = openProfile(fileName)) == null) {
            throw new IllegalArgumentException("Cannot open file " + fileName);
        }
        try {
            profileData = getProfileDataFromStream(fis);
            fis.close();    /* close the file */
        }
        catch (IOException e) {
            throw new IllegalArgumentException("Invalid ICC Profile Data" +
                fileName);
        }
        if (profileData == null) {
            throw new IllegalArgumentException("Invalid ICC Profile Data" +
                fileName);
        }
        try {
            ID = CMSManager.getModule().loadProfile(profileData);
        } catch (CMMException c) {
            throw new IllegalArgumentException("Invalid ICC Profile Data" +
                fileName);
        }
}

 protected  void finalize() 
{
        if (ID != 0) {
            CMSManager.getModule().freeProfile(ID);
        } else if (profileActivator != null) {
            ProfileDeferralMgr.unregisterDeferral(profileActivator);
        }
}

Frees the resources associated with an ICC_Profile object.

 public int getColorSpaceType() 
{
        if (deferralInfo != null) {
            return deferralInfo.colorSpaceType; /* Need to have this info for
                                                   ICC_ColorSpace without
                                                   causing a deferred profile
                                                   to be loaded */
        }
        return    getColorSpaceType(ID);
}

Returns the color space type. Returns one of the color space type constants defined by the ColorSpace class. This is the "input" color space of the profile. The type defines the number of components of the color space and the interpretation, e.g. TYPE_RGB identifies a color space with three components - red, green, and blue. It does not define the particular color characteristics of the space, e.g. the chromaticities of the primaries.

 static int getColorSpaceType(long profileID) 
{
    byte[] theHeader;
    int theColorSpaceSig, theColorSpace;
        theHeader = getData(profileID, icSigHead);
        theColorSpaceSig = intFromBigEndian(theHeader, icHdrColorSpace);
        theColorSpace = iccCStoJCS (theColorSpaceSig);
        return theColorSpace;
}

 public byte[] getData() 
{
    int profileSize;
    byte[] profileData;
        if (ProfileDeferralMgr.deferring) {
            ProfileDeferralMgr.activateProfiles();
        }
        PCMM mdl = CMSManager.getModule();
        /* get the number of bytes needed for this profile */
        profileSize = mdl.getProfileSize(ID);
        profileData = new byte [profileSize];
        /* get the data for the profile */
        mdl.getProfileData(ID, profileData);
        return profileData;
}

Returns a byte array corresponding to the data of this ICC_Profile.

 public byte[] getData(int tagSignature) 
{
        if (ProfileDeferralMgr.deferring) {
            ProfileDeferralMgr.activateProfiles();
        }
        return getData(ID, tagSignature);
}

Returns a particular tagged data element from the profile as a byte array. Elements are identified by signatures as defined in the ICC specification. The signature icSigHead can be used to get the header. This method is useful for advanced applets or applications which need to access profile data directly.

 static byte[] getData(long profileID,
    int tagSignature) 
{
    int tagSize;
    byte[] tagData;
        try {
            PCMM mdl = CMSManager.getModule();
            /* get the number of bytes needed for this tag */
            tagSize = mdl.getTagSize(profileID, tagSignature);
            tagData = new byte[tagSize]; /* get an array for the tag */
            /* get the tag's data */
            mdl.getTagData(profileID, tagSignature, tagData);
        } catch(CMMException c) {
            tagData = null;
        }
        return tagData;
}

 static ICC_Profile getDeferredInstance(ProfileDeferralInfo pdi) throws IOException 
{
        if (!ProfileDeferralMgr.deferring) {
            return getStandardProfile(pdi.filename);
        }
        if (pdi.colorSpaceType == ColorSpace.TYPE_RGB) {
            return new ICC_ProfileRGB(pdi);
        } else if (pdi.colorSpaceType == ColorSpace.TYPE_GRAY) {
            return new ICC_ProfileGray(pdi);
        } else {
            return new ICC_Profile(pdi);
        }
}

Constructs an ICC_Profile for which the actual loading of the profile data from a file and the initialization of the CMM should be deferred as long as possible. Deferral is only used for standard profiles. If deferring is disabled, then getStandardProfile() ensures that all of the appropriate access privileges are granted when loading this profile. If deferring is enabled, then the deferred activation code will take care of access privileges.

 float getGamma(int theTagSignature) 
{
    byte[] theTRCData;
    float theGamma;
    int theU8Fixed8;
        theTRCData = getData(theTagSignature); /* get the TRC */
                                               /* getData will activate deferred
                                                  profiles if necessary */
        if (intFromBigEndian (theTRCData, icCurveCount) != 1) {
            throw new ProfileDataException ("TRC is not a gamma");
        }
        /* convert u8Fixed8 to float */
        theU8Fixed8 = (shortFromBigEndian(theTRCData, icCurveData)) & 0xffff;
        theGamma = ((float) theU8Fixed8) / 256.0f;
        return theGamma;
}

Returns a gamma value representing a tone reproduction curve (TRC). If the profile represents the TRC as a table rather than a single gamma value, then an exception is thrown. In this case the actual table can be obtained via getTRC(). theTagSignature should be one of icSigGrayTRCTag, icSigRedTRCTag, icSigGreenTRCTag, or icSigBlueTRCTag.

 public static ICC_Profile getInstance(byte[] data) 
{
    ICC_Profile thisProfile;
        long theID;
        if (ProfileDeferralMgr.deferring) {
            ProfileDeferralMgr.activateProfiles();
        }
        try {
            theID = CMSManager.getModule().loadProfile(data);
        } catch (CMMException c) {
            throw new IllegalArgumentException("Invalid ICC Profile Data");
        }
        try {
            if ((getColorSpaceType (theID) == ColorSpace.TYPE_GRAY) &&
                (getData (theID, icSigMediaWhitePointTag) != null) &&
                (getData (theID, icSigGrayTRCTag) != null)) {
                thisProfile = new ICC_ProfileGray (theID);
            }
            else if ((getColorSpaceType (theID) == ColorSpace.TYPE_RGB) &&
                (getData (theID, icSigMediaWhitePointTag) != null) &&
                (getData (theID, icSigRedColorantTag) != null) &&
                (getData (theID, icSigGreenColorantTag) != null) &&
                (getData (theID, icSigBlueColorantTag) != null) &&
                (getData (theID, icSigRedTRCTag) != null) &&
                (getData (theID, icSigGreenTRCTag) != null) &&
                (getData (theID, icSigBlueTRCTag) != null)) {
                thisProfile = new ICC_ProfileRGB (theID);
            }
            else {
                thisProfile = new ICC_Profile (theID);
            }
        } catch (CMMException c) {
            thisProfile = new ICC_Profile (theID);
        }
        return thisProfile;
}

Constructs an ICC_Profile object corresponding to the data in a byte array. Throws an IllegalArgumentException if the data does not correspond to a valid ICC Profile.

 public static ICC_Profile getInstance(int cspace) 
{
        ICC_Profile thisProfile = null;
        String fileName;
        switch (cspace) {
        case ColorSpace.CS_sRGB:
            synchronized(ICC_Profile.class) {
                if (sRGBprofile == null) {
                    try {
                        /*
                         * Deferral is only used for standard profiles.
                         * Enabling the appropriate access privileges is handled
                         * at a lower level.
                         */
                        sRGBprofile = getDeferredInstance(
                            new ProfileDeferralInfo("sRGB.pf",
                                                    ColorSpace.TYPE_RGB,
                                                    3, CLASS_DISPLAY));
                    } catch (IOException e) {
                        throw new IllegalArgumentException(
                              "Can't load standard profile: sRGB.pf");
                    }
                }
                thisProfile = sRGBprofile;
            }
            break;
        case ColorSpace.CS_CIEXYZ:
            synchronized(ICC_Profile.class) {
                if (XYZprofile == null) {
                    XYZprofile = getStandardProfile("CIEXYZ.pf");
                }
                thisProfile = XYZprofile;
            }
            break;
        case ColorSpace.CS_PYCC:
            synchronized(ICC_Profile.class) {
                if (PYCCprofile == null) {
                    PYCCprofile = getStandardProfile("PYCC.pf");
                }
                thisProfile = PYCCprofile;
            }
            break;
        case ColorSpace.CS_GRAY:
            synchronized(ICC_Profile.class) {
                if (GRAYprofile == null) {
                    GRAYprofile = getStandardProfile("GRAY.pf");
                }
                thisProfile = GRAYprofile;
            }
            break;
        case ColorSpace.CS_LINEAR_RGB:
            synchronized(ICC_Profile.class) {
                if (LINEAR_RGBprofile == null) {
                    LINEAR_RGBprofile = getStandardProfile("LINEAR_RGB.pf");
                }
                thisProfile = LINEAR_RGBprofile;
            }
            break;
        default:
            throw new IllegalArgumentException("Unknown color space");
        }
        return thisProfile;
}

Constructs an ICC_Profile corresponding to one of the specific color spaces defined by the ColorSpace class (for example CS_sRGB). Throws an IllegalArgumentException if cspace is not one of the defined color spaces.

 public static ICC_Profile getInstance(String fileName) throws IOException 
{
    ICC_Profile thisProfile;
    FileInputStream fis;
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(fileName);
        }
        if ((fis = openProfile(fileName)) == null) {
            throw new IOException("Cannot open file " + fileName);
        }
        thisProfile = getInstance(fis);
        fis.close();    /* close the file */
        return thisProfile;
}

Constructs an ICC_Profile corresponding to the data in a file. fileName may be an absolute or a relative file specification. Relative file names are looked for in several places: first, relative to any directories specified by the java.iccprofile.path property; second, relative to any directories specified by the java.class.path property; finally, in a directory used to store profiles always available, such as the profile for sRGB. Built-in profiles use .pf as the file name extension for profiles, e.g. sRGB.pf. This method throws an IOException if the specified file cannot be opened or if an I/O error occurs while reading the file. It throws an IllegalArgumentException if the file does not contain valid ICC Profile data.

 public static ICC_Profile getInstance(InputStream s) throws IOException 
{
    byte profileData[];
        if (s instanceof ProfileDeferralInfo) {
            /* hack to detect profiles whose loading can be deferred */
            return getDeferredInstance((ProfileDeferralInfo) s);
        }
        if ((profileData = getProfileDataFromStream(s)) == null) {
            throw new IllegalArgumentException("Invalid ICC Profile Data");
        }
        return getInstance(profileData);
}

Constructs an ICC_Profile corresponding to the data in an InputStream. This method throws an IllegalArgumentException if the stream does not contain valid ICC Profile data. It throws an IOException if an I/O error occurs while reading the stream.

 public int getMajorVersion() 
{
    byte[] theHeader;
        theHeader = getData(icSigHead); /* getData will activate deferred
                                           profiles if necessary */
        return (int) theHeader[8];
}

Returns profile major version.

 float[] getMediaWhitePoint() 
{
        return getXYZTag(icSigMediaWhitePointTag);
                                           /* get the media white point tag */
}

Returns a float array of length 3 containing the X, Y, and Z components of the mediaWhitePointTag in the ICC profile.

 public int getMinorVersion() 
{
    byte[] theHeader;
        theHeader = getData(icSigHead); /* getData will activate deferred
                                           profiles if necessary */
        return (int) theHeader[9];
}

Returns profile minor version.

 public int getNumComponents() 
{
    byte[]    theHeader;
    int    theColorSpaceSig, theNumComponents;
        if (deferralInfo != null) {
            return deferralInfo.numComponents; /* Need to have this info for
                                                  ICC_ColorSpace without
                                                  causing a deferred profile
                                                  to be loaded */
        }
        theHeader = getData(icSigHead);
        theColorSpaceSig = intFromBigEndian (theHeader, icHdrColorSpace);
        switch (theColorSpaceSig) {
        case icSigGrayData:
            theNumComponents = 1;
            break;
        case icSigSpace2CLR:
            theNumComponents = 2;
            break;
        case icSigXYZData:
        case icSigLabData:
        case icSigLuvData:
        case icSigYCbCrData:
        case icSigYxyData:
        case icSigRgbData:
        case icSigHsvData:
        case icSigHlsData:
        case icSigCmyData:
        case icSigSpace3CLR:
            theNumComponents = 3;
            break;
        case icSigCmykData:
        case icSigSpace4CLR:
            theNumComponents = 4;
            break;
        case icSigSpace5CLR:
            theNumComponents = 5;
            break;
        case icSigSpace6CLR:
            theNumComponents = 6;
            break;
        case icSigSpace7CLR:
            theNumComponents = 7;
            break;
        case icSigSpace8CLR:
            theNumComponents = 8;
            break;
        case icSigSpace9CLR:
            theNumComponents = 9;
            break;
        case icSigSpaceACLR:
            theNumComponents = 10;
            break;
        case icSigSpaceBCLR:
            theNumComponents = 11;
            break;
        case icSigSpaceCCLR:
            theNumComponents = 12;
            break;
        case icSigSpaceDCLR:
            theNumComponents = 13;
            break;
        case icSigSpaceECLR:
            theNumComponents = 14;
            break;
        case icSigSpaceFCLR:
            theNumComponents = 15;
            break;
        default:
            throw new ProfileDataException ("invalid ICC color space");
        }
        return theNumComponents;
}

Returns the number of color components in the "input" color space of this profile. For example if the color space type of this profile is TYPE_RGB, then this method will return 3.

 public int getPCSType() 
{
        if (ProfileDeferralMgr.deferring) {
            ProfileDeferralMgr.activateProfiles();
        }
        return getPCSType(ID);
}

Returns the color space type of the Profile Connection Space (PCS). Returns one of the color space type constants defined by the ColorSpace class. This is the "output" color space of the profile. For an input, display, or output profile useful for tagging colors or images, this will be either TYPE_XYZ or TYPE_Lab and should be interpreted as the corresponding specific color space defined in the ICC specification. For a device link profile, this could be any of the color space type constants.

 static int getPCSType(long profileID) 
{
    byte[] theHeader;
    int thePCSSig, thePCS;
        theHeader = getData(profileID, icSigHead);
        thePCSSig = intFromBigEndian(theHeader, icHdrPcs);
        thePCS = iccCStoJCS(thePCSSig);
        return thePCS;
}

 public int getProfileClass() 
{
    byte[] theHeader;
    int theClassSig, theClass;
        if (deferralInfo != null) {
            return deferralInfo.profileClass; /* Need to have this info for
                                                 ICC_ColorSpace without
                                                 causing a deferred profile
                                                 to be loaded */
        }
        theHeader = getData(icSigHead);
        theClassSig = intFromBigEndian (theHeader, icHdrDeviceClass);
        switch (theClassSig) {
        case icSigInputClass:
            theClass = CLASS_INPUT;
            break;
        case icSigDisplayClass:
            theClass = CLASS_DISPLAY;
            break;
        case icSigOutputClass:
            theClass = CLASS_OUTPUT;
            break;
        case icSigLinkClass:
            theClass = CLASS_DEVICELINK;
            break;
        case icSigColorSpaceClass:
            theClass = CLASS_COLORSPACECONVERSION;
            break;
        case icSigAbstractClass:
            theClass = CLASS_ABSTRACT;
            break;
        case icSigNamedColorClass:
            theClass = CLASS_NAMEDCOLOR;
            break;
        default:
            throw new IllegalArgumentException("Unknown profile class");
        }
        return theClass;
}

Returns the profile class.

 static byte[] getProfileDataFromStream(InputStream s) throws IOException 
{
    byte profileData[];
    int profileSize;
        byte header[] = new byte[128];
        int bytestoread = 128;
        int bytesread = 0;
        int n;
        while (bytestoread != 0) {
            if ((n = s.read(header, bytesread, bytestoread)) <  0) {
                return null;
            }
            bytesread += n;
            bytestoread -= n;
        }
        if (header[36] != 0x61 || header[37] != 0x63 ||
            header[38] != 0x73 || header[39] != 0x70) {
            return null;   /* not a valid profile */
        }
        profileSize = ((header[0] & 0xff) < <  24) |
                      ((header[1] & 0xff) < <  16) |
                      ((header[2] & 0xff) < <   8) |
                       (header[3] & 0xff);
        profileData = new byte[profileSize];
        System.arraycopy(header, 0, profileData, 0, 128);
        bytestoread = profileSize - 128;
        bytesread = 128;
        while (bytestoread != 0) {
            if ((n = s.read(profileData, bytesread, bytestoread)) <  0) {
                return null;
            }
            bytesread += n;
            bytestoread -= n;
        }
        return profileData;
}

 int getRenderingIntent() 
{
        byte[] theHeader = getData(icSigHead);/* getData will activate deferred
                                                 profiles if necessary */
        int renderingIntent = intFromBigEndian(theHeader, icHdrRenderingIntent);
                                                 /* set the rendering intent */
        return renderingIntent;
}

Returns the rendering intent of the profile. This is used to select the proper transform from a profile that has multiple transforms. It is typically set in a source profile to select a transform from an output profile.

 short[] getTRC(int theTagSignature) 
{
    byte[] theTRCData;
    short[] theTRC;
    int i1, i2, nElements, theU8Fixed8;
        theTRCData = getData(theTagSignature); /* get the TRC */
                                               /* getData will activate deferred
                                                  profiles if necessary */
        nElements = intFromBigEndian(theTRCData, icCurveCount);
        if (nElements == 1) {
            throw new ProfileDataException("TRC is not a table");
        }
        /* make the short array */
        theTRC = new short [nElements];
        for (i1 = 0, i2 = icCurveData; i1 <  nElements; i1++, i2 += 2) {
            theTRC[i1] = shortFromBigEndian(theTRCData, i2);
        }
        return theTRC;
}

Returns the TRC as an array of shorts. If the profile has specified the TRC as linear (gamma = 1.0) or as a simple gamma value, this method throws an exception, and the getGamma() method should be used to get the gamma value. Otherwise the short array returned here represents a lookup table where the input Gray value is conceptually in the range [0.0, 1.0]. Value 0.0 maps to array index 0 and value 1.0 maps to array index length-1. Interpolation may be used to generate output values for input values which do not map exactly to an index in the array. Output values also map linearly to the range [0.0, 1.0]. Value 0.0 is represented by an array value of 0x0000 and value 1.0 by 0xFFFF, i.e. the values are really unsigned short values, although they are returned in a short array. theTagSignature should be one of icSigGrayTRCTag, icSigRedTRCTag, icSigGreenTRCTag, or icSigBlueTRCTag.

 float[] getXYZTag(int theTagSignature) 
{
    byte[] theData;
    float[] theXYZNumber;
    int i1, i2, theS15Fixed16;
        theData = getData(theTagSignature); /* get the tag data */
                                            /* getData will activate deferred
                                               profiles if necessary */
        theXYZNumber = new float [3];        /* array to return */
        /* convert s15Fixed16Number to float */
        for (i1 = 0, i2 = icXYZNumberX; i1 <  3; i1++, i2 += 4) {
            theS15Fixed16 = intFromBigEndian(theData, i2);
            theXYZNumber [i1] = ((float) theS15Fixed16) / 65536.0f;
        }
        return theXYZNumber;
}

Returns a float array of length 3 containing the X, Y, and Z components encoded in an XYZType tag.

 static int iccCStoJCS(int theColorSpaceSig) 
{
    int theColorSpace;
        switch (theColorSpaceSig) {
        case icSigXYZData:
            theColorSpace = ColorSpace.TYPE_XYZ;
            break;
        case icSigLabData:
            theColorSpace = ColorSpace.TYPE_Lab;
            break;
        case icSigLuvData:
            theColorSpace = ColorSpace.TYPE_Luv;
            break;
        case icSigYCbCrData:
            theColorSpace = ColorSpace.TYPE_YCbCr;
            break;
        case icSigYxyData:
            theColorSpace = ColorSpace.TYPE_Yxy;
            break;
        case icSigRgbData:
            theColorSpace = ColorSpace.TYPE_RGB;
            break;
        case icSigGrayData:
            theColorSpace = ColorSpace.TYPE_GRAY;
            break;
        case icSigHsvData:
            theColorSpace = ColorSpace.TYPE_HSV;
            break;
        case icSigHlsData:
            theColorSpace = ColorSpace.TYPE_HLS;
            break;
        case icSigCmykData:
            theColorSpace = ColorSpace.TYPE_CMYK;
            break;
        case icSigCmyData:
            theColorSpace = ColorSpace.TYPE_CMY;
            break;
        case icSigSpace2CLR:
            theColorSpace = ColorSpace.TYPE_2CLR;
            break;
        case icSigSpace3CLR:
            theColorSpace = ColorSpace.TYPE_3CLR;
            break;
        case icSigSpace4CLR:
            theColorSpace = ColorSpace.TYPE_4CLR;
            break;
        case icSigSpace5CLR:
            theColorSpace = ColorSpace.TYPE_5CLR;
            break;
        case icSigSpace6CLR:
            theColorSpace = ColorSpace.TYPE_6CLR;
            break;
        case icSigSpace7CLR:
            theColorSpace = ColorSpace.TYPE_7CLR;
            break;
        case icSigSpace8CLR:
            theColorSpace = ColorSpace.TYPE_8CLR;
            break;
        case icSigSpace9CLR:
            theColorSpace = ColorSpace.TYPE_9CLR;
            break;
        case icSigSpaceACLR:
            theColorSpace = ColorSpace.TYPE_ACLR;
            break;
        case icSigSpaceBCLR:
            theColorSpace = ColorSpace.TYPE_BCLR;
            break;
        case icSigSpaceCCLR:
            theColorSpace = ColorSpace.TYPE_CCLR;
            break;
        case icSigSpaceDCLR:
            theColorSpace = ColorSpace.TYPE_DCLR;
            break;
        case icSigSpaceECLR:
            theColorSpace = ColorSpace.TYPE_ECLR;
            break;
        case icSigSpaceFCLR:
            theColorSpace = ColorSpace.TYPE_FCLR;
            break;
        default:
            throw new IllegalArgumentException ("Unknown color space");
        }
        return theColorSpace;
}

 static int intFromBigEndian(byte[] array,
    int index) 
{
        return (((array[index]   & 0xff) < <  24) |
                ((array[index+1] & 0xff) < <  16) |
                ((array[index+2] & 0xff) < <   8) |
                 (array[index+3] & 0xff));
}

 static  void intToBigEndian(int value,
    byte[] array,
    int index) 
{
            array[index]   = (byte) (value  > > 24);
            array[index+1] = (byte) (value  > > 16);
            array[index+2] = (byte) (value  > >  8);
            array[index+3] = (byte) (value);
}

 protected Object readResolve() throws ObjectStreamException 
{
        return resolvedDeserializedProfile;
}

Resolves instances being deserialized into instances registered with CMM.

 public  void setData(int tagSignature,
    byte[] tagData) 
{
        if (ProfileDeferralMgr.deferring) {
            ProfileDeferralMgr.activateProfiles();
        }
        CMSManager.getModule().setTagData(ID, tagSignature, tagData);
}

Sets a particular tagged data element in the profile from a byte array. This method is useful for advanced applets or applications which need to access profile data directly.

  void setRenderingIntent(int renderingIntent) 
{
        byte[] theHeader = getData(icSigHead);/* getData will activate deferred
                                                 profiles if necessary */
        intToBigEndian (renderingIntent, theHeader, icHdrRenderingIntent);
                                                 /* set the rendering intent */
        setData (icSigHead, theHeader);
}

Sets the rendering intent of the profile. This is used to select the proper transform from a profile that has multiple transforms.

 static short shortFromBigEndian(byte[] array,
    int index) 
{
        return (short) (((array[index]   & 0xff) < <  8) |
                         (array[index+1] & 0xff));
}

 static  void shortToBigEndian(short value,
    byte[] array,
    int index) 
{
            array[index]   = (byte) (value  > > 8);
            array[index+1] = (byte) (value);
}

 public  void write(String fileName) throws IOException 
{
    FileOutputStream outputFile;
    byte profileData[];
        profileData = getData(); /* this will activate deferred
                                    profiles if necessary */
        outputFile = new FileOutputStream(fileName);
        outputFile.write(profileData);
        outputFile.close ();
}

Write this ICC_Profile to a file.

 public  void write(OutputStream s) throws IOException 
{
    byte profileData[];
        profileData = getData(); /* this will activate deferred
                                    profiles if necessary */
        s.write(profileData);
}

Write this ICC_Profile to an OutputStream.