1. /*

  2.  * @(#)ICC_Profile.java	1.23 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. /**********************************************************************

  12.  **********************************************************************

  13.  **********************************************************************

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

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

  16.  *** States Code.  All rights reserved.                             ***

  17.  **********************************************************************

  18.  **********************************************************************

  19.  **********************************************************************/

  20. 

  21. package java.awt.color;

  22. 

  23. import sun.awt.color.CMM;

  24. import sun.awt.color.ProfileDeferralMgr;

  25. import sun.awt.color.ProfileDeferralInfo;

  26. import sun.awt.color.ProfileActivator;

  27. 

  28. import java.io.File;

  29. import java.io.FileInputStream;

  30. import java.io.FileNotFoundException;

  31. import java.io.FileOutputStream;

  32. import java.io.IOException;

  33. import java.io.InputStream;

  34. import java.io.ObjectInputStream;

  35. import java.io.ObjectOutputStream;

  36. import java.io.ObjectStreamException;

  37. import java.io.OutputStream;

  38. import java.io.Serializable;

  39. 

  40. import java.util.StringTokenizer;

  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:1998-09, File Format for Color Profiles,

  46.  * September 1998, and the addendum ICC.1A:1999-04, April 1999, to that

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

  48.  * <p>

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

  50.  * ICC_Profile.

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

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

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

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

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

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

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

  58.  * another's).

  59.  * <p> 

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

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

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

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

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

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

  66.  * either have invertible transformations or explicitly specify

  67.  * transformations going both directions.

  68.  * <p>

  69.  * @version 10 Feb 1997

  70.  * @see ICC_ColorSpace

  71.  */

  72. 

  73. 

  74. public class ICC_Profile implements Serializable {

  75. 

  76.     transient long ID;

  77. 

  78.     private transient ProfileDeferralInfo deferralInfo;

  79.     private transient ProfileActivator profileActivator;

  80. 

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

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

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

  84.     private static ICC_Profile sRGBprofile;

  85.     private static ICC_Profile XYZprofile;

  86.     private static ICC_Profile PYCCprofile;

  87.     private static ICC_Profile GRAYprofile;

  88.     private static ICC_Profile LINEAR_RGBprofile;

  89. 

  90. 

  91.     /**

  92.      * Profile class is input.

  93.      */

  94.     public static final int CLASS_INPUT = 0;

  95. 

  96.     /**

  97.      * Profile class is display.

  98.      */

  99.     public static final int CLASS_DISPLAY = 1;

  100. 

  101.     /**

  102.      * Profile class is output.

  103.      */

  104.     public static final int CLASS_OUTPUT = 2;

  105. 

  106.     /**

  107.      * Profile class is device link.

  108.      */

  109.     public static final int CLASS_DEVICELINK = 3;

  110. 

  111.     /**

  112.      * Profile class is color space conversion.

  113.      */

  114.     public static final int CLASS_COLORSPACECONVERSION = 4;

  115. 

  116.     /**

  117.      * Profile class is abstract.

  118.      */

  119.     public static final int CLASS_ABSTRACT = 5;

  120. 

  121.     /**

  122.      * Profile class is named color.

  123.      */

  124.     public static final int CLASS_NAMEDCOLOR = 6;

  125. 

  126. 

  127.     /**

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

  129.      */

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

  131. 

  132.     /**

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

  134.      */

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

  136. 

  137.     /**

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

  139.      */

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

  141. 

  142.     /**

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

  144.      */

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

  146. 

  147.     /**

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

  149.      */

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

  151. 

  152.     /**

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

  154.      */

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

  156. 

  157.     /**

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

  159.      */

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

  161. 

  162.     /**

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

  164.      */

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

  166. 

  167.     /**

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

  169.      */

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

  171. 

  172.     /**

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

  174.      */

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

  176. 

  177.     /**

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

  179.      */

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

  181. 

  182.     /**

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

  184.      */

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

  186. 

  187.     /**

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

  189.      */

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

  191. 

  192.     /**

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

  194.      */

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

  196. 

  197.     /**

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

  199.      */

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

  201. 

  202.     /**

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

  204.      */

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

  206. 

  207.     /**

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

  209.      */

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

  211. 

  212.     /**

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

  214.      */

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

  216. 

  217.     /**

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

  219.      */

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

  221. 

  222.     /**

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

  224.      */

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

  226. 

  227.     /**

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

  229.      */

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

  231. 

  232.     /**

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

  234.      */

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

  236. 

  237.     /**

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

  239.      */

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

  241. 

  242.     /**

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

  244.      */

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

  246. 

  247.     /**

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

  249.      */

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

  251. 

  252. 

  253.     /**

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

  255.      */

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

  257. 

  258.     /**

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

  260.      */

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

  262. 

  263.     /**

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

  265.      */

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

  267. 

  268.     /**

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

  270.      */

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

  272. 

  273.     /**

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

  275.      */

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

  277. 

  278.     /**

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

  280.      */

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

  282. 

  283.     /**

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

  285.      */

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

  287. 

  288. 

  289.     /**

  290.      * ICC Profile Rendering Intent: Perceptual.

  291.      */

  292.     public static final int icPerceptual            = 0;

  293. 

  294.     /**

  295.      * ICC Profile Rendering Intent: RelativeColorimetric.

  296.      */

  297.     public static final int icRelativeColorimetric    = 1;

  298. 

  299.     /**

  300.      * ICC Profile Rendering Intent: Saturation.

  301.      */

  302.     public static final int icSaturation            = 2;

  303. 

  304.     /**

  305.      * ICC Profile Rendering Intent: AbsoluteColorimetric.

  306.      */

  307.     public static final int icAbsoluteColorimetric    = 3;

  308. 

  309. 

  310. 

  311.     /**

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

  313.      */

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

  315. 

  316.     /**

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

  318.      */

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

  320. 

  321.     /**

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

  323.      */

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

  325. 

  326.     /**

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

  328.      */

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

  330. 

  331.     /**

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

  333.      */

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

  335. 

  336.     /**

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

  338.      */

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

  340. 

  341.     /**

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

  343.      */

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

  345. 

  346.     /**

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

  348.      */

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

  350. 

  351.     /**

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

  353.      */

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

  355. 

  356.     /**

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

  358.      */

  359.     public static final int icSigCalibrationDateTimeTag = 0x63616C74;

  360.                                                                    /* 'calt' */

  361. 

  362.     /**

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

  364.      */

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

  366. 

  367.     /**

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

  369.      */

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

  371. 

  372.     /**

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

  374.      */

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

  376. 

  377.     /**

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

  379.      */

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

  381. 

  382.     /**

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

  384.      */

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

  386. 

  387.     /**

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

  389.      */

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

  391. 

  392.     /**

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

  394.      */

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

  396. 

  397.     /**

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

  399.      */

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

  401. 

  402.     /**

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

  404.      */

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

  406. 

  407.     /**

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

  409.      */

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

  411. 

  412.     /**

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

  414.      */

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

  416. 

  417.     /**

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

  419.      */

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

  421. 

  422.     /**

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

  424.      */

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

  426. 

  427.     /**

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

  429.      */

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

  431. 

  432.     /**

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

  434.      */

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

  436. 

  437.     /**

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

  439.      */

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

  441. 

  442.     /**

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

  444.      */

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

  446. 

  447.     /**

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

  449.      */

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

  451. 

  452.     /**

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

  454.      */

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

  456. 

  457.     /**

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

  459.      */

  460.     public static final int icSigProfileDescriptionTag = 0x64657363;

  461.                                                                    /* 'desc' */

  462. 

  463.     /**

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

  465.      */

  466.     public static final int icSigProfileSequenceDescTag = 0x70736571;

  467.                                                                    /* 'pseq' */

  468. 

  469.     /**

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

  471.      */

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

  473. 

  474.     /**

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

  476.      */

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

  478. 

  479.     /**

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

  481.      */

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

  483. 

  484.     /**

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

  486.      */

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

  488. 

  489.     /**

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

  491.      */

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

  493. 

  494.     /**

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

  496.      */

  497.     public static final int icSigPs2RenderingIntentTag = 0x70733269;

  498.                                                                    /* 'ps2i' */

  499. 

  500.     /**

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

  502.      */

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

  504. 

  505.     /**

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

  507.      */

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

  509. 

  510.     /**

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

  512.      */

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

  514. 

  515.     /**

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

  517.      */

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

  519. 

  520.     /**

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

  522.      */

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

  524. 

  525.     /**

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

  527.      */

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

  529. 

  530.     /**

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

  532.      */

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

  534. 

  535.     /**

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

  537.      */

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

  539. 

  540.     /**

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

  542.      */

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

  544. 

  545. 

  546.     /**

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

  548.      */

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

  550. 

  551.     /**

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

  553.      */

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

  555. 

  556.     /**

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

  558.      */

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

  560. 

  561.     /**

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

  563.      */

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

  565. 

  566.     /**

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

  568.      */

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

  570. 

  571.     /**

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

  573.      */

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

  575. 

  576.     /**

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

  578.      */

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

  580. 

  581.     /**

  582.      * ICC Profile Header Location: icMagicNumber.

  583.      */

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

  585. 

  586.     /**

  587.      * ICC Profile Header Location: primary platform.

  588.      */

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

  590. 

  591.     /**

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

  593.      */

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

  595. 

  596.     /**

  597.      * ICC Profile Header Location: device manufacturer.

  598.      */

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

  600. 

  601.     /**

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

  603.      */

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

  605. 

  606.     /**

  607.      * ICC Profile Header Location: device attributes.

  608.      */

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

  610. 

  611.     /**

  612.      * ICC Profile Header Location: rendering intent.

  613.      */

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

  615. 

  616.     /**

  617.      * ICC Profile Header Location: profile illuminant.

  618.      */

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

  620. 

  621.     /**

  622.      * ICC Profile Header Location: profile creator.

  623.      */

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

  625. 

  626. 

  627.     /**

  628.      * ICC Profile Constant: tag type signaturE.

  629.      */

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

  631. 

  632.     /**

  633.      * ICC Profile Constant: reserved.

  634.      */

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

  636. 

  637.     /**

  638.      * ICC Profile Constant: curveType count.

  639.      */

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

  641. 

  642.     /**

  643.      * ICC Profile Constant: curveType data.

  644.      */

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

  646. 

  647.     /**

  648.      * ICC Profile Constant: XYZNumber X.

  649.      */

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

  651. 

  652. 

  653.     /**

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

  655.      */

  656.     ICC_Profile(long ID) {

  657.         this.ID = ID;

  658.     }

  659. 

  660. 

  661.     /**

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

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

  664.      */

  665.     ICC_Profile(ProfileDeferralInfo pdi) {

  666.         this.deferralInfo = pdi;

  667.         this.profileActivator = new ProfileActivator() {

  668.             public void activate() {

  669.                 activateDeferredProfile();

  670.             }

  671.         };

  672.         ProfileDeferralMgr.registerDeferral(this.profileActivator);

  673.     }

  674. 

  675. 

  676.     /**

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

  678.      */

  679.     protected void finalize () {

  680.         if (ID != 0) {

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

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

  683.             ProfileDeferralMgr.unregisterDeferral(profileActivator);

  684.         }

  685.     }

  686. 

  687. 

  688.     /**

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

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

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

  692.      */

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

  694.     ICC_Profile thisProfile;

  695. 

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

  697. 

  698.         if (ProfileDeferralMgr.deferring) {

  699.             ProfileDeferralMgr.activateProfiles();

  700.         }

  701.         

  702.         try {

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

  704.         } catch (CMMException c) {

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

  706.         }

  707. 

  708.         try {

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

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

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

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

  713.             }

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

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

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

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

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

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

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

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

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

  723.             }

  724.             else {

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

  726.             }

  727.         } catch (CMMException c) {

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

  729.         }

  730.         return thisProfile;

  731.     }

  732. 

  733. 

  734. 

  735.     /**

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

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

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

  739.      * defined color spaces.

  740.      */

  741.     public static ICC_Profile getInstance (int cspace)

  742.     {

  743.     ICC_Profile thisProfile = null;

  744.     String fileName;

  745. 

  746.         try {

  747.             switch (cspace) {

  748.             case ColorSpace.CS_sRGB:

  749.                 if (sRGBprofile == null) {

  750.                     sRGBprofile = getDeferredInstance(

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

  752.                                                 3, CLASS_DISPLAY)); 

  753.                 }

  754.                 thisProfile = sRGBprofile;

  755. 

  756.                 break;

  757. 

  758.             case ColorSpace.CS_CIEXYZ:

  759.                 if (XYZprofile == null) {

  760.                     XYZprofile = getInstance ("CIEXYZ.pf");

  761.                 }

  762.                 thisProfile = XYZprofile;

  763. 

  764.                 break;

  765. 

  766.             case ColorSpace.CS_PYCC:

  767.                 if (PYCCprofile == null) {

  768.                     PYCCprofile = getInstance ("PYCC.pf");

  769.                 }

  770.                 thisProfile = PYCCprofile;

  771. 

  772.                 break;

  773. 

  774.             case ColorSpace.CS_GRAY:

  775.                 if (GRAYprofile == null) {

  776.                     GRAYprofile = getInstance ("GRAY.pf");

  777.                 }

  778.                 thisProfile = GRAYprofile;

  779. 

  780.                 break;

  781. 

  782.             case ColorSpace.CS_LINEAR_RGB:

  783.                 if (LINEAR_RGBprofile == null) {

  784.                     LINEAR_RGBprofile = getInstance ("LINEAR_RGB.pf");

  785.                 }

  786.                 thisProfile = LINEAR_RGBprofile;

  787. 

  788.                 break;

  789. 

  790.             default:

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

  792.             }

  793.         } catch (IOException e) {

  794.             throw new IllegalArgumentException("Can't load standard profile");

  795.         }

  796. 

  797.         return thisProfile;

  798.     }

  799. 

  800. 

  801.     /**

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

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

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

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

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

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

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

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

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

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

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

  813.      * Profile data.

  814.      */

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

  816.     ICC_Profile thisProfile;

  817.     FileInputStream fis;

  818. 

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

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

  821.         }

  822. 

  823.         thisProfile = getInstance(fis);

  824. 

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

  826.     

  827.         return thisProfile;

  828.     }

  829. 

  830. 

  831.     /**

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

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

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

  835.      * error occurs while reading the stream.

  836.      */

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

  838.     byte profileData[];

  839. 

  840.         if (s instanceof ProfileDeferralInfo) {

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

  842.             return getDeferredInstance((ProfileDeferralInfo) s);

  843.         }

  844. 

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

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

  847.         }

  848. 

  849.         return getInstance(profileData);

  850.     }

  851. 

  852. 

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

  854.     byte profileData[];

  855.     int profileSize;

  856. 

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

  858.         int bytestoread = 128;

  859.         int bytesread = 0;

  860.         int n;

  861. 

  862.         while (bytestoread != 0) {

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

  864.                 return null;

  865.             }

  866.             bytesread += n;

  867.             bytestoread -= n;

  868.         }

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

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

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

  872.         }

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

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

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

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

  877.         profileData = new byte[profileSize];

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

  879.         bytestoread = profileSize - 128;

  880.         bytesread = 128;

  881.         while (bytestoread != 0) {

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

  883.                 return null;

  884.             }

  885.             bytesread += n;

  886.             bytestoread -= n;

  887.         }

  888. 

  889.         return profileData;

  890.     }

  891. 

  892. 

  893.     /**

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

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

  896.      * be deferred as long as possible.

  897.      */

  898.     static ICC_Profile getDeferredInstance(ProfileDeferralInfo pdi)

  899.         throws IOException {

  900. 

  901.         if (!ProfileDeferralMgr.deferring) {

  902.             return getInstance(pdi.filename);

  903.         }

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

  905.             return new ICC_ProfileRGB(pdi);

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

  907.             return new ICC_ProfileGray(pdi);

  908.         } else {

  909.             return new ICC_Profile(pdi);

  910.         }

  911.     }

  912. 

  913. 

  914.     void activateDeferredProfile() {

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

  916.     byte profileData[];

  917.     FileInputStream fis;

  918.     String fileName = deferralInfo.filename;

  919. 

  920.         profileActivator = null;

  921.         deferralInfo = null;

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

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

  924.         }

  925.         try {

  926.             profileData = getProfileDataFromStream(fis);

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

  928.         }

  929.         catch (IOException e) {

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

  931.                 fileName);

  932.         }

  933.         if (profileData == null) {

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

  935.                 fileName);

  936.         }

  937.         try {

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

  939.         } catch (CMMException c) {

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

  941.                 fileName);

  942.         }

  943.         ID = theID[0];

  944.     }

  945. 

  946. 

  947.     /**

  948.      * Returns profile major version.

  949.      */

  950.     public int getMajorVersion() {

  951.     byte[] theHeader;

  952.     

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

  954.                                            profiles if necessary */

  955. 

  956.         return (int) theHeader[8];

  957.     }

  958. 

  959.     /**

  960.      * Returns profile minor version.

  961.      */

  962.     public int getMinorVersion() {

  963.     byte[] theHeader;

  964.     

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

  966.                                            profiles if necessary */

  967. 

  968.         return (int) theHeader[9];

  969.     }

  970. 

  971.     /**

  972.      * Returns the profile class.  Returns one of the predefined profile

  973.      * class constants.

  974.      */

  975.     public int getProfileClass() {

  976.     byte[] theHeader;

  977.     int theClassSig, theClass;

  978.     

  979.         if (deferralInfo != null) {

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

  981.                                                  ICC_ColorSpace without

  982.                                                  causing a deferred profile

  983.                                                  to be loaded */

  984.         }

  985. 

  986.         theHeader = getData(icSigHead);

  987. 

  988.         theClassSig = intFromBigEndian (theHeader, icHdrDeviceClass);

  989.                 

  990.         switch (theClassSig) {

  991.         case icSigInputClass:

  992.             theClass = CLASS_INPUT;

  993.             break;

  994. 

  995.         case icSigDisplayClass:

  996.             theClass = CLASS_DISPLAY;

  997.             break;

  998. 

  999.         case icSigOutputClass:

  1000.             theClass = CLASS_OUTPUT;

  1001.             break;

  1002. 

  1003.         case icSigLinkClass:

  1004.             theClass = CLASS_DEVICELINK;

  1005.             break;

  1006. 

  1007.         case icSigColorSpaceClass:

  1008.             theClass = CLASS_COLORSPACECONVERSION;

  1009.             break;

  1010. 

  1011.         case icSigAbstractClass:

  1012.             theClass = CLASS_ABSTRACT;

  1013.             break;

  1014. 

  1015.         case icSigNamedColorClass:

  1016.             theClass = CLASS_NAMEDCOLOR;

  1017.             break;

  1018. 

  1019.         default:

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

  1021.         }

  1022.         

  1023.         return theClass;

  1024.     }

  1025. 

  1026.     /**

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

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

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

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

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

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

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

  1034.      * primaries.

  1035.      */

  1036.     public int getColorSpaceType() {

  1037.         if (deferralInfo != null) {

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

  1039.                                                    ICC_ColorSpace without

  1040.                                                    causing a deferred profile

  1041.                                                    to be loaded */

  1042.         }

  1043.         return    getColorSpaceType(ID);

  1044.     }

  1045.     

  1046.     static int getColorSpaceType(long profileID) {

  1047.     byte[] theHeader;

  1048.     int theColorSpaceSig, theColorSpace;

  1049.     

  1050.         theHeader = getData(profileID, icSigHead);

  1051.         theColorSpaceSig = intFromBigEndian(theHeader, icHdrColorSpace);

  1052.         theColorSpace = iccCStoJCS (theColorSpaceSig);

  1053.         return theColorSpace;

  1054.     }

  1055. 

  1056.     /**

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

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

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

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

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

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

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

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

  1065.      */

  1066.     public int getPCSType() {

  1067.         if (ProfileDeferralMgr.deferring) {

  1068.             ProfileDeferralMgr.activateProfiles();

  1069.         }

  1070.         return getPCSType(ID);

  1071.     }

  1072.     

  1073.     

  1074.     static int getPCSType(long profileID) {

  1075.     byte[] theHeader;

  1076.     int thePCSSig, thePCS;

  1077.     

  1078.         theHeader = getData(profileID, icSigHead);

  1079.         thePCSSig = intFromBigEndian(theHeader, icHdrPcs);

  1080.         thePCS = iccCStoJCS(thePCSSig);

  1081.         return thePCS;

  1082.     }

  1083. 

  1084. 

  1085.     /**

  1086.      * Write this ICC_Profile to a file.  Throws an IOException if the

  1087.      * file cannot be opened for writing or if an I/O error occurs while

  1088.      * writing the file.

  1089.      */

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

  1091.     FileOutputStream outputFile;

  1092.     byte profileData[];

  1093. 

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

  1095.                                     profiles if necessary */

  1096.         outputFile = new FileOutputStream(fileName);

  1097.         outputFile.write(profileData);

  1098.         outputFile.close ();

  1099.     }

  1100. 

  1101. 

  1102.     /**

  1103.      * Write this ICC_Profile to an OutputStream.  Throws an IOException

  1104.      * an I/O error occurs while writing the stream.

  1105.      */

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

  1107.     byte profileData[];

  1108. 

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

  1110.                                     profiles if necessary */

  1111.         s.write(profileData);

  1112.     }

  1113. 

  1114. 

  1115.     /**

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

  1117.      */

  1118.     public byte[] getData() {

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

  1120.     byte[] profileData;

  1121. 

  1122.         if (ProfileDeferralMgr.deferring) {

  1123.             ProfileDeferralMgr.activateProfiles();

  1124.         }

  1125. 

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

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

  1128. 

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

  1130. 

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

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

  1133. 

  1134.         return profileData;

  1135.     }

  1136. 

  1137. 

  1138.     /**

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

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

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

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

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

  1144.      * profile data directly.  Returns null if no such tag exists.

  1145.      */

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

  1147. 

  1148.         if (ProfileDeferralMgr.deferring) {

  1149.             ProfileDeferralMgr.activateProfiles();

  1150.         }

  1151. 

  1152.         return getData(ID, tagSignature);

  1153.     }

  1154.     

  1155. 

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

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

  1158.     byte[] tagData;

  1159. 

  1160. 	try {

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

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

  1163.                                               tagSize));

  1164. 

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

  1166. 

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

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

  1169.                                               tagData));

  1170. 	} catch(CMMException c) {

  1171. 	    tagData = null;

  1172. 	}

  1173. 

  1174.         return tagData;

  1175.     }

  1176. 

  1177.     /**

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

  1179.      * a byte array.  This method is useful

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

  1181.      * profile data directly.

  1182.      */

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

  1184. 

  1185.         if (ProfileDeferralMgr.deferring) {

  1186.             ProfileDeferralMgr.activateProfiles();

  1187.         }

  1188. 

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

  1190.     }

  1191. 

  1192.     /**

  1193.      * Sets the rendering intent of the profile.

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

  1195.      * has multiple transforms.

  1196.      */

  1197.     void setRenderingIntent(int renderingIntent) {

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

  1199.                                                  profiles if necessary */

  1200.         intToBigEndian (renderingIntent, theHeader, icHdrRenderingIntent);

  1201.                                                  /* set the rendering intent */

  1202.         setData (icSigHead, theHeader);

  1203.     }

  1204. 

  1205. 

  1206.     /**

  1207.      * Returns the rendering intent of the profile.

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

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

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

  1211.      */

  1212.     int getRenderingIntent() {

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

  1214.                                                  profiles if necessary */

  1215.         

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

  1217.                                                  /* set the rendering intent */

  1218.         return renderingIntent;

  1219.     }

  1220. 

  1221. 

  1222.     /**

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

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

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

  1226.      */

  1227.     public int getNumComponents() {

  1228.     byte[]    theHeader;

  1229.     int    theColorSpaceSig, theNumComponents;

  1230.     

  1231.         if (deferralInfo != null) {

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

  1233.                                                   ICC_ColorSpace without

  1234.                                                   causing a deferred profile

  1235.                                                   to be loaded */

  1236.         }

  1237.         theHeader = getData(icSigHead);

  1238. 

  1239.         theColorSpaceSig = intFromBigEndian (theHeader, icHdrColorSpace);

  1240. 

  1241.         switch (theColorSpaceSig) {

  1242.         case icSigGrayData:

  1243.             theNumComponents = 1;

  1244.             break;

  1245. 

  1246.         case icSigSpace2CLR:

  1247.             theNumComponents = 2;

  1248.             break;

  1249. 

  1250.         case icSigXYZData:

  1251.         case icSigLabData:

  1252.         case icSigLuvData:

  1253.         case icSigYCbCrData:

  1254.         case icSigYxyData:

  1255.         case icSigRgbData:

  1256.         case icSigHsvData:

  1257.         case icSigHlsData:

  1258.         case icSigCmyData:

  1259.         case icSigSpace3CLR:

  1260.             theNumComponents = 3;

  1261.             break;

  1262. 

  1263.         case icSigCmykData:

  1264.         case icSigSpace4CLR:

  1265.             theNumComponents = 4;

  1266.             break;

  1267. 

  1268.         case icSigSpace5CLR:

  1269.             theNumComponents = 5;

  1270.             break;

  1271. 

  1272.         case icSigSpace6CLR:

  1273.             theNumComponents = 6;

  1274.             break;

  1275. 

  1276.         case icSigSpace7CLR:

  1277.             theNumComponents = 7;

  1278.             break;

  1279. 

  1280.         case icSigSpace8CLR:

  1281.             theNumComponents = 8;

  1282.             break;

  1283. 

  1284.         case icSigSpace9CLR:

  1285.             theNumComponents = 9;

  1286.             break;

  1287. 

  1288.         case icSigSpaceACLR:

  1289.             theNumComponents = 10;

  1290.             break;

  1291. 

  1292.         case icSigSpaceBCLR:

  1293.             theNumComponents = 11;

  1294.             break;

  1295. 

  1296.         case icSigSpaceCCLR:

  1297.             theNumComponents = 12;

  1298.             break;

  1299. 

  1300.         case icSigSpaceDCLR:

  1301.             theNumComponents = 13;

  1302.             break;

  1303. 

  1304.         case icSigSpaceECLR:

  1305.             theNumComponents = 14;

  1306.             break;

  1307. 

  1308.         case icSigSpaceFCLR:

  1309.             theNumComponents = 15;

  1310.             break;

  1311. 

  1312.         default:

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

  1314.         }

  1315.         

  1316.         return theNumComponents;

  1317.     }

  1318. 

  1319. 

  1320.     /**

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

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

  1323.      */

  1324.     float[] getMediaWhitePoint() {

  1325.         return getXYZTag(icSigMediaWhitePointTag);

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

  1327.     }

  1328. 

  1329. 

  1330.     /**

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

  1332.      * components encoded in an XYZType tag.

  1333.      */

  1334.     float[] getXYZTag(int theTagSignature) {

  1335.     byte[] theData;

  1336.     float[] theXYZNumber;

  1337.     int i1, i2, theS15Fixed16;

  1338.     

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

  1340.                                             /* getData will activate deferred

  1341.                                                profiles if necessary */

  1342.         

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

  1344. 

  1345.         /* convert s15Fixed16Number to float */

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

  1347.             theS15Fixed16 = intFromBigEndian(theData, i2);

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

  1349.         }

  1350.         return theXYZNumber;

  1351.     }

  1352. 

  1353. 

  1354.     /**

  1355.      * Returns a gamma value representing a tone reproduction

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

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

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

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

  1360.      * icSigGreenTRCTag, or icSigBlueTRCTag.

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

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

  1363.      *            the TRC as a single gamma value.

  1364.      */

  1365.     float getGamma(int theTagSignature) {

  1366.     byte[] theTRCData;

  1367.     float theGamma;

  1368.     int theU8Fixed8;

  1369. 

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

  1371.                                                /* getData will activate deferred

  1372.                                                   profiles if necessary */

  1373.         

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

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

  1376.         }

  1377. 

  1378.         /* convert u8Fixed8 to float */

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

  1380.             

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

  1382.         

  1383.         return theGamma;

  1384.     }

  1385. 

  1386. 

  1387.     /**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1402.      * icSigGreenTRCTag, or icSigBlueTRCTag.

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

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

  1405.      *            the TRC as a table.

  1406.      */

  1407.     short[] getTRC(int theTagSignature) {

  1408.     byte[] theTRCData;

  1409.     short[] theTRC;

  1410.     int i1, i2, nElements, theU8Fixed8;

  1411. 

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

  1413.                                                /* getData will activate deferred

  1414.                                                   profiles if necessary */

  1415.         

  1416.         nElements = intFromBigEndian(theTRCData, icCurveCount);

  1417. 

  1418.         if (nElements == 1) {

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

  1420.         }

  1421. 

  1422.         /* make the short array */

  1423.         theTRC = new short [nElements];

  1424. 

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

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

  1427.         }

  1428.         

  1429.         return theTRC;

  1430.     }

  1431. 

  1432. 

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

  1434.     static int iccCStoJCS(int theColorSpaceSig) {

  1435.     int theColorSpace;

  1436. 

  1437.         switch (theColorSpaceSig) {

  1438.         case icSigXYZData:

  1439.             theColorSpace = ColorSpace.TYPE_XYZ;

  1440.             break;

  1441. 

  1442.         case icSigLabData:

  1443.             theColorSpace = ColorSpace.TYPE_Lab;

  1444.             break;

  1445. 

  1446.         case icSigLuvData:

  1447.             theColorSpace = ColorSpace.TYPE_Luv;

  1448.             break;

  1449. 

  1450.         case icSigYCbCrData:

  1451.             theColorSpace = ColorSpace.TYPE_YCbCr;

  1452.             break;

  1453. 

  1454.         case icSigYxyData:

  1455.             theColorSpace = ColorSpace.TYPE_Yxy;

  1456.             break;

  1457. 

  1458.         case icSigRgbData:

  1459.             theColorSpace = ColorSpace.TYPE_RGB;

  1460.             break;

  1461. 

  1462.         case icSigGrayData:

  1463.             theColorSpace = ColorSpace.TYPE_GRAY;

  1464.             break;

  1465. 

  1466.         case icSigHsvData:

  1467.             theColorSpace = ColorSpace.TYPE_HSV;

  1468.             break;

  1469. 

  1470.         case icSigHlsData:

  1471.             theColorSpace = ColorSpace.TYPE_HLS;

  1472.             break;

  1473. 

  1474.         case icSigCmykData:

  1475.             theColorSpace = ColorSpace.TYPE_CMYK;

  1476.             break;

  1477. 

  1478.         case icSigCmyData:

  1479.             theColorSpace = ColorSpace.TYPE_CMY;

  1480.             break;

  1481. 

  1482.         case icSigSpace2CLR:

  1483.             theColorSpace = ColorSpace.TYPE_2CLR;

  1484.             break;

  1485. 

  1486.         case icSigSpace3CLR:

  1487.             theColorSpace = ColorSpace.TYPE_3CLR;

  1488.             break;

  1489. 

  1490.         case icSigSpace4CLR:

  1491.             theColorSpace = ColorSpace.TYPE_4CLR;

  1492.             break;

  1493. 

  1494.         case icSigSpace5CLR:

  1495.             theColorSpace = ColorSpace.TYPE_5CLR;

  1496.             break;

  1497. 

  1498.         case icSigSpace6CLR:

  1499.             theColorSpace = ColorSpace.TYPE_6CLR;

  1500.             break;

  1501. 

  1502.         case icSigSpace7CLR:

  1503.             theColorSpace = ColorSpace.TYPE_7CLR;

  1504.             break;

  1505. 

  1506.         case icSigSpace8CLR:

  1507.             theColorSpace = ColorSpace.TYPE_8CLR;

  1508.             break;

  1509. 

  1510.         case icSigSpace9CLR:

  1511.             theColorSpace = ColorSpace.TYPE_9CLR;

  1512.             break;

  1513. 

  1514.         case icSigSpaceACLR:

  1515.             theColorSpace = ColorSpace.TYPE_ACLR;

  1516.             break;

  1517. 

  1518.         case icSigSpaceBCLR:

  1519.             theColorSpace = ColorSpace.TYPE_BCLR;

  1520.             break;

  1521. 

  1522.         case icSigSpaceCCLR:

  1523.             theColorSpace = ColorSpace.TYPE_CCLR;

  1524.             break;

  1525. 

  1526.         case icSigSpaceDCLR:

  1527.             theColorSpace = ColorSpace.TYPE_DCLR;

  1528.             break;

  1529. 

  1530.         case icSigSpaceECLR:

  1531.             theColorSpace = ColorSpace.TYPE_ECLR;

  1532.             break;

  1533. 

  1534.         case icSigSpaceFCLR:

  1535.             theColorSpace = ColorSpace.TYPE_FCLR;

  1536.             break;

  1537. 

  1538.         default:

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

  1540.         }

  1541.         

  1542.         return theColorSpace;

  1543.     }

  1544.     

  1545.     

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

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

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

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

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

  1551.     }

  1552.     

  1553.     

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

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

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

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

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

  1559.     }

  1560.     

  1561.     

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

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

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

  1565.     }

  1566.     

  1567.     

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

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

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

  1571.     }

  1572. 

  1573. 

  1574.     /*

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

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

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

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

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

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

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

  1582.      */

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

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

  1585. 	    new java.security.PrivilegedAction() {

  1586. 	    public Object run() {

  1587. 		return privilegedOpenProfile(fileName);

  1588. 	    }

  1589. 	});

  1590.     }

  1591. 

  1592.     /*

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

  1594.      * the whole method is privileged!

  1595.      */

  1596.     private static FileInputStream privilegedOpenProfile(String fileName) {

  1597.         FileInputStream fis = null;

  1598.         String path, dir, fullPath;

  1599. 

  1600. 	    try {

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

  1602. 	    }

  1603. 	    catch (FileNotFoundException e) {

  1604. 	    }

  1605. 

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

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

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

  1609. 	        StringTokenizer st = 

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

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

  1612. 		    dir = st.nextToken();

  1613. 		    try {

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

  1615. 			fis = new FileInputStream(fullPath);

  1616. 		    }

  1617. 		    catch (FileNotFoundException e) {

  1618. 		    }

  1619. 		}

  1620. 	    }

  1621. 

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

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

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

  1625. 	        StringTokenizer st =

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

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

  1628. 		    dir = st.nextToken();

  1629. 		    try {

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

  1631. 			fis = new FileInputStream(fullPath);

  1632. 		    }

  1633. 		    catch (FileNotFoundException e) {

  1634. 		    }

  1635. 		}

  1636. 	    }

  1637. 

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

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

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

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

  1642. 		try {

  1643. 		    fis = new FileInputStream(fullPath);

  1644. 		}

  1645. 		catch (FileNotFoundException e) {

  1646. 		}

  1647. 	    }

  1648.         return fis;

  1649.     }

  1650. 

  1651. 

  1652.     /* 

  1653.      * Serialization support.

  1654.      * 

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

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

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

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

  1659.      * deserialization we implement readResolve method that will

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

  1661.      * with getInstance as well.

  1662.      *

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

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

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

  1666.      * cached singleton profile object, other implementations will

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

  1668.      * pattern across serialization we serialize cached singleton

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

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

  1671.      * object into the corresponding singleton as well.

  1672.      * 

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

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

  1675.      * singletons that are instances of subclasses of ICC_Profile

  1676.      * could be correctly deserialized.

  1677.      */

  1678. 

  1679. 

  1680.     /**

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

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

  1683.      * Platform, v1.3.

  1684.      * @since 1.3

  1685.      * @serial

  1686.      */

  1687.     private int iccProfileSerializedDataVersion = 1;

  1688. 

  1689. 

  1690.     /**

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

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

  1693.      *

  1694.      * @param s stream used for serialization.

  1695.      * @throws IOException

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

  1697.      * @serialData 

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

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

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

  1701.      *     for a predefined color space (for example

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

  1703.      *     otherwise.

  1704.      *     <p>

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

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

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

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

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

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

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

  1712.      *     could still deserialize the object.

  1713.      */

  1714.     private void writeObject(ObjectOutputStream s)

  1715.       throws IOException

  1716.     {

  1717. 	s.defaultWriteObject();

  1718. 

  1719. 	String csName = null;

  1720. 	if (this == sRGBprofile) {

  1721. 	    csName = "CS_sRGB";

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

  1723. 	    csName = "CS_CIEXYZ";

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

  1725. 	    csName = "CS_PYCC";

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

  1727. 	    csName = "CS_GRAY";

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

  1729. 	    csName = "CS_LINEAR_RGB";

  1730. 	}

  1731. 

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

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

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

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

  1736. 	byte[] data = null;

  1737. 	if (csName == null) {

  1738. 	    // getData will activate deferred profile if necessary

  1739. 	    data = getData();

  1740. 	}

  1741. 

  1742. 	s.writeObject(csName);

  1743. 	s.writeObject(data);

  1744.     }

  1745. 

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

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

  1748.     private transient ICC_Profile resolvedDeserializedProfile;

  1749. 

  1750.     /**

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

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

  1753.      *

  1754.      * @param s stream used for deserialization.

  1755.      * @throws IOException

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

  1757.      * @throws ClassNotFoundException

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

  1759.      * @serialData

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

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

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

  1763.      *     for a predefined color space (for example

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

  1765.      *     otherwise.

  1766.      *     <p>

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

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

  1769.      *     predefined profiles.

  1770.      *     <p>

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

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

  1773.      *     profile obtained with

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

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

  1776.      *     into profile obtained with

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

  1778.      * @see #readResolve()

  1779.      * @see #getInstance(int)

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

  1781.      */

  1782.     private void readObject(ObjectInputStream s)

  1783.       throws IOException, ClassNotFoundException

  1784.     {

  1785. 	s.defaultReadObject();

  1786. 

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

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

  1789. 

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

  1791. 	boolean isKnownPredefinedCS = false;

  1792. 	if (csName != null) {

  1793. 	    isKnownPredefinedCS = true;

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

  1795. 		cspace = ColorSpace.CS_sRGB;

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

  1797. 		cspace = ColorSpace.CS_CIEXYZ;

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

  1799. 		cspace = ColorSpace.CS_PYCC;

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

  1801. 		cspace = ColorSpace.CS_GRAY;

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

  1803. 		cspace = ColorSpace.CS_LINEAR_RGB;

  1804. 	    } else {

  1805. 		isKnownPredefinedCS = false;

  1806. 	    }

  1807. 	}

  1808. 

  1809. 	if (isKnownPredefinedCS) {

  1810. 	    resolvedDeserializedProfile = getInstance(cspace);

  1811. 	} else {

  1812. 	    resolvedDeserializedProfile = getInstance(data);

  1813. 	}

  1814.     }

  1815. 

  1816.     /**

  1817.      * Resolves instances being deserialized into instances registered

  1818.      * with CMM.

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

  1820.      * @throws ObjectStreamException

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

  1822.      */

  1823.     protected Object readResolve() throws ObjectStreamException {

  1824. 	return resolvedDeserializedProfile;

  1825.     }

  1826. }