--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 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 General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is 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. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ 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.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ 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 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. Use with the GNU Affero General Public License.
+
+ 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 Affero 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 special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU 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 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 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 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 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 General Public License for more details.
+
+ You should have received a copy of the GNU 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 the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ 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 GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 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.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
--- /dev/null
+libimago
+========
+
+Overview
+--------
+Imago is a simple C library for reading and writing images in many different
+image file formats.
+
+Download
+--------
+Latest release: http://nuclear.mutantstargoat.com/sw/libimago/files/libimago-2.0.tar.gz
+
+Grab the source code from github: https://github.com/jtsiomb/libimago
+
+web site: http://nuclear.mutantstargoat.com/sw/libimago
+
+License
+-------
+
+Copyright (C) 2011-2015 John Tsiombikas <nuclear@member.fsf.org>
+
+You may freely use, modify and/or redistribute libimago, under the terms of the
+GNU Lesser General Public License (LGPL) version 3 (or at your option, any
+later version published by the Free Software Foundation). See COPYING_ and
+COPYING.LESSER_ for details.
+
+Usage example
+-------------
+
+heck out the example program under ``test/``, and the *heavily*
+commented ``imago2.h`` header file, to find out how to use libimago.
+
+The simplest way to load image data in RGBA 32bit is:
+
+.. code:: c
+
+ int width, height;
+ unsigned char *pixels = img_load_pixels("foo.png", &width, &height, IMG_FMT_RGBA32);
+ img_free_pixels(pixels);
+
+There's also an optional interface for loading an image and creating an OpenGL
+texture out of it in a single call:
+
+.. code:: c
+
+ unsigned int texture = img_gltexture_load("foo.png");
+
+.. _COPYING: http://www.gnu.org/licenses/gpl
+.. _COPYING.LESSER: http://www.gnu.org/licenses/lgpl
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <string.h>
+#include "imago2.h"
+
+/* pixel-format conversions are sub-optimal at the moment to avoid
+ * writing a lot of code. optimize at some point ?
+ */
+
+#define CLAMP(x, a, b) ((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
+
+struct pixel {
+ float r, g, b, a;
+};
+
+static void unpack_grey8(struct pixel *unp, void *pptr, int count);
+static void unpack_rgb24(struct pixel *unp, void *pptr, int count);
+static void unpack_rgba32(struct pixel *unp, void *pptr, int count);
+static void unpack_greyf(struct pixel *unp, void *pptr, int count);
+static void unpack_rgbf(struct pixel *unp, void *pptr, int count);
+static void unpack_rgbaf(struct pixel *unp, void *pptr, int count);
+
+static void pack_grey8(void *pptr, struct pixel *unp, int count);
+static void pack_rgb24(void *pptr, struct pixel *unp, int count);
+static void pack_rgba32(void *pptr, struct pixel *unp, int count);
+static void pack_greyf(void *pptr, struct pixel *unp, int count);
+static void pack_rgbf(void *pptr, struct pixel *unp, int count);
+static void pack_rgbaf(void *pptr, struct pixel *unp, int count);
+
+/* XXX keep in sync with enum img_fmt at imago2.h */
+static void (*unpack[])(struct pixel*, void*, int) = {
+ unpack_grey8,
+ unpack_rgb24,
+ unpack_rgba32,
+ unpack_greyf,
+ unpack_rgbf,
+ unpack_rgbaf
+};
+
+/* XXX keep in sync with enum img_fmt at imago2.h */
+static void (*pack[])(void*, struct pixel*, int) = {
+ pack_grey8,
+ pack_rgb24,
+ pack_rgba32,
+ pack_greyf,
+ pack_rgbf,
+ pack_rgbaf
+};
+
+
+int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
+{
+ struct pixel pbuf[8];
+ int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
+ int i, num_pix = img->width * img->height;
+ int num_iter = num_pix / bufsz;
+ char *sptr, *dptr;
+ struct img_pixmap nimg;
+
+ if(img->fmt == tofmt) {
+ return 0; /* nothing to do */
+ }
+
+ img_init(&nimg);
+ if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
+ img_destroy(&nimg);
+ return -1;
+ }
+
+ sptr = img->pixels;
+ dptr = nimg.pixels;
+
+ for(i=0; i<num_iter; i++) {
+ unpack[img->fmt](pbuf, sptr, bufsz);
+ pack[tofmt](dptr, pbuf, bufsz);
+
+ sptr += bufsz * img->pixelsz;
+ dptr += bufsz * nimg.pixelsz;
+ }
+
+ img_copy(img, &nimg);
+ img_destroy(&nimg);
+ return 0;
+}
+
+/* the following functions *could* benefit from SIMD */
+
+static void unpack_grey8(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = unp->g = unp->b = (float)*pix++ / 255.0;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgb24(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = (float)*pix++ / 255.0;
+ unp->g = (float)*pix++ / 255.0;
+ unp->b = (float)*pix++ / 255.0;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgba32(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = (float)*pix++ / 255.0;
+ unp->g = (float)*pix++ / 255.0;
+ unp->b = (float)*pix++ / 255.0;
+ unp->a = (float)*pix++ / 255.0;
+ unp++;
+ }
+}
+
+static void unpack_greyf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = unp->g = unp->b = *pix++;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = *pix++;
+ unp->g = *pix++;
+ unp->b = *pix++;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = *pix++;
+ unp->g = *pix++;
+ unp->b = *pix++;
+ unp->a = *pix++;
+ unp++;
+ }
+}
+
+
+static void pack_grey8(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
+ *pix++ = CLAMP(lum, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_rgb24(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int r = (int)(unp->r * 255.0);
+ int g = (int)(unp->g * 255.0);
+ int b = (int)(unp->b * 255.0);
+
+ *pix++ = CLAMP(r, 0, 255);
+ *pix++ = CLAMP(g, 0, 255);
+ *pix++ = CLAMP(b, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_rgba32(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int r = (int)(unp->r * 255.0);
+ int g = (int)(unp->g * 255.0);
+ int b = (int)(unp->b * 255.0);
+ int a = (int)(unp->a * 255.0);
+
+ *pix++ = CLAMP(r, 0, 255);
+ *pix++ = CLAMP(g, 0, 255);
+ *pix++ = CLAMP(b, 0, 255);
+ *pix++ = CLAMP(a, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_greyf(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ *pix++ = (unp->r + unp->g + unp->b) / 3.0;
+ unp++;
+ }
+}
+
+static void pack_rgbf(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ *pix++ = unp->r;
+ *pix++ = unp->g;
+ *pix++ = unp->b;
+ unp++;
+ }
+}
+
+static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
+{
+ memcpy(pptr, unp, count * sizeof *unp);
+}
+
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- JPEG module -- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef WIN32
+#include <windows.h>
+#define HAVE_BOOLEAN
+#endif
+
+#include <jpeglib.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+#define INPUT_BUF_SIZE 512
+#define OUTPUT_BUF_SIZE 512
+
+/* data source manager: adapted from jdatasrc.c */
+struct src_mgr {
+ struct jpeg_source_mgr pub;
+
+ struct img_io *io;
+ unsigned char buffer[INPUT_BUF_SIZE];
+ int start_of_file;
+};
+
+/* data destination manager: adapted from jdatadst.c */
+struct dst_mgr {
+ struct jpeg_destination_mgr pub;
+
+ struct img_io *io;
+ unsigned char buffer[OUTPUT_BUF_SIZE];
+};
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+/* read source functions */
+static void init_source(j_decompress_ptr jd);
+static boolean fill_input_buffer(j_decompress_ptr jd);
+static void skip_input_data(j_decompress_ptr jd, long num_bytes);
+static void term_source(j_decompress_ptr jd);
+
+/* write destination functions */
+static void init_destination(j_compress_ptr jc);
+static boolean empty_output_buffer(j_compress_ptr jc);
+static void term_destination(j_compress_ptr jc);
+
+int img_register_jpeg(void)
+{
+ static struct ftype_module mod = {".jpg", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ unsigned char sig[10];
+
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(sig, 10, io->uptr) < 10) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(memcmp(sig, "\xff\xd8\xff\xe0", 4) != 0 && memcmp(sig, "\xff\xd8\xff\xe1", 4) != 0
+ && memcmp(sig, "\xff\xd8\xff\xdb", 4) != 0 && memcmp(sig + 6, "JFIF", 4) != 0) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return 0;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ int i, nlines = 0;
+ struct jpeg_decompress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ struct src_mgr src;
+ unsigned char **scanlines;
+
+ io->seek(0, SEEK_CUR, io->uptr);
+
+ cinfo.err = jpeg_std_error(&jerr); /* XXX change... */
+ jpeg_create_decompress(&cinfo);
+
+ src.pub.init_source = init_source;
+ src.pub.fill_input_buffer = fill_input_buffer;
+ src.pub.skip_input_data = skip_input_data;
+ src.pub.resync_to_restart = jpeg_resync_to_restart;
+ src.pub.term_source = term_source;
+ src.pub.next_input_byte = 0;
+ src.pub.bytes_in_buffer = 0;
+ src.io = io;
+ cinfo.src = (struct jpeg_source_mgr*)&src;
+
+ jpeg_read_header(&cinfo, 1);
+ cinfo.out_color_space = JCS_RGB;
+
+ if(img_set_pixels(img, cinfo.image_width, cinfo.image_height, IMG_FMT_RGB24, 0) == -1) {
+ jpeg_destroy_decompress(&cinfo);
+ return -1;
+ }
+
+ if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
+ jpeg_destroy_decompress(&cinfo);
+ return -1;
+ }
+ scanlines[0] = img->pixels;
+ for(i=1; i<img->height; i++) {
+ scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
+ }
+
+ jpeg_start_decompress(&cinfo);
+ while(nlines < img->height) {
+ int res = jpeg_read_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
+ nlines += res;
+ }
+ jpeg_finish_decompress(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+
+ free(scanlines);
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ int i, nlines = 0;
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ struct dst_mgr dest;
+ struct img_pixmap tmpimg;
+ unsigned char **scanlines;
+
+ img_init(&tmpimg);
+
+ if(img->fmt != IMG_FMT_RGB24) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ scanlines[0] = img->pixels;
+ for(i=1; i<img->height; i++) {
+ scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
+ }
+
+ cinfo.err = jpeg_std_error(&jerr); /* XXX */
+ jpeg_create_compress(&cinfo);
+
+ dest.pub.init_destination = init_destination;
+ dest.pub.empty_output_buffer = empty_output_buffer;
+ dest.pub.term_destination = term_destination;
+ dest.io = io;
+ cinfo.dest = (struct jpeg_destination_mgr*)&dest;
+
+ cinfo.image_width = img->width;
+ cinfo.image_height = img->height;
+ cinfo.input_components = 3;
+ cinfo.in_color_space = JCS_RGB;
+
+ jpeg_set_defaults(&cinfo);
+
+ jpeg_start_compress(&cinfo, 1);
+ while(nlines < img->height) {
+ int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
+ nlines += res;
+ }
+ jpeg_finish_compress(&cinfo);
+ jpeg_destroy_compress(&cinfo);
+
+ free(scanlines);
+ img_destroy(&tmpimg);
+ return 0;
+}
+
+/* -- read source functions --
+ * the following functions are adapted from jdatasrc.c in jpeglib
+ */
+static void init_source(j_decompress_ptr jd)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+ src->start_of_file = 1;
+}
+
+static boolean fill_input_buffer(j_decompress_ptr jd)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+ size_t nbytes;
+
+ nbytes = src->io->read(src->buffer, INPUT_BUF_SIZE, src->io->uptr);
+
+ if(nbytes <= 0) {
+ if(src->start_of_file) {
+ return 0;
+ }
+ /* insert a fake EOI marker */
+ src->buffer[0] = 0xff;
+ src->buffer[1] = JPEG_EOI;
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = 0;
+ return 1;
+}
+
+static void skip_input_data(j_decompress_ptr jd, long num_bytes)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+
+ if(num_bytes > 0) {
+ while(num_bytes > (long)src->pub.bytes_in_buffer) {
+ num_bytes -= (long)src->pub.bytes_in_buffer;
+ fill_input_buffer(jd);
+ }
+ src->pub.next_input_byte += (size_t)num_bytes;
+ src->pub.bytes_in_buffer -= (size_t)num_bytes;
+ }
+}
+
+static void term_source(j_decompress_ptr jd)
+{
+ /* nothing to see here, move along */
+}
+
+
+/* -- write destination functions --
+ * the following functions are adapted from jdatadst.c in jpeglib
+ */
+static void init_destination(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+static boolean empty_output_buffer(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+
+ if(dest->io->write(dest->buffer, OUTPUT_BUF_SIZE, dest->io->uptr) != OUTPUT_BUF_SIZE) {
+ return 0;
+ }
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+ return 1;
+}
+
+static void term_destination(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* write any remaining data in the buffer */
+ if(datacount > 0) {
+ dest->io->write(dest->buffer, datacount, dest->io->uptr);
+ }
+ /* XXX flush? ... */
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- PNG module -- */
+
+#include <stdlib.h>
+#include <string.h>
+#include <png.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+static int check_file(struct img_io *io);
+static int read_file(struct img_pixmap *img, struct img_io *io);
+static int write_file(struct img_pixmap *img, struct img_io *io);
+
+static void read_func(png_struct *png, unsigned char *data, size_t len);
+static void write_func(png_struct *png, unsigned char *data, size_t len);
+static void flush_func(png_struct *png);
+
+static int png_type_to_fmt(int color_type, int channel_bits);
+static int fmt_to_png_type(enum img_fmt fmt);
+
+
+int img_register_png(void)
+{
+ static struct ftype_module mod = {".png", check_file, read_file, write_file};
+ return img_register_module(&mod);
+}
+
+static int check_file(struct img_io *io)
+{
+ unsigned char sig[8];
+ int res;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(sig, 8, io->uptr) < 8) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ res = png_sig_cmp(sig, 0, 8) == 0 ? 0 : -1;
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int read_file(struct img_pixmap *img, struct img_io *io)
+{
+ png_struct *png;
+ png_info *info;
+ int channel_bits, color_type, ilace_type, compression, filtering, fmt;
+ png_uint_32 xsz, ysz;
+
+ if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+ return -1;
+ }
+
+ if(!(info = png_create_info_struct(png))) {
+ png_destroy_read_struct(&png, 0, 0);
+ return -1;
+ }
+
+ if(setjmp(png_jmpbuf(png))) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+ png_set_read_fn(png, io, read_func);
+ png_set_sig_bytes(png, 0);
+ png_read_png(png, info, 0, 0);
+
+ png_get_IHDR(png, info, &xsz, &ysz, &channel_bits, &color_type, &ilace_type,
+ &compression, &filtering);
+ if((fmt = png_type_to_fmt(color_type, channel_bits)) == -1) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+
+ if(channel_bits == 8) {
+ unsigned int i;
+ unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
+ unsigned char *dest = img->pixels;
+
+ for(i=0; i<ysz; i++) {
+ memcpy(dest, lineptr[i], xsz * img->pixelsz);
+ dest += xsz * img->pixelsz;
+ }
+ } else {
+ unsigned int i, j, num_elem;
+ unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
+ float *dest = img->pixels;
+
+ num_elem = img->pixelsz / sizeof(float);
+ for(i=0; i<ysz; i++) {
+ for(j=0; j<xsz * num_elem; j++) {
+ unsigned short val = (lineptr[i][j * 2] << 8) | lineptr[i][j * 2 + 1];
+ *dest++ = (float)val / 65535.0;
+ }
+ }
+ }
+
+
+ png_destroy_read_struct(&png, &info, 0);
+ return 0;
+}
+
+
+static int write_file(struct img_pixmap *img, struct img_io *io)
+{
+ png_struct *png;
+ png_info *info;
+ png_text txt;
+ struct img_pixmap tmpimg;
+ unsigned char **rows;
+ unsigned char *pixptr;
+ int i, coltype;
+
+ img_init(&tmpimg);
+
+ if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+ return -1;
+ }
+ if(!(info = png_create_info_struct(png))) {
+ png_destroy_write_struct(&png, 0);
+ return -1;
+ }
+
+ /* if the input image is floating-point, we need to convert it to integer */
+ if(img_is_float(img)) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_to_integer(&tmpimg) == -1) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ txt.compression = PNG_TEXT_COMPRESSION_NONE;
+ txt.key = "Software";
+ txt.text = "libimago2";
+ txt.text_length = 0;
+
+ if(setjmp(png_jmpbuf(png))) {
+ png_destroy_write_struct(&png, &info);
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ png_set_write_fn(png, io, write_func, flush_func);
+
+ coltype = fmt_to_png_type(img->fmt);
+ png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ png_set_text(png, info, &txt, 1);
+
+ if(!(rows = malloc(img->height * sizeof *rows))) {
+ png_destroy_write_struct(&png, &info);
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ pixptr = img->pixels;
+ for(i=0; i<img->height; i++) {
+ rows[i] = pixptr;
+ pixptr += img->width * img->pixelsz;
+ }
+ png_set_rows(png, info, rows);
+
+ png_write_png(png, info, 0, 0);
+ png_write_end(png, info);
+ png_destroy_write_struct(&png, &info);
+
+ free(rows);
+
+ img_destroy(&tmpimg);
+ return 0;
+}
+
+static void read_func(png_struct *png, unsigned char *data, size_t len)
+{
+ struct img_io *io = (struct img_io*)png_get_io_ptr(png);
+
+ if(io->read(data, len, io->uptr) == -1) {
+ longjmp(png_jmpbuf(png), 1);
+ }
+}
+
+static void write_func(png_struct *png, unsigned char *data, size_t len)
+{
+ struct img_io *io = (struct img_io*)png_get_io_ptr(png);
+
+ if(io->write(data, len, io->uptr) == -1) {
+ longjmp(png_jmpbuf(png), 1);
+ }
+}
+
+static void flush_func(png_struct *png)
+{
+ /* XXX does it matter that we can't flush? */
+}
+
+static int png_type_to_fmt(int color_type, int channel_bits)
+{
+ /* only 8 and 16 bits per channel ar supported at the moment */
+ if(channel_bits != 8 && channel_bits != 16) {
+ return -1;
+ }
+
+ switch(color_type) {
+ case PNG_COLOR_TYPE_RGB:
+ return channel_bits == 16 ? IMG_FMT_RGBF : IMG_FMT_RGB24;
+
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ return channel_bits == 16 ? IMG_FMT_RGBAF : IMG_FMT_RGBA32;
+
+ case PNG_COLOR_TYPE_GRAY:
+ return channel_bits == 16 ? IMG_FMT_GREYF : IMG_FMT_GREY8;
+
+ default:
+ break;
+ }
+ return -1;
+}
+
+static int fmt_to_png_type(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return PNG_COLOR_TYPE_GRAY;
+
+ case IMG_FMT_RGB24:
+ return PNG_COLOR_TYPE_RGB;
+
+ case IMG_FMT_RGBA32:
+ return PNG_COLOR_TYPE_RGBA;
+
+ default:
+ break;
+ }
+ return -1;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- Portable Pixmap (PPM) module -- */
+
+#include <string.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+int img_register_ppm(void)
+{
+ static struct ftype_module mod = {".ppm", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ char id[2];
+ int res = -1;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(id, 2, io->uptr) < 2) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(id[0] == 'P' && (id[1] == '6' || id[1] == '3')) {
+ res = 0;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static char *iofgets(char *buf, int size, struct img_io *io)
+{
+ int c;
+ char *ptr = buf;
+
+ while(--size > 0 && (c = iofgetc(io)) != -1) {
+ *ptr++ = c;
+ if(c == '\n') break;
+ }
+ *ptr = 0;
+
+ return ptr == buf ? 0 : buf;
+}
+
+/* TODO: implement P3 reading */
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ char buf[256];
+ int xsz, ysz, maxval, got_hdrlines = 1;
+
+ if(!iofgets(buf, sizeof buf, io)) {
+ return -1;
+ }
+ if(!(buf[0] == 'P' && (buf[1] == '6' || buf[1] == '3'))) {
+ return -1;
+ }
+
+ while(got_hdrlines < 3 && iofgets(buf, sizeof buf, io)) {
+ if(buf[0] == '#') continue;
+
+ switch(got_hdrlines) {
+ case 1:
+ if(sscanf(buf, "%d %d\n", &xsz, &ysz) < 2) {
+ return -1;
+ }
+ break;
+
+ case 2:
+ if(sscanf(buf, "%d\n", &maxval) < 1) {
+ return -1;
+ }
+ default:
+ break;
+ }
+ got_hdrlines++;
+ }
+
+ if(xsz < 1 || ysz < 1 || maxval != 255) {
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGB24, 0) == -1) {
+ return -1;
+ }
+
+ if(io->read(img->pixels, xsz * ysz * 3, io->uptr) < (unsigned int)(xsz * ysz * 3)) {
+ return -1;
+ }
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ int sz;
+ char buf[256];
+ struct img_pixmap tmpimg;
+
+ img_init(&tmpimg);
+
+ if(img->fmt != IMG_FMT_RGB24) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ sprintf(buf, "P6\n#written by libimago2\n%d %d\n255\n", img->width, img->height);
+ if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ sz = img->width * img->height * 3;
+ if(io->write(img->pixels, sz, io->uptr) < (unsigned int)sz) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ img_destroy(&tmpimg);
+ return 0;
+}
--- /dev/null
+/* This file contains code to read and write four byte rgbe file format
+ * developed by Greg Ward. It handles the conversions between rgbe and
+ * pixels consisting of floats. The data is assumed to be an array of floats.
+ * By default there are three floats per pixel in the order red, green, blue.
+ * (RGBE_DATA_??? values control this.)
+ *
+ * written by Bruce Walter (bjw@graphics.cornell.edu) 5/26/95
+ * based on code written by Greg Ward
+ * minor modifications by John Tsiombikas (nuclear@member.fsf.org) apr.9 2007
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#include <errno.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+
+typedef struct {
+ int valid; /* indicate which fields are valid */
+ char programtype[16]; /* listed at beginning of file to identify it
+ * after "#?". defaults to "RGBE" */
+ float gamma; /* image has already been gamma corrected with
+ * given gamma. defaults to 1.0 (no correction) */
+ float exposure; /* a value of 1.0 in an image corresponds to
+ * <exposure> watts/steradian/m^2.
+ * defaults to 1.0 */
+} rgbe_header_info;
+
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info);
+static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines);
+
+
+int img_register_rgbe(void)
+{
+ static struct ftype_module mod = {".rgbe", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ int xsz, ysz, res;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ rgbe_header_info hdr;
+ res = rgbe_read_header(io, &xsz, &ysz, &hdr);
+
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ int xsz, ysz;
+ rgbe_header_info hdr;
+
+ if(rgbe_read_header(io, &xsz, &ysz, &hdr) == -1) {
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGBF, 0) == -1) {
+ return -1;
+ }
+ if(rgbe_read_pixels_rle(io, img->pixels, xsz, ysz) == -1) {
+ return -1;
+ }
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ return -1; /* TODO */
+}
+
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static char *iofgets(char *buf, int size, struct img_io *io)
+{
+ int c;
+ char *ptr = buf;
+
+ while(--size > 0 && (c = iofgetc(io)) != -1) {
+ *ptr++ = c;
+ if(c == '\n') break;
+ }
+ *ptr = 0;
+
+ return ptr == buf ? 0 : buf;
+}
+
+
+/* flags indicating which fields in an rgbe_header_info are valid */
+#define RGBE_VALID_PROGRAMTYPE 0x01
+#define RGBE_VALID_GAMMA 0x02
+#define RGBE_VALID_EXPOSURE 0x04
+
+/* return codes for rgbe routines */
+#define RGBE_RETURN_SUCCESS 0
+#define RGBE_RETURN_FAILURE -1
+
+
+#if defined(__cplusplus) || defined(GNUC) || __STDC_VERSION >= 199901L
+#define INLINE inline
+#else
+#define INLINE
+#endif
+
+/* offsets to red, green, and blue components in a data (float) pixel */
+#define RGBE_DATA_RED 0
+#define RGBE_DATA_GREEN 1
+#define RGBE_DATA_BLUE 2
+
+/* number of floats per pixel */
+#define RGBE_DATA_SIZE 3
+
+enum rgbe_error_codes {
+ rgbe_read_error,
+ rgbe_write_error,
+ rgbe_format_error,
+ rgbe_memory_error
+};
+
+
+/* default error routine. change this to change error handling */
+static int rgbe_error(int rgbe_error_code, char *msg)
+{
+ switch (rgbe_error_code) {
+ case rgbe_read_error:
+ fprintf(stderr, "RGBE read error: %s\n", strerror(errno));
+ break;
+
+ case rgbe_write_error:
+ fprintf(stderr, "RGBE write error: %s\n", strerror(errno));
+ break;
+
+ case rgbe_format_error:
+ fprintf(stderr, "RGBE bad file format: %s\n", msg);
+ break;
+
+ default:
+ case rgbe_memory_error:
+ fprintf(stderr, "RGBE error: %s\n", msg);
+ }
+ return RGBE_RETURN_FAILURE;
+}
+
+/* standard conversion from float pixels to rgbe pixels */
+/*static INLINE void float2rgbe(unsigned char rgbe[4], float red, float green, float blue)
+{
+ float v;
+ int e;
+
+ v = red;
+ if(green > v)
+ v = green;
+ if(blue > v)
+ v = blue;
+ if(v < 1e-32) {
+ rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+ } else {
+ v = frexp(v, &e) * 256.0 / v;
+ rgbe[0] = (unsigned char)(red * v);
+ rgbe[1] = (unsigned char)(green * v);
+ rgbe[2] = (unsigned char)(blue * v);
+ rgbe[3] = (unsigned char)(e + 128);
+ }
+}*/
+
+/* standard conversion from rgbe to float pixels */
+/* note: Ward uses ldexp(col+0.5,exp-(128+8)). However we wanted pixels */
+/* in the range [0,1] to map back into the range [0,1]. */
+static INLINE void rgbe2float(float *red, float *green, float *blue, unsigned char rgbe[4])
+{
+ float f;
+
+ if(rgbe[3]) { /*nonzero pixel */
+ f = ldexp(1.0, rgbe[3] - (int)(128 + 8));
+ *red = rgbe[0] * f;
+ *green = rgbe[1] * f;
+ *blue = rgbe[2] * f;
+ } else
+ *red = *green = *blue = 0.0;
+}
+
+#if 0
+/* default minimal header. modify if you want more information in header */
+static int rgbe_write_header(FILE * fp, int width, int height, rgbe_header_info * info)
+{
+ char *programtype = "RGBE";
+
+ if(info && (info->valid & RGBE_VALID_PROGRAMTYPE))
+ programtype = info->programtype;
+ if(fprintf(fp, "#?%s\n", programtype) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ /* The #? is to identify file type, the programtype is optional. */
+ if(info && (info->valid & RGBE_VALID_GAMMA)) {
+ if(fprintf(fp, "GAMMA=%g\n", info->gamma) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ if(info && (info->valid & RGBE_VALID_EXPOSURE)) {
+ if(fprintf(fp, "EXPOSURE=%g\n", info->exposure) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ if(fprintf(fp, "FORMAT=32-bit_rle_rgbe\n\n") < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ if(fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+/* minimal header reading. modify if you want to parse more information */
+static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info)
+{
+ char buf[128];
+ float tempf;
+ int i;
+
+ if(info) {
+ info->valid = 0;
+ info->programtype[0] = 0;
+ info->gamma = info->exposure = 1.0;
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == NULL)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if((buf[0] != '#') || (buf[1] != '?')) {
+ /* if you want to require the magic token then uncomment the next line */
+ /*return rgbe_error(rgbe_format_error,"bad initial token"); */
+ } else if(info) {
+ info->valid |= RGBE_VALID_PROGRAMTYPE;
+ for(i = 0; i < sizeof(info->programtype) - 1; i++) {
+ if((buf[i + 2] == 0) || isspace(buf[i + 2]))
+ break;
+ info->programtype[i] = buf[i + 2];
+ }
+ info->programtype[i] = 0;
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ for(;;) {
+ if((buf[0] == 0) || (buf[0] == '\n'))
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "no FORMAT specifier found");*/
+ else if(strcmp(buf, "FORMAT=32-bit_rle_rgbe\n") == 0)
+ break; /* format found so break out of loop */
+ else if(info && (sscanf(buf, "GAMMA=%g", &tempf) == 1)) {
+ info->gamma = tempf;
+ info->valid |= RGBE_VALID_GAMMA;
+ } else if(info && (sscanf(buf, "EXPOSURE=%g", &tempf) == 1)) {
+ info->exposure = tempf;
+ info->valid |= RGBE_VALID_EXPOSURE;
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if(strcmp(buf, "\n") != 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing blank line after FORMAT specifier");*/
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if(sscanf(buf, "-Y %d +X %d", height, width) < 2)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing image size specifier");*/
+ return RGBE_RETURN_SUCCESS;
+}
+
+#if 0
+/* simple write routine that does not use run length encoding */
+
+/* These routines can be made faster by allocating a larger buffer and
+ fread-ing and fwrite-ing the data in larger chunks */
+static int rgbe_write_pixels(FILE * fp, float *data, int numpixels)
+{
+ unsigned char rgbe[4];
+
+ while(numpixels-- > 0) {
+ float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
+ data += RGBE_DATA_SIZE;
+ if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+/* simple read routine. will not correctly handle run length encoding */
+static int rgbe_read_pixels(struct img_io *io, float *data, int numpixels)
+{
+ unsigned char rgbe[4];
+
+ while(numpixels-- > 0) {
+ if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1)
+ return rgbe_error(rgbe_read_error, NULL);
+ rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
+ data += RGBE_DATA_SIZE;
+ }
+ return RGBE_RETURN_SUCCESS;
+}
+
+#if 0
+/* The code below is only needed for the run-length encoded files. */
+
+/* Run length encoding adds considerable complexity but does */
+
+/* save some space. For each scanline, each channel (r,g,b,e) is */
+
+/* encoded separately for better compression. */
+
+static int rgbe_write_bytes_rle(struct img_io *io, unsigned char *data, int numbytes)
+{
+#define MINRUNLENGTH 4
+ int cur, beg_run, run_count, old_run_count, nonrun_count;
+ unsigned char buf[2];
+
+ cur = 0;
+ while(cur < numbytes) {
+ beg_run = cur;
+ /* find next run of length at least 4 if one exists */
+ run_count = old_run_count = 0;
+ while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
+ beg_run += run_count;
+ old_run_count = run_count;
+ run_count = 1;
+ while((beg_run + run_count < numbytes) && (run_count < 127)
+ && (data[beg_run] == data[beg_run + run_count]))
+ run_count++;
+ }
+ /* if data before next big run is a short run then write it as such */
+ if((old_run_count > 1) && (old_run_count == beg_run - cur)) {
+ buf[0] = 128 + old_run_count; /*write short run */
+ buf[1] = data[cur];
+ if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur = beg_run;
+ }
+ /* write out bytes until we reach the start of the next run */
+ while(cur < beg_run) {
+ nonrun_count = beg_run - cur;
+ if(nonrun_count > 128)
+ nonrun_count = 128;
+ buf[0] = nonrun_count;
+ if(fwrite(buf, sizeof(buf[0]), 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ if(fwrite(&data[cur], sizeof(data[0]) * nonrun_count, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur += nonrun_count;
+ }
+ /* write out next run if one was found */
+ if(run_count >= MINRUNLENGTH) {
+ buf[0] = 128 + run_count;
+ buf[1] = data[beg_run];
+ if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur += run_count;
+ }
+ }
+ return RGBE_RETURN_SUCCESS;
+#undef MINRUNLENGTH
+}
+
+static int rgbe_write_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
+{
+ unsigned char rgbe[4];
+ unsigned char *buffer;
+ int i, err;
+
+ if((scanline_width < 8) || (scanline_width > 0x7fff))
+ /* run length encoding is not allowed so write flat */
+ return rgbe_write_pixels(io, data, scanline_width * num_scanlines);
+ buffer = (unsigned char *)malloc(sizeof(unsigned char) * 4 * scanline_width);
+ if(buffer == NULL)
+ /* no buffer space so write flat */
+ return rgbe_write_pixels(fp, data, scanline_width * num_scanlines);
+ while(num_scanlines-- > 0) {
+ rgbe[0] = 2;
+ rgbe[1] = 2;
+ rgbe[2] = scanline_width >> 8;
+ rgbe[3] = scanline_width & 0xFF;
+ if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
+ free(buffer);
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ for(i = 0; i < scanline_width; i++) {
+ float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
+ buffer[i] = rgbe[0];
+ buffer[i + scanline_width] = rgbe[1];
+ buffer[i + 2 * scanline_width] = rgbe[2];
+ buffer[i + 3 * scanline_width] = rgbe[3];
+ data += RGBE_DATA_SIZE;
+ }
+ /* write out each of the four channels separately run length encoded */
+ /* first red, then green, then blue, then exponent */
+ for(i = 0; i < 4; i++) {
+ if((err = rgbe_write_bytes_rle(fp, &buffer[i * scanline_width],
+ scanline_width)) != RGBE_RETURN_SUCCESS) {
+ free(buffer);
+ return err;
+ }
+ }
+ }
+ free(buffer);
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
+{
+ unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
+ int i, count;
+ unsigned char buf[2];
+
+ if((scanline_width < 8) || (scanline_width > 0x7fff))
+ /* run length encoding is not allowed so read flat */
+ return rgbe_read_pixels(io, data, scanline_width * num_scanlines);
+ scanline_buffer = NULL;
+ /* read in each successive scanline */
+ while(num_scanlines > 0) {
+ if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ if((rgbe[0] != 2) || (rgbe[1] != 2) || (rgbe[2] & 0x80)) {
+ /* this file is not run length encoded */
+ rgbe2float(&data[0], &data[1], &data[2], rgbe);
+ data += RGBE_DATA_SIZE;
+ free(scanline_buffer);
+ return rgbe_read_pixels(io, data, scanline_width * num_scanlines - 1);
+ }
+ if((((int)rgbe[2]) << 8 | rgbe[3]) != scanline_width) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "wrong scanline width");
+ }
+ if(scanline_buffer == NULL)
+ scanline_buffer = (unsigned char *)
+ malloc(sizeof(unsigned char) * 4 * scanline_width);
+ if(scanline_buffer == NULL)
+ return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
+
+ ptr = &scanline_buffer[0];
+ /* read each of the four channels for the scanline into the buffer */
+ for(i = 0; i < 4; i++) {
+ ptr_end = &scanline_buffer[(i + 1) * scanline_width];
+ while(ptr < ptr_end) {
+ if(io->read(buf, sizeof(buf[0]) * 2, io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ if(buf[0] > 128) {
+ /* a run of the same value */
+ count = buf[0] - 128;
+ if((count == 0) || (count > ptr_end - ptr)) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "bad scanline data");
+ }
+ while(count-- > 0)
+ *ptr++ = buf[1];
+ } else {
+ /* a non-run */
+ count = buf[0];
+ if((count == 0) || (count > ptr_end - ptr)) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "bad scanline data");
+ }
+ *ptr++ = buf[1];
+ if(--count > 0) {
+ if(io->read(ptr, sizeof(*ptr) * count, io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ ptr += count;
+ }
+ }
+ }
+ }
+ /* now convert data from buffer into floats */
+ for(i = 0; i < scanline_width; i++) {
+ rgbe[0] = scanline_buffer[i];
+ rgbe[1] = scanline_buffer[i + scanline_width];
+ rgbe[2] = scanline_buffer[i + 2 * scanline_width];
+ rgbe[3] = scanline_buffer[i + 3 * scanline_width];
+ rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
+ data += RGBE_DATA_SIZE;
+ }
+ num_scanlines--;
+ }
+ free(scanline_buffer);
+ return RGBE_RETURN_SUCCESS;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010-2015 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- Targa (tga) module -- */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+
+#if defined(__i386__) || defined(__ia64__) || defined(WIN32) || \
+ (defined(__alpha__) || defined(__alpha)) || \
+ defined(__arm__) || \
+ (defined(__mips__) && defined(__MIPSEL__)) || \
+ defined(__SYMBIAN32__) || \
+ defined(__x86_64__) || \
+ defined(__LITTLE_ENDIAN__)
+/* little endian */
+#define read_int16_le(f) read_int16(f)
+#else
+/* big endian */
+#define read_int16_le(f) read_int16_inv(f)
+#endif /* endian check */
+
+
+enum {
+ IMG_NONE,
+ IMG_CMAP,
+ IMG_RGBA,
+ IMG_BW,
+
+ IMG_RLE_CMAP = 9,
+ IMG_RLE_RGBA,
+ IMG_RLE_BW
+};
+
+#define IS_RLE(x) ((x) >= IMG_RLE_CMAP)
+#define IS_RGBA(x) ((x) == IMG_RGBA || (x) == IMG_RLE_RGBA)
+
+
+struct tga_header {
+ uint8_t idlen; /* id field length */
+ uint8_t cmap_type; /* color map type (0:no color map, 1:color map present) */
+ uint8_t img_type; /* image type:
+ * 0: no image data
+ * 1: uncomp. color-mapped 9: RLE color-mapped
+ * 2: uncomp. true color 10: RLE true color
+ * 3: uncomp. black/white 11: RLE black/white */
+ uint16_t cmap_first; /* color map first entry index */
+ uint16_t cmap_len; /* color map length */
+ uint8_t cmap_entry_sz; /* color map entry size */
+ uint16_t img_x; /* X-origin of the image */
+ uint16_t img_y; /* Y-origin of the image */
+ uint16_t img_width; /* image width */
+ uint16_t img_height; /* image height */
+ uint8_t img_bpp; /* bits per pixel */
+ uint8_t img_desc; /* descriptor:
+ * bits 0 - 3: alpha or overlay bits
+ * bits 5 & 4: origin (0 = bottom/left, 1 = top/right)
+ * bits 7 & 6: data interleaving */
+};
+
+struct tga_footer {
+ uint32_t ext_off; /* extension area offset */
+ uint32_t devdir_off; /* developer directory offset */
+ char sig[18]; /* signature with . and \0 */
+};
+
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix);
+static int16_t read_int16(struct img_io *io);
+static int16_t read_int16_inv(struct img_io *io);
+
+int img_register_tga(void)
+{
+ static struct ftype_module mod = {".tga", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ struct tga_footer foot;
+ int res = -1;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+ io->seek(-18, SEEK_END, io->uptr);
+
+ if(io->read(foot.sig, 17, io->uptr) < 17) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(memcmp(foot.sig, "TRUEVISION-XFILE.", 17) == 0) {
+ res = 0;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ struct tga_header hdr;
+ unsigned long x, y;
+ int i, c;
+ uint32_t ppixel = 0;
+ int rle_mode = 0, rle_pix_left = 0;
+ int rdalpha;
+
+ /* read header */
+ hdr.idlen = iofgetc(io);
+ hdr.cmap_type = iofgetc(io);
+ hdr.img_type = iofgetc(io);
+ hdr.cmap_first = read_int16_le(io);
+ hdr.cmap_len = read_int16_le(io);
+ hdr.cmap_entry_sz = iofgetc(io);
+ hdr.img_x = read_int16_le(io);
+ hdr.img_y = read_int16_le(io);
+ hdr.img_width = read_int16_le(io);
+ hdr.img_height = read_int16_le(io);
+ hdr.img_bpp = iofgetc(io);
+ if((c = iofgetc(io)) == -1) {
+ return -1;
+ }
+ hdr.img_desc = c;
+
+ if(!IS_RGBA(hdr.img_type)) {
+ fprintf(stderr, "only true color tga images supported\n");
+ return -1;
+ }
+
+ io->seek(hdr.idlen, SEEK_CUR, io); /* skip the image ID */
+
+ /* skip the color map if it exists */
+ if(hdr.cmap_type == 1) {
+ io->seek(hdr.cmap_len * hdr.cmap_entry_sz / 8, SEEK_CUR, io);
+ }
+
+ x = hdr.img_width;
+ y = hdr.img_height;
+ rdalpha = hdr.img_desc & 0xf;
+
+ /* TODO make this IMG_FMT_RGB24 if there's no alpha channel */
+ if(img_set_pixels(img, x, y, IMG_FMT_RGBA32, 0) == -1) {
+ return -1;
+ }
+
+ for(i=0; i<y; i++) {
+ uint32_t *ptr;
+ int j;
+
+ ptr = (uint32_t*)img->pixels + ((hdr.img_desc & 0x20) ? i : y - (i + 1)) * x;
+
+ for(j=0; j<x; j++) {
+ /* if the image is raw, then just read the next pixel */
+ if(!IS_RLE(hdr.img_type)) {
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ } else {
+ /* otherwise, for RLE... */
+
+ /* if we have pixels left in the packet ... */
+ if(rle_pix_left) {
+ /* if it's a raw packet, read the next pixel, otherwise keep the same */
+ if(!rle_mode) {
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ }
+ --rle_pix_left;
+ } else {
+ /* read RLE packet header */
+ unsigned char phdr = iofgetc(io);
+ rle_mode = (phdr & 128); /* last bit shows the mode for this packet (1: rle, 0: raw) */
+ rle_pix_left = (phdr & ~128); /* the rest gives the count of pixels minus one (we also read one here, so no +1) */
+ /* and read the first pixel of the packet */
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ }
+ }
+
+ *ptr++ = ppixel;
+ }
+ }
+
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ return -1; /* TODO */
+}
+
+#define PACK_COLOR32(r,g,b,a) \
+ ((((a) & 0xff) << 24) | \
+ (((r) & 0xff) << 0) | \
+ (((g) & 0xff) << 8) | \
+ (((b) & 0xff) << 16))
+
+static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix)
+{
+ int r, g, b, a;
+ b = iofgetc(io);
+ g = iofgetc(io);
+ r = iofgetc(io);
+ a = rdalpha ? iofgetc(io) : 0xff;
+ *pix = PACK_COLOR32(r, g, b, a);
+ return a == -1 || r == -1 ? -1 : 0;
+}
+
+static int16_t read_int16(struct img_io *io)
+{
+ int16_t v;
+ io->read(&v, 2, io);
+ return v;
+}
+
+static int16_t read_int16_inv(struct img_io *io)
+{
+ int16_t v;
+ io->read(&v, 2, io);
+ return ((v >> 8) & 0xff) | (v << 8);
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include "ftype_module.h"
+
+static struct list_node {
+ struct ftype_module *module;
+ struct list_node *next;
+} *modules;
+
+/* defined in modules.c which is generated by configure */
+void img_modules_init();
+
+static int done_init;
+
+int img_register_module(struct ftype_module *mod)
+{
+ struct list_node *node;
+
+ if(!(node = malloc(sizeof *node))) {
+ return -1;
+ }
+
+ node->module = mod;
+ node->next = modules;
+ modules = node;
+ return 0;
+}
+
+struct ftype_module *img_find_format_module(struct img_io *io)
+{
+ struct list_node *node;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ node = modules;
+ while(node) {
+ if(node->module->check(io) != -1) {
+ return node->module;
+ }
+ node = node->next;
+ }
+ return 0;
+}
+
+struct ftype_module *img_guess_format(const char *fname)
+{
+ struct list_node *node;
+ char *suffix;
+ int suffix_len;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ if(!(suffix = strrchr(fname, '.'))) {
+ return 0; /* no suffix, can't guess ... */
+ }
+ suffix_len = (int)strlen(suffix);
+
+ node = modules;
+ while(node) {
+ char *suflist = node->module->suffix;
+ char *start, *end;
+
+ while(*suflist) {
+ if(!(start = strstr(suflist, suffix))) {
+ break;
+ }
+ end = start + suffix_len;
+
+ if(*end == ':' || *end == 0) {
+ return node->module; /* found it */
+ }
+ suflist = end;
+ }
+
+ node = node->next;
+ }
+ return 0;
+}
+
+struct ftype_module *img_get_module(int idx)
+{
+ struct list_node *node;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ node = modules;
+ while(node && idx--) {
+ node = node->next;
+ }
+ return node->module;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef FTYPE_MODULE_H_
+#define FTYPE_MODULE_H_
+
+#include "imago2.h"
+
+struct ftype_module {
+ char *suffix; /* used for format autodetection during saving only */
+
+ int (*check)(struct img_io *io);
+ int (*read)(struct img_pixmap *img, struct img_io *io);
+ int (*write)(struct img_pixmap *img, struct img_io *io);
+};
+
+int img_register_module(struct ftype_module *mod);
+
+struct ftype_module *img_find_format_module(struct img_io *io);
+struct ftype_module *img_guess_format(const char *fname);
+struct ftype_module *img_get_module(int idx);
+
+
+#endif /* FTYPE_MODULE_H_ */
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "imago2.h"
+#include "ftype_module.h"
+
+static int pixel_size(enum img_fmt fmt);
+static size_t def_read(void *buf, size_t bytes, void *uptr);
+static size_t def_write(void *buf, size_t bytes, void *uptr);
+static long def_seek(long offset, int whence, void *uptr);
+
+
+void img_init(struct img_pixmap *img)
+{
+ img->pixels = 0;
+ img->width = img->height = 0;
+ img->fmt = IMG_FMT_RGBA32;
+ img->pixelsz = pixel_size(img->fmt);
+ img->name = 0;
+}
+
+
+void img_destroy(struct img_pixmap *img)
+{
+ free(img->pixels);
+ img->pixels = 0; /* just in case... */
+ img->width = img->height = 0xbadbeef;
+ free(img->name);
+}
+
+struct img_pixmap *img_create(void)
+{
+ struct img_pixmap *p;
+
+ if(!(p = malloc(sizeof *p))) {
+ return 0;
+ }
+ img_init(p);
+ return p;
+}
+
+void img_free(struct img_pixmap *img)
+{
+ img_destroy(img);
+ free(img);
+}
+
+int img_set_name(struct img_pixmap *img, const char *name)
+{
+ char *tmp;
+
+ if(!(tmp = malloc(strlen(name) + 1))) {
+ return -1;
+ }
+ strcpy(tmp, name);
+ img->name = tmp;
+ return 0;
+}
+
+int img_set_format(struct img_pixmap *img, enum img_fmt fmt)
+{
+ if(img->pixels) {
+ return img_convert(img, fmt);
+ }
+ img->fmt = fmt;
+ return 0;
+}
+
+int img_copy(struct img_pixmap *dest, struct img_pixmap *src)
+{
+ return img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels);
+}
+
+int img_set_pixels(struct img_pixmap *img, int w, int h, enum img_fmt fmt, void *pix)
+{
+ void *newpix;
+ int pixsz = pixel_size(fmt);
+
+ if(!(newpix = malloc(w * h * pixsz))) {
+ return -1;
+ }
+
+ if(pix) {
+ memcpy(newpix, pix, w * h * pixsz);
+ } else {
+ memset(newpix, 0, w * h * pixsz);
+ }
+
+ free(img->pixels);
+ img->pixels = newpix;
+ img->width = w;
+ img->height = h;
+ img->pixelsz = pixsz;
+ img->fmt = fmt;
+ return 0;
+}
+
+void *img_load_pixels(const char *fname, int *xsz, int *ysz, enum img_fmt fmt)
+{
+ struct img_pixmap img;
+
+ img_init(&img);
+
+ if(img_load(&img, fname) == -1) {
+ return 0;
+ }
+ if(img.fmt != fmt) {
+ if(img_convert(&img, fmt) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+ }
+
+ *xsz = img.width;
+ *ysz = img.height;
+ return img.pixels;
+}
+
+int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, enum img_fmt fmt)
+{
+ int res;
+ struct img_pixmap img;
+
+ img_init(&img);
+ img.fmt = fmt;
+ img.width = xsz;
+ img.height = ysz;
+ img.pixels = pix;
+
+ res = img_save(&img, fname);
+ img.pixels = 0;
+ img_destroy(&img);
+ return res;
+}
+
+void img_free_pixels(void *pix)
+{
+ free(pix);
+}
+
+int img_load(struct img_pixmap *img, const char *fname)
+{
+ int res;
+ FILE *fp;
+
+ if(!(fp = fopen(fname, "rb"))) {
+ return -1;
+ }
+ res = img_read_file(img, fp);
+ fclose(fp);
+ return res;
+}
+
+/* TODO implement filetype selection */
+int img_save(struct img_pixmap *img, const char *fname)
+{
+ int res;
+ FILE *fp;
+
+ img_set_name(img, fname);
+
+ if(!(fp = fopen(fname, "wb"))) {
+ return -1;
+ }
+ res = img_write_file(img, fp);
+ fclose(fp);
+ return res;
+}
+
+int img_read_file(struct img_pixmap *img, FILE *fp)
+{
+ struct img_io io = {0, def_read, def_write, def_seek};
+
+ io.uptr = fp;
+ return img_read(img, &io);
+}
+
+int img_write_file(struct img_pixmap *img, FILE *fp)
+{
+ struct img_io io = {0, def_read, def_write, def_seek};
+
+ io.uptr = fp;
+ return img_write(img, &io);
+}
+
+int img_read(struct img_pixmap *img, struct img_io *io)
+{
+ struct ftype_module *mod;
+
+ if((mod = img_find_format_module(io))) {
+ return mod->read(img, io);
+ }
+ return -1;
+}
+
+int img_write(struct img_pixmap *img, struct img_io *io)
+{
+ struct ftype_module *mod;
+
+ if(!img->name || !(mod = img_guess_format(img->name))) {
+ /* TODO throw some sort of warning? */
+ /* TODO implement some sort of module priority or let the user specify? */
+ if(!(mod = img_get_module(0))) {
+ return -1;
+ }
+ }
+
+ return mod->write(img, io);
+}
+
+int img_to_float(struct img_pixmap *img)
+{
+ enum img_fmt targ_fmt;
+
+ switch(img->fmt) {
+ case IMG_FMT_GREY8:
+ targ_fmt = IMG_FMT_GREYF;
+ break;
+
+ case IMG_FMT_RGB24:
+ targ_fmt = IMG_FMT_RGBF;
+ break;
+
+ case IMG_FMT_RGBA32:
+ targ_fmt = IMG_FMT_RGBAF;
+ break;
+
+ default:
+ return 0; /* already float */
+ }
+
+ return img_convert(img, targ_fmt);
+}
+
+int img_to_integer(struct img_pixmap *img)
+{
+ enum img_fmt targ_fmt;
+
+ switch(img->fmt) {
+ case IMG_FMT_GREYF:
+ targ_fmt = IMG_FMT_GREY8;
+ break;
+
+ case IMG_FMT_RGBF:
+ targ_fmt = IMG_FMT_RGB24;
+ break;
+
+ case IMG_FMT_RGBAF:
+ targ_fmt = IMG_FMT_RGBA32;
+ break;
+
+ default:
+ return 0; /* already integer */
+ }
+
+ return img_convert(img, targ_fmt);
+}
+
+int img_is_float(struct img_pixmap *img)
+{
+ return img->fmt >= IMG_FMT_GREYF && img->fmt <= IMG_FMT_RGBAF;
+}
+
+int img_has_alpha(struct img_pixmap *img)
+{
+ if(img->fmt == IMG_FMT_RGBA32 || img->fmt == IMG_FMT_RGBAF) {
+ return 1;
+ }
+ return 0;
+}
+
+
+void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel)
+{
+ char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
+ memcpy(dest, pixel, img->pixelsz);
+}
+
+void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel)
+{
+ char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
+ memcpy(pixel, dest, img->pixelsz);
+}
+
+void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix)
+{
+ img_setpixel4i(img, x, y, pix, pix, pix, pix);
+}
+
+void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix)
+{
+ img_setpixel4f(img, x, y, pix, pix, pix, pix);
+}
+
+void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a)
+{
+ if(img_is_float(img)) {
+ img_setpixel4f(img, x, y, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
+ } else {
+ unsigned char pixel[4];
+ pixel[0] = r;
+ pixel[1] = g;
+ pixel[2] = b;
+ pixel[3] = a;
+
+ img_setpixel(img, x, y, pixel);
+ }
+}
+
+void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a)
+{
+ if(img_is_float(img)) {
+ float pixel[4];
+ pixel[0] = r;
+ pixel[1] = g;
+ pixel[2] = b;
+ pixel[3] = a;
+
+ img_setpixel(img, x, y, pixel);
+ } else {
+ img_setpixel4i(img, x, y, (int)(r * 255.0), (int)(g * 255.0), (int)(b * 255.0), (int)(a * 255.0));
+ }
+}
+
+void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix)
+{
+ int junk[3];
+ img_getpixel4i(img, x, y, pix, junk, junk + 1, junk + 2);
+}
+
+void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix)
+{
+ float junk[3];
+ img_getpixel4f(img, x, y, pix, junk, junk + 1, junk + 2);
+}
+
+void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a)
+{
+ if(img_is_float(img)) {
+ float pixel[4] = {0, 0, 0, 0};
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0] * 255.0;
+ *g = pixel[1] * 255.0;
+ *b = pixel[2] * 255.0;
+ *a = pixel[3] * 255.0;
+ } else {
+ unsigned char pixel[4];
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0];
+ *g = pixel[1];
+ *b = pixel[2];
+ *a = pixel[3];
+ }
+}
+
+void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a)
+{
+ if(img_is_float(img)) {
+ float pixel[4] = {0, 0, 0, 0};
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0];
+ *g = pixel[1];
+ *b = pixel[2];
+ *a = pixel[3];
+ } else {
+ unsigned char pixel[4];
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0] / 255.0;
+ *g = pixel[1] / 255.0;
+ *b = pixel[2] / 255.0;
+ *a = pixel[3] / 255.0;
+ }
+}
+
+void img_io_set_user_data(struct img_io *io, void *uptr)
+{
+ io->uptr = uptr;
+}
+
+void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*))
+{
+ io->read = read;
+}
+
+void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*))
+{
+ io->write = write;
+}
+
+void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*))
+{
+ io->seek = seek;
+}
+
+
+static int pixel_size(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return 1;
+ case IMG_FMT_RGB24:
+ return 3;
+ case IMG_FMT_RGBA32:
+ return 4;
+ case IMG_FMT_GREYF:
+ return sizeof(float);
+ case IMG_FMT_RGBF:
+ return 3 * sizeof(float);
+ case IMG_FMT_RGBAF:
+ return 4 * sizeof(float);
+ default:
+ break;
+ }
+ return 0;
+}
+
+static size_t def_read(void *buf, size_t bytes, void *uptr)
+{
+ return uptr ? fread(buf, 1, bytes, uptr) : 0;
+}
+
+static size_t def_write(void *buf, size_t bytes, void *uptr)
+{
+ return uptr ? fwrite(buf, 1, bytes, uptr) : 0;
+}
+
+static long def_seek(long offset, int whence, void *uptr)
+{
+ if(!uptr || fseek(uptr, offset, whence) == -1) {
+ return -1;
+ }
+ return ftell(uptr);
+}
+
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010-2012 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef IMAGO2_H_
+#define IMAGO2_H_
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define IMG_OPTARG(arg, val) arg = val
+#else
+#define IMG_OPTARG(arg, val) arg
+#endif
+
+/* XXX if you change this make sure to also change pack/unpack arrays in conv.c */
+enum img_fmt {
+ IMG_FMT_GREY8,
+ IMG_FMT_RGB24,
+ IMG_FMT_RGBA32,
+ IMG_FMT_GREYF,
+ IMG_FMT_RGBF,
+ IMG_FMT_RGBAF,
+
+ NUM_IMG_FMT
+};
+
+struct img_pixmap {
+ void *pixels;
+ int width, height;
+ enum img_fmt fmt;
+ int pixelsz;
+ char *name;
+};
+
+struct img_io {
+ void *uptr; /* user-data */
+
+ size_t (*read)(void *buf, size_t bytes, void *uptr);
+ size_t (*write)(void *buf, size_t bytes, void *uptr);
+ long (*seek)(long offs, int whence, void *uptr);
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* initialize the img_pixmap structure */
+void img_init(struct img_pixmap *img);
+/* destroys the img_pixmap structure, freeing the pixel buffer (if available)
+ * and any other memory held by the pixmap.
+ */
+void img_destroy(struct img_pixmap *img);
+
+/* convenience function that allocates an img_pixmap struct and then initializes it.
+ * returns null if the malloc fails.
+ */
+struct img_pixmap *img_create(void);
+/* frees a pixmap previously allocated with img_create (free followed by img_destroy) */
+void img_free(struct img_pixmap *img);
+
+int img_set_name(struct img_pixmap *img, const char *name);
+
+/* set the image pixel format */
+int img_set_format(struct img_pixmap *img, enum img_fmt fmt);
+
+/* copies one pixmap to another.
+ * equivalent to: img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels)
+ */
+int img_copy(struct img_pixmap *dest, struct img_pixmap *src);
+
+/* allocates a pixel buffer of the specified dimensions and format, and copies the
+ * pixels given through the pix pointer into it.
+ * the pix pointer can be null, in which case there's no copy, just allocation.
+ *
+ * C++: fmt and pix have default parameters IMG_FMT_RGBA32 and null respectively.
+ */
+int img_set_pixels(struct img_pixmap *img, int w, int h, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32), IMG_OPTARG(void *pix, 0));
+
+/* Simplified image loading
+ * Loads the specified file, and returns a pointer to an array of pixels of the
+ * requested pixel format. The width and height of the image are returned through
+ * the xsz and ysz pointers.
+ * If the image cannot be loaded, the function returns null.
+ *
+ * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
+ */
+void *img_load_pixels(const char *fname, int *xsz, int *ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
+
+/* Simplified image saving
+ * Reads an array of pixels supplied through the pix pointer, of dimensions xsz
+ * and ysz, and pixel-format fmt, and saves it to a file.
+ * The output filetype is guessed by the filename suffix.
+ *
+ * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
+ */
+int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
+
+/* Frees the memory allocated by img_load_pixels */
+void img_free_pixels(void *pix);
+
+/* Loads an image file into the supplied pixmap */
+int img_load(struct img_pixmap *img, const char *fname);
+/* Saves the supplied pixmap to a file. The output filetype is guessed by the filename suffix */
+int img_save(struct img_pixmap *img, const char *fname);
+
+/* Reads an image from an open FILE* into the supplied pixmap */
+int img_read_file(struct img_pixmap *img, FILE *fp);
+/* Writes the supplied pixmap to an open FILE* */
+int img_write_file(struct img_pixmap *img, FILE *fp);
+
+/* Reads an image using user-defined file-i/o functions (see img_io_set_*) */
+int img_read(struct img_pixmap *img, struct img_io *io);
+/* Writes an image using user-defined file-i/o functions (see img_io_set_*) */
+int img_write(struct img_pixmap *img, struct img_io *io);
+
+/* Converts an image to the specified pixel format */
+int img_convert(struct img_pixmap *img, enum img_fmt tofmt);
+
+/* Converts an image from an integer pixel format to the corresponding floating point one */
+int img_to_float(struct img_pixmap *img);
+/* Converts an image from a floating point pixel format to the corresponding integer one */
+int img_to_integer(struct img_pixmap *img);
+
+/* Returns non-zero (true) if the supplied image is in a floating point pixel format */
+int img_is_float(struct img_pixmap *img);
+/* Returns non-zero (true) if the supplied image has an alpha channel */
+int img_has_alpha(struct img_pixmap *img);
+
+
+/* don't use these for anything performance-critical */
+void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel);
+void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel);
+
+void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix);
+void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix);
+void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a);
+void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a);
+
+void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix);
+void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix);
+void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a);
+void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a);
+
+
+/* OpenGL helper functions */
+
+/* Returns the equivalent OpenGL "format" as expected by the 7th argument of glTexImage2D */
+unsigned int img_fmt_glfmt(enum img_fmt fmt);
+/* Returns the equivalent OpenGL "type" as expected by the 8th argument of glTexImage2D */
+unsigned int img_fmt_gltype(enum img_fmt fmt);
+/* Returns the equivalent OpenGL "internal format" as expected by the 3rd argument of glTexImage2D */
+unsigned int img_fmt_glintfmt(enum img_fmt fmt);
+
+/* Same as above, based on the pixel format of the supplied image */
+unsigned int img_glfmt(struct img_pixmap *img);
+unsigned int img_gltype(struct img_pixmap *img);
+unsigned int img_glintfmt(struct img_pixmap *img);
+
+/* Creates an OpenGL texture from the image, and returns the texture id, or 0 for failure */
+unsigned int img_gltexture(struct img_pixmap *img);
+
+/* Load an image and create an OpenGL texture out of it */
+unsigned int img_gltexture_load(const char *fname);
+unsigned int img_gltexture_read_file(FILE *fp);
+unsigned int img_gltexture_read(struct img_io *io);
+
+/* These functions can be used to fill an img_io struct before it's passed to
+ * one of the user-defined i/o image reading/writing functions (img_read/img_write).
+ *
+ * User-defined i/o functions:
+ *
+ * - size_t read_func(void *buffer, size_t bytes, void *user_ptr)
+ * Must try to fill the buffer with the specified number of bytes, and return
+ * the number of bytes actually read.
+ *
+ * - size_t write_func(void *buffer, size_t bytes, void *user_ptr)
+ * Must write the specified number of bytes from the supplied buffer and return
+ * the number of bytes actually written.
+ *
+ * - long seek_func(long offset, int whence, void *user_ptr)
+ * Must seek offset bytes from: the beginning of the file if whence is SEEK_SET,
+ * the current position if whence is SEEK_CUR, or the end of the file if whence is
+ * SEEK_END, and return the resulting file offset from the beginning of the file.
+ * (i.e. seek_func(0, SEEK_CUR, user_ptr); must be equivalent to an ftell).
+ *
+ * All three functions get the user-data pointer set through img_io_set_user_data
+ * as their last argument.
+ *
+ * Note: obviously you don't need to set a write function if you're only going
+ * to call img_read, or the read and seek function if you're only going to call
+ * img_write.
+ *
+ * Note: if the user-supplied write function is buffered, make sure to flush
+ * (or close the file) after img_write returns.
+ */
+void img_io_set_user_data(struct img_io *io, void *uptr);
+void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*));
+void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*));
+void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*));
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* IMAGO_H_ */
--- /dev/null
+#include "imago2.h"
+
+/* to avoid dependency to OpenGL, I'll define all the relevant GL macros manually */
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_FLOAT 0x1406
+
+#define GL_LUMINANCE 0x1909
+#define GL_RGB 0x1907
+#define GL_RGBA 0x1908
+
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_LUMINANCE32F 0x8818
+
+#define GL_TEXTURE_2D 0x0de1
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_LINEAR 0x2601
+#define GL_REPEAT 0x2901
+
+
+typedef unsigned int GLenum;
+typedef unsigned int GLuint;
+typedef int GLint;
+typedef int GLsizei;
+typedef void GLvoid;
+
+/* for the same reason I'll load GL functions dynamically */
+#ifndef WIN32
+typedef void (*gl_gen_textures_func)(GLsizei, GLuint*);
+typedef void (*gl_bind_texture_func)(GLenum, GLuint);
+typedef void (*gl_tex_parameteri_func)(GLenum, GLenum, GLint);
+typedef void (*gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
+#else
+typedef void (__stdcall *gl_gen_textures_func)(GLsizei, GLuint*);
+typedef void (__stdcall *gl_bind_texture_func)(GLenum, GLuint);
+typedef void (__stdcall *gl_tex_parameteri_func)(GLenum, GLenum, GLint);
+typedef void (__stdcall *gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
+#endif
+
+static gl_gen_textures_func gl_gen_textures;
+static gl_bind_texture_func gl_bind_texture;
+static gl_tex_parameteri_func gl_tex_parameteri;
+static gl_tex_image2d_func gl_tex_image2d;
+
+static int load_glfunc(void);
+
+unsigned int img_fmt_glfmt(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ case IMG_FMT_GREYF:
+ return GL_LUMINANCE;
+
+ case IMG_FMT_RGB24:
+ case IMG_FMT_RGBF:
+ return GL_RGB;
+
+ case IMG_FMT_RGBA32:
+ case IMG_FMT_RGBAF:
+ return GL_RGBA;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_fmt_gltype(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ case IMG_FMT_RGB24:
+ case IMG_FMT_RGBA32:
+ return GL_UNSIGNED_BYTE;
+
+ case IMG_FMT_GREYF:
+ case IMG_FMT_RGBF:
+ case IMG_FMT_RGBAF:
+ return GL_FLOAT;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_fmt_glintfmt(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return GL_LUMINANCE;
+ case IMG_FMT_RGB24:
+ return GL_RGB;
+ case IMG_FMT_RGBA32:
+ return GL_RGBA;
+ case IMG_FMT_GREYF:
+ return GL_LUMINANCE32F;
+ case IMG_FMT_RGBF:
+ return GL_RGB32F;
+ case IMG_FMT_RGBAF:
+ return GL_RGBA32F;
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_glfmt(struct img_pixmap *img)
+{
+ return img_fmt_glfmt(img->fmt);
+}
+
+unsigned int img_gltype(struct img_pixmap *img)
+{
+ return img_fmt_gltype(img->fmt);
+}
+
+unsigned int img_glintfmt(struct img_pixmap *img)
+{
+ return img_fmt_glintfmt(img->fmt);
+}
+
+unsigned int img_gltexture(struct img_pixmap *img)
+{
+ unsigned int tex;
+ unsigned int intfmt, fmt, type;
+
+ if(!gl_gen_textures) {
+ if(load_glfunc() == -1) {
+ fprintf(stderr, "imago: failed to initialize the OpenGL helpers\n");
+ return 0;
+ }
+ }
+
+ intfmt = img_glintfmt(img);
+ fmt = img_glfmt(img);
+ type = img_gltype(img);
+
+ gl_gen_textures(1, &tex);
+ gl_bind_texture(GL_TEXTURE_2D, tex);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ gl_tex_image2d(GL_TEXTURE_2D, 0, intfmt, img->width, img->height, 0, fmt, type, img->pixels);
+ return tex;
+}
+
+unsigned int img_gltexture_load(const char *fname)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_load(&img, fname) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+unsigned int img_gltexture_read_file(FILE *fp)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_read_file(&img, fp) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+unsigned int img_gltexture_read(struct img_io *io)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_read(&img, io) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+#if defined(__unix__) || defined(__APPLE__)
+#ifndef __USE_GNU
+#define __USE_GNU
+#endif
+
+#include <dlfcn.h>
+#endif
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+static int load_glfunc(void)
+{
+#if defined(__unix__) || defined(__APPLE__)
+ gl_gen_textures = (gl_gen_textures_func)dlsym(RTLD_DEFAULT, "glGenTextures");
+ gl_bind_texture = (gl_bind_texture_func)dlsym(RTLD_DEFAULT, "glBindTexture");
+ gl_tex_parameteri = (gl_tex_parameteri_func)dlsym(RTLD_DEFAULT, "glTexParameteri");
+ gl_tex_image2d = (gl_tex_image2d_func)dlsym(RTLD_DEFAULT, "glTexImage2D");
+#endif
+
+#ifdef WIN32
+ HANDLE dll = LoadLibrary("opengl32.dll");
+ if(dll) {
+ gl_gen_textures = (gl_gen_textures_func)GetProcAddress(dll, "glGenTextures");
+ gl_bind_texture = (gl_bind_texture_func)GetProcAddress(dll, "glBindTexture");
+ gl_tex_parameteri = (gl_tex_parameteri_func)GetProcAddress(dll, "glTexParameteri");
+ gl_tex_image2d = (gl_tex_image2d_func)GetProcAddress(dll, "glTexImage2D");
+ }
+#endif
+
+ return (gl_gen_textures && gl_bind_texture && gl_tex_parameteri && gl_tex_image2d) ? 0 : -1;
+}
--- /dev/null
+/* this file is generated by ./configure, do not edit */
+int img_register_jpeg();
+int img_register_png();
+int img_register_ppm();
+int img_register_rgbe();
+int img_register_tga();
+
+void img_modules_init(void)
+{
+ img_register_jpeg();
+ img_register_png();
+ img_register_ppm();
+ img_register_rgbe();
+ img_register_tga();
+}
}
if(quit) goto break_evloop;
- wait_vsync();
+ /*wait_vsync();*/
time_msec = get_msec();
demo_draw();
}