1. /*

  2.  * @(#)ICC_Profile.java	1.34 04/05/10

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. /**********************************************************************

  9.  **********************************************************************

  10.  **********************************************************************

  11.  *** COPYRIGHT (c) Eastman Kodak Company, 1997                      ***

  12.  *** As  an unpublished  work pursuant to Title 17 of the United    ***

  13.  *** States Code.  All rights reserved.                             ***

  14.  **********************************************************************

  15.  **********************************************************************

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

  17. 

  18. package java.awt.color;

  19. 

  20. import sun.awt.color.CMM;

  21. import sun.awt.color.ProfileDeferralMgr;

  22. import sun.awt.color.ProfileDeferralInfo;

  23. import sun.awt.color.ProfileActivator;

  24. 

  25. import java.io.File;

  26. import java.io.FileInputStream;

  27. import java.io.FileNotFoundException;

  28. import java.io.FileOutputStream;

  29. import java.io.IOException;

  30. import java.io.InputStream;

  31. import java.io.ObjectInputStream;

  32. import java.io.ObjectOutputStream;

  33. import java.io.ObjectStreamException;

  34. import java.io.OutputStream;

  35. import java.io.Serializable;

  36. 

  37. import java.util.StringTokenizer;

  38. 

  39. import java.security.AccessController;

  40. import java.security.PrivilegedAction;

  41. 

  42. /**

  43.  * A representation of color profile data for device independent and

  44.  * device dependent color spaces based on the International Color

  45.  * Consortium Specification ICC.1:2001-12, File Format for Color Profiles,

  46.  * (see <A href="http://www.color.org"> http://www.color.org</A>).

  47.  * <p>

  48.  * An ICC_ColorSpace object can be constructed from an appropriate

  49.  * ICC_Profile.

  50.  * Typically, an ICC_ColorSpace would be associated with an ICC

  51.  * Profile which is either an input, display, or output profile (see

  52.  * the ICC specification).  There are also device link, abstract,

  53.  * color space conversion, and named color profiles.  These are less

  54.  * useful for tagging a color or image, but are useful for other

  55.  * purposes (in particular device link profiles can provide improved

  56.  * performance for converting from one device's color space to

  57.  * another's).

  58.  * <p> 

  59.  * ICC Profiles represent transformations from the color space of

  60.  * the profile (e.g. a monitor) to a Profile Connection Space (PCS).

  61.  * Profiles of interest for tagging images or colors have a PCS

  62.  * which is one of the two specific device independent

  63.  * spaces (one CIEXYZ space and one CIELab space) defined in the

  64.  * ICC Profile Format Specification.  Most profiles of interest

  65.  * either have invertible transformations or explicitly specify

  66.  * transformations going both directions.

  67.  * <p>

  68.  * @version 10 Feb 1997

  69.  * @see ICC_ColorSpace

  70.  */

  71. 

  72. 

  73. public class ICC_Profile implements Serializable {

  74. 

  75.     private static final long serialVersionUID = -3938515861990936766L;

  76. 

  77.     transient long ID;

  78. 

  79.     private transient ProfileDeferralInfo deferralInfo;

  80.     private transient ProfileActivator profileActivator;

  81. 

  82.     // Registry of singleton profile objects for specific color spaces

  83.     // defined in the ColorSpace class (e.g. CS_sRGB), see

  84.     // getInstance(int cspace) factory method.

  85.     private static ICC_Profile sRGBprofile;

  86.     private static ICC_Profile XYZprofile;

  87.     private static ICC_Profile PYCCprofile;

  88.     private static ICC_Profile GRAYprofile;

  89.     private static ICC_Profile LINEAR_RGBprofile;

  90. 

  91. 

  92.     /**

  93.      * Profile class is input.

  94.      */

  95.     public static final int CLASS_INPUT = 0;

  96. 

  97.     /**

  98.      * Profile class is display.

  99.      */

  100.     public static final int CLASS_DISPLAY = 1;

  101. 

  102.     /**

  103.      * Profile class is output.

  104.      */

  105.     public static final int CLASS_OUTPUT = 2;

  106. 

  107.     /**

  108.      * Profile class is device link.

  109.      */

  110.     public static final int CLASS_DEVICELINK = 3;

  111. 

  112.     /**

  113.      * Profile class is color space conversion.

  114.      */

  115.     public static final int CLASS_COLORSPACECONVERSION = 4;

  116. 

  117.     /**

  118.      * Profile class is abstract.

  119.      */

  120.     public static final int CLASS_ABSTRACT = 5;

  121. 

  122.     /**

  123.      * Profile class is named color.

  124.      */

  125.     public static final int CLASS_NAMEDCOLOR = 6;

  126. 

  127. 

  128.     /**

  129.      * ICC Profile Color Space Type Signature: 'XYZ '.

  130.      */

  131.     public static final int icSigXYZData        = 0x58595A20;    /* 'XYZ ' */

  132. 

  133.     /**

  134.      * ICC Profile Color Space Type Signature: 'Lab '.

  135.      */

  136.     public static final int icSigLabData        = 0x4C616220;    /* 'Lab ' */

  137. 

  138.     /**

  139.      * ICC Profile Color Space Type Signature: 'Luv '.

  140.      */

  141.     public static final int icSigLuvData        = 0x4C757620;    /* 'Luv ' */

  142. 

  143.     /**

  144.      * ICC Profile Color Space Type Signature: 'YCbr'.

  145.      */

  146.     public static final int icSigYCbCrData        = 0x59436272;    /* 'YCbr' */

  147. 

  148.     /**

  149.      * ICC Profile Color Space Type Signature: 'Yxy '.

  150.      */

  151.     public static final int icSigYxyData        = 0x59787920;    /* 'Yxy ' */

  152. 

  153.     /**

  154.      * ICC Profile Color Space Type Signature: 'RGB '.

  155.      */

  156.     public static final int icSigRgbData        = 0x52474220;    /* 'RGB ' */

  157. 

  158.     /**

  159.      * ICC Profile Color Space Type Signature: 'GRAY'.

  160.      */

  161.     public static final int icSigGrayData        = 0x47524159;    /* 'GRAY' */

  162. 

  163.     /**

  164.      * ICC Profile Color Space Type Signature: 'HSV'.

  165.      */

  166.     public static final int icSigHsvData        = 0x48535620;    /* 'HSV ' */

  167. 

  168.     /**

  169.      * ICC Profile Color Space Type Signature: 'HLS'.

  170.      */

  171.     public static final int icSigHlsData        = 0x484C5320;    /* 'HLS ' */

  172. 

  173.     /**

  174.      * ICC Profile Color Space Type Signature: 'CMYK'.

  175.      */

  176.     public static final int icSigCmykData        = 0x434D594B;    /* 'CMYK' */

  177. 

  178.     /**

  179.      * ICC Profile Color Space Type Signature: 'CMY '.

  180.      */

  181.     public static final int icSigCmyData        = 0x434D5920;    /* 'CMY ' */

  182. 

  183.     /**

  184.      * ICC Profile Color Space Type Signature: '2CLR'.

  185.      */

  186.     public static final int icSigSpace2CLR        = 0x32434C52;    /* '2CLR' */

  187. 

  188.     /**

  189.      * ICC Profile Color Space Type Signature: '3CLR'.

  190.      */

  191.     public static final int icSigSpace3CLR        = 0x33434C52;    /* '3CLR' */

  192. 

  193.     /**

  194.      * ICC Profile Color Space Type Signature: '4CLR'.

  195.      */

  196.     public static final int icSigSpace4CLR        = 0x34434C52;    /* '4CLR' */

  197. 

  198.     /**

  199.      * ICC Profile Color Space Type Signature: '5CLR'.

  200.      */

  201.     public static final int icSigSpace5CLR        = 0x35434C52;    /* '5CLR' */

  202. 

  203.     /**

  204.      * ICC Profile Color Space Type Signature: '6CLR'.

  205.      */

  206.     public static final int icSigSpace6CLR        = 0x36434C52;    /* '6CLR' */

  207. 

  208.     /**

  209.      * ICC Profile Color Space Type Signature: '7CLR'.

  210.      */

  211.     public static final int icSigSpace7CLR        = 0x37434C52;    /* '7CLR' */

  212. 

  213.     /**

  214.      * ICC Profile Color Space Type Signature: '8CLR'.

  215.      */

  216.     public static final int icSigSpace8CLR        = 0x38434C52;    /* '8CLR' */

  217. 

  218.     /**

  219.      * ICC Profile Color Space Type Signature: '9CLR'.

  220.      */

  221.     public static final int icSigSpace9CLR        = 0x39434C52;    /* '9CLR' */

  222. 

  223.     /**

  224.      * ICC Profile Color Space Type Signature: 'ACLR'.

  225.      */

  226.     public static final int icSigSpaceACLR        = 0x41434C52;    /* 'ACLR' */

  227. 

  228.     /**

  229.      * ICC Profile Color Space Type Signature: 'BCLR'.

  230.      */

  231.     public static final int icSigSpaceBCLR        = 0x42434C52;    /* 'BCLR' */

  232. 

  233.     /**

  234.      * ICC Profile Color Space Type Signature: 'CCLR'.

  235.      */

  236.     public static final int icSigSpaceCCLR        = 0x43434C52;    /* 'CCLR' */

  237. 

  238.     /**

  239.      * ICC Profile Color Space Type Signature: 'DCLR'.

  240.      */

  241.     public static final int icSigSpaceDCLR        = 0x44434C52;    /* 'DCLR' */

  242. 

  243.     /**

  244.      * ICC Profile Color Space Type Signature: 'ECLR'.

  245.      */

  246.     public static final int icSigSpaceECLR        = 0x45434C52;    /* 'ECLR' */

  247. 

  248.     /**

  249.      * ICC Profile Color Space Type Signature: 'FCLR'.

  250.      */

  251.     public static final int icSigSpaceFCLR        = 0x46434C52;    /* 'FCLR' */

  252. 

  253. 

  254.     /**

  255.      * ICC Profile Class Signature: 'scnr'.

  256.      */

  257.     public static final int icSigInputClass       = 0x73636E72;    /* 'scnr' */

  258. 

  259.     /**

  260.      * ICC Profile Class Signature: 'mntr'.

  261.      */

  262.     public static final int icSigDisplayClass     = 0x6D6E7472;    /* 'mntr' */

  263. 

  264.     /**

  265.      * ICC Profile Class Signature: 'prtr'.

  266.      */

  267.     public static final int icSigOutputClass      = 0x70727472;    /* 'prtr' */

  268. 

  269.     /**

  270.      * ICC Profile Class Signature: 'link'.

  271.      */

  272.     public static final int icSigLinkClass        = 0x6C696E6B;    /* 'link' */

  273. 

  274.     /**

  275.      * ICC Profile Class Signature: 'abst'.

  276.      */

  277.     public static final int icSigAbstractClass    = 0x61627374;    /* 'abst' */

  278. 

  279.     /**

  280.      * ICC Profile Class Signature: 'spac'.

  281.      */

  282.     public static final int icSigColorSpaceClass  = 0x73706163;    /* 'spac' */

  283. 

  284.     /**

  285.      * ICC Profile Class Signature: 'nmcl'.

  286.      */

  287.     public static final int icSigNamedColorClass  = 0x6e6d636c;    /* 'nmcl' */

  288. 

  289. 

  290.     /**

  291.      * ICC Profile Rendering Intent: Perceptual.

  292.      */

  293.     public static final int icPerceptual            = 0;

  294. 

  295.     /**

  296.      * ICC Profile Rendering Intent: RelativeColorimetric.

  297.      */

  298.     public static final int icRelativeColorimetric    = 1;

  299. 

  300.     /**

  301.      * ICC Profile Rendering Intent: Media-RelativeColorimetric.

  302.      */

  303.     public static final int icMediaRelativeColorimetric = 1;

  304. 

  305.     /**

  306.      * ICC Profile Rendering Intent: Saturation.

  307.      */

  308.     public static final int icSaturation            = 2;

  309. 

  310.     /**

  311.      * ICC Profile Rendering Intent: AbsoluteColorimetric.

  312.      */

  313.     public static final int icAbsoluteColorimetric    = 3;

  314. 

  315.     /**

  316.      * ICC Profile Rendering Intent: ICC-AbsoluteColorimetric.

  317.      */

  318.     public static final int icICCAbsoluteColorimetric = 3;

  319. 

  320. 

  321.     /**

  322.      * ICC Profile Tag Signature: 'head' - special.

  323.      */

  324.     public static final int icSigHead      = 0x68656164; /* 'head' - special */

  325. 

  326.     /**

  327.      * ICC Profile Tag Signature: 'A2B0'.

  328.      */

  329.     public static final int icSigAToB0Tag         = 0x41324230;    /* 'A2B0' */ 

  330. 

  331.     /**

  332.      * ICC Profile Tag Signature: 'A2B1'.

  333.      */

  334.     public static final int icSigAToB1Tag         = 0x41324231;    /* 'A2B1' */

  335. 

  336.     /**

  337.      * ICC Profile Tag Signature: 'A2B2'.

  338.      */

  339.     public static final int icSigAToB2Tag         = 0x41324232;    /* 'A2B2' */ 

  340. 

  341.     /**

  342.      * ICC Profile Tag Signature: 'bXYZ'.

  343.      */

  344.     public static final int icSigBlueColorantTag  = 0x6258595A;    /* 'bXYZ' */

  345. 

  346.     /**

  347.      * ICC Profile Tag Signature: 'bXYZ'.

  348.      */

  349.     public static final int icSigBlueMatrixColumnTag = 0x6258595A; /* 'bXYZ' */

  350. 

  351.     /**

  352.      * ICC Profile Tag Signature: 'bTRC'.

  353.      */

  354.     public static final int icSigBlueTRCTag       = 0x62545243;    /* 'bTRC' */

  355. 

  356.     /**

  357.      * ICC Profile Tag Signature: 'B2A0'.

  358.      */

  359.     public static final int icSigBToA0Tag         = 0x42324130;    /* 'B2A0' */

  360. 

  361.     /**

  362.      * ICC Profile Tag Signature: 'B2A1'.

  363.      */

  364.     public static final int icSigBToA1Tag         = 0x42324131;    /* 'B2A1' */

  365. 

  366.     /**

  367.      * ICC Profile Tag Signature: 'B2A2'.

  368.      */

  369.     public static final int icSigBToA2Tag         = 0x42324132;    /* 'B2A2' */

  370. 

  371.     /**

  372.      * ICC Profile Tag Signature: 'calt'.

  373.      */

  374.     public static final int icSigCalibrationDateTimeTag = 0x63616C74;

  375.                                                                    /* 'calt' */

  376. 

  377.     /**

  378.      * ICC Profile Tag Signature: 'targ'.

  379.      */

  380.     public static final int icSigCharTargetTag    = 0x74617267;    /* 'targ' */ 

  381. 

  382.     /**

  383.      * ICC Profile Tag Signature: 'cprt'.

  384.      */

  385.     public static final int icSigCopyrightTag     = 0x63707274;    /* 'cprt' */

  386. 

  387.     /**

  388.      * ICC Profile Tag Signature: 'crdi'.

  389.      */

  390.     public static final int icSigCrdInfoTag       = 0x63726469;    /* 'crdi' */

  391. 

  392.     /**

  393.      * ICC Profile Tag Signature: 'dmnd'.

  394.      */

  395.     public static final int icSigDeviceMfgDescTag = 0x646D6E64;    /* 'dmnd' */

  396. 

  397.     /**

  398.      * ICC Profile Tag Signature: 'dmdd'.

  399.      */

  400.     public static final int icSigDeviceModelDescTag = 0x646D6464;  /* 'dmdd' */

  401. 

  402.     /**

  403.      * ICC Profile Tag Signature: 'devs'.

  404.      */

  405.     public static final int icSigDeviceSettingsTag =  0x64657673;  /* 'devs' */

  406. 

  407.     /**

  408.      * ICC Profile Tag Signature: 'gamt'.

  409.      */

  410.     public static final int icSigGamutTag         = 0x67616D74;    /* 'gamt' */

  411. 

  412.     /**

  413.      * ICC Profile Tag Signature: 'kTRC'.

  414.      */

  415.     public static final int icSigGrayTRCTag       = 0x6b545243;    /* 'kTRC' */

  416. 

  417.     /**

  418.      * ICC Profile Tag Signature: 'gXYZ'.

  419.      */

  420.     public static final int icSigGreenColorantTag = 0x6758595A;    /* 'gXYZ' */

  421. 

  422.     /**

  423.      * ICC Profile Tag Signature: 'gXYZ'.

  424.      */

  425.     public static final int icSigGreenMatrixColumnTag = 0x6758595A;/* 'gXYZ' */

  426. 

  427.     /**

  428.      * ICC Profile Tag Signature: 'gTRC'.

  429.      */

  430.     public static final int icSigGreenTRCTag      = 0x67545243;    /* 'gTRC' */

  431. 

  432.     /**

  433.      * ICC Profile Tag Signature: 'lumi'.

  434.      */

  435.     public static final int icSigLuminanceTag     = 0x6C756d69;    /* 'lumi' */

  436. 

  437.     /**

  438.      * ICC Profile Tag Signature: 'meas'.

  439.      */

  440.     public static final int icSigMeasurementTag   = 0x6D656173;    /* 'meas' */

  441. 

  442.     /**

  443.      * ICC Profile Tag Signature: 'bkpt'.

  444.      */

  445.     public static final int icSigMediaBlackPointTag = 0x626B7074;  /* 'bkpt' */

  446. 

  447.     /**

  448.      * ICC Profile Tag Signature: 'wtpt'.

  449.      */

  450.     public static final int icSigMediaWhitePointTag = 0x77747074;  /* 'wtpt' */

  451. 

  452.     /**

  453.      * ICC Profile Tag Signature: 'ncl2'.

  454.      */

  455.     public static final int icSigNamedColor2Tag   = 0x6E636C32;    /* 'ncl2' */

  456. 

  457.     /**

  458.      * ICC Profile Tag Signature: 'resp'.

  459.      */

  460.     public static final int icSigOutputResponseTag = 0x72657370;   /* 'resp' */

  461. 

  462.     /**

  463.      * ICC Profile Tag Signature: 'pre0'.

  464.      */

  465.     public static final int icSigPreview0Tag      = 0x70726530;    /* 'pre0' */

  466. 

  467.     /**

  468.      * ICC Profile Tag Signature: 'pre1'.

  469.      */

  470.     public static final int icSigPreview1Tag      = 0x70726531;    /* 'pre1' */

  471. 

  472.     /**

  473.      * ICC Profile Tag Signature: 'pre2'.

  474.      */

  475.     public static final int icSigPreview2Tag      = 0x70726532;    /* 'pre2' */

  476. 

  477.     /**

  478.      * ICC Profile Tag Signature: 'desc'.

  479.      */

  480.     public static final int icSigProfileDescriptionTag = 0x64657363;

  481.                                                                    /* 'desc' */

  482. 

  483.     /**

  484.      * ICC Profile Tag Signature: 'pseq'.

  485.      */

  486.     public static final int icSigProfileSequenceDescTag = 0x70736571;

  487.                                                                    /* 'pseq' */

  488. 

  489.     /**

  490.      * ICC Profile Tag Signature: 'psd0'.

  491.      */

  492.     public static final int icSigPs2CRD0Tag       = 0x70736430;    /* 'psd0' */

  493. 

  494.     /**

  495.      * ICC Profile Tag Signature: 'psd1'.

  496.      */

  497.     public static final int icSigPs2CRD1Tag       = 0x70736431;    /* 'psd1' */

  498. 

  499.     /**

  500.      * ICC Profile Tag Signature: 'psd2'.

  501.      */

  502.     public static final int icSigPs2CRD2Tag       = 0x70736432;    /* 'psd2' */

  503. 

  504.     /**

  505.      * ICC Profile Tag Signature: 'psd3'.

  506.      */

  507.     public static final int icSigPs2CRD3Tag       = 0x70736433;    /* 'psd3' */

  508. 

  509.     /**

  510.      * ICC Profile Tag Signature: 'ps2s'.

  511.      */

  512.     public static final int icSigPs2CSATag        = 0x70733273;    /* 'ps2s' */

  513. 

  514.     /**

  515.      * ICC Profile Tag Signature: 'ps2i'.

  516.      */

  517.     public static final int icSigPs2RenderingIntentTag = 0x70733269;

  518.                                                                    /* 'ps2i' */

  519. 

  520.     /**

  521.      * ICC Profile Tag Signature: 'rXYZ'.

  522.      */

  523.     public static final int icSigRedColorantTag   = 0x7258595A;    /* 'rXYZ' */

  524. 

  525.     /**

  526.      * ICC Profile Tag Signature: 'rXYZ'.

  527.      */

  528.     public static final int icSigRedMatrixColumnTag = 0x7258595A;  /* 'rXYZ' */

  529. 

  530.     /**

  531.      * ICC Profile Tag Signature: 'rTRC'.

  532.      */

  533.     public static final int icSigRedTRCTag        = 0x72545243;    /* 'rTRC' */

  534. 

  535.     /**

  536.      * ICC Profile Tag Signature: 'scrd'.

  537.      */

  538.     public static final int icSigScreeningDescTag = 0x73637264;    /* 'scrd' */

  539. 

  540.     /**

  541.      * ICC Profile Tag Signature: 'scrn'.

  542.      */

  543.     public static final int icSigScreeningTag     = 0x7363726E;    /* 'scrn' */

  544. 

  545.     /**

  546.      * ICC Profile Tag Signature: 'tech'.

  547.      */

  548.     public static final int icSigTechnologyTag    = 0x74656368;    /* 'tech' */

  549. 

  550.     /**

  551.      * ICC Profile Tag Signature: 'bfd '.

  552.      */

  553.     public static final int icSigUcrBgTag         = 0x62666420;    /* 'bfd ' */

  554. 

  555.     /**

  556.      * ICC Profile Tag Signature: 'vued'.

  557.      */

  558.     public static final int icSigViewingCondDescTag = 0x76756564;  /* 'vued' */

  559. 

  560.     /**

  561.      * ICC Profile Tag Signature: 'view'.

  562.      */

  563.     public static final int icSigViewingConditionsTag = 0x76696577;/* 'view' */

  564. 

  565.     /**

  566.      * ICC Profile Tag Signature: 'chrm'.

  567.      */

  568.     public static final int icSigChromaticityTag  = 0x6368726d;    /* 'chrm' */

  569. 

  570.     /**

  571.      * ICC Profile Tag Signature: 'chad'.

  572.      */

  573.     public static final int icSigChromaticAdaptationTag = 0x63686164;/* 'chad' */

  574. 

  575.     /**

  576.      * ICC Profile Tag Signature: 'clro'.

  577.      */

  578.     public static final int icSigColorantOrderTag = 0x636C726F;    /* 'clro' */

  579. 

  580.     /**

  581.      * ICC Profile Tag Signature: 'clrt'.

  582.      */

  583.     public static final int icSigColorantTableTag = 0x636C7274;    /* 'clrt' */

  584. 

  585. 

  586.     /**

  587.      * ICC Profile Header Location: profile size in bytes.

  588.      */

  589.     public static final int icHdrSize         = 0;  /* Profile size in bytes */

  590. 

  591.     /**

  592.      * ICC Profile Header Location: CMM for this profile.

  593.      */

  594.     public static final int icHdrCmmId        = 4;  /* CMM for this profile */

  595. 

  596.     /**

  597.      * ICC Profile Header Location: format version number.

  598.      */

  599.     public static final int icHdrVersion      = 8;  /* Format version number */

  600. 

  601.     /**

  602.      * ICC Profile Header Location: type of profile.

  603.      */

  604.     public static final int icHdrDeviceClass  = 12; /* Type of profile */

  605. 

  606.     /**

  607.      * ICC Profile Header Location: color space of data.

  608.      */

  609.     public static final int icHdrColorSpace   = 16; /* Color space of data */

  610. 

  611.     /**

  612.      * ICC Profile Header Location: PCS - XYZ or Lab only.

  613.      */

  614.     public static final int icHdrPcs          = 20; /* PCS - XYZ or Lab only */

  615. 

  616.     /**

  617.      * ICC Profile Header Location: date profile was created.

  618.      */

  619.     public static final int icHdrDate       = 24; /* Date profile was created */

  620. 

  621.     /**

  622.      * ICC Profile Header Location: icMagicNumber.

  623.      */

  624.     public static final int icHdrMagic        = 36; /* icMagicNumber */

  625. 

  626.     /**

  627.      * ICC Profile Header Location: primary platform.

  628.      */

  629.     public static final int icHdrPlatform     = 40; /* Primary Platform */

  630. 

  631.     /**

  632.      * ICC Profile Header Location: various bit settings.

  633.      */

  634.     public static final int icHdrFlags        = 44; /* Various bit settings */

  635. 

  636.     /**

  637.      * ICC Profile Header Location: device manufacturer.

  638.      */

  639.     public static final int icHdrManufacturer = 48; /* Device manufacturer */

  640. 

  641.     /**

  642.      * ICC Profile Header Location: device model number.

  643.      */

  644.     public static final int icHdrModel        = 52; /* Device model number */

  645. 

  646.     /**

  647.      * ICC Profile Header Location: device attributes.

  648.      */

  649.     public static final int icHdrAttributes   = 56; /* Device attributes */

  650. 

  651.     /**

  652.      * ICC Profile Header Location: rendering intent.

  653.      */

  654.     public static final int icHdrRenderingIntent = 64; /* Rendering intent */

  655. 

  656.     /**

  657.      * ICC Profile Header Location: profile illuminant.

  658.      */

  659.     public static final int icHdrIlluminant   = 68; /* Profile illuminant */

  660. 

  661.     /**

  662.      * ICC Profile Header Location: profile creator.

  663.      */

  664.     public static final int icHdrCreator      = 80; /* Profile creator */

  665. 

  666.     /**

  667.      * ICC Profile Header Location: profile's ID.

  668.      */

  669.     public static final int icHdrProfileID = 84; /* Profile's ID */

  670. 

  671. 

  672.     /**

  673.      * ICC Profile Constant: tag type signaturE.

  674.      */

  675.     public static final int icTagType          = 0;    /* tag type signature */

  676. 

  677.     /**

  678.      * ICC Profile Constant: reserved.

  679.      */

  680.     public static final int icTagReserved      = 4;    /* reserved */

  681. 

  682.     /**

  683.      * ICC Profile Constant: curveType count.

  684.      */

  685.     public static final int icCurveCount       = 8;    /* curveType count */

  686. 

  687.     /**

  688.      * ICC Profile Constant: curveType data.

  689.      */

  690.     public static final int icCurveData        = 12;   /* curveType data */

  691. 

  692.     /**

  693.      * ICC Profile Constant: XYZNumber X.

  694.      */

  695.     public static final int icXYZNumberX       = 8;    /* XYZNumber X */

  696. 

  697. 

  698.     /**

  699.      * Constructs an ICC_Profile object with a given ID.

  700.      */

  701.     ICC_Profile(long ID) {

  702.         this.ID = ID;

  703.     }

  704. 

  705. 

  706.     /**

  707.      * Constructs an ICC_Profile object whose loading will be deferred.

  708.      * The ID will be 0 until the profile is loaded.

  709.      */

  710.     ICC_Profile(ProfileDeferralInfo pdi) {

  711.         this.deferralInfo = pdi;

  712.         this.profileActivator = new ProfileActivator() {

  713.             public void activate() {

  714.                 activateDeferredProfile();

  715.             }

  716.         };

  717.         ProfileDeferralMgr.registerDeferral(this.profileActivator);

  718.     }

  719. 

  720. 

  721.     /**

  722.      * Frees the resources associated with an ICC_Profile object.

  723.      */

  724.     protected void finalize () {

  725.         if (ID != 0) {

  726.             CMM.checkStatus(CMM.cmmFreeProfile(ID));

  727.         } else if (profileActivator != null) {

  728.             ProfileDeferralMgr.unregisterDeferral(profileActivator);

  729.         }

  730.     }

  731. 

  732. 

  733.     /**

  734.      * Constructs an ICC_Profile object corresponding to the data in

  735.      * a byte array.  Throws an IllegalArgumentException if the data

  736.      * does not correspond to a valid ICC Profile.

  737.      * @param data the specified ICC Profile data

  738.      * @return an <code>ICC_Profile</code> object corresponding to

  739.      *          the data in the specified <code>data</code> array.

  740.      */

  741.     public static ICC_Profile getInstance(byte[] data) {

  742.     ICC_Profile thisProfile;

  743. 

  744.         long[] theID = new long [1];

  745. 

  746.         if (ProfileDeferralMgr.deferring) {

  747.             ProfileDeferralMgr.activateProfiles();

  748.         }

  749.         

  750.         try {

  751.             CMM.checkStatus(CMM.cmmLoadProfile(data, theID));

  752.         } catch (CMMException c) {

  753.             throw new IllegalArgumentException("Invalid ICC Profile Data");

  754.         }

  755. 

  756.         try {

  757.             if ((getColorSpaceType (theID[0]) == ColorSpace.TYPE_GRAY) &&

  758.                 (getData (theID[0], icSigMediaWhitePointTag) != null) &&

  759.                 (getData (theID[0], icSigGrayTRCTag) != null)) {

  760.                 thisProfile = new ICC_ProfileGray (theID[0]);

  761.             }

  762.             else if ((getColorSpaceType (theID[0]) == ColorSpace.TYPE_RGB) &&

  763.                 (getData (theID[0], icSigMediaWhitePointTag) != null) &&

  764.                 (getData (theID[0], icSigRedColorantTag) != null) &&

  765.                 (getData (theID[0], icSigGreenColorantTag) != null) &&

  766.                 (getData (theID[0], icSigBlueColorantTag) != null) &&

  767.                 (getData (theID[0], icSigRedTRCTag) != null) &&

  768.                 (getData (theID[0], icSigGreenTRCTag) != null) &&

  769.                 (getData (theID[0], icSigBlueTRCTag) != null)) {

  770.                 thisProfile = new ICC_ProfileRGB (theID[0]);

  771.             }

  772.             else {

  773.                 thisProfile = new ICC_Profile (theID[0]);

  774.             }

  775.         } catch (CMMException c) {

  776.             thisProfile = new ICC_Profile (theID[0]);

  777.         }

  778.         return thisProfile;

  779.     }

  780. 

  781. 

  782. 

  783.     /**

  784.      * Constructs an ICC_Profile corresponding to one of the specific color

  785.      * spaces defined by the ColorSpace class (for example CS_sRGB).

  786.      * Throws an IllegalArgumentException if cspace is not one of the

  787.      * defined color spaces.

  788.      *   

  789.      * @param cspace the type of color space to create a profile for.

  790.      * The specified type is one of the color

  791.      * space constants defined in the  <CODE>ColorSpace</CODE> class.

  792.      *       

  793.      * @return an <code>ICC_Profile</code> object corresponding to

  794.      *          the specified <code>ColorSpace</code> type.

  795.      * @exception IllegalArgumentException If <CODE>cspace</CODE> is not

  796.      * one of the predefined color space types.

  797.      */

  798.     public static ICC_Profile getInstance (int cspace) {

  799. 	ICC_Profile thisProfile = null;

  800. 	String fileName;

  801. 

  802. 	switch (cspace) {

  803. 	case ColorSpace.CS_sRGB:

  804. 	    if (sRGBprofile == null) {

  805. 		try {

  806. 		    /*

  807. 		     * Deferral is only used for standard profiles.

  808. 		     * Enabling the appropriate access privileges is handled

  809. 		     * at a lower level.

  810. 		     */

  811. 		    sRGBprofile = getDeferredInstance(

  812. 			new ProfileDeferralInfo("sRGB.pf", ColorSpace.TYPE_RGB,

  813. 						3, CLASS_DISPLAY)); 

  814. 		} catch (IOException e) {

  815. 		    throw new IllegalArgumentException(

  816.                           "Can't load standard profile: sRGB.pf");

  817. 		}

  818. 	    }

  819. 	    thisProfile = sRGBprofile;

  820. 

  821. 	    break;

  822. 

  823. 	case ColorSpace.CS_CIEXYZ:

  824. 	    if (XYZprofile == null) {

  825. 		XYZprofile = getStandardProfile("CIEXYZ.pf");

  826. 	    }

  827. 	    thisProfile = XYZprofile;

  828. 

  829. 	    break;

  830. 

  831. 	case ColorSpace.CS_PYCC:

  832. 	    if (PYCCprofile == null) {

  833. 		PYCCprofile = getStandardProfile("PYCC.pf");

  834. 	    }

  835. 	    thisProfile = PYCCprofile;

  836. 

  837. 	    break;

  838. 

  839. 	case ColorSpace.CS_GRAY:

  840. 	    if (GRAYprofile == null) {

  841. 		GRAYprofile = getStandardProfile("GRAY.pf");

  842. 	    }

  843. 	    thisProfile = GRAYprofile;

  844. 

  845. 	    break;

  846. 

  847. 	case ColorSpace.CS_LINEAR_RGB:

  848. 	    if (LINEAR_RGBprofile == null) {

  849. 		LINEAR_RGBprofile = getStandardProfile("LINEAR_RGB.pf");

  850. 	    }

  851. 	    thisProfile = LINEAR_RGBprofile;

  852. 

  853. 	    break;

  854. 

  855. 	default:

  856. 	    throw new IllegalArgumentException("Unknown color space");

  857. 	}

  858. 

  859.         return thisProfile;

  860.     }

  861. 

  862.     /* This asserts system privileges, so is used only for the

  863.      * standard profiles.

  864.      */

  865.     private static ICC_Profile getStandardProfile(final String name) {

  866.         

  867. 	return (ICC_Profile) AccessController.doPrivileged(

  868. 	    new PrivilegedAction() {

  869.                  public Object run() {

  870.                      ICC_Profile p = null;

  871.                      try {

  872.                          p = getInstance (name);

  873.                      } catch (IOException ex) {

  874.                          throw new IllegalArgumentException(

  875. 			       "Can't load standard profile: " + name);

  876.                      }

  877.                      return p;

  878.                  }

  879.              });

  880.     }

  881. 

  882.     /**

  883.      * Constructs an ICC_Profile corresponding to the data in a file.

  884.      * fileName may be an absolute or a relative file specification.

  885.      * Relative file names are looked for in several places: first, relative

  886.      * to any directories specified by the java.iccprofile.path property;

  887.      * second, relative to any directories specified by the java.class.path

  888.      * property; finally, in a directory used to store profiles always

  889.      * available, such as the profile for sRGB.  Built-in profiles use .pf as

  890.      * the file name extension for profiles, e.g. sRGB.pf.

  891.      * This method throws an IOException if the specified file cannot be

  892.      * opened or if an I/O error occurs while reading the file.  It throws

  893.      * an IllegalArgumentException if the file does not contain valid ICC

  894.      * Profile data.

  895.      * @param fileName The file that contains the data for the profile.

  896.      *

  897.      * @return an <code>ICC_Profile</code> object corresponding to

  898.      *          the data in the specified file.

  899.      * @exception IOException If the specified file cannot be opened or

  900.      * an I/O error occurs while reading the file.

  901.      *   

  902.      * @exception IllegalArgumentException If the file does not

  903.      * contain valid ICC Profile data. 

  904.      *

  905.      * @exception SecurityException If a security manager is installed

  906.      * and it does not permit read access to the given file.

  907.      */

  908.     public static ICC_Profile getInstance(String fileName) throws IOException {

  909.     ICC_Profile thisProfile;

  910.     FileInputStream fis;

  911. 

  912.         SecurityManager security = System.getSecurityManager();

  913. 	if (security != null) {

  914.             security.checkRead(fileName);

  915.         }

  916. 

  917.         if ((fis = openProfile(fileName)) == null) {

  918.             throw new IOException("Cannot open file " + fileName);

  919.         }

  920. 

  921.         thisProfile = getInstance(fis);

  922. 

  923.         fis.close();    /* close the file */

  924.     

  925.         return thisProfile;

  926.     }

  927. 

  928. 

  929.     /**

  930.      * Constructs an ICC_Profile corresponding to the data in an InputStream.

  931.      * This method throws an IllegalArgumentException if the stream does not

  932.      * contain valid ICC Profile data.  It throws an IOException if an I/O

  933.      * error occurs while reading the stream.

  934.      * @param s The input stream from which to read the profile data.

  935.      *

  936.      * @return an <CODE>ICC_Profile</CODE> object corresponding to the

  937.      *     data in the specified <code>InputStream</code>.

  938.      *

  939.      * @exception IOException If an I/O error occurs while reading the stream.

  940.      *   

  941.      * @exception IllegalArgumentException If the stream does not

  942.      * contain valid ICC Profile data.

  943.      */

  944.     public static ICC_Profile getInstance(InputStream s) throws IOException {

  945.     byte profileData[];

  946. 

  947.         if (s instanceof ProfileDeferralInfo) {

  948.             /* hack to detect profiles whose loading can be deferred */

  949.             return getDeferredInstance((ProfileDeferralInfo) s);

  950.         }

  951. 

  952.         if ((profileData = getProfileDataFromStream(s)) == null) {

  953.             throw new IllegalArgumentException("Invalid ICC Profile Data");

  954.         }

  955. 

  956.         return getInstance(profileData);

  957.     }

  958. 

  959. 

  960.     static byte[] getProfileDataFromStream(InputStream s) throws IOException {

  961.     byte profileData[];

  962.     int profileSize;

  963. 

  964.         byte header[] = new byte[128];

  965.         int bytestoread = 128;

  966.         int bytesread = 0;

  967.         int n;

  968. 

  969.         while (bytestoread != 0) {

  970.             if ((n = s.read(header, bytesread, bytestoread)) < 0) {

  971.                 return null;

  972.             }

  973.             bytesread += n;

  974.             bytestoread -= n;

  975.         }

  976.         if (header[36] != 0x61 || header[37] != 0x63 ||

  977.             header[38] != 0x73 || header[39] != 0x70) {

  978.             return null;   /* not a valid profile */

  979.         }

  980.         profileSize = ((header[0] & 0xff) << 24) |

  981.                       ((header[1] & 0xff) << 16) |

  982.                       ((header[2] & 0xff) <<  8) |

  983.                        (header[3] & 0xff);

  984.         profileData = new byte[profileSize];

  985.         System.arraycopy(header, 0, profileData, 0, 128);

  986.         bytestoread = profileSize - 128;

  987.         bytesread = 128;

  988.         while (bytestoread != 0) {

  989.             if ((n = s.read(profileData, bytesread, bytestoread)) < 0) {

  990.                 return null;

  991.             }

  992.             bytesread += n;

  993.             bytestoread -= n;

  994.         }

  995. 

  996.         return profileData;

  997.     }

  998. 

  999. 

  1000.     /**

  1001.      * Constructs an ICC_Profile for which the actual loading of the

  1002.      * profile data from a file and the initialization of the CMM should

  1003.      * be deferred as long as possible.

  1004.      * Deferral is only used for standard profiles.

  1005.      * If deferring is disabled, then getStandardProfile() ensures

  1006.      * that all of the appropriate access privileges are granted

  1007.      * when loading this profile.

  1008.      * If deferring is enabled, then the deferred activation

  1009.      * code will take care of access privileges.

  1010.      * @see activateDeferredProfile() 

  1011.      */

  1012.     static ICC_Profile getDeferredInstance(ProfileDeferralInfo pdi)

  1013.         throws IOException {

  1014. 

  1015.         if (!ProfileDeferralMgr.deferring) {

  1016.             return getStandardProfile(pdi.filename);

  1017.         }

  1018.         if (pdi.colorSpaceType == ColorSpace.TYPE_RGB) {

  1019.             return new ICC_ProfileRGB(pdi);

  1020.         } else if (pdi.colorSpaceType == ColorSpace.TYPE_GRAY) {

  1021.             return new ICC_ProfileGray(pdi);

  1022.         } else {

  1023.             return new ICC_Profile(pdi);

  1024.         }

  1025.     }

  1026. 

  1027. 

  1028.     void activateDeferredProfile() {

  1029.     long[] theID = new long [1];

  1030.     byte profileData[];

  1031.     FileInputStream fis;

  1032.     String fileName = deferralInfo.filename;

  1033. 

  1034.         profileActivator = null;

  1035.         deferralInfo = null;

  1036.         if ((fis = openProfile(fileName)) == null) {

  1037.             throw new IllegalArgumentException("Cannot open file " + fileName);

  1038.         }

  1039.         try {

  1040.             profileData = getProfileDataFromStream(fis);

  1041.             fis.close();    /* close the file */

  1042.         }

  1043.         catch (IOException e) {

  1044.             throw new IllegalArgumentException("Invalid ICC Profile Data" +

  1045.                 fileName);

  1046.         }

  1047.         if (profileData == null) {

  1048.             throw new IllegalArgumentException("Invalid ICC Profile Data" +

  1049.                 fileName);

  1050.         }

  1051.         try {

  1052.             CMM.checkStatus(CMM.cmmLoadProfile(profileData, theID));

  1053.         } catch (CMMException c) {

  1054.             throw new IllegalArgumentException("Invalid ICC Profile Data" +

  1055.                 fileName);

  1056.         }

  1057.         ID = theID[0];

  1058.     }

  1059. 

  1060. 

  1061.     /**

  1062.      * Returns profile major version.

  1063.      * @return  The major version of the profile.

  1064.      */

  1065.     public int getMajorVersion() {

  1066.     byte[] theHeader;

  1067.     

  1068.         theHeader = getData(icSigHead); /* getData will activate deferred

  1069.                                            profiles if necessary */

  1070. 

  1071.         return (int) theHeader[8];

  1072.     }

  1073. 

  1074.     /**

  1075.      * Returns profile minor version.

  1076.      * @return The minor version of the profile.

  1077.      */

  1078.     public int getMinorVersion() {

  1079.     byte[] theHeader;

  1080.     

  1081.         theHeader = getData(icSigHead); /* getData will activate deferred

  1082.                                            profiles if necessary */

  1083. 

  1084.         return (int) theHeader[9];

  1085.     }

  1086. 

  1087.     /**

  1088.      * Returns the profile class.

  1089.      * @return One of the predefined profile class constants.

  1090.      */

  1091.     public int getProfileClass() {

  1092.     byte[] theHeader;

  1093.     int theClassSig, theClass;

  1094.     

  1095.         if (deferralInfo != null) {

  1096.             return deferralInfo.profileClass; /* Need to have this info for

  1097.                                                  ICC_ColorSpace without

  1098.                                                  causing a deferred profile

  1099.                                                  to be loaded */

  1100.         }

  1101. 

  1102.         theHeader = getData(icSigHead);

  1103. 

  1104.         theClassSig = intFromBigEndian (theHeader, icHdrDeviceClass);

  1105.                 

  1106.         switch (theClassSig) {

  1107.         case icSigInputClass:

  1108.             theClass = CLASS_INPUT;

  1109.             break;

  1110. 

  1111.         case icSigDisplayClass:

  1112.             theClass = CLASS_DISPLAY;

  1113.             break;

  1114. 

  1115.         case icSigOutputClass:

  1116.             theClass = CLASS_OUTPUT;

  1117.             break;

  1118. 

  1119.         case icSigLinkClass:

  1120.             theClass = CLASS_DEVICELINK;

  1121.             break;

  1122. 

  1123.         case icSigColorSpaceClass:

  1124.             theClass = CLASS_COLORSPACECONVERSION;

  1125.             break;

  1126. 

  1127.         case icSigAbstractClass:

  1128.             theClass = CLASS_ABSTRACT;

  1129.             break;

  1130. 

  1131.         case icSigNamedColorClass:

  1132.             theClass = CLASS_NAMEDCOLOR;

  1133.             break;

  1134. 

  1135.         default:

  1136.             throw new IllegalArgumentException("Unknown profile class");

  1137.         }

  1138.         

  1139.         return theClass;

  1140.     }

  1141. 

  1142.     /**

  1143.      * Returns the color space type.  Returns one of the color space type

  1144.      * constants defined by the ColorSpace class.  This is the

  1145.      * "input" color space of the profile.  The type defines the

  1146.      * number of components of the color space and the interpretation,

  1147.      * e.g. TYPE_RGB identifies a color space with three components - red,

  1148.      * green, and blue.  It does not define the particular color

  1149.      * characteristics of the space, e.g. the chromaticities of the

  1150.      * primaries.

  1151.      * @return One of the color space type constants defined in the

  1152.      * <CODE>ColorSpace</CODE> class.

  1153.      */

  1154.     public int getColorSpaceType() {

  1155.         if (deferralInfo != null) {

  1156.             return deferralInfo.colorSpaceType; /* Need to have this info for

  1157.                                                    ICC_ColorSpace without

  1158.                                                    causing a deferred profile

  1159.                                                    to be loaded */

  1160.         }

  1161.         return    getColorSpaceType(ID);

  1162.     }

  1163.     

  1164.     static int getColorSpaceType(long profileID) {

  1165.     byte[] theHeader;

  1166.     int theColorSpaceSig, theColorSpace;

  1167.     

  1168.         theHeader = getData(profileID, icSigHead);

  1169.         theColorSpaceSig = intFromBigEndian(theHeader, icHdrColorSpace);

  1170.         theColorSpace = iccCStoJCS (theColorSpaceSig);

  1171.         return theColorSpace;

  1172.     }

  1173. 

  1174.     /**

  1175.      * Returns the color space type of the Profile Connection Space (PCS).

  1176.      * Returns one of the color space type constants defined by the

  1177.      * ColorSpace class.  This is the "output" color space of the

  1178.      * profile.  For an input, display, or output profile useful

  1179.      * for tagging colors or images, this will be either TYPE_XYZ or

  1180.      * TYPE_Lab and should be interpreted as the corresponding specific

  1181.      * color space defined in the ICC specification.  For a device

  1182.      * link profile, this could be any of the color space type constants.

  1183.      * @return One of the color space type constants defined in the

  1184.      * <CODE>ColorSpace</CODE> class.

  1185.      */

  1186.     public int getPCSType() {

  1187.         if (ProfileDeferralMgr.deferring) {

  1188.             ProfileDeferralMgr.activateProfiles();

  1189.         }

  1190.         return getPCSType(ID);

  1191.     }

  1192.     

  1193.     

  1194.     static int getPCSType(long profileID) {

  1195.     byte[] theHeader;

  1196.     int thePCSSig, thePCS;

  1197.     

  1198.         theHeader = getData(profileID, icSigHead);

  1199.         thePCSSig = intFromBigEndian(theHeader, icHdrPcs);

  1200.         thePCS = iccCStoJCS(thePCSSig);

  1201.         return thePCS;

  1202.     }

  1203. 

  1204. 

  1205.     /**

  1206.      * Write this ICC_Profile to a file.

  1207.      *  

  1208.      * @param fileName The file to write the profile data to.

  1209.      *

  1210.      * @exception IOException If the file cannot be opened for writing

  1211.      * or an I/O error occurs while writing to the file.

  1212.      */

  1213.     public void write(String fileName) throws IOException {

  1214.     FileOutputStream outputFile;

  1215.     byte profileData[];

  1216. 

  1217.         profileData = getData(); /* this will activate deferred

  1218.                                     profiles if necessary */

  1219.         outputFile = new FileOutputStream(fileName);

  1220.         outputFile.write(profileData);

  1221.         outputFile.close ();

  1222.     }

  1223. 

  1224. 

  1225.     /**

  1226.      * Write this ICC_Profile to an OutputStream.

  1227.      *

  1228.      * @param s The stream to write the profile data to.

  1229.      *

  1230.      * @exception IOException If an I/O error occurs while writing to the

  1231.      * stream.

  1232.      */

  1233.     public void write(OutputStream s) throws IOException {

  1234.     byte profileData[];

  1235. 

  1236.         profileData = getData(); /* this will activate deferred

  1237.                                     profiles if necessary */

  1238.         s.write(profileData);

  1239.     }

  1240. 

  1241. 

  1242.     /**

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

  1244.      * @return A byte array that contains the profile data.

  1245.      * @see #setData(int, byte[])

  1246.      */

  1247.     public byte[] getData() {

  1248.     int[] profileSize = new int [1];

  1249.     byte[] profileData;

  1250. 

  1251.         if (ProfileDeferralMgr.deferring) {

  1252.             ProfileDeferralMgr.activateProfiles();

  1253.         }

  1254. 

  1255.         /* get the number of bytes needed for this profile */

  1256.         CMM.checkStatus(CMM.cmmGetProfileSize(ID, profileSize));

  1257. 

  1258.         profileData = new byte [profileSize[0]];

  1259. 

  1260.         /* get the data for the profile */

  1261.         CMM.checkStatus(CMM.cmmGetProfileData(ID, profileData));

  1262. 

  1263.         return profileData;

  1264.     }

  1265. 

  1266. 

  1267.     /**

  1268.      * Returns a particular tagged data element from the profile as

  1269.      * a byte array.  Elements are identified by signatures

  1270.      * as defined in the ICC specification.  The signature

  1271.      * icSigHead can be used to get the header.  This method is useful

  1272.      * for advanced applets or applications which need to access

  1273.      * profile data directly.

  1274.      *  

  1275.      * @param tagSignature The ICC tag signature for the data element you

  1276.      * want to get.

  1277.      * 

  1278.      * @return A byte array that contains the tagged data element. Returns

  1279.      * <code>null</code> if the specified tag doesn't exist.

  1280.      * @see #setData(int, byte[])

  1281.      */

  1282.     public byte[] getData(int tagSignature) {

  1283. 

  1284.         if (ProfileDeferralMgr.deferring) {

  1285.             ProfileDeferralMgr.activateProfiles();

  1286.         }

  1287. 

  1288.         return getData(ID, tagSignature);

  1289.     }

  1290.     

  1291. 

  1292.     static byte[] getData(long profileID, int tagSignature) {

  1293.     int[] tagSize = new int [1];

  1294.     byte[] tagData;

  1295. 

  1296. 	try {

  1297.             /* get the number of bytes needed for this tag */

  1298.             CMM.checkStatus(CMM.cmmGetTagSize(profileID, tagSignature,

  1299.                                               tagSize));

  1300. 

  1301.             tagData = new byte[tagSize[0]]; /* get an array for the tag */

  1302. 

  1303.             /* get the tag's data */

  1304.             CMM.checkStatus(CMM.cmmGetTagData(profileID, tagSignature,

  1305.                                               tagData));

  1306. 	} catch(CMMException c) {

  1307. 	    tagData = null;

  1308. 	}

  1309. 

  1310.         return tagData;

  1311.     }

  1312. 

  1313.     /**

  1314.      * Sets a particular tagged data element in the profile from

  1315.      * a byte array.  This method is useful

  1316.      * for advanced applets or applications which need to access

  1317.      * profile data directly.

  1318.      *                                        

  1319.      * @param tagSignature The ICC tag signature for the data element

  1320.      * you want to set.

  1321.      * @param tagData the data to set for the specified tag signature

  1322.      * @see #getData

  1323.      */

  1324.     public void setData(int tagSignature, byte[] tagData) {

  1325. 

  1326.         if (ProfileDeferralMgr.deferring) {

  1327.             ProfileDeferralMgr.activateProfiles();

  1328.         }

  1329. 

  1330.         CMM.checkStatus(CMM.cmmSetTagData(ID, tagSignature, tagData));

  1331.     }

  1332. 

  1333.     /**

  1334.      * Sets the rendering intent of the profile.

  1335.      * This is used to select the proper transform from a profile that

  1336.      * has multiple transforms.

  1337.      */

  1338.     void setRenderingIntent(int renderingIntent) {

  1339.         byte[] theHeader = getData(icSigHead);/* getData will activate deferred

  1340.                                                  profiles if necessary */

  1341.         intToBigEndian (renderingIntent, theHeader, icHdrRenderingIntent);

  1342.                                                  /* set the rendering intent */

  1343.         setData (icSigHead, theHeader);

  1344.     }

  1345. 

  1346. 

  1347.     /**

  1348.      * Returns the rendering intent of the profile.

  1349.      * This is used to select the proper transform from a profile that

  1350.      * has multiple transforms.  It is typically set in a source profile

  1351.      * to select a transform from an output profile.

  1352.      */

  1353.     int getRenderingIntent() {

  1354.         byte[] theHeader = getData(icSigHead);/* getData will activate deferred

  1355.                                                  profiles if necessary */

  1356.         

  1357.         int renderingIntent = intFromBigEndian(theHeader, icHdrRenderingIntent);

  1358.                                                  /* set the rendering intent */

  1359.         return renderingIntent;

  1360.     }

  1361. 

  1362. 

  1363.     /**

  1364.      * Returns the number of color components in the "input" color

  1365.      * space of this profile.  For example if the color space type

  1366.      * of this profile is TYPE_RGB, then this method will return 3.

  1367.      *

  1368.      * @return The number of color components in the profile's input

  1369.      * color space.

  1370.      *

  1371.      * @throws ProfileDataException if color space is in the profile

  1372.      *         is invalid

  1373.      */

  1374.     public int getNumComponents() {

  1375.     byte[]    theHeader;

  1376.     int    theColorSpaceSig, theNumComponents;

  1377.     

  1378.         if (deferralInfo != null) {

  1379.             return deferralInfo.numComponents; /* Need to have this info for

  1380.                                                   ICC_ColorSpace without

  1381.                                                   causing a deferred profile

  1382.                                                   to be loaded */

  1383.         }

  1384.         theHeader = getData(icSigHead);

  1385. 

  1386.         theColorSpaceSig = intFromBigEndian (theHeader, icHdrColorSpace);

  1387. 

  1388.         switch (theColorSpaceSig) {

  1389.         case icSigGrayData:

  1390.             theNumComponents = 1;

  1391.             break;

  1392. 

  1393.         case icSigSpace2CLR:

  1394.             theNumComponents = 2;

  1395.             break;

  1396. 

  1397.         case icSigXYZData:

  1398.         case icSigLabData:

  1399.         case icSigLuvData:

  1400.         case icSigYCbCrData:

  1401.         case icSigYxyData:

  1402.         case icSigRgbData:

  1403.         case icSigHsvData:

  1404.         case icSigHlsData:

  1405.         case icSigCmyData:

  1406.         case icSigSpace3CLR:

  1407.             theNumComponents = 3;

  1408.             break;

  1409. 

  1410.         case icSigCmykData:

  1411.         case icSigSpace4CLR:

  1412.             theNumComponents = 4;

  1413.             break;

  1414. 

  1415.         case icSigSpace5CLR:

  1416.             theNumComponents = 5;

  1417.             break;

  1418. 

  1419.         case icSigSpace6CLR:

  1420.             theNumComponents = 6;

  1421.             break;

  1422. 

  1423.         case icSigSpace7CLR:

  1424.             theNumComponents = 7;

  1425.             break;

  1426. 

  1427.         case icSigSpace8CLR:

  1428.             theNumComponents = 8;

  1429.             break;

  1430. 

  1431.         case icSigSpace9CLR:

  1432.             theNumComponents = 9;

  1433.             break;

  1434. 

  1435.         case icSigSpaceACLR:

  1436.             theNumComponents = 10;

  1437.             break;

  1438. 

  1439.         case icSigSpaceBCLR:

  1440.             theNumComponents = 11;

  1441.             break;

  1442. 

  1443.         case icSigSpaceCCLR:

  1444.             theNumComponents = 12;

  1445.             break;

  1446. 

  1447.         case icSigSpaceDCLR:

  1448.             theNumComponents = 13;

  1449.             break;

  1450. 

  1451.         case icSigSpaceECLR:

  1452.             theNumComponents = 14;

  1453.             break;

  1454. 

  1455.         case icSigSpaceFCLR:

  1456.             theNumComponents = 15;

  1457.             break;

  1458. 

  1459.         default:

  1460.             throw new ProfileDataException ("invalid ICC color space");

  1461.         }

  1462.         

  1463.         return theNumComponents;

  1464.     }

  1465. 

  1466. 

  1467.     /**

  1468.      * Returns a float array of length 3 containing the X, Y, and Z

  1469.      * components of the mediaWhitePointTag in the ICC profile.

  1470.      */

  1471.     float[] getMediaWhitePoint() {

  1472.         return getXYZTag(icSigMediaWhitePointTag);

  1473.                                            /* get the media white point tag */

  1474.     }

  1475. 

  1476. 

  1477.     /**

  1478.      * Returns a float array of length 3 containing the X, Y, and Z

  1479.      * components encoded in an XYZType tag.

  1480.      */

  1481.     float[] getXYZTag(int theTagSignature) {

  1482.     byte[] theData;

  1483.     float[] theXYZNumber;

  1484.     int i1, i2, theS15Fixed16;

  1485.     

  1486.         theData = getData(theTagSignature); /* get the tag data */

  1487.                                             /* getData will activate deferred

  1488.                                                profiles if necessary */

  1489.         

  1490.         theXYZNumber = new float [3];        /* array to return */

  1491. 

  1492.         /* convert s15Fixed16Number to float */

  1493.         for (i1 = 0, i2 = icXYZNumberX; i1 < 3; i1++, i2 += 4) {

  1494.             theS15Fixed16 = intFromBigEndian(theData, i2);

  1495.             theXYZNumber [i1] = ((float) theS15Fixed16) / 65536.0f;

  1496.         }

  1497.         return theXYZNumber;

  1498.     }

  1499. 

  1500. 

  1501.     /**

  1502.      * Returns a gamma value representing a tone reproduction

  1503.      * curve (TRC).  If the profile represents the TRC as a table rather

  1504.      * than a single gamma value, then an exception is thrown.  In this

  1505.      * case the actual table can be obtained via getTRC().

  1506.      * theTagSignature should be one of icSigGrayTRCTag, icSigRedTRCTag,

  1507.      * icSigGreenTRCTag, or icSigBlueTRCTag.

  1508.      * @return the gamma value as a float.

  1509.      * @exception ProfileDataException if the profile does not specify

  1510.      *            the TRC as a single gamma value.

  1511.      */

  1512.     float getGamma(int theTagSignature) {

  1513.     byte[] theTRCData;

  1514.     float theGamma;

  1515.     int theU8Fixed8;

  1516. 

  1517.         theTRCData = getData(theTagSignature); /* get the TRC */

  1518.                                                /* getData will activate deferred

  1519.                                                   profiles if necessary */

  1520.         

  1521.         if (intFromBigEndian (theTRCData, icCurveCount) != 1) {

  1522.             throw new ProfileDataException ("TRC is not a gamma");

  1523.         }

  1524. 

  1525.         /* convert u8Fixed8 to float */

  1526.         theU8Fixed8 = (shortFromBigEndian(theTRCData, icCurveData)) & 0xffff;

  1527.             

  1528.         theGamma = ((float) theU8Fixed8) / 256.0f;

  1529.         

  1530.         return theGamma;

  1531.     }

  1532. 

  1533. 

  1534.     /**

  1535.      * Returns the TRC as an array of shorts.  If the profile has

  1536.      * specified the TRC as linear (gamma = 1.0) or as a simple gamma

  1537.      * value, this method throws an exception, and the getGamma() method

  1538.      * should be used to get the gamma value.  Otherwise the short array

  1539.      * returned here represents a lookup table where the input Gray value

  1540.      * is conceptually in the range [0.0, 1.0].  Value 0.0 maps

  1541.      * to array index 0 and value 1.0 maps to array index length-1.

  1542.      * Interpolation may be used to generate output values for

  1543.      * input values which do not map exactly to an index in the

  1544.      * array.  Output values also map linearly to the range [0.0, 1.0].

  1545.      * Value 0.0 is represented by an array value of 0x0000 and

  1546.      * value 1.0 by 0xFFFF, i.e. the values are really unsigned

  1547.      * short values, although they are returned in a short array.

  1548.      * theTagSignature should be one of icSigGrayTRCTag, icSigRedTRCTag,

  1549.      * icSigGreenTRCTag, or icSigBlueTRCTag.

  1550.      * @return a short array representing the TRC.

  1551.      * @exception ProfileDataException if the profile does not specify

  1552.      *            the TRC as a table.

  1553.      */

  1554.     short[] getTRC(int theTagSignature) {

  1555.     byte[] theTRCData;

  1556.     short[] theTRC;

  1557.     int i1, i2, nElements, theU8Fixed8;

  1558. 

  1559.         theTRCData = getData(theTagSignature); /* get the TRC */

  1560.                                                /* getData will activate deferred

  1561.                                                   profiles if necessary */

  1562.         

  1563.         nElements = intFromBigEndian(theTRCData, icCurveCount);

  1564. 

  1565.         if (nElements == 1) {

  1566.             throw new ProfileDataException("TRC is not a table");

  1567.         }

  1568. 

  1569.         /* make the short array */

  1570.         theTRC = new short [nElements];

  1571. 

  1572.         for (i1 = 0, i2 = icCurveData; i1 < nElements; i1++, i2 += 2) {

  1573.             theTRC[i1] = shortFromBigEndian(theTRCData, i2);

  1574.         }

  1575.         

  1576.         return theTRC;

  1577.     }

  1578. 

  1579. 

  1580.     /* convert an ICC color space signature into a Java color space type */

  1581.     static int iccCStoJCS(int theColorSpaceSig) {

  1582.     int theColorSpace;

  1583. 

  1584.         switch (theColorSpaceSig) {

  1585.         case icSigXYZData:

  1586.             theColorSpace = ColorSpace.TYPE_XYZ;

  1587.             break;

  1588. 

  1589.         case icSigLabData:

  1590.             theColorSpace = ColorSpace.TYPE_Lab;

  1591.             break;

  1592. 

  1593.         case icSigLuvData:

  1594.             theColorSpace = ColorSpace.TYPE_Luv;

  1595.             break;

  1596. 

  1597.         case icSigYCbCrData:

  1598.             theColorSpace = ColorSpace.TYPE_YCbCr;

  1599.             break;

  1600. 

  1601.         case icSigYxyData:

  1602.             theColorSpace = ColorSpace.TYPE_Yxy;

  1603.             break;

  1604. 

  1605.         case icSigRgbData:

  1606.             theColorSpace = ColorSpace.TYPE_RGB;

  1607.             break;

  1608. 

  1609.         case icSigGrayData:

  1610.             theColorSpace = ColorSpace.TYPE_GRAY;

  1611.             break;

  1612. 

  1613.         case icSigHsvData:

  1614.             theColorSpace = ColorSpace.TYPE_HSV;

  1615.             break;

  1616. 

  1617.         case icSigHlsData:

  1618.             theColorSpace = ColorSpace.TYPE_HLS;

  1619.             break;

  1620. 

  1621.         case icSigCmykData:

  1622.             theColorSpace = ColorSpace.TYPE_CMYK;

  1623.             break;

  1624. 

  1625.         case icSigCmyData:

  1626.             theColorSpace = ColorSpace.TYPE_CMY;

  1627.             break;

  1628. 

  1629.         case icSigSpace2CLR:

  1630.             theColorSpace = ColorSpace.TYPE_2CLR;

  1631.             break;

  1632. 

  1633.         case icSigSpace3CLR:

  1634.             theColorSpace = ColorSpace.TYPE_3CLR;

  1635.             break;

  1636. 

  1637.         case icSigSpace4CLR:

  1638.             theColorSpace = ColorSpace.TYPE_4CLR;

  1639.             break;

  1640. 

  1641.         case icSigSpace5CLR:

  1642.             theColorSpace = ColorSpace.TYPE_5CLR;

  1643.             break;

  1644. 

  1645.         case icSigSpace6CLR:

  1646.             theColorSpace = ColorSpace.TYPE_6CLR;

  1647.             break;

  1648. 

  1649.         case icSigSpace7CLR:

  1650.             theColorSpace = ColorSpace.TYPE_7CLR;

  1651.             break;

  1652. 

  1653.         case icSigSpace8CLR:

  1654.             theColorSpace = ColorSpace.TYPE_8CLR;

  1655.             break;

  1656. 

  1657.         case icSigSpace9CLR:

  1658.             theColorSpace = ColorSpace.TYPE_9CLR;

  1659.             break;

  1660. 

  1661.         case icSigSpaceACLR:

  1662.             theColorSpace = ColorSpace.TYPE_ACLR;

  1663.             break;

  1664. 

  1665.         case icSigSpaceBCLR:

  1666.             theColorSpace = ColorSpace.TYPE_BCLR;

  1667.             break;

  1668. 

  1669.         case icSigSpaceCCLR:

  1670.             theColorSpace = ColorSpace.TYPE_CCLR;

  1671.             break;

  1672. 

  1673.         case icSigSpaceDCLR:

  1674.             theColorSpace = ColorSpace.TYPE_DCLR;

  1675.             break;

  1676. 

  1677.         case icSigSpaceECLR:

  1678.             theColorSpace = ColorSpace.TYPE_ECLR;

  1679.             break;

  1680. 

  1681.         case icSigSpaceFCLR:

  1682.             theColorSpace = ColorSpace.TYPE_FCLR;

  1683.             break;

  1684. 

  1685.         default:

  1686.             throw new IllegalArgumentException ("Unknown color space");

  1687.         }

  1688.         

  1689.         return theColorSpace;

  1690.     }

  1691.     

  1692.     

  1693.     static int intFromBigEndian(byte[] array, int index) {

  1694.         return (((array[index]   & 0xff) << 24) |

  1695.                 ((array[index+1] & 0xff) << 16) |

  1696.                 ((array[index+2] & 0xff) <<  8) |

  1697.                  (array[index+3] & 0xff));

  1698.     }

  1699.     

  1700.     

  1701.     static void intToBigEndian(int value, byte[] array, int index) {

  1702.             array[index]   = (byte) (value >> 24);

  1703.             array[index+1] = (byte) (value >> 16);

  1704.             array[index+2] = (byte) (value >>  8);

  1705.             array[index+3] = (byte) (value);

  1706.     }

  1707.     

  1708.     

  1709.     static short shortFromBigEndian(byte[] array, int index) {

  1710.         return (short) (((array[index]   & 0xff) << 8) |

  1711.                          (array[index+1] & 0xff));

  1712.     }

  1713.     

  1714.     

  1715.     static void shortToBigEndian(short value, byte[] array, int index) {

  1716.             array[index]   = (byte) (value >> 8);

  1717.             array[index+1] = (byte) (value);

  1718.     }

  1719. 

  1720. 

  1721.     /*

  1722.      * fileName may be an absolute or a relative file specification.

  1723.      * Relative file names are looked for in several places: first, relative

  1724.      * to any directories specified by the java.iccprofile.path property;

  1725.      * second, relative to any directories specified by the java.class.path

  1726.      * property; finally, in a directory used to store profiles always

  1727.      * available, such as a profile for sRGB.  Built-in profiles use .pf as

  1728.      * the file name extension for profiles, e.g. sRGB.pf.

  1729.      */

  1730.     private static FileInputStream openProfile(final String fileName) {

  1731. 	return (FileInputStream)java.security.AccessController.doPrivileged(

  1732. 	    new java.security.PrivilegedAction() {

  1733. 	    public Object run() {

  1734. 		return privilegedOpenProfile(fileName);

  1735. 	    }

  1736. 	});

  1737.     }

  1738. 

  1739.     /*

  1740.      * this version is called from doPrivileged in privilegedOpenProfile.

  1741.      * the whole method is privileged!

  1742.      */

  1743.     private static FileInputStream privilegedOpenProfile(String fileName) {

  1744.         FileInputStream fis = null;

  1745.         String path, dir, fullPath;

  1746. 

  1747. 	    try {

  1748. 	        fis = new FileInputStream(fileName);  /* absolute file name */

  1749. 	    }

  1750. 	    catch (FileNotFoundException e) {

  1751. 	    }

  1752. 

  1753. 	    if ((fis == null) &&

  1754. 		((path = System.getProperty("java.iccprofile.path")) != null)){

  1755.                                     /* try relative to java.iccprofile.path */

  1756. 	        StringTokenizer st = 

  1757. 		    new StringTokenizer(path, File.pathSeparator);

  1758. 		while (st.hasMoreTokens() && (fis == null)) {

  1759. 		    dir = st.nextToken();

  1760. 		    try {

  1761. 		        fullPath = dir + File.separatorChar + fileName;

  1762. 			fis = new FileInputStream(fullPath);

  1763. 		    }

  1764. 		    catch (FileNotFoundException e) {

  1765. 		    }

  1766. 		}

  1767. 	    }

  1768. 

  1769. 	    if ((fis == null) &&

  1770. 		((path = System.getProperty("java.class.path")) != null)) {

  1771.                                     /* try relative to java.class.path */

  1772. 	        StringTokenizer st =

  1773. 		    new StringTokenizer(path, File.pathSeparator);

  1774. 		while (st.hasMoreTokens() && (fis == null)) {

  1775. 		    dir = st.nextToken();

  1776. 		    try {

  1777. 		        fullPath = dir + File.separatorChar + fileName;

  1778. 			fis = new FileInputStream(fullPath);

  1779. 		    }

  1780. 		    catch (FileNotFoundException e) {

  1781. 		    }

  1782. 		}

  1783. 	    }

  1784. 

  1785. 	    if (fis == null) {    /* try the directory of built-in profiles */

  1786. 	        dir = System.getProperty("java.home") +

  1787. 		    File.separatorChar + "lib" + File.separatorChar + "cmm";

  1788. 		fullPath = dir + File.separatorChar + fileName;

  1789. 		try {

  1790. 		    fis = new FileInputStream(fullPath);

  1791. 		}

  1792. 		catch (FileNotFoundException e) {

  1793. 		}

  1794. 	    }

  1795.         return fis;

  1796.     }

  1797. 

  1798. 

  1799.     /* 

  1800.      * Serialization support.

  1801.      * 

  1802.      * Directly deserialized profiles are useless since they are not

  1803.      * registered with CMM.  We don't allow constructor to be called

  1804.      * directly and instead have clients to call one of getInstance

  1805.      * factory methods that will register the profile with CMM.  For

  1806.      * deserialization we implement readResolve method that will

  1807.      * resolve the bogus deserialized profile object with one obtained

  1808.      * with getInstance as well.

  1809.      *

  1810.      * There're two primary factory methods for construction of ICC

  1811.      * profiles: getInstance(int cspace) and getInstance(byte[] data).

  1812.      * This implementation of ICC_Profile uses the former to return a

  1813.      * cached singleton profile object, other implementations will

  1814.      * likely use this technique too.  To preserve the singleton

  1815.      * pattern across serialization we serialize cached singleton

  1816.      * profiles in such a way that deserializing VM could call

  1817.      * getInstance(int cspace) method that will resolve deserialized

  1818.      * object into the corresponding singleton as well.

  1819.      * 

  1820.      * Since the singletons are private to ICC_Profile the readResolve

  1821.      * method have to be `protected' instead of `private' so that

  1822.      * singletons that are instances of subclasses of ICC_Profile

  1823.      * could be correctly deserialized.

  1824.      */

  1825. 

  1826. 

  1827.     /**

  1828.      * Version of the format of additional serialized data in the

  1829.      * stream.  Version <code>1</code> corresponds to Java 2

  1830.      * Platform, v1.3.

  1831.      * @since 1.3

  1832.      * @serial

  1833.      */

  1834.     private int iccProfileSerializedDataVersion = 1;

  1835. 

  1836. 

  1837.     /**

  1838.      * Writes default serializable fields to the stream.  Writes a

  1839.      * string and an array of bytes to the stream as additional data.

  1840.      *

  1841.      * @param s stream used for serialization.

  1842.      * @throws IOException

  1843.      *     thrown by <code>ObjectInputStream</code>.

  1844.      * @serialData 

  1845.      *     The <code>String</code> is the name of one of

  1846.      *     <code>CS_<var>*</var></code> constants defined in the

  1847.      *     {@link ColorSpace} class if the profile object is a profile

  1848.      *     for a predefined color space (for example

  1849.      *     <code>"CS_sRGB"</code>).  The string is <code>null</code>

  1850.      *     otherwise.

  1851.      *     <p>

  1852.      *     The <code>byte[]</code> array is the profile data for the

  1853.      *     profile.  For predefined color spaces <code>null</code> is

  1854.      *     written instead of the profile data.  If in the future

  1855.      *     versions of Java API new predefined color spaces will be

  1856.      *     added, future versions of this class may choose to write

  1857.      *     for new predefined color spaces not only the color space

  1858.      *     name, but the profile data as well so that older versions

  1859.      *     could still deserialize the object.

  1860.      */

  1861.     private void writeObject(ObjectOutputStream s)

  1862.       throws IOException

  1863.     {

  1864. 	s.defaultWriteObject();

  1865. 

  1866. 	String csName = null;

  1867. 	if (this == sRGBprofile) {

  1868. 	    csName = "CS_sRGB";

  1869. 	} else if (this == XYZprofile) {

  1870. 	    csName = "CS_CIEXYZ";

  1871. 	} else if (this == PYCCprofile) {

  1872. 	    csName = "CS_PYCC";

  1873. 	} else if (this == GRAYprofile) {

  1874. 	    csName = "CS_GRAY";

  1875. 	} else if (this == LINEAR_RGBprofile) {

  1876. 	    csName = "CS_LINEAR_RGB";

  1877. 	}

  1878. 

  1879. 	// Future versions may choose to write profile data for new

  1880. 	// predefined color spaces as well, if any will be introduced,

  1881. 	// so that old versions that don't recognize the new CS name

  1882. 	// may fall back to constructing profile from the data.

  1883. 	byte[] data = null;

  1884. 	if (csName == null) {

  1885. 	    // getData will activate deferred profile if necessary

  1886. 	    data = getData();

  1887. 	}

  1888. 

  1889. 	s.writeObject(csName);

  1890. 	s.writeObject(data);

  1891.     }

  1892. 

  1893.     // Temporary storage used by readObject to store resolved profile

  1894.     // (obtained with getInstance) for readResolve to return.

  1895.     private transient ICC_Profile resolvedDeserializedProfile;

  1896. 

  1897.     /**

  1898.      * Reads default serializable fields from the stream.  Reads from

  1899.      * the stream a string and an array of bytes as additional data.

  1900.      *

  1901.      * @param s stream used for deserialization.

  1902.      * @throws IOException

  1903.      *     thrown by <code>ObjectInputStream</code>.

  1904.      * @throws ClassNotFoundException

  1905.      *     thrown by <code>ObjectInputStream</code>.

  1906.      * @serialData

  1907.      *     The <code>String</code> is the name of one of

  1908.      *     <code>CS_<var>*</var></code> constants defined in the

  1909.      *     {@link ColorSpace} class if the profile object is a profile

  1910.      *     for a predefined color space (for example

  1911.      *     <code>"CS_sRGB"</code>).  The string is <code>null</code>

  1912.      *     otherwise.

  1913.      *     <p>

  1914.      *     The <code>byte[]</code> array is the profile data for the

  1915.      *     profile.  It will usually be <code>null</code> for the

  1916.      *     predefined profiles.

  1917.      *     <p>

  1918.      *     If the string is recognized as a constant name for

  1919.      *     predefined color space the object will be resolved into

  1920.      *     profile obtained with

  1921.      *     <code>getInstance(int cspace)</code> and the profile

  1922.      *     data are ignored.  Otherwise the object will be resolved

  1923.      *     into profile obtained with

  1924.      *     <code>getInstance(byte[] data)</code>.

  1925.      * @see #readResolve()

  1926.      * @see #getInstance(int)

  1927.      * @see #getInstance(byte[])

  1928.      */

  1929.     private void readObject(ObjectInputStream s)

  1930.       throws IOException, ClassNotFoundException

  1931.     {

  1932. 	s.defaultReadObject();

  1933. 

  1934. 	String csName = (String)s.readObject();

  1935. 	byte[] data = (byte[])s.readObject();

  1936. 

  1937. 	int cspace = 0;		// ColorSpace.CS_* constant if known

  1938. 	boolean isKnownPredefinedCS = false;

  1939. 	if (csName != null) {

  1940. 	    isKnownPredefinedCS = true;

  1941. 	    if (csName.equals("CS_sRGB")) {

  1942. 		cspace = ColorSpace.CS_sRGB;

  1943. 	    } else if (csName.equals("CS_CIEXYZ")) {

  1944. 		cspace = ColorSpace.CS_CIEXYZ;

  1945. 	    } else if (csName.equals("CS_PYCC")) {

  1946. 		cspace = ColorSpace.CS_PYCC;

  1947. 	    } else if (csName.equals("CS_GRAY")) {

  1948. 		cspace = ColorSpace.CS_GRAY;

  1949. 	    } else if (csName.equals("CS_LINEAR_RGB")) {

  1950. 		cspace = ColorSpace.CS_LINEAR_RGB;

  1951. 	    } else {

  1952. 		isKnownPredefinedCS = false;

  1953. 	    }

  1954. 	}

  1955. 

  1956. 	if (isKnownPredefinedCS) {

  1957. 	    resolvedDeserializedProfile = getInstance(cspace);

  1958. 	} else {

  1959. 	    resolvedDeserializedProfile = getInstance(data);

  1960. 	}

  1961.     }

  1962. 

  1963.     /**

  1964.      * Resolves instances being deserialized into instances registered

  1965.      * with CMM.

  1966.      * @return ICC_Profile object for profile registered with CMM.

  1967.      * @throws ObjectStreamException

  1968.      *     never thrown, but mandated by the serialization spec.

  1969.      */

  1970.     protected Object readResolve() throws ObjectStreamException {

  1971. 	return resolvedDeserializedProfile;

  1972.     }

  1973. }