Initial import of argyll version 1.5.1-8debian/1.5.1-8

8 files changed, 4532 insertions, 0 deletions

diff --git a/link/Jamfile b/link/Jamfile
new file mode 100644
index 0000000..4d4dc24
--- /dev/null
+++ b/link/Jamfile
@@ -0,0 +1,36 @@
+
+# JAM style makefile for collink and friends
+ 
+#PREF_CCFLAGS 	+= $(CCOPTFLAG) ;		# Turn optimisation on
+PREF_CCFLAGS	    += $(CCDEBUGFLAG) ;		# Debugging flags
+#PREF_CCFLAGS 	+= $(CCPROFFLAG) ;		# Profile flags
+#PREF_LINKFLAGS	+= $(LINKPROFFLAG) ;    # Profile flags
+#PREF_CCFLAGS	+= $(CCHEAPDEBUG) ;		# Heap Debugging flags
+PREF_LINKFLAGS	+= $(LINKDEBUGFLAG) ;	# Link debugging flags
+
+#Products
+Executables = collink ;
+
+#Install
+InstallBin $(DESTDIR)$(PREFIX)/bin : $(Executables) ;
+
+HDRS = ../h ../icc ../rspl ../plot ../numlib $(TIFFINC) ;
+LINKLIBS = $(TIFFLIB) $(JPEGLIB) ../icc/libicc ../plot/libplot ../numlib/libnum $(LibWin) ;
+
+# K only reprocessor
+#Main icc2ko : icc2ko.c ;
+
+# Monochrome transfer curve plotter
+Main monoplot : monoplot.c ;
+
+HDRS += ../cgats ../xicc ../spectro ../gamut ; 
+LINKLIBS = ../xicc/libxicc ../xicc/libxcolorants ../gamut/libgamut.c
+           ../gamut/libgammap ../rspl/librspl ../cgats/libcgats
+           ../plot/libvrml $(LINKLIBS) ;
+
+# ICC linker
+Main collink : collink.c ;
+
+# Device path L curve plotter
+Main pathplot : pathplot.c ;
+
diff --git a/link/License.txt b/link/License.txt
new file mode 100644
index 0000000..a871fcf
--- /dev/null
+++ b/link/License.txt
@@ -0,0 +1,662 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.
+
diff --git a/link/Makefile.am b/link/Makefile.am
new file mode 100644
index 0000000..37a3ac9
--- /dev/null
+++ b/link/Makefile.am
@@ -0,0 +1,11 @@
+include $(top_srcdir)/Makefile.shared
+
+LDADD = ../spectro/libinsttypes.la ../xicc/libxicc.la			\
+	../xicc/libxutils.la ../gamut/libgamut.la			\
+	../gamut/libgammap.la ../plot/libplot.la ../plot/libvrml.la	\
+	../rspl/librspl.la $(ICC_LIBS) ../cgats/libcgats.la		\
+	../numlib/libargyllnum.la ../libargyll.la $(X_LIBS) $(TIFF_LIBS)
+
+bin_PROGRAMS = collink pathplot
+
+EXTRA_DIST = License.txt Readme.txt
diff --git a/link/Readme.txt b/link/Readme.txt
new file mode 100644
index 0000000..9e8dacc
--- /dev/null
+++ b/link/Readme.txt
@@ -0,0 +1,6 @@
+This direcory holds the top level icc link code.
+
+collink.exe	takes two device ICC profiles, and links
+			then together in a simple fashion, producing
+			a device link ICC profile.
+
diff --git a/link/afiles b/link/afiles
new file mode 100644
index 0000000..7c73bd7
--- /dev/null
+++ b/link/afiles
@@ -0,0 +1,7 @@
+Readme.txt
+License.txt
+afiles
+Jamfile
+collink.c
+monoplot.c
+pathplot.c
diff --git a/link/collink.c b/link/collink.c
new file mode 100644
index 0000000..6c40efd
--- /dev/null
+++ b/link/collink.c
@@ -0,0 +1,3298 @@
+
+/* 
+ * collink
+ *
+ * Link two device profiles to create a Device Link Profile
+ *
+ * Author:  Graeme W. Gill
+ * Date:    25/11/00
+ * Version: 2.10
+ *
+ * Copyright 2000 - 2005 Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
+ * see the License.txt file for licencing details.
+ */
+
+/* TTBD:
+ *
+ * Device curve resolution should be taken from the device profiles,
+ * rather than depending on the quality settings (scRGB compression curves)
+ *
+ * Abstract link support intent doesn't work properly for anything
+ * other than absolute. This should really be fixed.
+ */
+
+/* NOTES:
+
+	Normally the device side per channel curves are copied from
+	the source profiles to the link profile on the assumption that
+	the raw linearisation they do is good, and should be maintained
+	for best overall transform accuracy. Since the intermediate
+	link is done in an Lab like space, then this linearisation
+	will even out quantisation error introduced by the Lut
+	in perceptual space. In the case of a Matrix profile with a native
+	XYZ PCS, these assumptions break, since the device curves
+	would generally be linearising the device to Y, not a perceptual
+	space. For this reason we add a Y to L* type curve to the input
+	linearisation curves. For XYZ CLUT based profiles, we just have
+	to hope that the profile has been created well, and that the
+	input curves distribute the indexes reasonably perceptually
+	evenly. For an output (XYZ) Matrix profile, we also
+	use an L* style mixing space.  
+
+	In general the per channel curves should be:
+
+	  No curve, or
+
+	  An optimized curve, or
+
+      The source profile per channel curve plus
+	  a Y to L* curve it's a Matrix profile.
+
+
+	Colorspace representations are a bit of a mess. It's hard to know what space
+	color is in at any point, and difficult to transform to match
+	some other element. Putting the different colorspace support within
+	the profile transforms is neat, but may not be flexible enough, since the
+	needed information to do a transform (white point, viewing conditions)
+	might be a bit too closely bound into the profile. An alternative might be
+	to expand the colorspace definition from a tag to include all the
+	other needed information, and create a general colorspace adapter
+	to transform from one to the other, or to limit connections
+	to a cannonical spaces such as XYZ.
+	One big cause of confusion for user and implimentor is how to
+	handle the conflicting intents. What does it mean to link
+	a relative source to absolute abstract to CAM destination ???
+
+	A non-absolute abstract profile is poorly defined (just like
+	the device profiles) if it doesn't define the viewing conditions
+	within which the transform is defined. 
+
+	Having separated creating a gamut surface for a raster out
+	(for better modularity), it then creates problems in applying
+	an abstact transform. The abstract transform can't really be
+	applied to a gamut surface, it really needs to be applied
+	to the image data before gamut surface extraction. This is yet
+	another avenue for user & implementor confusion, with regard
+	to intents, even without allowing the user to set the intent
+	of the abstract profile.
+
+ */
+
+#undef USE_MERGE_CLUT_OPT	/* [Undef] When using inverse A2B table, merge the output luts */
+							/* with the clut for faster operation, and clipping in */
+							/* Jab space. Turned off because it affects the accuracy too much, */
+							/* and xicc handles Jab clip without this now. */
+
+#define USE_CAM_CLIP_OPT	/* [Define] Clip out of gamut in CAM space rather than XYZ or L*a*b* */
+#define ENKHACK				/* [Define] Enable K hack code */
+#undef WARN_CLUT_CLIPPING	/* [Undef] Print warning if setting clut clips */
+
+#undef DEBUG		/* Report values of each sample transformed */
+#undef DEBUGC 		/* ie "if (tt)" */		/* Debug condition */
+#undef DEBUG_ONE	/* test a single value out. Look for DBGNO to set value. */
+#undef NEUTKDEBUG	/* print info about neutral L -> K mapping */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <string.h>
+#include <math.h>
+#include "copyright.h"
+#include "aconfig.h"
+#include "numlib.h"
+#include "icc.h"
+#include "xicc.h"
+#include "gamut.h"
+#include "gammap.h"
+// ~~~99
+#include "vrml.h"
+
+void usage(char *diag, ...) {
+	int i;
+	fprintf(stderr,"Link ICC profiles, Version %s\n",ARGYLL_VERSION_STR);
+	fprintf(stderr,"Author: Graeme W. Gill, licensed under the AGPL Version 3\n");
+	if (diag != NULL) {
+		va_list args;
+		fprintf(stderr,"  Diagnostic: ");
+		va_start(args, diag);
+		vfprintf(stderr, diag, args);
+		va_end(args);
+		fprintf(stderr,"\n");
+	}
+	fprintf(stderr,"usage: collink [options] srcprofile dstprofile linkedprofile\n");
+	fprintf(stderr," -v              Verbose\n");
+	fprintf(stderr," -A manufacturer Manufacturer description string\n");
+	fprintf(stderr," -M model        Model description string\n");
+	fprintf(stderr," -D description  Profile Description string (Default \"inoutfile\")\n");
+	fprintf(stderr," -C copyright    Copyright string\n");
+	fprintf(stderr," -V              Verify existing profile, rather than link\n");
+	fprintf(stderr," -q lmhu         Quality - Low, Medium (def), High, Ultra\n");
+//	fprintf(stderr," -q fmsu         Speed - Fast, Medium (def), Slow, Ultra Slow\n");
+	fprintf(stderr," -r res          Override clut res. set by -q\n");
+	fprintf(stderr," -n              Don't preserve device linearization curves in result\n");
+	fprintf(stderr," -f              Special :- Force neutral colors to be K only output\n");
+	fprintf(stderr," -fk             Special :- Force K only neutral colors to be K only output\n");
+	fprintf(stderr," -F              Special :- Force all colors to be K only output\n");
+	fprintf(stderr," -fcmy           Special :- Force 100%% C,M or Y only to stay pure \n");
+	fprintf(stderr," -p absprof      Include abstract profile in link\n");
+	fprintf(stderr," -s              Simple Mode (default)\n");
+	fprintf(stderr," -g [src.gam]    Gamut Mapping Mode [optional source image gamut]\n");
+	fprintf(stderr," -G [src.gam]    Gamut Mapping Mode using inverse outprofile A2B\n");
+	fprintf(stderr," Simple Mode Options:\n");
+	fprintf(stderr," -i in_intent    p = perceptual, r = relative colorimetric,\n");
+	fprintf(stderr,"                 s = saturation, a = absolute colorimetric\n");
+	fprintf(stderr," -o out_intent   p = perceptual, r = relative colorimetric,\n");
+	fprintf(stderr,"                 s = saturation, a = absolute colorimetric\n");
+	fprintf(stderr," Gamut Mapping   Mode Options:\n");
+	fprintf(stderr," -i intent       set linking intent from the following choice:\n");
+	for (i = 0; ; i++) {
+		icxGMappingIntent gmi;
+		if (xicc_enum_gmapintent(&gmi, i, NULL) == icxIllegalGMIntent)
+			break;
+
+		fprintf(stderr,"              %s\n",gmi.desc);
+	}
+	fprintf(stderr," -w [J,a,b]      Use forced whitepoint hack [optional target point]\n");
+//	fprintf(stderr," -W J,a,b        Forced whitepoint adjustment by delta Jab\n");
+	fprintf(stderr," -c viewcond     set source viewing conditions for %s,\n",icxcam_description(cam_default));
+	fprintf(stderr,"                 either an enumerated choice, or a parameter\n");
+	fprintf(stderr," -d viewcond     set destination viewing conditions for %s,\n",icxcam_description(cam_default));
+	fprintf(stderr,"                 either an enumerated choice, or parameter:value changes\n");
+	for (i = 0; ; i++) {
+		icxViewCond vc;
+		if (xicc_enum_viewcond(NULL, &vc, i, NULL, 1, NULL) == -999)
+			break;
+
+		fprintf(stderr,"            %s\n",vc.desc);
+	}
+	fprintf(stderr,"         s:surround    n = auto, a = average, m = dim, d = dark,\n");
+	fprintf(stderr,"                       c = transparency (default average)\n");
+	fprintf(stderr,"         w:X:Y:Z       Adapted white point as XYZ (default media white)\n");
+	fprintf(stderr,"         w:x:y         Adapted white point as x, y\n");
+	fprintf(stderr,"         a:adaptation  Adaptation luminance in cd.m^2 (default 50.0)\n");
+	fprintf(stderr,"         b:background  Background %% of image luminance (default 20)\n");
+	fprintf(stderr,"         l:scenewhite  Scene white in cd.m^2 if surround = auto (default 250)\n");
+	fprintf(stderr,"         f:flare       Flare light %% of image luminance (default 1)\n");
+	fprintf(stderr,"         f:X:Y:Z       Flare color as XYZ (default media white)\n");
+	fprintf(stderr,"         f:x:y         Flare color as x, y\n");
+	fprintf(stderr," -t tlimit       set source total ink limit, 0 - 400%% (estimate by default)\n");
+	fprintf(stderr," -T klimit       set source black ink limit, 0 - 100%% (estimate by default)\n");
+	fprintf(stderr," Inverse outprofile A2B Options:\n");
+	fprintf(stderr," -k tezhxr       CMYK Black generation\n");
+	fprintf(stderr,"                 t = transfer K from source to destination, e = retain K of destination B2A table\n");
+	fprintf(stderr,"                 z = zero K, h = 0.5 K, x = maximum K, r = ramp K (default)\n");
+	fprintf(stderr," -k p stle stpo enpo enle shape\n");
+	fprintf(stderr,"                 p = black target generation curve parameters\n");
+	fprintf(stderr," -k q stle0 stpo0 enpo0 enle0 shape0 stle2 stpo2 enpo2 enle2 shape2\n");
+	fprintf(stderr,"                 q = transfer source K to dual curve limits\n");
+	fprintf(stderr," -K parameters   Same as -k, but target is K locus rather than K value itself\n");
+	fprintf(stderr," -l tlimit       set destination total ink limit, 0 - 400%% (estimate by default)\n");
+	fprintf(stderr," -L klimit       set destination black ink limit, 0 - 100%% (estimate by default)\n");
+	fprintf(stderr," -P              Create gamut gammap.wrl diagostic\n");
+	exit(1);
+}
+
+/* ------------------------------------------- */
+/* structures to support icc calbacks */
+
+/* Information needed from a profile */
+struct _profinfo {
+	/* Setup parameters */
+	icRenderingIntent intent;	/* Selected ICC rendering intent */
+	icxViewCond vc;				/* Viewing Condition for CAM */
+	int inking;					/* k inking algorithm, 0 = input, 1 = min, */
+								/* 2 = 0.5, 3 = max, 4 = ramp, 5 = curve, 6 = dual curve */
+								/* 7 = outpupt profile K value */
+	int locus;					/* 0 = K target value, 1 = K locus value */
+	icxInk ink;					/* Ink parameters */
+
+	/* Operational parameters */
+	icc *c;
+	icmHeader *h;
+	xicc *x;
+	icxLuBase *luo;				/* Base XLookup type object */
+	icmLuAlgType alg;			/* Type of lookup algorithm */
+	icColorSpaceSignature csp;	/* Colorspace */
+	int chan;					/* Channels */
+	int nocurve;				/* NZ to not use device curve in per channel curve */
+	int lcurve;					/* 1 to apply a Y like to L* curve for XYZ Matrix profiles */
+								/* 2 to apply a Y to L* curve for XYZ space */
+	double wp[3];				/* Lab/Jab white point for profile used by wphack & xyzscale */
+	icxLuBase *b2aluo;			/* B2A lookup for inking == 7 */
+}; typedef struct _profinfo profinfo;
+
+/* Structure that holds all the color lookup information */
+struct _clink {
+	/* Overall options */
+	int verb;
+	int gamdiag;	/* nz, create gammap.wrl diagnostic */
+	int total, count, last;	/* Progress count information */
+	int mode;		/* 0 = simple mode, 1 = mapping mode, 2 = mapping mode with inverse A2B */
+	int quality;	/* 0 = low, 1 = medium, 2 = high, 3 = ultra */
+	int clutres;	/* 0 = quality default, !0 = override, then actual during link */
+	int src_kbp;	/* nz = Use K only black point as src gamut black point */
+	int dst_kbp;	/* nz = Use K only black point as dst gamut black point */
+	int dst_cmymap;	/* masks C = 1, M = 2, Y = 4 to force 100% cusp map */
+
+	icColorSpaceSignature pcsor;	/* PCS to use between in & out profiles */
+
+	int nhack;		/* 0 = off, 1 = hack to map input neutrals to output K only, */
+					/* 2 = map 000K to output K only, 3 = all to K */
+	int cmyhack;	/* CMY 100% colorant map though hack, 1 = C, 2 = M, 4 = Y */
+	rspl *pcs2k;	/* PCS L to K' lookup for nhack */
+	int wphack;		/* 0 = off, 1 = hack to map input wp to output wp, 2 = to hwp[] */
+	double hwp[3];	/* hack destination white point in PCS space */
+	int wphacked;	/* Operation flag, set nz if white point was translated */
+	int rel_oride;	/* Relative override flag */
+
+	icmFile *abs_fp;	/* Abstract profile transform */
+	icRenderingIntent abs_intent;
+	icc *abs_icc;
+	xicc *abs_xicc;
+	icxLuBase *abs_luo;	/* NULL if none */
+
+					/* (We current assume that xyzscale can't be used with gmi) */
+	double xyzscale;	/* < 1.0 if Y is to be scaled in destination XYZ space */
+	double swxyz[3];	/* Source white point in XYZ */
+
+	icxGMappingIntent gmi;
+	gammap *map;	/* Gamut mapping */
+	gammap *Kmap;	/* Gamut mapping K in to K out nhack == 2 and K in to K out */
+	
+
+	/* Per profile setup information */
+	profinfo in;
+	profinfo out;
+
+}; typedef struct _clink clink;
+
+
+/* ------------------------------------------- */
+//#define YSCALE 1.0
+#define YSCALE (2.0/1.3)
+
+/* Extra non-linearity applied to BtoA XYZ PCS */
+/* This distributes the LUT indexes more evenly in */
+/* perceptual space, greatly improving the B2A accuracy of XYZ LUT */
+/* Since typically XYZ doesn't use the full range of 0-2.0 allowed */
+/* for in the encoding, we scale the cLUT index values to use the 0-1.3 range */
+
+/* (For these functions the encoded XYZ 0.0 - 2.0 range is 0.0 - 1.0 ??) */
+
+/* Y to L* */
+static void y2l_curve(double *out, double *in, int isXYZ) {
+	int i;
+	double val;
+	double isc = 1.0, osc = 1.0;
+
+	/* Scale from 0.0 .. 1.999969 to 0.0 .. 1.0 and back */
+	/* + range adjustment */
+	if (isXYZ) {
+		isc = 32768.0/65535.0 * YSCALE;
+		osc = 65535.0/32768.0;
+	}
+
+	for (i = 0; i < 3; i++) {
+		val = in[i] * isc;
+		if (val > 0.008856451586)
+			val = 1.16 * pow(val,1.0/3.0) - 0.16;
+		else
+			val = 9.032962896 * val;
+		if (val > 1.0)
+			val = 1.0;
+		out[i] = val * osc;
+	}
+}
+
+/* L* to Y */
+static void l2y_curve(double *out, double *in, int isXYZ) {
+	int i;
+	double val;
+	double isc = 1.0, osc = 1.0;
+
+	/* Scale from 0.0 .. 1.999969 to 0.0 .. 1.0 and back */
+	/* + range adjustment */
+	if (isXYZ) {
+		isc = 32768.0/65535.0;
+		osc = 65535.0/32768.0 / YSCALE;
+	}
+
+	/* Use an L* like curve, scaled to the maximum XYZ value */
+	for (i = 0; i < 3; i++) {
+		val = in[i] * isc;
+		if (val > 0.08)
+			val = pow((val + 0.16)/1.16, 3.0);
+		else
+			val = val/9.032962896;
+		out[i] = val * osc;
+	}
+}
+
+/* ------------------------------------------- */
+/* Functions called back in setting up the transform table */
+
+#ifdef DEBUGC
+
+static int tt = 0;
+
+#endif	/* DEBUGC */
+
+/* Input table, DevIn -> DevIn' */
+void devi_devip(void *cntx, double *out, double *in) {
+	int rv = 0;
+	clink *p = (clink *)cntx;
+
+#ifdef DEBUGC
+	if (in[0] == 1.0 && in[1] == 1.0 && in[2] == 1.0 && in[3])
+		tt = 1;
+#endif
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevIn->DevIn' got %f %f %f %f\n",in[0], in[1], in[2], in[3]); fflush(stdout);
+#endif
+
+	if (p->in.nocurve) {	/* Don't use profile per channel curves */
+		int i;
+		for (i = 0; i < p->in.chan; i++)
+			out[i] = in[i];
+	} else {				/* Use input profile per channel curves */
+		switch(p->in.alg) {
+		    case icmMonoFwdType: {
+				icxLuMono *lu = (icxLuMono *)p->in.luo;	/* Safe to coerce */
+				rv |= lu->fwd_curve(lu, out, in);
+				break;
+			}
+		    case icmMatrixFwdType: {
+				icxLuMatrix *lu = (icxLuMatrix *)p->in.luo;	/* Safe to coerce */
+				rv |= lu->fwd_curve(lu, out, in);
+				break;
+			}
+		    case icmLutType: {
+				icxLuLut *lu = (icxLuLut *)p->in.luo;	/* Safe to coerce */
+				/* Since not PCS, in_abs and matrix cannot be valid, */
+				/* so input curve on own is ok to use. */
+				rv |= lu->input(lu, out, in);
+				break;
+			}
+			default:
+				error("Unexpected algorithm type %d in devi_devip()",p->in.alg);
+		}
+		if (rv >= 2)
+			error("icc lookup failed: %d, %s",p->in.c->errc,p->in.c->err);
+	}
+
+	if (p->in.lcurve) { 		/* Apply Y to L* */
+//printf("~1 y2l_curve got %f %f %f, isXYZ %d\n",in[0],in[1],in[2],p->in.lcurve == 2);
+		y2l_curve(out, out, p->in.lcurve == 2);
+	}
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevIn->DevIn' ret %f %f %f %f\n",out[0], out[1], out[2], in[3]); fflush(stdout);
+#endif
+}
+
+
+/* - - - - - - - - - - - - */
+/* clut, DevIn' -> DevOut' */
+void devip_devop(void *cntx, double *out, double *in) {
+	double win[MAX_CHAN];			/* working input values */
+	double pcsv[MAX_CHAN];			/* PCS intermediate value, pre-gamut map */
+	double pcsvm[MAX_CHAN];			/* PCS intermediate value, post-gamut map */
+	double locus[MAX_CHAN];			/* Auxiliary locus values */
+	int wptrig = 0;				/* White point hack triggered */
+	double konlyness = 0.0;		/* Degree of K onlyness */
+	int ntrig = 0;				/* K only output hack triggered */
+	int cmytrig = 0;			/* CMY output hack triggered */
+	int i, rv = 0;
+	clink *p = (clink *)cntx;
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevIn'->DevOut' got %f %f %f %f\n",in[0], in[1], in[2], in[3]); fflush(stdout);
+#endif
+
+#ifdef ENKHACK
+	/* Handle neutral recognition/output K only hack */
+	/* (see discussion at top of file for generalization of this idea) */
+	if (p->nhack == 1 || p->nhack == 2) {
+		double thr = (0.5)/(p->clutres-1.0); /* Match threshold */
+
+		if (p->nhack == 1) {
+			/* We want to see if the input colors are equal (Or a=b= 0.0 ??) */
+			/* li.nhack should have set p->in.nocurve, so we should be getting raw */
+			/* input space device values here. It also made sure that there are at */
+			/* least 3 input channels. */
+
+		    if (fabs(in[0] - in[1]) < thr
+		     && fabs(in[1] - in[2]) < thr
+		     && fabs(in[2] - in[0]) < thr)
+				ntrig = 1;			/* K only output triggered flag */
+
+		} else if (p->nhack == 2) {
+			double maxcmy;		/* Comute a degree of source "K onlyness" */
+			double maxcmyk;
+
+			maxcmy = in[0];			/* Compute minimum of CMY */
+			if (in[1] > maxcmy)
+				maxcmy = in[1];
+			if (in[2] > maxcmy)
+				maxcmy = in[2];
+
+			maxcmyk = maxcmy;		/* Compute minimum of all inks */
+			if (in[3] > maxcmyk)
+				maxcmyk = in[3];
+
+//printf("~1 maxcmy = %f, maxcmyk = %f, in[3] = %f\n",maxcmy,maxcmyk,in[3]);
+			if (in[3] <= 0.0 || maxcmy > in[3]) {
+				konlyness = 0.0;
+			} else {
+				konlyness = (in[3] - maxcmy)/in[3];	
+			}
+
+			/* As we approach no colorant, blend towards no Konlyness */
+			if (maxcmyk < 0.2)
+				konlyness *= maxcmyk/0.2;
+
+			/* We want to see if the input colors are exactly K only. */
+		    if (in[0] < thr
+		     && in[1] < thr
+		     && in[2] < thr)
+				ntrig = 1;			/* K only output triggered flag */
+#ifdef DEBUG
+#ifdef DEBUGC
+			DEBUGC
+#endif
+			printf("konlyness set to %f\n",konlyness);
+#endif
+
+		}
+	}
+	/* Handle 100% CMY hack */
+	if (p->cmyhack != 0) {
+		double thr = (0.5)/(p->clutres-1.0); /* Match threshold */
+
+		if (p->cmyhack & 1) {
+		    if (in[0] > (1.0 - thr)
+		     && in[1] < thr
+		     && in[2] < thr
+		     && (p->in.chan < 4 || in[3] < thr))
+				cmytrig |= 1;
+		}
+		if (p->cmyhack & 2) {
+		    if (in[0] < thr
+		     && in[1] > (1.0 - thr)
+		     && in[2] < thr
+		     && (p->in.chan < 4 || in[3] < thr))
+				cmytrig |= 2;
+		}
+		if (p->cmyhack & 4) {
+		    if (in[0] < thr
+		     && in[1] < thr
+		     && in[2] > (1.0 - thr)
+		     && (p->in.chan < 4 || in[3] < thr))
+				cmytrig |= 4;
+		}
+	}
+#endif /* ENKHACK */
+
+	if (p->in.lcurve) {	/* Apply L* to Y */
+		l2y_curve(win, in, p->in.lcurve == 2);
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("win[] set to L* value %f %f %f %f\n",win[0], win[1], win[2], win[3]); fflush(stdout);
+#endif
+
+	} else {
+		for (i = 0; i < p->in.chan; i++)
+			win[i] = in[i];
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("win[] set to in[] value %f %f %f %f\n",win[0], win[1], win[2], win[3]); fflush(stdout);
+#endif
+	}
+
+	/* Do DevIn' -> PCS */
+	switch(p->in.alg) {
+	    case icmMonoFwdType: {
+			icxLuMono *lu = (icxLuMono *)p->in.luo;	/* Safe to coerce */
+
+			if (p->in.nocurve) {	/* No explicit curve, so do implicit here */
+				rv |= lu->fwd_curve(lu, pcsv, win);
+				rv |= lu->fwd_map(lu, pcsv, pcsv);
+			} else {
+				rv |= lu->fwd_map(lu, pcsv, win);
+			}
+			rv |= lu->fwd_abs(lu, pcsv, pcsv);
+			break;
+		}
+	    case icmMatrixFwdType: {
+			icxLuMatrix *lu = (icxLuMatrix *)p->in.luo;	/* Safe to coerce */
+
+			if (p->in.nocurve) {	/* No explicit curve, so do implicit here */
+				rv |= lu->fwd_curve(lu, pcsv, win);
+				rv |= lu->fwd_matrix(lu, pcsv, pcsv);
+			} else {
+				rv |= lu->fwd_matrix(lu, pcsv, win);
+			}
+			rv |= lu->fwd_abs(lu, pcsv, pcsv);
+			break;
+		}
+	    case icmLutType: {
+			icxLuLut *lu = (icxLuLut *)p->in.luo;	/* Safe to coerce */
+			if (p->in.nocurve) {	/* No explicit curve, so we've got Dev */
+				/* Since not PCS, in_abs and matrix cannot be valid, */
+				/* so input curve on own is ok to use. */
+				rv |= lu->input(lu, pcsv, win);		/* Dev  -> Dev' */
+				rv |= lu->clut(lu, pcsv, pcsv);		/* Dev' -> PCS' */
+			} else {	/* We've got Dev' */
+				rv |= lu->clut(lu, pcsv, win);		/* Dev' -> PCS' */
+			}
+			/* We've got the input profile PCS' at this point. */
+
+			/* If we're transfering the K value from the input profile to the */
+			/* output, copy it into locus[], which will be given to the inverse */
+			/* lookup function, else the inverse lookup will generate a K using */
+			/* the curve parameters. */  
+//printf("~1 out.inking = %d\n",p->out.inking);
+			if (p->out.inking == 0 || p->out.inking == 6) {
+				if (p->out.locus) {
+					/* Converts PCS' to K locus proportion */
+					lu->clut_locus(lu, locus, pcsv, win);	/* Compute possible locus values */
+//printf("~1 looked up locus value\n");
+				} else {
+					for (i = 0; i < p->in.chan; i++)		/* Target is K input value */
+						locus[i] = win[i];
+					/* Convert K' to K value ready for aux target */
+					if (!p->in.nocurve) {	/* we have an input curve, so convert Dev' -> Dev */
+						lu->inv_input(lu, locus, locus);
+					}
+//printf("~1 copied win to locus\n");
+				}
+#ifdef DEBUG
+#ifdef DEBUGC
+				DEBUGC
+#endif
+				printf("Got possible K %s of %f %f %f %f\n",p->out.locus ? "locus" : "value", locus[0],locus[1],locus[2],locus[3]);
+#endif
+			}
+			rv |= lu->output(lu, pcsv, pcsv);	/* PCS' ->     */
+			rv |= lu->out_abs(lu, pcsv, pcsv);	/*         PCS */
+			break;
+		}
+		default:
+			error("Unexpected algorithm type %d in devip of devip_devop()",p->in.alg);
+	}
+
+	/* At this point, the PCS is:
+	 *
+	 *	If not gamut mapped:
+	 *		Lab in the intent selected for the source profile
+	 *	If gamut mapped:
+	 *		either
+	 *			Absolute Lab
+	 *		or
+	 *			Jab derived from absolute XYZ via the in/out viewing conditions
+     *
+     *	and locus[] contains any auxiliar target values if the
+	 *  auxiliary is not being created by a rule applied to the PCS.
+	 */
+
+	/*
+	 * The order to do this intermediate processing is hard to figure out,
+	 * as is the interaction between such elements. How should the
+	 * abstract profile be properly handled ?
+	 * what should we do if the wphack is on and Y scaling is on ?
+	 */
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("PCS before map %f %f %f\n",pcsv[0], pcsv[1], pcsv[2]); fflush(stdout);
+#endif
+
+	if (p->wphack) {
+		int e;
+		double dd = 0.0;
+		for (e = 0; e < 3; e++) {			/* Does this match the input white point ? */
+			double tt;
+			tt = pcsv[e] - p->in.wp[e];
+			dd += tt * tt;
+		}
+		dd = sqrt(dd);
+
+		if (dd < 1.0) {		/* Triggered withing 1 delta E */
+			p->wphacked++;
+			wptrig = 1;
+			if (p->wphack == 2) {
+				for (e = 0; e < 3; e++)		/* Map input white to given white */
+					pcsv[e] = p->hwp[e];
+			} else {
+				for (e = 0; e < 3; e++)		/* Map input white to output white */
+					pcsv[e] = p->out.wp[e];
+			}
+
+#ifndef DEBUG
+			if (p->verb)
+#endif
+			{
+				printf("White point hack mapped %f %f %f to %f %f %f, hit withing %f\n",
+    		    p->in.wp[0],p->in.wp[1],p->in.wp[2],pcsv[0], pcsv[1], pcsv[2],dd);
+				fflush(stdout);
+			}
+		}
+	}
+
+	/* Do luminence scaling if requested */
+	if (wptrig == 0 && p->xyzscale < 1.0) {
+		double xyz[3];
+
+//printf("~1 got xyzscale = %f\n",p->xyzscale);
+//printf("PCS %f %f %f\n",pcsv[0], pcsv[1], pcsv[2]);
+
+		/* Convert our PCS to XYZ */
+		if (p->pcsor == icxSigJabData) {
+			/* We're being bad in delving inside the xluo, but we'll fix it latter */
+			p->out.luo->cam->cam_to_XYZ(p->out.luo->cam, xyz, pcsv);
+		} else
+			error("Internal :- not setup to handle Y scaling and non-Jab PCS");
+
+//printf("XYZ %f %f %f\n",xyz[0], xyz[1], xyz[2]);
+		/* Scale it */
+		xyz[0] *= p->xyzscale;
+		xyz[1] *= p->xyzscale;
+		xyz[2] *= p->xyzscale;
+
+//printf("scaled XYZ %f %f %f\n",xyz[0], xyz[1], xyz[2]);
+		/* Convert back to PCS */
+		if (p->pcsor == icxSigJabData) {
+			/* We're being bad in delving inside the xluo, but we'll fix it latter */
+			p->out.luo->cam->XYZ_to_cam(p->out.luo->cam, pcsv, xyz);
+		} else
+			error("Internal :- not setup to handle Y scaling and non-Jab PCS");
+
+//printf("scaled PCS %f %f %f\n",pcsv[0], pcsv[1], pcsv[2]);
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+		printf("PCS after Y scale %f %f %f\n",pcsv[0], pcsv[1], pcsv[2]); fflush(stdout);
+#endif
+	}
+
+
+	/* Do gamut mapping */
+	if (wptrig == 0 && p->mode > 0 && p->gmi.usemap) {
+		/* We've used pcsor to ensure PCS space is appropriate */
+		
+		/* Doing XXXK -> XXXK */
+		if (p->nhack == 2) {
+			/* Ideally we would create a 4D PCSK -> PCSK gamut mapping */
+			/* to smoothly and accurately cope with the changing source */
+			/* and destination gamuts acording to their degree of "K onlyness". */
+			/* In practice we're going to simply interpolated between */
+			/* two extremes: unrestricted gamut and K only black gamut. */
+			double map0[3], map1[3];
+
+			/* Compute blend of normal gamut map and Konly to Konly gamut map */	
+			{
+				p->map->domap(p->map, map0, pcsv);
+				p->Kmap->domap(p->Kmap, map1, pcsv);
+				icmBlend3(pcsvm, map0, map1, konlyness);
+			}
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+			printf("PCS after map0 %f %f %f map1 %f %f %f\n", map0[0], map0[1], map0[2], map1[0], map1[1], map1[2]);
+#endif
+
+		/* Normal gamut mapping */
+		} else {
+			{
+				p->map->domap(p->map, pcsvm, pcsv);
+			}
+		}
+
+
+#ifdef DEBUG
+#ifdef DEBUGC
+		DEBUGC
+#endif
+		printf("PCS after map %f %f %f\n",pcsvm[0], pcsvm[1], pcsvm[2]); fflush(stdout);
+#endif
+	} else {
+		pcsvm[0] = pcsv[0];
+		pcsvm[1] = pcsv[1];
+		pcsvm[2] = pcsv[2];
+	}
+
+	/* Gamut mapped PCS value is now in pcsvm[] */
+
+	/* Abstract profile transform, PCS -> PCS */
+	/* pcsor -> abstract -> pcsor conversion */
+	/* We're applying any abstract profile after gamut mapping, */
+	/* on the assumption is is primarily being used to "correct" the */
+	/* output device. Ideally the gamut mapping should take the change */
+	/* the abstract profile has on the output device into account, but */
+	/* currently we're not doing this.. */
+	if (wptrig == 0 && p->abs_luo != NULL) {
+		/* Abstract profile is either absolute or relative.  */
+		/* We need to convert the current PCS into something compatible. */
+		/* This is more ugly than it really should be, so we're ignoring it. */
+		/* We should really run the source through the abstract profile before */
+		/* creating the gamut mapping, to be able to use abstract with gamut */
+		/* mapping properly. */
+		p->abs_luo->lookup(p->abs_luo, pcsvm, pcsvm);
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+		printf("PCS after abstract %f %f %f\n",pcsvm[0], pcsvm[1], pcsvm[2]); fflush(stdout);
+#endif
+	}
+
+	/* If we're using the existing B2A inking to determine K, */
+	/* lookup the output profiles K value for this PCS */
+	if (p->mode >= 2 && p->out.inking == 7) {
+		double tdevv[MAX_CHAN];	
+
+//printf("~1 dealing with out.inking = %d\n",p->out.inking);
+		if (p->out.alg != icmLutType || p->out.c->header->colorSpace != icSigCmykData)
+			error ("Attempting to use non-CMYK output profile to determine K inking");
+
+		/* Lookup PCS in B2A of output profile to get target K value */  
+//printf("~1 looking up pcs %f %f %f in B2A\n", pcsvm[0], pcsvm[1], pcsvm[2]);
+		p->out.b2aluo->lookup(p->out.b2aluo, tdevv, pcsvm);
+//printf("~1 resulting dev %f %f %f %f\n", tdevv[0], tdevv[1], tdevv[2], tdevv[3]);
+
+		if (p->out.locus) {
+			double tpcsv[MAX_CHAN];	
+			icxLuLut *lu = (icxLuLut *)p->out.luo;		/* Safe to coerce */
+
+			/* Convert PCS to PCS' ready for locus lookup */
+			lu->in_abs(lu, tpcsv, pcsvm);
+			lu->matrix(lu, tpcsv, tpcsv);
+			lu->input(lu, tpcsv, tpcsv);
+			lu->clut_locus(lu, locus, tpcsv, tdevv);	/* Compute locus values */
+		} else {
+			for (i = 0; i < p->out.chan; i++)		/* Target is K value */
+				locus[i] = tdevv[i];
+		}
+#ifdef DEBUG
+#ifdef DEBUGC
+		DEBUGC
+#endif
+		printf("Got possible K %s of %f %f %f %f\n",p->out.locus ? "locus" : "value", locus[0],locus[1],locus[2],locus[3]);
+#endif
+	}
+
+	/* Do PCS -> DevOut' */
+	if (p->nhack == 3		/* All to K only */
+	 || ntrig	 			/* Neutral or K only to K only hack has triggered */
+	 || cmytrig) {			/* 100% CMY rough hack has triggered */
+
+		if (p->nhack == 3 || ntrig) { /* Neutral to K only hack has triggered */
+			co pp;
+			pp.p[0] = pcsvm[0];					/* Input L value */
+			p->pcs2k->interp(p->pcs2k, &pp);	/* L -> K' */
+			if (pp.v[0] < 0.0)		/* rspl might have extrapolated */
+				pp.v[0] = 0.0;
+			else if (pp.v[0] > 1.0)
+				pp.v[0] = 1.0;
+			out[0] = out[1] = out[2] = 0.0;		/* We know output is CMYK' */
+			out[3] = pp.v[0];
+
+#ifndef DEBUG
+			if (p->verb)
+#endif
+			if (ntrig) {
+				printf("Neutral hack mapped %s to 0 0 0 %f\n", icmPdv(p->in.chan,win), out[3]); 
+				fflush(stdout);
+			}
+		} else if (cmytrig) { /* 100% CMY rough hack has triggered */
+			if (cmytrig & 1) {
+				out[0] = 1.0;
+				out[1] = out[2] = out[3] = 0.0;
+			}
+			if (cmytrig & 2) {
+				out[1] = 1.0;
+				out[0] = out[2] = out[3] = 0.0;
+			}
+			if (cmytrig & 4) {
+				out[2] = 1.0;
+				out[0] = out[1] = out[3] = 0.0;
+			}
+
+#ifndef DEBUG
+			if (p->verb)
+#endif
+			if (cmytrig != 0) {
+				if (p->in.chan == 4) 
+					printf("CMY hack mapped %s to %s\n",icmPdv(p->in.chan, win), icmPdv(p->out.chan, out));
+				fflush(stdout);
+			}
+		}
+	} else {	/* Neutral to K hack has NOT triggered */
+		switch(p->out.alg) {
+		    case icmMonoBwdType: {
+				icxLuMono *lu = (icxLuMono *)p->out.luo;	/* Safe to coerce */
+
+				rv |= lu->bwd_abs(lu, pcsvm, pcsvm);
+				rv |= lu->bwd_map(lu, out, pcsvm);
+				if (p->out.nocurve) {	/* No explicit curve, so do implicit here */
+					rv |= lu->bwd_curve(lu, out, out);
+				}
+				break;
+			}
+		    case icmMatrixBwdType: {
+				icxLuMatrix *lu = (icxLuMatrix *)p->out.luo;	/* Safe to coerce */
+
+				rv |= lu->bwd_abs(lu, pcsvm, pcsvm);
+				rv |= lu->bwd_matrix(lu, out, pcsvm);
+				if (p->out.nocurve) {	/* No explicit curve, so do implicit here */
+					rv |= lu->bwd_curve(lu, out, out);
+				}
+				break;
+			}
+		    case icmLutType: {
+				icxLuLut *lu = (icxLuLut *)p->out.luo;	/* Safe to coerce */
+
+				if (p->mode < 2) {	/* Using B2A table */
+					rv |= lu->in_abs(lu, pcsvm, pcsvm);
+					rv |= lu->matrix(lu, pcsvm, pcsvm);
+					rv |= lu->input(lu, pcsvm, pcsvm);
+					rv |= lu->clut(lu, out, pcsvm);
+					if (p->out.nocurve) {	/* No explicit curve, so do implicit here */
+						rv |= lu->output(lu, out, out);
+					}
+
+				} else {	/* Use inverse A2B table */
+					int i;
+#ifdef USE_MERGE_CLUT_OPT
+					/* Because we have used the ICX_MERGE_CLUT flag, we don't need */
+					/* to call inv_out_abs() and inv_output() */
+#else
+					rv |= lu->inv_out_abs(lu, pcsvm, pcsvm);
+					rv |= lu->inv_output(lu, pcsvm, pcsvm);
+#endif
+
+#ifdef DEBUG
+#ifdef DEBUGC
+					DEBUGC
+#endif
+					printf("Calling inv_clut with K aux targets %f %f %f %f and pcsvm %f %f %f %f\n",
+					locus[0],locus[1],locus[2],locus[3],pcsvm[0],pcsvm[1],pcsvm[2],pcsvm[3]);
+#endif
+
+					/* locus[] contains possible K target or locus value, */
+					/* so copy it to out[] so that inv_clut will use it. */
+					for (i = 0; i < p->out.chan; i++)
+						out[i] = locus[i];
+
+					rv |= lu->inv_clut(lu, out, pcsvm);
+#ifdef DEBUG
+#ifdef DEBUGC
+					DEBUGC
+#endif
+					printf("Got result %f %f %f %f\n", out[0],out[1],out[2],out[3]);
+#endif
+
+					
+					if (p->out.nocurve) {	/* No explicit curve, so do implicit here */
+						rv |= lu->inv_input(lu, out, out);
+					}
+				}
+				break;
+			}
+
+			default:
+				error("Unexpected algorithm type %d in devop of devip_devop()",p->out.alg);
+		}
+		if (rv >= 2)
+			error("icc lookup failed: %d, %s",p->in.c->errc,p->in.c->err);
+	}
+
+	if (p->out.lcurve) 		/* Apply Y to L* */
+		y2l_curve(out, out, p->out.lcurve == 2);
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevIn'->DevOut' ret %f %f %f %f\n\n",out[0], out[1], out[2], out[3]); fflush(stdout);
+#endif
+
+
+	if (p->verb) {		/* Output percent intervals */
+		int pc;
+		p->count++;
+		pc = (int)(p->count * 100.0/p->total + 0.5);
+		if (pc != p->last) {
+			printf("%c%2d%%",cr_char,pc); fflush(stdout);
+			p->last = pc;
+		}
+	}
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Output table, DevOut' -> DevOut */
+void devop_devo(void *cntx, double *out, double *in) {
+	int rv = 0;
+	clink *p = (clink *)cntx;
+	int i;
+
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevOut'->DevOut got %f %f %f %f\n",in[0], in[1], in[2], in[4]); fflush(stdout);
+#endif
+
+	for (i = 0; i < p->out.chan; i++)
+		out[i] = in[i];
+
+	if (p->out.lcurve) 		/* Apply L* to Y */
+		l2y_curve(out, out, p->out.lcurve == 2);
+
+	if (p->out.nocurve == 0) {	/* Using per channel curves */
+
+		switch(p->out.alg) {
+		    case icmMonoBwdType: {
+				icxLuMono *lu = (icxLuMono *)p->out.luo;		/* Safe to coerce */
+				rv |= lu->bwd_curve(lu, out, out);
+				break;
+			}
+		    case icmMatrixBwdType: {
+				icxLuMatrix *lu = (icxLuMatrix *)p->out.luo;	/* Safe to coerce */
+				rv |= lu->bwd_curve(lu, out, out);
+				break;
+			}
+		    case icmLutType: {
+				if (p->mode < 2) {	/* Using B2A table */
+					icxLuLut *lu = (icxLuLut *)p->out.luo;	/* Safe to coerce */
+					rv |= lu->output(lu, out, out);
+					/* Since not PCS, out_abs is never used */
+					break;
+				} else {	/* Use inverse A2B table */
+					icxLuLut *lu = (icxLuLut *)p->out.luo;	/* Safe to coerce */
+					rv |= lu->inv_input(lu, out, out);
+					/* Since not PCS, inv_matrix and inv_in_abs is never used */
+					break;
+				}
+			}
+			default:
+				error("Unexpected algorithm type in devop_devo()");
+		}
+		if (rv >= 2)
+			error("icc lookup failed: %d, %s",p->in.c->errc,p->in.c->err);
+	}
+#ifdef DEBUG
+#ifdef DEBUGC
+	DEBUGC
+#endif
+	printf("DevOut'->DevOut ret %f %f %f %f\n",out[0], out[1], out[2], out[3]); fflush(stdout);
+#endif
+#ifdef DEBUGC
+	tt = 0;
+#endif
+}
+
+/* ------------------------------------------- */
+/* Fixup L -> K only lookup table white and black values, */
+/* to compensate for inexact rspl fitting */
+
+/* Context for fixup */
+typedef struct {
+	double kmax;
+	double kmin;
+} pcs2k_ctx;
+
+/* Function to pass to rspl to re-set output values, */
+/* to make them relative to the white and black points */
+static void
+fix_pcs2k_white(
+	void *pp,			/* relativectx structure */
+	double *out,		/* output value */
+	double *in			/* input value */
+) {
+	double f;
+	pcs2k_ctx *p = (pcs2k_ctx *)pp;
+
+	/* Scale so that kmin->hmax becomes 0 to 1 */
+	f = (out[0] - p->kmin)/(p->kmax - p->kmin);
+
+	out[0] = f;
+}
+
+/* ------------------------------------------- */
+/* powell() callback to set XYZ scaling factor */
+
+static double xyzoptfunc(void *cntx, double *v) {
+	clink *p = (clink *)cntx;
+	double swxyz[3], jab[3], dev[MAX_CHAN];
+	double rv;
+	int rc = 0;
+
+	rv = 2.0 - v[0];	/* Make Y as large as possible */
+
+	/* If we wanted to use this function to maximise the brightness */
+	/* we would not limit the scale to 1.0 */
+	if (v[0] > 1.0) {
+		rv += 1000.0;
+		return rv;
+	}
+	if (v[0] < 0.0) {
+		rv += 100.0;
+		return rv;
+	}
+	swxyz[0] = v[0] * p->swxyz[0];
+	swxyz[1] = v[0] * p->swxyz[1];
+	swxyz[2] = v[0] * p->swxyz[2];
+
+//printf("~1 scaled white XYZ = %f %f %f\n", swxyz[0], swxyz[1], swxyz[2]);
+
+	if (p->pcsor == icxSigJabData) {
+		/* We're being bad in delving inside the xluo, but we'll fix it latter */
+		p->out.luo->cam->XYZ_to_cam(p->out.luo->cam, jab, swxyz);
+	} else
+		error("Internal :- not setup to handle Y scaling and non-Jab PCS");
+
+//printf("~1 scaled white Jab = %f %f %f\n", jab[0], jab[1], jab[2]);
+
+	/* Run the target PCS backwards through the output space to see if it clips */
+	switch(p->out.alg) {
+	    case icmMonoBwdType: {
+			icxLuMono *lu = (icxLuMono *)p->out.luo;	/* Safe to coerce */
+
+			rc = lu->bwd_lookup(p->out.luo, dev, jab);
+			break;
+		}
+	    case icmMatrixBwdType: {
+			icxLuMatrix *lu = (icxLuMatrix *)p->out.luo;	/* Safe to coerce */
+
+			rc = lu->bwd_lookup(p->out.luo, dev, jab);
+			break;
+		}
+	    case icmLutType: {
+			icxLuLut *lu = (icxLuLut *)p->out.luo;	/* Safe to coerce */
+
+			if (p->mode < 2)	/* Using B2A table */
+				rc = lu->lookup(p->out.luo, dev, jab);
+			else				/* Use inverse A2B table */
+				rc = lu->inv_lookup(p->out.luo, dev, jab);
+			break;
+		}
+		default:
+			error("Unexpected algorithm type %d in devop of devip_devop()",p->out.alg);
+	}
+//printf("~1 device = %f %f %f, rc = %d\n", dev[0], dev[1], dev[2], rc);
+	if (rc != 0)
+		rv += 500.0;
+
+//printf("~1 xyzoptfunc rv %f from xyzscale %f\n\n",rv,v[0]);
+	return rv;
+}
+
+/* ------------------------------------------- */
+
+int
+main(int argc, char *argv[]) {
+	int fa, nfa, mfa;				/* argument we're looking at */
+	char in_name[MAXNAMEL+1];
+	char sgam_name[MAXNAMEL+1] = "\000";	/* Source gamut name */
+	char abs_name[MAXNAMEL+1] = "\000";		/* Abstract profile name */
+	char out_name[MAXNAMEL+1];
+	char link_name[MAXNAMEL+1];
+	int verify = 0;				/* Do verify pass */
+	int outinkset = 0;			/* The user specfied an output inking */
+	int intentset = 0;			/* The user specified an intent */
+	int vcset = 0;				/* Viewing conditions were set by user */
+	int modeset = 0;			/* The gamut mapping mode was set by the user */
+	int rv = 0;
+	icxViewCond ivc, ovc;		/* Viewing Condition Overrides for in and out profiles */
+	int ivc_e = -1, ovc_e = -1;	/* Enumerated viewing condition */
+	clink li;					/* Linking information structure */
+	int isJab = 0;				/* (Derived from li.mode & li.gmi) NZ if Jab link space */
+	int in_curve_res = 0;		/* Input profile A2B input curve resolution (if known) */
+	int out_curve_res = 0;		/* Output profile B2A output curve resolution (if known) */
+	profxinf xpi;				/* Extra profile information */
+	int i;
+
+	error_program = argv[0];
+	check_if_not_interactive();
+	memset((void *)&xpi, 0, sizeof(profxinf));	/* Init extra profile info to defaults */
+	memset((void *)&li, 0, sizeof(clink));
+
+	/* Set defaults */
+	li.verb = 0;
+	li.count = 0;
+	li.last = -1;
+	li.mode = 0;						/* Default simple link mode */
+	li.quality = 1;						/* Medium quality */
+	li.clutres = 0;						/* No resolution override */	
+	li.nhack = 0;
+	li.cmyhack = 0;						/* Mask for 100% purity through mapping of CMY */
+	li.pcs2k = NULL;
+	li.wphack = 0;
+	li.wphacked = 0;
+	li.abs_luo = NULL;					/* No abstract */
+	li.xyzscale = 1.0;					/* No XYZ scaling */
+	li.hwp[0] = li.hwp[1] = li.hwp[2] = 0.0;
+	li.map = NULL;
+	li.Kmap = NULL;
+	li.in.intent  = icmDefaultIntent;	/* Default */
+	li.in.ink.tlimit = -1.0;			/* Default no total limit */
+	li.in.ink.klimit = -1.0;			/* Default no black limit */
+	li.in.inking  = 4;					/* Inking algorithm default = ramp */
+	li.in.locus   = 0;					/* Default K value target */
+	li.in.nocurve = 0;					/* Preserve device linearisation curve */
+	li.in.lcurve = 0;					/* Don't apply a Y to L* curve after device curve */
+	li.out.intent = icmDefaultIntent;	/* Default */
+	li.out.ink.tlimit = -1.0;			/* Default no total limit */
+	li.out.ink.klimit = -1.0;			/* Default no black limit */
+	li.out.ink.KonlyLmin = 0;			/* Use normal black Lmin for locus */
+	li.out.ink.c.Ksmth = ICXINKDEFSMTH;	/* default curve smoothing */
+	li.out.ink.c.Kskew = ICXINKDEFSKEW;	/* default curve skew */
+	li.out.ink.x.Ksmth = ICXINKDEFSMTH;
+	li.out.ink.x.Kskew = ICXINKDEFSKEW;
+	li.out.inking  = 4;					/* Default ramp K */
+	li.out.locus   = 0;					/* Default K value target */
+	li.out.nocurve = 0;					/* Preserve device linearisation curve */
+	li.out.lcurve = 0;					/* Don't apply an L* to Y curve before device curve */
+	li.out.b2aluo = NULL;				/* B2A lookup for inking == 7 */
+
+	xicc_enum_gmapintent(&li.gmi, icxDefaultGMIntent, NULL);	/* Set default overall intent */
+
+	/* Init VC overrides so that we know when the've been set */
+	ivc.Ev = -1;
+	ivc.Wxyz[0] = -1.0; ivc.Wxyz[1] = -1.0; ivc.Wxyz[2] = -1.0;
+	ivc.La = -1.0;
+	ivc.Yb = -1.0;
+	ivc.Lv = -1.0;
+	ivc.Yf = -1.0;
+	ivc.Fxyz[0] = -1.0; ivc.Fxyz[1] = -1.0; ivc.Fxyz[2] = -1.0;
+
+	ovc.Ev = -1;
+	ovc.Wxyz[0] = -1.0; ovc.Wxyz[1] = -1.0; ovc.Wxyz[2] = -1.0;
+	ovc.La = -1.0;
+	ovc.Yb = -1.0;
+	ovc.Lv = -1.0;
+	ovc.Yf = -1.0;
+	ovc.Fxyz[0] = -1.0; ovc.Fxyz[1] = -1.0; ovc.Fxyz[2] = -1.0;
+
+	if (argc < 4)
+		usage("Too few arguments, got %d expect at least 3",argc-1);
+
+	/* Process the arguments */
+	mfa = 3;        /* Minimum final arguments */
+	for(fa = 1;fa < argc;fa++) {
+		nfa = fa;					/* skip to nfa if next argument is used */
+
+		if (argv[fa][0] == '-')	{	/* Look for any flags */
+			char *na = NULL;		/* next argument after flag, null if none */
+
+			if (argv[fa][2] != '\000')
+				na = &argv[fa][2];		/* next is directly after flag */
+			else {
+				if ((fa+1+mfa) < argc) {
+					if (argv[fa+1][0] != '-') {
+						nfa = fa + 1;
+						na = argv[nfa];		/* next is seperate non-flag argument */
+					}
+				}
+			}
+
+			if (argv[fa][1] == '?')
+				usage("Requested usage");
+
+			/* Verbosity */
+			else if (argv[fa][1] == 'v') {
+				li.verb = 1;
+			}
+
+			/* Manufacturer description string */
+			else if (argv[fa][1] == 'A') {
+				fa = nfa;
+				if (na == NULL) usage("Expect argument to manufacturer description flag -A");
+				xpi.deviceMfgDesc = na;
+			}
+
+			/* Model description string */
+			else if (argv[fa][1] == 'M') {
+				fa = nfa;
+				if (na == NULL) usage("Expect argument to model description flag -M");
+				xpi.modelDesc = na;
+			}
+
+			/* Profile Description */
+			else if (argv[fa][1] == 'D') {
+				fa = nfa;
+				if (na == NULL) usage("Expect argument to profile description flag -D");
+				xpi.profDesc = na;
+			}
+
+			/* Copyright string */
+			else if (argv[fa][1] == 'C') {
+				fa = nfa;
+				if (na == NULL) usage("Expect argument to copyright flag -C");
+				xpi.copyright = na;
+			}
+
+			/* Verify rather than link */
+			else if (argv[fa][1] == 'V')
+				verify = 1;
+
+			/* Disable profile per channel curve use in device link output */
+			else if (argv[fa][1] == 'n' || argv[fa][1] == 'N') {
+				li.in.nocurve = 1;
+				li.out.nocurve = 1;
+			}
+
+			/* Hack to force input neutrals to K only output */
+			else if (argv[fa][1] == 'f' || argv[fa][1] == 'F') {
+
+				if (argv[fa][1] == 'f') {
+					if (na != NULL) {		/* XXXK -> XXXK hack */
+						int j;
+						fa = nfa;
+						for (j = 0; ; j++) {
+							if (na[j] == '\000')
+								break;
+							if (na[j] == 'k' || na[j] == 'K')
+								li.nhack = 2;
+							else if (na[j] == 'c' || na[j] == 'C')
+								li.cmyhack |= 0x1;
+							else if (na[j] == 'm' || na[j] == 'M')
+								li.cmyhack |= 0x2;
+							else if (na[j] == 'y' || na[j] == 'Y')
+								li.cmyhack |= 0x4;
+							else
+								usage("Unexpected argument '%c' to -f flag",na[j]);
+						}
+
+					} else {				/* Neutral -> 000K hack */
+						li.nhack = 1;
+						li.in.nocurve = 1;	/* Disable input curve to preserve input equality */
+					}
+				} else {
+					li.nhack = 3;			/* All -> 000K Hack */
+				}
+			}
+
+			/* Quality */
+			else if (argv[fa][1] == 'q' || argv[fa][1] == 'Q') {
+				fa = nfa;
+				if (na == NULL) usage("Quality flag (-q) needs an argument");
+    			switch (na[0]) {
+					case 'f':				/* fast */
+					case 'l':
+					case 'L':
+						li.quality = 0;
+						break;
+					case 'm':				/* medium */
+					case 'M':
+						li.quality = 1;
+						break;
+					case 's':				/* slow */
+					case 'h':
+					case 'H':
+						li.quality = 2;
+						break;
+					case 'u':				/* ultra slow */
+					case 'U':
+						li.quality = 3;
+						break;
+					default:
+						usage("Unrecognised quality flag (-q) argument '%c'",na[0]);
+//						usage("Unrecognised speed flag (-q) argument '%c'",na[0]);
+				}
+			}
+
+			/* CLUT resolution override */
+			else if (argv[fa][1] == 'r' || argv[fa][1] == 'R') {
+				int rr;
+				fa = nfa;
+				if (na == NULL) usage("Resolution flag (-r) needs an argument");
+				rr = atoi(na);
+				if (rr < 1 || rr > 255) usage("Resolution flag (-r) argument out of range (%d)",rr);
+				li.clutres = rr;
+			}
+
+			/* Abstract profile */
+			else if (argv[fa][1] == 'p') {
+				if (na == NULL) usage("Expected abstract profile filename after -a");
+				fa = nfa;
+				strncpy(abs_name,na,MAXNAMEL); abs_name[MAXNAMEL] = '\000';
+			}
+
+			/* Simple mode */
+			else if (argv[fa][1] == 's') {
+				li.mode = 0;
+				modeset = 1;
+			}
+
+			/* Maping mode */
+			else if (argv[fa][1] == 'g' || argv[fa][1] == 'G') {
+				li.mode = 1;
+				if (argv[fa][1] == 'G') {
+					li.mode = 2;
+				}
+
+				if (na != NULL) {	/* Found an optional source gamut */
+					fa = nfa;
+					strncpy(sgam_name,na,MAXNAMEL); sgam_name[MAXNAMEL] = '\000';
+				}
+				modeset = 1;
+			}
+
+			/* White point hack */
+			else if (argv[fa][1] == 'w' || argv[fa][1] == 'W') {
+				li.wphack = 1;
+				if (na != NULL) {		// To a particular white point
+					fa = nfa;
+					if (sscanf(na, " %lf , %lf , %lf ",&li.hwp[0], &li.hwp[1], &li.hwp[2]) == 3) {
+						li.wphack = 2;
+					} else
+						usage("Couldn't parse hack white point (-w) value '%s'",na);
+				}
+			}
+			/* Input profile Intent or Mapping mode intent */
+			else if (argv[fa][1] == 'i' || argv[fa][1] == 'I') {
+				fa = nfa;
+				if (na == NULL) usage("Input intent flag (-i) needs an argument");
+				/* Record it for simple mode */
+    			switch (na[0]) {
+					case 'p':
+					case 'P':
+						li.in.intent = icPerceptual;
+						break;
+					case 'r':
+					case 'R':
+						li.in.intent = icRelativeColorimetric;
+						break;
+					case 's':
+					case 'S':
+						li.in.intent = icSaturation;
+						break;
+					case 'a':
+					case 'A':
+						li.in.intent = icAbsoluteColorimetric;
+						break;
+					default:
+						li.in.intent = icMaxEnumIntent;		/* Detect error later */
+				}
+				/* Record it for gamut mapping mode */
+				if (xicc_enum_gmapintent(&li.gmi, icxNoGMIntent, na) == -999)
+					usage("Input intent (-i) argument '%s' isn't recognised",na);
+				intentset = 1;
+			}
+
+			/* Output profile Intent */
+			else if (argv[fa][1] == 'o' || argv[fa][1] == 'O') {
+				fa = nfa;
+				if (na == NULL) usage("Output intent flag (-o) needs an argument");
+    			switch (na[0]) {
+					case 'p':
+					case 'P':
+						li.out.intent = icPerceptual;
+						break;
+					case 'r':
+					case 'R':
+						li.out.intent = icRelativeColorimetric;
+						break;
+					case 's':
+					case 'S':
+						li.out.intent = icSaturation;
+						break;
+					case 'a':
+					case 'A':
+						li.out.intent = icAbsoluteColorimetric;
+						break;
+					default:
+						usage("Output intent (-o) argument '%s' not recognised",na);
+				}
+			}
+			
+			/* Viewing conditions */
+			else if (argv[fa][1] == 'c' || argv[fa][1] == 'C'
+			      || argv[fa][1] == 'd' || argv[fa][1] == 'D') {
+				icxViewCond *vc;
+
+				if (argv[fa][1] == 'c' || argv[fa][1] == 'C') {
+					vc = &ivc;
+				} else {
+					vc = &ovc;
+				}
+
+				fa = nfa;
+				if (na == NULL) usage("Viewing conditions flag (-[cd]) needs an argument");
+#ifdef NEVER
+				if (na[0] >= '0' && na[0] <= '9') {
+					if (vc == &ivc)
+						ivc_e = atoi(na);
+					else
+						ovc_e = atoi(na);
+				} else
+#endif
+				if (na[1] != ':') {
+					/* Enumerated condition index */
+					if (vc == &ivc) {
+						if ((ivc_e = xicc_enum_viewcond(NULL, NULL, -2, na, 1, NULL)) == -999)
+							usage("Unrecognised viewing condition enumeration '%s'",na);
+					} else {
+						if ((ovc_e = xicc_enum_viewcond(NULL, NULL, -2, na, 1, NULL)) == -999)
+							usage("Unrecognised viewing condition enumeration '%s'",na);
+					}
+				} else if (na[0] == 's' || na[0] == 'S') {
+					if (na[1] != ':')
+						usage("Viewing conditions (-[cd]s) missing ':'");
+					if (na[2] == 'n' || na[2] == 'N') {
+						vc->Ev = vc_none;		/* Automatic */
+					} else if (na[2] == 'a' || na[2] == 'A') {
+						vc->Ev = vc_average;
+					} else if (na[2] == 'm' || na[2] == 'M') {
+						vc->Ev = vc_dim;
+					} else if (na[2] == 'd' || na[2] == 'D') {
+						vc->Ev = vc_dark;
+					} else if (na[2] == 'c' || na[2] == 'C') {
+						vc->Ev = vc_cut_sheet;
+					} else
+						usage("Viewing condition (-[cd]) unrecognised surround '%c'",na[2]);
+				} else if (na[0] == 'w' || na[0] == 'W') {
+					double x, y, z;
+					if (sscanf(na+1,":%lf:%lf:%lf",&x,&y,&z) == 3) {
+						vc->Wxyz[0] = x; vc->Wxyz[1] = y; vc->Wxyz[2] = z;
+					} else if (sscanf(na+1,":%lf:%lf",&x,&y) == 2) {
+						vc->Wxyz[0] = x; vc->Wxyz[1] = y;
+					} else
+						usage("Viewing condition (-[cd]w) unrecognised white point '%s'",na+1);
+				} else if (na[0] == 'a' || na[0] == 'A') {
+					if (na[1] != ':')
+						usage("Viewing conditions (-[cd]a) missing ':'");
+					vc->La = atof(na+2);
+				} else if (na[0] == 'b' || na[0] == 'B') {
+					if (na[1] != ':')
+						usage("Viewing conditions (-[cd]b) missing ':'");
+					vc->Yb = atof(na+2)/100.0;
+				} else if (na[0] == 'l' || na[0] == 'L') {
+					if (na[1] != ':')
+						usage("Viewing conditions (-[cd]l) missing ':'");
+					vc->Lv = atof(na+2);
+				} else if (na[0] == 'f' || na[0] == 'F') {
+					double x, y, z;
+					if (sscanf(na+1,":%lf:%lf:%lf",&x,&y,&z) == 3) {
+						vc->Fxyz[0] = x; vc->Fxyz[1] = y; vc->Fxyz[2] = z;
+					} else if (sscanf(na+1,":%lf:%lf",&x,&y) == 2) {
+						vc->Fxyz[0] = x; vc->Fxyz[1] = y;
+					} else if (sscanf(na+1,":%lf",&x) == 1) {
+						vc->Yf = x/100.0;
+					} else
+						usage("Viewing condition (-[cd]f) unrecognised flare '%s'",na+1);
+				} else
+					usage("Viewing condition (-[cd]) unrecognised sub flag '%c'",na[0]);
+				vcset = 1;			/* Viewing conditions were set by user */
+			}
+
+			/* Inking rule */
+			else if (argv[fa][1] == 'k' || argv[fa][1] == 'K') {
+				fa = nfa;
+				if (na == NULL) usage("Inking rule flag (-k) needs an argument");
+				if (argv[fa][1] == 'k')
+					li.out.locus = 0;			/* Use K value target */
+				else
+					li.out.locus = 1;			/* Use K locus target */
+    			switch (na[0]) {
+					case 't':
+					case 'T':
+						li.out.inking = 0;		/* Use input K value for output */
+						break;
+					case 'e':
+					case 'E':
+						li.out.inking = 7;		/* Use output K value as guide */
+						break;
+					case 'z':
+					case 'Z':
+						li.out.inking = 1;		/* Use minimum k */
+						break;
+					case 'h':
+					case 'H':
+						li.out.inking = 2;		/* Use half k */
+						break;
+					case 'x':
+					case 'X':
+						li.out.inking = 3;		/* Use maximum k */
+						break;
+					case 'r':
+					case 'R':
+						li.out.inking = 4;		/* Use ramp k */
+						break;
+					case 'p':
+					case 'P':
+					case 'q':
+					case 'Q':
+						li.out.inking = 5;		/* Use curve parameter */
+
+						++fa;
+						if (fa >= argc) usage("Inking rule (-kp) expects more parameters");
+						li.out.ink.c.Kstle = atof(argv[fa]);
+
+						++fa;
+						if (fa >= argc) usage("Inking rule (-kp) expects more parameters");
+						li.out.ink.c.Kstpo = atof(argv[fa]);
+
+						++fa;
+						if (fa >= argc || argv[fa][0] == '-') usage("Inking rule (-kp) expects more parameters");
+						li.out.ink.c.Kenpo = atof(argv[fa]);
+
+						++fa;
+						if (fa >= argc || argv[fa][0] == '-') usage("Inking rule (-kp) expects more parameters");
+						li.out.ink.c.Kenle = atof(argv[fa]);
+
+						++fa;
+						if (fa >= argc || argv[fa][0] == '-') usage("Inking rule (-kp) expects more parameters");
+						li.out.ink.c.Kshap = atof(argv[fa]);
+
+						if (na[0] == 'q' || na[0] == 'Q') {
+							li.out.inking = 6;		/* Use transfer to dual curve parameter */
+
+							++fa;
+							if (fa >= argc) usage("Inking rule (-kq) expects more parameters");
+							li.out.ink.x.Kstle = atof(argv[fa]);
+	
+							++fa;
+							if (fa >= argc) usage("Inking rule (-kq) expects more parameters");
+							li.out.ink.x.Kstpo = atof(argv[fa]);
+	
+							++fa;
+							if (fa >= argc || argv[fa][0] == '-') usage("Inking rule (-kq) expects more parameters");
+							li.out.ink.x.Kenpo = atof(argv[fa]);
+	
+							++fa;
+							if (fa >= argc) usage("Inking rule (-kq) expects more parameters");
+							li.out.ink.x.Kenle = atof(argv[fa]);
+	
+							++fa;
+							if (fa >= argc || argv[fa][0] == '-') usage("Inking rule (-kq) expects more parameters");
+							li.out.ink.x.Kshap = atof(argv[fa]);
+	
+						}
+						break;
+					default:
+						usage("Inking rule (-k) unknown sub flag '%c'",na[0]);
+				}
+				outinkset = 1;		/* The user set an inking */
+			}
+			/* Input ink limits */
+			else if (argv[fa][1] == 't') {
+				int tlimit;
+				fa = nfa;
+				if (na == NULL) usage("No parameter after flag -t");
+				tlimit = atoi(na);
+				if (tlimit >= 0)
+					li.in.ink.tlimit = tlimit/100.0;
+				else
+					li.in.ink.tlimit = -1.0;
+			}
+			else if (argv[fa][1] == 'T') {
+				int klimit;
+				fa = nfa;
+				if (na == NULL) usage("No parameter after flag -T");
+				klimit = atoi(na);
+				if (klimit >= 0)
+					li.in.ink.klimit = klimit/100.0;
+				else
+					li.in.ink.klimit = -1.0;
+			}
+			/* Output ink limits */
+			else if (argv[fa][1] == 'l') {
+				int tlimit;
+				fa = nfa;
+				if (na == NULL) usage("No parameter after flag -l");
+				tlimit = atoi(na);
+				if (tlimit >= 0)
+					li.out.ink.tlimit = tlimit/100.0;
+				else
+					li.out.ink.tlimit = -1.0;
+				if (li.mode < 2)	/* Set minimum link mode */
+					li.mode = 2;
+			}
+			else if (argv[fa][1] == 'L') {
+				int klimit;
+				fa = nfa;
+				if (na == NULL) usage("No parameter after flag -L");
+				klimit = atoi(na);
+				if (klimit >= 0)
+					li.out.ink.klimit = klimit/100.0;
+				else
+					li.out.ink.klimit = -1.0;
+				if (li.mode < 2)	/* Set minimum link mode */
+					li.mode = 2;
+			}
+
+			/* Gammut mapping diagnostic plots */
+			else if (argv[fa][1] == 'P')
+				li.gamdiag = 1;
+
+			else 
+				usage("Unknown flag '%c'",argv[fa][1]);
+		} else
+			break;
+	}
+
+	if (fa >= argc || argv[fa][0] == '-') usage("Missing input profile");
+	strncpy(in_name,argv[fa++],MAXNAMEL); in_name[MAXNAMEL] = '\000';
+
+	if (fa >= argc || argv[fa][0] == '-') usage("Missing output profile");
+	strncpy(out_name,argv[fa++],MAXNAMEL); out_name[MAXNAMEL] = '\000';
+
+	if (fa >= argc || argv[fa][0] == '-') usage("Missing result profile");
+	strncpy(link_name,argv[fa++],MAXNAMEL); link_name[MAXNAMEL] = '\000';
+
+	if (xpi.profDesc == NULL)
+		xpi.profDesc = link_name;	/* Default description */
+
+	if (li.verb)
+		printf("Got options\n");
+
+	/* - - - - - - - - - - - - - - - - - - - */
+#ifndef ENKHACK				/* Enable K hack code */
+	warning("!!!!!! linkl/collink.c ENKHACK not enabled !!!!!!");
+#endif
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Sanity checking/defaulting of options */
+
+	/* Deal with options that need link mode -g */
+	if (li.mode < 1
+	 && (li.in.intent == icMaxEnumIntent		/* User set a smart linking intent */
+	  || vcset								/* Viewing conditions were set by user */
+	  || li.wphack)) {
+		if (modeset) {
+			if (li.in.intent == icMaxEnumIntent)
+				warning("Complex intent can't work with -s linking mode");
+			else if (vcset)
+				warning("Viewing conditions are ignored with -s linking mode");
+			else if (li.wphack)
+				warning("White point hack is ignored with -s linking mode");
+		} else  {
+			if (li.verb) {
+				if (li.in.intent == icMaxEnumIntent)
+					printf("Setting -g to enable Gamut Mapping mode intent\n");
+				else if (vcset)
+					printf("Setting -g to enable viewing conditions\n");
+				else if (li.wphack)
+					printf("Setting -g to enable white point hack\n");
+			}
+			li.mode = 1;
+		}
+	}
+
+	/* Deal with options that need link mode -G */
+	if (li.mode < 2
+	  && (outinkset						/* The user set a K inking rule */
+	   || li.out.ink.tlimit >= 0.0		/* The user set an output total limit */
+	   || li.out.ink.klimit >= 0.0)) {	/* The user set an output black limit */
+		if (modeset) {
+			if (outinkset)
+				warning("Black inking can't work with -s or -g linking mode");
+			else if (li.out.ink.tlimit >= 0.0 || li.out.ink.klimit >= 0.0)
+				warning("Ink limiting can't work with -s linking mode");
+		} else {
+			if (li.verb) {
+				if (outinkset)
+					printf("Setting -G to enable black inking\n");
+				else if (li.out.ink.tlimit >= 0.0 || li.out.ink.klimit >= 0.0)
+					printf("Setting -G to enable ink limiting\n");
+			}
+			li.mode = 2;
+		}
+	}
+
+	/* Deal with options that complement -f -F */
+	if (li.nhack || li.cmyhack) {
+
+		/* Ideally we need to set K inking and map to K only black point, which require -G mode */
+		if (li.mode < 2) {
+			if (li.nhack == 1) {		/* All neutrals to K only */
+				if (modeset) {
+					warning("-f will give best result with -G mode");
+				} else {
+					if (li.verb)
+						printf("Setting -G mode to complement -f option\n");
+					li.mode = 2;
+				}
+			} else if (li.nhack == 2) {	/* K only in to K only out */
+				if (modeset) {
+					warning("For better results use -G mode with -fk option");
+				} else {
+					if (li.verb)
+						printf("Setting -G mode to complement -fk option\n");
+					li.mode = 2;
+				}
+			} else if (li.nhack == 3) {	/* All to K only out */
+				if (modeset) {
+					warning("For better results use -G mode with -F option");
+				} else {
+					if (li.verb)
+						printf("Setting -G mode to complement -F option\n");
+					li.mode = 2;
+				}
+			}
+			if (li.cmyhack != 0) {	/* Map pure 100% CMY to pure CMY */
+				if (modeset) {
+					warning("For better results use -G mode with -fcmy options");
+				} else {
+					if (li.verb)
+						printf("Setting -G mode to complement -fcmy options\n");
+					li.mode = 2;
+				}
+			}
+		}
+
+		/* Ideally we should use an appropriate K inking */ 
+		if (li.mode >= 2) {											/* Gammut mapping mode */
+			if (li.nhack == 1 && li.out.inking != 3) {		/* All neutrals to K only */
+				if (outinkset) {
+					warning("For better results use -kx with -f option");
+				} else {
+					if (li.verb)
+						printf("Setting -kx to complement -f option\n");
+					li.out.inking = 3;			/* Use maximum K */
+				}
+			} else if (li.nhack == 2 && li.out.inking != 0) {	/* K only in to K only out */
+				if (outinkset) {
+					warning("For better results use -kt with -fk option");
+				} else {
+					if (li.verb)
+						printf("Setting -kt to complement -fk option\n");
+					li.out.inking = 0;		/* Use input K value for output */
+				}
+			} else if (li.nhack == 3 && li.out.inking != 3) {		/* All colors to K only */
+				if (modeset) {
+					warning("For better results use -kx with -F option");
+				} else {
+					if (li.verb)
+						printf("Setting -kx to complement -f option\n");
+					li.out.inking = 3;			/* Use maximum K */
+				}
+			}
+		}
+
+		/* Ideally we should use an appropriate gamut mapping */
+		if (li.mode >= 1) {											/* Gammut mapping mode */
+
+			if (li.gmi.usemap == 0 || li.gmi.greymf < 1.0			/* Not mapping black point */
+		     || li.gmi.glumbcpf < 1.0 || li.gmi.glumbexf < 1.0) {
+				if (li.nhack == 1) {		/* All neutrals to K only */
+					if (intentset) {
+						warning("For better results use an intent that maps black point with -f option");
+					} else {
+						if (li.verb)
+							printf("Setting -ip intent to complement -f option\n");
+						if (xicc_enum_gmapintent(&li.gmi, icxNoGMIntent, "p") == -999)
+							usage("Internal, intent 'p' isn't recognised");
+						li.dst_kbp = 1;				/* Map to K only black point */
+						li.out.ink.KonlyLmin = 1;	/* Use K only black Lmin for locus */
+					}
+				} else if (li.nhack == 3) {	/* All to K only out */
+					if (intentset) {
+						warning("For better results use an intent that maps black point with -F option");
+					} else {
+						if (li.verb)
+							printf("Setting -ip intent to complement -F option\n");
+						if (xicc_enum_gmapintent(&li.gmi, icxNoGMIntent, "p") == -999)
+							usage("Internal, intent 'p' isn't recognised");
+						li.dst_kbp = 1;				/* Map to K only black point */
+						li.out.ink.KonlyLmin = 1;	/* Use K only black Lmin for locus */
+					}
+				}
+
+			/* Got an appropriate intent, so set mapping to K only black point */
+			} else if (li.nhack == 1 || li.nhack == 3) {
+				li.dst_kbp = 1;				/* Map to K only black point */
+				li.out.ink.KonlyLmin = 1;	/* Use K only black Lmin for locus */
+			}
+			if (li.cmyhack != 0) {	/* Map pure 100% CMY to pure CMY */
+				if (intentset) {
+					if (strcmp(li.gmi.as, "s") != 0)
+						warning("For better results use -is with -fcmy options");
+				} else {
+					if (li.verb)
+						printf("Setting -is intent to complement -fcmy options\n");
+					if (xicc_enum_gmapintent(&li.gmi, icxNoGMIntent, "s") == -999)
+						usage("Internal, intent 's' isn't recognised");
+					li.dst_cmymap = li.cmyhack;
+				}
+			}
+		}
+	}
+
+	if (li.mode == 0) {
+		if (li.in.intent == icMaxEnumIntent)
+			usage("Input intent (-i) argument isn't recognised for simple mapping mode");
+	}
+
+	if (li.wphack && (li.gmi.usecas & 0x100) != 0)
+		usage("Can't use 'white point hack' and Luminence scaling intent together");
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Open up the input device profile for reading, and read header etc. */
+	if ((li.in.c = read_embedded_icc(in_name)) == NULL)
+		error ("Can't open file '%s'",in_name);
+	li.in.h = li.in.c->header;
+
+	/* Check that it is a suitable device input icc */
+	if (li.in.h->deviceClass != icSigInputClass
+	 && li.in.h->deviceClass != icSigDisplayClass
+	 && li.in.h->deviceClass != icSigOutputClass
+	 && li.in.h->deviceClass != icSigColorSpaceClass)	/* For sRGB etc. */
+		error("Input profile '%s' isn't a device profile",in_name);
+
+	/* Wrap with an expanded icc */
+	if ((li.in.x = new_xicc(li.in.c)) == NULL)
+		error ("Creation of input profile xicc failed");
+
+	/* Set the default ink limits if not set on command line */
+	icxDefaultLimits(li.in.x, &li.in.ink.tlimit, li.in.ink.tlimit, &li.in.ink.klimit, li.in.ink.klimit);
+
+	if (li.verb) {
+		if (li.in.ink.tlimit >= 0.0)
+			printf("Input total ink limit assumed is %3.0f%%\n",100.0 * li.in.ink.tlimit);
+		if (li.in.ink.klimit >= 0.0)
+			printf("Input black ink limit assumed is %3.0f%%\n",100.0 * li.in.ink.klimit);
+	}
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Open up the abstract profile if requested */
+	if (abs_name[0] != '\000') {
+		if ((li.abs_fp = new_icmFileStd_name(abs_name,"r")) == NULL)
+			error ("Can't open abstract profile file '%s'",abs_name);
+		
+		if ((li.abs_icc = new_icc()) == NULL)
+			error ("Creation of Abstract profile ICC object failed");
+
+		/* Read header etc. */
+		if ((rv = li.abs_icc->read(li.abs_icc,li.abs_fp,0)) != 0)
+			error ("%d, %s",rv,li.abs_icc->err);
+
+		if (li.abs_icc->header->deviceClass != icSigAbstractClass)
+			error("Abstract profile isn't an abstract profile");
+
+		/* Take intended abstract intent from profile itself */
+		if ((li.abs_intent = li.abs_icc->header->renderingIntent) != icAbsoluteColorimetric)
+			li.abs_intent = icRelativeColorimetric;
+
+		/* Wrap with an expanded icc */
+		if ((li.abs_xicc = new_xicc(li.abs_icc)) == NULL)
+			error ("Creation of abstract profile xicc failed");
+	}
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Open up the output device output profile for reading, and read header etc. */
+	if ((li.out.c = read_embedded_icc(out_name)) == NULL)
+		error ("Can't open file '%s'",out_name);
+	li.out.h = li.out.c->header;
+
+	if (li.out.h->deviceClass != icSigInputClass
+	 && li.out.h->deviceClass != icSigDisplayClass
+	 && li.out.h->deviceClass != icSigOutputClass
+	 && li.out.h->deviceClass != icSigColorSpaceClass)	/* For sRGB etc. */
+		error("Output profile isn't a device profile");
+
+	/* Wrap with an expanded icc */
+	if ((li.out.x = new_xicc(li.out.c)) == NULL)
+		error ("Creation of output profile xicc failed");
+
+	/* Set the default ink limits if not set on command line */
+	icxDefaultLimits(li.out.x, &li.out.ink.tlimit, li.out.ink.tlimit, &li.out.ink.klimit, li.out.ink.klimit);
+
+	if (li.verb) {
+		if (li.out.ink.tlimit >= 0.0)
+			printf("Output total ink limit assumed is %3.0f%%\n",100.0 * li.out.ink.tlimit);
+		if (li.out.ink.klimit >= 0.0)
+			printf("Output black ink limit assumed is %3.0f%%\n",100.0 * li.out.ink.klimit);
+	}
+
+	/* deal with output black generation. */
+	/* Ink limits will have been set in option parsing */
+
+	switch (li.out.inking) {
+		case 0:			/* Use input profile K level or locus */
+			/* Sanity check */
+			if (li.in.h->colorSpace != li.out.h->colorSpace)
+				error("Can't transfer black ink in & out unless the same colorspaces");
+			li.out.ink.k_rule = li.out.locus ? icxKlocus : icxKvalue;	/* Given as aux parameter in PCS -> Device */
+			break;
+		case 7:			/* Use output profile K level or locus */
+			li.out.ink.k_rule = li.out.locus ? icxKlocus : icxKvalue;	/* Given as aux parameter in PCS -> Device */
+			break;
+		case 1:			/* Minimum K */
+			li.out.ink.k_rule = li.out.locus ? icxKluma5 : icxKluma5k;
+			li.out.ink.c.Kstle = 0.0;
+			li.out.ink.c.Kstpo = 0.0;
+			li.out.ink.c.Kenpo = 1.0;
+			li.out.ink.c.Kenle = 0.0;
+			li.out.ink.c.Kshap = 1.0;
+			break;
+		case 2:			/* 0.5 K */
+			li.out.ink.k_rule = li.out.locus ? icxKluma5 : icxKluma5k;
+			li.out.ink.c.Kstle = 0.5;
+			li.out.ink.c.Kstpo = 0.0;
+			li.out.ink.c.Kenpo = 1.0;
+			li.out.ink.c.Kenle = 0.5;
+			li.out.ink.c.Kshap = 1.0;
+			break;
+		case 3:			/* Maximum K */
+			li.out.ink.k_rule = li.out.locus ? icxKluma5 : icxKluma5k;
+			li.out.ink.c.Kstle = 1.0;
+			li.out.ink.c.Kstpo = 0.0;
+			li.out.ink.c.Kenpo = 1.0;
+			li.out.ink.c.Kenle = 1.0;
+			li.out.ink.c.Kshap = 1.0;
+			break;
+		case 4:			/* Ramp K */
+			li.out.ink.k_rule = li.out.locus ? icxKluma5 : icxKluma5k;
+			li.out.ink.c.Kstle = 0.0;
+			li.out.ink.c.Kstpo = 0.0;
+			li.out.ink.c.Kenpo = 1.0;
+			li.out.ink.c.Kenle = 1.0;
+			li.out.ink.c.Kshap = 1.0;
+			break;
+		case 5:			/* Curve */
+			li.out.ink.k_rule = li.out.locus ? icxKluma5 : icxKluma5k;
+			break;		/* Other params already set by options */
+		case 6:			/* Use input profile K locus + dual curve limits */
+			/* Sanity check */
+			if (li.in.h->colorSpace != li.out.h->colorSpace)
+				error("Can't transfer black ink in & out unless the same colorspaces");
+			li.out.ink.k_rule = li.out.locus ? icxKl5l : icxKl5lk;	/* Aux param in PCS -> Device */
+			break;		/* Other params already set by options */
+	}
+
+	for (i = 0; i < 2; i++) {
+		xicc *x;
+		icxViewCond *v, *vc;
+		int es;
+
+		if (i == 0) {
+			v = &ivc;			/* Override parameters */
+			vc = &li.in.vc;		/* Target parameters */
+			es = ivc_e;
+			x = li.in.x;		/* xicc */
+		} else {
+			v = &ovc;			/* Override parameters */
+			vc = &li.out.vc;	/* Target parameters */
+			es = ovc_e;
+			x = li.out.x;		/* xicc */
+		}
+		
+		/* Set the default viewing conditions */
+		xicc_enum_viewcond(x, vc, -1, NULL, 0, NULL);
+
+		/* Override the default viewing conditions. */
+		/* (?? Could move this code into xicc_enum_viewcond() as an option ??) */
+		/* First any enumerated selection */
+		if (es != -1) {
+			if (xicc_enum_viewcond(x, vc, es, NULL, 0, NULL) == -999)
+				error ("%d, %s",x->errc, x->err);
+		}
+		/* Then any individual paramaters */
+		if (v->Ev >= 0)
+			vc->Ev = v->Ev;
+		if (v->Wxyz[0] >= 0.0 && v->Wxyz[1] > 0.0 && v->Wxyz[2] >= 0.0) {
+			/* Normalise XYZ to current media white */
+			vc->Wxyz[0] = v->Wxyz[0]/v->Wxyz[1] * vc->Wxyz[1];
+			vc->Wxyz[2] = v->Wxyz[2]/v->Wxyz[1] * vc->Wxyz[1];
+		} 
+		if (v->Wxyz[0] >= 0.0 && v->Wxyz[1] >= 0.0 && v->Wxyz[2] < 0.0) {
+			/* Convert Yxy to XYZ */
+			double x = v->Wxyz[0];
+			double y = v->Wxyz[1];	/* If Y == 1.0, then X+Y+Z = 1/y */
+			double z = 1.0 - x - y;
+			vc->Wxyz[0] = x/y * vc->Wxyz[1];
+			vc->Wxyz[2] = z/y * vc->Wxyz[1];
+		}
+		if (v->La >= 0.0)
+			vc->La = v->La;
+		if (v->Yb >= 0.0)
+			vc->Yb = v->Yb;
+		if (v->Lv >= 0.0)
+			vc->Lv = v->Lv;
+		if (v->Yf >= 0.0)
+			vc->Yf = v->Yf;
+		if (v->Fxyz[0] >= 0.0 && v->Fxyz[1] > 0.0 && v->Fxyz[2] >= 0.0) {
+			/* Normalise XYZ to current media white */
+			vc->Fxyz[0] = v->Fxyz[0]/v->Fxyz[1] * vc->Fxyz[1];
+			vc->Fxyz[2] = v->Fxyz[2]/v->Fxyz[1] * vc->Fxyz[1];
+		}
+		if (v->Fxyz[0] >= 0.0 && v->Fxyz[1] >= 0.0 && v->Fxyz[2] < 0.0) {
+			/* Convert Yxy to XYZ */
+			double x = v->Fxyz[0];
+			double y = v->Fxyz[1];	/* If Y == 1.0, then X+Y+Z = 1/y */
+			double z = 1.0 - x - y;
+			vc->Fxyz[0] = x/y * vc->Fxyz[1];
+			vc->Fxyz[2] = z/y * vc->Fxyz[1];
+		}
+	}
+
+	if (li.verb)
+		printf("Configured options\n");
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Setup the profile color lookup information */
+	{
+		icmLuAlgType oalg;				/* Native output algorithm */
+		icColorSpaceSignature natpcs;	/* Underlying native output PCS */
+		int flb = 0, fl = 0;			/* luobj flags */
+		
+		li.pcsor = icSigLabData;			/* Default use Lab as PCS */
+
+		/* If we are using the gamut map mode, then setup */
+		/* the intents and pcsor appropriately. */
+		if (li.mode > 0) {
+
+			if ((li.gmi.usecas & 0xff) != 0) {
+				li.pcsor = icxSigJabData;		/* Use CAM as PCS */
+				isJab = 1;
+
+				if ((li.gmi.usecas & 0xff) == 0x2) {	/* Absolute Appearance space */
+					double mxw;
+	
+					li.in.intent = li.out.intent = li.abs_intent = icxAbsAppearance;
+
+					/* Make absolute common white point average between the two */
+					li.in.vc.Wxyz[0] = 0.5 * (li.in.vc.Wxyz[0] + li.out.vc.Wxyz[0]);
+					li.in.vc.Wxyz[1] = 0.5 * (li.in.vc.Wxyz[1] + li.out.vc.Wxyz[1]);
+					li.in.vc.Wxyz[2] = 0.5 * (li.in.vc.Wxyz[2] + li.out.vc.Wxyz[2]);
+	
+					/* And scale it Y to be equal to 1.0 */
+					mxw = 1.0/li.in.vc.Wxyz[1];
+					li.in.vc.Wxyz[0] *= mxw;
+					li.in.vc.Wxyz[1] *= mxw;
+					li.in.vc.Wxyz[2] *= mxw;
+	
+					/* Set the output vc to be the same as the input */
+					li.out.vc = li.in.vc;	/* Structure copy */
+				} else {
+					/* Not Abs Appearance space */
+					li.in.intent = li.out.intent = li.abs_intent = icxAppearance;
+				}
+			} else {
+				/* Not Appearance space */
+				li.in.intent = li.out.intent = li.abs_intent = icAbsoluteColorimetric;
+			}
+		}
+
+		if (li.verb)
+			printf("Loading input A2B table\n");
+
+		/* default flags for all xicc luobj's */
+		flb = ICX_CLIP_NEAREST;
+		if (li.verb)
+			flb |= ICX_VERBOSE;
+
+		/* Get an input profile xicc conversion object */
+		fl = flb;
+#ifdef USE_MERGE_CLUT_OPT
+		fl |= ICX_MERGE_CLUT;
+#endif
+
+#ifdef NEVER
+		printf("~1 input space flags = 0x%x\n",fl);
+		printf("~1 input space intent = %s\n",icx2str(icmRenderingIntent,li.in.intent));
+		printf("~1 input space pcs = %s\n",icx2str(icmColorSpaceSignature,li.pcsor));
+		printf("~1 input space viewing conditions =\n"); xicc_dump_viewcond(&li.in.vc);
+		printf("~1 input space inking =\n"); xicc_dump_inking(&li.in.ink);
+#endif
+		if ((li.in.luo = li.in.x->get_luobj(li.in.x, fl, icmFwd, li.in.intent,
+		                                    li.pcsor, icmLuOrdNorm, &li.in.vc, &li.in.ink)) == NULL) {
+			error("get xlookup object failed: %d, %s",li.in.x->errc,li.in.x->err);
+		}
+	
+		/* Get details of overall conversion */
+		li.in.luo->spaces(li.in.luo, &li.in.csp, &li.in.chan, NULL, NULL, &li.in.alg,
+		                  NULL, NULL, NULL);
+
+		/* Get the input profile A2B input curve resolution */
+		/* (This is pretty rough - this should work for non LUT types as well!!) */
+		{
+			if (li.in.alg== icmLutType) {
+				icmLut *lut;
+				icxLuLut *luluo = (icxLuLut *)li.in.luo;		/* Safe to coerce */
+				luluo->get_info(luluo, &lut, NULL, NULL, NULL);	/* Get some details */
+				in_curve_res = lut->inputEnt;
+			}
+		}
+
+		/* Grab the white point in case the wphack or xyzscale needs it */
+		li.in.luo->efv_wh_bk_points(li.in.luo, li.in.wp, NULL, NULL);
+
+		/* Get native PCS space */
+		li.in.luo->lutspaces(li.in.luo, NULL, NULL, &natpcs, NULL, NULL);
+	
+		if (li.in.nocurve == 0 && natpcs == icSigXYZData
+		  && (li.in.alg == icmMatrixFwdType || li.in.alg == icmMatrixBwdType
+		      || li.in.csp == icSigXYZData)) {
+			li.in.lcurve = 1;		/* Use Y to L* and L* to Y for input */
+		    if (li.in.csp == icSigXYZData) {
+				li.in.lcurve = 2;		/* Use real Y to L* and L* to Y for input */
+				li.in.nocurve = 1;		/* Don't trust the curve that comes with it */
+			}
+			if (li.verb)
+				printf("Using Y to L* and L* to Y curves for input\n");
+		}
+
+		/* Setup any abstract profile to match the chosen PCS */
+		/* We aren't checking whether the input/abstract/output profile */
+		/* intents really make any sense. It's assumed at the moment */
+		/* that the user knows what they're doing! */
+		if (abs_name[0] != '\000') {
+
+			if ((li.abs_luo = li.abs_xicc->get_luobj(li.abs_xicc, flb, icmFwd, li.abs_intent,
+			        li.pcsor, icmLuOrdNorm, &li.out.vc, NULL)) == NULL)
+					error ("%d, %s",li.abs_icc->errc, li.abs_icc->err);
+		}
+
+		// Figure out whether the output profile is a Lut profile or not */
+		{
+			icmLuBase *plu;
+
+			/* Get temporary icm lookup object */
+			/* (Use Fwd just in case profile is missing B2A !!!!) */
+			if ((plu = li.out.c->get_luobj(li.out.c, icmFwd, icmDefaultIntent, icmSigDefaultData,
+			                            icmLuOrdNorm)) == NULL) {
+				error("get icm lookup object failed: on '%s' %d, %s",out_name,li.out.c->errc,li.out.c->err);
+			}
+
+			/* Check what the algorithm is */
+			plu->spaces(plu, NULL, NULL, NULL, NULL, &oalg, NULL, NULL, NULL, NULL);
+
+			/* release the icm lookup */
+			plu->del(plu);
+
+		}
+
+		if (oalg != icmLutType || li.mode < 2) {	/* Using B2A table or inv. mono/matrix */
+			if (li.verb)
+				printf("Loading output B2A table\n");
+
+			if ((li.out.luo = li.out.x->get_luobj(li.out.x, flb, icmBwd, li.out.intent,
+			                              li.pcsor, icmLuOrdNorm, &li.out.vc, &li.out.ink)) == NULL) {
+				error("get xlookup object failed: %d, %s",li.out.x->errc,li.out.x->err);
+			}
+			/* Get details of overall conversion */
+			li.out.luo->spaces(li.out.luo, NULL, NULL, NULL, &li.out.chan, &li.out.alg,
+			                   NULL, NULL, NULL);
+
+			/* Get the output profile B2A output curve resolution */
+			/* (This is pretty rough - this should work for non LUT types as well!!) */
+			{
+				if (li.out.alg== icmLutType) {
+					icmLut *lut;
+					icxLuLut *luluo = (icxLuLut *)li.out.luo;		/* Safe to coerce */
+					luluo->get_info(luluo, &lut, NULL, NULL, NULL);	/* Get some details */
+					out_curve_res = lut->outputEnt;
+				}
+			}
+	
+			/* Grab the white point in case the wphack or xyzscale needs it */
+			li.out.luo->efv_wh_bk_points(li.out.luo, li.out.wp, NULL, NULL);
+
+			/* Get native PCS space */
+			li.out.luo->lutspaces(li.out.luo, &natpcs, NULL, NULL, NULL, NULL);
+
+		} else {	/* Using inverse A2B Lut for output conversion */
+
+			fl = flb;
+#ifdef USE_MERGE_CLUT_OPT
+			fl |= ICX_MERGE_CLUT;
+#endif
+#ifdef USE_CAM_CLIP_OPT
+			fl |= ICX_CAM_CLIP;
+#endif
+			if (li.verb)
+				printf("Loading output inverse A2B table\n");
+
+#ifdef NEVER
+			printf("~1 output space flags = 0x%x\n",fl);
+			printf("~1 output space intent = %s\n",icx2str(icmRenderingIntent,li.out.intent));
+			printf("~1 output space pcs = %s\n",icx2str(icmColorSpaceSignature,li.pcsor));
+			printf("~1 output space viewing conditions =\n"); xicc_dump_viewcond(&li.out.vc);
+			printf("~1 output space inking =\n"); xicc_dump_inking(&li.out.ink);
+#endif
+
+			if ((li.out.luo = li.out.x->get_luobj(li.out.x, fl, icmFwd,
+			                  li.out.intent, li.pcsor, icmLuOrdNorm, &li.out.vc,
+			                  &li.out.ink)) == NULL) {
+				error("get xlookup object failed: %d, %s",li.out.x->errc,li.out.x->err);
+			}
+		
+			/* Get details of overall conversion */
+			li.out.luo->spaces(li.out.luo, &li.out.csp, &li.out.chan, NULL, NULL, &li.out.alg,
+			                   NULL, NULL, NULL);
+
+			/* Get the output profile A2B input curve resolution */
+			/* (This is pretty rough - this should work for non LUT types as well!!) */
+			{
+				if (li.out.alg== icmLutType) {
+					icmLut *lut;
+					icxLuLut *luluo = (icxLuLut *)li.out.luo;		/* Safe to coerce */
+					luluo->get_info(luluo, &lut, NULL, NULL, NULL);	/* Get some details */
+					out_curve_res = lut->inputEnt;
+				}
+			}
+
+			/* Grab the white point in case the wphack or xyzscale needs it */
+			li.out.luo->efv_wh_bk_points(li.out.luo, li.out.wp, NULL, NULL);
+
+			/* Get native PCS space */
+			li.out.luo->lutspaces(li.out.luo, NULL, NULL, &natpcs, NULL, NULL);
+
+			/* If we need a B2A lookup to get the existing K */
+			if (li.out.inking == 7) {
+				if ((li.out.b2aluo = li.out.x->get_luobj(li.out.x, flb, icmBwd,
+					li.out.intent, li.pcsor, icmLuOrdNorm, &li.out.vc, NULL)) == NULL) {
+					error("get B2A xlookup object failed: %d, %s",li.out.x->errc,li.out.x->err);
+				}
+			}
+		}
+		
+		/* If we need an PCS->K' mapping for the neutral axis to K hack. */
+		/* What we do is lookup the L for K values from 0 to 1, */
+		/* and then invert this to create an L to K lookup. */
+		/* If the gamut mapping is set to map to the K only black point, */
+		/* it should all work well... */
+		if (li.nhack) {
+			icxLuBase *luo;		/* Base XLookup type object */
+			icmLuAlgType alg;	/* Type of lookup algorithm */
+			co ips[256];		/* Initialisation points */
+			datai glow;			/* Grid low scale */
+			datai ghigh;		/* Grid high scale */
+			datao vlow;			/* Data value low normalize */
+			datao vhigh;		/* Data value high normalize */
+			double Lmax, Lmin;	/* Max and Min L values that result */
+			int grres;
+			double avgdev[MXDO];
+
+			if (li.out.h->colorSpace != icSigCmykData)
+				error("Neutral Axis K only requested with non CMYK output profile");
+
+			if (li.in.chan < 3)
+				error("Neutral Axis K only requested with input profile with less than 3 channels");
+
+			if (li.nhack == 2 && li.in.h->colorSpace != icSigCmykData)
+				error("Neutral Axis 000K only requested with input profile that is not CMYK");
+
+			if ((li.pcs2k = new_rspl(RSPL_NOFLAGS, 1, 1)) == NULL) {
+				error("Failed to create an rspl object");
+			}
+
+			/* Get a device to PCS lookup object to use to lookup K->PCS */
+			if ((luo = li.out.x->get_luobj(li.out.x, flb,
+			                  icmFwd, li.out.intent, li.pcsor, icmLuOrdNorm, &li.out.vc,
+			                  NULL)) == NULL) {
+				error("get xlookup object failed: %d, %s",li.out.x->errc,li.out.x->err);
+			}
+			/* Get details of overall conversion */
+			luo->spaces(luo, NULL, NULL, NULL, NULL, &alg, NULL, NULL, NULL);
+			if (alg != icmLutType)
+				error ("Unexpected algorithm type for CMYK output profile");
+
+			/* Setup the initialisation points */
+			Lmax = -100.0;
+			Lmin = 1000.0;
+			for (i = 0; i < 256; i++) {
+				icxLuLut *lu = (icxLuLut *)luo;	/* Safe to coerce */
+				double in[4], pcsv[4];
+				in[0] = in[1] = in[2] = 0.0;
+				in[3] = i/(255.0);
+
+				/* Want to do dev' -> PCS conversion to match the */
+				/* normal inverse PCS-> dev' used in devip_devop() */
+				if (li.out.nocurve) {	/* No explicit curve, so do implicit here */
+					/* Since not PCS, in_abs and matrix cannot be valid, */
+					/* so input curve on own is ok to use. */
+					lu->input(lu, pcsv, in);
+					lu->clut(lu, pcsv, pcsv);
+				} else {
+					lu->clut(lu, pcsv, in);
+				}
+				lu->output(lu, pcsv, pcsv);
+				lu->out_abs(lu, pcsv, pcsv);
+		
+				/* We force the rspl to be a forward conversion by swapping K and PCS */
+				ips[i].p[0] = pcsv[0];		/* PCS as input */
+				ips[i].v[0] = in[3];		/* K as output */
+#ifdef NEUTKDEBUG
+				printf("L %f -> K' %f\n",pcsv[0], in[3]);
+#endif /* NEUTKDEBUG */
+
+				if (pcsv[0] > Lmax)			/* Track min and max L values */
+					Lmax = pcsv[0];
+				if (pcsv[0] < Lmin)
+					Lmin = pcsv[0];
+			}
+
+			glow[0] = 0.0;
+			ghigh[0] = 100.0;
+			vlow[0] = 0.0;
+			vhigh[0] = 1.0;
+			grres = 256;
+			avgdev[0] = 0.005;
+
+			li.pcs2k->fit_rspl(li.pcs2k, 0, ips, 256, glow, ghigh, &grres, vlow, vhigh, 1.0, avgdev, NULL);
+
+			/* Fixup the white and black points for neutral axis to K hack. */
+			/* This is to make sure that they exactly match the fwd mapping */
+			/* after the rspl is fitted. */
+			{
+				pcs2k_ctx cx;		/* White point fixup context */
+				co pp;				/* Lookup the min and max K values */
+
+				pp.p[0] = Lmax;
+				li.pcs2k->interp(li.pcs2k, &pp);
+				cx.kmin = pp.v[0];	/* Ideally would be 0 */
+				pp.p[0] = Lmin;
+				li.pcs2k->interp(li.pcs2k, &pp);
+				cx.kmax = pp.v[0];	/* Ideally would be 1 */
+
+#ifdef NEUTKDEBUG
+				printf("Before fix: Lmax %f, Lmin %f, Kmin %f, Kmax %f\n",Lmax, Lmin, cx.kmin, cx.kmax);
+#endif /* NEUTKDEBUG */
+
+				li.pcs2k->re_set_rspl(li.pcs2k, 0, (void *)&cx, fix_pcs2k_white);
+#ifdef NEUTKDEBUG
+				pp.p[0] = Lmax;
+				li.pcs2k->interp(li.pcs2k, &pp);
+				cx.kmin = pp.v[0];	/* Ideally would be 0 */
+				pp.p[0] = Lmin;
+				li.pcs2k->interp(li.pcs2k, &pp);
+				cx.kmax = pp.v[0];	/* Ideally would be 1 */
+				printf("After fix: Lmax %f, Lmin %f, Kmin %f, Kmax %f\n",Lmax, Lmin, cx.kmin, cx.kmax);
+#endif /* NEUTKDEBUG */
+			}
+
+		}	/* end if neutral axis to K hack */
+
+		if (li.cmyhack != 0) {
+			if (li.in.h->colorSpace != icSigCmyData
+			 && li.in.h->colorSpace != icSigCmykData)
+				error("100% CMY mapping requested with non CMY or CMYK input profile");
+
+			if (li.out.h->colorSpace != icSigCmyData
+			 && li.out.h->colorSpace != icSigCmykData)
+				error("100% CMY mapping requested with non CMY or CMYK output profile");
+		}
+
+		if (li.out.nocurve == 0 && natpcs == icSigXYZData
+		  && (li.out.alg == icmMatrixFwdType || li.out.alg == icmMatrixBwdType
+		      || li.out.csp == icSigXYZData)) {
+			li.out.lcurve = 1;		/* Use Y to L* and L* to Y for output */
+		    if (li.out.csp == icSigXYZData) {
+				li.out.lcurve = 2;		/* Use real Y to L* and L* to Y for output */
+				li.out.nocurve = 1;		/* Don't trust the curve that comes with it */
+			}
+			if (li.verb)
+				printf("Using Y to L* and L* to Y curves for output\n");
+		}
+	}
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Setup the gamut mapping */
+// ~~~~ need to account for possible abstract profile after source !!!!
+// ~~~~ also need to fix tiffgamut to allow for abstract profile !!!!
+
+	if (li.verb)
+		printf("Gamut mapping mode is '%s'\n",li.mode == 0 ? "Simple" : li.mode == 1 ? "Mapping" : "Mapping inverse A2B");
+	if (li.verb && li.mode > 0)
+		printf("Gamut mapping intent is '%s'\n",li.gmi.desc);
+
+	/* In gamut mapping mode, the PCS used will always be absolute */
+	/* intent from the input and output profiles, and either */
+	/* lab or Jab space, with the given in/out viewing conditions */
+	/* for the latter. The xluo->get_gamut work in the set li.pcsor */
+	/* for each xluo. */
+	if (li.mode > 0 && li.gmi.usemap) {
+		gamut *csgam, *igam, *ogam;
+		double sgres;			/* Source gamut surface feature resolution */
+		double dgres;			/* Destination gamut surface feature resolution */
+		int    mapres;			/* Mapping rspl resolution */
+
+		if (li.verb)
+			printf("Creating Gamut Mapping\n");
+
+		/* Gamut mapping will extend given grid res to encompas */
+		/* source gamut by a margin. */
+		if (li.quality == 3) {			/* Ultra High */
+  	 		sgres = 7.0;
+  	 		dgres = 7.0;
+  	 		mapres = 41;
+		} else if (li.quality == 2) {	/* High */
+  	 		sgres = 8.0;
+  	 		dgres = 8.0;
+  	 		mapres = 33;
+		} else if (li.quality == 1) {	/* Medium */
+  	 		sgres = 10.0;
+  	 		dgres = 10.0;
+  	 		mapres = 25;
+		} else {						/* Low quality */
+  	 		sgres = 12.0;
+  	 		dgres = 12.0;
+  	 		mapres = 17;
+		}
+
+		/* Creat the source colorspace gamut surface */
+		if (li.verb)
+			printf(" Finding Source Colorspace Gamut with res %f\n",sgres);
+
+		/* Creat the source image gamut surface in the selected li.pcsor space */
+		if ((csgam = li.in.luo->get_gamut(li.in.luo, sgres)) == NULL)
+			error ("%d, %s",li.in.x->errc, li.in.x->err);
+
+		/* Grab a given source image gamut. */
+		if (sgam_name[0] != '\000') {		/* Optional source gamut - ie. from an images */
+
+			if (li.verb)
+				printf(" Loading Image Source Gamut '%s'\n",sgam_name);
+
+			igam = new_gamut(sgres, isJab, 0);	/* isJab will be overriden by gamut file */
+
+			if (igam->read_gam(igam, sgam_name))
+				error("Reading source gamut '%s' failed",sgam_name);
+
+			if (igam->getisjab(igam) != isJab) {
+				/* Should really convert to/from Jab here! */
+				warning("Image gamut is wrong colorspace for link (Lab != Jab)");
+
+				/* This will actually error in the gamut mapping code */
+				/* Note that we're not checking relative/absolute colorspace here. */
+				/* At the moment it's up to the user to get this right. */
+			}
+
+		} else {
+			igam = NULL;	/* NULL signals no source image gamut */
+		}
+
+		/* Creat the destination gamut surface */
+		if (li.verb)
+			printf(" Finding Destination Gamut with res %f\n",dgres);
+
+		if ((ogam = li.out.luo->get_gamut(li.out.luo, dgres)) == NULL)
+			error ("%d, %s",li.out.x->errc, li.out.x->err);
+
+		if (li.verb)
+			printf(" Creating Gamut match\n");
+
+		li.map = new_gammap(li.verb, csgam, igam, ogam, &li.gmi,
+		                    li.src_kbp, li.dst_kbp, li.cmyhack, li.rel_oride,
+		                    mapres, NULL, NULL, li.gamdiag ? "gammap.wrl" : NULL
+		);
+		if (li.map == NULL)
+			error ("Failed to make gamut map transform");
+
+		if (li.nhack == 2) {
+			if (li.verb)
+				printf(" Creating K only black to K only black Gamut match\n");
+
+			li.Kmap = new_gammap(li.verb, csgam, igam, ogam, &li.gmi,
+			                    1, 1, li.cmyhack, li.rel_oride,
+			                    mapres, NULL, NULL, li.gamdiag ? "gammap.wrl" : NULL
+			);
+			if (li.Kmap == NULL)
+				error ("Failed to make K only gamut map transform");
+		}
+
+		ogam->del(ogam);
+		if (igam != NULL)
+			igam->del(igam);
+		csgam->del(csgam);
+	}
+
+	/* If we've got a request for Absolute Appearance mode with scaling */
+	/* to avoid clipping the source white point, compute the needed XYZ scaling factor. */
+	/* We assume that the white point hack can't be used at the same time. */
+	if (li.mode > 0 && li.wphack == 0 && (li.gmi.usecas & 0x100) != 0) {
+		double xyzscale[1], sa[1];
+
+		/* We already have the source space white point in li.in.wp[] */
+
+		/* Convert it to destination XYZ */
+		if (li.pcsor == icxSigJabData) {
+			/* We're being bad in delving inside the xluo, but we'll fix it latter */
+			li.out.luo->cam->cam_to_XYZ(li.out.luo->cam, li.swxyz, li.in.wp);
+		} else
+			error("Internal :- not setup to handle Y scaling and non-Jab PCS");
+
+//printf("~1 Source white Jab = %f %f %f\n", li.in.wp[0], li.in.wp[1], li.in.wp[2]);
+//printf("~1 Source white XYZ = %f %f %f\n", li.swxyz[0], li.swxyz[1], li.swxyz[2]);
+
+		/* Compute the bigest scale factor less than or equal to 1.0, */
+		/* that doesn't clip the li.swxyz[] on the destination gamut */
+		sa[0] = 0.1;
+		xyzscale[0] = 0.5;
+		if (powell(NULL, 1, xyzscale, sa, 1e-6, 2000, xyzoptfunc, (void *)&li, NULL, NULL) != 0) {
+			warning("set_icxLuLut: XYZ scale powell failed to converge - set scale to 1.0");
+		} else {
+			li.xyzscale = xyzscale[0];
+			if (li.verb)
+				printf("Set XYZ scale factor to %f\n",li.xyzscale);
+		}
+	}
+
+	/* Create the link profile */
+	if (verify == 0) {
+		icmFile *wr_fp;
+		icc *wr_icc;
+
+		if (li.verb)
+			printf("Creating link profile\n");
+
+		/* Open up the link file for writing */
+		if ((wr_fp = new_icmFileStd_name(link_name,"w")) == NULL)
+			error ("Write: Can't open file '%s'",link_name);
+
+		if ((wr_icc = new_icc()) == NULL)
+			error ("Write: Creation of ICC object failed");
+
+		/* Add all the tags required */
+
+		/* The header: */
+		{
+			icmHeader *wh = wr_icc->header;
+
+			/* Values that must be set before writing */
+			wh->deviceClass     = icSigLinkClass;			/* We are creating a link ! */
+			wh->colorSpace      = li.in.h->colorSpace;		/* Input profile device space */
+			wh->pcs             = li.out.h->colorSpace;		/* Output profile device space */
+			if (li.mode > 0) {
+				wh->renderingIntent = li.gmi.icci;			/* Closest ICC intent */
+			} else {
+				wh->renderingIntent = li.out.intent;		/* Output intent chosen */
+			}
+
+			/* Values that should be set before writing */
+			if (xpi.manufacturer != 0L)
+				wh->manufacturer = xpi.manufacturer;
+			else
+				wh->manufacturer = icmSigUnknownType;
+	
+			if (xpi.model != 0L)
+				wh->model = xpi.model;
+			else
+		    	wh->model        = icmSigUnknownType;
+	
+			/* Values that may be set before writing */
+			if (xpi.creator != 0L)
+				wh->creator = xpi.creator;
+
+			wh->attributes.l = 0;
+			wh->flags        = 0;
+#ifdef NT
+			wh->platform = icSigMicrosoft;
+#endif
+#ifdef __APPLE__
+			wh->platform = icSigMacintosh;
+#endif
+#if defined(UNIX) && !defined(__APPLE__)
+			wh->platform = icmSig_nix;
+#endif
+		}
+		/* Profile Description Tag: */
+		{
+			icmTextDescription *wo;
+			char *dst, dstm[200];			/* description */
+	
+			if (xpi.profDesc != NULL)
+				dst = xpi.profDesc;
+			else {
+				dst = "Device Link profile - See ProfileSequenceDescTag for more information";
+				dst = dstm;
+			}
+	
+			if ((wo = (icmTextDescription *)wr_icc->add_tag(
+			           wr_icc, icSigProfileDescriptionTag,	icSigTextDescriptionType)) == NULL) 
+				error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+	
+			wo->size = strlen(dst)+1; 	/* Allocated and used size of desc, inc null */
+			wo->allocate((icmBase *)wo);/* Allocate space */
+			strcpy(wo->desc, dst);		/* Copy the string in */
+		}
+		/* Copyright Tag: */
+		{
+			icmText *wo;
+			char *crt;
+	
+			if (xpi.copyright != NULL)
+				crt = xpi.copyright;
+			else
+				crt = "Copyright, the creator of this profile";
+	
+			if ((wo = (icmText *)wr_icc->add_tag(
+			           wr_icc, icSigCopyrightTag,	icSigTextType)) == NULL) 
+				error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+	
+			wo->size = strlen(crt)+1; 	/* Allocated and used size of text, inc null */
+			wo->allocate((icmBase *)wo);/* Allocate space */
+			strcpy(wo->data, crt);		/* Copy the text in */
+		}
+		/* Device Manufacturers Description Tag: */
+		if (xpi.deviceMfgDesc != NULL) {
+			icmTextDescription *wo;
+			char *dst = xpi.deviceMfgDesc;
+	
+			if ((wo = (icmTextDescription *)wr_icc->add_tag(
+			           wr_icc, icSigDeviceMfgDescTag,	icSigTextDescriptionType)) == NULL) 
+				error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+	
+			wo->size = strlen(dst)+1; 	/* Allocated and used size of desc, inc null */
+			wo->allocate((icmBase *)wo);/* Allocate space */
+			strcpy(wo->desc, dst);		/* Copy the string in */
+		}
+		/* Model Description Tag: */
+		if (xpi.modelDesc != NULL) {
+			icmTextDescription *wo;
+			char *dst = xpi.modelDesc;
+	
+			if ((wo = (icmTextDescription *)wr_icc->add_tag(
+			           wr_icc, icSigDeviceModelDescTag,	icSigTextDescriptionType)) == NULL) 
+				error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+	
+			wo->size = strlen(dst)+1; 	/* Allocated and used size of desc, inc null */
+			wo->allocate((icmBase *)wo);/* Allocate space */
+			strcpy(wo->desc, dst);		/* Copy the string in */
+		}
+		/* ProfileSequenceDescTag: */
+		{
+			unsigned int i;
+			icmProfileSequenceDesc *wo;
+			if ((wo = (icmProfileSequenceDesc *)wr_icc->add_tag(
+			           wr_icc, icSigProfileSequenceDescTag, icSigProfileSequenceDescType)) == NULL) 
+				return 1;
+
+			wo->count = 2; 		/* Number of descriptions in sequence */
+			if (wo->allocate((icmBase *)wo) != 0)	/* Allocate space for all the DescStructures */
+				error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+			/* Fill in each description structure in sequence */
+
+			/* For each profile in the chain */
+			for (i = 0; i < wo->count; i++) {
+				icc *iccs = NULL;
+				icmHeader *sh = NULL;
+				icmSignature *tsig;
+				icmTextDescription *ddesc;
+				icmTextDescription *mdesc;
+
+				if (i == 0) {
+					iccs = li.in.c;		/* Input profile */
+					sh = li.in.h;		/* Input profile header */
+				} else if (i == (wo->count-1)) {
+					iccs = li.out.c;	/* Output profile */
+					sh = li.out.h;		/* Output profile header */
+				} else {
+					error("Abstract profiles in link not implemented yet!");
+				}
+
+				/* Try and read the technology tag */
+				if ((tsig = (icmSignature *)iccs->read_tag(iccs, icSigTechnologyTag)) != NULL) {
+					if (tsig->ttype != icSigSignatureType)	/* oops */
+						tsig = NULL;
+				}
+
+				/* Try and read the Device Manufacturers Description Tag */
+				if ((ddesc = (icmTextDescription *)iccs->read_tag(
+				                                      iccs, icSigDeviceMfgDescTag)) != NULL) {
+					if (ddesc->ttype != icSigTextDescriptionType)	/* oops */
+						ddesc = NULL;
+				}
+			
+				/* Try and read the Model Manufacturers Description Tag */
+				if ((mdesc = (icmTextDescription *)iccs->read_tag(
+				                                      iccs, icSigDeviceModelDescTag)) != NULL) {
+					if (mdesc->ttype != icSigTextDescriptionType)	/* oops */
+						mdesc = NULL;
+				}
+			
+				/* Header information */
+				wo->data[i].deviceMfg   = sh->manufacturer;
+				wo->data[i].deviceModel = sh->model;
+				wo->data[i].attributes  = sh->attributes;
+
+				/* Technology signature */
+				if (tsig != NULL)
+					wo->data[i].technology = tsig->sig; 
+
+				if (ddesc != NULL) {
+					wo->data[i].device.size = ddesc->size;
+					if (wo->data[i].allocate(&wo->data[i]) != 0)	/* Allocate space */
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+					strcpy(wo->data[i].device.desc, ddesc->desc);
+
+					wo->data[i].device.ucLangCode = ddesc->ucLangCode;
+					wo->data[i].device.ucSize = ddesc->ucSize;
+					if (wo->data[i].allocate(&wo->data[i]) != 0)	/* Allocate space */
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+					memmove(wo->data[i].device.ucDesc, ddesc->ucDesc, 2 * ddesc->ucSize);
+
+					wo->data[i].device.scCode = ddesc->scCode;	
+					wo->data[i].device.scSize = ddesc->scSize;		
+					strcpy((char *)wo->data[i].device.scDesc, (char *)ddesc->scDesc);
+				}
+
+				/* model Text description */
+				if (mdesc != NULL) {
+					wo->data[i].model.size = mdesc->size;
+					if (wo->data[i].allocate(&wo->data[i])!= 0)		/* Allocate space */
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+					strcpy(wo->data[i].model.desc, mdesc->desc);
+
+					wo->data[i].model.ucLangCode = mdesc->ucLangCode;
+					wo->data[i].model.ucSize = mdesc->ucSize;
+					if (wo->data[i].allocate(&wo->data[i]) != 0) 	/* Allocate space */
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+					memmove(wo->data[i].model.ucDesc, mdesc->ucDesc, 2 * mdesc->ucSize);
+
+					wo->data[i].model.scCode = mdesc->scCode;	
+					wo->data[i].model.scSize = mdesc->scSize;		
+					strcpy((char *)wo->data[i].model.scDesc, (char *)mdesc->scDesc);
+				}
+			}
+		}
+		/* ColorantTable: */
+		{
+			int i;
+			unsigned int j;
+			int repclip = 0;
+
+			/* For the first and last profile in the chain */
+			/* (Note that we're assuming that the link output PCS is always Lab) */ 
+			for (i = 0; i < 2; i++) {
+				icc *iccs;
+				icmHeader *sh;
+				icmColorantTable *ro;
+				icmColorantTable *wo;
+				icTagSignature cts;
+
+				if (i == 0) {
+					iccs = li.in.c;		/* Input profile */
+					sh = li.in.h;		/* Input profile header */
+					cts = icSigColorantTableTag; 
+				} else {
+					iccs = li.out.c;	/* Output profile */
+					sh = li.out.h;		/* Output profile header */
+					cts = icSigColorantTableOutTag;
+				}
+
+				/* Try and read the input ColorantTable */
+				if ((ro = (icmColorantTable *)iccs->read_tag(
+			   	          iccs, icSigColorantTableTag)) != NULL) { 
+
+					/* Create a ColorantTable in the output device link */
+					if ((wo = (icmColorantTable *)wr_icc->add_tag(
+			           wr_icc, cts, icSigColorantTableType)) == NULL) 
+						error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+					/* Copy everything across */
+			   		wo->count = ro->count;
+					if (wo->allocate((icmBase *)wo) != 0)
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+					for (j = 0; j < wo->count; j++) {
+						strcpy(wo->data[j].name, ro->data[j].name);
+						if (sh->pcs != icSigLabData) {
+							icmXYZ2Lab(&icmD50, wo->data[j].pcsCoords, ro->data[j].pcsCoords);
+							/* For device links the colorant table must be Lab PCS, */
+							/* but embarassingly, XYZ profiles can have colorant values */
+							/* not representable in the Lab PCS range. */
+							if (icmClipLab(wo->data[j].pcsCoords, wo->data[j].pcsCoords)) {
+								if (repclip)
+									warning("Colorant Tag Lab value was clipped");
+								repclip = 1;
+							}
+						} else {
+							icmAry2Ary(wo->data[j].pcsCoords, ro->data[j].pcsCoords);
+						}
+					}
+
+				} else {	/* Do this the hard way */
+					icmLuBase *luo;
+					unsigned int count;
+					double dv[MAX_CHAN];
+					double cvals[MAX_CHAN][3];
+					inkmask imask;
+
+					/* Get a lookup to read colorant values */
+					if ((luo = iccs->get_luobj(iccs, icmFwd, icRelativeColorimetric,
+					                           icSigLabData, icmLuOrdNorm)) == NULL)
+						goto skip_coloranttable;
+
+			   		count = icmCSSig2nchan(sh->colorSpace);
+					for (j = 0; j < count; j++)
+						dv[j] = 0.0;
+
+					/* Lookup the colorant Lab values the recommended ICC way */
+					for (j = 0; j < count; j++) {
+						dv[j] = 1.0;
+						luo->lookup(luo, cvals[j], dv);
+						/* For device links the colorant table must be Lab PCS, */
+						/* but embarassingly, XYZ profiles can have colorant values */
+						/* not representable in the Lab PCS range. */
+						if (icmClipLab(cvals[j], cvals[j])) {
+							if (repclip)
+								warning("Colorant Tag Lab value was clipped");
+							repclip = 1;
+						}
+						dv[j] = 0.0;
+					}
+					luo->del(luo);
+
+					/* Lookup colorant names */
+					if ((imask = icx_icc_cv_to_colorant_comb(sh->colorSpace, iccs->header->deviceClass, cvals)) == 0)
+						goto skip_coloranttable;
+
+					/* Create a ColorantTable in the output device link */
+					if ((wo = (icmColorantTable *)wr_icc->add_tag(
+			           wr_icc, cts, icSigColorantTableType)) == NULL) 
+						error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+			   		wo->count = count;
+					if (wo->allocate((icmBase *)wo) != 0)
+						error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+					
+					for (j = 0; j < count; j++) {
+						inkmask iimask;			/* Individual ink mask */
+						char *name;
+						
+						iimask = icx_index2ink(imask, j);
+						name = icx_ink2string(iimask); 
+						if (strlen(name) > 31)
+							error("Internal: colorant name exceeds 31 characters");
+						strcpy(wo->data[j].name, name);
+						wo->data[j].pcsCoords[0] = cvals[j][0];
+						wo->data[j].pcsCoords[1] = cvals[j][1];
+						wo->data[j].pcsCoords[2] = cvals[j][2];
+					}
+				}
+				/* Jump to here if we can't figure out what to put in ColorantTag */
+				skip_coloranttable:;
+			}
+		}
+		/* 16 bit input device -> output device lut: */
+		{
+			int inputEnt, outputEnt, clutPoints;
+			icmLut *wo;
+
+			/* Setup the cLUT resolutions */
+			if (li.quality >= 3)
+	    		inputEnt = 4096;
+			else if (li.quality == 2)
+	    		inputEnt = 2048;
+			else
+	    		inputEnt = 256;
+
+			/* Make sure that we have at least the number of input entries as the */
+			/* input profile. */
+			if (in_curve_res > inputEnt)
+				inputEnt = in_curve_res;
+
+			/* See discussion in imdi/imdi_gen.c for ideal numbers */
+			switch (li.in.chan) {
+				case 0:
+					error ("Illegal number of input chanels");
+				case 1:
+					if (li.quality >= 3)
+			  		  	clutPoints = 255;
+					else if (li.quality == 2)
+			  		  	clutPoints = 255;
+					else
+			  		  	clutPoints = 255;
+					break;
+
+				case 2:
+					if (li.quality >= 2)
+		  		  		clutPoints = 255;
+					else
+		  		  		clutPoints = 86;
+					break;
+				case 3:
+					if (li.quality >= 3)
+		  		  		clutPoints = 52;
+					else if (li.quality == 2)
+		  		  		clutPoints = 33;
+					else if (li.quality == 1)
+		  		  		clutPoints = 17;
+					else
+		  		  		clutPoints = 9;
+					break;
+				case 4:
+					if (li.quality >= 3)
+		  		  		clutPoints = 33;
+					else if (li.quality == 2)
+		  		  		clutPoints = 18;
+					else if (li.quality == 1)
+		  		  		clutPoints = 9;
+					else
+		  		  		clutPoints = 6;
+					break;
+				case 5:
+					if (li.quality >= 3)
+		  		  		clutPoints = 18;
+					else if (li.quality == 2)
+		  		  		clutPoints = 16;
+					else 
+						clutPoints = 9;
+					break;
+				case 6:
+					if (li.quality >= 3)
+		  		  		clutPoints = 12;
+					else if (li.quality == 2)
+		  		  		clutPoints = 9;
+					else 
+						clutPoints = 6;
+					break;
+				case 7:
+					if (li.quality >= 3)
+		  		  		clutPoints = 8;
+					else if (li.quality == 2)
+		  		  		clutPoints = 7;
+					else 
+						clutPoints = 6;
+					break;
+				case 8:
+					if (li.quality >= 3)
+		  		  		clutPoints = 7;
+					else if (li.quality == 2)
+		  		  		clutPoints = 6;
+					else 
+						clutPoints = 5;
+					break;
+				default: /* > 8 chan */
+					clutPoints = 3;
+					break;
+			}	
+
+			if (li.clutres > 0)		/* clut resolution override */
+  		  		clutPoints = li.clutres;
+			li.clutres = clutPoints;	/* Actual resolution */
+
+			if (li.quality >= 3)
+	    		outputEnt = 4096;
+			else if (li.quality == 2)
+	    		outputEnt = 2048;
+			else
+	    		outputEnt = 256;
+
+			/* Make sure that we have at least the number of input entries as the */
+			/* output profile. */
+			if (out_curve_res > outputEnt)
+				outputEnt = out_curve_res;
+
+
+			/* Link Lut = AToB0 */
+			if ((wo = (icmLut *)wr_icc->add_tag(
+			           wr_icc, icSigAToB0Tag,	icSigLut16Type)) == NULL) 
+				error("add_tag failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+			wo->inputChan = li.in.chan;
+			wo->outputChan = li.out.chan;
+
+			/* Setup the tables resolutions */
+    		wo->inputEnt = inputEnt;
+  		  	wo->clutPoints = clutPoints;
+	  		wo->outputEnt = outputEnt;
+
+			if (wo->allocate((icmBase *)wo) != 0)	/* Allocate space */
+				error("allocate failed: %d, %s",wr_icc->errc,wr_icc->err);
+
+			/* Special case if input profile is Lut with matrix */
+			/* (Does this do anything since input is not XYZ ?) */
+			if (li.in.alg == icmLutType && li.in.nocurve == 0) {
+				icxLuLut *lu = (icxLuLut *)li.in.luo;
+				lu->get_matrix(lu, wo->e);		/* Copy it across */
+			}
+
+
+
+			if (li.verb)
+				printf("Filling in Lut table\n");
+#ifdef DEBUG_ONE
+#define DBGNO 1		/* Up to 10 */
+
+#ifndef NEVER
+			/* Test a single given rgb/cmyk -> cmyk value */
+			{
+				double in[10][MAX_CHAN];
+				double out[MAX_CHAN];
+				in[0][0] = 1.0;
+				in[0][1] = 1.0;
+				in[0][2] = 1.0;
+				in[0][3] = 0.0;
+
+				in[1][0] = 1.0;
+				in[1][1] = 1.0;
+				in[1][2] = 1.0;
+				in[1][3] = 0.0;
+
+				for (i = 0; i < DBGNO; i++) {
+					printf("Input %f %f %f %f\n",in[i][0], in[i][1], in[i][2], in[i][3]);
+					devi_devip((void *)&li, out, in[i]);
+					devip_devop((void *)&li, out, out);
+					devop_devo((void *)&li, out, out);
+					printf("Output %f %f %f %f\n\n",out[0], out[1], out[2], out[3]);
+				}
+			}
+#endif /* NEVER */
+
+#else	/* !DEBUG_ONE */
+			/* Use helper function to do the hard work. */
+			if (li.verb) {
+				unsigned int ui;
+				int itotal;
+				for (itotal = 1, ui = 0; ui < li.in.chan; ui++, itotal *= clutPoints)
+					; 
+				li.total = itotal;
+				/* Allow for extra lookups due to ICM_CLUT_SET_APXLS */
+				for (itotal = 1, ui = 0; ui < li.in.chan; ui++, itotal *= (clutPoints-1))
+					; 
+				li.total += itotal;
+				li.count = 0;
+				printf(" 0%%"); fflush(stdout);
+			}
+			if (icmSetMultiLutTables(
+				1,
+				&wo,
+				ICM_CLUT_SET_APXLS,			/* Use aproximate least squares */
+				&li,						/* Context */
+				li.in.h->colorSpace,		/* Input color space */
+				li.out.h->colorSpace,		/* Output color space */
+				devi_devip,					/* Input transfer tables devi->devi' */
+				NULL, NULL,					/* Use default input colorspace range */
+				devip_devop,				/* devi' -> devo' transfer function */
+				NULL, NULL,					/* Default output colorspace range */
+				devop_devo					/* Output transfer tables, devo'->devo */
+			) != 0) {
+				error("Setting 16 bit Lut failed: %d, %s",wr_icc->errc,wr_icc->err);
+			}
+			if (li.verb) {
+				printf("\n");
+			}
+#ifdef WARN_CLUT_CLIPPING
+			if (wr_icc->warnc)
+				warning("Values clipped in setting device link LUT");
+#endif /* WARN_CLUT_CLIPPING */
+
+#endif	/* !DEBUG_ONE */
+
+		}
+
+		if (li.verb && li.wphack && li.wphacked == 0)
+			printf("Warning :- white point hack didn't trigger!\n");
+		if (li.verb && li.wphack && li.wphacked > 1)
+			printf("Warning :- white point hack trigger more than once! (%d)\n",li.wphacked);
+
+		if (li.verb)
+			printf("Writing out file\n");
+
+		/* Write the file out */
+		if ((rv = wr_icc->write(wr_icc,wr_fp,0)) != 0)
+			error ("Write file: %d, %s",rv,wr_icc->err);
+		
+		wr_icc->del(wr_icc);
+		wr_fp->del(wr_fp);
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Verify the given link, assuming all the options are the same */
+	} else {
+		icmFile *rd_fp;
+		icc *rd_icc;
+		icmLuBase *luo;
+
+		icColorSpaceSignature ins, outs;	/* Type of input and output spaces */
+		int inn, outn;						/* Number of components */
+		icmLuAlgType alg;					/* Type of lookup algorithm */
+
+		/* Lookup parameters */
+		icmLookupFunc     func   = icmFwd;				/* Default */
+		icRenderingIntent intent = icmDefaultIntent;	/* Default */
+		icmLookupOrder    order  = icmLuOrdNorm;		/* Default */
+
+		int gc[MAX_CHAN];								/* Grid counter */
+		int vres = 8;		//~~9
+		double imin[MAX_CHAN], imax[MAX_CHAN];			/* Range of input values */
+		double omin[MAX_CHAN], omax[MAX_CHAN];			/* Range of output values */
+		double in[MAX_CHAN];							/* Input value */
+		double ref[MAX_CHAN];							/* Reference output value */
+		double out[MAX_CHAN];							/* Output value */
+		double aerr, perr;								/* Average, Peak error */
+		double nerr;
+		int count, total;
+		int pc, lastpc;
+		double pin[MAX_CHAN], pref[MAX_CHAN], pout[MAX_CHAN];	/* Peak error values */
+		
+		if (li.verb)
+			printf("Setting up to verify the link\n");
+
+		/* Open up the link file for reading */
+		if ((rd_fp = new_icmFileStd_name(link_name,"r")) == NULL)
+			error ("Verify: Can't open file '%s'",link_name);
+
+		if ((rd_icc = new_icc()) == NULL)
+			error ("Verify: Creation of ICC object failed");
+
+		if ((rv = rd_icc->read(rd_icc,rd_fp,0)) != 0)
+			error ("%d, %s",rv,rd_icc->err);
+
+		/* Check that the profile is appropriate */
+		if (rd_icc->header->deviceClass != icSigLinkClass)
+			error("Profile isn't a device link profile");
+
+		/* Get a conversion object */
+		if ((luo = rd_icc->get_luobj(rd_icc, func, intent, icmSigDefaultData, order)) == NULL)
+			error ("%d, %s",rd_icc->errc, rd_icc->err);
+
+		/* Get details of conversion (Arguments may be NULL if info not needed) */
+		luo->spaces(luo, &ins, &inn, &outs, &outn, &alg, NULL, NULL, NULL, NULL);
+
+		if (alg != icmLutType)
+			error ("DeviceLink profile doesn't have Lut !");
+
+		/* Get the icm value ranges */
+		luo->get_ranges(luo, imin, imax, omin, omax);
+
+		/* Init the grid counter */
+		for (i = 0; i < inn; i++)
+			gc[i] = 0;
+
+		for (total = 1, i = 0; i < inn; i++, total *= vres)
+				; 
+
+		count = 0;
+		lastpc = 0;
+		nerr = aerr = perr = 0.0;
+		for(i = 0; i < inn; ) {
+			int j;
+			double err;
+
+			/* Create and scale input */
+			for (j = 0; j < inn; j++) {
+				in[j] = gc[j]/(vres-1.0);
+				in[j] = in[j] * (imax[j] - imin[j]) + imin[j];
+			}
+
+//			printf("Input %f %f %f %f\n",in[0], in[1], in[2], in[3]);
+
+			/* Create the reference output value */
+			devi_devip((void *)&li, ref, in);
+			devip_devop((void *)&li, ref, ref);
+			devop_devo((void *)&li, ref, ref);
+
+			/* Lookup the icm output value */
+			if ((rv = luo->lookup(luo, out, in)) > 1)
+				error ("%d, %s",rd_icc->errc,rd_icc->err);
+		
+//			printf("Output %f %f %f %f\n",out[0], out[1], out[2], out[3]);
+//			printf("Ref    %f %f %f %f\n",ref[0], ref[1], ref[2], ref[3]);
+//			printf("\n");
+
+			/* Unscale output and compare the results */
+			for (err = 0.0, j = 0; j < outn; j++) {
+				double o,r;
+				o = (out[j] - omin[j])/(omax[j] - omin[j]);
+				r = (ref[j] - omin[j])/(omax[j] - omin[j]);
+				err += (o - r) * (o - r);
+			}
+			err = sqrt(err);
+
+			aerr += err;
+			nerr++;
+			if (err > perr) {
+				perr = err;
+				for (j = 0; j < outn; j++) {
+					pin[j]  = in[j];
+					pref[j] = ref[j];
+					pout[j] = out[j];
+				}
+			}
+
+			count++;
+			pc = (int)(count * 100.0/total + 0.5);
+			if (pc != lastpc) {
+				printf("%c%2d%%",cr_char,pc); fflush(stdout);
+				lastpc = pc;
+			}
+
+			/* Increment the grid counter */
+			for (i = 0; i < inn; i++) {
+				if (++gc[i] < vres)
+					break;			/* No carry */
+				gc[i] = 0;			/* Reset digit */
+			}
+		}
+
+		if (li.verb)
+			printf("Finished verfication\n");
+
+		printf("Average error = %f%%, peak error = %f%%\n",aerr * 100.0/nerr, perr * 100.0);
+		printf("Input %f %f %f %f\n",pin[0], pin[1], pin[2], pin[3]);
+		printf("Output %f %f %f %f\n",pout[0], pout[1], pout[2], pout[3]);
+		printf("Ref    %f %f %f %f\n",pref[0], pref[1], pref[2], pref[3]);
+
+		luo->del(luo);
+		rd_icc->del(rd_icc);
+		rd_fp->del(rd_fp);
+	}
+
+	/* - - - - - - - - - - - - - - - - - - - */
+	/* Cleanup source profiles and exit */
+
+	if (li.pcs2k != NULL)			/* Free up PCS->K lookup for neutral hack */
+		li.pcs2k->del(li.pcs2k);
+
+	if (li.map != NULL)
+		li.map->del(li.map);
+	if (li.Kmap != NULL)
+		li.Kmap->del(li.Kmap);
+
+	if (li.abs_luo != NULL) {		/* Free up abstract transform */
+		li.abs_luo->del(li.abs_luo);
+		li.abs_xicc->del(li.abs_xicc);
+		li.abs_icc->del(li.abs_icc);
+		li.abs_fp->del(li.abs_fp);
+	}
+
+	li.in.luo->del(li.in.luo);
+	li.in.x->del(li.in.x);
+	li.in.c->del(li.in.c);
+
+	if (li.out.b2aluo != NULL)
+		li.out.b2aluo->del(li.out.b2aluo);
+	li.out.luo->del(li.out.luo);
+	li.out.x->del(li.out.x);
+	li.out.c->del(li.out.c);
+
+	return 0;
+}
+
+
+
+
+
+
+
diff --git a/link/monoplot.c b/link/monoplot.c
new file mode 100644
index 0000000..781342b
--- /dev/null
+++ b/link/monoplot.c
@@ -0,0 +1,231 @@
+
+/* 
+ * Argyll Color Management System
+ *
+ * Plot the monochrome axis transfer curve of a given link.
+ *
+ * Author:  Graeme W. Gill
+ * Date:    01/26/8
+ * Version: 2.00
+ *
+ * Copyright 2001 Graeme W. Gill
+ *
+ * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
+ * see the License.txt file for licencing details.
+ */
+
+/* TTBD:
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <string.h>
+#include <math.h>
+#include "copyright.h"
+#include "aconfig.h"
+#include "icc.h"
+#include "plot.h"
+
+#define PRES 100
+
+void error(char *fmt, ...), warning(char *fmt, ...);
+
+/* ---------------------------------------- */
+
+void usage(void) {
+	fprintf(stderr,"Plot monochrome axis of ICC link file, Version %s\n",ARGYLL_VERSION_STR);
+	fprintf(stderr,"PCS->DEV ->link-> DEV->PCS\n");
+	fprintf(stderr,"Author: Graeme W. Gill\n");
+	fprintf(stderr,"usage: monoplot inprof linkprof outprof\n");
+	fprintf(stderr," -v        verbose\n");
+	exit(1);
+}
+
+int
+main(
+	int argc,
+	char *argv[]
+) {
+	int fa, nfa;				/* argument we're looking at */
+	int verb = 0;
+	char in_name[100];
+	char link_name[100];
+	char out_name[100];
+	icmFile *in_fp, *link_fp, *out_fp;
+	icc *in_icco, *link_icco, *out_icco;
+	icmLuBase *in_lu, *link_lu, *out_lu;
+	int rv = 0;
+
+	if (argc < 4)
+		usage();
+
+	/* Process the arguments */
+	for(fa = 1;fa < argc;fa++) {
+		nfa = fa;					/* skip to nfa if next argument is used */
+		if (argv[fa][0] == '-')	{	/* Look for any flags */
+			char *na = NULL;		/* next argument after flag, null if none */
+
+			if (argv[fa][2] != '\000')
+				na = &argv[fa][2];		/* next is directly after flag */
+			else {
+				if ((fa+1) < argc) {
+					if (argv[fa+1][0] != '-') {
+						nfa = fa + 1;
+						na = argv[nfa];		/* next is seperate non-flag argument */
+					}
+				}
+			}
+
+			/* Verbosity */
+			if (argv[fa][1] == 'v' || argv[fa][1] == 'V') {
+				verb = 1;
+			}
+			else if (argv[fa][1] == '?')
+				usage();
+			else 
+				usage();
+		}
+		else
+			break;
+	}
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(in_name,argv[fa++]);
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(link_name,argv[fa++]);
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(out_name,argv[fa++]);
+
+	/* Open up the files for reading */
+	if ((in_fp = new_icmFileStd_name(in_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",in_name);
+
+	if ((in_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = in_icco->read(in_icco,in_fp,0)) != 0)
+		error ("Read: %d, %s",rv,in_icco->err);
+
+
+	if ((link_fp = new_icmFileStd_name(link_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",link_name);
+
+	if ((link_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = link_icco->read(link_icco,link_fp,0)) != 0)
+		error ("Read: %d, %s",rv,link_icco->err);
+
+
+	if ((out_fp = new_icmFileStd_name(out_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",out_name);
+
+	if ((out_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = out_icco->read(out_icco,out_fp,0)) != 0)
+		error ("Read: %d, %s",rv,out_icco->err);
+
+
+	/* Get a PCS to Device conversion object */
+	if ((in_lu = in_icco->get_luobj(in_icco, icmBwd, icAbsoluteColorimetric, icSigLabData, icmLuOrdNorm)) == NULL) {
+		if ((in_lu = in_icco->get_luobj(in_icco, icmBwd, icmDefaultIntent, icSigLabData, icmLuOrdNorm)) == NULL)
+			error ("%d, %s",in_icco->errc, in_icco->err);
+	}
+
+	/* Get a Device to Device conversion object */
+	if ((link_lu = link_icco->get_luobj(link_icco, icmFwd, icmDefaultIntent, icSigLabData, icmLuOrdNorm)) == NULL)
+		error ("%d, %s",link_icco->errc, link_icco->err);
+
+	/* Get a Device to PCS conversion object */
+	if ((out_lu = out_icco->get_luobj(out_icco, icmFwd, icAbsoluteColorimetric, icSigLabData, icmLuOrdNorm)) == NULL) {
+		if ((out_lu = out_icco->get_luobj(out_icco, icmFwd, icmDefaultIntent, icSigLabData, icmLuOrdNorm)) == NULL)
+			error ("%d, %s",out_icco->errc, out_icco->err);
+	}
+
+	{
+		double xx[100], yy[PRES];
+		int i;
+		double tt[10];
+
+		for (i = 0; i < PRES; i++) {
+
+			tt[0] = 100.0 * i/(PRES-1.0);
+			tt[1] = tt[2] = 0.0;
+
+			xx[i] = tt[0];
+
+			if (verb)
+				printf(" %f %f %f -> ",tt[0],tt[1],tt[2]);
+
+			/* PCS to input device space */
+			if ((rv = in_lu->lookup(in_lu, tt, tt)) > 1)
+				error ("%d, %s",in_icco->errc,in_icco->err);
+
+
+			/* input device space to output device space */
+			if ((rv = link_lu->lookup(link_lu, tt, tt)) > 1)
+				error ("%d, %s",link_icco->errc,link_icco->err);
+
+			/* output device space to PCS */
+			if ((rv = out_lu->lookup(out_lu, tt, tt)) > 1)
+				error ("%d, %s",out_icco->errc,out_icco->err);
+
+			yy[i] = tt[0];
+
+			if (verb)
+				printf("%f %f %f\n",tt[0],tt[1],tt[2]);
+		}
+
+		if (do_plot(xx,yy,NULL,NULL,PRES) < 0)
+			error("do_plot returned -1!\n");
+
+	}
+
+	/* Done with lookup objects */
+	in_lu->del(in_lu);
+	link_lu->del(link_lu);
+	out_lu->del(out_lu);
+
+	in_icco->del(in_icco);
+	in_fp->del(in_fp);
+	link_icco->del(link_icco);
+	link_fp->del(link_fp);
+	out_icco->del(out_icco);
+	out_fp->del(out_fp);
+
+	return 0;
+}
+
+/* ------------------------------------------------ */
+/* Basic printf type error() and warning() routines */
+
+void
+error(char *fmt, ...)
+{
+	va_list args;
+
+	fprintf(stderr,"monoplot: Error - ");
+	va_start(args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end(args);
+	fprintf(stderr, "\n");
+	exit (-1);
+}
+
+void
+warning(char *fmt, ...)
+{
+	va_list args;
+
+	fprintf(stderr,"monoplot: Warning - ");
+	va_start(args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end(args);
+	fprintf(stderr, "\n");
+}
diff --git a/link/pathplot.c b/link/pathplot.c
new file mode 100644
index 0000000..fc12943
--- /dev/null
+++ b/link/pathplot.c
@@ -0,0 +1,281 @@
+
+/* 
+ * Argyll Color Management System
+ *
+ * Plot the L in vs. L out for a path through the
+ * input device space, for a given link.
+ *
+ * We are assuming RGB device input space !!!!
+ *
+ * Author:  Graeme W. Gill
+ * Date:    2002/1/28
+ * Version: 1.00
+ *
+ * Copyright 2002 Graeme W. Gill
+ *
+ * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
+ * see the License.txt file for licencing details.
+ */
+
+/* TTBD:
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <string.h>
+#include <math.h>
+#include "copyright.h"
+#include "aconfig.h"
+#include "numlib.h"
+#include "icc.h"
+#include "xicc.h"
+#include "plot.h"
+
+#define PRES 100
+
+static double start[13][4]   = {
+	{ 0.0, 0.0, 0.0, 0.0},
+	{ 0.0, 0.0, 0.0, 0.0},
+	{ 0.0, 0.0, 0.0, 0.0},
+	{ 0.0, 0.0, 0.0, 0.0},
+	{ 0.0, 0.0, 0.0, 0.0},
+	{ 0.0, 0.0, 0.0, 0.0},
+
+	{ 0.0, 0.0, 0.0, 0.0},
+
+	{ 1.0, 0.0, 0.0, 0.0},
+	{ 0.0, 1.0, 0.0, 0.0},
+	{ 0.0, 0.0, 1.0, 0.0},
+	{ 0.0, 1.0, 1.0, 0.0},
+	{ 1.0, 0.0, 1.0, 0.0},
+	{ 1.0, 1.0, 0.0, 0.0}
+};
+
+static double end[13][4]  = {
+	{ 1.0, 0.0, 0.0, 0.0},
+	{ 0.0, 1.0, 0.0, 0.0},
+	{ 0.0, 0.0, 1.0, 0.0},
+	{ 0.0, 1.0, 1.0, 0.0},
+	{ 1.0, 0.0, 1.0, 0.0},
+	{ 1.0, 1.0, 0.0, 0.0},
+
+	{ 1.0, 1.0, 1.0, 0.0},
+
+	{ 1.0, 1.0, 1.0, 0.0},
+	{ 1.0, 1.0, 1.0, 0.0},
+	{ 1.0, 1.0, 1.0, 0.0},
+	{ 1.0, 1.0, 1.0, 0.0},
+	{ 1.0, 1.0, 1.0, 0.0},
+	{ 1.0, 1.0, 1.0, 0.0}
+};
+
+static char *name[13] = {
+		"Black - Red", "Black - Green", "Black - Blue", 
+		"Black - Cyan", "Black - Magenta", "Black - Yellow", 
+		"Grey",
+		"Red - White", "Green - White", "Blue - White", 
+		"Cyan - White", "Magenta - White", "Yellow - White", 
+	};
+
+#define USE_JAB		/* Assume CRT in (2), print out (0) */
+
+/* ---------------------------------------- */
+
+void usage(void) {
+	fprintf(stderr,"Plot device space path L in/out curve from an ICC link file, Version %s\n",ARGYLL_VERSION_STR);
+	fprintf(stderr,"Author: Graeme W. Gill\n");
+	fprintf(stderr,"usage: pathplot inprof linkprof outprof\n");
+	fprintf(stderr," -v        verbose\n");
+	exit(1);
+}
+
+int
+main(
+	int argc,
+	char *argv[]
+) {
+	int fa, nfa;				/* argument we're looking at */
+	int verb = 0;
+	char in_name[100];
+	char link_name[100];
+	char out_name[100];
+	icmFile *in_fp, *link_fp, *out_fp;
+	icc *in_icco, *link_icco, *out_icco;
+	xicc *in_xicco, *out_xicco;
+	icmLuBase *link_lu;
+	icxLuBase *in_lu, *out_lu;
+	icColorSpaceSignature pcsor;	/* PCS to use */
+	icxViewCond ivc[1], ovc[1];
+	int rv = 0;
+
+	error_program = argv[0];
+
+	if (argc < 4)
+		usage();
+
+	/* Process the arguments */
+	for(fa = 1;fa < argc;fa++) {
+		nfa = fa;					/* skip to nfa if next argument is used */
+		if (argv[fa][0] == '-')	{	/* Look for any flags */
+			char *na = NULL;		/* next argument after flag, null if none */
+
+			if (argv[fa][2] != '\000')
+				na = &argv[fa][2];		/* next is directly after flag */
+			else {
+				if ((fa+1) < argc) {
+					if (argv[fa+1][0] != '-') {
+						nfa = fa + 1;
+						na = argv[nfa];		/* next is seperate non-flag argument */
+					}
+				}
+			}
+
+			/* Verbosity */
+			if (argv[fa][1] == 'v' || argv[fa][1] == 'V') {
+				verb = 1;
+			}
+			else if (argv[fa][1] == '?')
+				usage();
+			else 
+				usage();
+		}
+		else
+			break;
+	}
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(in_name,argv[fa++]);
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(link_name,argv[fa++]);
+
+	if (fa >= argc || argv[fa][0] == '-') usage();
+	strcpy(out_name,argv[fa++]);
+
+	/* Open up the files for reading */
+	if ((in_fp = new_icmFileStd_name(in_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",in_name);
+
+	if ((in_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = in_icco->read(in_icco,in_fp,0)) != 0)
+		error ("Read: %d, %s",rv,in_icco->err);
+
+	if ((in_xicco = new_xicc(in_icco)) == NULL)
+		error ("Creation of input profile xicc failed");
+
+
+	if ((link_fp = new_icmFileStd_name(link_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",link_name);
+
+	if ((link_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = link_icco->read(link_icco,link_fp,0)) != 0)
+		error ("Read: %d, %s",rv,link_icco->err);
+
+
+	if ((out_fp = new_icmFileStd_name(out_name,"r")) == NULL)
+		error ("Read: Can't open file '%s'",out_name);
+
+	if ((out_icco = new_icc()) == NULL)
+		error ("Read: Creation of ICC object failed");
+
+	if ((rv = out_icco->read(out_icco,out_fp,0)) != 0)
+		error ("Read: %d, %s",rv,out_icco->err);
+
+	if ((out_xicco = new_xicc(out_icco)) == NULL)
+		error ("Creation of output profile xicc failed");
+
+
+#ifdef USE_JAB
+	pcsor = icxSigJabData;		/* Use CIECAM as PCS */
+
+	if (xicc_enum_viewcond(in_xicco, ivc, -2, "mt", 0, NULL) == -999)	/* Set input at monitor in typical */
+		error ("%d, %s",in_xicco->errc, in_xicco->err);
+
+	if (xicc_enum_viewcond(out_xicco, ovc, -2, "pp", 0, NULL) == -999)	/* Set output at practical reflection print */
+		error ("%d, %s",out_xicco->errc, out_xicco->err);
+
+#else
+	pcsor = icSigLabData;		/* Default use Lab as PCS */
+#endif	/* !USE_JAB */
+
+	/* Device to PCS conversion object */
+	if ((in_lu = in_xicco->get_luobj(in_xicco, ICX_CLIP_NEAREST, icmFwd, icAbsoluteColorimetric, pcsor, icmLuOrdNorm, ivc, NULL)) == NULL) {
+		if ((in_lu = in_xicco->get_luobj(in_xicco, ICX_CLIP_NEAREST, icmBwd, icmDefaultIntent, pcsor, icmLuOrdNorm, ivc, NULL)) == NULL)
+			error ("%d, %s",in_xicco->errc, in_xicco->err);
+	}
+
+	/* Get a Device to Device conversion object */
+	if ((link_lu = link_icco->get_luobj(link_icco, icmFwd, icmDefaultIntent, pcsor, icmLuOrdNorm)) == NULL)
+		error ("%d, %s",link_icco->errc, link_icco->err);
+
+	/* Get a Device to PCS conversion object */
+	if ((out_lu = out_xicco->get_luobj(out_xicco, ICX_CLIP_NEAREST, icmFwd, icAbsoluteColorimetric, pcsor, icmLuOrdNorm, ovc, NULL)) == NULL) {
+		if ((out_lu = out_xicco->get_luobj(out_xicco, ICX_CLIP_NEAREST, icmFwd, icmDefaultIntent, pcsor, icmLuOrdNorm, ovc, NULL)) == NULL)
+			error ("%d, %s",out_xicco->errc, out_xicco->err);
+	}
+
+	{
+		double xx[PRES], yy[PRES];
+		int k, i, j;
+		double tt[10], tt2[10];
+
+		for (k = 0; k < 13; k++) {
+			printf("Doing %s\n",name[k]);
+
+			for (i = 0; i < PRES; i++) {
+				double frac = i/(PRES-1.0);
+
+				for (j = 0; j < 4; j++)
+					tt[j] = (end[k][j] - start[k][j]) * frac + start[k][j];
+
+				if (verb)
+					printf(" %f %f %f -> ",tt[0],tt[1],tt[2]);
+
+				/* input device space to PCS */
+				if ((rv = in_lu->lookup(in_lu, tt2, tt)) > 1)
+					error ("%d, %s",in_icco->errc,in_icco->err);
+
+				xx[i] = tt2[0];		/* L value */
+
+				/* input device space to output device space */
+				if ((rv = link_lu->lookup(link_lu, tt, tt)) > 1)
+					error ("%d, %s",link_icco->errc,link_icco->err);
+
+				/* output device space to PCS */
+				if ((rv = out_lu->lookup(out_lu, tt, tt)) > 1)
+					error ("%d, %s",out_icco->errc,out_icco->err);
+
+				yy[i] = tt[0];		/* L value */
+
+				if (verb)
+					printf("%f %f %f\n",tt[0],tt[1],tt[2]);
+			}
+
+			if (do_plot(xx,yy,NULL,NULL,PRES) < 0)
+				error("do_plot returned -1!\n");
+		}
+
+	}
+
+	/* Done with lookup objects */
+	in_lu->del(in_lu);
+	link_lu->del(link_lu);
+	out_lu->del(out_lu);
+
+	in_icco->del(in_icco);
+	in_fp->del(in_fp);
+	link_icco->del(link_icco);
+	link_fp->del(link_fp);
+	out_icco->del(out_icco);
+	out_fp->del(out_fp);
+
+	return 0;
+}
+