1.1 --- a/android/Makefile	Sun Jun 07 02:29:10 2015 +0300
     1.2 +++ b/android/Makefile	Sun Jun 07 17:25:49 2015 +0300
     1.3 @@ -29,7 +29,7 @@
     1.4  CXXFLAGS = -Wall -g $(defs) -march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16 \
     1.5  		 $(android_inc) -I$(root)/src/android -I$(root)/src/gles $(incpaths)
     1.6  CFLAGS = -std=c99 $(CXXFLAGS)
     1.7 -LDFLAGS = -Wl,--fix-cortex-a8 -Wl,-z,defs $(android_libs) $(libpaths) -lm
     1.8 +LDFLAGS = -Wl,--fix-cortex-a8 -Wl,-z,defs $(android_libs) $(libpaths) $(libs)
     1.9  
    1.10  .PHONY: debug
    1.11  debug: $(apk-debug)

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/libs/imago/COPYING	Sun Jun 07 17:25:49 2015 +0300
     2.3 @@ -0,0 +1,674 @@
     2.4 +                    GNU GENERAL PUBLIC LICENSE
     2.5 +                       Version 3, 29 June 2007
     2.6 +
     2.7 + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     2.8 + Everyone is permitted to copy and distribute verbatim copies
     2.9 + of this license document, but changing it is not allowed.
    2.10 +
    2.11 +                            Preamble
    2.12 +
    2.13 +  The GNU General Public License is a free, copyleft license for
    2.14 +software and other kinds of works.
    2.15 +
    2.16 +  The licenses for most software and other practical works are designed
    2.17 +to take away your freedom to share and change the works.  By contrast,
    2.18 +the GNU General Public License is intended to guarantee your freedom to
    2.19 +share and change all versions of a program--to make sure it remains free
    2.20 +software for all its users.  We, the Free Software Foundation, use the
    2.21 +GNU General Public License for most of our software; it applies also to
    2.22 +any other work released this way by its authors.  You can apply it to
    2.23 +your programs, too.
    2.24 +
    2.25 +  When we speak of free software, we are referring to freedom, not
    2.26 +price.  Our General Public Licenses are designed to make sure that you
    2.27 +have the freedom to distribute copies of free software (and charge for
    2.28 +them if you wish), that you receive source code or can get it if you
    2.29 +want it, that you can change the software or use pieces of it in new
    2.30 +free programs, and that you know you can do these things.
    2.31 +
    2.32 +  To protect your rights, we need to prevent others from denying you
    2.33 +these rights or asking you to surrender the rights.  Therefore, you have
    2.34 +certain responsibilities if you distribute copies of the software, or if
    2.35 +you modify it: responsibilities to respect the freedom of others.
    2.36 +
    2.37 +  For example, if you distribute copies of such a program, whether
    2.38 +gratis or for a fee, you must pass on to the recipients the same
    2.39 +freedoms that you received.  You must make sure that they, too, receive
    2.40 +or can get the source code.  And you must show them these terms so they
    2.41 +know their rights.
    2.42 +
    2.43 +  Developers that use the GNU GPL protect your rights with two steps:
    2.44 +(1) assert copyright on the software, and (2) offer you this License
    2.45 +giving you legal permission to copy, distribute and/or modify it.
    2.46 +
    2.47 +  For the developers' and authors' protection, the GPL clearly explains
    2.48 +that there is no warranty for this free software.  For both users' and
    2.49 +authors' sake, the GPL requires that modified versions be marked as
    2.50 +changed, so that their problems will not be attributed erroneously to
    2.51 +authors of previous versions.
    2.52 +
    2.53 +  Some devices are designed to deny users access to install or run
    2.54 +modified versions of the software inside them, although the manufacturer
    2.55 +can do so.  This is fundamentally incompatible with the aim of
    2.56 +protecting users' freedom to change the software.  The systematic
    2.57 +pattern of such abuse occurs in the area of products for individuals to
    2.58 +use, which is precisely where it is most unacceptable.  Therefore, we
    2.59 +have designed this version of the GPL to prohibit the practice for those
    2.60 +products.  If such problems arise substantially in other domains, we
    2.61 +stand ready to extend this provision to those domains in future versions
    2.62 +of the GPL, as needed to protect the freedom of users.
    2.63 +
    2.64 +  Finally, every program is threatened constantly by software patents.
    2.65 +States should not allow patents to restrict development and use of
    2.66 +software on general-purpose computers, but in those that do, we wish to
    2.67 +avoid the special danger that patents applied to a free program could
    2.68 +make it effectively proprietary.  To prevent this, the GPL assures that
    2.69 +patents cannot be used to render the program non-free.
    2.70 +
    2.71 +  The precise terms and conditions for copying, distribution and
    2.72 +modification follow.
    2.73 +
    2.74 +                       TERMS AND CONDITIONS
    2.75 +
    2.76 +  0. Definitions.
    2.77 +
    2.78 +  "This License" refers to version 3 of the GNU General Public License.
    2.79 +
    2.80 +  "Copyright" also means copyright-like laws that apply to other kinds of
    2.81 +works, such as semiconductor masks.
    2.82 +
    2.83 +  "The Program" refers to any copyrightable work licensed under this
    2.84 +License.  Each licensee is addressed as "you".  "Licensees" and
    2.85 +"recipients" may be individuals or organizations.
    2.86 +
    2.87 +  To "modify" a work means to copy from or adapt all or part of the work
    2.88 +in a fashion requiring copyright permission, other than the making of an
    2.89 +exact copy.  The resulting work is called a "modified version" of the
    2.90 +earlier work or a work "based on" the earlier work.
    2.91 +
    2.92 +  A "covered work" means either the unmodified Program or a work based
    2.93 +on the Program.
    2.94 +
    2.95 +  To "propagate" a work means to do anything with it that, without
    2.96 +permission, would make you directly or secondarily liable for
    2.97 +infringement under applicable copyright law, except executing it on a
    2.98 +computer or modifying a private copy.  Propagation includes copying,
    2.99 +distribution (with or without modification), making available to the
   2.100 +public, and in some countries other activities as well.
   2.101 +
   2.102 +  To "convey" a work means any kind of propagation that enables other
   2.103 +parties to make or receive copies.  Mere interaction with a user through
   2.104 +a computer network, with no transfer of a copy, is not conveying.
   2.105 +
   2.106 +  An interactive user interface displays "Appropriate Legal Notices"
   2.107 +to the extent that it includes a convenient and prominently visible
   2.108 +feature that (1) displays an appropriate copyright notice, and (2)
   2.109 +tells the user that there is no warranty for the work (except to the
   2.110 +extent that warranties are provided), that licensees may convey the
   2.111 +work under this License, and how to view a copy of this License.  If
   2.112 +the interface presents a list of user commands or options, such as a
   2.113 +menu, a prominent item in the list meets this criterion.
   2.114 +
   2.115 +  1. Source Code.
   2.116 +
   2.117 +  The "source code" for a work means the preferred form of the work
   2.118 +for making modifications to it.  "Object code" means any non-source
   2.119 +form of a work.
   2.120 +
   2.121 +  A "Standard Interface" means an interface that either is an official
   2.122 +standard defined by a recognized standards body, or, in the case of
   2.123 +interfaces specified for a particular programming language, one that
   2.124 +is widely used among developers working in that language.
   2.125 +
   2.126 +  The "System Libraries" of an executable work include anything, other
   2.127 +than the work as a whole, that (a) is included in the normal form of
   2.128 +packaging a Major Component, but which is not part of that Major
   2.129 +Component, and (b) serves only to enable use of the work with that
   2.130 +Major Component, or to implement a Standard Interface for which an
   2.131 +implementation is available to the public in source code form.  A
   2.132 +"Major Component", in this context, means a major essential component
   2.133 +(kernel, window system, and so on) of the specific operating system
   2.134 +(if any) on which the executable work runs, or a compiler used to
   2.135 +produce the work, or an object code interpreter used to run it.
   2.136 +
   2.137 +  The "Corresponding Source" for a work in object code form means all
   2.138 +the source code needed to generate, install, and (for an executable
   2.139 +work) run the object code and to modify the work, including scripts to
   2.140 +control those activities.  However, it does not include the work's
   2.141 +System Libraries, or general-purpose tools or generally available free
   2.142 +programs which are used unmodified in performing those activities but
   2.143 +which are not part of the work.  For example, Corresponding Source
   2.144 +includes interface definition files associated with source files for
   2.145 +the work, and the source code for shared libraries and dynamically
   2.146 +linked subprograms that the work is specifically designed to require,
   2.147 +such as by intimate data communication or control flow between those
   2.148 +subprograms and other parts of the work.
   2.149 +
   2.150 +  The Corresponding Source need not include anything that users
   2.151 +can regenerate automatically from other parts of the Corresponding
   2.152 +Source.
   2.153 +
   2.154 +  The Corresponding Source for a work in source code form is that
   2.155 +same work.
   2.156 +
   2.157 +  2. Basic Permissions.
   2.158 +
   2.159 +  All rights granted under this License are granted for the term of
   2.160 +copyright on the Program, and are irrevocable provided the stated
   2.161 +conditions are met.  This License explicitly affirms your unlimited
   2.162 +permission to run the unmodified Program.  The output from running a
   2.163 +covered work is covered by this License only if the output, given its
   2.164 +content, constitutes a covered work.  This License acknowledges your
   2.165 +rights of fair use or other equivalent, as provided by copyright law.
   2.166 +
   2.167 +  You may make, run and propagate covered works that you do not
   2.168 +convey, without conditions so long as your license otherwise remains
   2.169 +in force.  You may convey covered works to others for the sole purpose
   2.170 +of having them make modifications exclusively for you, or provide you
   2.171 +with facilities for running those works, provided that you comply with
   2.172 +the terms of this License in conveying all material for which you do
   2.173 +not control copyright.  Those thus making or running the covered works
   2.174 +for you must do so exclusively on your behalf, under your direction
   2.175 +and control, on terms that prohibit them from making any copies of
   2.176 +your copyrighted material outside their relationship with you.
   2.177 +
   2.178 +  Conveying under any other circumstances is permitted solely under
   2.179 +the conditions stated below.  Sublicensing is not allowed; section 10
   2.180 +makes it unnecessary.
   2.181 +
   2.182 +  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
   2.183 +
   2.184 +  No covered work shall be deemed part of an effective technological
   2.185 +measure under any applicable law fulfilling obligations under article
   2.186 +11 of the WIPO copyright treaty adopted on 20 December 1996, or
   2.187 +similar laws prohibiting or restricting circumvention of such
   2.188 +measures.
   2.189 +
   2.190 +  When you convey a covered work, you waive any legal power to forbid
   2.191 +circumvention of technological measures to the extent such circumvention
   2.192 +is effected by exercising rights under this License with respect to
   2.193 +the covered work, and you disclaim any intention to limit operation or
   2.194 +modification of the work as a means of enforcing, against the work's
   2.195 +users, your or third parties' legal rights to forbid circumvention of
   2.196 +technological measures.
   2.197 +
   2.198 +  4. Conveying Verbatim Copies.
   2.199 +
   2.200 +  You may convey verbatim copies of the Program's source code as you
   2.201 +receive it, in any medium, provided that you conspicuously and
   2.202 +appropriately publish on each copy an appropriate copyright notice;
   2.203 +keep intact all notices stating that this License and any
   2.204 +non-permissive terms added in accord with section 7 apply to the code;
   2.205 +keep intact all notices of the absence of any warranty; and give all
   2.206 +recipients a copy of this License along with the Program.
   2.207 +
   2.208 +  You may charge any price or no price for each copy that you convey,
   2.209 +and you may offer support or warranty protection for a fee.
   2.210 +
   2.211 +  5. Conveying Modified Source Versions.
   2.212 +
   2.213 +  You may convey a work based on the Program, or the modifications to
   2.214 +produce it from the Program, in the form of source code under the
   2.215 +terms of section 4, provided that you also meet all of these conditions:
   2.216 +
   2.217 +    a) The work must carry prominent notices stating that you modified
   2.218 +    it, and giving a relevant date.
   2.219 +
   2.220 +    b) The work must carry prominent notices stating that it is
   2.221 +    released under this License and any conditions added under section
   2.222 +    7.  This requirement modifies the requirement in section 4 to
   2.223 +    "keep intact all notices".
   2.224 +
   2.225 +    c) You must license the entire work, as a whole, under this
   2.226 +    License to anyone who comes into possession of a copy.  This
   2.227 +    License will therefore apply, along with any applicable section 7
   2.228 +    additional terms, to the whole of the work, and all its parts,
   2.229 +    regardless of how they are packaged.  This License gives no
   2.230 +    permission to license the work in any other way, but it does not
   2.231 +    invalidate such permission if you have separately received it.
   2.232 +
   2.233 +    d) If the work has interactive user interfaces, each must display
   2.234 +    Appropriate Legal Notices; however, if the Program has interactive
   2.235 +    interfaces that do not display Appropriate Legal Notices, your
   2.236 +    work need not make them do so.
   2.237 +
   2.238 +  A compilation of a covered work with other separate and independent
   2.239 +works, which are not by their nature extensions of the covered work,
   2.240 +and which are not combined with it such as to form a larger program,
   2.241 +in or on a volume of a storage or distribution medium, is called an
   2.242 +"aggregate" if the compilation and its resulting copyright are not
   2.243 +used to limit the access or legal rights of the compilation's users
   2.244 +beyond what the individual works permit.  Inclusion of a covered work
   2.245 +in an aggregate does not cause this License to apply to the other
   2.246 +parts of the aggregate.
   2.247 +
   2.248 +  6. Conveying Non-Source Forms.
   2.249 +
   2.250 +  You may convey a covered work in object code form under the terms
   2.251 +of sections 4 and 5, provided that you also convey the
   2.252 +machine-readable Corresponding Source under the terms of this License,
   2.253 +in one of these ways:
   2.254 +
   2.255 +    a) Convey the object code in, or embodied in, a physical product
   2.256 +    (including a physical distribution medium), accompanied by the
   2.257 +    Corresponding Source fixed on a durable physical medium
   2.258 +    customarily used for software interchange.
   2.259 +
   2.260 +    b) Convey the object code in, or embodied in, a physical product
   2.261 +    (including a physical distribution medium), accompanied by a
   2.262 +    written offer, valid for at least three years and valid for as
   2.263 +    long as you offer spare parts or customer support for that product
   2.264 +    model, to give anyone who possesses the object code either (1) a
   2.265 +    copy of the Corresponding Source for all the software in the
   2.266 +    product that is covered by this License, on a durable physical
   2.267 +    medium customarily used for software interchange, for a price no
   2.268 +    more than your reasonable cost of physically performing this
   2.269 +    conveying of source, or (2) access to copy the
   2.270 +    Corresponding Source from a network server at no charge.
   2.271 +
   2.272 +    c) Convey individual copies of the object code with a copy of the
   2.273 +    written offer to provide the Corresponding Source.  This
   2.274 +    alternative is allowed only occasionally and noncommercially, and
   2.275 +    only if you received the object code with such an offer, in accord
   2.276 +    with subsection 6b.
   2.277 +
   2.278 +    d) Convey the object code by offering access from a designated
   2.279 +    place (gratis or for a charge), and offer equivalent access to the
   2.280 +    Corresponding Source in the same way through the same place at no
   2.281 +    further charge.  You need not require recipients to copy the
   2.282 +    Corresponding Source along with the object code.  If the place to
   2.283 +    copy the object code is a network server, the Corresponding Source
   2.284 +    may be on a different server (operated by you or a third party)
   2.285 +    that supports equivalent copying facilities, provided you maintain
   2.286 +    clear directions next to the object code saying where to find the
   2.287 +    Corresponding Source.  Regardless of what server hosts the
   2.288 +    Corresponding Source, you remain obligated to ensure that it is
   2.289 +    available for as long as needed to satisfy these requirements.
   2.290 +
   2.291 +    e) Convey the object code using peer-to-peer transmission, provided
   2.292 +    you inform other peers where the object code and Corresponding
   2.293 +    Source of the work are being offered to the general public at no
   2.294 +    charge under subsection 6d.
   2.295 +
   2.296 +  A separable portion of the object code, whose source code is excluded
   2.297 +from the Corresponding Source as a System Library, need not be
   2.298 +included in conveying the object code work.
   2.299 +
   2.300 +  A "User Product" is either (1) a "consumer product", which means any
   2.301 +tangible personal property which is normally used for personal, family,
   2.302 +or household purposes, or (2) anything designed or sold for incorporation
   2.303 +into a dwelling.  In determining whether a product is a consumer product,
   2.304 +doubtful cases shall be resolved in favor of coverage.  For a particular
   2.305 +product received by a particular user, "normally used" refers to a
   2.306 +typical or common use of that class of product, regardless of the status
   2.307 +of the particular user or of the way in which the particular user
   2.308 +actually uses, or expects or is expected to use, the product.  A product
   2.309 +is a consumer product regardless of whether the product has substantial
   2.310 +commercial, industrial or non-consumer uses, unless such uses represent
   2.311 +the only significant mode of use of the product.
   2.312 +
   2.313 +  "Installation Information" for a User Product means any methods,
   2.314 +procedures, authorization keys, or other information required to install
   2.315 +and execute modified versions of a covered work in that User Product from
   2.316 +a modified version of its Corresponding Source.  The information must
   2.317 +suffice to ensure that the continued functioning of the modified object
   2.318 +code is in no case prevented or interfered with solely because
   2.319 +modification has been made.
   2.320 +
   2.321 +  If you convey an object code work under this section in, or with, or
   2.322 +specifically for use in, a User Product, and the conveying occurs as
   2.323 +part of a transaction in which the right of possession and use of the
   2.324 +User Product is transferred to the recipient in perpetuity or for a
   2.325 +fixed term (regardless of how the transaction is characterized), the
   2.326 +Corresponding Source conveyed under this section must be accompanied
   2.327 +by the Installation Information.  But this requirement does not apply
   2.328 +if neither you nor any third party retains the ability to install
   2.329 +modified object code on the User Product (for example, the work has
   2.330 +been installed in ROM).
   2.331 +
   2.332 +  The requirement to provide Installation Information does not include a
   2.333 +requirement to continue to provide support service, warranty, or updates
   2.334 +for a work that has been modified or installed by the recipient, or for
   2.335 +the User Product in which it has been modified or installed.  Access to a
   2.336 +network may be denied when the modification itself materially and
   2.337 +adversely affects the operation of the network or violates the rules and
   2.338 +protocols for communication across the network.
   2.339 +
   2.340 +  Corresponding Source conveyed, and Installation Information provided,
   2.341 +in accord with this section must be in a format that is publicly
   2.342 +documented (and with an implementation available to the public in
   2.343 +source code form), and must require no special password or key for
   2.344 +unpacking, reading or copying.
   2.345 +
   2.346 +  7. Additional Terms.
   2.347 +
   2.348 +  "Additional permissions" are terms that supplement the terms of this
   2.349 +License by making exceptions from one or more of its conditions.
   2.350 +Additional permissions that are applicable to the entire Program shall
   2.351 +be treated as though they were included in this License, to the extent
   2.352 +that they are valid under applicable law.  If additional permissions
   2.353 +apply only to part of the Program, that part may be used separately
   2.354 +under those permissions, but the entire Program remains governed by
   2.355 +this License without regard to the additional permissions.
   2.356 +
   2.357 +  When you convey a copy of a covered work, you may at your option
   2.358 +remove any additional permissions from that copy, or from any part of
   2.359 +it.  (Additional permissions may be written to require their own
   2.360 +removal in certain cases when you modify the work.)  You may place
   2.361 +additional permissions on material, added by you to a covered work,
   2.362 +for which you have or can give appropriate copyright permission.
   2.363 +
   2.364 +  Notwithstanding any other provision of this License, for material you
   2.365 +add to a covered work, you may (if authorized by the copyright holders of
   2.366 +that material) supplement the terms of this License with terms:
   2.367 +
   2.368 +    a) Disclaiming warranty or limiting liability differently from the
   2.369 +    terms of sections 15 and 16 of this License; or
   2.370 +
   2.371 +    b) Requiring preservation of specified reasonable legal notices or
   2.372 +    author attributions in that material or in the Appropriate Legal
   2.373 +    Notices displayed by works containing it; or
   2.374 +
   2.375 +    c) Prohibiting misrepresentation of the origin of that material, or
   2.376 +    requiring that modified versions of such material be marked in
   2.377 +    reasonable ways as different from the original version; or
   2.378 +
   2.379 +    d) Limiting the use for publicity purposes of names of licensors or
   2.380 +    authors of the material; or
   2.381 +
   2.382 +    e) Declining to grant rights under trademark law for use of some
   2.383 +    trade names, trademarks, or service marks; or
   2.384 +
   2.385 +    f) Requiring indemnification of licensors and authors of that
   2.386 +    material by anyone who conveys the material (or modified versions of
   2.387 +    it) with contractual assumptions of liability to the recipient, for
   2.388 +    any liability that these contractual assumptions directly impose on
   2.389 +    those licensors and authors.
   2.390 +
   2.391 +  All other non-permissive additional terms are considered "further
   2.392 +restrictions" within the meaning of section 10.  If the Program as you
   2.393 +received it, or any part of it, contains a notice stating that it is
   2.394 +governed by this License along with a term that is a further
   2.395 +restriction, you may remove that term.  If a license document contains
   2.396 +a further restriction but permits relicensing or conveying under this
   2.397 +License, you may add to a covered work material governed by the terms
   2.398 +of that license document, provided that the further restriction does
   2.399 +not survive such relicensing or conveying.
   2.400 +
   2.401 +  If you add terms to a covered work in accord with this section, you
   2.402 +must place, in the relevant source files, a statement of the
   2.403 +additional terms that apply to those files, or a notice indicating
   2.404 +where to find the applicable terms.
   2.405 +
   2.406 +  Additional terms, permissive or non-permissive, may be stated in the
   2.407 +form of a separately written license, or stated as exceptions;
   2.408 +the above requirements apply either way.
   2.409 +
   2.410 +  8. Termination.
   2.411 +
   2.412 +  You may not propagate or modify a covered work except as expressly
   2.413 +provided under this License.  Any attempt otherwise to propagate or
   2.414 +modify it is void, and will automatically terminate your rights under
   2.415 +this License (including any patent licenses granted under the third
   2.416 +paragraph of section 11).
   2.417 +
   2.418 +  However, if you cease all violation of this License, then your
   2.419 +license from a particular copyright holder is reinstated (a)
   2.420 +provisionally, unless and until the copyright holder explicitly and
   2.421 +finally terminates your license, and (b) permanently, if the copyright
   2.422 +holder fails to notify you of the violation by some reasonable means
   2.423 +prior to 60 days after the cessation.
   2.424 +
   2.425 +  Moreover, your license from a particular copyright holder is
   2.426 +reinstated permanently if the copyright holder notifies you of the
   2.427 +violation by some reasonable means, this is the first time you have
   2.428 +received notice of violation of this License (for any work) from that
   2.429 +copyright holder, and you cure the violation prior to 30 days after
   2.430 +your receipt of the notice.
   2.431 +
   2.432 +  Termination of your rights under this section does not terminate the
   2.433 +licenses of parties who have received copies or rights from you under
   2.434 +this License.  If your rights have been terminated and not permanently
   2.435 +reinstated, you do not qualify to receive new licenses for the same
   2.436 +material under section 10.
   2.437 +
   2.438 +  9. Acceptance Not Required for Having Copies.
   2.439 +
   2.440 +  You are not required to accept this License in order to receive or
   2.441 +run a copy of the Program.  Ancillary propagation of a covered work
   2.442 +occurring solely as a consequence of using peer-to-peer transmission
   2.443 +to receive a copy likewise does not require acceptance.  However,
   2.444 +nothing other than this License grants you permission to propagate or
   2.445 +modify any covered work.  These actions infringe copyright if you do
   2.446 +not accept this License.  Therefore, by modifying or propagating a
   2.447 +covered work, you indicate your acceptance of this License to do so.
   2.448 +
   2.449 +  10. Automatic Licensing of Downstream Recipients.
   2.450 +
   2.451 +  Each time you convey a covered work, the recipient automatically
   2.452 +receives a license from the original licensors, to run, modify and
   2.453 +propagate that work, subject to this License.  You are not responsible
   2.454 +for enforcing compliance by third parties with this License.
   2.455 +
   2.456 +  An "entity transaction" is a transaction transferring control of an
   2.457 +organization, or substantially all assets of one, or subdividing an
   2.458 +organization, or merging organizations.  If propagation of a covered
   2.459 +work results from an entity transaction, each party to that
   2.460 +transaction who receives a copy of the work also receives whatever
   2.461 +licenses to the work the party's predecessor in interest had or could
   2.462 +give under the previous paragraph, plus a right to possession of the
   2.463 +Corresponding Source of the work from the predecessor in interest, if
   2.464 +the predecessor has it or can get it with reasonable efforts.
   2.465 +
   2.466 +  You may not impose any further restrictions on the exercise of the
   2.467 +rights granted or affirmed under this License.  For example, you may
   2.468 +not impose a license fee, royalty, or other charge for exercise of
   2.469 +rights granted under this License, and you may not initiate litigation
   2.470 +(including a cross-claim or counterclaim in a lawsuit) alleging that
   2.471 +any patent claim is infringed by making, using, selling, offering for
   2.472 +sale, or importing the Program or any portion of it.
   2.473 +
   2.474 +  11. Patents.
   2.475 +
   2.476 +  A "contributor" is a copyright holder who authorizes use under this
   2.477 +License of the Program or a work on which the Program is based.  The
   2.478 +work thus licensed is called the contributor's "contributor version".
   2.479 +
   2.480 +  A contributor's "essential patent claims" are all patent claims
   2.481 +owned or controlled by the contributor, whether already acquired or
   2.482 +hereafter acquired, that would be infringed by some manner, permitted
   2.483 +by this License, of making, using, or selling its contributor version,
   2.484 +but do not include claims that would be infringed only as a
   2.485 +consequence of further modification of the contributor version.  For
   2.486 +purposes of this definition, "control" includes the right to grant
   2.487 +patent sublicenses in a manner consistent with the requirements of
   2.488 +this License.
   2.489 +
   2.490 +  Each contributor grants you a non-exclusive, worldwide, royalty-free
   2.491 +patent license under the contributor's essential patent claims, to
   2.492 +make, use, sell, offer for sale, import and otherwise run, modify and
   2.493 +propagate the contents of its contributor version.
   2.494 +
   2.495 +  In the following three paragraphs, a "patent license" is any express
   2.496 +agreement or commitment, however denominated, not to enforce a patent
   2.497 +(such as an express permission to practice a patent or covenant not to
   2.498 +sue for patent infringement).  To "grant" such a patent license to a
   2.499 +party means to make such an agreement or commitment not to enforce a
   2.500 +patent against the party.
   2.501 +
   2.502 +  If you convey a covered work, knowingly relying on a patent license,
   2.503 +and the Corresponding Source of the work is not available for anyone
   2.504 +to copy, free of charge and under the terms of this License, through a
   2.505 +publicly available network server or other readily accessible means,
   2.506 +then you must either (1) cause the Corresponding Source to be so
   2.507 +available, or (2) arrange to deprive yourself of the benefit of the
   2.508 +patent license for this particular work, or (3) arrange, in a manner
   2.509 +consistent with the requirements of this License, to extend the patent
   2.510 +license to downstream recipients.  "Knowingly relying" means you have
   2.511 +actual knowledge that, but for the patent license, your conveying the
   2.512 +covered work in a country, or your recipient's use of the covered work
   2.513 +in a country, would infringe one or more identifiable patents in that
   2.514 +country that you have reason to believe are valid.
   2.515 +
   2.516 +  If, pursuant to or in connection with a single transaction or
   2.517 +arrangement, you convey, or propagate by procuring conveyance of, a
   2.518 +covered work, and grant a patent license to some of the parties
   2.519 +receiving the covered work authorizing them to use, propagate, modify
   2.520 +or convey a specific copy of the covered work, then the patent license
   2.521 +you grant is automatically extended to all recipients of the covered
   2.522 +work and works based on it.
   2.523 +
   2.524 +  A patent license is "discriminatory" if it does not include within
   2.525 +the scope of its coverage, prohibits the exercise of, or is
   2.526 +conditioned on the non-exercise of one or more of the rights that are
   2.527 +specifically granted under this License.  You may not convey a covered
   2.528 +work if you are a party to an arrangement with a third party that is
   2.529 +in the business of distributing software, under which you make payment
   2.530 +to the third party based on the extent of your activity of conveying
   2.531 +the work, and under which the third party grants, to any of the
   2.532 +parties who would receive the covered work from you, a discriminatory
   2.533 +patent license (a) in connection with copies of the covered work
   2.534 +conveyed by you (or copies made from those copies), or (b) primarily
   2.535 +for and in connection with specific products or compilations that
   2.536 +contain the covered work, unless you entered into that arrangement,
   2.537 +or that patent license was granted, prior to 28 March 2007.
   2.538 +
   2.539 +  Nothing in this License shall be construed as excluding or limiting
   2.540 +any implied license or other defenses to infringement that may
   2.541 +otherwise be available to you under applicable patent law.
   2.542 +
   2.543 +  12. No Surrender of Others' Freedom.
   2.544 +
   2.545 +  If conditions are imposed on you (whether by court order, agreement or
   2.546 +otherwise) that contradict the conditions of this License, they do not
   2.547 +excuse you from the conditions of this License.  If you cannot convey a
   2.548 +covered work so as to satisfy simultaneously your obligations under this
   2.549 +License and any other pertinent obligations, then as a consequence you may
   2.550 +not convey it at all.  For example, if you agree to terms that obligate you
   2.551 +to collect a royalty for further conveying from those to whom you convey
   2.552 +the Program, the only way you could satisfy both those terms and this
   2.553 +License would be to refrain entirely from conveying the Program.
   2.554 +
   2.555 +  13. Use with the GNU Affero General Public License.
   2.556 +
   2.557 +  Notwithstanding any other provision of this License, you have
   2.558 +permission to link or combine any covered work with a work licensed
   2.559 +under version 3 of the GNU Affero General Public License into a single
   2.560 +combined work, and to convey the resulting work.  The terms of this
   2.561 +License will continue to apply to the part which is the covered work,
   2.562 +but the special requirements of the GNU Affero General Public License,
   2.563 +section 13, concerning interaction through a network will apply to the
   2.564 +combination as such.
   2.565 +
   2.566 +  14. Revised Versions of this License.
   2.567 +
   2.568 +  The Free Software Foundation may publish revised and/or new versions of
   2.569 +the GNU General Public License from time to time.  Such new versions will
   2.570 +be similar in spirit to the present version, but may differ in detail to
   2.571 +address new problems or concerns.
   2.572 +
   2.573 +  Each version is given a distinguishing version number.  If the
   2.574 +Program specifies that a certain numbered version of the GNU General
   2.575 +Public License "or any later version" applies to it, you have the
   2.576 +option of following the terms and conditions either of that numbered
   2.577 +version or of any later version published by the Free Software
   2.578 +Foundation.  If the Program does not specify a version number of the
   2.579 +GNU General Public License, you may choose any version ever published
   2.580 +by the Free Software Foundation.
   2.581 +
   2.582 +  If the Program specifies that a proxy can decide which future
   2.583 +versions of the GNU General Public License can be used, that proxy's
   2.584 +public statement of acceptance of a version permanently authorizes you
   2.585 +to choose that version for the Program.
   2.586 +
   2.587 +  Later license versions may give you additional or different
   2.588 +permissions.  However, no additional obligations are imposed on any
   2.589 +author or copyright holder as a result of your choosing to follow a
   2.590 +later version.
   2.591 +
   2.592 +  15. Disclaimer of Warranty.
   2.593 +
   2.594 +  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
   2.595 +APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
   2.596 +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
   2.597 +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
   2.598 +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   2.599 +PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
   2.600 +IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
   2.601 +ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
   2.602 +
   2.603 +  16. Limitation of Liability.
   2.604 +
   2.605 +  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   2.606 +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
   2.607 +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
   2.608 +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
   2.609 +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
   2.610 +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
   2.611 +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
   2.612 +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
   2.613 +SUCH DAMAGES.
   2.614 +
   2.615 +  17. Interpretation of Sections 15 and 16.
   2.616 +
   2.617 +  If the disclaimer of warranty and limitation of liability provided
   2.618 +above cannot be given local legal effect according to their terms,
   2.619 +reviewing courts shall apply local law that most closely approximates
   2.620 +an absolute waiver of all civil liability in connection with the
   2.621 +Program, unless a warranty or assumption of liability accompanies a
   2.622 +copy of the Program in return for a fee.
   2.623 +
   2.624 +                     END OF TERMS AND CONDITIONS
   2.625 +
   2.626 +            How to Apply These Terms to Your New Programs
   2.627 +
   2.628 +  If you develop a new program, and you want it to be of the greatest
   2.629 +possible use to the public, the best way to achieve this is to make it
   2.630 +free software which everyone can redistribute and change under these terms.
   2.631 +
   2.632 +  To do so, attach the following notices to the program.  It is safest
   2.633 +to attach them to the start of each source file to most effectively
   2.634 +state the exclusion of warranty; and each file should have at least
   2.635 +the "copyright" line and a pointer to where the full notice is found.
   2.636 +
   2.637 +    <one line to give the program's name and a brief idea of what it does.>
   2.638 +    Copyright (C) <year>  <name of author>
   2.639 +
   2.640 +    This program is free software: you can redistribute it and/or modify
   2.641 +    it under the terms of the GNU General Public License as published by
   2.642 +    the Free Software Foundation, either version 3 of the License, or
   2.643 +    (at your option) any later version.
   2.644 +
   2.645 +    This program is distributed in the hope that it will be useful,
   2.646 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   2.647 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   2.648 +    GNU General Public License for more details.
   2.649 +
   2.650 +    You should have received a copy of the GNU General Public License
   2.651 +    along with this program.  If not, see <http://www.gnu.org/licenses/>.
   2.652 +
   2.653 +Also add information on how to contact you by electronic and paper mail.
   2.654 +
   2.655 +  If the program does terminal interaction, make it output a short
   2.656 +notice like this when it starts in an interactive mode:
   2.657 +
   2.658 +    <program>  Copyright (C) <year>  <name of author>
   2.659 +    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
   2.660 +    This is free software, and you are welcome to redistribute it
   2.661 +    under certain conditions; type `show c' for details.
   2.662 +
   2.663 +The hypothetical commands `show w' and `show c' should show the appropriate
   2.664 +parts of the General Public License.  Of course, your program's commands
   2.665 +might be different; for a GUI interface, you would use an "about box".
   2.666 +
   2.667 +  You should also get your employer (if you work as a programmer) or school,
   2.668 +if any, to sign a "copyright disclaimer" for the program, if necessary.
   2.669 +For more information on this, and how to apply and follow the GNU GPL, see
   2.670 +<http://www.gnu.org/licenses/>.
   2.671 +
   2.672 +  The GNU General Public License does not permit incorporating your program
   2.673 +into proprietary programs.  If your program is a subroutine library, you
   2.674 +may consider it more useful to permit linking proprietary applications with
   2.675 +the library.  If this is what you want to do, use the GNU Lesser General
   2.676 +Public License instead of this License.  But first, please read
   2.677 +<http://www.gnu.org/philosophy/why-not-lgpl.html>.

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/libs/imago/COPYING.LESSER	Sun Jun 07 17:25:49 2015 +0300
     3.3 @@ -0,0 +1,165 @@
     3.4 +                   GNU LESSER GENERAL PUBLIC LICENSE
     3.5 +                       Version 3, 29 June 2007
     3.6 +
     3.7 + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
     3.8 + Everyone is permitted to copy and distribute verbatim copies
     3.9 + of this license document, but changing it is not allowed.
    3.10 +
    3.11 +
    3.12 +  This version of the GNU Lesser General Public License incorporates
    3.13 +the terms and conditions of version 3 of the GNU General Public
    3.14 +License, supplemented by the additional permissions listed below.
    3.15 +
    3.16 +  0. Additional Definitions.
    3.17 +
    3.18 +  As used herein, "this License" refers to version 3 of the GNU Lesser
    3.19 +General Public License, and the "GNU GPL" refers to version 3 of the GNU
    3.20 +General Public License.
    3.21 +
    3.22 +  "The Library" refers to a covered work governed by this License,
    3.23 +other than an Application or a Combined Work as defined below.
    3.24 +
    3.25 +  An "Application" is any work that makes use of an interface provided
    3.26 +by the Library, but which is not otherwise based on the Library.
    3.27 +Defining a subclass of a class defined by the Library is deemed a mode
    3.28 +of using an interface provided by the Library.
    3.29 +
    3.30 +  A "Combined Work" is a work produced by combining or linking an
    3.31 +Application with the Library.  The particular version of the Library
    3.32 +with which the Combined Work was made is also called the "Linked
    3.33 +Version".
    3.34 +
    3.35 +  The "Minimal Corresponding Source" for a Combined Work means the
    3.36 +Corresponding Source for the Combined Work, excluding any source code
    3.37 +for portions of the Combined Work that, considered in isolation, are
    3.38 +based on the Application, and not on the Linked Version.
    3.39 +
    3.40 +  The "Corresponding Application Code" for a Combined Work means the
    3.41 +object code and/or source code for the Application, including any data
    3.42 +and utility programs needed for reproducing the Combined Work from the
    3.43 +Application, but excluding the System Libraries of the Combined Work.
    3.44 +
    3.45 +  1. Exception to Section 3 of the GNU GPL.
    3.46 +
    3.47 +  You may convey a covered work under sections 3 and 4 of this License
    3.48 +without being bound by section 3 of the GNU GPL.
    3.49 +
    3.50 +  2. Conveying Modified Versions.
    3.51 +
    3.52 +  If you modify a copy of the Library, and, in your modifications, a
    3.53 +facility refers to a function or data to be supplied by an Application
    3.54 +that uses the facility (other than as an argument passed when the
    3.55 +facility is invoked), then you may convey a copy of the modified
    3.56 +version:
    3.57 +
    3.58 +   a) under this License, provided that you make a good faith effort to
    3.59 +   ensure that, in the event an Application does not supply the
    3.60 +   function or data, the facility still operates, and performs
    3.61 +   whatever part of its purpose remains meaningful, or
    3.62 +
    3.63 +   b) under the GNU GPL, with none of the additional permissions of
    3.64 +   this License applicable to that copy.
    3.65 +
    3.66 +  3. Object Code Incorporating Material from Library Header Files.
    3.67 +
    3.68 +  The object code form of an Application may incorporate material from
    3.69 +a header file that is part of the Library.  You may convey such object
    3.70 +code under terms of your choice, provided that, if the incorporated
    3.71 +material is not limited to numerical parameters, data structure
    3.72 +layouts and accessors, or small macros, inline functions and templates
    3.73 +(ten or fewer lines in length), you do both of the following:
    3.74 +
    3.75 +   a) Give prominent notice with each copy of the object code that the
    3.76 +   Library is used in it and that the Library and its use are
    3.77 +   covered by this License.
    3.78 +
    3.79 +   b) Accompany the object code with a copy of the GNU GPL and this license
    3.80 +   document.
    3.81 +
    3.82 +  4. Combined Works.
    3.83 +
    3.84 +  You may convey a Combined Work under terms of your choice that,
    3.85 +taken together, effectively do not restrict modification of the
    3.86 +portions of the Library contained in the Combined Work and reverse
    3.87 +engineering for debugging such modifications, if you also do each of
    3.88 +the following:
    3.89 +
    3.90 +   a) Give prominent notice with each copy of the Combined Work that
    3.91 +   the Library is used in it and that the Library and its use are
    3.92 +   covered by this License.
    3.93 +
    3.94 +   b) Accompany the Combined Work with a copy of the GNU GPL and this license
    3.95 +   document.
    3.96 +
    3.97 +   c) For a Combined Work that displays copyright notices during
    3.98 +   execution, include the copyright notice for the Library among
    3.99 +   these notices, as well as a reference directing the user to the
   3.100 +   copies of the GNU GPL and this license document.
   3.101 +
   3.102 +   d) Do one of the following:
   3.103 +
   3.104 +       0) Convey the Minimal Corresponding Source under the terms of this
   3.105 +       License, and the Corresponding Application Code in a form
   3.106 +       suitable for, and under terms that permit, the user to
   3.107 +       recombine or relink the Application with a modified version of
   3.108 +       the Linked Version to produce a modified Combined Work, in the
   3.109 +       manner specified by section 6 of the GNU GPL for conveying
   3.110 +       Corresponding Source.
   3.111 +
   3.112 +       1) Use a suitable shared library mechanism for linking with the
   3.113 +       Library.  A suitable mechanism is one that (a) uses at run time
   3.114 +       a copy of the Library already present on the user's computer
   3.115 +       system, and (b) will operate properly with a modified version
   3.116 +       of the Library that is interface-compatible with the Linked
   3.117 +       Version.
   3.118 +
   3.119 +   e) Provide Installation Information, but only if you would otherwise
   3.120 +   be required to provide such information under section 6 of the
   3.121 +   GNU GPL, and only to the extent that such information is
   3.122 +   necessary to install and execute a modified version of the
   3.123 +   Combined Work produced by recombining or relinking the
   3.124 +   Application with a modified version of the Linked Version. (If
   3.125 +   you use option 4d0, the Installation Information must accompany
   3.126 +   the Minimal Corresponding Source and Corresponding Application
   3.127 +   Code. If you use option 4d1, you must provide the Installation
   3.128 +   Information in the manner specified by section 6 of the GNU GPL
   3.129 +   for conveying Corresponding Source.)
   3.130 +
   3.131 +  5. Combined Libraries.
   3.132 +
   3.133 +  You may place library facilities that are a work based on the
   3.134 +Library side by side in a single library together with other library
   3.135 +facilities that are not Applications and are not covered by this
   3.136 +License, and convey such a combined library under terms of your
   3.137 +choice, if you do both of the following:
   3.138 +
   3.139 +   a) Accompany the combined library with a copy of the same work based
   3.140 +   on the Library, uncombined with any other library facilities,
   3.141 +   conveyed under the terms of this License.
   3.142 +
   3.143 +   b) Give prominent notice with the combined library that part of it
   3.144 +   is a work based on the Library, and explaining where to find the
   3.145 +   accompanying uncombined form of the same work.
   3.146 +
   3.147 +  6. Revised Versions of the GNU Lesser General Public License.
   3.148 +
   3.149 +  The Free Software Foundation may publish revised and/or new versions
   3.150 +of the GNU Lesser General Public License from time to time. Such new
   3.151 +versions will be similar in spirit to the present version, but may
   3.152 +differ in detail to address new problems or concerns.
   3.153 +
   3.154 +  Each version is given a distinguishing version number. If the
   3.155 +Library as you received it specifies that a certain numbered version
   3.156 +of the GNU Lesser General Public License "or any later version"
   3.157 +applies to it, you have the option of following the terms and
   3.158 +conditions either of that published version or of any later version
   3.159 +published by the Free Software Foundation. If the Library as you
   3.160 +received it does not specify a version number of the GNU Lesser
   3.161 +General Public License, you may choose any version of the GNU Lesser
   3.162 +General Public License ever published by the Free Software Foundation.
   3.163 +
   3.164 +  If the Library as you received it specifies that a proxy can decide
   3.165 +whether future versions of the GNU Lesser General Public License shall
   3.166 +apply, that proxy's public statement of acceptance of any version is
   3.167 +permanent authorization for you to choose that version for the
   3.168 +Library.

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/imago/README.rst	Sun Jun 07 17:25:49 2015 +0300
     4.3 @@ -0,0 +1,49 @@
     4.4 +libimago
     4.5 +========
     4.6 +
     4.7 +Overview
     4.8 +--------
     4.9 +Imago is a simple C library for reading and writing images in many different
    4.10 +image file formats.
    4.11 +
    4.12 +Download
    4.13 +--------
    4.14 +Latest release: http://nuclear.mutantstargoat.com/sw/libimago/files/libimago-2.0.tar.gz
    4.15 +
    4.16 +Grab the source code from github: https://github.com/jtsiomb/libimago
    4.17 +
    4.18 +web site: http://nuclear.mutantstargoat.com/sw/libimago
    4.19 +
    4.20 +License
    4.21 +-------
    4.22 +
    4.23 +Copyright (C) 2011-2015 John Tsiombikas <nuclear@member.fsf.org>
    4.24 +
    4.25 +You may freely use, modify and/or redistribute libimago, under the terms of the
    4.26 +GNU Lesser General Public License (LGPL) version 3 (or at your option, any
    4.27 +later version published by the Free Software Foundation). See COPYING_ and
    4.28 +COPYING.LESSER_ for details.
    4.29 +
    4.30 +Usage example
    4.31 +-------------
    4.32 +
    4.33 +heck out the example program under ``test/``, and the *heavily*
    4.34 +commented ``imago2.h`` header file, to find out how to use libimago.
    4.35 +
    4.36 +The simplest way to load image data in RGBA 32bit is:
    4.37 +
    4.38 +.. code:: c
    4.39 +
    4.40 + int width, height;
    4.41 + unsigned char *pixels = img_load_pixels("foo.png", &width, &height, IMG_FMT_RGBA32);
    4.42 + img_free_pixels(pixels);
    4.43 +
    4.44 +There's also an optional interface for loading an image and creating an OpenGL
    4.45 +texture out of it in a single call:
    4.46 +
    4.47 +.. code:: c
    4.48 +
    4.49 + unsigned int texture = img_gltexture_load("foo.png");
    4.50 +
    4.51 +.. _COPYING: http://www.gnu.org/licenses/gpl
    4.52 +.. _COPYING.LESSER: http://www.gnu.org/licenses/lgpl

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/imago/conv.c	Sun Jun 07 17:25:49 2015 +0300
     5.3 @@ -0,0 +1,260 @@
     5.4 +/*
     5.5 +libimago - a multi-format image file input/output library.
     5.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     5.7 +
     5.8 +This program is free software: you can redistribute it and/or modify
     5.9 +it under the terms of the GNU Lesser General Public License as published
    5.10 +by the Free Software Foundation, either version 3 of the License, or
    5.11 +(at your option) any later version.
    5.12 +
    5.13 +This program is distributed in the hope that it will be useful,
    5.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    5.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    5.16 +GNU Lesser General Public License for more details.
    5.17 +
    5.18 +You should have received a copy of the GNU Lesser General Public License
    5.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    5.20 +*/
    5.21 +#include <string.h>
    5.22 +#include "imago2.h"
    5.23 +
    5.24 +/* pixel-format conversions are sub-optimal at the moment to avoid
    5.25 + * writing a lot of code. optimize at some point ?
    5.26 + */
    5.27 +
    5.28 +#define CLAMP(x, a, b)	((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
    5.29 +
    5.30 +struct pixel {
    5.31 +	float r, g, b, a;
    5.32 +};
    5.33 +
    5.34 +static void unpack_grey8(struct pixel *unp, void *pptr, int count);
    5.35 +static void unpack_rgb24(struct pixel *unp, void *pptr, int count);
    5.36 +static void unpack_rgba32(struct pixel *unp, void *pptr, int count);
    5.37 +static void unpack_greyf(struct pixel *unp, void *pptr, int count);
    5.38 +static void unpack_rgbf(struct pixel *unp, void *pptr, int count);
    5.39 +static void unpack_rgbaf(struct pixel *unp, void *pptr, int count);
    5.40 +
    5.41 +static void pack_grey8(void *pptr, struct pixel *unp, int count);
    5.42 +static void pack_rgb24(void *pptr, struct pixel *unp, int count);
    5.43 +static void pack_rgba32(void *pptr, struct pixel *unp, int count);
    5.44 +static void pack_greyf(void *pptr, struct pixel *unp, int count);
    5.45 +static void pack_rgbf(void *pptr, struct pixel *unp, int count);
    5.46 +static void pack_rgbaf(void *pptr, struct pixel *unp, int count);
    5.47 +
    5.48 +/* XXX keep in sync with enum img_fmt at imago2.h */
    5.49 +static void (*unpack[])(struct pixel*, void*, int) = {
    5.50 +	unpack_grey8,
    5.51 +	unpack_rgb24,
    5.52 +	unpack_rgba32,
    5.53 +	unpack_greyf,
    5.54 +	unpack_rgbf,
    5.55 +	unpack_rgbaf
    5.56 +};
    5.57 +
    5.58 +/* XXX keep in sync with enum img_fmt at imago2.h */
    5.59 +static void (*pack[])(void*, struct pixel*, int) = {
    5.60 +	pack_grey8,
    5.61 +	pack_rgb24,
    5.62 +	pack_rgba32,
    5.63 +	pack_greyf,
    5.64 +	pack_rgbf,
    5.65 +	pack_rgbaf
    5.66 +};
    5.67 +
    5.68 +
    5.69 +int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
    5.70 +{
    5.71 +	struct pixel pbuf[8];
    5.72 +	int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
    5.73 +	int i, num_pix = img->width * img->height;
    5.74 +	int num_iter = num_pix / bufsz;
    5.75 +	char *sptr, *dptr;
    5.76 +	struct img_pixmap nimg;
    5.77 +
    5.78 +	if(img->fmt == tofmt) {
    5.79 +		return 0;	/* nothing to do */
    5.80 +	}
    5.81 +
    5.82 +	img_init(&nimg);
    5.83 +	if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
    5.84 +		img_destroy(&nimg);
    5.85 +		return -1;
    5.86 +	}
    5.87 +
    5.88 +	sptr = img->pixels;
    5.89 +	dptr = nimg.pixels;
    5.90 +
    5.91 +	for(i=0; i<num_iter; i++) {
    5.92 +		unpack[img->fmt](pbuf, sptr, bufsz);
    5.93 +		pack[tofmt](dptr, pbuf, bufsz);
    5.94 +
    5.95 +		sptr += bufsz * img->pixelsz;
    5.96 +		dptr += bufsz * nimg.pixelsz;
    5.97 +	}
    5.98 +
    5.99 +	img_copy(img, &nimg);
   5.100 +	img_destroy(&nimg);
   5.101 +	return 0;
   5.102 +}
   5.103 +
   5.104 +/* the following functions *could* benefit from SIMD */
   5.105 +
   5.106 +static void unpack_grey8(struct pixel *unp, void *pptr, int count)
   5.107 +{
   5.108 +	int i;
   5.109 +	unsigned char *pix = pptr;
   5.110 +
   5.111 +	for(i=0; i<count; i++) {
   5.112 +		unp->r = unp->g = unp->b = (float)*pix++ / 255.0;
   5.113 +		unp->a = 1.0;
   5.114 +		unp++;
   5.115 +	}
   5.116 +}
   5.117 +
   5.118 +static void unpack_rgb24(struct pixel *unp, void *pptr, int count)
   5.119 +{
   5.120 +	int i;
   5.121 +	unsigned char *pix = pptr;
   5.122 +
   5.123 +	for(i=0; i<count; i++) {
   5.124 +		unp->r = (float)*pix++ / 255.0;
   5.125 +		unp->g = (float)*pix++ / 255.0;
   5.126 +		unp->b = (float)*pix++ / 255.0;
   5.127 +		unp->a = 1.0;
   5.128 +		unp++;
   5.129 +	}
   5.130 +}
   5.131 +
   5.132 +static void unpack_rgba32(struct pixel *unp, void *pptr, int count)
   5.133 +{
   5.134 +	int i;
   5.135 +	unsigned char *pix = pptr;
   5.136 +
   5.137 +	for(i=0; i<count; i++) {
   5.138 +		unp->r = (float)*pix++ / 255.0;
   5.139 +		unp->g = (float)*pix++ / 255.0;
   5.140 +		unp->b = (float)*pix++ / 255.0;
   5.141 +		unp->a = (float)*pix++ / 255.0;
   5.142 +		unp++;
   5.143 +	}
   5.144 +}
   5.145 +
   5.146 +static void unpack_greyf(struct pixel *unp, void *pptr, int count)
   5.147 +{
   5.148 +	int i;
   5.149 +	float *pix = pptr;
   5.150 +
   5.151 +	for(i=0; i<count; i++) {
   5.152 +		unp->r = unp->g = unp->b = *pix++;
   5.153 +		unp->a = 1.0;
   5.154 +		unp++;
   5.155 +	}
   5.156 +}
   5.157 +
   5.158 +static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
   5.159 +{
   5.160 +	int i;
   5.161 +	float *pix = pptr;
   5.162 +
   5.163 +	for(i=0; i<count; i++) {
   5.164 +		unp->r = *pix++;
   5.165 +		unp->g = *pix++;
   5.166 +		unp->b = *pix++;
   5.167 +		unp->a = 1.0;
   5.168 +		unp++;
   5.169 +	}
   5.170 +}
   5.171 +
   5.172 +static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
   5.173 +{
   5.174 +	int i;
   5.175 +	float *pix = pptr;
   5.176 +
   5.177 +	for(i=0; i<count; i++) {
   5.178 +		unp->r = *pix++;
   5.179 +		unp->g = *pix++;
   5.180 +		unp->b = *pix++;
   5.181 +		unp->a = *pix++;
   5.182 +		unp++;
   5.183 +	}
   5.184 +}
   5.185 +
   5.186 +
   5.187 +static void pack_grey8(void *pptr, struct pixel *unp, int count)
   5.188 +{
   5.189 +	int i;
   5.190 +	unsigned char *pix = pptr;
   5.191 +
   5.192 +	for(i=0; i<count; i++) {
   5.193 +		int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
   5.194 +		*pix++ = CLAMP(lum, 0, 255);
   5.195 +		unp++;
   5.196 +	}
   5.197 +}
   5.198 +
   5.199 +static void pack_rgb24(void *pptr, struct pixel *unp, int count)
   5.200 +{
   5.201 +	int i;
   5.202 +	unsigned char *pix = pptr;
   5.203 +
   5.204 +	for(i=0; i<count; i++) {
   5.205 +		int r = (int)(unp->r * 255.0);
   5.206 +		int g = (int)(unp->g * 255.0);
   5.207 +		int b = (int)(unp->b * 255.0);
   5.208 +
   5.209 +		*pix++ = CLAMP(r, 0, 255);
   5.210 +		*pix++ = CLAMP(g, 0, 255);
   5.211 +		*pix++ = CLAMP(b, 0, 255);
   5.212 +		unp++;
   5.213 +	}
   5.214 +}
   5.215 +
   5.216 +static void pack_rgba32(void *pptr, struct pixel *unp, int count)
   5.217 +{
   5.218 +	int i;
   5.219 +	unsigned char *pix = pptr;
   5.220 +
   5.221 +	for(i=0; i<count; i++) {
   5.222 +		int r = (int)(unp->r * 255.0);
   5.223 +		int g = (int)(unp->g * 255.0);
   5.224 +		int b = (int)(unp->b * 255.0);
   5.225 +		int a = (int)(unp->a * 255.0);
   5.226 +
   5.227 +		*pix++ = CLAMP(r, 0, 255);
   5.228 +		*pix++ = CLAMP(g, 0, 255);
   5.229 +		*pix++ = CLAMP(b, 0, 255);
   5.230 +		*pix++ = CLAMP(a, 0, 255);
   5.231 +		unp++;
   5.232 +	}
   5.233 +}
   5.234 +
   5.235 +static void pack_greyf(void *pptr, struct pixel *unp, int count)
   5.236 +{
   5.237 +	int i;
   5.238 +	float *pix = pptr;
   5.239 +
   5.240 +	for(i=0; i<count; i++) {
   5.241 +		*pix++ = (unp->r + unp->g + unp->b) / 3.0;
   5.242 +		unp++;
   5.243 +	}
   5.244 +}
   5.245 +
   5.246 +static void pack_rgbf(void *pptr, struct pixel *unp, int count)
   5.247 +{
   5.248 +	int i;
   5.249 +	float *pix = pptr;
   5.250 +
   5.251 +	for(i=0; i<count; i++) {
   5.252 +		*pix++ = unp->r;
   5.253 +		*pix++ = unp->g;
   5.254 +		*pix++ = unp->b;
   5.255 +		unp++;
   5.256 +	}
   5.257 +}
   5.258 +
   5.259 +static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
   5.260 +{
   5.261 +	memcpy(pptr, unp, count * sizeof *unp);
   5.262 +}
   5.263 +

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/imago/file_jpeg.c	Sun Jun 07 17:25:49 2015 +0300
     6.3 @@ -0,0 +1,294 @@
     6.4 +/*
     6.5 +libimago - a multi-format image file input/output library.
     6.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     6.7 +
     6.8 +This program is free software: you can redistribute it and/or modify
     6.9 +it under the terms of the GNU Lesser General Public License as published
    6.10 +by the Free Software Foundation, either version 3 of the License, or
    6.11 +(at your option) any later version.
    6.12 +
    6.13 +This program is distributed in the hope that it will be useful,
    6.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    6.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    6.16 +GNU Lesser General Public License for more details.
    6.17 +
    6.18 +You should have received a copy of the GNU Lesser General Public License
    6.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    6.20 +*/
    6.21 +
    6.22 +/* -- JPEG module -- */
    6.23 +
    6.24 +#include <stdio.h>
    6.25 +#include <stdlib.h>
    6.26 +#include <string.h>
    6.27 +
    6.28 +#ifdef WIN32
    6.29 +#include <windows.h>
    6.30 +#define HAVE_BOOLEAN
    6.31 +#endif
    6.32 +
    6.33 +#include <jpeglib.h>
    6.34 +#include "imago2.h"
    6.35 +#include "ftype_module.h"
    6.36 +
    6.37 +#define INPUT_BUF_SIZE	512
    6.38 +#define OUTPUT_BUF_SIZE	512
    6.39 +
    6.40 +/* data source manager: adapted from jdatasrc.c */
    6.41 +struct src_mgr {
    6.42 +	struct jpeg_source_mgr pub;
    6.43 +
    6.44 +	struct img_io *io;
    6.45 +	unsigned char buffer[INPUT_BUF_SIZE];
    6.46 +	int start_of_file;
    6.47 +};
    6.48 +
    6.49 +/* data destination manager: adapted from jdatadst.c */
    6.50 +struct dst_mgr {
    6.51 +	struct jpeg_destination_mgr pub;
    6.52 +
    6.53 +	struct img_io *io;
    6.54 +	unsigned char buffer[OUTPUT_BUF_SIZE];
    6.55 +};
    6.56 +
    6.57 +static int check(struct img_io *io);
    6.58 +static int read(struct img_pixmap *img, struct img_io *io);
    6.59 +static int write(struct img_pixmap *img, struct img_io *io);
    6.60 +
    6.61 +/* read source functions */
    6.62 +static void init_source(j_decompress_ptr jd);
    6.63 +static boolean fill_input_buffer(j_decompress_ptr jd);
    6.64 +static void skip_input_data(j_decompress_ptr jd, long num_bytes);
    6.65 +static void term_source(j_decompress_ptr jd);
    6.66 +
    6.67 +/* write destination functions */
    6.68 +static void init_destination(j_compress_ptr jc);
    6.69 +static boolean empty_output_buffer(j_compress_ptr jc);
    6.70 +static void term_destination(j_compress_ptr jc);
    6.71 +
    6.72 +int img_register_jpeg(void)
    6.73 +{
    6.74 +	static struct ftype_module mod = {".jpg", check, read, write};
    6.75 +	return img_register_module(&mod);
    6.76 +}
    6.77 +
    6.78 +
    6.79 +static int check(struct img_io *io)
    6.80 +{
    6.81 +	unsigned char sig[10];
    6.82 +
    6.83 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    6.84 +
    6.85 +	if(io->read(sig, 10, io->uptr) < 10) {
    6.86 +		io->seek(pos, SEEK_SET, io->uptr);
    6.87 +		return -1;
    6.88 +	}
    6.89 +
    6.90 +	if(memcmp(sig, "\xff\xd8\xff\xe0", 4) != 0 && memcmp(sig, "\xff\xd8\xff\xe1", 4) != 0
    6.91 +			&& memcmp(sig + 6, "JFIF", 4) != 0) {
    6.92 +		io->seek(pos, SEEK_SET, io->uptr);
    6.93 +		return -1;
    6.94 +	}
    6.95 +	io->seek(pos, SEEK_SET, io->uptr);
    6.96 +	return 0;
    6.97 +}
    6.98 +
    6.99 +static int read(struct img_pixmap *img, struct img_io *io)
   6.100 +{
   6.101 +	int i, nlines = 0;
   6.102 +	struct jpeg_decompress_struct cinfo;
   6.103 +	struct jpeg_error_mgr jerr;
   6.104 +	struct src_mgr src;
   6.105 +	unsigned char **scanlines;
   6.106 +
   6.107 +	io->seek(0, SEEK_CUR, io->uptr);
   6.108 +
   6.109 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX change... */
   6.110 +	jpeg_create_decompress(&cinfo);
   6.111 +
   6.112 +	src.pub.init_source = init_source;
   6.113 +	src.pub.fill_input_buffer = fill_input_buffer;
   6.114 +	src.pub.skip_input_data = skip_input_data;
   6.115 +	src.pub.resync_to_restart = jpeg_resync_to_restart;
   6.116 +	src.pub.term_source = term_source;
   6.117 +	src.pub.next_input_byte = 0;
   6.118 +	src.pub.bytes_in_buffer = 0;
   6.119 +	src.io = io;
   6.120 +	cinfo.src = (struct jpeg_source_mgr*)&src;
   6.121 +
   6.122 +	jpeg_read_header(&cinfo, 1);
   6.123 +	cinfo.out_color_space = JCS_RGB;
   6.124 +
   6.125 +	if(img_set_pixels(img, cinfo.image_width, cinfo.image_height, IMG_FMT_RGB24, 0) == -1) {
   6.126 +		jpeg_destroy_decompress(&cinfo);
   6.127 +		return -1;
   6.128 +	}
   6.129 +
   6.130 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   6.131 +		jpeg_destroy_decompress(&cinfo);
   6.132 +		return -1;
   6.133 +	}
   6.134 +	scanlines[0] = img->pixels;
   6.135 +	for(i=1; i<img->height; i++) {
   6.136 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   6.137 +	}
   6.138 +
   6.139 +	jpeg_start_decompress(&cinfo);
   6.140 +	while(nlines < img->height) {
   6.141 +		int res = jpeg_read_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   6.142 +		nlines += res;
   6.143 +	}
   6.144 +	jpeg_finish_decompress(&cinfo);
   6.145 +	jpeg_destroy_decompress(&cinfo);
   6.146 +
   6.147 +	free(scanlines);
   6.148 +	return 0;
   6.149 +}
   6.150 +
   6.151 +static int write(struct img_pixmap *img, struct img_io *io)
   6.152 +{
   6.153 +	int i, nlines = 0;
   6.154 +	struct jpeg_compress_struct cinfo;
   6.155 +	struct jpeg_error_mgr jerr;
   6.156 +	struct dst_mgr dest;
   6.157 +	struct img_pixmap tmpimg;
   6.158 +	unsigned char **scanlines;
   6.159 +
   6.160 +	img_init(&tmpimg);
   6.161 +
   6.162 +	if(img->fmt != IMG_FMT_RGB24) {
   6.163 +		if(img_copy(&tmpimg, img) == -1) {
   6.164 +			return -1;
   6.165 +		}
   6.166 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   6.167 +			img_destroy(&tmpimg);
   6.168 +			return -1;
   6.169 +		}
   6.170 +		img = &tmpimg;
   6.171 +	}
   6.172 +
   6.173 +	if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
   6.174 +		img_destroy(&tmpimg);
   6.175 +		return -1;
   6.176 +	}
   6.177 +	scanlines[0] = img->pixels;
   6.178 +	for(i=1; i<img->height; i++) {
   6.179 +		scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
   6.180 +	}
   6.181 +
   6.182 +	cinfo.err = jpeg_std_error(&jerr);	/* XXX */
   6.183 +	jpeg_create_compress(&cinfo);
   6.184 +
   6.185 +	dest.pub.init_destination = init_destination;
   6.186 +	dest.pub.empty_output_buffer = empty_output_buffer;
   6.187 +	dest.pub.term_destination = term_destination;
   6.188 +	dest.io = io;
   6.189 +	cinfo.dest = (struct jpeg_destination_mgr*)&dest;
   6.190 +
   6.191 +	cinfo.image_width = img->width;
   6.192 +	cinfo.image_height = img->height;
   6.193 +	cinfo.input_components = 3;
   6.194 +	cinfo.in_color_space = JCS_RGB;
   6.195 +
   6.196 +	jpeg_set_defaults(&cinfo);
   6.197 +
   6.198 +	jpeg_start_compress(&cinfo, 1);
   6.199 +	while(nlines < img->height) {
   6.200 +		int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
   6.201 +		nlines += res;
   6.202 +	}
   6.203 +	jpeg_finish_compress(&cinfo);
   6.204 +	jpeg_destroy_compress(&cinfo);
   6.205 +
   6.206 +	free(scanlines);
   6.207 +	img_destroy(&tmpimg);
   6.208 +	return 0;
   6.209 +}
   6.210 +
   6.211 +/* -- read source functions --
   6.212 + * the following functions are adapted from jdatasrc.c in jpeglib
   6.213 + */
   6.214 +static void init_source(j_decompress_ptr jd)
   6.215 +{
   6.216 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   6.217 +	src->start_of_file = 1;
   6.218 +}
   6.219 +
   6.220 +static boolean fill_input_buffer(j_decompress_ptr jd)
   6.221 +{
   6.222 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   6.223 +	size_t nbytes;
   6.224 +
   6.225 +	nbytes = src->io->read(src->buffer, INPUT_BUF_SIZE, src->io->uptr);
   6.226 +
   6.227 +	if(nbytes <= 0) {
   6.228 +		if(src->start_of_file) {
   6.229 +			return 0;
   6.230 +		}
   6.231 +		/* insert a fake EOI marker */
   6.232 +		src->buffer[0] = 0xff;
   6.233 +		src->buffer[1] = JPEG_EOI;
   6.234 +		nbytes = 2;
   6.235 +	}
   6.236 +
   6.237 +	src->pub.next_input_byte = src->buffer;
   6.238 +	src->pub.bytes_in_buffer = nbytes;
   6.239 +	src->start_of_file = 0;
   6.240 +	return 1;
   6.241 +}
   6.242 +
   6.243 +static void skip_input_data(j_decompress_ptr jd, long num_bytes)
   6.244 +{
   6.245 +	struct src_mgr *src = (struct src_mgr*)jd->src;
   6.246 +
   6.247 +	if(num_bytes > 0) {
   6.248 +		while(num_bytes > (long)src->pub.bytes_in_buffer) {
   6.249 +			num_bytes -= (long)src->pub.bytes_in_buffer;
   6.250 +			fill_input_buffer(jd);
   6.251 +		}
   6.252 +		src->pub.next_input_byte += (size_t)num_bytes;
   6.253 +		src->pub.bytes_in_buffer -= (size_t)num_bytes;
   6.254 +	}
   6.255 +}
   6.256 +
   6.257 +static void term_source(j_decompress_ptr jd)
   6.258 +{
   6.259 +	/* nothing to see here, move along */
   6.260 +}
   6.261 +
   6.262 +
   6.263 +/* -- write destination functions --
   6.264 + * the following functions are adapted from jdatadst.c in jpeglib
   6.265 + */
   6.266 +static void init_destination(j_compress_ptr jc)
   6.267 +{
   6.268 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   6.269 +
   6.270 +	dest->pub.next_output_byte = dest->buffer;
   6.271 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   6.272 +}
   6.273 +
   6.274 +static boolean empty_output_buffer(j_compress_ptr jc)
   6.275 +{
   6.276 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   6.277 +
   6.278 +	if(dest->io->write(dest->buffer, OUTPUT_BUF_SIZE, dest->io->uptr) != OUTPUT_BUF_SIZE) {
   6.279 +		return 0;
   6.280 +	}
   6.281 +
   6.282 +	dest->pub.next_output_byte = dest->buffer;
   6.283 +	dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
   6.284 +	return 1;
   6.285 +}
   6.286 +
   6.287 +static void term_destination(j_compress_ptr jc)
   6.288 +{
   6.289 +	struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
   6.290 +	size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
   6.291 +
   6.292 +	/* write any remaining data in the buffer */
   6.293 +	if(datacount > 0) {
   6.294 +		dest->io->write(dest->buffer, datacount, dest->io->uptr);
   6.295 +	}
   6.296 +	/* XXX flush? ... */
   6.297 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/imago/file_png.c	Sun Jun 07 17:25:49 2015 +0300
     7.3 @@ -0,0 +1,261 @@
     7.4 +/*
     7.5 +libimago - a multi-format image file input/output library.
     7.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     7.7 +
     7.8 +This program is free software: you can redistribute it and/or modify
     7.9 +it under the terms of the GNU Lesser General Public License as published
    7.10 +by the Free Software Foundation, either version 3 of the License, or
    7.11 +(at your option) any later version.
    7.12 +
    7.13 +This program is distributed in the hope that it will be useful,
    7.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    7.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    7.16 +GNU Lesser General Public License for more details.
    7.17 +
    7.18 +You should have received a copy of the GNU Lesser General Public License
    7.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    7.20 +*/
    7.21 +
    7.22 +/* -- PNG module -- */
    7.23 +
    7.24 +#include <stdlib.h>
    7.25 +#include <png.h>
    7.26 +#include "imago2.h"
    7.27 +#include "ftype_module.h"
    7.28 +
    7.29 +static int check_file(struct img_io *io);
    7.30 +static int read_file(struct img_pixmap *img, struct img_io *io);
    7.31 +static int write_file(struct img_pixmap *img, struct img_io *io);
    7.32 +
    7.33 +static void read_func(png_struct *png, unsigned char *data, size_t len);
    7.34 +static void write_func(png_struct *png, unsigned char *data, size_t len);
    7.35 +static void flush_func(png_struct *png);
    7.36 +
    7.37 +static int png_type_to_fmt(int color_type, int channel_bits);
    7.38 +static int fmt_to_png_type(enum img_fmt fmt);
    7.39 +
    7.40 +
    7.41 +int img_register_png(void)
    7.42 +{
    7.43 +	static struct ftype_module mod = {".png", check_file, read_file, write_file};
    7.44 +	return img_register_module(&mod);
    7.45 +}
    7.46 +
    7.47 +static int check_file(struct img_io *io)
    7.48 +{
    7.49 +	unsigned char sig[8];
    7.50 +	int res;
    7.51 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    7.52 +
    7.53 +	if(io->read(sig, 8, io->uptr) < 8) {
    7.54 +		io->seek(pos, SEEK_SET, io->uptr);
    7.55 +		return -1;
    7.56 +	}
    7.57 +
    7.58 +	res = png_sig_cmp(sig, 0, 8) == 0 ? 0 : -1;
    7.59 +	io->seek(pos, SEEK_SET, io->uptr);
    7.60 +	return res;
    7.61 +}
    7.62 +
    7.63 +static int read_file(struct img_pixmap *img, struct img_io *io)
    7.64 +{
    7.65 +	png_struct *png;
    7.66 +	png_info *info;
    7.67 +	int channel_bits, color_type, ilace_type, compression, filtering, fmt;
    7.68 +	png_uint_32 xsz, ysz;
    7.69 +
    7.70 +	if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
    7.71 +		return -1;
    7.72 +	}
    7.73 +
    7.74 +	if(!(info = png_create_info_struct(png))) {
    7.75 +		png_destroy_read_struct(&png, 0, 0);
    7.76 +		return -1;
    7.77 +	}
    7.78 +
    7.79 +	if(setjmp(png_jmpbuf(png))) {
    7.80 +		png_destroy_read_struct(&png, &info, 0);
    7.81 +		return -1;
    7.82 +	}
    7.83 +
    7.84 +	png_set_read_fn(png, io, read_func);
    7.85 +	png_set_sig_bytes(png, 0);
    7.86 +	png_read_png(png, info, 0, 0);
    7.87 +
    7.88 +	png_get_IHDR(png, info, &xsz, &ysz, &channel_bits, &color_type, &ilace_type,
    7.89 +			&compression, &filtering);
    7.90 +	if((fmt = png_type_to_fmt(color_type, channel_bits)) == -1) {
    7.91 +		png_destroy_read_struct(&png, &info, 0);
    7.92 +		return -1;
    7.93 +	}
    7.94 +
    7.95 +	if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
    7.96 +		png_destroy_read_struct(&png, &info, 0);
    7.97 +		return -1;
    7.98 +	}
    7.99 +
   7.100 +
   7.101 +	if(channel_bits == 8) {
   7.102 +		unsigned int i;
   7.103 +		unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
   7.104 +		unsigned char *dest = img->pixels;
   7.105 +
   7.106 +		for(i=0; i<ysz; i++) {
   7.107 +			memcpy(dest, lineptr[i], xsz * img->pixelsz);
   7.108 +			dest += xsz * img->pixelsz;
   7.109 +		}
   7.110 +	} else {
   7.111 +		unsigned int i, j, num_elem;
   7.112 +		unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
   7.113 +		float *dest = img->pixels;
   7.114 +
   7.115 +		num_elem = img->pixelsz / sizeof(float);
   7.116 +		for(i=0; i<ysz; i++) {
   7.117 +			for(j=0; j<xsz * num_elem; j++) {
   7.118 +				unsigned short val = (lineptr[i][j * 2] << 8) | lineptr[i][j * 2 + 1];
   7.119 +				*dest++ = (float)val / 65535.0;
   7.120 +			}
   7.121 +		}
   7.122 +	}
   7.123 +
   7.124 +
   7.125 +	png_destroy_read_struct(&png, &info, 0);
   7.126 +	return 0;
   7.127 +}
   7.128 +
   7.129 +
   7.130 +static int write_file(struct img_pixmap *img, struct img_io *io)
   7.131 +{
   7.132 +	png_struct *png;
   7.133 +	png_info *info;
   7.134 +	png_text txt;
   7.135 +	struct img_pixmap tmpimg;
   7.136 +	unsigned char **rows;
   7.137 +	unsigned char *pixptr;
   7.138 +	int i, coltype;
   7.139 +
   7.140 +	img_init(&tmpimg);
   7.141 +
   7.142 +	if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
   7.143 +		return -1;
   7.144 +	}
   7.145 +	if(!(info = png_create_info_struct(png))) {
   7.146 +		png_destroy_write_struct(&png, 0);
   7.147 +		return -1;
   7.148 +	}
   7.149 +
   7.150 +	/* if the input image is floating-point, we need to convert it to integer */
   7.151 +	if(img_is_float(img)) {
   7.152 +		if(img_copy(&tmpimg, img) == -1) {
   7.153 +			return -1;
   7.154 +		}
   7.155 +		if(img_to_integer(&tmpimg) == -1) {
   7.156 +			img_destroy(&tmpimg);
   7.157 +			return -1;
   7.158 +		}
   7.159 +		img = &tmpimg;
   7.160 +	}
   7.161 +
   7.162 +	txt.compression = PNG_TEXT_COMPRESSION_NONE;
   7.163 +	txt.key = "Software";
   7.164 +	txt.text = "libimago2";
   7.165 +	txt.text_length = 0;
   7.166 +
   7.167 +	if(setjmp(png_jmpbuf(png))) {
   7.168 +		png_destroy_write_struct(&png, &info);
   7.169 +		img_destroy(&tmpimg);
   7.170 +		return -1;
   7.171 +	}
   7.172 +	png_set_write_fn(png, io, write_func, flush_func);
   7.173 +
   7.174 +	coltype = fmt_to_png_type(img->fmt);
   7.175 +	png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
   7.176 +			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
   7.177 +	png_set_text(png, info, &txt, 1);
   7.178 +
   7.179 +	if(!(rows = malloc(img->height * sizeof *rows))) {
   7.180 +		png_destroy_write_struct(&png, &info);
   7.181 +		img_destroy(&tmpimg);
   7.182 +		return -1;
   7.183 +	}
   7.184 +
   7.185 +	pixptr = img->pixels;
   7.186 +	for(i=0; i<img->height; i++) {
   7.187 +		rows[i] = pixptr;
   7.188 +		pixptr += img->width * img->pixelsz;
   7.189 +	}
   7.190 +	png_set_rows(png, info, rows);
   7.191 +
   7.192 +	png_write_png(png, info, 0, 0);
   7.193 +	png_write_end(png, info);
   7.194 +	png_destroy_write_struct(&png, &info);
   7.195 +
   7.196 +	free(rows);
   7.197 +
   7.198 +	img_destroy(&tmpimg);
   7.199 +	return 0;
   7.200 +}
   7.201 +
   7.202 +static void read_func(png_struct *png, unsigned char *data, size_t len)
   7.203 +{
   7.204 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   7.205 +
   7.206 +	if(io->read(data, len, io->uptr) == -1) {
   7.207 +		longjmp(png_jmpbuf(png), 1);
   7.208 +	}
   7.209 +}
   7.210 +
   7.211 +static void write_func(png_struct *png, unsigned char *data, size_t len)
   7.212 +{
   7.213 +	struct img_io *io = (struct img_io*)png_get_io_ptr(png);
   7.214 +
   7.215 +	if(io->write(data, len, io->uptr) == -1) {
   7.216 +		longjmp(png_jmpbuf(png), 1);
   7.217 +	}
   7.218 +}
   7.219 +
   7.220 +static void flush_func(png_struct *png)
   7.221 +{
   7.222 +	/* XXX does it matter that we can't flush? */
   7.223 +}
   7.224 +
   7.225 +static int png_type_to_fmt(int color_type, int channel_bits)
   7.226 +{
   7.227 +	/* only 8 and 16 bits per channel ar supported at the moment */
   7.228 +	if(channel_bits != 8 && channel_bits != 16) {
   7.229 +		return -1;
   7.230 +	}
   7.231 +
   7.232 +	switch(color_type) {
   7.233 +	case PNG_COLOR_TYPE_RGB:
   7.234 +		return channel_bits == 16 ? IMG_FMT_RGBF : IMG_FMT_RGB24;
   7.235 +
   7.236 +	case PNG_COLOR_TYPE_RGB_ALPHA:
   7.237 +		return channel_bits == 16 ? IMG_FMT_RGBAF : IMG_FMT_RGBA32;
   7.238 +
   7.239 +	case PNG_COLOR_TYPE_GRAY:
   7.240 +		return channel_bits == 16 ? IMG_FMT_GREYF : IMG_FMT_GREY8;
   7.241 +
   7.242 +	default:
   7.243 +		break;
   7.244 +	}
   7.245 +	return -1;
   7.246 +}
   7.247 +
   7.248 +static int fmt_to_png_type(enum img_fmt fmt)
   7.249 +{
   7.250 +	switch(fmt) {
   7.251 +	case IMG_FMT_GREY8:
   7.252 +		return PNG_COLOR_TYPE_GRAY;
   7.253 +
   7.254 +	case IMG_FMT_RGB24:
   7.255 +		return PNG_COLOR_TYPE_RGB;
   7.256 +
   7.257 +	case IMG_FMT_RGBA32:
   7.258 +		return PNG_COLOR_TYPE_RGBA;
   7.259 +
   7.260 +	default:
   7.261 +		break;
   7.262 +	}
   7.263 +	return -1;
   7.264 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/libs/imago/file_ppm.c	Sun Jun 07 17:25:49 2015 +0300
     8.3 @@ -0,0 +1,153 @@
     8.4 +/*
     8.5 +libimago - a multi-format image file input/output library.
     8.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
     8.7 +
     8.8 +This program is free software: you can redistribute it and/or modify
     8.9 +it under the terms of the GNU Lesser General Public License as published
    8.10 +by the Free Software Foundation, either version 3 of the License, or
    8.11 +(at your option) any later version.
    8.12 +
    8.13 +This program is distributed in the hope that it will be useful,
    8.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
    8.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    8.16 +GNU Lesser General Public License for more details.
    8.17 +
    8.18 +You should have received a copy of the GNU Lesser General Public License
    8.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
    8.20 +*/
    8.21 +
    8.22 +/* -- Portable Pixmap (PPM) module -- */
    8.23 +
    8.24 +#include <string.h>
    8.25 +#include "imago2.h"
    8.26 +#include "ftype_module.h"
    8.27 +
    8.28 +static int check(struct img_io *io);
    8.29 +static int read(struct img_pixmap *img, struct img_io *io);
    8.30 +static int write(struct img_pixmap *img, struct img_io *io);
    8.31 +
    8.32 +int img_register_ppm(void)
    8.33 +{
    8.34 +	static struct ftype_module mod = {".ppm", check, read, write};
    8.35 +	return img_register_module(&mod);
    8.36 +}
    8.37 +
    8.38 +
    8.39 +static int check(struct img_io *io)
    8.40 +{
    8.41 +	char id[2];
    8.42 +	int res = -1;
    8.43 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    8.44 +
    8.45 +	if(io->read(id, 2, io->uptr) < 2) {
    8.46 +		io->seek(pos, SEEK_SET, io->uptr);
    8.47 +		return -1;
    8.48 +	}
    8.49 +
    8.50 +	if(id[0] == 'P' && (id[1] == '6' || id[1] == '3')) {
    8.51 +		res = 0;
    8.52 +	}
    8.53 +	io->seek(pos, SEEK_SET, io->uptr);
    8.54 +	return res;
    8.55 +}
    8.56 +
    8.57 +static int iofgetc(struct img_io *io)
    8.58 +{
    8.59 +	char c;
    8.60 +	return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
    8.61 +}
    8.62 +
    8.63 +static char *iofgets(char *buf, int size, struct img_io *io)
    8.64 +{
    8.65 +	int c;
    8.66 +	char *ptr = buf;
    8.67 +
    8.68 +	while(--size > 0 && (c = iofgetc(io)) != -1) {
    8.69 +		*ptr++ = c;
    8.70 +		if(c == '\n') break;
    8.71 +	}
    8.72 +	*ptr = 0;
    8.73 +
    8.74 +	return ptr == buf ? 0 : buf;
    8.75 +}
    8.76 +
    8.77 +/* TODO: implement P3 reading */
    8.78 +static int read(struct img_pixmap *img, struct img_io *io)
    8.79 +{
    8.80 +	char buf[256];
    8.81 +	int xsz, ysz, maxval, got_hdrlines = 1;
    8.82 +
    8.83 +	if(!iofgets(buf, sizeof buf, io)) {
    8.84 +		return -1;
    8.85 +	}
    8.86 +	if(!(buf[0] == 'P' && (buf[1] == '6' || buf[1] == '3'))) {
    8.87 +		return -1;
    8.88 +	}
    8.89 +
    8.90 +	while(got_hdrlines < 3 && iofgets(buf, sizeof buf, io)) {
    8.91 +		if(buf[0] == '#') continue;
    8.92 +
    8.93 +		switch(got_hdrlines) {
    8.94 +		case 1:
    8.95 +			if(sscanf(buf, "%d %d\n", &xsz, &ysz) < 2) {
    8.96 +				return -1;
    8.97 +			}
    8.98 +			break;
    8.99 +
   8.100 +		case 2:
   8.101 +			if(sscanf(buf, "%d\n", &maxval) < 1) {
   8.102 +				return -1;
   8.103 +			}
   8.104 +		default:
   8.105 +			break;
   8.106 +		}
   8.107 +		got_hdrlines++;
   8.108 +	}
   8.109 +
   8.110 +	if(xsz < 1 || ysz < 1 || maxval != 255) {
   8.111 +		return -1;
   8.112 +	}
   8.113 +
   8.114 +	if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGB24, 0) == -1) {
   8.115 +		return -1;
   8.116 +	}
   8.117 +
   8.118 +	if(io->read(img->pixels, xsz * ysz * 3, io->uptr) < (unsigned int)(xsz * ysz * 3)) {
   8.119 +		return -1;
   8.120 +	}
   8.121 +	return 0;
   8.122 +}
   8.123 +
   8.124 +static int write(struct img_pixmap *img, struct img_io *io)
   8.125 +{
   8.126 +	int sz;
   8.127 +	char buf[256];
   8.128 +	struct img_pixmap tmpimg;
   8.129 +
   8.130 +	img_init(&tmpimg);
   8.131 +
   8.132 +	if(img->fmt != IMG_FMT_RGB24) {
   8.133 +		if(img_copy(&tmpimg, img) == -1) {
   8.134 +			return -1;
   8.135 +		}
   8.136 +		if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
   8.137 +			return -1;
   8.138 +		}
   8.139 +		img = &tmpimg;
   8.140 +	}
   8.141 +
   8.142 +	sprintf(buf, "P6\n#written by libimago2\n%d %d\n255\n", img->width, img->height);
   8.143 +	if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
   8.144 +		img_destroy(&tmpimg);
   8.145 +		return -1;
   8.146 +	}
   8.147 +
   8.148 +	sz = img->width * img->height * 3;
   8.149 +	if(io->write(img->pixels, sz, io->uptr) < (unsigned int)sz) {
   8.150 +		img_destroy(&tmpimg);
   8.151 +		return -1;
   8.152 +	}
   8.153 +
   8.154 +	img_destroy(&tmpimg);
   8.155 +	return 0;
   8.156 +}

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/libs/imago/file_rgbe.c	Sun Jun 07 17:25:49 2015 +0300
     9.3 @@ -0,0 +1,501 @@
     9.4 +/* This file contains code to read and write four byte rgbe file format
     9.5 + * developed by Greg Ward.  It handles the conversions between rgbe and
     9.6 + * pixels consisting of floats.  The data is assumed to be an array of floats.
     9.7 + * By default there are three floats per pixel in the order red, green, blue.
     9.8 + * (RGBE_DATA_??? values control this.)
     9.9 + *
    9.10 + * written by Bruce Walter  (bjw@graphics.cornell.edu)  5/26/95
    9.11 + * based on code written by Greg Ward
    9.12 + * minor modifications by John Tsiombikas (nuclear@member.fsf.org) apr.9 2007
    9.13 + */
    9.14 +
    9.15 +#include <stdio.h>
    9.16 +#include <stdlib.h>
    9.17 +#include <string.h>
    9.18 +#include <math.h>
    9.19 +#include <ctype.h>
    9.20 +#include <errno.h>
    9.21 +#include "imago2.h"
    9.22 +#include "ftype_module.h"
    9.23 +
    9.24 +
    9.25 +typedef struct {
    9.26 +	int valid;				/* indicate which fields are valid */
    9.27 +	char programtype[16];	/* listed at beginning of file to identify it
    9.28 +							 * after "#?".  defaults to "RGBE" */
    9.29 +	float gamma;			/* image has already been gamma corrected with
    9.30 +							 * given gamma.  defaults to 1.0 (no correction) */
    9.31 +	float exposure;			/* a value of 1.0 in an image corresponds to
    9.32 +							 * <exposure> watts/steradian/m^2.
    9.33 +							 * defaults to 1.0 */
    9.34 +} rgbe_header_info;
    9.35 +
    9.36 +
    9.37 +static int check(struct img_io *io);
    9.38 +static int read(struct img_pixmap *img, struct img_io *io);
    9.39 +static int write(struct img_pixmap *img, struct img_io *io);
    9.40 +
    9.41 +static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info);
    9.42 +static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines);
    9.43 +
    9.44 +
    9.45 +int img_register_rgbe(void)
    9.46 +{
    9.47 +	static struct ftype_module mod = {".rgbe", check, read, write};
    9.48 +	return img_register_module(&mod);
    9.49 +}
    9.50 +
    9.51 +
    9.52 +static int check(struct img_io *io)
    9.53 +{
    9.54 +	int xsz, ysz, res;
    9.55 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
    9.56 +
    9.57 +	rgbe_header_info hdr;
    9.58 +	res = rgbe_read_header(io, &xsz, &ysz, &hdr);
    9.59 +
    9.60 +	io->seek(pos, SEEK_SET, io->uptr);
    9.61 +	return res;
    9.62 +}
    9.63 +
    9.64 +static int read(struct img_pixmap *img, struct img_io *io)
    9.65 +{
    9.66 +	int xsz, ysz;
    9.67 +	rgbe_header_info hdr;
    9.68 +
    9.69 +	if(rgbe_read_header(io, &xsz, &ysz, &hdr) == -1) {
    9.70 +		return -1;
    9.71 +	}
    9.72 +
    9.73 +	if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGBF, 0) == -1) {
    9.74 +		return -1;
    9.75 +	}
    9.76 +	if(rgbe_read_pixels_rle(io, img->pixels, xsz, ysz) == -1) {
    9.77 +		return -1;
    9.78 +	}
    9.79 +	return 0;
    9.80 +}
    9.81 +
    9.82 +static int write(struct img_pixmap *img, struct img_io *io)
    9.83 +{
    9.84 +	return -1;	/* TODO */
    9.85 +}
    9.86 +
    9.87 +
    9.88 +static int iofgetc(struct img_io *io)
    9.89 +{
    9.90 +	char c;
    9.91 +	return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
    9.92 +}
    9.93 +
    9.94 +static char *iofgets(char *buf, int size, struct img_io *io)
    9.95 +{
    9.96 +	int c;
    9.97 +	char *ptr = buf;
    9.98 +
    9.99 +	while(--size > 0 && (c = iofgetc(io)) != -1) {
   9.100 +		*ptr++ = c;
   9.101 +		if(c == '\n') break;
   9.102 +	}
   9.103 +	*ptr = 0;
   9.104 +
   9.105 +	return ptr == buf ? 0 : buf;
   9.106 +}
   9.107 +
   9.108 +
   9.109 +/* flags indicating which fields in an rgbe_header_info are valid */
   9.110 +#define RGBE_VALID_PROGRAMTYPE 0x01
   9.111 +#define RGBE_VALID_GAMMA       0x02
   9.112 +#define RGBE_VALID_EXPOSURE    0x04
   9.113 +
   9.114 +/* return codes for rgbe routines */
   9.115 +#define RGBE_RETURN_SUCCESS 0
   9.116 +#define RGBE_RETURN_FAILURE -1
   9.117 +
   9.118 +
   9.119 +#if defined(__cplusplus) || defined(GNUC) || __STDC_VERSION >= 199901L
   9.120 +#define INLINE inline
   9.121 +#else
   9.122 +#define INLINE
   9.123 +#endif
   9.124 +
   9.125 +/* offsets to red, green, and blue components in a data (float) pixel */
   9.126 +#define RGBE_DATA_RED	0
   9.127 +#define RGBE_DATA_GREEN  1
   9.128 +#define RGBE_DATA_BLUE   2
   9.129 +
   9.130 +/* number of floats per pixel */
   9.131 +#define RGBE_DATA_SIZE   3
   9.132 +
   9.133 +enum rgbe_error_codes {
   9.134 +	rgbe_read_error,
   9.135 +	rgbe_write_error,
   9.136 +	rgbe_format_error,
   9.137 +	rgbe_memory_error
   9.138 +};
   9.139 +
   9.140 +
   9.141 +/* default error routine.  change this to change error handling */
   9.142 +static int rgbe_error(int rgbe_error_code, char *msg)
   9.143 +{
   9.144 +	switch (rgbe_error_code) {
   9.145 +	case rgbe_read_error:
   9.146 +		fprintf(stderr, "RGBE read error: %s\n", strerror(errno));
   9.147 +		break;
   9.148 +
   9.149 +	case rgbe_write_error:
   9.150 +		fprintf(stderr, "RGBE write error: %s\n", strerror(errno));
   9.151 +		break;
   9.152 +
   9.153 +	case rgbe_format_error:
   9.154 +		fprintf(stderr, "RGBE bad file format: %s\n", msg);
   9.155 +		break;
   9.156 +
   9.157 +	default:
   9.158 +	case rgbe_memory_error:
   9.159 +		fprintf(stderr, "RGBE error: %s\n", msg);
   9.160 +	}
   9.161 +	return RGBE_RETURN_FAILURE;
   9.162 +}
   9.163 +
   9.164 +/* standard conversion from float pixels to rgbe pixels */
   9.165 +/*static INLINE void float2rgbe(unsigned char rgbe[4], float red, float green, float blue)
   9.166 +{
   9.167 +	float v;
   9.168 +	int e;
   9.169 +
   9.170 +	v = red;
   9.171 +	if(green > v)
   9.172 +		v = green;
   9.173 +	if(blue > v)
   9.174 +		v = blue;
   9.175 +	if(v < 1e-32) {
   9.176 +		rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
   9.177 +	} else {
   9.178 +		v = frexp(v, &e) * 256.0 / v;
   9.179 +		rgbe[0] = (unsigned char)(red * v);
   9.180 +		rgbe[1] = (unsigned char)(green * v);
   9.181 +		rgbe[2] = (unsigned char)(blue * v);
   9.182 +		rgbe[3] = (unsigned char)(e + 128);
   9.183 +	}
   9.184 +}*/
   9.185 +
   9.186 +/* standard conversion from rgbe to float pixels */
   9.187 +/* note: Ward uses ldexp(col+0.5,exp-(128+8)). However we wanted pixels */
   9.188 +/*       in the range [0,1] to map back into the range [0,1]. */
   9.189 +static INLINE void rgbe2float(float *red, float *green, float *blue, unsigned char rgbe[4])
   9.190 +{
   9.191 +	float f;
   9.192 +
   9.193 +	if(rgbe[3]) {				/*nonzero pixel */
   9.194 +		f = ldexp(1.0, rgbe[3] - (int)(128 + 8));
   9.195 +		*red = rgbe[0] * f;
   9.196 +		*green = rgbe[1] * f;
   9.197 +		*blue = rgbe[2] * f;
   9.198 +	} else
   9.199 +		*red = *green = *blue = 0.0;
   9.200 +}
   9.201 +
   9.202 +#if 0
   9.203 +/* default minimal header. modify if you want more information in header */
   9.204 +static int rgbe_write_header(FILE * fp, int width, int height, rgbe_header_info * info)
   9.205 +{
   9.206 +	char *programtype = "RGBE";
   9.207 +
   9.208 +	if(info && (info->valid & RGBE_VALID_PROGRAMTYPE))
   9.209 +		programtype = info->programtype;
   9.210 +	if(fprintf(fp, "#?%s\n", programtype) < 0)
   9.211 +		return rgbe_error(rgbe_write_error, NULL);
   9.212 +	/* The #? is to identify file type, the programtype is optional. */
   9.213 +	if(info && (info->valid & RGBE_VALID_GAMMA)) {
   9.214 +		if(fprintf(fp, "GAMMA=%g\n", info->gamma) < 0)
   9.215 +			return rgbe_error(rgbe_write_error, NULL);
   9.216 +	}
   9.217 +	if(info && (info->valid & RGBE_VALID_EXPOSURE)) {
   9.218 +		if(fprintf(fp, "EXPOSURE=%g\n", info->exposure) < 0)
   9.219 +			return rgbe_error(rgbe_write_error, NULL);
   9.220 +	}
   9.221 +	if(fprintf(fp, "FORMAT=32-bit_rle_rgbe\n\n") < 0)
   9.222 +		return rgbe_error(rgbe_write_error, NULL);
   9.223 +	if(fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
   9.224 +		return rgbe_error(rgbe_write_error, NULL);
   9.225 +	return RGBE_RETURN_SUCCESS;
   9.226 +}
   9.227 +#endif
   9.228 +
   9.229 +/* minimal header reading.  modify if you want to parse more information */
   9.230 +static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info)
   9.231 +{
   9.232 +	char buf[128];
   9.233 +	float tempf;
   9.234 +	int i;
   9.235 +
   9.236 +	if(info) {
   9.237 +		info->valid = 0;
   9.238 +		info->programtype[0] = 0;
   9.239 +		info->gamma = info->exposure = 1.0;
   9.240 +	}
   9.241 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == NULL)
   9.242 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   9.243 +	if((buf[0] != '#') || (buf[1] != '?')) {
   9.244 +		/* if you want to require the magic token then uncomment the next line */
   9.245 +		/*return rgbe_error(rgbe_format_error,"bad initial token"); */
   9.246 +	} else if(info) {
   9.247 +		info->valid |= RGBE_VALID_PROGRAMTYPE;
   9.248 +		for(i = 0; i < sizeof(info->programtype) - 1; i++) {
   9.249 +			if((buf[i + 2] == 0) || isspace(buf[i + 2]))
   9.250 +				break;
   9.251 +			info->programtype[i] = buf[i + 2];
   9.252 +		}
   9.253 +		info->programtype[i] = 0;
   9.254 +		if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   9.255 +			return rgbe_error(rgbe_read_error, NULL);
   9.256 +	}
   9.257 +	for(;;) {
   9.258 +		if((buf[0] == 0) || (buf[0] == '\n'))
   9.259 +			return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "no FORMAT specifier found");*/
   9.260 +		else if(strcmp(buf, "FORMAT=32-bit_rle_rgbe\n") == 0)
   9.261 +			break;				/* format found so break out of loop */
   9.262 +		else if(info && (sscanf(buf, "GAMMA=%g", &tempf) == 1)) {
   9.263 +			info->gamma = tempf;
   9.264 +			info->valid |= RGBE_VALID_GAMMA;
   9.265 +		} else if(info && (sscanf(buf, "EXPOSURE=%g", &tempf) == 1)) {
   9.266 +			info->exposure = tempf;
   9.267 +			info->valid |= RGBE_VALID_EXPOSURE;
   9.268 +		}
   9.269 +		if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   9.270 +			return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   9.271 +	}
   9.272 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   9.273 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   9.274 +	if(strcmp(buf, "\n") != 0)
   9.275 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing blank line after FORMAT specifier");*/
   9.276 +	if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
   9.277 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
   9.278 +	if(sscanf(buf, "-Y %d +X %d", height, width) < 2)
   9.279 +		return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing image size specifier");*/
   9.280 +	return RGBE_RETURN_SUCCESS;
   9.281 +}
   9.282 +
   9.283 +#if 0
   9.284 +/* simple write routine that does not use run length encoding */
   9.285 +
   9.286 +/* These routines can be made faster by allocating a larger buffer and
   9.287 +   fread-ing and fwrite-ing the data in larger chunks */
   9.288 +static int rgbe_write_pixels(FILE * fp, float *data, int numpixels)
   9.289 +{
   9.290 +	unsigned char rgbe[4];
   9.291 +
   9.292 +	while(numpixels-- > 0) {
   9.293 +		float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
   9.294 +		data += RGBE_DATA_SIZE;
   9.295 +		if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
   9.296 +			return rgbe_error(rgbe_write_error, NULL);
   9.297 +	}
   9.298 +	return RGBE_RETURN_SUCCESS;
   9.299 +}
   9.300 +#endif
   9.301 +
   9.302 +/* simple read routine.  will not correctly handle run length encoding */
   9.303 +static int rgbe_read_pixels(struct img_io *io, float *data, int numpixels)
   9.304 +{
   9.305 +	unsigned char rgbe[4];
   9.306 +
   9.307 +	while(numpixels-- > 0) {
   9.308 +		if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1)
   9.309 +			return rgbe_error(rgbe_read_error, NULL);
   9.310 +		rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
   9.311 +		data += RGBE_DATA_SIZE;
   9.312 +	}
   9.313 +	return RGBE_RETURN_SUCCESS;
   9.314 +}
   9.315 +
   9.316 +#if 0
   9.317 +/* The code below is only needed for the run-length encoded files. */
   9.318 +
   9.319 +/* Run length encoding adds considerable complexity but does */
   9.320 +
   9.321 +/* save some space.  For each scanline, each channel (r,g,b,e) is */
   9.322 +
   9.323 +/* encoded separately for better compression. */
   9.324 +
   9.325 +static int rgbe_write_bytes_rle(struct img_io *io, unsigned char *data, int numbytes)
   9.326 +{
   9.327 +#define MINRUNLENGTH 4
   9.328 +	int cur, beg_run, run_count, old_run_count, nonrun_count;
   9.329 +	unsigned char buf[2];
   9.330 +
   9.331 +	cur = 0;
   9.332 +	while(cur < numbytes) {
   9.333 +		beg_run = cur;
   9.334 +		/* find next run of length at least 4 if one exists */
   9.335 +		run_count = old_run_count = 0;
   9.336 +		while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
   9.337 +			beg_run += run_count;
   9.338 +			old_run_count = run_count;
   9.339 +			run_count = 1;
   9.340 +			while((beg_run + run_count < numbytes) && (run_count < 127)
   9.341 +				  && (data[beg_run] == data[beg_run + run_count]))
   9.342 +				run_count++;
   9.343 +		}
   9.344 +		/* if data before next big run is a short run then write it as such */
   9.345 +		if((old_run_count > 1) && (old_run_count == beg_run - cur)) {
   9.346 +			buf[0] = 128 + old_run_count;	/*write short run */
   9.347 +			buf[1] = data[cur];
   9.348 +			if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
   9.349 +				return rgbe_error(rgbe_write_error, NULL);
   9.350 +			cur = beg_run;
   9.351 +		}
   9.352 +		/* write out bytes until we reach the start of the next run */
   9.353 +		while(cur < beg_run) {
   9.354 +			nonrun_count = beg_run - cur;
   9.355 +			if(nonrun_count > 128)
   9.356 +				nonrun_count = 128;
   9.357 +			buf[0] = nonrun_count;
   9.358 +			if(fwrite(buf, sizeof(buf[0]), 1, fp) < 1)
   9.359 +				return rgbe_error(rgbe_write_error, NULL);
   9.360 +			if(fwrite(&data[cur], sizeof(data[0]) * nonrun_count, 1, fp) < 1)
   9.361 +				return rgbe_error(rgbe_write_error, NULL);
   9.362 +			cur += nonrun_count;
   9.363 +		}
   9.364 +		/* write out next run if one was found */
   9.365 +		if(run_count >= MINRUNLENGTH) {
   9.366 +			buf[0] = 128 + run_count;
   9.367 +			buf[1] = data[beg_run];
   9.368 +			if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
   9.369 +				return rgbe_error(rgbe_write_error, NULL);
   9.370 +			cur += run_count;
   9.371 +		}
   9.372 +	}
   9.373 +	return RGBE_RETURN_SUCCESS;
   9.374 +#undef MINRUNLENGTH
   9.375 +}
   9.376 +
   9.377 +static int rgbe_write_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
   9.378 +{
   9.379 +	unsigned char rgbe[4];
   9.380 +	unsigned char *buffer;
   9.381 +	int i, err;
   9.382 +
   9.383 +	if((scanline_width < 8) || (scanline_width > 0x7fff))
   9.384 +		/* run length encoding is not allowed so write flat */
   9.385 +		return rgbe_write_pixels(io, data, scanline_width * num_scanlines);
   9.386 +	buffer = (unsigned char *)malloc(sizeof(unsigned char) * 4 * scanline_width);
   9.387 +	if(buffer == NULL)
   9.388 +		/* no buffer space so write flat */
   9.389 +		return rgbe_write_pixels(fp, data, scanline_width * num_scanlines);
   9.390 +	while(num_scanlines-- > 0) {
   9.391 +		rgbe[0] = 2;
   9.392 +		rgbe[1] = 2;
   9.393 +		rgbe[2] = scanline_width >> 8;
   9.394 +		rgbe[3] = scanline_width & 0xFF;
   9.395 +		if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
   9.396 +			free(buffer);
   9.397 +			return rgbe_error(rgbe_write_error, NULL);
   9.398 +		}
   9.399 +		for(i = 0; i < scanline_width; i++) {
   9.400 +			float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
   9.401 +			buffer[i] = rgbe[0];
   9.402 +			buffer[i + scanline_width] = rgbe[1];
   9.403 +			buffer[i + 2 * scanline_width] = rgbe[2];
   9.404 +			buffer[i + 3 * scanline_width] = rgbe[3];
   9.405 +			data += RGBE_DATA_SIZE;
   9.406 +		}
   9.407 +		/* write out each of the four channels separately run length encoded */
   9.408 +		/* first red, then green, then blue, then exponent */
   9.409 +		for(i = 0; i < 4; i++) {
   9.410 +			if((err = rgbe_write_bytes_rle(fp, &buffer[i * scanline_width],
   9.411 +										  scanline_width)) != RGBE_RETURN_SUCCESS) {
   9.412 +				free(buffer);
   9.413 +				return err;
   9.414 +			}
   9.415 +		}
   9.416 +	}
   9.417 +	free(buffer);
   9.418 +	return RGBE_RETURN_SUCCESS;
   9.419 +}
   9.420 +#endif
   9.421 +
   9.422 +static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
   9.423 +{
   9.424 +	unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
   9.425 +	int i, count;
   9.426 +	unsigned char buf[2];
   9.427 +
   9.428 +	if((scanline_width < 8) || (scanline_width > 0x7fff))
   9.429 +		/* run length encoding is not allowed so read flat */
   9.430 +		return rgbe_read_pixels(io, data, scanline_width * num_scanlines);
   9.431 +	scanline_buffer = NULL;
   9.432 +	/* read in each successive scanline */
   9.433 +	while(num_scanlines > 0) {
   9.434 +		if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1) {
   9.435 +			free(scanline_buffer);
   9.436 +			return rgbe_error(rgbe_read_error, NULL);
   9.437 +		}
   9.438 +		if((rgbe[0] != 2) || (rgbe[1] != 2) || (rgbe[2] & 0x80)) {
   9.439 +			/* this file is not run length encoded */
   9.440 +			rgbe2float(&data[0], &data[1], &data[2], rgbe);
   9.441 +			data += RGBE_DATA_SIZE;
   9.442 +			free(scanline_buffer);
   9.443 +			return rgbe_read_pixels(io, data, scanline_width * num_scanlines - 1);
   9.444 +		}
   9.445 +		if((((int)rgbe[2]) << 8 | rgbe[3]) != scanline_width) {
   9.446 +			free(scanline_buffer);
   9.447 +			return rgbe_error(rgbe_format_error, "wrong scanline width");
   9.448 +		}
   9.449 +		if(scanline_buffer == NULL)
   9.450 +			scanline_buffer = (unsigned char *)
   9.451 +				malloc(sizeof(unsigned char) * 4 * scanline_width);
   9.452 +		if(scanline_buffer == NULL)
   9.453 +			return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
   9.454 +
   9.455 +		ptr = &scanline_buffer[0];
   9.456 +		/* read each of the four channels for the scanline into the buffer */
   9.457 +		for(i = 0; i < 4; i++) {
   9.458 +			ptr_end = &scanline_buffer[(i + 1) * scanline_width];
   9.459 +			while(ptr < ptr_end) {
   9.460 +				if(io->read(buf, sizeof(buf[0]) * 2, io->uptr) < 1) {
   9.461 +					free(scanline_buffer);
   9.462 +					return rgbe_error(rgbe_read_error, NULL);
   9.463 +				}
   9.464 +				if(buf[0] > 128) {
   9.465 +					/* a run of the same value */
   9.466 +					count = buf[0] - 128;
   9.467 +					if((count == 0) || (count > ptr_end - ptr)) {
   9.468 +						free(scanline_buffer);
   9.469 +						return rgbe_error(rgbe_format_error, "bad scanline data");
   9.470 +					}
   9.471 +					while(count-- > 0)
   9.472 +						*ptr++ = buf[1];
   9.473 +				} else {
   9.474 +					/* a non-run */
   9.475 +					count = buf[0];
   9.476 +					if((count == 0) || (count > ptr_end - ptr)) {
   9.477 +						free(scanline_buffer);
   9.478 +						return rgbe_error(rgbe_format_error, "bad scanline data");
   9.479 +					}
   9.480 +					*ptr++ = buf[1];
   9.481 +					if(--count > 0) {
   9.482 +						if(io->read(ptr, sizeof(*ptr) * count, io->uptr) < 1) {
   9.483 +							free(scanline_buffer);
   9.484 +							return rgbe_error(rgbe_read_error, NULL);
   9.485 +						}
   9.486 +						ptr += count;
   9.487 +					}
   9.488 +				}
   9.489 +			}
   9.490 +		}
   9.491 +		/* now convert data from buffer into floats */
   9.492 +		for(i = 0; i < scanline_width; i++) {
   9.493 +			rgbe[0] = scanline_buffer[i];
   9.494 +			rgbe[1] = scanline_buffer[i + scanline_width];
   9.495 +			rgbe[2] = scanline_buffer[i + 2 * scanline_width];
   9.496 +			rgbe[3] = scanline_buffer[i + 3 * scanline_width];
   9.497 +			rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
   9.498 +			data += RGBE_DATA_SIZE;
   9.499 +		}
   9.500 +		num_scanlines--;
   9.501 +	}
   9.502 +	free(scanline_buffer);
   9.503 +	return RGBE_RETURN_SUCCESS;
   9.504 +}

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/libs/imago/file_tga.c	Sun Jun 07 17:25:49 2015 +0300
    10.3 @@ -0,0 +1,250 @@
    10.4 +/*
    10.5 +libimago - a multi-format image file input/output library.
    10.6 +Copyright (C) 2010-2015 John Tsiombikas <nuclear@member.fsf.org>
    10.7 +
    10.8 +This program is free software: you can redistribute it and/or modify
    10.9 +it under the terms of the GNU Lesser General Public License as published
   10.10 +by the Free Software Foundation, either version 3 of the License, or
   10.11 +(at your option) any later version.
   10.12 +
   10.13 +This program is distributed in the hope that it will be useful,
   10.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   10.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   10.16 +GNU Lesser General Public License for more details.
   10.17 +
   10.18 +You should have received a copy of the GNU Lesser General Public License
   10.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   10.20 +*/
   10.21 +
   10.22 +/* -- Targa (tga) module -- */
   10.23 +
   10.24 +#include <string.h>
   10.25 +#include <stdlib.h>
   10.26 +#include <stdint.h>
   10.27 +#include "imago2.h"
   10.28 +#include "ftype_module.h"
   10.29 +
   10.30 +
   10.31 +#if  defined(__i386__) || defined(__ia64__) || defined(WIN32) || \
   10.32 +    (defined(__alpha__) || defined(__alpha)) || \
   10.33 +     defined(__arm__) || \
   10.34 +    (defined(__mips__) && defined(__MIPSEL__)) || \
   10.35 +     defined(__SYMBIAN32__) || \
   10.36 +     defined(__x86_64__) || \
   10.37 +     defined(__LITTLE_ENDIAN__)
   10.38 +/* little endian */
   10.39 +#define read_int16_le(f)	read_int16(f)
   10.40 +#else
   10.41 +/* big endian */
   10.42 +#define read_int16_le(f)	read_int16_inv(f)
   10.43 +#endif	/* endian check */
   10.44 +
   10.45 +
   10.46 +enum {
   10.47 +	IMG_NONE,
   10.48 +	IMG_CMAP,
   10.49 +	IMG_RGBA,
   10.50 +	IMG_BW,
   10.51 +
   10.52 +	IMG_RLE_CMAP = 9,
   10.53 +	IMG_RLE_RGBA,
   10.54 +	IMG_RLE_BW
   10.55 +};
   10.56 +
   10.57 +#define IS_RLE(x)	((x) >= IMG_RLE_CMAP)
   10.58 +#define IS_RGBA(x)	((x) == IMG_RGBA || (x) == IMG_RLE_RGBA)
   10.59 +
   10.60 +
   10.61 +struct tga_header {
   10.62 +	uint8_t idlen;			/* id field length */
   10.63 +	uint8_t cmap_type;		/* color map type (0:no color map, 1:color map present) */
   10.64 +	uint8_t img_type;		/* image type:
   10.65 +							 * 0: no image data
   10.66 +							 *	1: uncomp. color-mapped		 9: RLE color-mapped
   10.67 +							 *	2: uncomp. true color		10: RLE true color
   10.68 +							 *	3: uncomp. black/white		11: RLE black/white */
   10.69 +	uint16_t cmap_first;	/* color map first entry index */
   10.70 +	uint16_t cmap_len;		/* color map length */
   10.71 +	uint8_t cmap_entry_sz;	/* color map entry size */
   10.72 +	uint16_t img_x;			/* X-origin of the image */
   10.73 +	uint16_t img_y;			/* Y-origin of the image */
   10.74 +	uint16_t img_width;		/* image width */
   10.75 +	uint16_t img_height;	/* image height */
   10.76 +	uint8_t img_bpp;		/* bits per pixel */
   10.77 +	uint8_t img_desc;		/* descriptor:
   10.78 +							 * bits 0 - 3: alpha or overlay bits
   10.79 +							 * bits 5 & 4: origin (0 = bottom/left, 1 = top/right)
   10.80 +							 * bits 7 & 6: data interleaving */
   10.81 +};
   10.82 +
   10.83 +struct tga_footer {
   10.84 +	uint32_t ext_off;		/* extension area offset */
   10.85 +	uint32_t devdir_off;	/* developer directory offset */
   10.86 +	char sig[18];				/* signature with . and \0 */
   10.87 +};
   10.88 +
   10.89 +
   10.90 +static int check(struct img_io *io);
   10.91 +static int read(struct img_pixmap *img, struct img_io *io);
   10.92 +static int write(struct img_pixmap *img, struct img_io *io);
   10.93 +static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix);
   10.94 +static int16_t read_int16(struct img_io *io);
   10.95 +static int16_t read_int16_inv(struct img_io *io);
   10.96 +
   10.97 +int img_register_tga(void)
   10.98 +{
   10.99 +	static struct ftype_module mod = {".tga", check, read, write};
  10.100 +	return img_register_module(&mod);
  10.101 +}
  10.102 +
  10.103 +
  10.104 +static int check(struct img_io *io)
  10.105 +{
  10.106 +	struct tga_footer foot;
  10.107 +	int res = -1;
  10.108 +	long pos = io->seek(0, SEEK_CUR, io->uptr);
  10.109 +	io->seek(-18, SEEK_END, io->uptr);
  10.110 +
  10.111 +	if(io->read(foot.sig, 17, io->uptr) < 17) {
  10.112 +		io->seek(pos, SEEK_SET, io->uptr);
  10.113 +		return -1;
  10.114 +	}
  10.115 +
  10.116 +	if(memcmp(foot.sig, "TRUEVISION-XFILE.", 17) == 0) {
  10.117 +		res = 0;
  10.118 +	}
  10.119 +	io->seek(pos, SEEK_SET, io->uptr);
  10.120 +	return res;
  10.121 +}
  10.122 +
  10.123 +static int iofgetc(struct img_io *io)
  10.124 +{
  10.125 +	char c;
  10.126 +	return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
  10.127 +}
  10.128 +
  10.129 +static int read(struct img_pixmap *img, struct img_io *io)
  10.130 +{
  10.131 +	struct tga_header hdr;
  10.132 +	unsigned long x, y;
  10.133 +	int i, c;
  10.134 +	uint32_t ppixel = 0;
  10.135 +	int rle_mode = 0, rle_pix_left = 0;
  10.136 +	int rdalpha;
  10.137 +
  10.138 +	/* read header */
  10.139 +	hdr.idlen = iofgetc(io);
  10.140 +	hdr.cmap_type = iofgetc(io);
  10.141 +	hdr.img_type = iofgetc(io);
  10.142 +	hdr.cmap_first = read_int16_le(io);
  10.143 +	hdr.cmap_len = read_int16_le(io);
  10.144 +	hdr.cmap_entry_sz = iofgetc(io);
  10.145 +	hdr.img_x = read_int16_le(io);
  10.146 +	hdr.img_y = read_int16_le(io);
  10.147 +	hdr.img_width = read_int16_le(io);
  10.148 +	hdr.img_height = read_int16_le(io);
  10.149 +	hdr.img_bpp = iofgetc(io);
  10.150 +	if((c = iofgetc(io)) == -1) {
  10.151 +		return -1;
  10.152 +	}
  10.153 +	hdr.img_desc = c;
  10.154 +
  10.155 +	if(!IS_RGBA(hdr.img_type)) {
  10.156 +		fprintf(stderr, "only true color tga images supported\n");
  10.157 +		return -1;
  10.158 +	}
  10.159 +
  10.160 +	io->seek(hdr.idlen, SEEK_CUR, io);	/* skip the image ID */
  10.161 +
  10.162 +	/* skip the color map if it exists */
  10.163 +	if(hdr.cmap_type == 1) {
  10.164 +		io->seek(hdr.cmap_len * hdr.cmap_entry_sz / 8, SEEK_CUR, io);
  10.165 +	}
  10.166 +
  10.167 +	x = hdr.img_width;
  10.168 +	y = hdr.img_height;
  10.169 +	rdalpha = hdr.img_desc & 0xf;
  10.170 +
  10.171 +	/* TODO make this IMG_FMT_RGB24 if there's no alpha channel */
  10.172 +	if(img_set_pixels(img, x, y, IMG_FMT_RGBA32, 0) == -1) {
  10.173 +		return -1;
  10.174 +	}
  10.175 +
  10.176 +	for(i=0; i<y; i++) {
  10.177 +		uint32_t *ptr;
  10.178 +		int j;
  10.179 +
  10.180 +		ptr = (uint32_t*)img->pixels + ((hdr.img_desc & 0x20) ? i : y - (i + 1)) * x;
  10.181 +
  10.182 +		for(j=0; j<x; j++) {
  10.183 +			/* if the image is raw, then just read the next pixel */
  10.184 +			if(!IS_RLE(hdr.img_type)) {
  10.185 +				if(read_pixel(io, rdalpha, &ppixel) == -1) {
  10.186 +					return -1;
  10.187 +				}
  10.188 +			} else {
  10.189 +				/* otherwise, for RLE... */
  10.190 +
  10.191 +				/* if we have pixels left in the packet ... */
  10.192 +				if(rle_pix_left) {
  10.193 +					/* if it's a raw packet, read the next pixel, otherwise keep the same */
  10.194 +					if(!rle_mode) {
  10.195 +						if(read_pixel(io, rdalpha, &ppixel) == -1) {
  10.196 +							return -1;
  10.197 +						}
  10.198 +					}
  10.199 +					--rle_pix_left;
  10.200 +				} else {
  10.201 +					/* read RLE packet header */
  10.202 +					unsigned char phdr = iofgetc(io);
  10.203 +					rle_mode = (phdr & 128);		/* last bit shows the mode for this packet (1: rle, 0: raw) */
  10.204 +					rle_pix_left = (phdr & ~128);	/* the rest gives the count of pixels minus one (we also read one here, so no +1) */
  10.205 +					/* and read the first pixel of the packet */
  10.206 +					if(read_pixel(io, rdalpha, &ppixel) == -1) {
  10.207 +						return -1;
  10.208 +					}
  10.209 +				}
  10.210 +			}
  10.211 +
  10.212 +			*ptr++ = ppixel;
  10.213 +		}
  10.214 +	}
  10.215 +
  10.216 +	return 0;
  10.217 +}
  10.218 +
  10.219 +static int write(struct img_pixmap *img, struct img_io *io)
  10.220 +{
  10.221 +	return -1;	/* TODO */
  10.222 +}
  10.223 +
  10.224 +#define PACK_COLOR32(r,g,b,a) \
  10.225 +	((((a) & 0xff) << 24) | \
  10.226 +	 (((r) & 0xff) << 0) | \
  10.227 +	 (((g) & 0xff) << 8) | \
  10.228 +	 (((b) & 0xff) << 16))
  10.229 +
  10.230 +static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix)
  10.231 +{
  10.232 +	int r, g, b, a;
  10.233 +	b = iofgetc(io);
  10.234 +	g = iofgetc(io);
  10.235 +	r = iofgetc(io);
  10.236 +	a = rdalpha ? iofgetc(io) : 0xff;
  10.237 +	*pix = PACK_COLOR32(r, g, b, a);
  10.238 +	return a == -1 || r == -1 ? -1 : 0;
  10.239 +}
  10.240 +
  10.241 +static int16_t read_int16(struct img_io *io)
  10.242 +{
  10.243 +	int16_t v;
  10.244 +	io->read(&v, 2, io);
  10.245 +	return v;
  10.246 +}
  10.247 +
  10.248 +static int16_t read_int16_inv(struct img_io *io)
  10.249 +{
  10.250 +	int16_t v;
  10.251 +	io->read(&v, 2, io);
  10.252 +	return ((v >> 8) & 0xff) | (v << 8);
  10.253 +}

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/libs/imago/ftype_module.c	Sun Jun 07 17:25:49 2015 +0300
    11.3 @@ -0,0 +1,118 @@
    11.4 +/*
    11.5 +libimago - a multi-format image file input/output library.
    11.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
    11.7 +
    11.8 +This program is free software: you can redistribute it and/or modify
    11.9 +it under the terms of the GNU Lesser General Public License as published
   11.10 +by the Free Software Foundation, either version 3 of the License, or
   11.11 +(at your option) any later version.
   11.12 +
   11.13 +This program is distributed in the hope that it will be useful,
   11.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   11.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   11.16 +GNU Lesser General Public License for more details.
   11.17 +
   11.18 +You should have received a copy of the GNU Lesser General Public License
   11.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   11.20 +*/
   11.21 +
   11.22 +#include <stdlib.h>
   11.23 +#include <string.h>
   11.24 +#include "ftype_module.h"
   11.25 +
   11.26 +static struct list_node {
   11.27 +	struct ftype_module *module;
   11.28 +	struct list_node *next;
   11.29 +} *modules;
   11.30 +
   11.31 +/* defined in modules.c which is generated by configure */
   11.32 +void img_modules_init();
   11.33 +
   11.34 +static int done_init;
   11.35 +
   11.36 +int img_register_module(struct ftype_module *mod)
   11.37 +{
   11.38 +	struct list_node *node;
   11.39 +
   11.40 +	if(!(node = malloc(sizeof *node))) {
   11.41 +		return -1;
   11.42 +	}
   11.43 +
   11.44 +	node->module = mod;
   11.45 +	node->next = modules;
   11.46 +	modules = node;
   11.47 +	return 0;
   11.48 +}
   11.49 +
   11.50 +struct ftype_module *img_find_format_module(struct img_io *io)
   11.51 +{
   11.52 +	struct list_node *node;
   11.53 +
   11.54 +	if(!done_init) {
   11.55 +		img_modules_init();
   11.56 +		done_init = 1;
   11.57 +	}
   11.58 +
   11.59 +	node = modules;
   11.60 +	while(node) {
   11.61 +		if(node->module->check(io) != -1) {
   11.62 +			return node->module;
   11.63 +		}
   11.64 +		node = node->next;
   11.65 +	}
   11.66 +	return 0;
   11.67 +}
   11.68 +
   11.69 +struct ftype_module *img_guess_format(const char *fname)
   11.70 +{
   11.71 +	struct list_node *node;
   11.72 +	char *suffix;
   11.73 +	int suffix_len;
   11.74 +
   11.75 +	if(!done_init) {
   11.76 +		img_modules_init();
   11.77 +		done_init = 1;
   11.78 +	}
   11.79 +
   11.80 +	if(!(suffix = strrchr(fname, '.'))) {
   11.81 +		return 0;	/* no suffix, can't guess ... */
   11.82 +	}
   11.83 +	suffix_len = (int)strlen(suffix);
   11.84 +
   11.85 +	node = modules;
   11.86 +	while(node) {
   11.87 +		char *suflist = node->module->suffix;
   11.88 +		char *start, *end;
   11.89 +
   11.90 +		while(*suflist) {
   11.91 +			if(!(start = strstr(suflist, suffix))) {
   11.92 +				break;
   11.93 +			}
   11.94 +			end = start + suffix_len;
   11.95 +
   11.96 +			if(*end == ':' || *end == 0) {
   11.97 +				return node->module;	/* found it */
   11.98 +			}
   11.99 +			suflist = end;
  11.100 +		}
  11.101 +
  11.102 +		node = node->next;
  11.103 +	}
  11.104 +	return 0;
  11.105 +}
  11.106 +
  11.107 +struct ftype_module *img_get_module(int idx)
  11.108 +{
  11.109 +	struct list_node *node;
  11.110 +
  11.111 +	if(!done_init) {
  11.112 +		img_modules_init();
  11.113 +		done_init = 1;
  11.114 +	}
  11.115 +
  11.116 +	node = modules;
  11.117 +	while(node && idx--) {
  11.118 +		node = node->next;
  11.119 +	}
  11.120 +	return node->module;
  11.121 +}

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/libs/imago/ftype_module.h	Sun Jun 07 17:25:49 2015 +0300
    12.3 @@ -0,0 +1,39 @@
    12.4 +/*
    12.5 +libimago - a multi-format image file input/output library.
    12.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
    12.7 +
    12.8 +This program is free software: you can redistribute it and/or modify
    12.9 +it under the terms of the GNU Lesser General Public License as published
   12.10 +by the Free Software Foundation, either version 3 of the License, or
   12.11 +(at your option) any later version.
   12.12 +
   12.13 +This program is distributed in the hope that it will be useful,
   12.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   12.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   12.16 +GNU Lesser General Public License for more details.
   12.17 +
   12.18 +You should have received a copy of the GNU Lesser General Public License
   12.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   12.20 +*/
   12.21 +
   12.22 +#ifndef FTYPE_MODULE_H_
   12.23 +#define FTYPE_MODULE_H_
   12.24 +
   12.25 +#include "imago2.h"
   12.26 +
   12.27 +struct ftype_module {
   12.28 +	char *suffix;	/* used for format autodetection during saving only */
   12.29 +
   12.30 +	int (*check)(struct img_io *io);
   12.31 +	int (*read)(struct img_pixmap *img, struct img_io *io);
   12.32 +	int (*write)(struct img_pixmap *img, struct img_io *io);
   12.33 +};
   12.34 +
   12.35 +int img_register_module(struct ftype_module *mod);
   12.36 +
   12.37 +struct ftype_module *img_find_format_module(struct img_io *io);
   12.38 +struct ftype_module *img_guess_format(const char *fname);
   12.39 +struct ftype_module *img_get_module(int idx);
   12.40 +
   12.41 +
   12.42 +#endif	/* FTYPE_MODULE_H_ */

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/libs/imago/imago2.c	Sun Jun 07 17:25:49 2015 +0300
    13.3 @@ -0,0 +1,449 @@
    13.4 +/*
    13.5 +libimago - a multi-format image file input/output library.
    13.6 +Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
    13.7 +
    13.8 +This program is free software: you can redistribute it and/or modify
    13.9 +it under the terms of the GNU Lesser General Public License as published
   13.10 +by the Free Software Foundation, either version 3 of the License, or
   13.11 +(at your option) any later version.
   13.12 +
   13.13 +This program is distributed in the hope that it will be useful,
   13.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   13.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   13.16 +GNU Lesser General Public License for more details.
   13.17 +
   13.18 +You should have received a copy of the GNU Lesser General Public License
   13.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   13.20 +*/
   13.21 +
   13.22 +#include <stdio.h>
   13.23 +#include <stdlib.h>
   13.24 +#include <string.h>
   13.25 +#include "imago2.h"
   13.26 +#include "ftype_module.h"
   13.27 +
   13.28 +static int pixel_size(enum img_fmt fmt);
   13.29 +static size_t def_read(void *buf, size_t bytes, void *uptr);
   13.30 +static size_t def_write(void *buf, size_t bytes, void *uptr);
   13.31 +static long def_seek(long offset, int whence, void *uptr);
   13.32 +
   13.33 +
   13.34 +void img_init(struct img_pixmap *img)
   13.35 +{
   13.36 +	img->pixels = 0;
   13.37 +	img->width = img->height = 0;
   13.38 +	img->fmt = IMG_FMT_RGBA32;
   13.39 +	img->pixelsz = pixel_size(img->fmt);
   13.40 +	img->name = 0;
   13.41 +}
   13.42 +
   13.43 +
   13.44 +void img_destroy(struct img_pixmap *img)
   13.45 +{
   13.46 +	free(img->pixels);
   13.47 +	img->pixels = 0;	/* just in case... */
   13.48 +	img->width = img->height = 0xbadbeef;
   13.49 +	free(img->name);
   13.50 +}
   13.51 +
   13.52 +struct img_pixmap *img_create(void)
   13.53 +{
   13.54 +	struct img_pixmap *p;
   13.55 +
   13.56 +	if(!(p = malloc(sizeof *p))) {
   13.57 +		return 0;
   13.58 +	}
   13.59 +	img_init(p);
   13.60 +	return p;
   13.61 +}
   13.62 +
   13.63 +void img_free(struct img_pixmap *img)
   13.64 +{
   13.65 +	img_destroy(img);
   13.66 +	free(img);
   13.67 +}
   13.68 +
   13.69 +int img_set_name(struct img_pixmap *img, const char *name)
   13.70 +{
   13.71 +	char *tmp;
   13.72 +
   13.73 +	if(!(tmp = malloc(strlen(name) + 1))) {
   13.74 +		return -1;
   13.75 +	}
   13.76 +	strcpy(tmp, name);
   13.77 +	img->name = tmp;
   13.78 +	return 0;
   13.79 +}
   13.80 +
   13.81 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt)
   13.82 +{
   13.83 +	if(img->pixels) {
   13.84 +		return img_convert(img, fmt);
   13.85 +	}
   13.86 +	img->fmt = fmt;
   13.87 +	return 0;
   13.88 +}
   13.89 +
   13.90 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src)
   13.91 +{
   13.92 +	return img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels);
   13.93 +}
   13.94 +
   13.95 +int img_set_pixels(struct img_pixmap *img, int w, int h, enum img_fmt fmt, void *pix)
   13.96 +{
   13.97 +	void *newpix;
   13.98 +	int pixsz = pixel_size(fmt);
   13.99 +
  13.100 +	if(!(newpix = malloc(w * h * pixsz))) {
  13.101 +		return -1;
  13.102 +	}
  13.103 +
  13.104 +	if(pix) {
  13.105 +		memcpy(newpix, pix, w * h * pixsz);
  13.106 +	} else {
  13.107 +		memset(newpix, 0, w * h * pixsz);
  13.108 +	}
  13.109 +
  13.110 +	free(img->pixels);
  13.111 +	img->pixels = newpix;
  13.112 +	img->width = w;
  13.113 +	img->height = h;
  13.114 +	img->pixelsz = pixsz;
  13.115 +	img->fmt = fmt;
  13.116 +	return 0;
  13.117 +}
  13.118 +
  13.119 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, enum img_fmt fmt)
  13.120 +{
  13.121 +	struct img_pixmap img;
  13.122 +
  13.123 +	img_init(&img);
  13.124 +
  13.125 +	if(img_load(&img, fname) == -1) {
  13.126 +		return 0;
  13.127 +	}
  13.128 +	if(img.fmt != fmt) {
  13.129 +		if(img_convert(&img, fmt) == -1) {
  13.130 +			img_destroy(&img);
  13.131 +			return 0;
  13.132 +		}
  13.133 +	}
  13.134 +
  13.135 +	*xsz = img.width;
  13.136 +	*ysz = img.height;
  13.137 +	return img.pixels;
  13.138 +}
  13.139 +
  13.140 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, enum img_fmt fmt)
  13.141 +{
  13.142 +	struct img_pixmap img;
  13.143 +
  13.144 +	img_init(&img);
  13.145 +	img.fmt = fmt;
  13.146 +	img.name = (char*)fname;
  13.147 +	img.width = xsz;
  13.148 +	img.height = ysz;
  13.149 +	img.pixels = pix;
  13.150 +
  13.151 +	return img_save(&img, fname);
  13.152 +}
  13.153 +
  13.154 +void img_free_pixels(void *pix)
  13.155 +{
  13.156 +	free(pix);
  13.157 +}
  13.158 +
  13.159 +int img_load(struct img_pixmap *img, const char *fname)
  13.160 +{
  13.161 +	int res;
  13.162 +	FILE *fp;
  13.163 +
  13.164 +	if(!(fp = fopen(fname, "rb"))) {
  13.165 +		return -1;
  13.166 +	}
  13.167 +	res = img_read_file(img, fp);
  13.168 +	fclose(fp);
  13.169 +	return res;
  13.170 +}
  13.171 +
  13.172 +/* TODO implement filetype selection */
  13.173 +int img_save(struct img_pixmap *img, const char *fname)
  13.174 +{
  13.175 +	int res;
  13.176 +	FILE *fp;
  13.177 +
  13.178 +	img_set_name(img, fname);
  13.179 +
  13.180 +	if(!(fp = fopen(fname, "wb"))) {
  13.181 +		return -1;
  13.182 +	}
  13.183 +	res = img_write_file(img, fp);
  13.184 +	fclose(fp);
  13.185 +	return res;
  13.186 +}
  13.187 +
  13.188 +int img_read_file(struct img_pixmap *img, FILE *fp)
  13.189 +{
  13.190 +	struct img_io io = {0, def_read, def_write, def_seek};
  13.191 +
  13.192 +	io.uptr = fp;
  13.193 +	return img_read(img, &io);
  13.194 +}
  13.195 +
  13.196 +int img_write_file(struct img_pixmap *img, FILE *fp)
  13.197 +{
  13.198 +	struct img_io io = {0, def_read, def_write, def_seek};
  13.199 +
  13.200 +	io.uptr = fp;
  13.201 +	return img_write(img, &io);
  13.202 +}
  13.203 +
  13.204 +int img_read(struct img_pixmap *img, struct img_io *io)
  13.205 +{
  13.206 +	struct ftype_module *mod;
  13.207 +
  13.208 +	if((mod = img_find_format_module(io))) {
  13.209 +		return mod->read(img, io);
  13.210 +	}
  13.211 +	return -1;
  13.212 +}
  13.213 +
  13.214 +int img_write(struct img_pixmap *img, struct img_io *io)
  13.215 +{
  13.216 +	struct ftype_module *mod;
  13.217 +
  13.218 +	if(!img->name || !(mod = img_guess_format(img->name))) {
  13.219 +		/* TODO throw some sort of warning? */
  13.220 +		/* TODO implement some sort of module priority or let the user specify? */
  13.221 +		if(!(mod = img_get_module(0))) {
  13.222 +			return -1;
  13.223 +		}
  13.224 +	}
  13.225 +
  13.226 +	return mod->write(img, io);
  13.227 +}
  13.228 +
  13.229 +int img_to_float(struct img_pixmap *img)
  13.230 +{
  13.231 +	enum img_fmt targ_fmt;
  13.232 +
  13.233 +	switch(img->fmt) {
  13.234 +	case IMG_FMT_GREY8:
  13.235 +		targ_fmt = IMG_FMT_GREYF;
  13.236 +		break;
  13.237 +
  13.238 +	case IMG_FMT_RGB24:
  13.239 +		targ_fmt = IMG_FMT_RGBF;
  13.240 +		break;
  13.241 +
  13.242 +	case IMG_FMT_RGBA32:
  13.243 +		targ_fmt = IMG_FMT_RGBAF;
  13.244 +		break;
  13.245 +
  13.246 +	default:
  13.247 +		return 0;	/* already float */
  13.248 +	}
  13.249 +
  13.250 +	return img_convert(img, targ_fmt);
  13.251 +}
  13.252 +
  13.253 +int img_to_integer(struct img_pixmap *img)
  13.254 +{
  13.255 +	enum img_fmt targ_fmt;
  13.256 +
  13.257 +	switch(img->fmt) {
  13.258 +	case IMG_FMT_GREYF:
  13.259 +		targ_fmt = IMG_FMT_GREY8;
  13.260 +		break;
  13.261 +
  13.262 +	case IMG_FMT_RGBF:
  13.263 +		targ_fmt = IMG_FMT_RGB24;
  13.264 +		break;
  13.265 +
  13.266 +	case IMG_FMT_RGBAF:
  13.267 +		targ_fmt = IMG_FMT_RGBA32;
  13.268 +		break;
  13.269 +
  13.270 +	default:
  13.271 +		return 0;	/* already integer */
  13.272 +	}
  13.273 +
  13.274 +	return img_convert(img, targ_fmt);
  13.275 +}
  13.276 +
  13.277 +int img_is_float(struct img_pixmap *img)
  13.278 +{
  13.279 +	return img->fmt >= IMG_FMT_GREYF && img->fmt <= IMG_FMT_RGBAF;
  13.280 +}
  13.281 +
  13.282 +int img_has_alpha(struct img_pixmap *img)
  13.283 +{
  13.284 +	if(img->fmt == IMG_FMT_RGBA32 || img->fmt == IMG_FMT_RGBAF) {
  13.285 +		return 1;
  13.286 +	}
  13.287 +	return 0;
  13.288 +}
  13.289 +
  13.290 +
  13.291 +void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel)
  13.292 +{
  13.293 +	char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
  13.294 +	memcpy(dest, pixel, img->pixelsz);
  13.295 +}
  13.296 +
  13.297 +void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel)
  13.298 +{
  13.299 +	char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
  13.300 +	memcpy(pixel, dest, img->pixelsz);
  13.301 +}
  13.302 +
  13.303 +void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix)
  13.304 +{
  13.305 +	img_setpixel4i(img, x, y, pix, pix, pix, pix);
  13.306 +}
  13.307 +
  13.308 +void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix)
  13.309 +{
  13.310 +	img_setpixel4f(img, x, y, pix, pix, pix, pix);
  13.311 +}
  13.312 +
  13.313 +void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a)
  13.314 +{
  13.315 +	if(img_is_float(img)) {
  13.316 +		img_setpixel4f(img, x, y, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
  13.317 +	} else {
  13.318 +		unsigned char pixel[4];
  13.319 +		pixel[0] = r;
  13.320 +		pixel[1] = g;
  13.321 +		pixel[2] = b;
  13.322 +		pixel[3] = a;
  13.323 +
  13.324 +		img_setpixel(img, x, y, pixel);
  13.325 +	}
  13.326 +}
  13.327 +
  13.328 +void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a)
  13.329 +{
  13.330 +	if(img_is_float(img)) {
  13.331 +		float pixel[4];
  13.332 +		pixel[0] = r;
  13.333 +		pixel[1] = g;
  13.334 +		pixel[2] = b;
  13.335 +		pixel[3] = a;
  13.336 +
  13.337 +		img_setpixel(img, x, y, pixel);
  13.338 +	} else {
  13.339 +		img_setpixel4i(img, x, y, (int)(r * 255.0), (int)(g * 255.0), (int)(b * 255.0), (int)(a * 255.0));
  13.340 +	}
  13.341 +}
  13.342 +
  13.343 +void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix)
  13.344 +{
  13.345 +	int junk[3];
  13.346 +	img_getpixel4i(img, x, y, pix, junk, junk + 1, junk + 2);
  13.347 +}
  13.348 +
  13.349 +void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix)
  13.350 +{
  13.351 +	float junk[3];
  13.352 +	img_getpixel4f(img, x, y, pix, junk, junk + 1, junk + 2);
  13.353 +}
  13.354 +
  13.355 +void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a)
  13.356 +{
  13.357 +	if(img_is_float(img)) {
  13.358 +		float pixel[4] = {0, 0, 0, 0};
  13.359 +		img_getpixel(img, x, y, pixel);
  13.360 +		*r = pixel[0] * 255.0;
  13.361 +		*g = pixel[1] * 255.0;
  13.362 +		*b = pixel[2] * 255.0;
  13.363 +		*a = pixel[3] * 255.0;
  13.364 +	} else {
  13.365 +		unsigned char pixel[4];
  13.366 +		img_getpixel(img, x, y, pixel);
  13.367 +		*r = pixel[0];
  13.368 +		*g = pixel[1];
  13.369 +		*b = pixel[2];
  13.370 +		*a = pixel[3];
  13.371 +	}
  13.372 +}
  13.373 +
  13.374 +void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a)
  13.375 +{
  13.376 +	if(img_is_float(img)) {
  13.377 +		float pixel[4] = {0, 0, 0, 0};
  13.378 +		img_getpixel(img, x, y, pixel);
  13.379 +		*r = pixel[0];
  13.380 +		*g = pixel[1];
  13.381 +		*b = pixel[2];
  13.382 +		*a = pixel[3];
  13.383 +	} else {
  13.384 +		unsigned char pixel[4];
  13.385 +		img_getpixel(img, x, y, pixel);
  13.386 +		*r = pixel[0] / 255.0;
  13.387 +		*g = pixel[1] / 255.0;
  13.388 +		*b = pixel[2] / 255.0;
  13.389 +		*a = pixel[3] / 255.0;
  13.390 +	}
  13.391 +}
  13.392 +
  13.393 +void img_io_set_user_data(struct img_io *io, void *uptr)
  13.394 +{
  13.395 +	io->uptr = uptr;
  13.396 +}
  13.397 +
  13.398 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*))
  13.399 +{
  13.400 +	io->read = read;
  13.401 +}
  13.402 +
  13.403 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*))
  13.404 +{
  13.405 +	io->write = write;
  13.406 +}
  13.407 +
  13.408 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*))
  13.409 +{
  13.410 +	io->seek = seek;
  13.411 +}
  13.412 +
  13.413 +
  13.414 +static int pixel_size(enum img_fmt fmt)
  13.415 +{
  13.416 +	switch(fmt) {
  13.417 +	case IMG_FMT_GREY8:
  13.418 +		return 1;
  13.419 +	case IMG_FMT_RGB24:
  13.420 +		return 3;
  13.421 +	case IMG_FMT_RGBA32:
  13.422 +		return 4;
  13.423 +	case IMG_FMT_GREYF:
  13.424 +		return sizeof(float);
  13.425 +	case IMG_FMT_RGBF:
  13.426 +		return 3 * sizeof(float);
  13.427 +	case IMG_FMT_RGBAF:
  13.428 +		return 4 * sizeof(float);
  13.429 +	default:
  13.430 +		break;
  13.431 +	}
  13.432 +	return 0;
  13.433 +}
  13.434 +
  13.435 +static size_t def_read(void *buf, size_t bytes, void *uptr)
  13.436 +{
  13.437 +	return uptr ? fread(buf, 1, bytes, uptr) : 0;
  13.438 +}
  13.439 +
  13.440 +static size_t def_write(void *buf, size_t bytes, void *uptr)
  13.441 +{
  13.442 +	return uptr ? fwrite(buf, 1, bytes, uptr) : 0;
  13.443 +}
  13.444 +
  13.445 +static long def_seek(long offset, int whence, void *uptr)
  13.446 +{
  13.447 +	if(!uptr || fseek(uptr, offset, whence) == -1) {
  13.448 +		return -1;
  13.449 +	}
  13.450 +	return ftell(uptr);
  13.451 +}
  13.452 +

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/libs/imago/imago2.h	Sun Jun 07 17:25:49 2015 +0300
    14.3 @@ -0,0 +1,222 @@
    14.4 +/*
    14.5 +libimago - a multi-format image file input/output library.
    14.6 +Copyright (C) 2010-2012 John Tsiombikas <nuclear@member.fsf.org>
    14.7 +
    14.8 +This program is free software: you can redistribute it and/or modify
    14.9 +it under the terms of the GNU Lesser General Public License as published
   14.10 +by the Free Software Foundation, either version 3 of the License, or
   14.11 +(at your option) any later version.
   14.12 +
   14.13 +This program is distributed in the hope that it will be useful,
   14.14 +but WITHOUT ANY WARRANTY; without even the implied warranty of
   14.15 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14.16 +GNU Lesser General Public License for more details.
   14.17 +
   14.18 +You should have received a copy of the GNU Lesser General Public License
   14.19 +along with this program.  If not, see <http://www.gnu.org/licenses/>.
   14.20 +*/
   14.21 +
   14.22 +#ifndef IMAGO2_H_
   14.23 +#define IMAGO2_H_
   14.24 +
   14.25 +#include <stdio.h>
   14.26 +
   14.27 +#ifdef __cplusplus
   14.28 +#define IMG_OPTARG(arg, val)	arg = val
   14.29 +#else
   14.30 +#define IMG_OPTARG(arg, val)	arg
   14.31 +#endif
   14.32 +
   14.33 +/* XXX if you change this make sure to also change pack/unpack arrays in conv.c */
   14.34 +enum img_fmt {
   14.35 +	IMG_FMT_GREY8,
   14.36 +	IMG_FMT_RGB24,
   14.37 +	IMG_FMT_RGBA32,
   14.38 +	IMG_FMT_GREYF,
   14.39 +	IMG_FMT_RGBF,
   14.40 +	IMG_FMT_RGBAF,
   14.41 +
   14.42 +	NUM_IMG_FMT
   14.43 +};
   14.44 +
   14.45 +struct img_pixmap {
   14.46 +	void *pixels;
   14.47 +	int width, height;
   14.48 +	enum img_fmt fmt;
   14.49 +	int pixelsz;
   14.50 +	char *name;
   14.51 +};
   14.52 +
   14.53 +struct img_io {
   14.54 +	void *uptr;	/* user-data */
   14.55 +
   14.56 +	size_t (*read)(void *buf, size_t bytes, void *uptr);
   14.57 +	size_t (*write)(void *buf, size_t bytes, void *uptr);
   14.58 +	long (*seek)(long offs, int whence, void *uptr);
   14.59 +};
   14.60 +
   14.61 +#ifdef __cplusplus
   14.62 +extern "C" {
   14.63 +#endif
   14.64 +
   14.65 +/* initialize the img_pixmap structure */
   14.66 +void img_init(struct img_pixmap *img);
   14.67 +/* destroys the img_pixmap structure, freeing the pixel buffer (if available)
   14.68 + * and any other memory held by the pixmap.
   14.69 + */
   14.70 +void img_destroy(struct img_pixmap *img);
   14.71 +
   14.72 +/* convenience function that allocates an img_pixmap struct and then initializes it.
   14.73 + * returns null if the malloc fails.
   14.74 + */
   14.75 +struct img_pixmap *img_create(void);
   14.76 +/* frees a pixmap previously allocated with img_create (free followed by img_destroy) */
   14.77 +void img_free(struct img_pixmap *img);
   14.78 +
   14.79 +int img_set_name(struct img_pixmap *img, const char *name);
   14.80 +
   14.81 +/* set the image pixel format */
   14.82 +int img_set_format(struct img_pixmap *img, enum img_fmt fmt);
   14.83 +
   14.84 +/* copies one pixmap to another.
   14.85 + * equivalent to: img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels)
   14.86 + */
   14.87 +int img_copy(struct img_pixmap *dest, struct img_pixmap *src);
   14.88 +
   14.89 +/* allocates a pixel buffer of the specified dimensions and format, and copies the
   14.90 + * pixels given through the pix pointer into it.
   14.91 + * the pix pointer can be null, in which case there's no copy, just allocation.
   14.92 + *
   14.93 + * C++: fmt and pix have default parameters IMG_FMT_RGBA32 and null respectively.
   14.94 + */
   14.95 +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));
   14.96 +
   14.97 +/* Simplified image loading
   14.98 + * Loads the specified file, and returns a pointer to an array of pixels of the
   14.99 + * requested pixel format. The width and height of the image are returned through
  14.100 + * the xsz and ysz pointers.
  14.101 + * If the image cannot be loaded, the function returns null.
  14.102 + *
  14.103 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  14.104 + */
  14.105 +void *img_load_pixels(const char *fname, int *xsz, int *ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  14.106 +
  14.107 +/* Simplified image saving
  14.108 + * Reads an array of pixels supplied through the pix pointer, of dimensions xsz
  14.109 + * and ysz, and pixel-format fmt, and saves it to a file.
  14.110 + * The output filetype is guessed by the filename suffix.
  14.111 + *
  14.112 + * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
  14.113 + */
  14.114 +int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
  14.115 +
  14.116 +/* Frees the memory allocated by img_load_pixels */
  14.117 +void img_free_pixels(void *pix);
  14.118 +
  14.119 +/* Loads an image file into the supplied pixmap */
  14.120 +int img_load(struct img_pixmap *img, const char *fname);
  14.121 +/* Saves the supplied pixmap to a file. The output filetype is guessed by the filename suffix */
  14.122 +int img_save(struct img_pixmap *img, const char *fname);
  14.123 +
  14.124 +/* Reads an image from an open FILE* into the supplied pixmap */
  14.125 +int img_read_file(struct img_pixmap *img, FILE *fp);
  14.126 +/* Writes the supplied pixmap to an open FILE* */
  14.127 +int img_write_file(struct img_pixmap *img, FILE *fp);
  14.128 +
  14.129 +/* Reads an image using user-defined file-i/o functions (see img_io_set_*) */
  14.130 +int img_read(struct img_pixmap *img, struct img_io *io);
  14.131 +/* Writes an image using user-defined file-i/o functions (see img_io_set_*) */
  14.132 +int img_write(struct img_pixmap *img, struct img_io *io);
  14.133 +
  14.134 +/* Converts an image to the specified pixel format */
  14.135 +int img_convert(struct img_pixmap *img, enum img_fmt tofmt);
  14.136 +
  14.137 +/* Converts an image from an integer pixel format to the corresponding floating point one */
  14.138 +int img_to_float(struct img_pixmap *img);
  14.139 +/* Converts an image from a floating point pixel format to the corresponding integer one */
  14.140 +int img_to_integer(struct img_pixmap *img);
  14.141 +
  14.142 +/* Returns non-zero (true) if the supplied image is in a floating point pixel format */
  14.143 +int img_is_float(struct img_pixmap *img);
  14.144 +/* Returns non-zero (true) if the supplied image has an alpha channel */
  14.145 +int img_has_alpha(struct img_pixmap *img);
  14.146 +
  14.147 +
  14.148 +/* don't use these for anything performance-critical */
  14.149 +void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel);
  14.150 +void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel);
  14.151 +
  14.152 +void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix);
  14.153 +void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix);
  14.154 +void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a);
  14.155 +void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a);
  14.156 +
  14.157 +void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix);
  14.158 +void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix);
  14.159 +void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a);
  14.160 +void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a);
  14.161 +
  14.162 +
  14.163 +/* OpenGL helper functions */
  14.164 +
  14.165 +/* Returns the equivalent OpenGL "format" as expected by the 7th argument of glTexImage2D */
  14.166 +unsigned int img_fmt_glfmt(enum img_fmt fmt);
  14.167 +/* Returns the equivalent OpenGL "type" as expected by the 8th argument of glTexImage2D */
  14.168 +unsigned int img_fmt_gltype(enum img_fmt fmt);
  14.169 +/* Returns the equivalent OpenGL "internal format" as expected by the 3rd argument of glTexImage2D */
  14.170 +unsigned int img_fmt_glintfmt(enum img_fmt fmt);
  14.171 +
  14.172 +/* Same as above, based on the pixel format of the supplied image */
  14.173 +unsigned int img_glfmt(struct img_pixmap *img);
  14.174 +unsigned int img_gltype(struct img_pixmap *img);
  14.175 +unsigned int img_glintfmt(struct img_pixmap *img);
  14.176 +
  14.177 +/* Creates an OpenGL texture from the image, and returns the texture id, or 0 for failure */
  14.178 +unsigned int img_gltexture(struct img_pixmap *img);
  14.179 +
  14.180 +/* Load an image and create an OpenGL texture out of it */
  14.181 +unsigned int img_gltexture_load(const char *fname);
  14.182 +unsigned int img_gltexture_read_file(FILE *fp);
  14.183 +unsigned int img_gltexture_read(struct img_io *io);
  14.184 +
  14.185 +/* These functions can be used to fill an img_io struct before it's passed to
  14.186 + * one of the user-defined i/o image reading/writing functions (img_read/img_write).
  14.187 + *
  14.188 + * User-defined i/o functions:
  14.189 + *
  14.190 + * - size_t read_func(void *buffer, size_t bytes, void *user_ptr)
  14.191 + * Must try to fill the buffer with the specified number of bytes, and return
  14.192 + * the number of bytes actually read.
  14.193 + *
  14.194 + * - size_t write_func(void *buffer, size_t bytes, void *user_ptr)
  14.195 + * Must write the specified number of bytes from the supplied buffer and return
  14.196 + * the number of bytes actually written.
  14.197 + *
  14.198 + * - long seek_func(long offset, int whence, void *user_ptr)
  14.199 + * Must seek offset bytes from: the beginning of the file if whence is SEEK_SET,
  14.200 + * the current position if whence is SEEK_CUR, or the end of the file if whence is
  14.201 + * SEEK_END, and return the resulting file offset from the beginning of the file.
  14.202 + * (i.e. seek_func(0, SEEK_CUR, user_ptr); must be equivalent to an ftell).
  14.203 + *
  14.204 + * All three functions get the user-data pointer set through img_io_set_user_data
  14.205 + * as their last argument.
  14.206 + *
  14.207 + * Note: obviously you don't need to set a write function if you're only going
  14.208 + * to call img_read, or the read and seek function if you're only going to call
  14.209 + * img_write.
  14.210 + *
  14.211 + * Note: if the user-supplied write function is buffered, make sure to flush
  14.212 + * (or close the file) after img_write returns.
  14.213 + */
  14.214 +void img_io_set_user_data(struct img_io *io, void *uptr);
  14.215 +void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*));
  14.216 +void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*));
  14.217 +void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*));
  14.218 +
  14.219 +
  14.220 +#ifdef __cplusplus
  14.221 +}
  14.222 +#endif
  14.223 +
  14.224 +
  14.225 +#endif	/* IMAGO_H_ */

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/libs/imago/imago_gl.c	Sun Jun 07 17:25:49 2015 +0300
    15.3 @@ -0,0 +1,231 @@
    15.4 +#include "imago2.h"
    15.5 +
    15.6 +/* to avoid dependency to OpenGL, I'll define all the relevant GL macros manually */
    15.7 +#define GL_UNSIGNED_BYTE		0x1401
    15.8 +#define GL_FLOAT				0x1406
    15.9 +
   15.10 +#define GL_LUMINANCE			0x1909
   15.11 +#define GL_RGB					0x1907
   15.12 +#define GL_RGBA					0x1908
   15.13 +
   15.14 +#define GL_RGBA32F				0x8814
   15.15 +#define GL_RGB32F				0x8815
   15.16 +#define GL_LUMINANCE32F			0x8818
   15.17 +
   15.18 +#define GL_TEXTURE_2D			0x0de1
   15.19 +#define GL_TEXTURE_WRAP_S		0x2802
   15.20 +#define GL_TEXTURE_WRAP_T		0x2803
   15.21 +#define GL_TEXTURE_MAG_FILTER	0x2800
   15.22 +#define GL_TEXTURE_MIN_FILTER	0x2801
   15.23 +#define GL_LINEAR				0x2601
   15.24 +#define GL_REPEAT				0x2901
   15.25 +
   15.26 +
   15.27 +typedef unsigned int GLenum;
   15.28 +typedef unsigned int GLuint;
   15.29 +typedef int GLint;
   15.30 +typedef int GLsizei;
   15.31 +typedef void GLvoid;
   15.32 +
   15.33 +/* for the same reason I'll load GL functions dynamically */
   15.34 +#ifndef WIN32
   15.35 +typedef void (*gl_gen_textures_func)(GLsizei, GLuint*);
   15.36 +typedef void (*gl_bind_texture_func)(GLenum, GLuint);
   15.37 +typedef void (*gl_tex_parameteri_func)(GLenum, GLenum, GLint);
   15.38 +typedef void (*gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
   15.39 +#else
   15.40 +typedef void (__stdcall *gl_gen_textures_func)(GLsizei, GLuint*);
   15.41 +typedef void (__stdcall *gl_bind_texture_func)(GLenum, GLuint);
   15.42 +typedef void (__stdcall *gl_tex_parameteri_func)(GLenum, GLenum, GLint);
   15.43 +typedef void (__stdcall *gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
   15.44 +#endif
   15.45 +
   15.46 +static gl_gen_textures_func gl_gen_textures;
   15.47 +static gl_bind_texture_func gl_bind_texture;
   15.48 +static gl_tex_parameteri_func gl_tex_parameteri;
   15.49 +static gl_tex_image2d_func gl_tex_image2d;
   15.50 +
   15.51 +static int load_glfunc(void);
   15.52 +
   15.53 +unsigned int img_fmt_glfmt(enum img_fmt fmt)
   15.54 +{
   15.55 +	switch(fmt) {
   15.56 +	case IMG_FMT_GREY8:
   15.57 +	case IMG_FMT_GREYF:
   15.58 +		return GL_LUMINANCE;
   15.59 +
   15.60 +	case IMG_FMT_RGB24:
   15.61 +	case IMG_FMT_RGBF:
   15.62 +		return GL_RGB;
   15.63 +
   15.64 +	case IMG_FMT_RGBA32:
   15.65 +	case IMG_FMT_RGBAF:
   15.66 +		return GL_RGBA;
   15.67 +
   15.68 +	default:
   15.69 +		break;
   15.70 +	}
   15.71 +	return 0;
   15.72 +}
   15.73 +
   15.74 +unsigned int img_fmt_gltype(enum img_fmt fmt)
   15.75 +{
   15.76 +	switch(fmt) {
   15.77 +	case IMG_FMT_GREY8:
   15.78 +	case IMG_FMT_RGB24:
   15.79 +	case IMG_FMT_RGBA32:
   15.80 +		return GL_UNSIGNED_BYTE;
   15.81 +
   15.82 +	case IMG_FMT_GREYF:
   15.83 +	case IMG_FMT_RGBF:
   15.84 +	case IMG_FMT_RGBAF:
   15.85 +		return GL_FLOAT;
   15.86 +
   15.87 +	default:
   15.88 +		break;
   15.89 +	}
   15.90 +	return 0;
   15.91 +}
   15.92 +
   15.93 +unsigned int img_fmt_glintfmt(enum img_fmt fmt)
   15.94 +{
   15.95 +	switch(fmt) {
   15.96 +	case IMG_FMT_GREY8:
   15.97 +		return GL_LUMINANCE;
   15.98 +	case IMG_FMT_RGB24:
   15.99 +		return GL_RGB;
  15.100 +	case IMG_FMT_RGBA32:
  15.101 +		return GL_RGBA;
  15.102 +	case IMG_FMT_GREYF:
  15.103 +		return GL_LUMINANCE32F;
  15.104 +	case IMG_FMT_RGBF:
  15.105 +		return GL_RGB32F;
  15.106 +	case IMG_FMT_RGBAF:
  15.107 +		return GL_RGBA32F;
  15.108 +	default:
  15.109 +		break;
  15.110 +	}
  15.111 +	return 0;
  15.112 +}
  15.113 +
  15.114 +unsigned int img_glfmt(struct img_pixmap *img)
  15.115 +{
  15.116 +	return img_fmt_glfmt(img->fmt);
  15.117 +}
  15.118 +
  15.119 +unsigned int img_gltype(struct img_pixmap *img)
  15.120 +{
  15.121 +	return img_fmt_gltype(img->fmt);
  15.122 +}
  15.123 +
  15.124 +unsigned int img_glintfmt(struct img_pixmap *img)
  15.125 +{
  15.126 +	return img_fmt_glintfmt(img->fmt);
  15.127 +}
  15.128 +
  15.129 +unsigned int img_gltexture(struct img_pixmap *img)
  15.130 +{
  15.131 +	unsigned int tex;
  15.132 +	unsigned int intfmt, fmt, type;
  15.133 +
  15.134 +	if(!gl_gen_textures) {
  15.135 +		if(load_glfunc() == -1) {
  15.136 +			fprintf(stderr, "imago: failed to initialize the OpenGL helpers\n");
  15.137 +			return 0;
  15.138 +		}
  15.139 +	}
  15.140 +
  15.141 +	intfmt = img_glintfmt(img);
  15.142 +	fmt = img_glfmt(img);
  15.143 +	type = img_gltype(img);
  15.144 +
  15.145 +	gl_gen_textures(1, &tex);
  15.146 +	gl_bind_texture(GL_TEXTURE_2D, tex);
  15.147 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  15.148 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  15.149 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  15.150 +	gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  15.151 +	gl_tex_image2d(GL_TEXTURE_2D, 0, intfmt, img->width, img->height, 0, fmt, type, img->pixels);
  15.152 +	return tex;
  15.153 +}
  15.154 +
  15.155 +unsigned int img_gltexture_load(const char *fname)
  15.156 +{
  15.157 +	struct img_pixmap img;
  15.158 +	unsigned int tex;
  15.159 +
  15.160 +	img_init(&img);
  15.161 +	if(img_load(&img, fname) == -1) {
  15.162 +		img_destroy(&img);
  15.163 +		return 0;
  15.164 +	}
  15.165 +
  15.166 +	tex = img_gltexture(&img);
  15.167 +	img_destroy(&img);
  15.168 +	return tex;
  15.169 +}
  15.170 +
  15.171 +unsigned int img_gltexture_read_file(FILE *fp)
  15.172 +{
  15.173 +	struct img_pixmap img;
  15.174 +	unsigned int tex;
  15.175 +
  15.176 +	img_init(&img);
  15.177 +	if(img_read_file(&img, fp) == -1) {
  15.178 +		img_destroy(&img);
  15.179 +		return 0;
  15.180 +	}
  15.181 +
  15.182 +	tex = img_gltexture(&img);
  15.183 +	img_destroy(&img);
  15.184 +	return tex;
  15.185 +}
  15.186 +
  15.187 +unsigned int img_gltexture_read(struct img_io *io)
  15.188 +{
  15.189 +	struct img_pixmap img;
  15.190 +	unsigned int tex;
  15.191 +
  15.192 +	img_init(&img);
  15.193 +	if(img_read(&img, io) == -1) {
  15.194 +		img_destroy(&img);
  15.195 +		return 0;
  15.196 +	}
  15.197 +
  15.198 +	tex = img_gltexture(&img);
  15.199 +	img_destroy(&img);
  15.200 +	return tex;
  15.201 +}
  15.202 +
  15.203 +#if defined(__unix__) || defined(__APPLE__)
  15.204 +#ifndef __USE_GNU
  15.205 +#define __USE_GNU
  15.206 +#endif
  15.207 +
  15.208 +#include <dlfcn.h>
  15.209 +#endif
  15.210 +#ifdef WIN32
  15.211 +#include <windows.h>
  15.212 +#endif
  15.213 +
  15.214 +static int load_glfunc(void)
  15.215 +{
  15.216 +#if defined(__unix__) || defined(__APPLE__)
  15.217 +	gl_gen_textures = (gl_gen_textures_func)dlsym(RTLD_DEFAULT, "glGenTextures");
  15.218 +	gl_bind_texture = (gl_bind_texture_func)dlsym(RTLD_DEFAULT, "glBindTexture");
  15.219 +	gl_tex_parameteri = (gl_tex_parameteri_func)dlsym(RTLD_DEFAULT, "glTexParameteri");
  15.220 +	gl_tex_image2d = (gl_tex_image2d_func)dlsym(RTLD_DEFAULT, "glTexImage2D");
  15.221 +#endif
  15.222 +
  15.223 +#ifdef WIN32
  15.224 +	HANDLE dll = LoadLibrary("opengl32.dll");
  15.225 +	if(dll) {
  15.226 +		gl_gen_textures = (gl_gen_textures_func)GetProcAddress(dll, "glGenTextures");
  15.227 +		gl_bind_texture = (gl_bind_texture_func)GetProcAddress(dll, "glBindTexture");
  15.228 +		gl_tex_parameteri = (gl_tex_parameteri_func)GetProcAddress(dll, "glTexParameteri");
  15.229 +		gl_tex_image2d = (gl_tex_image2d_func)GetProcAddress(dll, "glTexImage2D");
  15.230 +	}
  15.231 +#endif
  15.232 +
  15.233 +	return (gl_gen_textures && gl_bind_texture && gl_tex_parameteri && gl_tex_image2d) ? 0 : -1;
  15.234 +}