1. /*

  2.  * @(#)ICC_Profile.java	1.19 01/11/29

  3.  *

  4.  * Copyright 2002 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. import java.io.*;

  25. import java.util.StringTokenizer;

  26. 

  27. /**

  28.  *  

  29.  * A representation of color profile data for device

  30.  * independent and device dependent color spaces based on the ICC

  31.  * Profile Format Specification, Version 3.4, August 15, 1997, from

  32.  * the International Color Consortium (see <A href="http://www.color.org">

  33.  * http://www.color.org</A>).

  34.  * <p>

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

  36.  * ICC_Profile.

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

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

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

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

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

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

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

  44.  * another's).

  45.  * <p> 

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

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

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

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

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

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

  52.  * either have invertible transformations or explicitly specify

  53.  * transformations going both directions.

  54.  * <p>

  55.  * @version 10 Feb 1997

  56.  * @see ICC_ColorSpace

  57.  */

  58. 

  59. 

  60. public class ICC_Profile

  61. extends Object {

  62.     long    ID;

  63.     private static ICC_Profile sRGBprofile;

  64.     private static ICC_Profile XYZprofile;

  65.     private static ICC_Profile PYCCprofile;

  66.     private static ICC_Profile GRAYprofile;

  67.     private static ICC_Profile LINEAR_RGBprofile;

  68.     private ProfileDeferralInfo deferralInfo;

  69.     private ProfileActivator profileActivator;

  70. 

  71. 

  72.     /**

  73.      * Profile class is input.

  74.      */

  75.     public static final int CLASS_INPUT = 0;

  76. 

  77.     /**

  78.      * Profile class is display.

  79.      */

  80.     public static final int CLASS_DISPLAY = 1;

  81. 

  82.     /**

  83.      * Profile class is output.

  84.      */

  85.     public static final int CLASS_OUTPUT = 2;

  86. 

  87.     /**

  88.      * Profile class is device link.

  89.      */

  90.     public static final int CLASS_DEVICELINK = 3;

  91. 

  92.     /**

  93.      * Profile class is color space conversion.

  94.      */

  95.     public static final int CLASS_COLORSPACECONVERSION = 4;

  96. 

  97.     /**

  98.      * Profile class is abstract.

  99.      */

  100.     public static final int CLASS_ABSTRACT = 5;

  101. 

  102.     /**

  103.      * Profile class is named color.

  104.      */

  105.     public static final int CLASS_NAMEDCOLOR = 6;

  106. 

  107. 

  108.     /**

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

  110.      */

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

  112. 

  113.     /**

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

  115.      */

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

  117. 

  118.     /**

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

  120.      */

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

  122. 

  123.     /**

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

  125.      */

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

  127. 

  128.     /**

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

  130.      */

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

  132. 

  133.     /**

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

  135.      */

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

  137. 

  138.     /**

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

  140.      */

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

  142. 

  143.     /**

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

  145.      */

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

  147. 

  148.     /**

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

  150.      */

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

  152. 

  153.     /**

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

  155.      */

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

  157. 

  158.     /**

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

  160.      */

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

  162. 

  163.     /**

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

  165.      */

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

  167. 

  168.     /**

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

  170.      */

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

  172. 

  173.     /**

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

  175.      */

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

  177. 

  178.     /**

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

  180.      */

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

  182. 

  183.     /**

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

  185.      */

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

  187. 

  188.     /**

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

  190.      */

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

  192. 

  193.     /**

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

  195.      */

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

  197. 

  198.     /**

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

  200.      */

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

  202. 

  203.     /**

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

  205.      */

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

  207. 

  208.     /**

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

  210.      */

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

  212. 

  213.     /**

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

  215.      */

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

  217. 

  218.     /**

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

  220.      */

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

  222. 

  223.     /**

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

  225.      */

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

  227. 

  228.     /**

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

  230.      */

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

  232. 

  233. 

  234.     /**

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

  236.      */

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

  238. 

  239.     /**

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

  241.      */

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

  243. 

  244.     /**

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

  246.      */

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

  248. 

  249.     /**

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

  251.      */

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

  253. 

  254.     /**

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

  256.      */

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

  258. 

  259.     /**

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

  261.      */

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

  263. 

  264.     /**

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

  266.      */

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

  268. 

  269. 

  270.     /**

  271.      * ICC Profile Rendering Intent: Perceptual.

  272.      */

  273.     public static final int icPerceptual            = 0;

  274. 

  275.     /**

  276.      * ICC Profile Rendering Intent: RelativeColorimetric.

  277.      */

  278.     public static final int icRelativeColorimetric    = 1;

  279. 

  280.     /**

  281.      * ICC Profile Rendering Intent: Saturation.

  282.      */

  283.     public static final int icSaturation            = 2;

  284. 

  285.     /**

  286.      * ICC Profile Rendering Intent: AbsoluteColorimetric.

  287.      */

  288.     public static final int icAbsoluteColorimetric    = 3;

  289. 

  290. 

  291. 

  292.     /**

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

  294.      */

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

  296. 

  297.     /**

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

  299.      */

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

  301. 

  302.     /**

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

  304.      */

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

  306. 

  307.     /**

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

  309.      */

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

  311. 

  312.     /**

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

  314.      */

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

  316. 

  317.     /**

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

  319.      */

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

  321. 

  322.     /**

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

  324.      */

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

  326. 

  327.     /**

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

  329.      */

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

  331. 

  332.     /**

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

  334.      */

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

  336. 

  337.     /**

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

  339.      */

  340.     public static final int icSigCalibrationDateTimeTag = 0x63616C74;

  341.                                                                    /* 'calt' */

  342. 

  343.     /**

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

  345.      */

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

  347. 

  348.     /**

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

  350.      */

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

  352. 

  353.     /**

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

  355.      */

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

  357. 

  358.     /**

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

  360.      */

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

  362. 

  363.     /**

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

  365.      */

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

  367. 

  368.     /**

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

  370.      */

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

  372. 

  373.     /**

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

  375.      */

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

  377. 

  378.     /**

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

  380.      */

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

  382. 

  383.     /**

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

  385.      */

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

  387. 

  388.     /**

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

  390.      */

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

  392. 

  393.     /**

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

  395.      */

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

  397. 

  398.     /**

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

  400.      */

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

  402. 

  403.     /**

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

  405.      */

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

  407. 

  408.     /**

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

  410.      */

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

  412. 

  413.     /**

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

  415.      */

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

  417. 

  418.     /**

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

  420.      */

  421.     public static final int icSigProfileDescriptionTag = 0x64657363;

  422.                                                                    /* 'desc' */

  423. 

  424.     /**

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

  426.      */

  427.     public static final int icSigProfileSequenceDescTag = 0x70736571;

  428.                                                                    /* 'pseq' */

  429. 

  430.     /**

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

  432.      */

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

  434. 

  435.     /**

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

  437.      */

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

  439. 

  440.     /**

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

  442.      */

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

  444. 

  445.     /**

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

  447.      */

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

  449. 

  450.     /**

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

  452.      */

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

  454. 

  455.     /**

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

  457.      */

  458.     public static final int icSigPs2RenderingIntentTag = 0x70733269;

  459.                                                                    /* 'ps2i' */

  460. 

  461.     /**

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

  463.      */

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

  465. 

  466.     /**

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

  468.      */

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

  470. 

  471.     /**

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

  473.      */

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

  475. 

  476.     /**

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

  478.      */

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

  480. 

  481.     /**

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

  483.      */

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

  485. 

  486.     /**

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

  488.      */

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

  490. 

  491.     /**

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

  493.      */

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

  495. 

  496.     /**

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

  498.      */

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

  500. 

  501.     /**

  502.      * ICC Profile Tag Signature: 'nc12'.

  503.      */

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

  505. 

  506. 

  507.     /**

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

  509.      */

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

  511. 

  512.     /**

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

  514.      */

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

  516. 

  517.     /**

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

  519.      */

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

  521. 

  522.     /**

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

  524.      */

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

  526. 

  527.     /**

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

  529.      */

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

  531. 

  532.     /**

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

  534.      */

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

  536. 

  537.     /**

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

  539.      */

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

  541. 

  542.     /**

  543.      * ICC Profile Header Location: icMagicNumber.

  544.      */

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

  546. 

  547.     /**

  548.      * ICC Profile Header Location: primary platform.

  549.      */

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

  551. 

  552.     /**

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

  554.      */

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

  556. 

  557.     /**

  558.      * ICC Profile Header Location: device manufacturer.

  559.      */

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

  561. 

  562.     /**

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

  564.      */

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

  566. 

  567.     /**

  568.      * ICC Profile Header Location: device attributes.

  569.      */

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

  571. 

  572.     /**

  573.      * ICC Profile Header Location: rendering intent.

  574.      */

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

  576. 

  577.     /**

  578.      * ICC Profile Header Location: profile illuminant.

  579.      */

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

  581. 

  582.     /**

  583.      * ICC Profile Header Location: profile creator.

  584.      */

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

  586. 

  587. 

  588.     /**

  589.      * ICC Profile Constant: tag type signaturE.

  590.      */

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

  592. 

  593.     /**

  594.      * ICC Profile Constant: reserved.

  595.      */

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

  597. 

  598.     /**

  599.      * ICC Profile Constant: curveType count.

  600.      */

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

  602. 

  603.     /**

  604.      * ICC Profile Constant: curveType data.

  605.      */

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

  607. 

  608.     /**

  609.      * ICC Profile Constant: XYZNumber X.

  610.      */

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

  612. 

  613. 

  614.     /**

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

  616.      */

  617.     ICC_Profile(long ID) {

  618.         this.ID = ID;

  619.     }

  620. 

  621. 

  622.     /**

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

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

  625.      */

  626.     ICC_Profile(ProfileDeferralInfo pdi) {

  627.         this.deferralInfo = pdi;

  628.         this.profileActivator = new ProfileActivator() {

  629.             public void activate() {

  630.                 activateDeferredProfile();

  631.             }

  632.         };

  633.         ProfileDeferralMgr.registerDeferral(this.profileActivator);

  634.     }

  635. 

  636. 

  637.     /**

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

  639.      */

  640.     protected void finalize () {

  641.         if (ID != 0) {

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

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

  644.             ProfileDeferralMgr.unregisterDeferral(profileActivator);

  645.         }

  646.     }

  647. 

  648. 

  649.     /**

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

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

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

  653.      */

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

  655.     ICC_Profile thisProfile;

  656. 

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

  658. 

  659.         if (ProfileDeferralMgr.deferring) {

  660.             ProfileDeferralMgr.activateProfiles();

  661.         }

  662.         

  663.         try {

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

  665.         } catch (CMMException c) {

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

  667.         }

  668. 

  669.         try {

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

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

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

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

  674.             }

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

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

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

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

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

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

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

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

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

  684.             }

  685.             else {

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

  687.             }

  688.         } catch (CMMException c) {

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

  690.         }

  691.         return thisProfile;

  692.     }

  693. 

  694. 

  695. 

  696.     /**

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

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

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

  700.      * defined color spaces.

  701.      */

  702.     public static ICC_Profile getInstance (int cspace)

  703.     {

  704.     ICC_Profile thisProfile = null;

  705.     String fileName;

  706. 

  707.         try {

  708.             switch (cspace) {

  709.             case ColorSpace.CS_sRGB:

  710.                 if (sRGBprofile == null) {

  711.                     sRGBprofile = getDeferredInstance(

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

  713.                                                 3, CLASS_DISPLAY)); 

  714.                 }

  715.                 thisProfile = sRGBprofile;

  716. 

  717.                 break;

  718. 

  719.             case ColorSpace.CS_CIEXYZ:

  720.                 if (XYZprofile == null) {

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

  722.                 }

  723.                 thisProfile = XYZprofile;

  724. 

  725.                 break;

  726. 

  727.             case ColorSpace.CS_PYCC:

  728.                 if (PYCCprofile == null) {

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

  730.                 }

  731.                 thisProfile = PYCCprofile;

  732. 

  733.                 break;

  734. 

  735.             case ColorSpace.CS_GRAY:

  736.                 if (GRAYprofile == null) {

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

  738.                 }

  739.                 thisProfile = GRAYprofile;

  740. 

  741.                 break;

  742. 

  743.             case ColorSpace.CS_LINEAR_RGB:

  744.                 if (LINEAR_RGBprofile == null) {

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

  746.                 }

  747.                 thisProfile = LINEAR_RGBprofile;

  748. 

  749.                 break;

  750. 

  751.             default:

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

  753.             }

  754.         } catch (IOException e) {

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

  756.         }

  757. 

  758.         return thisProfile;

  759.     }

  760. 

  761. 

  762.     /**

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

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

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

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

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

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

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

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

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

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

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

  774.      * Profile data.

  775.      */

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

  777.     ICC_Profile thisProfile;

  778.     FileInputStream fis;

  779. 

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

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

  782.         }

  783. 

  784.         thisProfile = getInstance(fis);

  785. 

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

  787.     

  788.         return thisProfile;

  789.     }

  790. 

  791. 

  792.     /**

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

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

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

  796.      * error occurs while reading the stream.

  797.      */

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

  799.     byte profileData[];

  800. 

  801.         if (s instanceof ProfileDeferralInfo) {

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

  803.             return getDeferredInstance((ProfileDeferralInfo) s);

  804.         }

  805. 

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

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

  808.         }

  809. 

  810.         return getInstance(profileData);

  811.     }

  812. 

  813. 

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

  815.     byte profileData[];

  816.     int profileSize;

  817. 

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

  819.         int bytestoread = 128;

  820.         int bytesread = 0;

  821.         int n;

  822. 

  823.         while (bytestoread != 0) {

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

  825.                 return null;

  826.             }

  827.             bytesread += n;

  828.             bytestoread -= n;

  829.         }

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

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

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

  833.         }

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

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

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

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

  838.         profileData = new byte[profileSize];

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

  840.         bytestoread = profileSize - 128;

  841.         bytesread = 128;

  842.         while (bytestoread != 0) {

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

  844.                 return null;

  845.             }

  846.             bytesread += n;

  847.             bytestoread -= n;

  848.         }

  849. 

  850.         return profileData;

  851.     }

  852. 

  853. 

  854.     /**

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

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

  857.      * be deferred as long as possible.

  858.      */

  859.     static ICC_Profile getDeferredInstance(ProfileDeferralInfo pdi)

  860.         throws IOException {

  861. 

  862.         if (!ProfileDeferralMgr.deferring) {

  863.             return getInstance(pdi.filename);

  864.         }

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

  866.             return new ICC_ProfileRGB(pdi);

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

  868.             return new ICC_ProfileGray(pdi);

  869.         } else {

  870.             return new ICC_Profile(pdi);

  871.         }

  872.     }

  873. 

  874. 

  875.     void activateDeferredProfile() {

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

  877.     byte profileData[];

  878.     FileInputStream fis;

  879.     String fileName = deferralInfo.filename;

  880. 

  881.         profileActivator = null;

  882.         deferralInfo = null;

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

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

  885.         }

  886.         try {

  887.             profileData = getProfileDataFromStream(fis);

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

  889.         }

  890.         catch (IOException e) {

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

  892.                 fileName);

  893.         }

  894.         if (profileData == null) {

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

  896.                 fileName);

  897.         }

  898.         try {

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

  900.         } catch (CMMException c) {

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

  902.                 fileName);

  903.         }

  904.         ID = theID[0];

  905.     }

  906. 

  907. 

  908.     /**

  909.      * Returns profile major version.

  910.      */

  911.     public int getMajorVersion() {

  912.     byte[] theHeader;

  913.     

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

  915.                                            profiles if necessary */

  916. 

  917.         return (int) theHeader[8];

  918.     }

  919. 

  920.     /**

  921.      * Returns profile minor version.

  922.      */

  923.     public int getMinorVersion() {

  924.     byte[] theHeader;

  925.     

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

  927.                                            profiles if necessary */

  928. 

  929.         return (int) theHeader[9];

  930.     }

  931. 

  932.     /**

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

  934.      * class constants.

  935.      */

  936.     public int getProfileClass() {

  937.     byte[] theHeader;

  938.     int theClassSig, theClass;

  939.     

  940.         if (deferralInfo != null) {

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

  942.                                                  ICC_ColorSpace without

  943.                                                  causing a deferred profile

  944.                                                  to be loaded */

  945.         }

  946. 

  947.         theHeader = getData(icSigHead);

  948. 

  949.         theClassSig = intFromBigEndian (theHeader, icHdrDeviceClass);

  950.                 

  951.         switch (theClassSig) {

  952.         case icSigInputClass:

  953.             theClass = CLASS_INPUT;

  954.             break;

  955. 

  956.         case icSigDisplayClass:

  957.             theClass = CLASS_DISPLAY;

  958.             break;

  959. 

  960.         case icSigOutputClass:

  961.             theClass = CLASS_OUTPUT;

  962.             break;

  963. 

  964.         case icSigLinkClass:

  965.             theClass = CLASS_DEVICELINK;

  966.             break;

  967. 

  968.         case icSigColorSpaceClass:

  969.             theClass = CLASS_COLORSPACECONVERSION;

  970.             break;

  971. 

  972.         case icSigAbstractClass:

  973.             theClass = CLASS_ABSTRACT;

  974.             break;

  975. 

  976.         case icSigNamedColorClass:

  977.             theClass = CLASS_NAMEDCOLOR;

  978.             break;

  979. 

  980.         default:

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

  982.         }

  983.         

  984.         return theClass;

  985.     }

  986. 

  987.     /**

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

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

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

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

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

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

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

  995.      * primaries.

  996.      */

  997.     public int getColorSpaceType() {

  998.         if (deferralInfo != null) {

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

  1000.                                                    ICC_ColorSpace without

  1001.                                                    causing a deferred profile

  1002.                                                    to be loaded */

  1003.         }

  1004.         return    getColorSpaceType(ID);

  1005.     }

  1006.     

  1007.     static int getColorSpaceType(long profileID) {

  1008.     byte[] theHeader;

  1009.     int theColorSpaceSig, theColorSpace;

  1010.     

  1011.         theHeader = getData(profileID, icSigHead);

  1012.         theColorSpaceSig = intFromBigEndian(theHeader, icHdrColorSpace);

  1013.         theColorSpace = iccCStoJCS (theColorSpaceSig);

  1014.         return theColorSpace;

  1015.     }

  1016. 

  1017.     /**

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

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

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

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

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

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

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

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

  1026.      */

  1027.     public int getPCSType() {

  1028.         if (ProfileDeferralMgr.deferring) {

  1029.             ProfileDeferralMgr.activateProfiles();

  1030.         }

  1031.         return getPCSType(ID);

  1032.     }

  1033.     

  1034.     

  1035.     static int getPCSType(long profileID) {

  1036.     byte[] theHeader;

  1037.     int thePCSSig, thePCS;

  1038.     

  1039.         theHeader = getData(profileID, icSigHead);

  1040.         thePCSSig = intFromBigEndian(theHeader, icHdrPcs);

  1041.         thePCS = iccCStoJCS(thePCSSig);

  1042.         return thePCS;

  1043.     }

  1044. 

  1045. 

  1046.     /**

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

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

  1049.      * writing the file.

  1050.      */

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

  1052.     FileOutputStream outputFile;

  1053.     byte profileData[];

  1054. 

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

  1056.                                     profiles if necessary */

  1057.         outputFile = new FileOutputStream(fileName);

  1058.         outputFile.write(profileData);

  1059.         outputFile.close ();

  1060.     }

  1061. 

  1062. 

  1063.     /**

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

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

  1066.      */

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

  1068.     byte profileData[];

  1069. 

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

  1071.                                     profiles if necessary */

  1072.         s.write(profileData);

  1073.     }

  1074. 

  1075. 

  1076.     /**

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

  1078.      */

  1079.     public byte[] getData() {

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

  1081.     byte[] profileData;

  1082. 

  1083.         if (ProfileDeferralMgr.deferring) {

  1084.             ProfileDeferralMgr.activateProfiles();

  1085.         }

  1086. 

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

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

  1089. 

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

  1091. 

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

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

  1094. 

  1095.         return profileData;

  1096.     }

  1097. 

  1098. 

  1099.     /**

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

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

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

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

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

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

  1106.      */

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

  1108. 

  1109.         if (ProfileDeferralMgr.deferring) {

  1110.             ProfileDeferralMgr.activateProfiles();

  1111.         }

  1112. 

  1113.         return getData(ID, tagSignature);

  1114.     }

  1115.     

  1116. 

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

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

  1119.     byte[] tagData;

  1120. 

  1121. 	try {

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

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

  1124.                                               tagSize));

  1125. 

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

  1127. 

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

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

  1130.                                               tagData));

  1131. 	} catch(CMMException c) {

  1132. 	    tagData = null;

  1133. 	}

  1134. 

  1135.         return tagData;

  1136.     }

  1137. 

  1138.     /**

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

  1140.      * a byte array.  This method is useful

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

  1142.      * profile data directly.

  1143.      */

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

  1145. 

  1146.         if (ProfileDeferralMgr.deferring) {

  1147.             ProfileDeferralMgr.activateProfiles();

  1148.         }

  1149. 

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

  1151.     }

  1152. 

  1153.     /**

  1154.      * Sets the rendering intent of the profile.

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

  1156.      * has multiple transforms.

  1157.      */

  1158.     void setRenderingIntent(int renderingIntent) {

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

  1160.                                                  profiles if necessary */

  1161.         intToBigEndian (renderingIntent, theHeader, icHdrRenderingIntent);

  1162.                                                  /* set the rendering intent */

  1163.         setData (icSigHead, theHeader);

  1164.     }

  1165. 

  1166. 

  1167.     /**

  1168.      * Returns the rendering intent of the profile.

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

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

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

  1172.      */

  1173.     int getRenderingIntent() {

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

  1175.                                                  profiles if necessary */

  1176.         

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

  1178.                                                  /* set the rendering intent */

  1179.         return renderingIntent;

  1180.     }

  1181. 

  1182. 

  1183.     /**

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

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

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

  1187.      */

  1188.     public int getNumComponents() {

  1189.     byte[]    theHeader;

  1190.     int    theColorSpaceSig, theNumComponents;

  1191.     

  1192.         if (deferralInfo != null) {

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

  1194.                                                   ICC_ColorSpace without

  1195.                                                   causing a deferred profile

  1196.                                                   to be loaded */

  1197.         }

  1198.         theHeader = getData(icSigHead);

  1199. 

  1200.         theColorSpaceSig = intFromBigEndian (theHeader, icHdrColorSpace);

  1201. 

  1202.         switch (theColorSpaceSig) {

  1203.         case icSigGrayData:

  1204.             theNumComponents = 1;

  1205.             break;

  1206. 

  1207.         case icSigSpace2CLR:

  1208.             theNumComponents = 2;

  1209.             break;

  1210. 

  1211.         case icSigXYZData:

  1212.         case icSigLabData:

  1213.         case icSigLuvData:

  1214.         case icSigYCbCrData:

  1215.         case icSigYxyData:

  1216.         case icSigRgbData:

  1217.         case icSigHsvData:

  1218.         case icSigHlsData:

  1219.         case icSigCmyData:

  1220.         case icSigSpace3CLR:

  1221.             theNumComponents = 3;

  1222.             break;

  1223. 

  1224.         case icSigCmykData:

  1225.         case icSigSpace4CLR:

  1226.             theNumComponents = 4;

  1227.             break;

  1228. 

  1229.         case icSigSpace5CLR:

  1230.             theNumComponents = 5;

  1231.             break;

  1232. 

  1233.         case icSigSpace6CLR:

  1234.             theNumComponents = 6;

  1235.             break;

  1236. 

  1237.         case icSigSpace7CLR:

  1238.             theNumComponents = 7;

  1239.             break;

  1240. 

  1241.         case icSigSpace8CLR:

  1242.             theNumComponents = 8;

  1243.             break;

  1244. 

  1245.         case icSigSpace9CLR:

  1246.             theNumComponents = 9;

  1247.             break;

  1248. 

  1249.         case icSigSpaceACLR:

  1250.             theNumComponents = 10;

  1251.             break;

  1252. 

  1253.         case icSigSpaceBCLR:

  1254.             theNumComponents = 11;

  1255.             break;

  1256. 

  1257.         case icSigSpaceCCLR:

  1258.             theNumComponents = 12;

  1259.             break;

  1260. 

  1261.         case icSigSpaceDCLR:

  1262.             theNumComponents = 13;

  1263.             break;

  1264. 

  1265.         case icSigSpaceECLR:

  1266.             theNumComponents = 14;

  1267.             break;

  1268. 

  1269.         case icSigSpaceFCLR:

  1270.             theNumComponents = 15;

  1271.             break;

  1272. 

  1273.         default:

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

  1275.         }

  1276.         

  1277.         return theNumComponents;

  1278.     }

  1279. 

  1280. 

  1281.     /**

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

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

  1284.      */

  1285.     float[] getMediaWhitePoint() {

  1286.         return getXYZTag(icSigMediaWhitePointTag);

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

  1288.     }

  1289. 

  1290. 

  1291.     /**

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

  1293.      * components encoded in an XYZType tag.

  1294.      */

  1295.     float[] getXYZTag(int theTagSignature) {

  1296.     byte[] theData;

  1297.     float[] theXYZNumber;

  1298.     int i1, i2, theS15Fixed16;

  1299.     

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

  1301.                                             /* getData will activate deferred

  1302.                                                profiles if necessary */

  1303.         

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

  1305. 

  1306.         /* convert s15Fixed16Number to float */

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

  1308.             theS15Fixed16 = intFromBigEndian(theData, i2);

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

  1310.         }

  1311.         return theXYZNumber;

  1312.     }

  1313. 

  1314. 

  1315.     /**

  1316.      * Returns a gamma value representing a tone reproduction

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

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

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

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

  1321.      * icSigGreenTRCTag, or icSigBlueTRCTag.

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

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

  1324.      *            the TRC as a single gamma value.

  1325.      */

  1326.     float getGamma(int theTagSignature) {

  1327.     byte[] theTRCData;

  1328.     float theGamma;

  1329.     int theU8Fixed8;

  1330. 

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

  1332.                                                /* getData will activate deferred

  1333.                                                   profiles if necessary */

  1334.         

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

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

  1337.         }

  1338. 

  1339.         /* convert u8Fixed8 to float */

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

  1341.             

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

  1343.         

  1344.         return theGamma;

  1345.     }

  1346. 

  1347. 

  1348.     /**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1363.      * icSigGreenTRCTag, or icSigBlueTRCTag.

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

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

  1366.      *            the TRC as a table.

  1367.      */

  1368.     short[] getTRC(int theTagSignature) {

  1369.     byte[] theTRCData;

  1370.     short[] theTRC;

  1371.     int i1, i2, nElements, theU8Fixed8;

  1372. 

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

  1374.                                                /* getData will activate deferred

  1375.                                                   profiles if necessary */

  1376.         

  1377.         nElements = intFromBigEndian(theTRCData, icCurveCount);

  1378. 

  1379.         if (nElements == 1) {

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

  1381.         }

  1382. 

  1383.         /* make the short array */

  1384.         theTRC = new short [nElements];

  1385. 

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

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

  1388.         }

  1389.         

  1390.         return theTRC;

  1391.     }

  1392. 

  1393. 

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

  1395.     static int iccCStoJCS(int theColorSpaceSig) {

  1396.     int theColorSpace;

  1397. 

  1398.         switch (theColorSpaceSig) {

  1399.         case icSigXYZData:

  1400.             theColorSpace = ColorSpace.TYPE_XYZ;

  1401.             break;

  1402. 

  1403.         case icSigLabData:

  1404.             theColorSpace = ColorSpace.TYPE_Lab;

  1405.             break;

  1406. 

  1407.         case icSigLuvData:

  1408.             theColorSpace = ColorSpace.TYPE_Luv;

  1409.             break;

  1410. 

  1411.         case icSigYCbCrData:

  1412.             theColorSpace = ColorSpace.TYPE_YCbCr;

  1413.             break;

  1414. 

  1415.         case icSigYxyData:

  1416.             theColorSpace = ColorSpace.TYPE_Yxy;

  1417.             break;

  1418. 

  1419.         case icSigRgbData:

  1420.             theColorSpace = ColorSpace.TYPE_RGB;

  1421.             break;

  1422. 

  1423.         case icSigGrayData:

  1424.             theColorSpace = ColorSpace.TYPE_GRAY;

  1425.             break;

  1426. 

  1427.         case icSigHsvData:

  1428.             theColorSpace = ColorSpace.TYPE_HSV;

  1429.             break;

  1430. 

  1431.         case icSigHlsData:

  1432.             theColorSpace = ColorSpace.TYPE_HLS;

  1433.             break;

  1434. 

  1435.         case icSigCmykData:

  1436.             theColorSpace = ColorSpace.TYPE_CMYK;

  1437.             break;

  1438. 

  1439.         case icSigCmyData:

  1440.             theColorSpace = ColorSpace.TYPE_CMY;

  1441.             break;

  1442. 

  1443.         case icSigSpace2CLR:

  1444.             theColorSpace = ColorSpace.TYPE_2CLR;

  1445.             break;

  1446. 

  1447.         case icSigSpace3CLR:

  1448.             theColorSpace = ColorSpace.TYPE_3CLR;

  1449.             break;

  1450. 

  1451.         case icSigSpace4CLR:

  1452.             theColorSpace = ColorSpace.TYPE_4CLR;

  1453.             break;

  1454. 

  1455.         case icSigSpace5CLR:

  1456.             theColorSpace = ColorSpace.TYPE_5CLR;

  1457.             break;

  1458. 

  1459.         case icSigSpace6CLR:

  1460.             theColorSpace = ColorSpace.TYPE_6CLR;

  1461.             break;

  1462. 

  1463.         case icSigSpace7CLR:

  1464.             theColorSpace = ColorSpace.TYPE_7CLR;

  1465.             break;

  1466. 

  1467.         case icSigSpace8CLR:

  1468.             theColorSpace = ColorSpace.TYPE_8CLR;

  1469.             break;

  1470. 

  1471.         case icSigSpace9CLR:

  1472.             theColorSpace = ColorSpace.TYPE_9CLR;

  1473.             break;

  1474. 

  1475.         case icSigSpaceACLR:

  1476.             theColorSpace = ColorSpace.TYPE_ACLR;

  1477.             break;

  1478. 

  1479.         case icSigSpaceBCLR:

  1480.             theColorSpace = ColorSpace.TYPE_BCLR;

  1481.             break;

  1482. 

  1483.         case icSigSpaceCCLR:

  1484.             theColorSpace = ColorSpace.TYPE_CCLR;

  1485.             break;

  1486. 

  1487.         case icSigSpaceDCLR:

  1488.             theColorSpace = ColorSpace.TYPE_DCLR;

  1489.             break;

  1490. 

  1491.         case icSigSpaceECLR:

  1492.             theColorSpace = ColorSpace.TYPE_ECLR;

  1493.             break;

  1494. 

  1495.         case icSigSpaceFCLR:

  1496.             theColorSpace = ColorSpace.TYPE_FCLR;

  1497.             break;

  1498. 

  1499.         default:

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

  1501.         }

  1502.         

  1503.         return theColorSpace;

  1504.     }

  1505.     

  1506.     

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

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

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

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

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

  1512.     }

  1513.     

  1514.     

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

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

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

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

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

  1520.     }

  1521.     

  1522.     

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

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

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

  1526.     }

  1527.     

  1528.     

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

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

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

  1532.     }

  1533. 

  1534. 

  1535.     /*

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

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

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

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

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

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

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

  1543.      */

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

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

  1546. 	    new java.security.PrivilegedAction() {

  1547. 	    public Object run() {

  1548. 		return privilegedOpenProfile(fileName);

  1549. 	    }

  1550. 	});

  1551.     }

  1552. 

  1553.     /*

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

  1555.      * the whole method is privileged!

  1556.      */

  1557.     private static FileInputStream privilegedOpenProfile(String fileName) {

  1558.         FileInputStream fis = null;

  1559.         String path, dir, fullPath;

  1560. 

  1561. 	    try {

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

  1563. 	    }

  1564. 	    catch (FileNotFoundException e) {

  1565. 	    }

  1566. 

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

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

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

  1570. 	        StringTokenizer st = 

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

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

  1573. 		    dir = st.nextToken();

  1574. 		    try {

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

  1576. 			fis = new FileInputStream(fullPath);

  1577. 		    }

  1578. 		    catch (FileNotFoundException e) {

  1579. 		    }

  1580. 		}

  1581. 	    }

  1582. 

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

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

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

  1586. 	        StringTokenizer st =

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

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

  1589. 		    dir = st.nextToken();

  1590. 		    try {

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

  1592. 			fis = new FileInputStream(fullPath);

  1593. 		    }

  1594. 		    catch (FileNotFoundException e) {

  1595. 		    }

  1596. 		}

  1597. 	    }

  1598. 

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

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

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

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

  1603. 		try {

  1604. 		    fis = new FileInputStream(fullPath);

  1605. 		}

  1606. 		catch (FileNotFoundException e) {

  1607. 		}

  1608. 	    }

  1609.         return fis;

  1610.     }

  1611. 

  1612. }