dosobj = src/dos/main.obj src/dos/gfx.obj src/dos/timer.obj src/dos/watdpmi.obj &
src/dos/vbe.obj src/dos/vga.obj src/dos/keyb.obj src/dos/mouse.obj &
src/dos/logger.obj
-gameobj = src/game.obj src/util.obj
+gameobj = src/game.obj src/util.obj src/gfxutil.obj src/menuscr.obj
incpath = -Isrc -Isrc/dos -Ilibs/imago/src
libpath = libpath libs/imago
!else
dosobj = src\dos\main.obj src\dos\gfx.obj src\dos\timer.obj src\dos\watdpmi.obj &
src\dos\vbe.obj src\dos\vga.obj src\dos\keyb.obj src\dos\mouse.obj &
src\dos\logger.obj
-gameobj = src\game.obj src\util.obj
+gameobj = src\game.obj src\util.obj src\gfxutil.obj src\menuscr.obj
incpath = -Isrc -Isrc\dos -Ilibs\imago\src
libpath = libpath libs\imago
!endif
obj = $(dosobj) $(gameobj)
bin = game.exe
+libs = imago.lib
+
CC = wcc386
LD = wlink
CFLAGS = -d3 -5 -fp5 -otebmileran -s -zq -bt=dos $(incpath)
-LDFLAGS = option map $(libpath)
-# library { $(libs) }
+LDFLAGS = option map $(libpath) library { $(libs) }
$(bin): $(obj)
%write objects.lnk $(obj)
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
--- /dev/null
+!ifdef __UNIX__
+libpng = libpng/png.obj libpng/pngerror.obj libpng/pngget.obj libpng/pngmem.obj &
+ libpng/pngpread.obj libpng/pngread.obj libpng/pngrio.obj libpng/pngrtran.obj &
+ libpng/pngrutil.obj libpng/pngset.obj libpng/pngtrans.obj libpng/pngwio.obj &
+ libpng/pngwrite.obj libpng/pngwtran.obj libpng/pngwutil.obj
+zlib = zlib/adler32.obj zlib/compress.obj zlib/crc32.obj zlib/deflate.obj &
+ zlib/gzio.obj zlib/infback.obj zlib/inffast.obj zlib/inflate.obj &
+ zlib/inftrees.obj zlib/trees.obj zlib/uncompr.obj zlib/zutil.obj
+jpeglib = jpeglib/jcapimin.obj jpeglib/jcapistd.obj jpeglib/jccoefct.obj &
+ jpeglib/jccolor.obj jpeglib/jcdctmgr.obj jpeglib/jchuff.obj jpeglib/jcinit.obj &
+ jpeglib/jcmainct.obj jpeglib/jcmarker.obj jpeglib/jcmaster.obj jpeglib/jcomapi.obj &
+ jpeglib/jcparam.obj jpeglib/jcphuff.obj jpeglib/jcprepct.obj jpeglib/jcsample.obj &
+ jpeglib/jctrans.obj jpeglib/jdapimin.obj jpeglib/jdapistd.obj jpeglib/jdatadst.obj &
+ jpeglib/jdatasrc.obj jpeglib/jdcoefct.obj jpeglib/jdcolor.obj jpeglib/jddctmgr.obj &
+ jpeglib/jdhuff.obj jpeglib/jdinput.obj jpeglib/jdmainct.obj jpeglib/jdmarker.obj &
+ jpeglib/jdmaster.obj jpeglib/jdmerge.obj jpeglib/jdphuff.obj jpeglib/jdpostct.obj &
+ jpeglib/jdsample.obj jpeglib/jdtrans.obj jpeglib/jerror.obj jpeglib/jfdctflt.obj &
+ jpeglib/jfdctfst.obj jpeglib/jfdctint.obj jpeglib/jidctflt.obj jpeglib/jidctfst.obj &
+ jpeglib/jidctint.obj jpeglib/jidctred.obj jpeglib/jmemmgr.obj jpeglib/jmemnobs.obj &
+ jpeglib/jquant1.obj jpeglib/jquant2.obj jpeglib/jutils.obj
+obj = src/conv.obj src/filejpeg.obj src/filepng.obj src/fileppm.obj src/filergbe.obj &
+ src/filetga.obj src/ftmodule.obj src/imago2.obj src/imago_gl.obj src/modules.obj &
+ $(libpng) $(zlib) $(jpeglib)
+!else
+libpng = libpng\png.obj libpng\pngerror.obj libpng\pngget.obj libpng\pngmem.obj &
+ libpng\pngpread.obj libpng\pngread.obj libpng\pngrio.obj libpng\pngrtran.obj &
+ libpng\pngrutil.obj libpng\pngset.obj libpng\pngtrans.obj libpng\pngwio.obj &
+ libpng\pngwrite.obj libpng\pngwtran.obj libpng\pngwutil.obj
+zlib = zlib\adler32.obj zlib\compress.obj zlib\crc32.obj zlib\deflate.obj &
+ zlib\gzio.obj zlib\infback.obj zlib\inffast.obj zlib\inflate.obj &
+ zlib\inftrees.obj zlib\trees.obj zlib\uncompr.obj zlib\zutil.obj
+jpeglib = jpeglib\jcapimin.obj jpeglib\jcapistd.obj jpeglib\jccoefct.obj &
+ jpeglib\jccolor.obj jpeglib\jcdctmgr.obj jpeglib\jchuff.obj jpeglib\jcinit.obj &
+ jpeglib\jcmainct.obj jpeglib\jcmarker.obj jpeglib\jcmaster.obj jpeglib\jcomapi.obj &
+ jpeglib\jcparam.obj jpeglib\jcphuff.obj jpeglib\jcprepct.obj jpeglib\jcsample.obj &
+ jpeglib\jctrans.obj jpeglib\jdapimin.obj jpeglib\jdapistd.obj jpeglib\jdatadst.obj &
+ jpeglib\jdatasrc.obj jpeglib\jdcoefct.obj jpeglib\jdcolor.obj jpeglib\jddctmgr.obj &
+ jpeglib\jdhuff.obj jpeglib\jdinput.obj jpeglib\jdmainct.obj jpeglib\jdmarker.obj &
+ jpeglib\jdmaster.obj jpeglib\jdmerge.obj jpeglib\jdphuff.obj jpeglib\jdpostct.obj &
+ jpeglib\jdsample.obj jpeglib\jdtrans.obj jpeglib\jerror.obj jpeglib\jfdctflt.obj &
+ jpeglib\jfdctfst.obj jpeglib\jfdctint.obj jpeglib\jidctflt.obj jpeglib\jidctfst.obj &
+ jpeglib\jidctint.obj jpeglib\jidctred.obj jpeglib\jmemmgr.obj jpeglib\jmemnobs.obj &
+ jpeglib\jquant1.obj jpeglib\jquant2.obj jpeglib\jutils.obj
+obj = src\conv.obj src\filejpeg.obj src\filepng.obj src\fileppm.obj src\filergbe.obj &
+ src\filetga.obj src\ftmodule.obj src\imago2.obj src\imago_gl.obj src\modules.obj &
+ $(libpng) $(zlib) $(jpeglib)
+!endif
+
+alib = imago.lib
+
+opt = -5 -fp5 -otexan
+dbg = -d1
+def = -DPNG_NO_SNPRINTF
+
+CC = wcc386
+CFLAGS = $(dbg) $(opt) $(def) -zq -bt=dos -Ilibpng -Izlib -Ijpeglib
+
+$(alib): $(obj)
+ %write objects.lbc $(obj)
+ wlib -b -n $@ @objects
+
+.c: src;libpng;jpeglib;zlib
+
+.c.obj: .autodepend
+ $(CC) -fo=$@ $(CFLAGS) $[*
+
+!ifdef __UNIX__
+clean: .symbolic
+ rm -f $(obj)
+ rm -f $(alib)
+!else
+clean: .symbolic
+ del src\*.obj
+ del zlib\*.obj
+ del libpng\*.obj
+ del jpeglib\*.obj
+ del objects.lbc
+ del $(alib)
+!endif
--- /dev/null
+libimago
+========
+
+Overview
+--------
+Imago is a simple C library for reading and writing images in many different
+image file formats.
+
+Download
+--------
+Latest release: http://nuclear.mutantstargoat.com/sw/libimago/files/libimago-2.0.tar.gz
+
+Grab the source code from github: https://github.com/jtsiomb/libimago
+
+web site: http://nuclear.mutantstargoat.com/sw/libimago
+
+License
+-------
+
+Copyright (C) 2011-2015 John Tsiombikas <nuclear@member.fsf.org>
+
+You may freely use, modify and/or redistribute libimago, under the terms of the
+GNU Lesser General Public License (LGPL) version 3 (or at your option, any
+later version published by the Free Software Foundation). See COPYING_ and
+COPYING.LESSER_ for details.
+
+Usage example
+-------------
+
+heck out the example program under ``test/``, and the *heavily*
+commented ``imago2.h`` header file, to find out how to use libimago.
+
+The simplest way to load image data in RGBA 32bit is:
+
+.. code:: c
+
+ int width, height;
+ unsigned char *pixels = img_load_pixels("foo.png", &width, &height, IMG_FMT_RGBA32);
+ img_free_pixels(pixels);
+
+There's also an optional interface for loading an image and creating an OpenGL
+texture out of it in a single call:
+
+.. code:: c
+
+ unsigned int texture = img_gltexture_load("foo.png");
+
+.. _COPYING: http://www.gnu.org/licenses/gpl
+.. _COPYING.LESSER: http://www.gnu.org/licenses/lgpl
--- /dev/null
+The Independent JPEG Group's JPEG software
+==========================================
+
+README for release 8c of 16-Jan-2011
+====================================
+
+This distribution contains the eighth public release of the Independent JPEG
+Group's free JPEG software. You are welcome to redistribute this software and
+to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
+
+This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
+Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
+Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
+and other members of the Independent JPEG Group.
+
+IJG is not affiliated with the official ISO JPEG standards committee.
+
+
+DOCUMENTATION ROADMAP
+=====================
+
+This file contains the following sections:
+
+OVERVIEW General description of JPEG and the IJG software.
+LEGAL ISSUES Copyright, lack of warranty, terms of distribution.
+REFERENCES Where to learn more about JPEG.
+ARCHIVE LOCATIONS Where to find newer versions of this software.
+ACKNOWLEDGMENTS Special thanks.
+FILE FORMAT WARS Software *not* to get.
+TO DO Plans for future IJG releases.
+
+Other documentation files in the distribution are:
+
+User documentation:
+ install.txt How to configure and install the IJG software.
+ usage.txt Usage instructions for cjpeg, djpeg, jpegtran,
+ rdjpgcom, and wrjpgcom.
+ *.1 Unix-style man pages for programs (same info as usage.txt).
+ wizard.txt Advanced usage instructions for JPEG wizards only.
+ change.log Version-to-version change highlights.
+Programmer and internal documentation:
+ libjpeg.txt How to use the JPEG library in your own programs.
+ example.c Sample code for calling the JPEG library.
+ structure.txt Overview of the JPEG library's internal structure.
+ filelist.txt Road map of IJG files.
+ coderules.txt Coding style rules --- please read if you contribute code.
+
+Please read at least the files install.txt and usage.txt. Some information
+can also be found in the JPEG FAQ (Frequently Asked Questions) article. See
+ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.
+
+If you want to understand how the JPEG code works, we suggest reading one or
+more of the REFERENCES, then looking at the documentation files (in roughly
+the order listed) before diving into the code.
+
+
+OVERVIEW
+========
+
+This package contains C software to implement JPEG image encoding, decoding,
+and transcoding. JPEG (pronounced "jay-peg") is a standardized compression
+method for full-color and gray-scale images.
+
+This software implements JPEG baseline, extended-sequential, and progressive
+compression processes. Provision is made for supporting all variants of these
+processes, although some uncommon parameter settings aren't implemented yet.
+We have made no provision for supporting the hierarchical or lossless
+processes defined in the standard.
+
+We provide a set of library routines for reading and writing JPEG image files,
+plus two sample applications "cjpeg" and "djpeg", which use the library to
+perform conversion between JPEG and some other popular image file formats.
+The library is intended to be reused in other applications.
+
+In order to support file conversion and viewing software, we have included
+considerable functionality beyond the bare JPEG coding/decoding capability;
+for example, the color quantization modules are not strictly part of JPEG
+decoding, but they are essential for output to colormapped file formats or
+colormapped displays. These extra functions can be compiled out of the
+library if not required for a particular application.
+
+We have also included "jpegtran", a utility for lossless transcoding between
+different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple
+applications for inserting and extracting textual comments in JFIF files.
+
+The emphasis in designing this software has been on achieving portability and
+flexibility, while also making it fast enough to be useful. In particular,
+the software is not intended to be read as a tutorial on JPEG. (See the
+REFERENCES section for introductory material.) Rather, it is intended to
+be reliable, portable, industrial-strength code. We do not claim to have
+achieved that goal in every aspect of the software, but we strive for it.
+
+We welcome the use of this software as a component of commercial products.
+No royalty is required, but we do ask for an acknowledgement in product
+documentation, as described under LEGAL ISSUES.
+
+
+LEGAL ISSUES
+============
+
+In plain English:
+
+1. We don't promise that this software works. (But if you find any bugs,
+ please let us know!)
+2. You can use this software for whatever you want. You don't have to pay us.
+3. You may not pretend that you wrote this software. If you use it in a
+ program, you must acknowledge somewhere in your documentation that
+ you've used the IJG code.
+
+In legalese:
+
+The authors make NO WARRANTY or representation, either express or implied,
+with respect to this software, its quality, accuracy, merchantability, or
+fitness for a particular purpose. This software is provided "AS IS", and you,
+its user, assume the entire risk as to its quality and accuracy.
+
+This software is copyright (C) 1991-2011, Thomas G. Lane, Guido Vollbeding.
+All Rights Reserved except as specified below.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+software (or portions thereof) for any purpose, without fee, subject to these
+conditions:
+(1) If any part of the source code for this software is distributed, then this
+README file must be included, with this copyright and no-warranty notice
+unaltered; and any additions, deletions, or changes to the original files
+must be clearly indicated in accompanying documentation.
+(2) If only executable code is distributed, then the accompanying
+documentation must state that "this software is based in part on the work of
+the Independent JPEG Group".
+(3) Permission for use of this software is granted only if the user accepts
+full responsibility for any undesirable consequences; the authors accept
+NO LIABILITY for damages of any kind.
+
+These conditions apply to any software derived from or based on the IJG code,
+not just to the unmodified library. If you use our work, you ought to
+acknowledge us.
+
+Permission is NOT granted for the use of any IJG author's name or company name
+in advertising or publicity relating to this software or products derived from
+it. This software may be referred to only as "the Independent JPEG Group's
+software".
+
+We specifically permit and encourage the use of this software as the basis of
+commercial products, provided that all warranty or liability claims are
+assumed by the product vendor.
+
+
+ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,
+sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.
+ansi2knr.c is NOT covered by the above copyright and conditions, but instead
+by the usual distribution terms of the Free Software Foundation; principally,
+that you must include source code if you redistribute it. (See the file
+ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part
+of any program generated from the IJG code, this does not limit you more than
+the foregoing paragraphs do.
+
+The Unix configuration script "configure" was produced with GNU Autoconf.
+It is copyright by the Free Software Foundation but is freely distributable.
+The same holds for its supporting scripts (config.guess, config.sub,
+ltmain.sh). Another support script, install-sh, is copyright by X Consortium
+but is also freely distributable.
+
+The IJG distribution formerly included code to read and write GIF files.
+To avoid entanglement with the Unisys LZW patent, GIF reading support has
+been removed altogether, and the GIF writer has been simplified to produce
+"uncompressed GIFs". This technique does not use the LZW algorithm; the
+resulting GIF files are larger than usual, but are readable by all standard
+GIF decoders.
+
+We are required to state that
+ "The Graphics Interchange Format(c) is the Copyright property of
+ CompuServe Incorporated. GIF(sm) is a Service Mark property of
+ CompuServe Incorporated."
+
+
+REFERENCES
+==========
+
+We recommend reading one or more of these references before trying to
+understand the innards of the JPEG software.
+
+The best short technical introduction to the JPEG compression algorithm is
+ Wallace, Gregory K. "The JPEG Still Picture Compression Standard",
+ Communications of the ACM, April 1991 (vol. 34 no. 4), pp. 30-44.
+(Adjacent articles in that issue discuss MPEG motion picture compression,
+applications of JPEG, and related topics.) If you don't have the CACM issue
+handy, a PostScript file containing a revised version of Wallace's article is
+available at http://www.ijg.org/files/wallace.ps.gz. The file (actually
+a preprint for an article that appeared in IEEE Trans. Consumer Electronics)
+omits the sample images that appeared in CACM, but it includes corrections
+and some added material. Note: the Wallace article is copyright ACM and IEEE,
+and it may not be used for commercial purposes.
+
+A somewhat less technical, more leisurely introduction to JPEG can be found in
+"The Data Compression Book" by Mark Nelson and Jean-loup Gailly, published by
+M&T Books (New York), 2nd ed. 1996, ISBN 1-55851-434-1. This book provides
+good explanations and example C code for a multitude of compression methods
+including JPEG. It is an excellent source if you are comfortable reading C
+code but don't know much about data compression in general. The book's JPEG
+sample code is far from industrial-strength, but when you are ready to look
+at a full implementation, you've got one here...
+
+The best currently available description of JPEG is the textbook "JPEG Still
+Image Data Compression Standard" by William B. Pennebaker and Joan L.
+Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
+Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG
+standards (DIS 10918-1 and draft DIS 10918-2).
+Although this is by far the most detailed and comprehensive exposition of
+JPEG publicly available, we point out that it is still missing an explanation
+of the most essential properties and algorithms of the underlying DCT
+technology.
+If you think that you know about DCT-based JPEG after reading this book,
+then you are in delusion. The real fundamentals and corresponding potential
+of DCT-based JPEG are not publicly known so far, and that is the reason for
+all the mistaken developments taking place in the image coding domain.
+
+The original JPEG standard is divided into two parts, Part 1 being the actual
+specification, while Part 2 covers compliance testing methods. Part 1 is
+titled "Digital Compression and Coding of Continuous-tone Still Images,
+Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
+10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of
+Continuous-tone Still Images, Part 2: Compliance testing" and has document
+numbers ISO/IEC IS 10918-2, ITU-T T.83.
+IJG JPEG 8 introduces an implementation of the JPEG SmartScale extension
+which is specified in a contributed document at ITU and ISO with title "ITU-T
+JPEG-Plus Proposal for Extending ITU-T T.81 for Advanced Image Coding", April
+2006, Geneva, Switzerland. The latest version of the document is Revision 3.
+
+The JPEG standard does not specify all details of an interchangeable file
+format. For the omitted details we follow the "JFIF" conventions, revision
+1.02. JFIF 1.02 has been adopted as an Ecma International Technical Report
+and thus received a formal publication status. It is available as a free
+download in PDF format from
+http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
+A PostScript version of the JFIF document is available at
+http://www.ijg.org/files/jfif.ps.gz. There is also a plain text version at
+http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.
+
+The TIFF 6.0 file format specification can be obtained by FTP from
+ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme
+found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
+IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
+Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
+(Compression tag 7). Copies of this Note can be obtained from
+http://www.ijg.org/files/. It is expected that the next revision
+of the TIFF spec will replace the 6.0 JPEG design with the Note's design.
+Although IJG's own code does not support TIFF/JPEG, the free libtiff library
+uses our library to implement TIFF/JPEG per the Note.
+
+
+ARCHIVE LOCATIONS
+=================
+
+The "official" archive site for this software is www.ijg.org.
+The most recent released version can always be found there in
+directory "files". This particular version will be archived as
+http://www.ijg.org/files/jpegsrc.v8c.tar.gz, and in Windows-compatible
+"zip" archive format as http://www.ijg.org/files/jpegsr8c.zip.
+
+The JPEG FAQ (Frequently Asked Questions) article is a source of some
+general information about JPEG.
+It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/
+and other news.answers archive sites, including the official news.answers
+archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.
+If you don't have Web or FTP access, send e-mail to mail-server@rtfm.mit.edu
+with body
+ send usenet/news.answers/jpeg-faq/part1
+ send usenet/news.answers/jpeg-faq/part2
+
+
+ACKNOWLEDGMENTS
+===============
+
+Thank to Juergen Bruder for providing me with a copy of the common DCT
+algorithm article, only to find out that I had come to the same result
+in a more direct and comprehensible way with a more generative approach.
+
+Thank to Istvan Sebestyen and Joan L. Mitchell for inviting me to the
+ITU JPEG (Study Group 16) meeting in Geneva, Switzerland.
+
+Thank to Thomas Wiegand and Gary Sullivan for inviting me to the
+Joint Video Team (MPEG & ITU) meeting in Geneva, Switzerland.
+
+Thank to John Korejwa and Massimo Ballerini for inviting me to
+fruitful consultations in Boston, MA and Milan, Italy.
+
+Thank to Hendrik Elstner, Roland Fassauer, Simone Zuck, Guenther
+Maier-Gerber, Walter Stoeber, Fred Schmitz, and Norbert Braunagel
+for corresponding business development.
+
+Thank to Nico Zschach and Dirk Stelling of the technical support team
+at the Digital Images company in Halle for providing me with extra
+equipment for configuration tests.
+
+Thank to Richard F. Lyon (then of Foveon Inc.) for fruitful
+communication about JPEG configuration in Sigma Photo Pro software.
+
+Thank to Andrew Finkenstadt for hosting the ijg.org site.
+
+Last but not least special thank to Thomas G. Lane for the original
+design and development of this singular software package.
+
+
+FILE FORMAT WARS
+================
+
+The ISO JPEG standards committee actually promotes different formats like
+"JPEG 2000" or "JPEG XR" which are incompatible with original DCT-based
+JPEG and which are based on faulty technologies. IJG therefore does not
+and will not support such momentary mistakes (see REFERENCES).
+We have little or no sympathy for the promotion of these formats. Indeed,
+one of the original reasons for developing this free software was to help
+force convergence on common, interoperable format standards for JPEG files.
+Don't use an incompatible file format!
+(In any case, our decoder will remain capable of reading existing JPEG
+image files indefinitely.)
+
+
+TO DO
+=====
+
+Version 8 is the first release of a new generation JPEG standard
+to overcome the limitations of the original JPEG specification.
+More features are being prepared for coming releases...
+
+Please send bug reports, offers of help, etc. to jpeg-info@uc.ag.
--- /dev/null
+/*
+ * cderror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the cjpeg/djpeg
+ * applications. These strings are not needed as part of the JPEG library
+ * proper.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE. To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef CDERROR_H
+#define CDERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* CDERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string) code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
+
+#ifdef BMP_SUPPORTED
+JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
+JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
+JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
+JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
+JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
+JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
+JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
+JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
+JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
+JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
+JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
+#endif /* BMP_SUPPORTED */
+
+#ifdef GIF_SUPPORTED
+JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
+JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
+JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
+JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
+JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
+JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
+JMESSAGE(JTRC_GIF_BADVERSION,
+ "Warning: unexpected GIF version number '%c%c%c'")
+JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
+JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
+JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
+JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
+JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
+JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
+#endif /* GIF_SUPPORTED */
+
+#ifdef PPM_SUPPORTED
+JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
+JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
+JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
+JMESSAGE(JTRC_PGM, "%ux%u PGM image")
+JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
+JMESSAGE(JTRC_PPM, "%ux%u PPM image")
+JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
+#endif /* PPM_SUPPORTED */
+
+#ifdef RLE_SUPPORTED
+JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
+JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
+JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
+JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
+JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
+JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
+JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
+JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
+JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
+JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
+JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
+JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
+JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
+#endif /* RLE_SUPPORTED */
+
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
+JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
+JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
+JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
+JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
+JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
+#else
+JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
+#endif /* TARGA_SUPPORTED */
+
+JMESSAGE(JERR_BAD_CMAP_FILE,
+ "Color map file is invalid or of unsupported format")
+JMESSAGE(JERR_TOO_MANY_COLORS,
+ "Output file format cannot handle %d colormap entries")
+JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
+#ifdef TARGA_SUPPORTED
+JMESSAGE(JERR_UNKNOWN_FORMAT,
+ "Unrecognized input file format --- perhaps you need -targa")
+#else
+JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
+#endif
+JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
+
+#ifdef JMAKE_ENUM_LIST
+
+ JMSG_LASTADDONCODE
+} ADDON_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
--- /dev/null
+/*
+ * jcapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library. These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c. But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateCompress (j_compress_ptr cinfo, int version, size_t structsize)
+{
+ int i;
+
+ /* Guard against version mismatches between library and caller. */
+ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */
+ if (version != JPEG_LIB_VERSION)
+ ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+ if (structsize != SIZEOF(struct jpeg_compress_struct))
+ ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+ (int) SIZEOF(struct jpeg_compress_struct), (int) structsize);
+
+ /* For debugging purposes, we zero the whole master structure.
+ * But the application has already set the err pointer, and may have set
+ * client_data, so we have to save and restore those fields.
+ * Note: if application hasn't set client_data, tools like Purify may
+ * complain here.
+ */
+ {
+ struct jpeg_error_mgr * err = cinfo->err;
+ void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+ MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
+ cinfo->err = err;
+ cinfo->client_data = client_data;
+ }
+ cinfo->is_decompressor = FALSE;
+
+ /* Initialize a memory manager instance for this object */
+ jinit_memory_mgr((j_common_ptr) cinfo);
+
+ /* Zero out pointers to permanent structures. */
+ cinfo->progress = NULL;
+ cinfo->dest = NULL;
+
+ cinfo->comp_info = NULL;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++)
+ cinfo->quant_tbl_ptrs[i] = NULL;
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ cinfo->dc_huff_tbl_ptrs[i] = NULL;
+ cinfo->ac_huff_tbl_ptrs[i] = NULL;
+ }
+
+ cinfo->script_space = NULL;
+
+ cinfo->input_gamma = 1.0; /* in case application forgets */
+
+ /* OK, I'm ready */
+ cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_compress (j_compress_ptr cinfo)
+{
+ jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_compress (j_compress_ptr cinfo)
+{
+ jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress). This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams. It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL(void)
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
+{
+ int i;
+ JQUANT_TBL * qtbl;
+ JHUFF_TBL * htbl;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+ qtbl->sent_table = suppress;
+ }
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+ htbl->sent_table = suppress;
+ if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+ htbl->sent_table = suppress;
+ }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL(void)
+jpeg_finish_compress (j_compress_ptr cinfo)
+{
+ JDIMENSION iMCU_row;
+
+ if (cinfo->global_state == CSTATE_SCANNING ||
+ cinfo->global_state == CSTATE_RAW_OK) {
+ /* Terminate first pass */
+ if (cinfo->next_scanline < cinfo->image_height)
+ ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+ (*cinfo->master->finish_pass) (cinfo);
+ } else if (cinfo->global_state != CSTATE_WRCOEFS)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Perform any remaining passes */
+ while (! cinfo->master->is_last_pass) {
+ (*cinfo->master->prepare_for_pass) (cinfo);
+ for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) iMCU_row;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+ /* We bypass the main controller and invoke coef controller directly;
+ * all work is being done from the coefficient buffer.
+ */
+ if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+ }
+ (*cinfo->master->finish_pass) (cinfo);
+ }
+ /* Write EOI, do final cleanup */
+ (*cinfo->marker->write_file_trailer) (cinfo);
+ (*cinfo->dest->term_destination) (cinfo);
+ /* We can use jpeg_abort to release memory and reset global_state */
+ jpeg_abort((j_common_ptr) cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL(void)
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+ const JOCTET *dataptr, unsigned int datalen)
+{
+ JMETHOD(void, write_marker_byte, (j_compress_ptr info, int val));
+
+ if (cinfo->next_scanline != 0 ||
+ (cinfo->global_state != CSTATE_SCANNING &&
+ cinfo->global_state != CSTATE_RAW_OK &&
+ cinfo->global_state != CSTATE_WRCOEFS))
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+ write_marker_byte = cinfo->marker->write_marker_byte; /* copy for speed */
+ while (datalen--) {
+ (*write_marker_byte) (cinfo, *dataptr);
+ dataptr++;
+ }
+}
+
+/* Same, but piecemeal. */
+
+GLOBAL(void)
+jpeg_write_m_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+{
+ if (cinfo->next_scanline != 0 ||
+ (cinfo->global_state != CSTATE_SCANNING &&
+ cinfo->global_state != CSTATE_RAW_OK &&
+ cinfo->global_state != CSTATE_WRCOEFS))
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ (*cinfo->marker->write_marker_header) (cinfo, marker, datalen);
+}
+
+GLOBAL(void)
+jpeg_write_m_byte (j_compress_ptr cinfo, int val)
+{
+ (*cinfo->marker->write_marker_byte) (cinfo, val);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ * initialize JPEG object
+ * set JPEG parameters
+ * set destination to table file
+ * jpeg_write_tables(cinfo);
+ * set destination to image file
+ * jpeg_start_compress(cinfo, FALSE);
+ * write data...
+ * jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)). Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL(void)
+jpeg_write_tables (j_compress_ptr cinfo)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Initialize the marker writer ... bit of a crock to do it here. */
+ jinit_marker_writer(cinfo);
+ /* Write them tables! */
+ (*cinfo->marker->write_tables_only) (cinfo);
+ /* And clean up. */
+ (*cinfo->dest->term_destination) (cinfo);
+ /*
+ * In library releases up through v6a, we called jpeg_abort() here to free
+ * any working memory allocated by the destination manager and marker
+ * writer. Some applications had a problem with that: they allocated space
+ * of their own from the library memory manager, and didn't want it to go
+ * away during write_tables. So now we do nothing. This will cause a
+ * memory leak if an app calls write_tables repeatedly without doing a full
+ * compression cycle or otherwise resetting the JPEG object. However, that
+ * seems less bad than unexpectedly freeing memory in the normal case.
+ * An app that prefers the old behavior can call jpeg_abort for itself after
+ * each call to jpeg_write_tables().
+ */
+}
--- /dev/null
+/*
+ * jcapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library. These are the "standard" API routines that are
+ * used in the normal full-compression case. They are not used by a
+ * transcoding-only application. Note that if an application links in
+ * jpeg_start_compress, it will end up linking in the entire compressor.
+ * We thus must separate this file from jcapimin.c to avoid linking the
+ * whole compression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object. Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default. This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images. Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL(void)
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (write_all_tables)
+ jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */
+
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Perform master selection of active modules */
+ jinit_compress_master(cinfo);
+ /* Set up for the first pass */
+ (*cinfo->master->prepare_for_pass) (cinfo);
+ /* Ready for application to drive first pass through jpeg_write_scanlines
+ * or jpeg_write_raw_data.
+ */
+ cinfo->next_scanline = 0;
+ cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error. However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+ JDIMENSION num_lines)
+{
+ JDIMENSION row_ctr, rows_left;
+
+ if (cinfo->global_state != CSTATE_SCANNING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->next_scanline >= cinfo->image_height)
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->image_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Give master control module another chance if this is first call to
+ * jpeg_write_scanlines. This lets output of the frame/scan headers be
+ * delayed so that application can write COM, etc, markers between
+ * jpeg_start_compress and jpeg_write_scanlines.
+ */
+ if (cinfo->master->call_pass_startup)
+ (*cinfo->master->pass_startup) (cinfo);
+
+ /* Ignore any extra scanlines at bottom of image. */
+ rows_left = cinfo->image_height - cinfo->next_scanline;
+ if (num_lines > rows_left)
+ num_lines = rows_left;
+
+ row_ctr = 0;
+ (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+ cinfo->next_scanline += row_ctr;
+ return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to write raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_write_raw_data (j_compress_ptr cinfo, JSAMPIMAGE data,
+ JDIMENSION num_lines)
+{
+ JDIMENSION lines_per_iMCU_row;
+
+ if (cinfo->global_state != CSTATE_RAW_OK)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->next_scanline >= cinfo->image_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->image_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Give master control module another chance if this is first call to
+ * jpeg_write_raw_data. This lets output of the frame/scan headers be
+ * delayed so that application can write COM, etc, markers between
+ * jpeg_start_compress and jpeg_write_raw_data.
+ */
+ if (cinfo->master->call_pass_startup)
+ (*cinfo->master->pass_startup) (cinfo);
+
+ /* Verify that at least one iMCU row has been passed. */
+ lines_per_iMCU_row = cinfo->max_v_samp_factor * DCTSIZE;
+ if (num_lines < lines_per_iMCU_row)
+ ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+ /* Directly compress the row. */
+ if (! (*cinfo->coef->compress_data) (cinfo, data)) {
+ /* If compressor did not consume the whole row, suspend processing. */
+ return 0;
+ }
+
+ /* OK, we processed one iMCU row. */
+ cinfo->next_scanline += lines_per_iMCU_row;
+ return lines_per_iMCU_row;
+}
--- /dev/null
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files. In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_coef_controller pub; /* public fields */
+
+ JDIMENSION iMCU_row_num; /* iMCU row # within image */
+ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* For single-pass compression, it's sufficient to buffer just one MCU
+ * (although this may prove a bit slow in practice). We allocate a
+ * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+ * MCU constructed and sent. (On 80x86, the workspace is FAR even though
+ * it's not really very big; this is to keep the module interfaces unchanged
+ * when a large coefficient buffer is necessary.)
+ * In multi-pass modes, this array points to the current MCU's blocks
+ * within the virtual arrays.
+ */
+ JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+ /* In multi-pass modes, we need a virtual block array for each component. */
+ jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF(boolean) compress_data
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF(boolean) compress_first_pass
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF(boolean) compress_output
+ JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->mcu_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ coef->iMCU_row_num = 0;
+ start_iMCU_row(cinfo);
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (coef->whole_image[0] != NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_data;
+ break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+ case JBUF_SAVE_AND_PASS:
+ if (coef->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_first_pass;
+ break;
+ case JBUF_CRANK_DEST:
+ if (coef->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ coef->pub.compress_data = compress_output;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(boolean)
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, bi, ci, yindex, yoffset, blockcnt;
+ JDIMENSION ypos, xpos;
+ jpeg_component_info *compptr;
+
+ /* Loop to write as much as one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+ MCU_col_num++) {
+ /* Determine where data comes from in input_buf and do the DCT thing.
+ * Each call on forward_DCT processes a horizontal row of DCT blocks
+ * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+ * sequentially. Dummy blocks at the right or bottom edge are filled in
+ * specially. The data in them does not matter for image reconstruction,
+ * so we fill them with values that will encode to the smallest amount of
+ * data, viz: all zeroes in the AC entries, DC entries equal to previous
+ * block's DC value. (Thanks to Thomas Kinsman for this idea.)
+ */
+ blkn = 0;
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ xpos = MCU_col_num * compptr->MCU_sample_width;
+ ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (coef->iMCU_row_num < last_iMCU_row ||
+ yoffset+yindex < compptr->last_row_height) {
+ (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+ input_buf[compptr->component_index],
+ coef->MCU_buffer[blkn],
+ ypos, xpos, (JDIMENSION) blockcnt);
+ if (blockcnt < compptr->MCU_width) {
+ /* Create some dummy blocks at the right edge of the image. */
+ jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+ (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+ for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+ coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+ }
+ }
+ } else {
+ /* Create a row of dummy blocks at the bottom of the image. */
+ jzero_far((void FAR *) coef->MCU_buffer[blkn],
+ compptr->MCU_width * SIZEOF(JBLOCK));
+ for (bi = 0; bi < compptr->MCU_width; bi++) {
+ coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+ }
+ }
+ blkn += compptr->MCU_width;
+ ypos += DCTSIZE;
+ }
+ }
+ /* Try to write the MCU. In event of a suspension failure, we will
+ * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+ */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays. We also generate suitable dummy blocks
+ * as needed at the right and lower edges. (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.) This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder. This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image. All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF(boolean)
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION blocks_across, MCUs_across, MCUindex;
+ int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+ JCOEF lastDC;
+ jpeg_component_info *compptr;
+ JBLOCKARRAY buffer;
+ JBLOCKROW thisblockrow, lastblockrow;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Align the virtual buffer for this component. */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, TRUE);
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (coef->iMCU_row_num < last_iMCU_row)
+ block_rows = compptr->v_samp_factor;
+ else {
+ /* NB: can't use last_row_height here, since may not be set! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ }
+ blocks_across = compptr->width_in_blocks;
+ h_samp_factor = compptr->h_samp_factor;
+ /* Count number of dummy blocks to be added at the right margin. */
+ ndummy = (int) (blocks_across % h_samp_factor);
+ if (ndummy > 0)
+ ndummy = h_samp_factor - ndummy;
+ /* Perform DCT for all non-dummy blocks in this iMCU row. Each call
+ * on forward_DCT processes a complete horizontal row of DCT blocks.
+ */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ thisblockrow = buffer[block_row];
+ (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+ input_buf[ci], thisblockrow,
+ (JDIMENSION) (block_row * DCTSIZE),
+ (JDIMENSION) 0, blocks_across);
+ if (ndummy > 0) {
+ /* Create dummy blocks at the right edge of the image. */
+ thisblockrow += blocks_across; /* => first dummy block */
+ jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+ lastDC = thisblockrow[-1][0];
+ for (bi = 0; bi < ndummy; bi++) {
+ thisblockrow[bi][0] = lastDC;
+ }
+ }
+ }
+ /* If at end of image, create dummy block rows as needed.
+ * The tricky part here is that within each MCU, we want the DC values
+ * of the dummy blocks to match the last real block's DC value.
+ * This squeezes a few more bytes out of the resulting file...
+ */
+ if (coef->iMCU_row_num == last_iMCU_row) {
+ blocks_across += ndummy; /* include lower right corner */
+ MCUs_across = blocks_across / h_samp_factor;
+ for (block_row = block_rows; block_row < compptr->v_samp_factor;
+ block_row++) {
+ thisblockrow = buffer[block_row];
+ lastblockrow = buffer[block_row-1];
+ jzero_far((void FAR *) thisblockrow,
+ (size_t) (blocks_across * SIZEOF(JBLOCK)));
+ for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+ lastDC = lastblockrow[h_samp_factor-1][0];
+ for (bi = 0; bi < h_samp_factor; bi++) {
+ thisblockrow[bi][0] = lastDC;
+ }
+ thisblockrow += h_samp_factor; /* advance to next MCU in row */
+ lastblockrow += h_samp_factor;
+ }
+ }
+ }
+ }
+ /* NB: compress_output will increment iMCU_row_num if successful.
+ * A suspension return will result in redoing all the work above next time.
+ */
+
+ /* Emit data to the entropy encoder, sharing code with subsequent passes */
+ return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ int blkn, ci, xindex, yindex, yoffset;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan.
+ * NB: during first pass, this is safe only because the buffers will
+ * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+ coef->MCU_buffer[blkn++] = buffer_ptr++;
+ }
+ }
+ }
+ /* Try to write the MCU. */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_coef_ptr coef;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+ coef->pub.start_pass = start_pass_coef;
+
+ /* Create the coefficient buffer. */
+ if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+ /* Allocate a full-image virtual array for each component, */
+ /* padded to a multiple of samp_factor DCT blocks in each direction. */
+ int ci;
+ jpeg_component_info *compptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+ (long) compptr->h_samp_factor),
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor),
+ (JDIMENSION) compptr->v_samp_factor);
+ }
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ } else {
+ /* We only need a single-MCU buffer. */
+ JBLOCKROW buffer;
+ int i;
+
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+ coef->MCU_buffer[i] = buffer + i;
+ }
+ coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+ }
+}
--- /dev/null
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_converter pub; /* public fields */
+
+ /* Private state for RGB->YCC conversion */
+ INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter * my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ * Y = 0.29900 * R + 0.58700 * G + 0.11400 * B
+ * Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + CENTERJSAMPLE
+ * Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr. This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly. Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable. It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define CBCR_OFFSET ((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests. This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF 0 /* offset to R => Y section */
+#define G_Y_OFF (1*(MAXJSAMPLE+1)) /* offset to G => Y section */
+#define B_Y_OFF (2*(MAXJSAMPLE+1)) /* etc. */
+#define R_CB_OFF (3*(MAXJSAMPLE+1))
+#define G_CB_OFF (4*(MAXJSAMPLE+1))
+#define B_CB_OFF (5*(MAXJSAMPLE+1))
+#define R_CR_OFF B_CB_OFF /* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF (6*(MAXJSAMPLE+1))
+#define B_CR_OFF (7*(MAXJSAMPLE+1))
+#define TABLE_SIZE (8*(MAXJSAMPLE+1))
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF(void)
+rgb_ycc_start (j_compress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ INT32 * rgb_ycc_tab;
+ INT32 i;
+
+ /* Allocate and fill in the conversion tables. */
+ cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (TABLE_SIZE * SIZEOF(INT32)));
+
+ for (i = 0; i <= MAXJSAMPLE; i++) {
+ rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+ rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+ rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i + ONE_HALF;
+ rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+ rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
+ /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+ * This ensures that the maximum output will round to MAXJSAMPLE
+ * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+ */
+ rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1;
+/* B=>Cb and R=>Cr tables are the same
+ rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i + CBCR_OFFSET + ONE_HALF-1;
+*/
+ rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+ rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer. The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+rgb_ycc_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr0, outptr1, outptr2;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr0 = output_buf[0][output_row];
+ outptr1 = output_buf[1][output_row];
+ outptr2 = output_buf[2][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = GETJSAMPLE(inptr[RGB_RED]);
+ g = GETJSAMPLE(inptr[RGB_GREEN]);
+ b = GETJSAMPLE(inptr[RGB_BLUE]);
+ inptr += RGB_PIXELSIZE;
+ /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+ * must be too; we do not need an explicit range-limiting operation.
+ * Hence the value being shifted is never negative, and we don't
+ * need the general RIGHT_SHIFT macro.
+ */
+ /* Y */
+ outptr0[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ /* Cb */
+ outptr1[col] = (JSAMPLE)
+ ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+ >> SCALEBITS);
+ /* Cr */
+ outptr2[col] = (JSAMPLE)
+ ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+METHODDEF(void)
+rgb_gray_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr = output_buf[0][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = GETJSAMPLE(inptr[RGB_RED]);
+ g = GETJSAMPLE(inptr[RGB_GREEN]);
+ b = GETJSAMPLE(inptr[RGB_BLUE]);
+ inptr += RGB_PIXELSIZE;
+ /* Y */
+ outptr[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF(void)
+cmyk_ycck_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int r, g, b;
+ register INT32 * ctab = cconvert->rgb_ycc_tab;
+ register JSAMPROW inptr;
+ register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr0 = output_buf[0][output_row];
+ outptr1 = output_buf[1][output_row];
+ outptr2 = output_buf[2][output_row];
+ outptr3 = output_buf[3][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+ g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+ b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
+ /* K passes through as-is */
+ outptr3[col] = inptr[3]; /* don't need GETJSAMPLE here */
+ inptr += 4;
+ /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+ * must be too; we do not need an explicit range-limiting operation.
+ * Hence the value being shifted is never negative, and we don't
+ * need the general RIGHT_SHIFT macro.
+ */
+ /* Y */
+ outptr0[col] = (JSAMPLE)
+ ((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+ >> SCALEBITS);
+ /* Cb */
+ outptr1[col] = (JSAMPLE)
+ ((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+ >> SCALEBITS);
+ /* Cr */
+ outptr2[col] = (JSAMPLE)
+ ((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+ >> SCALEBITS);
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF(void)
+grayscale_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->image_width;
+ int instride = cinfo->input_components;
+
+ while (--num_rows >= 0) {
+ inptr = *input_buf++;
+ outptr = output_buf[0][output_row];
+ output_row++;
+ for (col = 0; col < num_cols; col++) {
+ outptr[col] = inptr[0]; /* don't need GETJSAMPLE() here */
+ inptr += instride;
+ }
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF(void)
+null_convert (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows)
+{
+ register JSAMPROW inptr;
+ register JSAMPROW outptr;
+ register JDIMENSION col;
+ register int ci;
+ int nc = cinfo->num_components;
+ JDIMENSION num_cols = cinfo->image_width;
+
+ while (--num_rows >= 0) {
+ /* It seems fastest to make a separate pass for each component. */
+ for (ci = 0; ci < nc; ci++) {
+ inptr = *input_buf;
+ outptr = output_buf[ci][output_row];
+ for (col = 0; col < num_cols; col++) {
+ outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+ inptr += nc;
+ }
+ }
+ input_buf++;
+ output_row++;
+ }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+null_method (j_compress_ptr cinfo)
+{
+ /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_converter (j_compress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert;
+
+ cconvert = (my_cconvert_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_color_converter));
+ cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
+ /* set start_pass to null method until we find out differently */
+ cconvert->pub.start_pass = null_method;
+
+ /* Make sure input_components agrees with in_color_space */
+ switch (cinfo->in_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->input_components != 1)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+ if (cinfo->input_components != RGB_PIXELSIZE)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+#endif /* else share code with YCbCr */
+
+ case JCS_YCbCr:
+ if (cinfo->input_components != 3)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ case JCS_CMYK:
+ case JCS_YCCK:
+ if (cinfo->input_components != 4)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+
+ default: /* JCS_UNKNOWN can be anything */
+ if (cinfo->input_components < 1)
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ break;
+ }
+
+ /* Check num_components, set conversion method based on requested space */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->num_components != 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_GRAYSCALE)
+ cconvert->pub.color_convert = grayscale_convert;
+ else if (cinfo->in_color_space == JCS_RGB) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = rgb_gray_convert;
+ } else if (cinfo->in_color_space == JCS_YCbCr)
+ cconvert->pub.color_convert = grayscale_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_RGB:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_YCbCr:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_RGB) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = rgb_ycc_convert;
+ } else if (cinfo->in_color_space == JCS_YCbCr)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_CMYK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_CMYK)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_YCCK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ if (cinfo->in_color_space == JCS_CMYK) {
+ cconvert->pub.start_pass = rgb_ycc_start;
+ cconvert->pub.color_convert = cmyk_ycck_convert;
+ } else if (cinfo->in_color_space == JCS_YCCK)
+ cconvert->pub.color_convert = null_convert;
+ else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ default: /* allow null conversion of JCS_UNKNOWN */
+ if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+ cinfo->num_components != cinfo->input_components)
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ cconvert->pub.color_convert = null_convert;
+ break;
+ }
+}
--- /dev/null
+/*
+ * jcdctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+ struct jpeg_forward_dct pub; /* public fields */
+
+ /* Pointer to the DCT routine actually in use */
+ forward_DCT_method_ptr do_dct;
+
+ /* The actual post-DCT divisors --- not identical to the quant table
+ * entries, because of scaling (especially for an unnormalized DCT).
+ * Each table is given in normal array order.
+ */
+ DCTELEM * divisors[NUM_QUANT_TBLS];
+
+#ifdef DCT_FLOAT_SUPPORTED
+ /* Same as above for the floating-point case. */
+ float_DCT_method_ptr do_float_dct;
+ FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller * my_fdct_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan. Hence all components should be examined here.
+ */
+
+METHODDEF(void)
+start_pass_fdctmgr (j_compress_ptr cinfo)
+{
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ int ci, qtblno, i;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtbl;
+ DCTELEM * dtbl;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ qtblno = compptr->quant_tbl_no;
+ /* Make sure specified quantization table is present */
+ if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+ cinfo->quant_tbl_ptrs[qtblno] == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+ qtbl = cinfo->quant_tbl_ptrs[qtblno];
+ /* Compute divisors for this quant table */
+ /* We may do this more than once for same table, but it's not a big deal */
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ /* For LL&M IDCT method, divisors are equal to raw quantization
+ * coefficients multiplied by 8 (to counteract scaling).
+ */
+ if (fdct->divisors[qtblno] == NULL) {
+ fdct->divisors[qtblno] = (DCTELEM *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(DCTELEM));
+ }
+ dtbl = fdct->divisors[qtblno];
+ for (i = 0; i < DCTSIZE2; i++) {
+ dtbl[i] = ((DCTELEM) qtbl->quantval[i]) << 3;
+ }
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ {
+ /* For AA&N IDCT method, divisors are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * We apply a further scale factor of 8.
+ */
+#define CONST_BITS 14
+ static const INT16 aanscales[DCTSIZE2] = {
+ /* precomputed values scaled up by 14 bits */
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
+ 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
+ 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
+ 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
+ 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
+ };
+ SHIFT_TEMPS
+
+ if (fdct->divisors[qtblno] == NULL) {
+ fdct->divisors[qtblno] = (DCTELEM *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(DCTELEM));
+ }
+ dtbl = fdct->divisors[qtblno];
+ for (i = 0; i < DCTSIZE2; i++) {
+ dtbl[i] = (DCTELEM)
+ DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+ (INT32) aanscales[i]),
+ CONST_BITS-3);
+ }
+ }
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ {
+ /* For float AA&N IDCT method, divisors are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * We apply a further scale factor of 8.
+ * What's actually stored is 1/divisor so that the inner loop can
+ * use a multiplication rather than a division.
+ */
+ FAST_FLOAT * fdtbl;
+ int row, col;
+ static const double aanscalefactor[DCTSIZE] = {
+ 1.0, 1.387039845, 1.306562965, 1.175875602,
+ 1.0, 0.785694958, 0.541196100, 0.275899379
+ };
+
+ if (fdct->float_divisors[qtblno] == NULL) {
+ fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ DCTSIZE2 * SIZEOF(FAST_FLOAT));
+ }
+ fdtbl = fdct->float_divisors[qtblno];
+ i = 0;
+ for (row = 0; row < DCTSIZE; row++) {
+ for (col = 0; col < DCTSIZE; col++) {
+ fdtbl[i] = (FAST_FLOAT)
+ (1.0 / (((double) qtbl->quantval[i] *
+ aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+ i++;
+ }
+ }
+ }
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ }
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+METHODDEF(void)
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+ /* This routine is heavily used, so it's worth coding it tightly. */
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ forward_DCT_method_ptr do_dct = fdct->do_dct;
+ DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
+ DCTELEM workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+ JDIMENSION bi;
+
+ sample_data += start_row; /* fold in the vertical offset once */
+
+ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+ /* Load data into workspace, applying unsigned->signed conversion */
+ { register DCTELEM *workspaceptr;
+ register JSAMPROW elemptr;
+ register int elemr;
+
+ workspaceptr = workspace;
+ for (elemr = 0; elemr < DCTSIZE; elemr++) {
+ elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8 /* unroll the inner loop */
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+ { register int elemc;
+ for (elemc = DCTSIZE; elemc > 0; elemc--) {
+ *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+ }
+ }
+#endif
+ }
+ }
+
+ /* Perform the DCT */
+ (*do_dct) (workspace);
+
+ /* Quantize/descale the coefficients, and store into coef_blocks[] */
+ { register DCTELEM temp, qval;
+ register int i;
+ register JCOEFPTR output_ptr = coef_blocks[bi];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ qval = divisors[i];
+ temp = workspace[i];
+ /* Divide the coefficient value by qval, ensuring proper rounding.
+ * Since C does not specify the direction of rounding for negative
+ * quotients, we have to force the dividend positive for portability.
+ *
+ * In most files, at least half of the output values will be zero
+ * (at default quantization settings, more like three-quarters...)
+ * so we should ensure that this case is fast. On many machines,
+ * a comparison is enough cheaper than a divide to make a special test
+ * a win. Since both inputs will be nonnegative, we need only test
+ * for a < b to discover whether a/b is 0.
+ * If your machine's division is fast enough, define FAST_DIVIDE.
+ */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a,b) a /= b
+#else
+#define DIVIDE_BY(a,b) if (a >= b) a /= b; else a = 0
+#endif
+ if (temp < 0) {
+ temp = -temp;
+ temp += qval>>1; /* for rounding */
+ DIVIDE_BY(temp, qval);
+ temp = -temp;
+ } else {
+ temp += qval>>1; /* for rounding */
+ DIVIDE_BY(temp, qval);
+ }
+ output_ptr[i] = (JCOEF) temp;
+ }
+ }
+ }
+}
+
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF(void)
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+ /* This routine is heavily used, so it's worth coding it tightly. */
+ my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+ float_DCT_method_ptr do_dct = fdct->do_float_dct;
+ FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
+ FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+ JDIMENSION bi;
+
+ sample_data += start_row; /* fold in the vertical offset once */
+
+ for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+ /* Load data into workspace, applying unsigned->signed conversion */
+ { register FAST_FLOAT *workspaceptr;
+ register JSAMPROW elemptr;
+ register int elemr;
+
+ workspaceptr = workspace;
+ for (elemr = 0; elemr < DCTSIZE; elemr++) {
+ elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8 /* unroll the inner loop */
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ *workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+#else
+ { register int elemc;
+ for (elemc = DCTSIZE; elemc > 0; elemc--) {
+ *workspaceptr++ = (FAST_FLOAT)
+ (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+ }
+ }
+#endif
+ }
+ }
+
+ /* Perform the DCT */
+ (*do_dct) (workspace);
+
+ /* Quantize/descale the coefficients, and store into coef_blocks[] */
+ { register FAST_FLOAT temp;
+ register int i;
+ register JCOEFPTR output_ptr = coef_blocks[bi];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ /* Apply the quantization and scaling factor */
+ temp = workspace[i] * divisors[i];
+ /* Round to nearest integer.
+ * Since C does not specify the direction of rounding for negative
+ * quotients, we have to force the dividend positive for portability.
+ * The maximum coefficient size is +-16K (for 12-bit data), so this
+ * code should work for either 16-bit or 32-bit ints.
+ */
+ output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+ }
+ }
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL(void)
+jinit_forward_dct (j_compress_ptr cinfo)
+{
+ my_fdct_ptr fdct;
+ int i;
+
+ fdct = (my_fdct_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_fdct_controller));
+ cinfo->fdct = (struct jpeg_forward_dct *) fdct;
+ fdct->pub.start_pass = start_pass_fdctmgr;
+
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ fdct->pub.forward_DCT = forward_DCT;
+ fdct->do_dct = jpeg_fdct_islow;
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ fdct->pub.forward_DCT = forward_DCT;
+ fdct->do_dct = jpeg_fdct_ifast;
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ fdct->pub.forward_DCT = forward_DCT_float;
+ fdct->do_float_dct = jpeg_fdct_float;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+
+ /* Mark divisor tables unallocated */
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+ fdct->float_divisors[i] = NULL;
+#endif
+ }
+}
--- /dev/null
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU. To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h" /* Declarations shared with jcphuff.c */
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ INT32 put_buffer; /* current bit-accumulation buffer */
+ int put_bits; /* # of bits now in it */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).put_buffer = (src).put_buffer, \
+ (dest).put_bits = (src).put_bits, \
+ (dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_encoder pub; /* public fields */
+
+ savable_state saved; /* Bit buffer & DC state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+ int next_restart_num; /* next restart number to write (0-7) */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+ c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED /* Statistics tables for optimization */
+ long * dc_count_ptrs[NUM_HUFF_TBLS];
+ long * ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder * huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+ savable_state cur; /* Current bit buffer & DC state */
+ j_compress_ptr cinfo; /* dump_buffer needs access to this */
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo));
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF(void)
+start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, dctbl, actbl;
+ jpeg_component_info * compptr;
+
+ if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+ entropy->pub.encode_mcu = encode_mcu_gather;
+ entropy->pub.finish_pass = finish_pass_gather;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ entropy->pub.encode_mcu = encode_mcu_huff;
+ entropy->pub.finish_pass = finish_pass_huff;
+ }
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+ /* Check for invalid table indexes */
+ /* (make_c_derived_tbl does this in the other path) */
+ if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+ if (actbl < 0 || actbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+ /* Allocate and zero the statistics tables */
+ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+ if (entropy->dc_count_ptrs[dctbl] == NULL)
+ entropy->dc_count_ptrs[dctbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
+ if (entropy->ac_count_ptrs[actbl] == NULL)
+ entropy->ac_count_ptrs[actbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
+#endif
+ } else {
+ /* Compute derived values for Huffman tables */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_c_derived_tbl(cinfo, TRUE, dctbl,
+ & entropy->dc_derived_tbls[dctbl]);
+ jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
+ & entropy->ac_derived_tbls[actbl]);
+ }
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Initialize bit buffer to empty */
+ entropy->saved.put_buffer = 0;
+ entropy->saved.put_bits = 0;
+
+ /* Initialize restart stuff */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
+ c_derived_tbl ** pdtbl)
+{
+ JHUFF_TBL *htbl;
+ c_derived_tbl *dtbl;
+ int p, i, l, lastp, si, maxsymbol;
+ char huffsize[257];
+ unsigned int huffcode[257];
+ unsigned int code;
+
+ /* Note that huffsize[] and huffcode[] are filled in code-length order,
+ * paralleling the order of the symbols themselves in htbl->huffval[].
+ */
+
+ /* Find the input Huffman table */
+ if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+ htbl =
+ isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+ /* Allocate a workspace if we haven't already done so. */
+ if (*pdtbl == NULL)
+ *pdtbl = (c_derived_tbl *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(c_derived_tbl));
+ dtbl = *pdtbl;
+
+ /* Figure C.1: make table of Huffman code length for each symbol */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ i = (int) htbl->bits[l];
+ if (i < 0 || p + i > 256) /* protect against table overrun */
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ while (i--)
+ huffsize[p++] = (char) l;
+ }
+ huffsize[p] = 0;
+ lastp = p;
+
+ /* Figure C.2: generate the codes themselves */
+ /* We also validate that the counts represent a legal Huffman code tree. */
+
+ code = 0;
+ si = huffsize[0];
+ p = 0;
+ while (huffsize[p]) {
+ while (((int) huffsize[p]) == si) {
+ huffcode[p++] = code;
+ code++;
+ }
+ /* code is now 1 more than the last code used for codelength si; but
+ * it must still fit in si bits, since no code is allowed to be all ones.
+ */
+ if (((INT32) code) >= (((INT32) 1) << si))
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ code <<= 1;
+ si++;
+ }
+
+ /* Figure C.3: generate encoding tables */
+ /* These are code and size indexed by symbol value */
+
+ /* Set all codeless symbols to have code length 0;
+ * this lets us detect duplicate VAL entries here, and later
+ * allows emit_bits to detect any attempt to emit such symbols.
+ */
+ MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
+
+ /* This is also a convenient place to check for out-of-range
+ * and duplicated VAL entries. We allow 0..255 for AC symbols
+ * but only 0..15 for DC. (We could constrain them further
+ * based on data depth and mode, but this seems enough.)
+ */
+ maxsymbol = isDC ? 15 : 255;
+
+ for (p = 0; p < lastp; p++) {
+ i = htbl->huffval[p];
+ if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ dtbl->ehufco[i] = huffcode[p];
+ dtbl->ehufsi[i] = huffsize[p];
+ }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action) \
+ { *(state)->next_output_byte++ = (JOCTET) (val); \
+ if (--(state)->free_in_buffer == 0) \
+ if (! dump_buffer(state)) \
+ { action; } }
+
+
+LOCAL(boolean)
+dump_buffer (working_state * state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+ struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+ if (! (*dest->empty_output_buffer) (state->cinfo))
+ return FALSE;
+ /* After a successful buffer dump, must reset buffer pointers */
+ state->next_output_byte = dest->next_output_byte;
+ state->free_in_buffer = dest->free_in_buffer;
+ return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part. At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(boolean)
+emit_bits (working_state * state, unsigned int code, int size)
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+{
+ /* This routine is heavily used, so it's worth coding tightly. */
+ register INT32 put_buffer = (INT32) code;
+ register int put_bits = state->cur.put_bits;
+
+ /* if size is 0, caller used an invalid Huffman table entry */
+ if (size == 0)
+ ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
+
+ put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+
+ put_bits += size; /* new number of bits in buffer */
+
+ put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+ put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+
+ while (put_bits >= 8) {
+ int c = (int) ((put_buffer >> 16) & 0xFF);
+
+ emit_byte(state, c, return FALSE);
+ if (c == 0xFF) { /* need to stuff a zero byte? */
+ emit_byte(state, 0, return FALSE);
+ }
+ put_buffer <<= 8;
+ put_bits -= 8;
+ }
+
+ state->cur.put_buffer = put_buffer; /* update state variables */
+ state->cur.put_bits = put_bits;
+
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+flush_bits (working_state * state)
+{
+ if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
+ return FALSE;
+ state->cur.put_buffer = 0; /* and reset bit-buffer to empty */
+ state->cur.put_bits = 0;
+ return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL(boolean)
+encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
+ c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+ register int temp, temp2;
+ register int nbits;
+ register int k, r, i;
+
+ /* Encode the DC coefficient difference per section F.1.2.1 */
+
+ temp = temp2 = block[0] - last_dc_val;
+
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* For a negative input, want temp2 = bitwise complement of abs(input) */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+
+ /* Emit the Huffman-coded symbol for the number of bits */
+ if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+ return FALSE;
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (nbits) /* emit_bits rejects calls with size 0 */
+ if (! emit_bits(state, (unsigned int) temp2, nbits))
+ return FALSE;
+
+ /* Encode the AC coefficients per section F.1.2.2 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = 1; k < DCTSIZE2; k++) {
+ if ((temp = block[jpeg_natural_order[k]]) == 0) {
+ r++;
+ } else {
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+ return FALSE;
+ r -= 16;
+ }
+
+ temp2 = temp;
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(state->cinfo, JERR_BAD_DCT_COEF);
+
+ /* Emit Huffman symbol for run length / number of bits */
+ i = (r << 4) + nbits;
+ if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
+ return FALSE;
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (! emit_bits(state, (unsigned int) temp2, nbits))
+ return FALSE;
+
+ r = 0;
+ }
+ }
+
+ /* If the last coef(s) were zero, emit an end-of-block code */
+ if (r > 0)
+ if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0]))
+ return FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(boolean)
+emit_restart (working_state * state, int restart_num)
+{
+ int ci;
+
+ if (! flush_bits(state))
+ return FALSE;
+
+ emit_byte(state, 0xFF, return FALSE);
+ emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+ state->cur.last_dc_val[ci] = 0;
+
+ /* The restart counter is not updated until we successfully write the MCU. */
+
+ return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF(boolean)
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ working_state state;
+ int blkn, ci;
+ jpeg_component_info * compptr;
+
+ /* Load up working state */
+ state.next_output_byte = cinfo->dest->next_output_byte;
+ state.free_in_buffer = cinfo->dest->free_in_buffer;
+ ASSIGN_STATE(state.cur, entropy->saved);
+ state.cinfo = cinfo;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! emit_restart(&state, entropy->next_restart_num))
+ return FALSE;
+ }
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ if (! encode_one_block(&state,
+ MCU_data[blkn][0], state.cur.last_dc_val[ci],
+ entropy->dc_derived_tbls[compptr->dc_tbl_no],
+ entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+ return FALSE;
+ /* Update last_dc_val */
+ state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+ }
+
+ /* Completed MCU, so update state */
+ cinfo->dest->next_output_byte = state.next_output_byte;
+ cinfo->dest->free_in_buffer = state.free_in_buffer;
+ ASSIGN_STATE(entropy->saved, state.cur);
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+finish_pass_huff (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ working_state state;
+
+ /* Load up working state ... flush_bits needs it */
+ state.next_output_byte = cinfo->dest->next_output_byte;
+ state.free_in_buffer = cinfo->dest->free_in_buffer;
+ ASSIGN_STATE(state.cur, entropy->saved);
+ state.cinfo = cinfo;
+
+ /* Flush out the last data */
+ if (! flush_bits(&state))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+ /* Update state */
+ cinfo->dest->next_output_byte = state.next_output_byte;
+ cinfo->dest->free_in_buffer = state.free_in_buffer;
+ ASSIGN_STATE(entropy->saved, state.cur);
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * We first scan the supplied data and count the number of uses of each symbol
+ * that is to be Huffman-coded. (This process MUST agree with the code above.)
+ * Then we build a Huffman coding tree for the observed counts.
+ * Symbols which are not needed at all for the particular image are not
+ * assigned any code, which saves space in the DHT marker as well as in
+ * the compressed data.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL(void)
+htest_one_block (j_compress_ptr cinfo, JCOEFPTR block, int last_dc_val,
+ long dc_counts[], long ac_counts[])
+{
+ register int temp;
+ register int nbits;
+ register int k, r;
+
+ /* Encode the DC coefficient difference per section F.1.2.1 */
+
+ temp = block[0] - last_dc_val;
+ if (temp < 0)
+ temp = -temp;
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count the Huffman symbol for the number of bits */
+ dc_counts[nbits]++;
+
+ /* Encode the AC coefficients per section F.1.2.2 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = 1; k < DCTSIZE2; k++) {
+ if ((temp = block[jpeg_natural_order[k]]) == 0) {
+ r++;
+ } else {
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ ac_counts[0xF0]++;
+ r -= 16;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ if (temp < 0)
+ temp = -temp;
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count Huffman symbol for run length / number of bits */
+ ac_counts[(r << 4) + nbits]++;
+
+ r = 0;
+ }
+ }
+
+ /* If the last coef(s) were zero, emit an end-of-block code */
+ if (r > 0)
+ ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF(boolean)
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int blkn, ci;
+ jpeg_component_info * compptr;
+
+ /* Take care of restart intervals if needed */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+ /* Update restart state */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ htest_one_block(cinfo, MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+ entropy->dc_count_ptrs[compptr->dc_tbl_no],
+ entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+ entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Generate the best Huffman code table for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ *
+ * The JPEG standard requires that no symbol be assigned a codeword of all
+ * one bits (so that padding bits added at the end of a compressed segment
+ * can't look like a valid code). Because of the canonical ordering of
+ * codewords, this just means that there must be an unused slot in the
+ * longest codeword length category. Section K.2 of the JPEG spec suggests
+ * reserving such a slot by pretending that symbol 256 is a valid symbol
+ * with count 1. In theory that's not optimal; giving it count zero but
+ * including it in the symbol set anyway should give a better Huffman code.
+ * But the theoretically better code actually seems to come out worse in
+ * practice, because it produces more all-ones bytes (which incur stuffed
+ * zero bytes in the final file). In any case the difference is tiny.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction. We currently use
+ * the adjustment method suggested in JPEG section K.2. This method is *not*
+ * optimal; it may not choose the best possible limited-length code. But
+ * typically only very-low-frequency symbols will be given less-than-optimal
+ * lengths, so the code is almost optimal. Experimental comparisons against
+ * an optimal limited-length-code algorithm indicate that the difference is
+ * microscopic --- usually less than a hundredth of a percent of total size.
+ * So the extra complexity of an optimal algorithm doesn't seem worthwhile.
+ */
+
+GLOBAL(void)
+jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
+{
+#define MAX_CLEN 32 /* assumed maximum initial code length */
+ UINT8 bits[MAX_CLEN+1]; /* bits[k] = # of symbols with code length k */
+ int codesize[257]; /* codesize[k] = code length of symbol k */
+ int others[257]; /* next symbol in current branch of tree */
+ int c1, c2;
+ int p, i, j;
+ long v;
+
+ /* This algorithm is explained in section K.2 of the JPEG standard */
+
+ MEMZERO(bits, SIZEOF(bits));
+ MEMZERO(codesize, SIZEOF(codesize));
+ for (i = 0; i < 257; i++)
+ others[i] = -1; /* init links to empty */
+
+ freq[256] = 1; /* make sure 256 has a nonzero count */
+ /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+ * that no real symbol is given code-value of all ones, because 256
+ * will be placed last in the largest codeword category.
+ */
+
+ /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+ for (;;) {
+ /* Find the smallest nonzero frequency, set c1 = its symbol */
+ /* In case of ties, take the larger symbol number */
+ c1 = -1;
+ v = 1000000000L;
+ for (i = 0; i <= 256; i++) {
+ if (freq[i] && freq[i] <= v) {
+ v = freq[i];
+ c1 = i;
+ }
+ }
+
+ /* Find the next smallest nonzero frequency, set c2 = its symbol */
+ /* In case of ties, take the larger symbol number */
+ c2 = -1;
+ v = 1000000000L;
+ for (i = 0; i <= 256; i++) {
+ if (freq[i] && freq[i] <= v && i != c1) {
+ v = freq[i];
+ c2 = i;
+ }
+ }
+
+ /* Done if we've merged everything into one frequency */
+ if (c2 < 0)
+ break;
+
+ /* Else merge the two counts/trees */
+ freq[c1] += freq[c2];
+ freq[c2] = 0;
+
+ /* Increment the codesize of everything in c1's tree branch */
+ codesize[c1]++;
+ while (others[c1] >= 0) {
+ c1 = others[c1];
+ codesize[c1]++;
+ }
+
+ others[c1] = c2; /* chain c2 onto c1's tree branch */
+
+ /* Increment the codesize of everything in c2's tree branch */
+ codesize[c2]++;
+ while (others[c2] >= 0) {
+ c2 = others[c2];
+ codesize[c2]++;
+ }
+ }
+
+ /* Now count the number of symbols of each code length */
+ for (i = 0; i <= 256; i++) {
+ if (codesize[i]) {
+ /* The JPEG standard seems to think that this can't happen, */
+ /* but I'm paranoid... */
+ if (codesize[i] > MAX_CLEN)
+ ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+ bits[codesize[i]]++;
+ }
+ }
+
+ /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+ * Huffman procedure assigned any such lengths, we must adjust the coding.
+ * Here is what the JPEG spec says about how this next bit works:
+ * Since symbols are paired for the longest Huffman code, the symbols are
+ * removed from this length category two at a time. The prefix for the pair
+ * (which is one bit shorter) is allocated to one of the pair; then,
+ * skipping the BITS entry for that prefix length, a code word from the next
+ * shortest nonzero BITS entry is converted into a prefix for two code words
+ * one bit longer.
+ */
+
+ for (i = MAX_CLEN; i > 16; i--) {
+ while (bits[i] > 0) {
+ j = i - 2; /* find length of new prefix to be used */
+ while (bits[j] == 0)
+ j--;
+
+ bits[i] -= 2; /* remove two symbols */
+ bits[i-1]++; /* one goes in this length */
+ bits[j+1] += 2; /* two new symbols in this length */
+ bits[j]--; /* symbol of this length is now a prefix */
+ }
+ }
+
+ /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+ while (bits[i] == 0) /* find largest codelength still in use */
+ i--;
+ bits[i]--;
+
+ /* Return final symbol counts (only for lengths 0..16) */
+ MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
+
+ /* Return a list of the symbols sorted by code length */
+ /* It's not real clear to me why we don't need to consider the codelength
+ * changes made above, but the JPEG spec seems to think this works.
+ */
+ p = 0;
+ for (i = 1; i <= MAX_CLEN; i++) {
+ for (j = 0; j <= 255; j++) {
+ if (codesize[j] == i) {
+ htbl->huffval[p] = (UINT8) j;
+ p++;
+ }
+ }
+ }
+
+ /* Set sent_table FALSE so updated table will be written to JPEG file. */
+ htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, dctbl, actbl;
+ jpeg_component_info * compptr;
+ JHUFF_TBL **htblptr;
+ boolean did_dc[NUM_HUFF_TBLS];
+ boolean did_ac[NUM_HUFF_TBLS];
+
+ /* It's important not to apply jpeg_gen_optimal_table more than once
+ * per table, because it clobbers the input frequency counts!
+ */
+ MEMZERO(did_dc, SIZEOF(did_dc));
+ MEMZERO(did_ac, SIZEOF(did_ac));
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ if (! did_dc[dctbl]) {
+ htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+ did_dc[dctbl] = TRUE;
+ }
+ if (! did_ac[actbl]) {
+ htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+ did_ac[actbl] = TRUE;
+ }
+ }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_huff_encoder (j_compress_ptr cinfo)
+{
+ huff_entropy_ptr entropy;
+ int i;
+
+ entropy = (huff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(huff_entropy_encoder));
+ cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+ entropy->pub.start_pass = start_pass_huff;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+ entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+ }
+}
--- /dev/null
+/*
+ * jchuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c). No other modules need to see these.
+ */
+
+/* The legal range of a DCT coefficient is
+ * -1024 .. +1023 for 8-bit data;
+ * -16384 .. +16383 for 12-bit data.
+ * Hence the magnitude should always fit in 10 or 14 bits respectively.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MAX_COEF_BITS 10
+#else
+#define MAX_COEF_BITS 14
+#endif
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+ unsigned int ehufco[256]; /* code for each symbol */
+ char ehufsi[256]; /* length of code for each symbol */
+ /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_c_derived_tbl jMkCDerived
+#define jpeg_gen_optimal_table jGenOptTbl
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_c_derived_tbl
+ JPP((j_compress_ptr cinfo, boolean isDC, int tblno,
+ c_derived_tbl ** pdtbl));
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN(void) jpeg_gen_optimal_table
+ JPP((j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[]));
--- /dev/null
+/*
+ * jcinit.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c. It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image. We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL(void)
+jinit_compress_master (j_compress_ptr cinfo)
+{
+ /* Initialize master control (includes parameter checking/processing) */
+ jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+ /* Preprocessing */
+ if (! cinfo->raw_data_in) {
+ jinit_color_converter(cinfo);
+ jinit_downsampler(cinfo);
+ jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+ }
+ /* Forward DCT */
+ jinit_forward_dct(cinfo);
+ /* Entropy encoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ jinit_phuff_encoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_encoder(cinfo);
+ }
+
+ /* Need a full-image coefficient buffer in any multi-pass mode. */
+ jinit_c_coef_controller(cinfo,
+ (boolean) (cinfo->num_scans > 1 || cinfo->optimize_coding));
+ jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+ jinit_marker_writer(cinfo);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Write the datastream header (SOI) immediately.
+ * Frame and scan headers are postponed till later.
+ * This lets application insert special markers after the SOI.
+ */
+ (*cinfo->marker->write_file_header) (cinfo);
+}
--- /dev/null
+/*
+ * jcmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Note: currently, there is no operating mode in which a full-image buffer
+ * is needed at this step. If there were, that mode could not be used with
+ * "raw data" input, since this module is bypassed in that case. However,
+ * we've left the code here for possible use in special applications.
+ */
+#undef FULL_MAIN_BUFFER_SUPPORTED
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_main_controller pub; /* public fields */
+
+ JDIMENSION cur_iMCU_row; /* number of current iMCU row */
+ JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */
+ boolean suspended; /* remember if we suspended output */
+ J_BUF_MODE pass_mode; /* current operating mode */
+
+ /* If using just a strip buffer, this points to the entire set of buffers
+ * (we allocate one for each component). In the full-image case, this
+ * points to the currently accessible strips of the virtual arrays.
+ */
+ JSAMPARRAY buffer[MAX_COMPONENTS];
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ /* If using full-image storage, this array holds pointers to virtual-array
+ * control blocks for each component. Unused if not full-image storage.
+ */
+ jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
+#endif
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+ JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+METHODDEF(void) process_data_buffer_main
+ JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ /* Do nothing in raw-data mode. */
+ if (cinfo->raw_data_in)
+ return;
+
+ main->cur_iMCU_row = 0; /* initialize counters */
+ main->rowgroup_ctr = 0;
+ main->suspended = FALSE;
+ main->pass_mode = pass_mode; /* save mode for use by process_data */
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ if (main->whole_image[0] != NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ main->pub.process_data = process_data_simple_main;
+ break;
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ case JBUF_SAVE_SOURCE:
+ case JBUF_CRANK_DEST:
+ case JBUF_SAVE_AND_PASS:
+ if (main->whole_image[0] == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ main->pub.process_data = process_data_buffer_main;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+ /* Read input data if we haven't filled the main buffer yet */
+ if (main->rowgroup_ctr < DCTSIZE)
+ (*cinfo->prep->pre_process_data) (cinfo,
+ input_buf, in_row_ctr, in_rows_avail,
+ main->buffer, &main->rowgroup_ctr,
+ (JDIMENSION) DCTSIZE);
+
+ /* If we don't have a full iMCU row buffered, return to application for
+ * more data. Note that preprocessor will always pad to fill the iMCU row
+ * at the bottom of the image.
+ */
+ if (main->rowgroup_ctr != DCTSIZE)
+ return;
+
+ /* Send the completed row to the compressor */
+ if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+ /* If compressor did not consume the whole row, then we must need to
+ * suspend processing and return to the application. In this situation
+ * we pretend we didn't yet consume the last input row; otherwise, if
+ * it happened to be the last row of the image, the application would
+ * think we were done.
+ */
+ if (! main->suspended) {
+ (*in_row_ctr)--;
+ main->suspended = TRUE;
+ }
+ return;
+ }
+ /* We did finish the row. Undo our little suspension hack if a previous
+ * call suspended; then mark the main buffer empty.
+ */
+ if (main->suspended) {
+ (*in_row_ctr)++;
+ main->suspended = FALSE;
+ }
+ main->rowgroup_ctr = 0;
+ main->cur_iMCU_row++;
+ }
+}
+
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+
+/*
+ * Process some data.
+ * This routine handles all of the modes that use a full-size buffer.
+ */
+
+METHODDEF(void)
+process_data_buffer_main (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci;
+ jpeg_component_info *compptr;
+ boolean writing = (main->pass_mode != JBUF_CRANK_DEST);
+
+ while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+ /* Realign the virtual buffers if at the start of an iMCU row. */
+ if (main->rowgroup_ctr == 0) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, main->whole_image[ci],
+ main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+ }
+ /* In a read pass, pretend we just read some source data. */
+ if (! writing) {
+ *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+ main->rowgroup_ctr = DCTSIZE;
+ }
+ }
+
+ /* If a write pass, read input data until the current iMCU row is full. */
+ /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
+ if (writing) {
+ (*cinfo->prep->pre_process_data) (cinfo,
+ input_buf, in_row_ctr, in_rows_avail,
+ main->buffer, &main->rowgroup_ctr,
+ (JDIMENSION) DCTSIZE);
+ /* Return to application if we need more data to fill the iMCU row. */
+ if (main->rowgroup_ctr < DCTSIZE)
+ return;
+ }
+
+ /* Emit data, unless this is a sink-only pass. */
+ if (main->pass_mode != JBUF_SAVE_SOURCE) {
+ if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+ /* If compressor did not consume the whole row, then we must need to
+ * suspend processing and return to the application. In this situation
+ * we pretend we didn't yet consume the last input row; otherwise, if
+ * it happened to be the last row of the image, the application would
+ * think we were done.
+ */
+ if (! main->suspended) {
+ (*in_row_ctr)--;
+ main->suspended = TRUE;
+ }
+ return;
+ }
+ /* We did finish the row. Undo our little suspension hack if a previous
+ * call suspended; then mark the main buffer empty.
+ */
+ if (main->suspended) {
+ (*in_row_ctr)++;
+ main->suspended = FALSE;
+ }
+ }
+
+ /* If get here, we are done with this iMCU row. Mark buffer empty. */
+ main->rowgroup_ctr = 0;
+ main->cur_iMCU_row++;
+ }
+}
+
+#endif /* FULL_MAIN_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_main_ptr main;
+ int ci;
+ jpeg_component_info *compptr;
+
+ main = (my_main_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_main_controller));
+ cinfo->main = (struct jpeg_c_main_controller *) main;
+ main->pub.start_pass = start_pass_main;
+
+ /* We don't need to create a buffer in raw-data mode. */
+ if (cinfo->raw_data_in)
+ return;
+
+ /* Create the buffer. It holds downsampled data, so each component
+ * may be of a different size.
+ */
+ if (need_full_buffer) {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ /* Allocate a full-image virtual array for each component */
+ /* Note we pad the bottom to a multiple of the iMCU height */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ compptr->width_in_blocks * DCTSIZE,
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor) * DCTSIZE,
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+ }
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+ } else {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+ main->whole_image[0] = NULL; /* flag for no virtual arrays */
+#endif
+ /* Allocate a strip buffer for each component */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ main->buffer[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ compptr->width_in_blocks * DCTSIZE,
+ (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+ }
+ }
+}
--- /dev/null
+/*
+ * jcmarker.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum { /* JPEG marker codes */
+ M_SOF0 = 0xc0,
+ M_SOF1 = 0xc1,
+ M_SOF2 = 0xc2,
+ M_SOF3 = 0xc3,
+
+ M_SOF5 = 0xc5,
+ M_SOF6 = 0xc6,
+ M_SOF7 = 0xc7,
+
+ M_JPG = 0xc8,
+ M_SOF9 = 0xc9,
+ M_SOF10 = 0xca,
+ M_SOF11 = 0xcb,
+
+ M_SOF13 = 0xcd,
+ M_SOF14 = 0xce,
+ M_SOF15 = 0xcf,
+
+ M_DHT = 0xc4,
+
+ M_DAC = 0xcc,
+
+ M_RST0 = 0xd0,
+ M_RST1 = 0xd1,
+ M_RST2 = 0xd2,
+ M_RST3 = 0xd3,
+ M_RST4 = 0xd4,
+ M_RST5 = 0xd5,
+ M_RST6 = 0xd6,
+ M_RST7 = 0xd7,
+
+ M_SOI = 0xd8,
+ M_EOI = 0xd9,
+ M_SOS = 0xda,
+ M_DQT = 0xdb,
+ M_DNL = 0xdc,
+ M_DRI = 0xdd,
+ M_DHP = 0xde,
+ M_EXP = 0xdf,
+
+ M_APP0 = 0xe0,
+ M_APP1 = 0xe1,
+ M_APP2 = 0xe2,
+ M_APP3 = 0xe3,
+ M_APP4 = 0xe4,
+ M_APP5 = 0xe5,
+ M_APP6 = 0xe6,
+ M_APP7 = 0xe7,
+ M_APP8 = 0xe8,
+ M_APP9 = 0xe9,
+ M_APP10 = 0xea,
+ M_APP11 = 0xeb,
+ M_APP12 = 0xec,
+ M_APP13 = 0xed,
+ M_APP14 = 0xee,
+ M_APP15 = 0xef,
+
+ M_JPG0 = 0xf0,
+ M_JPG13 = 0xfd,
+ M_COM = 0xfe,
+
+ M_TEM = 0x01,
+
+ M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_marker_writer pub; /* public fields */
+
+ unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
+} my_marker_writer;
+
+typedef my_marker_writer * my_marker_ptr;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress. Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL(void)
+emit_byte (j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+ struct jpeg_destination_mgr * dest = cinfo->dest;
+
+ *(dest->next_output_byte)++ = (JOCTET) val;
+ if (--dest->free_in_buffer == 0) {
+ if (! (*dest->empty_output_buffer) (cinfo))
+ ERREXIT(cinfo, JERR_CANT_SUSPEND);
+ }
+}
+
+
+LOCAL(void)
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+ emit_byte(cinfo, 0xFF);
+ emit_byte(cinfo, (int) mark);
+}
+
+
+LOCAL(void)
+emit_2bytes (j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+ emit_byte(cinfo, (value >> 8) & 0xFF);
+ emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL(int)
+emit_dqt (j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+ JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
+ int prec;
+ int i;
+
+ if (qtbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+ prec = 0;
+ for (i = 0; i < DCTSIZE2; i++) {
+ if (qtbl->quantval[i] > 255)
+ prec = 1;
+ }
+
+ if (! qtbl->sent_table) {
+ emit_marker(cinfo, M_DQT);
+
+ emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+ emit_byte(cinfo, index + (prec<<4));
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ /* The table entries must be emitted in zigzag order. */
+ unsigned int qval = qtbl->quantval[jpeg_natural_order[i]];
+ if (prec)
+ emit_byte(cinfo, (int) (qval >> 8));
+ emit_byte(cinfo, (int) (qval & 0xFF));
+ }
+
+ qtbl->sent_table = TRUE;
+ }
+
+ return prec;
+}
+
+
+LOCAL(void)
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+ JHUFF_TBL * htbl;
+ int length, i;
+
+ if (is_ac) {
+ htbl = cinfo->ac_huff_tbl_ptrs[index];
+ index += 0x10; /* output index has AC bit set */
+ } else {
+ htbl = cinfo->dc_huff_tbl_ptrs[index];
+ }
+
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+
+ if (! htbl->sent_table) {
+ emit_marker(cinfo, M_DHT);
+
+ length = 0;
+ for (i = 1; i <= 16; i++)
+ length += htbl->bits[i];
+
+ emit_2bytes(cinfo, length + 2 + 1 + 16);
+ emit_byte(cinfo, index);
+
+ for (i = 1; i <= 16; i++)
+ emit_byte(cinfo, htbl->bits[i]);
+
+ for (i = 0; i < length; i++)
+ emit_byte(cinfo, htbl->huffval[i]);
+
+ htbl->sent_table = TRUE;
+ }
+}
+
+
+LOCAL(void)
+emit_dac (j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker. Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+ char dc_in_use[NUM_ARITH_TBLS];
+ char ac_in_use[NUM_ARITH_TBLS];
+ int length, i;
+ jpeg_component_info *compptr;
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++)
+ dc_in_use[i] = ac_in_use[i] = 0;
+
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ dc_in_use[compptr->dc_tbl_no] = 1;
+ ac_in_use[compptr->ac_tbl_no] = 1;
+ }
+
+ length = 0;
+ for (i = 0; i < NUM_ARITH_TBLS; i++)
+ length += dc_in_use[i] + ac_in_use[i];
+
+ emit_marker(cinfo, M_DAC);
+
+ emit_2bytes(cinfo, length*2 + 2);
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ if (dc_in_use[i]) {
+ emit_byte(cinfo, i);
+ emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+ }
+ if (ac_in_use[i]) {
+ emit_byte(cinfo, i + 0x10);
+ emit_byte(cinfo, cinfo->arith_ac_K[i]);
+ }
+ }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL(void)
+emit_dri (j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+ emit_marker(cinfo, M_DRI);
+
+ emit_2bytes(cinfo, 4); /* fixed length */
+
+ emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL(void)
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+ int ci;
+ jpeg_component_info *compptr;
+
+ emit_marker(cinfo, code);
+
+ emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+ /* Make sure image isn't bigger than SOF field can handle */
+ if ((long) cinfo->image_height > 65535L ||
+ (long) cinfo->image_width > 65535L)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
+
+ emit_byte(cinfo, cinfo->data_precision);
+ emit_2bytes(cinfo, (int) cinfo->image_height);
+ emit_2bytes(cinfo, (int) cinfo->image_width);
+
+ emit_byte(cinfo, cinfo->num_components);
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ emit_byte(cinfo, compptr->component_id);
+ emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+ emit_byte(cinfo, compptr->quant_tbl_no);
+ }
+}
+
+
+LOCAL(void)
+emit_sos (j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+ int i, td, ta;
+ jpeg_component_info *compptr;
+
+ emit_marker(cinfo, M_SOS);
+
+ emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+
+ emit_byte(cinfo, cinfo->comps_in_scan);
+
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ emit_byte(cinfo, compptr->component_id);
+ td = compptr->dc_tbl_no;
+ ta = compptr->ac_tbl_no;
+ if (cinfo->progressive_mode) {
+ /* Progressive mode: only DC or only AC tables are used in one scan;
+ * furthermore, Huffman coding of DC refinement uses no table at all.
+ * We emit 0 for unused field(s); this is recommended by the P&M text
+ * but does not seem to be specified in the standard.
+ */
+ if (cinfo->Ss == 0) {
+ ta = 0; /* DC scan */
+ if (cinfo->Ah != 0 && !cinfo->arith_code)
+ td = 0; /* no DC table either */
+ } else {
+ td = 0; /* AC scan */
+ }
+ }
+ emit_byte(cinfo, (td << 4) + ta);
+ }
+
+ emit_byte(cinfo, cinfo->Ss);
+ emit_byte(cinfo, cinfo->Se);
+ emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL(void)
+emit_jfif_app0 (j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+ /*
+ * Length of APP0 block (2 bytes)
+ * Block ID (4 bytes - ASCII "JFIF")
+ * Zero byte (1 byte to terminate the ID string)
+ * Version Major, Minor (2 bytes - major first)
+ * Units (1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+ * Xdpu (2 bytes - dots per unit horizontal)
+ * Ydpu (2 bytes - dots per unit vertical)
+ * Thumbnail X size (1 byte)
+ * Thumbnail Y size (1 byte)
+ */
+
+ emit_marker(cinfo, M_APP0);
+
+ emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+ emit_byte(cinfo, 0x4A); /* Identifier: ASCII "JFIF" */
+ emit_byte(cinfo, 0x46);
+ emit_byte(cinfo, 0x49);
+ emit_byte(cinfo, 0x46);
+ emit_byte(cinfo, 0);
+ emit_byte(cinfo, cinfo->JFIF_major_version); /* Version fields */
+ emit_byte(cinfo, cinfo->JFIF_minor_version);
+ emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+ emit_2bytes(cinfo, (int) cinfo->X_density);
+ emit_2bytes(cinfo, (int) cinfo->Y_density);
+ emit_byte(cinfo, 0); /* No thumbnail image */
+ emit_byte(cinfo, 0);
+}
+
+
+LOCAL(void)
+emit_adobe_app14 (j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+ /*
+ * Length of APP14 block (2 bytes)
+ * Block ID (5 bytes - ASCII "Adobe")
+ * Version Number (2 bytes - currently 100)
+ * Flags0 (2 bytes - currently 0)
+ * Flags1 (2 bytes - currently 0)
+ * Color transform (1 byte)
+ *
+ * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+ * now in circulation seem to use Version = 100, so that's what we write.
+ *
+ * We write the color transform byte as 1 if the JPEG color space is
+ * YCbCr, 2 if it's YCCK, 0 otherwise. Adobe's definition has to do with
+ * whether the encoder performed a transformation, which is pretty useless.
+ */
+
+ emit_marker(cinfo, M_APP14);
+
+ emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+ emit_byte(cinfo, 0x41); /* Identifier: ASCII "Adobe" */
+ emit_byte(cinfo, 0x64);
+ emit_byte(cinfo, 0x6F);
+ emit_byte(cinfo, 0x62);
+ emit_byte(cinfo, 0x65);
+ emit_2bytes(cinfo, 100); /* Version */
+ emit_2bytes(cinfo, 0); /* Flags0 */
+ emit_2bytes(cinfo, 0); /* Flags1 */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_YCbCr:
+ emit_byte(cinfo, 1); /* Color transform = 1 */
+ break;
+ case JCS_YCCK:
+ emit_byte(cinfo, 2); /* Color transform = 2 */
+ break;
+ default:
+ emit_byte(cinfo, 0); /* Color transform = 0 */
+ break;
+ }
+}
+
+
+/*
+ * These routines allow writing an arbitrary marker with parameters.
+ * The only intended use is to emit COM or APPn markers after calling
+ * write_file_header and before calling write_frame_header.
+ * Other uses are not guaranteed to produce desirable results.
+ * Counting the parameter bytes properly is the caller's responsibility.
+ */
+
+METHODDEF(void)
+write_marker_header (j_compress_ptr cinfo, int marker, unsigned int datalen)
+/* Emit an arbitrary marker header */
+{
+ if (datalen > (unsigned int) 65533) /* safety check */
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ emit_marker(cinfo, (JPEG_MARKER) marker);
+
+ emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */
+}
+
+METHODDEF(void)
+write_marker_byte (j_compress_ptr cinfo, int val)
+/* Emit one byte of marker parameters following write_marker_header */
+{
+ emit_byte(cinfo, val);
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data. The JFIF marker should NOT
+ * be used for any other JPEG colorspace. The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF(void)
+write_file_header (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ emit_marker(cinfo, M_SOI); /* first the SOI */
+
+ /* SOI is defined to reset restart interval to 0 */
+ marker->last_restart_interval = 0;
+
+ if (cinfo->write_JFIF_header) /* next an optional JFIF APP0 */
+ emit_jfif_app0(cinfo);
+ if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+ emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF(void)
+write_frame_header (j_compress_ptr cinfo)
+{
+ int ci, prec;
+ boolean is_baseline;
+ jpeg_component_info *compptr;
+
+ /* Emit DQT for each quantization table.
+ * Note that emit_dqt() suppresses any duplicate tables.
+ */
+ prec = 0;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+ }
+ /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+ /* Check for a non-baseline specification.
+ * Note we assume that Huffman table numbers won't be changed later.
+ */
+ if (cinfo->arith_code || cinfo->progressive_mode ||
+ cinfo->data_precision != 8) {
+ is_baseline = FALSE;
+ } else {
+ is_baseline = TRUE;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+ is_baseline = FALSE;
+ }
+ if (prec && is_baseline) {
+ is_baseline = FALSE;
+ /* If it's baseline except for quantizer size, warn the user */
+ TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+ }
+ }
+
+ /* Emit the proper SOF marker */
+ if (cinfo->arith_code) {
+ emit_sof(cinfo, M_SOF9); /* SOF code for arithmetic coding */
+ } else {
+ if (cinfo->progressive_mode)
+ emit_sof(cinfo, M_SOF2); /* SOF code for progressive Huffman */
+ else if (is_baseline)
+ emit_sof(cinfo, M_SOF0); /* SOF code for baseline implementation */
+ else
+ emit_sof(cinfo, M_SOF1); /* SOF code for non-baseline Huffman file */
+ }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF(void)
+write_scan_header (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ int i;
+ jpeg_component_info *compptr;
+
+ if (cinfo->arith_code) {
+ /* Emit arith conditioning info. We may have some duplication
+ * if the file has multiple scans, but it's so small it's hardly
+ * worth worrying about.
+ */
+ emit_dac(cinfo);
+ } else {
+ /* Emit Huffman tables.
+ * Note that emit_dht() suppresses any duplicate tables.
+ */
+ for (i = 0; i < cinfo->comps_in_scan; i++) {
+ compptr = cinfo->cur_comp_info[i];
+ if (cinfo->progressive_mode) {
+ /* Progressive mode: only DC or only AC tables are used in one scan */
+ if (cinfo->Ss == 0) {
+ if (cinfo->Ah == 0) /* DC needs no table for refinement scan */
+ emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+ } else {
+ emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+ }
+ } else {
+ /* Sequential mode: need both DC and AC tables */
+ emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+ emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+ }
+ }
+ }
+
+ /* Emit DRI if required --- note that DRI value could change for each scan.
+ * We avoid wasting space with unnecessary DRIs, however.
+ */
+ if (cinfo->restart_interval != marker->last_restart_interval) {
+ emit_dri(cinfo);
+ marker->last_restart_interval = cinfo->restart_interval;
+ }
+
+ emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF(void)
+write_file_trailer (j_compress_ptr cinfo)
+{
+ emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted. Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF(void)
+write_tables_only (j_compress_ptr cinfo)
+{
+ int i;
+
+ emit_marker(cinfo, M_SOI);
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++) {
+ if (cinfo->quant_tbl_ptrs[i] != NULL)
+ (void) emit_dqt(cinfo, i);
+ }
+
+ if (! cinfo->arith_code) {
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+ emit_dht(cinfo, i, FALSE);
+ if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+ emit_dht(cinfo, i, TRUE);
+ }
+ }
+
+ emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL(void)
+jinit_marker_writer (j_compress_ptr cinfo)
+{
+ my_marker_ptr marker;
+
+ /* Create the subobject */
+ marker = (my_marker_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_marker_writer));
+ cinfo->marker = (struct jpeg_marker_writer *) marker;
+ /* Initialize method pointers */
+ marker->pub.write_file_header = write_file_header;
+ marker->pub.write_frame_header = write_frame_header;
+ marker->pub.write_scan_header = write_scan_header;
+ marker->pub.write_file_trailer = write_file_trailer;
+ marker->pub.write_tables_only = write_tables_only;
+ marker->pub.write_marker_header = write_marker_header;
+ marker->pub.write_marker_byte = write_marker_byte;
+ /* Initialize private state */
+ marker->last_restart_interval = 0;
+}
--- /dev/null
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work
+ * to be done in each pass).
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef enum {
+ main_pass, /* input data, also do first output step */
+ huff_opt_pass, /* Huffman code optimization pass */
+ output_pass /* data output pass */
+} c_pass_type;
+
+typedef struct {
+ struct jpeg_comp_master pub; /* public fields */
+
+ c_pass_type pass_type; /* the type of the current pass */
+
+ int pass_number; /* # of passes completed */
+ int total_passes; /* total # of passes needed */
+
+ int scan_number; /* current index in scan_info[] */
+} my_comp_master;
+
+typedef my_comp_master * my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+LOCAL(void)
+initial_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+ int ci;
+ jpeg_component_info *compptr;
+ long samplesperrow;
+ JDIMENSION jd_samplesperrow;
+
+ /* Sanity check on image dimensions */
+ if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+ || cinfo->num_components <= 0 || cinfo->input_components <= 0)
+ ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+ /* Make sure image isn't bigger than I can handle */
+ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+ (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+ /* Width of an input scanline must be representable as JDIMENSION. */
+ samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+ jd_samplesperrow = (JDIMENSION) samplesperrow;
+ if ((long) jd_samplesperrow != samplesperrow)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+ /* For now, precision must match compiled-in value... */
+ if (cinfo->data_precision != BITS_IN_JSAMPLE)
+ ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+ /* Check that number of components won't exceed internal array sizes */
+ if (cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+
+ /* Compute maximum sampling factors; check factor validity */
+ cinfo->max_h_samp_factor = 1;
+ cinfo->max_v_samp_factor = 1;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+ compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+ ERREXIT(cinfo, JERR_BAD_SAMPLING);
+ cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+ compptr->h_samp_factor);
+ cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+ compptr->v_samp_factor);
+ }
+
+ /* Compute dimensions of components */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Fill in the correct component_index value; don't rely on application */
+ compptr->component_index = ci;
+ /* For compression, we never do DCT scaling. */
+ compptr->DCT_scaled_size = DCTSIZE;
+ /* Size in DCT blocks */
+ compptr->width_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->height_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ /* Size in samples */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) cinfo->max_h_samp_factor);
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) cinfo->max_v_samp_factor);
+ /* Mark component needed (this flag isn't actually used for compression) */
+ compptr->component_needed = TRUE;
+ }
+
+ /* Compute number of fully interleaved MCU rows (number of times that
+ * main controller will call coefficient controller).
+ */
+ cinfo->total_iMCU_rows = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL(void)
+validate_script (j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+ const jpeg_scan_info * scanptr;
+ int scanno, ncomps, ci, coefi, thisi;
+ int Ss, Se, Ah, Al;
+ boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+ int * last_bitpos_ptr;
+ int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+ /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+ if (cinfo->num_scans <= 0)
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+ /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+ * for progressive JPEG, no scan can have this.
+ */
+ scanptr = cinfo->scan_info;
+ if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ cinfo->progressive_mode = TRUE;
+ last_bitpos_ptr = & last_bitpos[0][0];
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ for (coefi = 0; coefi < DCTSIZE2; coefi++)
+ *last_bitpos_ptr++ = -1;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ cinfo->progressive_mode = FALSE;
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ component_sent[ci] = FALSE;
+ }
+
+ for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+ /* Validate component indexes */
+ ncomps = scanptr->comps_in_scan;
+ if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+ for (ci = 0; ci < ncomps; ci++) {
+ thisi = scanptr->component_index[ci];
+ if (thisi < 0 || thisi >= cinfo->num_components)
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ /* Components must appear in SOF order within each scan */
+ if (ci > 0 && thisi <= scanptr->component_index[ci-1])
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ }
+ /* Validate progression parameters */
+ Ss = scanptr->Ss;
+ Se = scanptr->Se;
+ Ah = scanptr->Ah;
+ Al = scanptr->Al;
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ /* The JPEG spec simply gives the ranges 0..13 for Ah and Al, but that
+ * seems wrong: the upper bound ought to depend on data precision.
+ * Perhaps they really meant 0..N+1 for N-bit precision.
+ * Here we allow 0..10 for 8-bit data; Al larger than 10 results in
+ * out-of-range reconstructed DC values during the first DC scan,
+ * which might cause problems for some decoders.
+ */
+#if BITS_IN_JSAMPLE == 8
+#define MAX_AH_AL 10
+#else
+#define MAX_AH_AL 13
+#endif
+ if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+ Ah < 0 || Ah > MAX_AH_AL || Al < 0 || Al > MAX_AH_AL)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ if (Ss == 0) {
+ if (Se != 0) /* DC and AC together not OK */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ } else {
+ if (ncomps != 1) /* AC scans must be for only one component */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ }
+ for (ci = 0; ci < ncomps; ci++) {
+ last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
+ if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ for (coefi = Ss; coefi <= Se; coefi++) {
+ if (last_bitpos_ptr[coefi] < 0) {
+ /* first scan of this coefficient */
+ if (Ah != 0)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ } else {
+ /* not first scan */
+ if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ }
+ last_bitpos_ptr[coefi] = Al;
+ }
+ }
+#endif
+ } else {
+ /* For sequential JPEG, all progression parameters must be these: */
+ if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
+ ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+ /* Make sure components are not sent twice */
+ for (ci = 0; ci < ncomps; ci++) {
+ thisi = scanptr->component_index[ci];
+ if (component_sent[thisi])
+ ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+ component_sent[thisi] = TRUE;
+ }
+ }
+ }
+
+ /* Now verify that everything got sent. */
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ /* For progressive mode, we only check that at least some DC data
+ * got sent for each component; the spec does not require that all bits
+ * of all coefficients be transmitted. Would it be wiser to enforce
+ * transmission of all coefficient bits??
+ */
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ if (last_bitpos[ci][0] < 0)
+ ERREXIT(cinfo, JERR_MISSING_DATA);
+ }
+#endif
+ } else {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ if (! component_sent[ci])
+ ERREXIT(cinfo, JERR_MISSING_DATA);
+ }
+ }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL(void)
+select_scan_parameters (j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+ int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+ if (cinfo->scan_info != NULL) {
+ /* Prepare for current scan --- the script is already validated */
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+ const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number;
+
+ cinfo->comps_in_scan = scanptr->comps_in_scan;
+ for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+ cinfo->cur_comp_info[ci] =
+ &cinfo->comp_info[scanptr->component_index[ci]];
+ }
+ cinfo->Ss = scanptr->Ss;
+ cinfo->Se = scanptr->Se;
+ cinfo->Ah = scanptr->Ah;
+ cinfo->Al = scanptr->Al;
+ }
+ else
+#endif
+ {
+ /* Prepare for single sequential-JPEG scan containing all components */
+ if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPS_IN_SCAN);
+ cinfo->comps_in_scan = cinfo->num_components;
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+ }
+ cinfo->Ss = 0;
+ cinfo->Se = DCTSIZE2-1;
+ cinfo->Ah = 0;
+ cinfo->Al = 0;
+ }
+}
+
+
+LOCAL(void)
+per_scan_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+ int ci, mcublks, tmp;
+ jpeg_component_info *compptr;
+
+ if (cinfo->comps_in_scan == 1) {
+
+ /* Noninterleaved (single-component) scan */
+ compptr = cinfo->cur_comp_info[0];
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = compptr->width_in_blocks;
+ cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+ /* For noninterleaved scan, always one block per MCU */
+ compptr->MCU_width = 1;
+ compptr->MCU_height = 1;
+ compptr->MCU_blocks = 1;
+ compptr->MCU_sample_width = DCTSIZE;
+ compptr->last_col_width = 1;
+ /* For noninterleaved scans, it is convenient to define last_row_height
+ * as the number of block rows present in the last iMCU row.
+ */
+ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (tmp == 0) tmp = compptr->v_samp_factor;
+ compptr->last_row_height = tmp;
+
+ /* Prepare array describing MCU composition */
+ cinfo->blocks_in_MCU = 1;
+ cinfo->MCU_membership[0] = 0;
+
+ } else {
+
+ /* Interleaved (multi-component) scan */
+ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+ MAX_COMPS_IN_SCAN);
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width,
+ (long) (cinfo->max_h_samp_factor*DCTSIZE));
+ cinfo->MCU_rows_in_scan = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ cinfo->blocks_in_MCU = 0;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Sampling factors give # of blocks of component in each MCU */
+ compptr->MCU_width = compptr->h_samp_factor;
+ compptr->MCU_height = compptr->v_samp_factor;
+ compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+ compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+ /* Figure number of non-dummy blocks in last MCU column & row */
+ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+ if (tmp == 0) tmp = compptr->MCU_width;
+ compptr->last_col_width = tmp;
+ tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+ if (tmp == 0) tmp = compptr->MCU_height;
+ compptr->last_row_height = tmp;
+ /* Prepare array describing MCU composition */
+ mcublks = compptr->MCU_blocks;
+ if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+ ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+ while (mcublks-- > 0) {
+ cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+ }
+ }
+
+ }
+
+ /* Convert restart specified in rows to actual MCU count. */
+ /* Note that count must fit in 16 bits, so we provide limiting. */
+ if (cinfo->restart_in_rows > 0) {
+ long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+ cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
+ }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass. We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF(void)
+prepare_for_pass (j_compress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ switch (master->pass_type) {
+ case main_pass:
+ /* Initial pass: will collect input data, and do either Huffman
+ * optimization or data output for the first scan.
+ */
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ if (! cinfo->raw_data_in) {
+ (*cinfo->cconvert->start_pass) (cinfo);
+ (*cinfo->downsample->start_pass) (cinfo);
+ (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+ }
+ (*cinfo->fdct->start_pass) (cinfo);
+ (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+ (*cinfo->coef->start_pass) (cinfo,
+ (master->total_passes > 1 ?
+ JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+ (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+ if (cinfo->optimize_coding) {
+ /* No immediate data output; postpone writing frame/scan headers */
+ master->pub.call_pass_startup = FALSE;
+ } else {
+ /* Will write frame/scan headers at first jpeg_write_scanlines call */
+ master->pub.call_pass_startup = TRUE;
+ }
+ break;
+#ifdef ENTROPY_OPT_SUPPORTED
+ case huff_opt_pass:
+ /* Do Huffman optimization for a scan after the first one. */
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+ (*cinfo->entropy->start_pass) (cinfo, TRUE);
+ (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+ master->pub.call_pass_startup = FALSE;
+ break;
+ }
+ /* Special case: Huffman DC refinement scans need no Huffman table
+ * and therefore we can skip the optimization pass for them.
+ */
+ master->pass_type = output_pass;
+ master->pass_number++;
+ /*FALLTHROUGH*/
+#endif
+ case output_pass:
+ /* Do a data-output pass. */
+ /* We need not repeat per-scan setup if prior optimization pass did it. */
+ if (! cinfo->optimize_coding) {
+ select_scan_parameters(cinfo);
+ per_scan_setup(cinfo);
+ }
+ (*cinfo->entropy->start_pass) (cinfo, FALSE);
+ (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+ /* We emit frame/scan headers now */
+ if (master->scan_number == 0)
+ (*cinfo->marker->write_frame_header) (cinfo);
+ (*cinfo->marker->write_scan_header) (cinfo);
+ master->pub.call_pass_startup = FALSE;
+ break;
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ }
+
+ master->pub.is_last_pass = (master->pass_number == master->total_passes-1);
+
+ /* Set up progress monitor's pass info if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->completed_passes = master->pass_number;
+ cinfo->progress->total_passes = master->total_passes;
+ }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF(void)
+pass_startup (j_compress_ptr cinfo)
+{
+ cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+ (*cinfo->marker->write_frame_header) (cinfo);
+ (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF(void)
+finish_pass_master (j_compress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ /* The entropy coder always needs an end-of-pass call,
+ * either to analyze statistics or to flush its output buffer.
+ */
+ (*cinfo->entropy->finish_pass) (cinfo);
+
+ /* Update state for next pass */
+ switch (master->pass_type) {
+ case main_pass:
+ /* next pass is either output of scan 0 (after optimization)
+ * or output of scan 1 (if no optimization).
+ */
+ master->pass_type = output_pass;
+ if (! cinfo->optimize_coding)
+ master->scan_number++;
+ break;
+ case huff_opt_pass:
+ /* next pass is always output of current scan */
+ master->pass_type = output_pass;
+ break;
+ case output_pass:
+ /* next pass is either optimization or output of next scan */
+ if (cinfo->optimize_coding)
+ master->pass_type = huff_opt_pass;
+ master->scan_number++;
+ break;
+ }
+
+ master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL(void)
+jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
+{
+ my_master_ptr master;
+
+ master = (my_master_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_comp_master));
+ cinfo->master = (struct jpeg_comp_master *) master;
+ master->pub.prepare_for_pass = prepare_for_pass;
+ master->pub.pass_startup = pass_startup;
+ master->pub.finish_pass = finish_pass_master;
+ master->pub.is_last_pass = FALSE;
+
+ /* Validate parameters, determine derived values */
+ initial_setup(cinfo);
+
+ if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+ validate_script(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ cinfo->progressive_mode = FALSE;
+ cinfo->num_scans = 1;
+ }
+
+ if (cinfo->progressive_mode) /* TEMPORARY HACK ??? */
+ cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+ /* Initialize my private state */
+ if (transcode_only) {
+ /* no main pass in transcoding */
+ if (cinfo->optimize_coding)
+ master->pass_type = huff_opt_pass;
+ else
+ master->pass_type = output_pass;
+ } else {
+ /* for normal compression, first pass is always this type: */
+ master->pass_type = main_pass;
+ }
+ master->scan_number = 0;
+ master->pass_number = 0;
+ if (cinfo->optimize_coding)
+ master->total_passes = cinfo->num_scans * 2;
+ else
+ master->total_passes = cinfo->num_scans;
+}
--- /dev/null
+/*
+ * jcomapi.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Abort processing of a JPEG compression or decompression operation,
+ * but don't destroy the object itself.
+ *
+ * For this, we merely clean up all the nonpermanent memory pools.
+ * Note that temp files (virtual arrays) are not allowed to belong to
+ * the permanent pool, so we will be able to close all temp files here.
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_abort (j_common_ptr cinfo)
+{
+ int pool;
+
+ /* Do nothing if called on a not-initialized or destroyed JPEG object. */
+ if (cinfo->mem == NULL)
+ return;
+
+ /* Releasing pools in reverse order might help avoid fragmentation
+ * with some (brain-damaged) malloc libraries.
+ */
+ for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
+ (*cinfo->mem->free_pool) (cinfo, pool);
+ }
+
+ /* Reset overall state for possible reuse of object */
+ if (cinfo->is_decompressor) {
+ cinfo->global_state = DSTATE_START;
+ /* Try to keep application from accessing now-deleted marker list.
+ * A bit kludgy to do it here, but this is the most central place.
+ */
+ ((j_decompress_ptr) cinfo)->marker_list = NULL;
+ } else {
+ cinfo->global_state = CSTATE_START;
+ }
+}
+
+
+/*
+ * Destruction of a JPEG object.
+ *
+ * Everything gets deallocated except the master jpeg_compress_struct itself
+ * and the error manager struct. Both of these are supplied by the application
+ * and must be freed, if necessary, by the application. (Often they are on
+ * the stack and so don't need to be freed anyway.)
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL(void)
+jpeg_destroy (j_common_ptr cinfo)
+{
+ /* We need only tell the memory manager to release everything. */
+ /* NB: mem pointer is NULL if memory mgr failed to initialize. */
+ if (cinfo->mem != NULL)
+ (*cinfo->mem->self_destruct) (cinfo);
+ cinfo->mem = NULL; /* be safe if jpeg_destroy is called twice */
+ cinfo->global_state = 0; /* mark it destroyed */
+}
+
+
+/*
+ * Convenience routines for allocating quantization and Huffman tables.
+ * (Would jutils.c be a more reasonable place to put these?)
+ */
+
+GLOBAL(JQUANT_TBL *)
+jpeg_alloc_quant_table (j_common_ptr cinfo)
+{
+ JQUANT_TBL *tbl;
+
+ tbl = (JQUANT_TBL *)
+ (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
+ tbl->sent_table = FALSE; /* make sure this is false in any new table */
+ return tbl;
+}
+
+
+GLOBAL(JHUFF_TBL *)
+jpeg_alloc_huff_table (j_common_ptr cinfo)
+{
+ JHUFF_TBL *tbl;
+
+ tbl = (JHUFF_TBL *)
+ (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
+ tbl->sent_table = FALSE; /* make sure this is false in any new table */
+ return tbl;
+}
--- /dev/null
+/* jconfig.vc --- jconfig.h for Microsoft Visual C++ on Windows 95 or NT. */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#undef CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS /* we presume a 32-bit flat memory model */
+#undef NEED_SHORT_EXTERNAL_NAMES
+#undef INCOMPLETE_TYPES_BROKEN
+
+/* Define "boolean" as unsigned char, not int, per Windows custom */
+#ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */
+typedef unsigned char boolean;
+#endif
+#define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */
+
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED /* BMP image file format */
+#define GIF_SUPPORTED /* GIF image file format */
+#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED /* Utah RLE image file format */
+#define TARGA_SUPPORTED /* Targa image file format */
+
+#define TWO_FILE_COMMANDLINE /* optional */
+#define USE_SETMODE /* Microsoft has setmode() */
+#undef NEED_SIGNAL_CATCHER
+#undef DONT_USE_B_MODE
+#undef PROGRESS_REPORT /* optional */
+
+#endif /* JPEG_CJPEG_DJPEG */
--- /dev/null
+/*
+ * jcparam.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL(void)
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+ const unsigned int *basic_table,
+ int scale_factor, boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+ JQUANT_TBL ** qtblptr;
+ int i;
+ long temp;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (which_tbl < 0 || which_tbl >= NUM_QUANT_TBLS)
+ ERREXIT1(cinfo, JERR_DQT_INDEX, which_tbl);
+
+ qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+
+ if (*qtblptr == NULL)
+ *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+ /* limit the values to the valid range */
+ if (temp <= 0L) temp = 1L;
+ if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+ if (force_baseline && temp > 255L)
+ temp = 255L; /* limit to baseline range if requested */
+ (*qtblptr)->quantval[i] = (UINT16) temp;
+ }
+
+ /* Initialize sent_table FALSE so table will be written to JPEG file. */
+ (*qtblptr)->sent_table = FALSE;
+}
+
+
+GLOBAL(void)
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+ boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale. In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+ /* These are the sample quantization tables given in JPEG spec section K.1.
+ * The spec says that the values given produce "good" quality, and
+ * when divided by 2, "very good" quality.
+ */
+ static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+ 16, 11, 10, 16, 24, 40, 51, 61,
+ 12, 12, 14, 19, 26, 58, 60, 55,
+ 14, 13, 16, 24, 40, 57, 69, 56,
+ 14, 17, 22, 29, 51, 87, 80, 62,
+ 18, 22, 37, 56, 68, 109, 103, 77,
+ 24, 35, 55, 64, 81, 104, 113, 92,
+ 49, 64, 78, 87, 103, 121, 120, 101,
+ 72, 92, 95, 98, 112, 100, 103, 99
+ };
+ static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+ 17, 18, 24, 47, 99, 99, 99, 99,
+ 18, 21, 26, 66, 99, 99, 99, 99,
+ 24, 26, 56, 99, 99, 99, 99, 99,
+ 47, 66, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99,
+ 99, 99, 99, 99, 99, 99, 99, 99
+ };
+
+ /* Set up two quantization tables using the specified scaling */
+ jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+ scale_factor, force_baseline);
+ jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+ scale_factor, force_baseline);
+}
+
+
+GLOBAL(int)
+jpeg_quality_scaling (int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+ /* Safety limit on quality factor. Convert 0 to 1 to avoid zero divide. */
+ if (quality <= 0) quality = 1;
+ if (quality > 100) quality = 100;
+
+ /* The basic table is used as-is (scaling 100) for a quality of 50.
+ * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+ * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
+ * to make all the table entries 1 (hence, minimum quantization loss).
+ * Qualities 1..50 are converted to scaling percentage 5000/Q.
+ */
+ if (quality < 50)
+ quality = 5000 / quality;
+ else
+ quality = 200 - quality*2;
+
+ return quality;
+}
+
+
+GLOBAL(void)
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+ /* Convert user 0-100 rating to percentage scaling */
+ quality = jpeg_quality_scaling(quality);
+
+ /* Set up standard quality tables */
+ jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL(void)
+add_huff_table (j_compress_ptr cinfo,
+ JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
+{
+ int nsymbols, len;
+
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+
+ /* Copy the number-of-symbols-of-each-code-length counts */
+ MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+
+ /* Validate the counts. We do this here mainly so we can copy the right
+ * number of symbols from the val[] array, without risking marching off
+ * the end of memory. jchuff.c will do a more thorough test later.
+ */
+ nsymbols = 0;
+ for (len = 1; len <= 16; len++)
+ nsymbols += bits[len];
+ if (nsymbols < 1 || nsymbols > 256)
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+ MEMCOPY((*htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));
+
+ /* Initialize sent_table FALSE so table will be written to JPEG file. */
+ (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL(void)
+std_huff_tables (j_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+ static const UINT8 bits_dc_luminance[17] =
+ { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+ static const UINT8 val_dc_luminance[] =
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+
+ static const UINT8 bits_dc_chrominance[17] =
+ { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+ static const UINT8 val_dc_chrominance[] =
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+
+ static const UINT8 bits_ac_luminance[17] =
+ { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+ static const UINT8 val_ac_luminance[] =
+ { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+ 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+ 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+ 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+ 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+ 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+ 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+ 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+ 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+ 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+ 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+ 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+ 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+ 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+ 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+ 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+ 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+ 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+ 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+ 0xf9, 0xfa };
+
+ static const UINT8 bits_ac_chrominance[17] =
+ { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+ static const UINT8 val_ac_chrominance[] =
+ { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+ 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+ 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+ 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+ 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+ 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+ 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+ 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+ 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+ 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+ 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+ 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+ 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+ 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+ 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+ 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+ 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+ 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+ 0xf9, 0xfa };
+
+ add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+ bits_dc_luminance, val_dc_luminance);
+ add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+ bits_ac_luminance, val_ac_luminance);
+ add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+ bits_dc_chrominance, val_dc_chrominance);
+ add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+ bits_ac_chrominance, val_ac_chrominance);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters. Alternately, you can call this
+ * to establish defaults and then alter parameters selectively. This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL(void)
+jpeg_set_defaults (j_compress_ptr cinfo)
+{
+ int i;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* Allocate comp_info array large enough for maximum component count.
+ * Array is made permanent in case application wants to compress
+ * multiple images at same param settings.
+ */
+ if (cinfo->comp_info == NULL)
+ cinfo->comp_info = (jpeg_component_info *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ MAX_COMPONENTS * SIZEOF(jpeg_component_info));
+
+ /* Initialize everything not dependent on the color space */
+
+ cinfo->data_precision = BITS_IN_JSAMPLE;
+ /* Set up two quantization tables using default quality of 75 */
+ jpeg_set_quality(cinfo, 75, TRUE);
+ /* Set up two Huffman tables */
+ std_huff_tables(cinfo);
+
+ /* Initialize default arithmetic coding conditioning */
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ cinfo->arith_dc_L[i] = 0;
+ cinfo->arith_dc_U[i] = 1;
+ cinfo->arith_ac_K[i] = 5;
+ }
+
+ /* Default is no multiple-scan output */
+ cinfo->scan_info = NULL;
+ cinfo->num_scans = 0;
+
+ /* Expect normal source image, not raw downsampled data */
+ cinfo->raw_data_in = FALSE;
+
+ /* Use Huffman coding, not arithmetic coding, by default */
+ cinfo->arith_code = FALSE;
+
+ /* By default, don't do extra passes to optimize entropy coding */
+ cinfo->optimize_coding = FALSE;
+ /* The standard Huffman tables are only valid for 8-bit data precision.
+ * If the precision is higher, force optimization on so that usable
+ * tables will be computed. This test can be removed if default tables
+ * are supplied that are valid for the desired precision.
+ */
+ if (cinfo->data_precision > 8)
+ cinfo->optimize_coding = TRUE;
+
+ /* By default, use the simpler non-cosited sampling alignment */
+ cinfo->CCIR601_sampling = FALSE;
+
+ /* No input smoothing */
+ cinfo->smoothing_factor = 0;
+
+ /* DCT algorithm preference */
+ cinfo->dct_method = JDCT_DEFAULT;
+
+ /* No restart markers */
+ cinfo->restart_interval = 0;
+ cinfo->restart_in_rows = 0;
+
+ /* Fill in default JFIF marker parameters. Note that whether the marker
+ * will actually be written is determined by jpeg_set_colorspace.
+ *
+ * By default, the library emits JFIF version code 1.01.
+ * An application that wants to emit JFIF 1.02 extension markers should set
+ * JFIF_minor_version to 2. We could probably get away with just defaulting
+ * to 1.02, but there may still be some decoders in use that will complain
+ * about that; saying 1.01 should minimize compatibility problems.
+ */
+ cinfo->JFIF_major_version = 1; /* Default JFIF version = 1.01 */
+ cinfo->JFIF_minor_version = 1;
+ cinfo->density_unit = 0; /* Pixel size is unknown by default */
+ cinfo->X_density = 1; /* Pixel aspect ratio is square by default */
+ cinfo->Y_density = 1;
+
+ /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+ jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL(void)
+jpeg_default_colorspace (j_compress_ptr cinfo)
+{
+ switch (cinfo->in_color_space) {
+ case JCS_GRAYSCALE:
+ jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+ break;
+ case JCS_RGB:
+ jpeg_set_colorspace(cinfo, JCS_YCbCr);
+ break;
+ case JCS_YCbCr:
+ jpeg_set_colorspace(cinfo, JCS_YCbCr);
+ break;
+ case JCS_CMYK:
+ jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+ break;
+ case JCS_YCCK:
+ jpeg_set_colorspace(cinfo, JCS_YCCK);
+ break;
+ case JCS_UNKNOWN:
+ jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+ break;
+ default:
+ ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+ }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL(void)
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+ jpeg_component_info * compptr;
+ int ci;
+
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl) \
+ (compptr = &cinfo->comp_info[index], \
+ compptr->component_id = (id), \
+ compptr->h_samp_factor = (hsamp), \
+ compptr->v_samp_factor = (vsamp), \
+ compptr->quant_tbl_no = (quant), \
+ compptr->dc_tbl_no = (dctbl), \
+ compptr->ac_tbl_no = (actbl) )
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+ * tables 1 for chrominance components.
+ */
+
+ cinfo->jpeg_color_space = colorspace;
+
+ cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+ cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+ switch (colorspace) {
+ case JCS_GRAYSCALE:
+ cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+ cinfo->num_components = 1;
+ /* JFIF specifies component ID 1 */
+ SET_COMP(0, 1, 1,1, 0, 0,0);
+ break;
+ case JCS_RGB:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+ cinfo->num_components = 3;
+ SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+ SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+ SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
+ break;
+ case JCS_YCbCr:
+ cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+ cinfo->num_components = 3;
+ /* JFIF specifies component IDs 1,2,3 */
+ /* We default to 2x2 subsamples of chrominance */
+ SET_COMP(0, 1, 2,2, 0, 0,0);
+ SET_COMP(1, 2, 1,1, 1, 1,1);
+ SET_COMP(2, 3, 1,1, 1, 1,1);
+ break;
+ case JCS_CMYK:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+ cinfo->num_components = 4;
+ SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+ SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+ SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+ SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
+ break;
+ case JCS_YCCK:
+ cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+ cinfo->num_components = 4;
+ SET_COMP(0, 1, 2,2, 0, 0,0);
+ SET_COMP(1, 2, 1,1, 1, 1,1);
+ SET_COMP(2, 3, 1,1, 1, 1,1);
+ SET_COMP(3, 4, 2,2, 0, 0,0);
+ break;
+ case JCS_UNKNOWN:
+ cinfo->num_components = cinfo->input_components;
+ if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ SET_COMP(ci, ci, 1,1, 0, 0,0);
+ }
+ break;
+ default:
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL(jpeg_scan_info *)
+fill_a_scan (jpeg_scan_info * scanptr, int ci,
+ int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+ scanptr->comps_in_scan = 1;
+ scanptr->component_index[0] = ci;
+ scanptr->Ss = Ss;
+ scanptr->Se = Se;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_scans (jpeg_scan_info * scanptr, int ncomps,
+ int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+ int ci;
+
+ for (ci = 0; ci < ncomps; ci++) {
+ scanptr->comps_in_scan = 1;
+ scanptr->component_index[0] = ci;
+ scanptr->Ss = Ss;
+ scanptr->Se = Se;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ }
+ return scanptr;
+}
+
+LOCAL(jpeg_scan_info *)
+fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+ int ci;
+
+ if (ncomps <= MAX_COMPS_IN_SCAN) {
+ /* Single interleaved DC scan */
+ scanptr->comps_in_scan = ncomps;
+ for (ci = 0; ci < ncomps; ci++)
+ scanptr->component_index[ci] = ci;
+ scanptr->Ss = scanptr->Se = 0;
+ scanptr->Ah = Ah;
+ scanptr->Al = Al;
+ scanptr++;
+ } else {
+ /* Noninterleaved DC scan for each component */
+ scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+ }
+ return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL(void)
+jpeg_simple_progression (j_compress_ptr cinfo)
+{
+ int ncomps = cinfo->num_components;
+ int nscans;
+ jpeg_scan_info * scanptr;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ /* Figure space needed for script. Calculation must match code below! */
+ if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+ /* Custom script for YCbCr color images. */
+ nscans = 10;
+ } else {
+ /* All-purpose script for other color spaces. */
+ if (ncomps > MAX_COMPS_IN_SCAN)
+ nscans = 6 * ncomps; /* 2 DC + 4 AC scans per component */
+ else
+ nscans = 2 + 4 * ncomps; /* 2 DC scans; 4 AC scans per component */
+ }
+
+ /* Allocate space for script.
+ * We need to put it in the permanent pool in case the application performs
+ * multiple compressions without changing the settings. To avoid a memory
+ * leak if jpeg_simple_progression is called repeatedly for the same JPEG
+ * object, we try to re-use previously allocated space, and we allocate
+ * enough space to handle YCbCr even if initially asked for grayscale.
+ */
+ if (cinfo->script_space == NULL || cinfo->script_space_size < nscans) {
+ cinfo->script_space_size = MAX(nscans, 10);
+ cinfo->script_space = (jpeg_scan_info *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ cinfo->script_space_size * SIZEOF(jpeg_scan_info));
+ }
+ scanptr = cinfo->script_space;
+ cinfo->scan_info = scanptr;
+ cinfo->num_scans = nscans;
+
+ if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+ /* Custom script for YCbCr color images. */
+ /* Initial DC scan */
+ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+ /* Initial AC scan: get some luma data out in a hurry */
+ scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+ /* Chroma data is too small to be worth expending many scans on */
+ scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+ scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+ /* Complete spectral selection for luma AC */
+ scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+ /* Refine next bit of luma AC */
+ scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+ /* Finish DC successive approximation */
+ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+ /* Finish AC successive approximation */
+ scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+ scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+ /* Luma bottom bit comes last since it's usually largest scan */
+ scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+ } else {
+ /* All-purpose script for other color spaces. */
+ /* Successive approximation first pass */
+ scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+ scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+ scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+ /* Successive approximation second pass */
+ scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+ /* Successive approximation final pass */
+ scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+ scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+ }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jcphuff.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h" /* Declarations shared with jchuff.c */
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+ struct jpeg_entropy_encoder pub; /* public fields */
+
+ /* Mode flag: TRUE for optimization, FALSE for actual data output */
+ boolean gather_statistics;
+
+ /* Bit-level coding status.
+ * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+ */
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+ INT32 put_buffer; /* current bit-accumulation buffer */
+ int put_bits; /* # of bits now in it */
+ j_compress_ptr cinfo; /* link to cinfo (needed for dump_buffer) */
+
+ /* Coding status for DC components */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+ /* Coding status for AC components */
+ int ac_tbl_no; /* the table number of the single component */
+ unsigned int EOBRUN; /* run length of EOBs */
+ unsigned int BE; /* # of buffered correction bits before MCU */
+ char * bit_buffer; /* buffer for correction bits (1 per char) */
+ /* packing correction bits tightly would save some space but cost time... */
+
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+ int next_restart_num; /* next restart number to write (0-7) */
+
+ /* Pointers to derived tables (these workspaces have image lifespan).
+ * Since any one scan codes only DC or only AC, we only need one set
+ * of tables, not one for DC and one for AC.
+ */
+ c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+ /* Statistics tables for optimization; again, one set is enough */
+ long * count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder * phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold. Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS 1000 /* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
+ * We assume that int right shift is unsigned if INT32 right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS int ishift_temp;
+#define IRIGHT_SHIFT(x,shft) \
+ ((ishift_temp = (x)) < 0 ? \
+ (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+ (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+/* Forward declarations */
+METHODDEF(boolean) encode_mcu_DC_first JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_first JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(void) finish_pass_phuff JPP((j_compress_ptr cinfo));
+METHODDEF(void) finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF(void)
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band;
+ int ci, tbl;
+ jpeg_component_info * compptr;
+
+ entropy->cinfo = cinfo;
+ entropy->gather_statistics = gather_statistics;
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* We assume jcmaster.c already validated the scan parameters. */
+
+ /* Select execution routines */
+ if (cinfo->Ah == 0) {
+ if (is_DC_band)
+ entropy->pub.encode_mcu = encode_mcu_DC_first;
+ else
+ entropy->pub.encode_mcu = encode_mcu_AC_first;
+ } else {
+ if (is_DC_band)
+ entropy->pub.encode_mcu = encode_mcu_DC_refine;
+ else {
+ entropy->pub.encode_mcu = encode_mcu_AC_refine;
+ /* AC refinement needs a correction bit buffer */
+ if (entropy->bit_buffer == NULL)
+ entropy->bit_buffer = (char *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ MAX_CORR_BITS * SIZEOF(char));
+ }
+ }
+ if (gather_statistics)
+ entropy->pub.finish_pass = finish_pass_gather_phuff;
+ else
+ entropy->pub.finish_pass = finish_pass_phuff;
+
+ /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+ * for AC coefficients.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Initialize DC predictions to 0 */
+ entropy->last_dc_val[ci] = 0;
+ /* Get table index */
+ if (is_DC_band) {
+ if (cinfo->Ah != 0) /* DC refinement needs no table */
+ continue;
+ tbl = compptr->dc_tbl_no;
+ } else {
+ entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+ }
+ if (gather_statistics) {
+ /* Check for invalid table index */
+ /* (make_c_derived_tbl does this in the other path) */
+ if (tbl < 0 || tbl >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
+ /* Allocate and zero the statistics tables */
+ /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+ if (entropy->count_ptrs[tbl] == NULL)
+ entropy->count_ptrs[tbl] = (long *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 257 * SIZEOF(long));
+ MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
+ } else {
+ /* Compute derived values for Huffman table */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_c_derived_tbl(cinfo, is_DC_band, tbl,
+ & entropy->derived_tbls[tbl]);
+ }
+ }
+
+ /* Initialize AC stuff */
+ entropy->EOBRUN = 0;
+ entropy->BE = 0;
+
+ /* Initialize bit buffer to empty */
+ entropy->put_buffer = 0;
+ entropy->put_bits = 0;
+
+ /* Initialize restart stuff */
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy,val) \
+ { *(entropy)->next_output_byte++ = (JOCTET) (val); \
+ if (--(entropy)->free_in_buffer == 0) \
+ dump_buffer(entropy); }
+
+
+LOCAL(void)
+dump_buffer (phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+ struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
+
+ if (! (*dest->empty_output_buffer) (entropy->cinfo))
+ ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+ /* After a successful buffer dump, must reset buffer pointers */
+ entropy->next_output_byte = dest->next_output_byte;
+ entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part. At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL(void)
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+ /* This routine is heavily used, so it's worth coding tightly. */
+ register INT32 put_buffer = (INT32) code;
+ register int put_bits = entropy->put_bits;
+
+ /* if size is 0, caller used an invalid Huffman table entry */
+ if (size == 0)
+ ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+ if (entropy->gather_statistics)
+ return; /* do nothing if we're only getting stats */
+
+ put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+
+ put_bits += size; /* new number of bits in buffer */
+
+ put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+ put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+ while (put_bits >= 8) {
+ int c = (int) ((put_buffer >> 16) & 0xFF);
+
+ emit_byte(entropy, c);
+ if (c == 0xFF) { /* need to stuff a zero byte? */
+ emit_byte(entropy, 0);
+ }
+ put_buffer <<= 8;
+ put_bits -= 8;
+ }
+
+ entropy->put_buffer = put_buffer; /* update variables */
+ entropy->put_bits = put_bits;
+}
+
+
+LOCAL(void)
+flush_bits (phuff_entropy_ptr entropy)
+{
+ emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+ entropy->put_buffer = 0; /* and reset bit-buffer to empty */
+ entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+INLINE
+LOCAL(void)
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+ if (entropy->gather_statistics)
+ entropy->count_ptrs[tbl_no][symbol]++;
+ else {
+ c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
+ emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+ }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL(void)
+emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
+ unsigned int nbits)
+{
+ if (entropy->gather_statistics)
+ return; /* no real work */
+
+ while (nbits > 0) {
+ emit_bits(entropy, (unsigned int) (*bufstart), 1);
+ bufstart++;
+ nbits--;
+ }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL(void)
+emit_eobrun (phuff_entropy_ptr entropy)
+{
+ register int temp, nbits;
+
+ if (entropy->EOBRUN > 0) { /* if there is any pending EOBRUN */
+ temp = entropy->EOBRUN;
+ nbits = 0;
+ while ((temp >>= 1))
+ nbits++;
+ /* safety check: shouldn't happen given limited correction-bit buffer */
+ if (nbits > 14)
+ ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+ emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+ if (nbits)
+ emit_bits(entropy, entropy->EOBRUN, nbits);
+
+ entropy->EOBRUN = 0;
+
+ /* Emit any buffered correction bits */
+ emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+ entropy->BE = 0;
+ }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL(void)
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
+{
+ int ci;
+
+ emit_eobrun(entropy);
+
+ if (! entropy->gather_statistics) {
+ flush_bits(entropy);
+ emit_byte(entropy, 0xFF);
+ emit_byte(entropy, JPEG_RST0 + restart_num);
+ }
+
+ if (entropy->cinfo->Ss == 0) {
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+ entropy->last_dc_val[ci] = 0;
+ } else {
+ /* Re-initialize all AC-related fields to 0 */
+ entropy->EOBRUN = 0;
+ entropy->BE = 0;
+ }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp, temp2;
+ register int nbits;
+ int blkn, ci;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+ jpeg_component_info * compptr;
+ ISHIFT_TEMPS
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+
+ /* Compute the DC value after the required point transform by Al.
+ * This is simply an arithmetic right shift.
+ */
+ temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
+
+ /* DC differences are figured on the point-transformed values. */
+ temp = temp2 - entropy->last_dc_val[ci];
+ entropy->last_dc_val[ci] = temp2;
+
+ /* Encode the DC coefficient difference per section G.1.2.1 */
+ temp2 = temp;
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ /* For a negative input, want temp2 = bitwise complement of abs(input) */
+ /* This code assumes we are on a two's complement machine */
+ temp2--;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 0;
+ while (temp) {
+ nbits++;
+ temp >>= 1;
+ }
+ /* Check for out-of-range coefficient values.
+ * Since we're encoding a difference, the range limit is twice as much.
+ */
+ if (nbits > MAX_COEF_BITS+1)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count/emit the Huffman-coded symbol for the number of bits */
+ emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ if (nbits) /* emit_bits rejects calls with size 0 */
+ emit_bits(entropy, (unsigned int) temp2, nbits);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp, temp2;
+ register int nbits;
+ register int r, k;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data block */
+ block = MCU_data[0];
+
+ /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+
+ r = 0; /* r = run length of zeros */
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+ r++;
+ continue;
+ }
+ /* We must apply the point transform by Al. For AC coefficients this
+ * is an integer division with rounding towards 0. To do this portably
+ * in C, we shift after obtaining the absolute value; so the code is
+ * interwoven with finding the abs value (temp) and output bits (temp2).
+ */
+ if (temp < 0) {
+ temp = -temp; /* temp is abs value of input */
+ temp >>= Al; /* apply the point transform */
+ /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+ temp2 = ~temp;
+ } else {
+ temp >>= Al; /* apply the point transform */
+ temp2 = temp;
+ }
+ /* Watch out for case that nonzero coef is zero after point transform */
+ if (temp == 0) {
+ r++;
+ continue;
+ }
+
+ /* Emit any pending EOBRUN */
+ if (entropy->EOBRUN > 0)
+ emit_eobrun(entropy);
+ /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+ while (r > 15) {
+ emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+ r -= 16;
+ }
+
+ /* Find the number of bits needed for the magnitude of the coefficient */
+ nbits = 1; /* there must be at least one 1 bit */
+ while ((temp >>= 1))
+ nbits++;
+ /* Check for out-of-range coefficient values */
+ if (nbits > MAX_COEF_BITS)
+ ERREXIT(cinfo, JERR_BAD_DCT_COEF);
+
+ /* Count/emit Huffman symbol for run length / number of bits */
+ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+ /* Emit that number of bits of the value, if positive, */
+ /* or the complement of its magnitude, if negative. */
+ emit_bits(entropy, (unsigned int) temp2, nbits);
+
+ r = 0; /* reset zero run length */
+ }
+
+ if (r > 0) { /* If there are trailing zeroes, */
+ entropy->EOBRUN++; /* count an EOB */
+ if (entropy->EOBRUN == 0x7FFF)
+ emit_eobrun(entropy); /* force it out to avoid overflow */
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp;
+ int blkn;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data blocks */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+
+ /* We simply emit the Al'th bit of the DC coefficient value. */
+ temp = (*block)[0];
+ emit_bits(entropy, (unsigned int) (temp >> Al), 1);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ register int temp;
+ register int r, k;
+ int EOB;
+ char *BR_buffer;
+ unsigned int BR;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ JBLOCKROW block;
+ int absvalues[DCTSIZE2];
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Emit restart marker if needed */
+ if (cinfo->restart_interval)
+ if (entropy->restarts_to_go == 0)
+ emit_restart(entropy, entropy->next_restart_num);
+
+ /* Encode the MCU data block */
+ block = MCU_data[0];
+
+ /* It is convenient to make a pre-pass to determine the transformed
+ * coefficients' absolute values and the EOB position.
+ */
+ EOB = 0;
+ for (k = cinfo->Ss; k <= Se; k++) {
+ temp = (*block)[jpeg_natural_order[k]];
+ /* We must apply the point transform by Al. For AC coefficients this
+ * is an integer division with rounding towards 0. To do this portably
+ * in C, we shift after obtaining the absolute value.
+ */
+ if (temp < 0)
+ temp = -temp; /* temp is abs value of input */
+ temp >>= Al; /* apply the point transform */
+ absvalues[k] = temp; /* save abs value for main pass */
+ if (temp == 1)
+ EOB = k; /* EOB = index of last newly-nonzero coef */
+ }
+
+ /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+
+ r = 0; /* r = run length of zeros */
+ BR = 0; /* BR = count of buffered bits added now */
+ BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ if ((temp = absvalues[k]) == 0) {
+ r++;
+ continue;
+ }
+
+ /* Emit any required ZRLs, but not if they can be folded into EOB */
+ while (r > 15 && k <= EOB) {
+ /* emit any pending EOBRUN and the BE correction bits */
+ emit_eobrun(entropy);
+ /* Emit ZRL */
+ emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+ r -= 16;
+ /* Emit buffered correction bits that must be associated with ZRL */
+ emit_buffered_bits(entropy, BR_buffer, BR);
+ BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+ BR = 0;
+ }
+
+ /* If the coef was previously nonzero, it only needs a correction bit.
+ * NOTE: a straight translation of the spec's figure G.7 would suggest
+ * that we also need to test r > 15. But if r > 15, we can only get here
+ * if k > EOB, which implies that this coefficient is not 1.
+ */
+ if (temp > 1) {
+ /* The correction bit is the next bit of the absolute value. */
+ BR_buffer[BR++] = (char) (temp & 1);
+ continue;
+ }
+
+ /* Emit any pending EOBRUN and the BE correction bits */
+ emit_eobrun(entropy);
+
+ /* Count/emit Huffman symbol for run length / number of bits */
+ emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+ /* Emit output bit for newly-nonzero coef */
+ temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+ emit_bits(entropy, (unsigned int) temp, 1);
+
+ /* Emit buffered correction bits that must be associated with this code */
+ emit_buffered_bits(entropy, BR_buffer, BR);
+ BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+ BR = 0;
+ r = 0; /* reset zero run length */
+ }
+
+ if (r > 0 || BR > 0) { /* If there are trailing zeroes, */
+ entropy->EOBRUN++; /* count an EOB */
+ entropy->BE += BR; /* concat my correction bits to older ones */
+ /* We force out the EOB if we risk either:
+ * 1. overflow of the EOB counter;
+ * 2. overflow of the correction bit buffer during the next MCU.
+ */
+ if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
+ emit_eobrun(entropy);
+ }
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+ /* Update restart-interval state too */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0) {
+ entropy->restarts_to_go = cinfo->restart_interval;
+ entropy->next_restart_num++;
+ entropy->next_restart_num &= 7;
+ }
+ entropy->restarts_to_go--;
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF(void)
+finish_pass_phuff (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+
+ entropy->next_output_byte = cinfo->dest->next_output_byte;
+ entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+ /* Flush out any buffered data */
+ emit_eobrun(entropy);
+ flush_bits(entropy);
+
+ cinfo->dest->next_output_byte = entropy->next_output_byte;
+ cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF(void)
+finish_pass_gather_phuff (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band;
+ int ci, tbl;
+ jpeg_component_info * compptr;
+ JHUFF_TBL **htblptr;
+ boolean did[NUM_HUFF_TBLS];
+
+ /* Flush out buffered data (all we care about is counting the EOB symbol) */
+ emit_eobrun(entropy);
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* It's important not to apply jpeg_gen_optimal_table more than once
+ * per table, because it clobbers the input frequency counts!
+ */
+ MEMZERO(did, SIZEOF(did));
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ if (is_DC_band) {
+ if (cinfo->Ah != 0) /* DC refinement needs no table */
+ continue;
+ tbl = compptr->dc_tbl_no;
+ } else {
+ tbl = compptr->ac_tbl_no;
+ }
+ if (! did[tbl]) {
+ if (is_DC_band)
+ htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+ else
+ htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+ jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+ did[tbl] = TRUE;
+ }
+ }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_encoder (j_compress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy;
+ int i;
+
+ entropy = (phuff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(phuff_entropy_encoder));
+ cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+ entropy->pub.start_pass = start_pass_phuff;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->derived_tbls[i] = NULL;
+ entropy->count_ptrs[i] = NULL;
+ }
+ entropy->bit_buffer = NULL; /* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jcprepct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler. See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures. The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step. At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels. Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row. This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_prep_controller pub; /* public fields */
+
+ /* Downsampling input buffer. This buffer holds color-converted data
+ * until we have enough to do a downsample step.
+ */
+ JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+ JDIMENSION rows_to_go; /* counts rows remaining in source image */
+ int next_buf_row; /* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED /* only needed for context case */
+ int this_row_group; /* starting row index of group to process */
+ int next_buf_stop; /* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller * my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+
+ if (pass_mode != JBUF_PASS_THRU)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ /* Initialize total-height counter for detecting bottom of image */
+ prep->rows_to_go = cinfo->image_height;
+ /* Mark the conversion buffer empty */
+ prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+ /* Preset additional state variables for context mode.
+ * These aren't used in non-context mode, so we needn't test which mode.
+ */
+ prep->this_row_group = 0;
+ /* Set next_buf_stop to stop after two row groups have been read in. */
+ prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL(void)
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+ int input_rows, int output_rows)
+{
+ register int row;
+
+ for (row = input_rows; row < output_rows; row++) {
+ jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+ 1, num_cols);
+ }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups". A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF(void)
+pre_process_data (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int numrows, ci;
+ JDIMENSION inrows;
+ jpeg_component_info * compptr;
+
+ while (*in_row_ctr < in_rows_avail &&
+ *out_row_group_ctr < out_row_groups_avail) {
+ /* Do color conversion to fill the conversion buffer. */
+ inrows = in_rows_avail - *in_row_ctr;
+ numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+ numrows = (int) MIN((JDIMENSION) numrows, inrows);
+ (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+ prep->color_buf,
+ (JDIMENSION) prep->next_buf_row,
+ numrows);
+ *in_row_ctr += numrows;
+ prep->next_buf_row += numrows;
+ prep->rows_to_go -= numrows;
+ /* If at bottom of image, pad to fill the conversion buffer. */
+ if (prep->rows_to_go == 0 &&
+ prep->next_buf_row < cinfo->max_v_samp_factor) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+ prep->next_buf_row, cinfo->max_v_samp_factor);
+ }
+ prep->next_buf_row = cinfo->max_v_samp_factor;
+ }
+ /* If we've filled the conversion buffer, empty it. */
+ if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+ (*cinfo->downsample->downsample) (cinfo,
+ prep->color_buf, (JDIMENSION) 0,
+ output_buf, *out_row_group_ctr);
+ prep->next_buf_row = 0;
+ (*out_row_group_ctr)++;
+ }
+ /* If at bottom of image, pad the output to a full iMCU height.
+ * Note we assume the caller is providing a one-iMCU-height output buffer!
+ */
+ if (prep->rows_to_go == 0 &&
+ *out_row_group_ctr < out_row_groups_avail) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ expand_bottom_edge(output_buf[ci],
+ compptr->width_in_blocks * DCTSIZE,
+ (int) (*out_row_group_ctr * compptr->v_samp_factor),
+ (int) (out_row_groups_avail * compptr->v_samp_factor));
+ }
+ *out_row_group_ctr = out_row_groups_avail;
+ break; /* can exit outer loop without test */
+ }
+ }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF(void)
+pre_process_context (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int numrows, ci;
+ int buf_height = cinfo->max_v_samp_factor * 3;
+ JDIMENSION inrows;
+
+ while (*out_row_group_ctr < out_row_groups_avail) {
+ if (*in_row_ctr < in_rows_avail) {
+ /* Do color conversion to fill the conversion buffer. */
+ inrows = in_rows_avail - *in_row_ctr;
+ numrows = prep->next_buf_stop - prep->next_buf_row;
+ numrows = (int) MIN((JDIMENSION) numrows, inrows);
+ (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+ prep->color_buf,
+ (JDIMENSION) prep->next_buf_row,
+ numrows);
+ /* Pad at top of image, if first time through */
+ if (prep->rows_to_go == cinfo->image_height) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ int row;
+ for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+ jcopy_sample_rows(prep->color_buf[ci], 0,
+ prep->color_buf[ci], -row,
+ 1, cinfo->image_width);
+ }
+ }
+ }
+ *in_row_ctr += numrows;
+ prep->next_buf_row += numrows;
+ prep->rows_to_go -= numrows;
+ } else {
+ /* Return for more data, unless we are at the bottom of the image. */
+ if (prep->rows_to_go != 0)
+ break;
+ /* When at bottom of image, pad to fill the conversion buffer. */
+ if (prep->next_buf_row < prep->next_buf_stop) {
+ for (ci = 0; ci < cinfo->num_components; ci++) {
+ expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+ prep->next_buf_row, prep->next_buf_stop);
+ }
+ prep->next_buf_row = prep->next_buf_stop;
+ }
+ }
+ /* If we've gotten enough data, downsample a row group. */
+ if (prep->next_buf_row == prep->next_buf_stop) {
+ (*cinfo->downsample->downsample) (cinfo,
+ prep->color_buf,
+ (JDIMENSION) prep->this_row_group,
+ output_buf, *out_row_group_ctr);
+ (*out_row_group_ctr)++;
+ /* Advance pointers with wraparound as necessary. */
+ prep->this_row_group += cinfo->max_v_samp_factor;
+ if (prep->this_row_group >= buf_height)
+ prep->this_row_group = 0;
+ if (prep->next_buf_row >= buf_height)
+ prep->next_buf_row = 0;
+ prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+ }
+ }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL(void)
+create_context_buffer (j_compress_ptr cinfo)
+{
+ my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+ int rgroup_height = cinfo->max_v_samp_factor;
+ int ci, i;
+ jpeg_component_info * compptr;
+ JSAMPARRAY true_buffer, fake_buffer;
+
+ /* Grab enough space for fake row pointers for all the components;
+ * we need five row groups' worth of pointers for each component.
+ */
+ fake_buffer = (JSAMPARRAY)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (cinfo->num_components * 5 * rgroup_height) *
+ SIZEOF(JSAMPROW));
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Allocate the actual buffer space (3 row groups) for this component.
+ * We make the buffer wide enough to allow the downsampler to edge-expand
+ * horizontally within the buffer, if it so chooses.
+ */
+ true_buffer = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+ cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+ (JDIMENSION) (3 * rgroup_height));
+ /* Copy true buffer row pointers into the middle of the fake row array */
+ MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+ 3 * rgroup_height * SIZEOF(JSAMPROW));
+ /* Fill in the above and below wraparound pointers */
+ for (i = 0; i < rgroup_height; i++) {
+ fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+ fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+ }
+ prep->color_buf[ci] = fake_buffer + rgroup_height;
+ fake_buffer += 5 * rgroup_height; /* point to space for next component */
+ }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+ my_prep_ptr prep;
+ int ci;
+ jpeg_component_info * compptr;
+
+ if (need_full_buffer) /* safety check */
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ prep = (my_prep_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_prep_controller));
+ cinfo->prep = (struct jpeg_c_prep_controller *) prep;
+ prep->pub.start_pass = start_pass_prep;
+
+ /* Allocate the color conversion buffer.
+ * We make the buffer wide enough to allow the downsampler to edge-expand
+ * horizontally within the buffer, if it so chooses.
+ */
+ if (cinfo->downsample->need_context_rows) {
+ /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+ prep->pub.pre_process_data = pre_process_context;
+ create_context_buffer(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ /* No context, just make it tall enough for one row group */
+ prep->pub.pre_process_data = pre_process_data;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+ cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+ (JDIMENSION) cinfo->max_v_samp_factor);
+ }
+ }
+}
--- /dev/null
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups". A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally. The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup. In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ * Digital Image Warping, George Wolberg, 1990.
+ * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel. The hi-falutin sampling literature
+ * refers to this as a "box filter". In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad. If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided. This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol). When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef JMETHOD(void, downsample1_ptr,
+ (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data));
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_downsampler pub; /* public fields */
+
+ /* Downsampling method pointers, one per component */
+ downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler * my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_downsample (j_compress_ptr cinfo)
+{
+ /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL(void)
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+ JDIMENSION input_cols, JDIMENSION output_cols)
+{
+ register JSAMPROW ptr;
+ register JSAMPLE pixval;
+ register int count;
+ int row;
+ int numcols = (int) (output_cols - input_cols);
+
+ if (numcols > 0) {
+ for (row = 0; row < num_rows; row++) {
+ ptr = image_data[row] + input_cols;
+ pixval = ptr[-1]; /* don't need GETJSAMPLE() here */
+ for (count = numcols; count > 0; count--)
+ *ptr++ = pixval;
+ }
+ }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF(void)
+sep_downsample (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+ JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+{
+ my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
+ int ci;
+ jpeg_component_info * compptr;
+ JSAMPARRAY in_ptr, out_ptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ in_ptr = input_buf[ci] + in_row_index;
+ out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+ (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF(void)
+int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+ JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ JSAMPROW inptr, outptr;
+ INT32 outvalue;
+
+ h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+ v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+ numpix = h_expand * v_expand;
+ numpix2 = numpix/2;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * h_expand);
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ for (outcol = 0, outcol_h = 0; outcol < output_cols;
+ outcol++, outcol_h += h_expand) {
+ outvalue = 0;
+ for (v = 0; v < v_expand; v++) {
+ inptr = input_data[inrow+v] + outcol_h;
+ for (h = 0; h < h_expand; h++) {
+ outvalue += (INT32) GETJSAMPLE(*inptr++);
+ }
+ }
+ *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
+ }
+ inrow += v_expand;
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ /* Copy the data */
+ jcopy_sample_rows(input_data, 0, output_data, 0,
+ cinfo->max_v_samp_factor, cinfo->image_width);
+ /* Edge-expand */
+ expand_right_edge(output_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int outrow;
+ JDIMENSION outcol;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr, outptr;
+ register int bias;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * 2);
+
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr = input_data[outrow];
+ bias = 0; /* bias = 0,1,0,1,... for successive samples */
+ for (outcol = 0; outcol < output_cols; outcol++) {
+ *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+ + bias) >> 1);
+ bias ^= 1; /* 0=>1, 1=>0 */
+ inptr += 2;
+ }
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF(void)
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow;
+ JDIMENSION outcol;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr0, inptr1, outptr;
+ register int bias;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data, cinfo->max_v_samp_factor,
+ cinfo->image_width, output_cols * 2);
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr0 = input_data[inrow];
+ inptr1 = input_data[inrow+1];
+ bias = 1; /* bias = 1,2,1,2,... for successive samples */
+ for (outcol = 0; outcol < output_cols; outcol++) {
+ *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+ + bias) >> 2);
+ bias ^= 3; /* 1=>2, 2=>1 */
+ inptr0 += 2; inptr1 += 2;
+ }
+ inrow += 2;
+ }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing. One row of context is required.
+ */
+
+METHODDEF(void)
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int inrow, outrow;
+ JDIMENSION colctr;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+ INT32 membersum, neighsum, memberscale, neighscale;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+ cinfo->image_width, output_cols * 2);
+
+ /* We don't bother to form the individual "smoothed" input pixel values;
+ * we can directly compute the output which is the average of the four
+ * smoothed values. Each of the four member pixels contributes a fraction
+ * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+ * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+ * output. The four corner-adjacent neighbor pixels contribute a fraction
+ * SF to just one smoothed pixel, or SF/4 to the final output; while the
+ * eight edge-adjacent neighbors contribute SF to each of two smoothed
+ * pixels, or SF/2 overall. In order to use integer arithmetic, these
+ * factors are scaled by 2^16 = 65536.
+ * Also recall that SF = smoothing_factor / 1024.
+ */
+
+ memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+ neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+ inrow = 0;
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr0 = input_data[inrow];
+ inptr1 = input_data[inrow+1];
+ above_ptr = input_data[inrow-1];
+ below_ptr = input_data[inrow+2];
+
+ /* Special case for first column: pretend column -1 is same as column 0 */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+ neighsum += neighsum;
+ neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+
+ for (colctr = output_cols - 2; colctr > 0; colctr--) {
+ /* sum of pixels directly mapped to this output element */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ /* sum of edge-neighbor pixels */
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+ GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+ /* The edge-neighbors count twice as much as corner-neighbors */
+ neighsum += neighsum;
+ /* Add in the corner-neighbors */
+ neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+ GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+ /* form final output scaled up by 2^16 */
+ membersum = membersum * memberscale + neighsum * neighscale;
+ /* round, descale and output it */
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+ }
+
+ /* Special case for last column */
+ membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+ neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+ GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+ GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+ neighsum += neighsum;
+ neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+ GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+ inrow += 2;
+ }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing. One row of context is required.
+ */
+
+METHODDEF(void)
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+ JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+ int outrow;
+ JDIMENSION colctr;
+ JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+ register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+ INT32 membersum, neighsum, memberscale, neighscale;
+ int colsum, lastcolsum, nextcolsum;
+
+ /* Expand input data enough to let all the output samples be generated
+ * by the standard loop. Special-casing padded output would be more
+ * efficient.
+ */
+ expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+ cinfo->image_width, output_cols);
+
+ /* Each of the eight neighbor pixels contributes a fraction SF to the
+ * smoothed pixel, while the main pixel contributes (1-8*SF). In order
+ * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+ * Also recall that SF = smoothing_factor / 1024.
+ */
+
+ memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+ neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+ for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+ outptr = output_data[outrow];
+ inptr = input_data[outrow];
+ above_ptr = input_data[outrow-1];
+ below_ptr = input_data[outrow+1];
+
+ /* Special case for first column */
+ colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+ GETJSAMPLE(*inptr);
+ membersum = GETJSAMPLE(*inptr++);
+ nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+ GETJSAMPLE(*inptr);
+ neighsum = colsum + (colsum - membersum) + nextcolsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ lastcolsum = colsum; colsum = nextcolsum;
+
+ for (colctr = output_cols - 2; colctr > 0; colctr--) {
+ membersum = GETJSAMPLE(*inptr++);
+ above_ptr++; below_ptr++;
+ nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+ GETJSAMPLE(*inptr);
+ neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+ lastcolsum = colsum; colsum = nextcolsum;
+ }
+
+ /* Special case for last column */
+ membersum = GETJSAMPLE(*inptr);
+ neighsum = lastcolsum + (colsum - membersum) + colsum;
+ membersum = membersum * memberscale + neighsum * neighscale;
+ *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+ }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL(void)
+jinit_downsampler (j_compress_ptr cinfo)
+{
+ my_downsample_ptr downsample;
+ int ci;
+ jpeg_component_info * compptr;
+ boolean smoothok = TRUE;
+
+ downsample = (my_downsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_downsampler));
+ cinfo->downsample = (struct jpeg_downsampler *) downsample;
+ downsample->pub.start_pass = start_pass_downsample;
+ downsample->pub.downsample = sep_downsample;
+ downsample->pub.need_context_rows = FALSE;
+
+ if (cinfo->CCIR601_sampling)
+ ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+ /* Verify we can handle the sampling factors, and set up method pointers */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor) {
+ downsample->methods[ci] = fullsize_smooth_downsample;
+ downsample->pub.need_context_rows = TRUE;
+ } else
+#endif
+ downsample->methods[ci] = fullsize_downsample;
+ } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+ smoothok = FALSE;
+ downsample->methods[ci] = h2v1_downsample;
+ } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+ compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor) {
+ downsample->methods[ci] = h2v2_smooth_downsample;
+ downsample->pub.need_context_rows = TRUE;
+ } else
+#endif
+ downsample->methods[ci] = h2v2_downsample;
+ } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+ (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+ smoothok = FALSE;
+ downsample->methods[ci] = int_downsample;
+ } else
+ ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+ }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+ if (cinfo->smoothing_factor && !smoothok)
+ TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}
--- /dev/null
+/*
+ * jctrans.c
+ *
+ * Copyright (C) 1995-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(void) transencode_master_selection
+ JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+LOCAL(void) transencode_coef_controller
+ JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL(void)
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
+{
+ if (cinfo->global_state != CSTATE_START)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Mark all tables to be written */
+ jpeg_suppress_tables(cinfo, FALSE);
+ /* (Re)initialize error mgr and destination modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->dest->init_destination) (cinfo);
+ /* Perform master selection of active modules */
+ transencode_master_selection(cinfo, coef_arrays);
+ /* Wait for jpeg_finish_compress() call */
+ cinfo->next_scanline = 0; /* so jpeg_write_marker works */
+ cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding. Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL(void)
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+ j_compress_ptr dstinfo)
+{
+ JQUANT_TBL ** qtblptr;
+ jpeg_component_info *incomp, *outcomp;
+ JQUANT_TBL *c_quant, *slot_quant;
+ int tblno, ci, coefi;
+
+ /* Safety check to ensure start_compress not called yet. */
+ if (dstinfo->global_state != CSTATE_START)
+ ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+ /* Copy fundamental image dimensions */
+ dstinfo->image_width = srcinfo->image_width;
+ dstinfo->image_height = srcinfo->image_height;
+ dstinfo->input_components = srcinfo->num_components;
+ dstinfo->in_color_space = srcinfo->jpeg_color_space;
+ /* Initialize all parameters to default values */
+ jpeg_set_defaults(dstinfo);
+ /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+ * Fix it to get the right header markers for the image colorspace.
+ */
+ jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+ dstinfo->data_precision = srcinfo->data_precision;
+ dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+ /* Copy the source's quantization tables. */
+ for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+ if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+ qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
+ if (*qtblptr == NULL)
+ *qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+ MEMCOPY((*qtblptr)->quantval,
+ srcinfo->quant_tbl_ptrs[tblno]->quantval,
+ SIZEOF((*qtblptr)->quantval));
+ (*qtblptr)->sent_table = FALSE;
+ }
+ }
+ /* Copy the source's per-component info.
+ * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+ */
+ dstinfo->num_components = srcinfo->num_components;
+ if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+ MAX_COMPONENTS);
+ for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+ ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+ outcomp->component_id = incomp->component_id;
+ outcomp->h_samp_factor = incomp->h_samp_factor;
+ outcomp->v_samp_factor = incomp->v_samp_factor;
+ outcomp->quant_tbl_no = incomp->quant_tbl_no;
+ /* Make sure saved quantization table for component matches the qtable
+ * slot. If not, the input file re-used this qtable slot.
+ * IJG encoder currently cannot duplicate this.
+ */
+ tblno = outcomp->quant_tbl_no;
+ if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+ srcinfo->quant_tbl_ptrs[tblno] == NULL)
+ ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+ slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+ c_quant = incomp->quant_table;
+ if (c_quant != NULL) {
+ for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+ if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+ ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+ }
+ }
+ /* Note: we do not copy the source's Huffman table assignments;
+ * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+ */
+ }
+ /* Also copy JFIF version and resolution information, if available.
+ * Strictly speaking this isn't "critical" info, but it's nearly
+ * always appropriate to copy it if available. In particular,
+ * if the application chooses to copy JFIF 1.02 extension markers from
+ * the source file, we need to copy the version to make sure we don't
+ * emit a file that has 1.02 extensions but a claimed version of 1.01.
+ * We will *not*, however, copy version info from mislabeled "2.01" files.
+ */
+ if (srcinfo->saw_JFIF_marker) {
+ if (srcinfo->JFIF_major_version == 1) {
+ dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
+ dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
+ }
+ dstinfo->density_unit = srcinfo->density_unit;
+ dstinfo->X_density = srcinfo->X_density;
+ dstinfo->Y_density = srcinfo->Y_density;
+ }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL(void)
+transencode_master_selection (j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays)
+{
+ /* Although we don't actually use input_components for transcoding,
+ * jcmaster.c's initial_setup will complain if input_components is 0.
+ */
+ cinfo->input_components = 1;
+ /* Initialize master control (includes parameter checking/processing) */
+ jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+ /* Entropy encoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+ jinit_phuff_encoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_encoder(cinfo);
+ }
+
+ /* We need a special coefficient buffer controller. */
+ transencode_coef_controller(cinfo, coef_arrays);
+
+ jinit_marker_writer(cinfo);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Write the datastream header (SOI, JFIF) immediately.
+ * Frame and scan headers are postponed till later.
+ * This lets application insert special markers after the SOI.
+ */
+ (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller. This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays. Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_c_coef_controller pub; /* public fields */
+
+ JDIMENSION iMCU_row_num; /* iMCU row # within image */
+ JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* Virtual block array for each component. */
+ jvirt_barray_ptr * whole_image;
+
+ /* Workspace for constructing dummy blocks at right/bottom edges. */
+ JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+LOCAL(void)
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->mcu_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ if (pass_mode != JBUF_CRANK_DEST)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ coef->iMCU_row_num = 0;
+ start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF(boolean)
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, ci, xindex, yindex, yoffset, blockcnt;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan. */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ coef->iMCU_row_num * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (coef->iMCU_row_num < last_iMCU_row ||
+ yindex+yoffset < compptr->last_row_height) {
+ /* Fill in pointers to real blocks in this row */
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < blockcnt; xindex++)
+ MCU_buffer[blkn++] = buffer_ptr++;
+ } else {
+ /* At bottom of image, need a whole row of dummy blocks */
+ xindex = 0;
+ }
+ /* Fill in any dummy blocks needed in this row.
+ * Dummy blocks are filled in the same way as in jccoefct.c:
+ * all zeroes in the AC entries, DC entries equal to previous
+ * block's DC value. The init routine has already zeroed the
+ * AC entries, so we need only set the DC entries correctly.
+ */
+ for (; xindex < compptr->MCU_width; xindex++) {
+ MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+ MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+ blkn++;
+ }
+ }
+ }
+ /* Try to write the MCU. */
+ if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->mcu_ctr = MCU_col_num;
+ return FALSE;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->mcu_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ coef->iMCU_row_num++;
+ start_iMCU_row(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL(void)
+transencode_coef_controller (j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays)
+{
+ my_coef_ptr coef;
+ JBLOCKROW buffer;
+ int i;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+ coef->pub.start_pass = start_pass_coef;
+ coef->pub.compress_data = compress_output;
+
+ /* Save pointer to virtual arrays */
+ coef->whole_image = coef_arrays;
+
+ /* Allocate and pre-zero space for dummy DCT blocks. */
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+ coef->dummy_buffer[i] = buffer + i;
+ }
+}
--- /dev/null
+/*
+ * jdapimin.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library. These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c. But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL(void)
+jpeg_CreateDecompress (j_decompress_ptr cinfo, int version, size_t structsize)
+{
+ int i;
+
+ /* Guard against version mismatches between library and caller. */
+ cinfo->mem = NULL; /* so jpeg_destroy knows mem mgr not called */
+ if (version != JPEG_LIB_VERSION)
+ ERREXIT2(cinfo, JERR_BAD_LIB_VERSION, JPEG_LIB_VERSION, version);
+ if (structsize != SIZEOF(struct jpeg_decompress_struct))
+ ERREXIT2(cinfo, JERR_BAD_STRUCT_SIZE,
+ (int) SIZEOF(struct jpeg_decompress_struct), (int) structsize);
+
+ /* For debugging purposes, we zero the whole master structure.
+ * But the application has already set the err pointer, and may have set
+ * client_data, so we have to save and restore those fields.
+ * Note: if application hasn't set client_data, tools like Purify may
+ * complain here.
+ */
+ {
+ struct jpeg_error_mgr * err = cinfo->err;
+ void * client_data = cinfo->client_data; /* ignore Purify complaint here */
+ MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));
+ cinfo->err = err;
+ cinfo->client_data = client_data;
+ }
+ cinfo->is_decompressor = TRUE;
+
+ /* Initialize a memory manager instance for this object */
+ jinit_memory_mgr((j_common_ptr) cinfo);
+
+ /* Zero out pointers to permanent structures. */
+ cinfo->progress = NULL;
+ cinfo->src = NULL;
+
+ for (i = 0; i < NUM_QUANT_TBLS; i++)
+ cinfo->quant_tbl_ptrs[i] = NULL;
+
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ cinfo->dc_huff_tbl_ptrs[i] = NULL;
+ cinfo->ac_huff_tbl_ptrs[i] = NULL;
+ }
+
+ /* Initialize marker processor so application can override methods
+ * for COM, APPn markers before calling jpeg_read_header.
+ */
+ cinfo->marker_list = NULL;
+ jinit_marker_reader(cinfo);
+
+ /* And initialize the overall input controller. */
+ jinit_input_controller(cinfo);
+
+ /* OK, I'm ready */
+ cinfo->global_state = DSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL(void)
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
+{
+ jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL(void)
+jpeg_abort_decompress (j_decompress_ptr cinfo)
+{
+ jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL(void)
+default_decompress_parms (j_decompress_ptr cinfo)
+{
+ /* Guess the input colorspace, and set output colorspace accordingly. */
+ /* (Wish JPEG committee had provided a real way to specify this...) */
+ /* Note application may override our guesses. */
+ switch (cinfo->num_components) {
+ case 1:
+ cinfo->jpeg_color_space = JCS_GRAYSCALE;
+ cinfo->out_color_space = JCS_GRAYSCALE;
+ break;
+
+ case 3:
+ if (cinfo->saw_JFIF_marker) {
+ cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+ } else if (cinfo->saw_Adobe_marker) {
+ switch (cinfo->Adobe_transform) {
+ case 0:
+ cinfo->jpeg_color_space = JCS_RGB;
+ break;
+ case 1:
+ cinfo->jpeg_color_space = JCS_YCbCr;
+ break;
+ default:
+ WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+ break;
+ }
+ } else {
+ /* Saw no special markers, try to guess from the component IDs */
+ int cid0 = cinfo->comp_info[0].component_id;
+ int cid1 = cinfo->comp_info[1].component_id;
+ int cid2 = cinfo->comp_info[2].component_id;
+
+ if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+ else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+ cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+ else {
+ TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+ cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+ }
+ }
+ /* Always guess RGB is proper output colorspace. */
+ cinfo->out_color_space = JCS_RGB;
+ break;
+
+ case 4:
+ if (cinfo->saw_Adobe_marker) {
+ switch (cinfo->Adobe_transform) {
+ case 0:
+ cinfo->jpeg_color_space = JCS_CMYK;
+ break;
+ case 2:
+ cinfo->jpeg_color_space = JCS_YCCK;
+ break;
+ default:
+ WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+ cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+ break;
+ }
+ } else {
+ /* No special markers, assume straight CMYK. */
+ cinfo->jpeg_color_space = JCS_CMYK;
+ }
+ cinfo->out_color_space = JCS_CMYK;
+ break;
+
+ default:
+ cinfo->jpeg_color_space = JCS_UNKNOWN;
+ cinfo->out_color_space = JCS_UNKNOWN;
+ break;
+ }
+
+ /* Set defaults for other decompression parameters. */
+ cinfo->scale_num = 1; /* 1:1 scaling */
+ cinfo->scale_denom = 1;
+ cinfo->output_gamma = 1.0;
+ cinfo->buffered_image = FALSE;
+ cinfo->raw_data_out = FALSE;
+ cinfo->dct_method = JDCT_DEFAULT;
+ cinfo->do_fancy_upsampling = TRUE;
+ cinfo->do_block_smoothing = TRUE;
+ cinfo->quantize_colors = FALSE;
+ /* We set these in case application only sets quantize_colors. */
+ cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+ cinfo->two_pass_quantize = TRUE;
+#else
+ cinfo->two_pass_quantize = FALSE;
+#endif
+ cinfo->desired_number_of_colors = 256;
+ cinfo->colormap = NULL;
+ /* Initialize for no mode change in buffered-image mode. */
+ cinfo->enable_1pass_quant = FALSE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object. It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK. On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed. In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI. The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor. In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL(int)
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
+{
+ int retcode;
+
+ if (cinfo->global_state != DSTATE_START &&
+ cinfo->global_state != DSTATE_INHEADER)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ retcode = jpeg_consume_input(cinfo);
+
+ switch (retcode) {
+ case JPEG_REACHED_SOS:
+ retcode = JPEG_HEADER_OK;
+ break;
+ case JPEG_REACHED_EOI:
+ if (require_image) /* Complain if application wanted an image */
+ ERREXIT(cinfo, JERR_NO_IMAGE);
+ /* Reset to start state; it would be safer to require the application to
+ * call jpeg_abort, but we can't change it now for compatibility reasons.
+ * A side effect is to free any temporary memory (there shouldn't be any).
+ */
+ jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
+ retcode = JPEG_HEADER_TABLES_ONLY;
+ break;
+ case JPEG_SUSPENDED:
+ /* no work */
+ break;
+ }
+
+ return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL(int)
+jpeg_consume_input (j_decompress_ptr cinfo)
+{
+ int retcode = JPEG_SUSPENDED;
+
+ /* NB: every possible DSTATE value should be listed in this switch */
+ switch (cinfo->global_state) {
+ case DSTATE_START:
+ /* Start-of-datastream actions: reset appropriate modules */
+ (*cinfo->inputctl->reset_input_controller) (cinfo);
+ /* Initialize application's data source module */
+ (*cinfo->src->init_source) (cinfo);
+ cinfo->global_state = DSTATE_INHEADER;
+ /*FALLTHROUGH*/
+ case DSTATE_INHEADER:
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+ /* Set up default parameters based on header data */
+ default_decompress_parms(cinfo);
+ /* Set global state: ready for start_decompress */
+ cinfo->global_state = DSTATE_READY;
+ }
+ break;
+ case DSTATE_READY:
+ /* Can't advance past first SOS until start_decompress is called */
+ retcode = JPEG_REACHED_SOS;
+ break;
+ case DSTATE_PRELOAD:
+ case DSTATE_PRESCAN:
+ case DSTATE_SCANNING:
+ case DSTATE_RAW_OK:
+ case DSTATE_BUFIMAGE:
+ case DSTATE_BUFPOST:
+ case DSTATE_STOPPING:
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ break;
+ default:
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL(boolean)
+jpeg_input_complete (j_decompress_ptr cinfo)
+{
+ /* Check for valid jpeg object */
+ if (cinfo->global_state < DSTATE_START ||
+ cinfo->global_state > DSTATE_STOPPING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL(boolean)
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
+{
+ /* Only valid after jpeg_read_header completes */
+ if (cinfo->global_state < DSTATE_READY ||
+ cinfo->global_state > DSTATE_STOPPING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_decompress (j_decompress_ptr cinfo)
+{
+ if ((cinfo->global_state == DSTATE_SCANNING ||
+ cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
+ /* Terminate final pass of non-buffered mode */
+ if (cinfo->output_scanline < cinfo->output_height)
+ ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+ (*cinfo->master->finish_output_pass) (cinfo);
+ cinfo->global_state = DSTATE_STOPPING;
+ } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+ /* Finishing after a buffered-image operation */
+ cinfo->global_state = DSTATE_STOPPING;
+ } else if (cinfo->global_state != DSTATE_STOPPING) {
+ /* STOPPING = repeat call after a suspension, anything else is error */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ /* Read until EOI */
+ while (! cinfo->inputctl->eoi_reached) {
+ if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+ return FALSE; /* Suspend, come back later */
+ }
+ /* Do final cleanup */
+ (*cinfo->src->term_source) (cinfo);
+ /* We can use jpeg_abort to release memory and reset global_state */
+ jpeg_abort((j_common_ptr) cinfo);
+ return TRUE;
+}
--- /dev/null
+/*
+ * jdapistd.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library. These are the "standard" API routines that are
+ * used in the normal full-decompression case. They are not used by a
+ * transcoding-only application. Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(boolean) output_pass_setup JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_start_decompress (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state == DSTATE_READY) {
+ /* First call: initialize master control, select active modules */
+ jinit_master_decompress(cinfo);
+ if (cinfo->buffered_image) {
+ /* No more work here; expecting jpeg_start_output next */
+ cinfo->global_state = DSTATE_BUFIMAGE;
+ return TRUE;
+ }
+ cinfo->global_state = DSTATE_PRELOAD;
+ }
+ if (cinfo->global_state == DSTATE_PRELOAD) {
+ /* If file has multiple scans, absorb them all into the coef buffer */
+ if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ for (;;) {
+ int retcode;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL)
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ /* Absorb some more input */
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_SUSPENDED)
+ return FALSE;
+ if (retcode == JPEG_REACHED_EOI)
+ break;
+ /* Advance progress counter if appropriate */
+ if (cinfo->progress != NULL &&
+ (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+ if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+ /* jdmaster underestimated number of scans; ratchet up one scan */
+ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+ }
+ }
+ }
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+ }
+ cinfo->output_scan_number = cinfo->input_scan_number;
+ } else if (cinfo->global_state != DSTATE_PRESCAN)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Perform any dummy output passes, and set up for the final pass */
+ return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ * If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL(boolean)
+output_pass_setup (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state != DSTATE_PRESCAN) {
+ /* First call: do pass setup */
+ (*cinfo->master->prepare_for_output_pass) (cinfo);
+ cinfo->output_scanline = 0;
+ cinfo->global_state = DSTATE_PRESCAN;
+ }
+ /* Loop over any required dummy passes */
+ while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+ /* Crank through the dummy pass */
+ while (cinfo->output_scanline < cinfo->output_height) {
+ JDIMENSION last_scanline;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+ /* Process some data */
+ last_scanline = cinfo->output_scanline;
+ (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+ &cinfo->output_scanline, (JDIMENSION) 0);
+ if (cinfo->output_scanline == last_scanline)
+ return FALSE; /* No progress made, must suspend */
+ }
+ /* Finish up dummy pass, and set up for another one */
+ (*cinfo->master->finish_output_pass) (cinfo);
+ (*cinfo->master->prepare_for_output_pass) (cinfo);
+ cinfo->output_scanline = 0;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+ }
+ /* Ready for application to drive output pass through
+ * jpeg_read_scanlines or jpeg_read_raw_data.
+ */
+ cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+ return TRUE;
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error. However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+ JDIMENSION max_lines)
+{
+ JDIMENSION row_ctr;
+
+ if (cinfo->global_state != DSTATE_SCANNING)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->output_scanline >= cinfo->output_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Process some data */
+ row_ctr = 0;
+ (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+ cinfo->output_scanline += row_ctr;
+ return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL(JDIMENSION)
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+ JDIMENSION max_lines)
+{
+ JDIMENSION lines_per_iMCU_row;
+
+ if (cinfo->global_state != DSTATE_RAW_OK)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ if (cinfo->output_scanline >= cinfo->output_height) {
+ WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+ return 0;
+ }
+
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+ cinfo->progress->pass_limit = (long) cinfo->output_height;
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ }
+
+ /* Verify that at least one iMCU row can be returned. */
+ lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
+ if (max_lines < lines_per_iMCU_row)
+ ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+ /* Decompress directly into user's buffer. */
+ if (! (*cinfo->coef->decompress_data) (cinfo, data))
+ return 0; /* suspension forced, can do nothing more */
+
+ /* OK, we processed one iMCU row. */
+ cinfo->output_scanline += lines_per_iMCU_row;
+ return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL(boolean)
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
+{
+ if (cinfo->global_state != DSTATE_BUFIMAGE &&
+ cinfo->global_state != DSTATE_PRESCAN)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ /* Limit scan number to valid range */
+ if (scan_number <= 0)
+ scan_number = 1;
+ if (cinfo->inputctl->eoi_reached &&
+ scan_number > cinfo->input_scan_number)
+ scan_number = cinfo->input_scan_number;
+ cinfo->output_scan_number = scan_number;
+ /* Perform any dummy output passes, and set up for the real pass */
+ return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended. The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(boolean)
+jpeg_finish_output (j_decompress_ptr cinfo)
+{
+ if ((cinfo->global_state == DSTATE_SCANNING ||
+ cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+ /* Terminate this pass. */
+ /* We do not require the whole pass to have been completed. */
+ (*cinfo->master->finish_output_pass) (cinfo);
+ cinfo->global_state = DSTATE_BUFPOST;
+ } else if (cinfo->global_state != DSTATE_BUFPOST) {
+ /* BUFPOST = repeat call after a suspension, anything else is error */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ }
+ /* Read markers looking for SOS or EOI */
+ while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+ ! cinfo->inputctl->eoi_reached) {
+ if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+ return FALSE; /* Suspend, come back later */
+ }
+ cinfo->global_state = DSTATE_BUFIMAGE;
+ return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
--- /dev/null
+/*
+ * jdatadst.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to a file (or any stdio stream). While these routines
+ * are sufficient for most applications, some will want to use a different
+ * destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage. If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+ struct jpeg_destination_mgr pub; /* public fields */
+
+ FILE * outfile; /* target stream */
+ JOCTET * buffer; /* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF(void)
+init_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ /* Allocate the output buffer --- it will be released when done with image */
+ dest->buffer = (JOCTET *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines). The
+ * application should resume compression after it has made more room in the
+ * output buffer. Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF(boolean)
+empty_output_buffer (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+ (size_t) OUTPUT_BUF_SIZE)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+ return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written. Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* Write any data remaining in the buffer */
+ if (datacount > 0) {
+ if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+ }
+ fflush(dest->outfile);
+ /* Make sure we wrote the output file OK */
+ if (ferror(dest->outfile))
+ ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
+{
+ my_dest_ptr dest;
+
+ /* The destination object is made permanent so that multiple JPEG images
+ * can be written to the same file without re-executing jpeg_stdio_dest.
+ * This makes it dangerous to use this manager and a different destination
+ * manager serially with the same JPEG object, because their private object
+ * sizes may be different. Caveat programmer.
+ */
+ if (cinfo->dest == NULL) { /* first time for this JPEG object? */
+ cinfo->dest = (struct jpeg_destination_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_destination_mgr));
+ }
+
+ dest = (my_dest_ptr) cinfo->dest;
+ dest->pub.init_destination = init_destination;
+ dest->pub.empty_output_buffer = empty_output_buffer;
+ dest->pub.term_destination = term_destination;
+ dest->outfile = outfile;
+}
--- /dev/null
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream). While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage. If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+ struct jpeg_source_mgr pub; /* public fields */
+
+ FILE * infile; /* source stream */
+ JOCTET * buffer; /* start of buffer */
+ boolean start_of_file; /* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF(void)
+init_source (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* We reset the empty-input-file flag for each image,
+ * but we don't clear the input buffer.
+ * This is correct behavior for reading a series of images from one source.
+ */
+ src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded. It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return. If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer. In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there. However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later. In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any). The application should resume
+ * decompression after it has loaded more data into the input buffer. Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF(boolean)
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+ size_t nbytes;
+
+ nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);
+
+ if (nbytes <= 0) {
+ if (src->start_of_file) /* Treat empty input file as fatal error */
+ ERREXIT(cinfo, JERR_INPUT_EMPTY);
+ WARNMS(cinfo, JWRN_JPEG_EOF);
+ /* Insert a fake EOI marker */
+ src->buffer[0] = (JOCTET) 0xFF;
+ src->buffer[1] = (JOCTET) JPEG_EOI;
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return. If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF(void)
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* Just a dumb implementation for now. Could use fseek() except
+ * it doesn't work on pipes. Not clear that being smart is worth
+ * any trouble anyway --- large skips are infrequent.
+ */
+ if (num_bytes > 0) {
+ while (num_bytes > (long) src->pub.bytes_in_buffer) {
+ num_bytes -= (long) src->pub.bytes_in_buffer;
+ (void) fill_input_buffer(cinfo);
+ /* note we assume that fill_input_buffer will never return FALSE,
+ * so suspension need not be handled.
+ */
+ }
+ src->pub.next_input_byte += (size_t) num_bytes;
+ src->pub.bytes_in_buffer -= (size_t) num_bytes;
+ }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library. That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read. Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF(void)
+term_source (j_decompress_ptr cinfo)
+{
+ /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL(void)
+jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
+{
+ my_src_ptr src;
+
+ /* The source object and input buffer are made permanent so that a series
+ * of JPEG images can be read from the same file by calling jpeg_stdio_src
+ * only before the first one. (If we discarded the buffer at the end of
+ * one image, we'd likely lose the start of the next one.)
+ * This makes it unsafe to use this manager and a different source
+ * manager serially with the same JPEG object. Caveat programmer.
+ */
+ if (cinfo->src == NULL) { /* first time for this JPEG object? */
+ cinfo->src = (struct jpeg_source_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_source_mgr));
+ src = (my_src_ptr) cinfo->src;
+ src->buffer = (JOCTET *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ INPUT_BUF_SIZE * SIZEOF(JOCTET));
+ }
+
+ src = (my_src_ptr) cinfo->src;
+ src->pub.init_source = init_source;
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = term_source;
+ src->infile = infile;
+ src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+ src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
--- /dev/null
+/*
+ * jdcoefct.c
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_coef_controller pub; /* public fields */
+
+ /* These variables keep track of the current location of the input side. */
+ /* cinfo->input_iMCU_row is also used for this. */
+ JDIMENSION MCU_ctr; /* counts MCUs processed in current row */
+ int MCU_vert_offset; /* counts MCU rows within iMCU row */
+ int MCU_rows_per_iMCU_row; /* number of such rows needed */
+
+ /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+ /* In single-pass modes, it's sufficient to buffer just one MCU.
+ * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+ * and let the entropy decoder write into that workspace each time.
+ * (On 80x86, the workspace is FAR even though it's not really very big;
+ * this is to keep the module interfaces unchanged when a large coefficient
+ * buffer is necessary.)
+ * In multi-pass modes, this array points to the current MCU's blocks
+ * within the virtual arrays; it is used only by the input side.
+ */
+ JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* In multi-pass modes, we need a virtual block array for each component. */
+ jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ /* When doing block smoothing, we latch coefficient Al values here */
+ int * coef_bits_latch;
+#define SAVED_COEFS 6 /* we save coef_bits[0..5] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+/* Forward declarations */
+METHODDEF(int) decompress_onepass
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF(int) decompress_data
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL(boolean) smoothing_ok JPP((j_decompress_ptr cinfo));
+METHODDEF(int) decompress_smooth_data
+ JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+
+
+LOCAL(void)
+start_iMCU_row (j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* In an interleaved scan, an MCU row is the same as an iMCU row.
+ * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+ * But at the bottom of the image, process only what's left.
+ */
+ if (cinfo->comps_in_scan > 1) {
+ coef->MCU_rows_per_iMCU_row = 1;
+ } else {
+ if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+ else
+ coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+ }
+
+ coef->MCU_ctr = 0;
+ coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+ cinfo->input_iMCU_row = 0;
+ start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF(void)
+start_output_pass (j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+ /* If multipass, check to see whether to use block smoothing on this pass */
+ if (coef->pub.coef_arrays != NULL) {
+ if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+ coef->pub.decompress_data = decompress_smooth_data;
+ else
+ coef->pub.decompress_data = decompress_data;
+ }
+#endif
+ cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image,
+ * which we index according to the component's SOF position.
+ */
+
+METHODDEF(int)
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ int blkn, ci, xindex, yindex, yoffset, useful_width;
+ JSAMPARRAY output_ptr;
+ JDIMENSION start_col, output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+
+ /* Loop to process as much as one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+ MCU_col_num++) {
+ /* Try to fetch an MCU. Entropy decoder expects buffer to be zeroed. */
+ jzero_far((void FAR *) coef->MCU_buffer[0],
+ (size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+ if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->MCU_ctr = MCU_col_num;
+ return JPEG_SUSPENDED;
+ }
+ /* Determine where data should go in output_buf and do the IDCT thing.
+ * We skip dummy blocks at the right and bottom edges (but blkn gets
+ * incremented past them!). Note the inner loop relies on having
+ * allocated the MCU_buffer[] blocks sequentially.
+ */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed) {
+ blkn += compptr->MCU_blocks;
+ continue;
+ }
+ inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+ useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+ : compptr->last_col_width;
+ output_ptr = output_buf[compptr->component_index] +
+ yoffset * compptr->DCT_scaled_size;
+ start_col = MCU_col_num * compptr->MCU_sample_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ if (cinfo->input_iMCU_row < last_iMCU_row ||
+ yoffset+yindex < compptr->last_row_height) {
+ output_col = start_col;
+ for (xindex = 0; xindex < useful_width; xindex++) {
+ (*inverse_DCT) (cinfo, compptr,
+ (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+ output_ptr, output_col);
+ output_col += compptr->DCT_scaled_size;
+ }
+ }
+ blkn += compptr->MCU_width;
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->MCU_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ cinfo->output_iMCU_row++;
+ if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+ start_iMCU_row(cinfo);
+ return JPEG_ROW_COMPLETED;
+ }
+ /* Completed the scan */
+ (*cinfo->inputctl->finish_input_pass) (cinfo);
+ return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF(int)
+dummy_consume_data (j_decompress_ptr cinfo)
+{
+ return JPEG_SUSPENDED; /* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF(int)
+consume_data (j_decompress_ptr cinfo)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION MCU_col_num; /* index of current MCU within row */
+ int blkn, ci, xindex, yindex, yoffset;
+ JDIMENSION start_col;
+ JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+ JBLOCKROW buffer_ptr;
+ jpeg_component_info *compptr;
+
+ /* Align the virtual buffers for the components used in this scan. */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ buffer[ci] = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+ cinfo->input_iMCU_row * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, TRUE);
+ /* Note: entropy decoder expects buffer to be zeroed,
+ * but this is handled automatically by the memory manager
+ * because we requested a pre-zeroed array.
+ */
+ }
+
+ /* Loop to process one whole iMCU row */
+ for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+ yoffset++) {
+ for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+ MCU_col_num++) {
+ /* Construct list of pointers to DCT blocks belonging to this MCU */
+ blkn = 0; /* index of current DCT block within MCU */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ start_col = MCU_col_num * compptr->MCU_width;
+ for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+ buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+ for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+ coef->MCU_buffer[blkn++] = buffer_ptr++;
+ }
+ }
+ }
+ /* Try to fetch the MCU. */
+ if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+ /* Suspension forced; update state counters and exit */
+ coef->MCU_vert_offset = yoffset;
+ coef->MCU_ctr = MCU_col_num;
+ return JPEG_SUSPENDED;
+ }
+ }
+ /* Completed an MCU row, but perhaps not an iMCU row */
+ coef->MCU_ctr = 0;
+ }
+ /* Completed the iMCU row, advance counters for next one */
+ if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+ start_iMCU_row(cinfo);
+ return JPEG_ROW_COMPLETED;
+ }
+ /* Completed the scan */
+ (*cinfo->inputctl->finish_input_pass) (cinfo);
+ return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF(int)
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION block_num;
+ int ci, block_row, block_rows;
+ JBLOCKARRAY buffer;
+ JBLOCKROW buffer_ptr;
+ JSAMPARRAY output_ptr;
+ JDIMENSION output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+
+ /* Force some input to be done if we are getting ahead of the input. */
+ while (cinfo->input_scan_number < cinfo->output_scan_number ||
+ (cinfo->input_scan_number == cinfo->output_scan_number &&
+ cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+ if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+ return JPEG_SUSPENDED;
+ }
+
+ /* OK, output from the virtual arrays. */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed)
+ continue;
+ /* Align the virtual buffer for this component. */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ cinfo->output_iMCU_row * compptr->v_samp_factor,
+ (JDIMENSION) compptr->v_samp_factor, FALSE);
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (cinfo->output_iMCU_row < last_iMCU_row)
+ block_rows = compptr->v_samp_factor;
+ else {
+ /* NB: can't use last_row_height here; it is input-side-dependent! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ }
+ inverse_DCT = cinfo->idct->inverse_DCT[ci];
+ output_ptr = output_buf[ci];
+ /* Loop over all DCT blocks to be processed. */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ buffer_ptr = buffer[block_row];
+ output_col = 0;
+ for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
+ (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+ output_ptr, output_col);
+ buffer_ptr++;
+ output_col += compptr->DCT_scaled_size;
+ }
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+
+ if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+ return JPEG_ROW_COMPLETED;
+ return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/* Natural-order array positions of the first 5 zigzag-order coefficients */
+#define Q01_POS 1
+#define Q10_POS 8
+#define Q20_POS 16
+#define Q11_POS 9
+#define Q02_POS 2
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL(boolean)
+smoothing_ok (j_decompress_ptr cinfo)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ boolean smoothing_useful = FALSE;
+ int ci, coefi;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtable;
+ int * coef_bits;
+ int * coef_bits_latch;
+
+ if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
+ return FALSE;
+
+ /* Allocate latch area if not already done */
+ if (coef->coef_bits_latch == NULL)
+ coef->coef_bits_latch = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components *
+ (SAVED_COEFS * SIZEOF(int)));
+ coef_bits_latch = coef->coef_bits_latch;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* All components' quantization values must already be latched. */
+ if ((qtable = compptr->quant_table) == NULL)
+ return FALSE;
+ /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
+ if (qtable->quantval[0] == 0 ||
+ qtable->quantval[Q01_POS] == 0 ||
+ qtable->quantval[Q10_POS] == 0 ||
+ qtable->quantval[Q20_POS] == 0 ||
+ qtable->quantval[Q11_POS] == 0 ||
+ qtable->quantval[Q02_POS] == 0)
+ return FALSE;
+ /* DC values must be at least partly known for all components. */
+ coef_bits = cinfo->coef_bits[ci];
+ if (coef_bits[0] < 0)
+ return FALSE;
+ /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+ for (coefi = 1; coefi <= 5; coefi++) {
+ coef_bits_latch[coefi] = coef_bits[coefi];
+ if (coef_bits[coefi] != 0)
+ smoothing_useful = TRUE;
+ }
+ coef_bits_latch += SAVED_COEFS;
+ }
+
+ return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF(int)
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+ my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+ JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+ JDIMENSION block_num, last_block_column;
+ int ci, block_row, block_rows, access_rows;
+ JBLOCKARRAY buffer;
+ JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
+ JSAMPARRAY output_ptr;
+ JDIMENSION output_col;
+ jpeg_component_info *compptr;
+ inverse_DCT_method_ptr inverse_DCT;
+ boolean first_row, last_row;
+ JBLOCK workspace;
+ int *coef_bits;
+ JQUANT_TBL *quanttbl;
+ INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
+ int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
+ int Al, pred;
+
+ /* Force some input to be done if we are getting ahead of the input. */
+ while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+ ! cinfo->inputctl->eoi_reached) {
+ if (cinfo->input_scan_number == cinfo->output_scan_number) {
+ /* If input is working on current scan, we ordinarily want it to
+ * have completed the current row. But if input scan is DC,
+ * we want it to keep one row ahead so that next block row's DC
+ * values are up to date.
+ */
+ JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+ if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
+ break;
+ }
+ if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+ return JPEG_SUSPENDED;
+ }
+
+ /* OK, output from the virtual arrays. */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Don't bother to IDCT an uninteresting component. */
+ if (! compptr->component_needed)
+ continue;
+ /* Count non-dummy DCT block rows in this iMCU row. */
+ if (cinfo->output_iMCU_row < last_iMCU_row) {
+ block_rows = compptr->v_samp_factor;
+ access_rows = block_rows * 2; /* this and next iMCU row */
+ last_row = FALSE;
+ } else {
+ /* NB: can't use last_row_height here; it is input-side-dependent! */
+ block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (block_rows == 0) block_rows = compptr->v_samp_factor;
+ access_rows = block_rows; /* this iMCU row only */
+ last_row = TRUE;
+ }
+ /* Align the virtual buffer for this component. */
+ if (cinfo->output_iMCU_row > 0) {
+ access_rows += compptr->v_samp_factor; /* prior iMCU row too */
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+ (JDIMENSION) access_rows, FALSE);
+ buffer += compptr->v_samp_factor; /* point to current iMCU row */
+ first_row = FALSE;
+ } else {
+ buffer = (*cinfo->mem->access_virt_barray)
+ ((j_common_ptr) cinfo, coef->whole_image[ci],
+ (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+ first_row = TRUE;
+ }
+ /* Fetch component-dependent info */
+ coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+ quanttbl = compptr->quant_table;
+ Q00 = quanttbl->quantval[0];
+ Q01 = quanttbl->quantval[Q01_POS];
+ Q10 = quanttbl->quantval[Q10_POS];
+ Q20 = quanttbl->quantval[Q20_POS];
+ Q11 = quanttbl->quantval[Q11_POS];
+ Q02 = quanttbl->quantval[Q02_POS];
+ inverse_DCT = cinfo->idct->inverse_DCT[ci];
+ output_ptr = output_buf[ci];
+ /* Loop over all DCT blocks to be processed. */
+ for (block_row = 0; block_row < block_rows; block_row++) {
+ buffer_ptr = buffer[block_row];
+ if (first_row && block_row == 0)
+ prev_block_row = buffer_ptr;
+ else
+ prev_block_row = buffer[block_row-1];
+ if (last_row && block_row == block_rows-1)
+ next_block_row = buffer_ptr;
+ else
+ next_block_row = buffer[block_row+1];
+ /* We fetch the surrounding DC values using a sliding-register approach.
+ * Initialize all nine here so as to do the right thing on narrow pics.
+ */
+ DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+ DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+ DC7 = DC8 = DC9 = (int) next_block_row[0][0];
+ output_col = 0;
+ last_block_column = compptr->width_in_blocks - 1;
+ for (block_num = 0; block_num <= last_block_column; block_num++) {
+ /* Fetch current DCT block into workspace so we can modify it. */
+ jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+ /* Update DC values */
+ if (block_num < last_block_column) {
+ DC3 = (int) prev_block_row[1][0];
+ DC6 = (int) buffer_ptr[1][0];
+ DC9 = (int) next_block_row[1][0];
+ }
+ /* Compute coefficient estimates per K.8.
+ * An estimate is applied only if coefficient is still zero,
+ * and is not known to be fully accurate.
+ */
+ /* AC01 */
+ if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+ num = 36 * Q00 * (DC4 - DC6);
+ if (num >= 0) {
+ pred = (int) (((Q01<<7) + num) / (Q01<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q01<<7) - num) / (Q01<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[1] = (JCOEF) pred;
+ }
+ /* AC10 */
+ if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+ num = 36 * Q00 * (DC2 - DC8);
+ if (num >= 0) {
+ pred = (int) (((Q10<<7) + num) / (Q10<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q10<<7) - num) / (Q10<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[8] = (JCOEF) pred;
+ }
+ /* AC20 */
+ if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+ num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+ if (num >= 0) {
+ pred = (int) (((Q20<<7) + num) / (Q20<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q20<<7) - num) / (Q20<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[16] = (JCOEF) pred;
+ }
+ /* AC11 */
+ if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+ num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+ if (num >= 0) {
+ pred = (int) (((Q11<<7) + num) / (Q11<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q11<<7) - num) / (Q11<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[9] = (JCOEF) pred;
+ }
+ /* AC02 */
+ if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+ num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+ if (num >= 0) {
+ pred = (int) (((Q02<<7) + num) / (Q02<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ } else {
+ pred = (int) (((Q02<<7) - num) / (Q02<<8));
+ if (Al > 0 && pred >= (1<<Al))
+ pred = (1<<Al)-1;
+ pred = -pred;
+ }
+ workspace[2] = (JCOEF) pred;
+ }
+ /* OK, do the IDCT */
+ (*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+ output_ptr, output_col);
+ /* Advance for next column */
+ DC1 = DC2; DC2 = DC3;
+ DC4 = DC5; DC5 = DC6;
+ DC7 = DC8; DC8 = DC9;
+ buffer_ptr++, prev_block_row++, next_block_row++;
+ output_col += compptr->DCT_scaled_size;
+ }
+ output_ptr += compptr->DCT_scaled_size;
+ }
+ }
+
+ if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+ return JPEG_ROW_COMPLETED;
+ return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_coef_ptr coef;
+
+ coef = (my_coef_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_coef_controller));
+ cinfo->coef = (struct jpeg_d_coef_controller *) coef;
+ coef->pub.start_input_pass = start_input_pass;
+ coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ coef->coef_bits_latch = NULL;
+#endif
+
+ /* Create the coefficient buffer. */
+ if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* Allocate a full-image virtual array for each component, */
+ /* padded to a multiple of samp_factor DCT blocks in each direction. */
+ /* Note we ask for a pre-zeroed array. */
+ int ci, access_rows;
+ jpeg_component_info *compptr;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+ /* If block smoothing could be used, need a bigger window */
+ if (cinfo->progressive_mode)
+ access_rows *= 3;
+#endif
+ coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+ (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+ (long) compptr->h_samp_factor),
+ (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+ (long) compptr->v_samp_factor),
+ (JDIMENSION) access_rows);
+ }
+ coef->pub.consume_data = consume_data;
+ coef->pub.decompress_data = decompress_data;
+ coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ /* We only need a single-MCU buffer. */
+ JBLOCKROW buffer;
+ int i;
+
+ buffer = (JBLOCKROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+ for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+ coef->MCU_buffer[i] = buffer + i;
+ }
+ coef->pub.consume_data = dummy_consume_data;
+ coef->pub.decompress_data = decompress_onepass;
+ coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+ }
+}
--- /dev/null
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_deconverter pub; /* public fields */
+
+ /* Private state for YCC->RGB conversion */
+ int * Cr_r_tab; /* => table for Cr to R conversion */
+ int * Cb_b_tab; /* => table for Cb to B conversion */
+ INT32 * Cr_g_tab; /* => table for Cr to G conversion */
+ INT32 * Cb_g_tab; /* => table for Cb to G conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter * my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ * R = Y + 1.40200 * Cr
+ * G = Y - 0.34414 * Cb - 0.71414 * Cr
+ * B = Y + 1.77200 * Cb
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable. It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ int i;
+ INT32 x;
+ SHIFT_TEMPS
+
+ cconvert->Cr_r_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ cconvert->Cb_b_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ cconvert->Cr_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+ cconvert->Cb_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+
+ for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+ /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+ /* Cr=>R value is nearest int to 1.40200 * x */
+ cconvert->Cr_r_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+ /* Cb=>B value is nearest int to 1.77200 * x */
+ cconvert->Cb_b_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+ /* Cr=>G value is scaled-up -0.71414 * x */
+ cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+ /* Cb=>G value is scaled-up -0.34414 * x */
+ /* We also add in ONE_HALF so that need not do it in inner loop */
+ cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+ }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format. The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer. The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF(void)
+ycc_rgb_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int y, cb, cr;
+ register JSAMPROW outptr;
+ register JSAMPROW inptr0, inptr1, inptr2;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ register int * Crrtab = cconvert->Cr_r_tab;
+ register int * Cbbtab = cconvert->Cb_b_tab;
+ register INT32 * Crgtab = cconvert->Cr_g_tab;
+ register INT32 * Cbgtab = cconvert->Cb_g_tab;
+ SHIFT_TEMPS
+
+ while (--num_rows >= 0) {
+ inptr0 = input_buf[0][input_row];
+ inptr1 = input_buf[1][input_row];
+ inptr2 = input_buf[2][input_row];
+ input_row++;
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ y = GETJSAMPLE(inptr0[col]);
+ cb = GETJSAMPLE(inptr1[col]);
+ cr = GETJSAMPLE(inptr2[col]);
+ /* Range-limiting is essential due to noise introduced by DCT losses. */
+ outptr[RGB_RED] = range_limit[y + Crrtab[cr]];
+ outptr[RGB_GREEN] = range_limit[y +
+ ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+ SCALEBITS))];
+ outptr[RGB_BLUE] = range_limit[y + Cbbtab[cb]];
+ outptr += RGB_PIXELSIZE;
+ }
+ }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF(void)
+null_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ register JSAMPROW inptr, outptr;
+ register JDIMENSION count;
+ register int num_components = cinfo->num_components;
+ JDIMENSION num_cols = cinfo->output_width;
+ int ci;
+
+ while (--num_rows >= 0) {
+ for (ci = 0; ci < num_components; ci++) {
+ inptr = input_buf[ci][input_row];
+ outptr = output_buf[0] + ci;
+ for (count = num_cols; count > 0; count--) {
+ *outptr = *inptr++; /* needn't bother with GETJSAMPLE() here */
+ outptr += num_components;
+ }
+ }
+ input_row++;
+ output_buf++;
+ }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF(void)
+grayscale_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+ num_rows, cinfo->output_width);
+}
+
+
+/*
+ * Convert grayscale to RGB: just duplicate the graylevel three times.
+ * This is provided to support applications that don't want to cope
+ * with grayscale as a separate case.
+ */
+
+METHODDEF(void)
+gray_rgb_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ register JSAMPROW inptr, outptr;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+
+ while (--num_rows >= 0) {
+ inptr = input_buf[0][input_row++];
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ /* We can dispense with GETJSAMPLE() here */
+ outptr[RGB_RED] = outptr[RGB_GREEN] = outptr[RGB_BLUE] = inptr[col];
+ outptr += RGB_PIXELSIZE;
+ }
+ }
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF(void)
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+ register int y, cb, cr;
+ register JSAMPROW outptr;
+ register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+ register JDIMENSION col;
+ JDIMENSION num_cols = cinfo->output_width;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ register int * Crrtab = cconvert->Cr_r_tab;
+ register int * Cbbtab = cconvert->Cb_b_tab;
+ register INT32 * Crgtab = cconvert->Cr_g_tab;
+ register INT32 * Cbgtab = cconvert->Cb_g_tab;
+ SHIFT_TEMPS
+
+ while (--num_rows >= 0) {
+ inptr0 = input_buf[0][input_row];
+ inptr1 = input_buf[1][input_row];
+ inptr2 = input_buf[2][input_row];
+ inptr3 = input_buf[3][input_row];
+ input_row++;
+ outptr = *output_buf++;
+ for (col = 0; col < num_cols; col++) {
+ y = GETJSAMPLE(inptr0[col]);
+ cb = GETJSAMPLE(inptr1[col]);
+ cr = GETJSAMPLE(inptr2[col]);
+ /* Range-limiting is essential due to noise introduced by DCT losses. */
+ outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])]; /* red */
+ outptr[1] = range_limit[MAXJSAMPLE - (y + /* green */
+ ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+ SCALEBITS)))];
+ outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])]; /* blue */
+ /* K passes through unchanged */
+ outptr[3] = inptr3[col]; /* don't need GETJSAMPLE here */
+ outptr += 4;
+ }
+ }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF(void)
+start_pass_dcolor (j_decompress_ptr cinfo)
+{
+ /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL(void)
+jinit_color_deconverter (j_decompress_ptr cinfo)
+{
+ my_cconvert_ptr cconvert;
+ int ci;
+
+ cconvert = (my_cconvert_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_color_deconverter));
+ cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
+ cconvert->pub.start_pass = start_pass_dcolor;
+
+ /* Make sure num_components agrees with jpeg_color_space */
+ switch (cinfo->jpeg_color_space) {
+ case JCS_GRAYSCALE:
+ if (cinfo->num_components != 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ case JCS_RGB:
+ case JCS_YCbCr:
+ if (cinfo->num_components != 3)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ case JCS_CMYK:
+ case JCS_YCCK:
+ if (cinfo->num_components != 4)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+
+ default: /* JCS_UNKNOWN can be anything */
+ if (cinfo->num_components < 1)
+ ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+ break;
+ }
+
+ /* Set out_color_components and conversion method based on requested space.
+ * Also clear the component_needed flags for any unused components,
+ * so that earlier pipeline stages can avoid useless computation.
+ */
+
+ switch (cinfo->out_color_space) {
+ case JCS_GRAYSCALE:
+ cinfo->out_color_components = 1;
+ if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+ cinfo->jpeg_color_space == JCS_YCbCr) {
+ cconvert->pub.color_convert = grayscale_convert;
+ /* For color->grayscale conversion, only the Y (0) component is needed */
+ for (ci = 1; ci < cinfo->num_components; ci++)
+ cinfo->comp_info[ci].component_needed = FALSE;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_RGB:
+ cinfo->out_color_components = RGB_PIXELSIZE;
+ if (cinfo->jpeg_color_space == JCS_YCbCr) {
+ cconvert->pub.color_convert = ycc_rgb_convert;
+ build_ycc_rgb_table(cinfo);
+ } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) {
+ cconvert->pub.color_convert = gray_rgb_convert;
+ } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
+ cconvert->pub.color_convert = null_convert;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ case JCS_CMYK:
+ cinfo->out_color_components = 4;
+ if (cinfo->jpeg_color_space == JCS_YCCK) {
+ cconvert->pub.color_convert = ycck_cmyk_convert;
+ build_ycc_rgb_table(cinfo);
+ } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+ cconvert->pub.color_convert = null_convert;
+ } else
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+
+ default:
+ /* Permit null conversion to same output space */
+ if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+ cinfo->out_color_components = cinfo->num_components;
+ cconvert->pub.color_convert = null_convert;
+ } else /* unsupported non-null conversion */
+ ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+ break;
+ }
+
+ if (cinfo->quantize_colors)
+ cinfo->output_components = 1; /* single colormapped output component */
+ else
+ cinfo->output_components = cinfo->out_color_components;
+}
--- /dev/null
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules. These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer. Type DCTELEM is int
+ * for 8-bit samples, INT32 for 12-bit samples. (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data. This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM; /* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM; /* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array. The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table. The output data is to be placed into the
+ * sample array starting at a specified column. (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS 2 /* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE; /* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS 13 /* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE). The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required. We use a mask-and-table-lookup method
+ * to do the combined operations quickly. See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo) ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow jFDislow
+#define jpeg_fdct_ifast jFDifast
+#define jpeg_fdct_float jFDfloat
+#define jpeg_idct_islow jRDislow
+#define jpeg_idct_ifast jRDifast
+#define jpeg_idct_float jRDfloat
+#define jpeg_idct_4x4 jRD4x4
+#define jpeg_idct_2x2 jRD2x2
+#define jpeg_idct_1x1 jRD1x1
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN(void) jpeg_fdct_islow JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_ifast JPP((DCTELEM * data));
+EXTERN(void) jpeg_fdct_float JPP((FAST_FLOAT * data));
+
+EXTERN(void) jpeg_idct_islow
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_ifast
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_float
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_4x4
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_2x2
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN(void) jpeg_idct_1x1
+ JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE ((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x) ((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n) RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply. This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32 /* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const) (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16 /* default definition */
+#define MULTIPLY16C16(var,const) ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32 /* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2) (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16 /* default definition */
+#define MULTIPLY16V16(var1,var2) ((var1) * (var2))
+#endif
--- /dev/null
+/*
+ * jddctmgr.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores. No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper. This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component. (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent. To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away. To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+ struct jpeg_inverse_dct pub; /* public fields */
+
+ /* This array contains the IDCT method code that each multiplier table
+ * is currently set up for, or -1 if it's not yet set up.
+ * The actual multiplier tables are pointed to by dct_table in the
+ * per-component comp_info structures.
+ */
+ int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller * my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+ ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+ IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF(void)
+start_pass (j_decompress_ptr cinfo)
+{
+ my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
+ int ci, i;
+ jpeg_component_info *compptr;
+ int method = 0;
+ inverse_DCT_method_ptr method_ptr = NULL;
+ JQUANT_TBL * qtbl;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Select the proper IDCT routine for this component's scaling */
+ switch (compptr->DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+ case 1:
+ method_ptr = jpeg_idct_1x1;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+ case 2:
+ method_ptr = jpeg_idct_2x2;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+ case 4:
+ method_ptr = jpeg_idct_4x4;
+ method = JDCT_ISLOW; /* jidctred uses islow-style table */
+ break;
+#endif
+ case DCTSIZE:
+ switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+ case JDCT_ISLOW:
+ method_ptr = jpeg_idct_islow;
+ method = JDCT_ISLOW;
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ method_ptr = jpeg_idct_ifast;
+ method = JDCT_IFAST;
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ method_ptr = jpeg_idct_float;
+ method = JDCT_FLOAT;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ break;
+ default:
+ ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
+ break;
+ }
+ idct->pub.inverse_DCT[ci] = method_ptr;
+ /* Create multiplier table from quant table.
+ * However, we can skip this if the component is uninteresting
+ * or if we already built the table. Also, if no quant table
+ * has yet been saved for the component, we leave the
+ * multiplier table all-zero; we'll be reading zeroes from the
+ * coefficient controller's buffer anyway.
+ */
+ if (! compptr->component_needed || idct->cur_method[ci] == method)
+ continue;
+ qtbl = compptr->quant_table;
+ if (qtbl == NULL) /* happens if no data yet for component */
+ continue;
+ idct->cur_method[ci] = method;
+ switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+ case JDCT_ISLOW:
+ {
+ /* For LL&M IDCT method, multipliers are equal to raw quantization
+ * coefficients, but are stored as ints to ensure access efficiency.
+ */
+ ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ for (i = 0; i < DCTSIZE2; i++) {
+ ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[i];
+ }
+ }
+ break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+ case JDCT_IFAST:
+ {
+ /* For AA&N IDCT method, multipliers are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ * For integer operation, the multiplier table is to be scaled by
+ * IFAST_SCALE_BITS.
+ */
+ IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
+ static const INT16 aanscales[DCTSIZE2] = {
+ /* precomputed values scaled up by 14 bits */
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
+ 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
+ 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
+ 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
+ 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
+ 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
+ 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
+ };
+ SHIFT_TEMPS
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ ifmtbl[i] = (IFAST_MULT_TYPE)
+ DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[i],
+ (INT32) aanscales[i]),
+ CONST_BITS-IFAST_SCALE_BITS);
+ }
+ }
+ break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+ case JDCT_FLOAT:
+ {
+ /* For float AA&N IDCT method, multipliers are equal to quantization
+ * coefficients scaled by scalefactor[row]*scalefactor[col], where
+ * scalefactor[0] = 1
+ * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
+ */
+ FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
+ int row, col;
+ static const double aanscalefactor[DCTSIZE] = {
+ 1.0, 1.387039845, 1.306562965, 1.175875602,
+ 1.0, 0.785694958, 0.541196100, 0.275899379
+ };
+
+ i = 0;
+ for (row = 0; row < DCTSIZE; row++) {
+ for (col = 0; col < DCTSIZE; col++) {
+ fmtbl[i] = (FLOAT_MULT_TYPE)
+ ((double) qtbl->quantval[i] *
+ aanscalefactor[row] * aanscalefactor[col]);
+ i++;
+ }
+ }
+ }
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+ }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL(void)
+jinit_inverse_dct (j_decompress_ptr cinfo)
+{
+ my_idct_ptr idct;
+ int ci;
+ jpeg_component_info *compptr;
+
+ idct = (my_idct_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_idct_controller));
+ cinfo->idct = (struct jpeg_inverse_dct *) idct;
+ idct->pub.start_pass = start_pass;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Allocate and pre-zero a multiplier table for each component */
+ compptr->dct_table =
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(multiplier_table));
+ MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
+ /* Mark multiplier table not yet set up for any method */
+ idct->cur_method[ci] = -1;
+ }
+}
--- /dev/null
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU. To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h" /* Declarations shared with jdphuff.c */
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_decoder pub; /* public fields */
+
+ /* These fields are loaded into local variables at start of each MCU.
+ * In case of suspension, we exit WITHOUT updating them.
+ */
+ bitread_perm_state bitstate; /* Bit buffer at start of MCU */
+ savable_state saved; /* Other state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+ d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+ /* Precalculated info set up by start_pass for use in decode_mcu: */
+
+ /* Pointers to derived tables to be used for each block within an MCU */
+ d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+ d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
+ /* Whether we care about the DC and AC coefficient values for each block */
+ boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
+ boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder * huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_huff_decoder (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci, blkn, dctbl, actbl;
+ jpeg_component_info * compptr;
+
+ /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+ * This ought to be an error condition, but we make it a warning because
+ * there are some baseline files out there with all zeroes in these bytes.
+ */
+ if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
+ cinfo->Ah != 0 || cinfo->Al != 0)
+ WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ dctbl = compptr->dc_tbl_no;
+ actbl = compptr->ac_tbl_no;
+ /* Compute derived values for Huffman tables */
+ /* We may do this more than once for a table, but it's not expensive */
+ jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
+ & entropy->dc_derived_tbls[dctbl]);
+ jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
+ & entropy->ac_derived_tbls[actbl]);
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Precalculate decoding info for each block in an MCU of this scan */
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ /* Precalculate which table to use for each block */
+ entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+ entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+ /* Decide whether we really care about the coefficient values */
+ if (compptr->component_needed) {
+ entropy->dc_needed[blkn] = TRUE;
+ /* we don't need the ACs if producing a 1/8th-size image */
+ entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1);
+ } else {
+ entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
+ }
+ }
+
+ /* Initialize bitread state variables */
+ entropy->bitstate.bits_left = 0;
+ entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+ entropy->pub.insufficient_data = FALSE;
+
+ /* Initialize restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * This routine also performs some validation checks on the table.
+ *
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL(void)
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
+ d_derived_tbl ** pdtbl)
+{
+ JHUFF_TBL *htbl;
+ d_derived_tbl *dtbl;
+ int p, i, l, si, numsymbols;
+ int lookbits, ctr;
+ char huffsize[257];
+ unsigned int huffcode[257];
+ unsigned int code;
+
+ /* Note that huffsize[] and huffcode[] are filled in code-length order,
+ * paralleling the order of the symbols themselves in htbl->huffval[].
+ */
+
+ /* Find the input Huffman table */
+ if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+ htbl =
+ isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
+ if (htbl == NULL)
+ ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
+
+ /* Allocate a workspace if we haven't already done so. */
+ if (*pdtbl == NULL)
+ *pdtbl = (d_derived_tbl *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(d_derived_tbl));
+ dtbl = *pdtbl;
+ dtbl->pub = htbl; /* fill in back link */
+
+ /* Figure C.1: make table of Huffman code length for each symbol */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ i = (int) htbl->bits[l];
+ if (i < 0 || p + i > 256) /* protect against table overrun */
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ while (i--)
+ huffsize[p++] = (char) l;
+ }
+ huffsize[p] = 0;
+ numsymbols = p;
+
+ /* Figure C.2: generate the codes themselves */
+ /* We also validate that the counts represent a legal Huffman code tree. */
+
+ code = 0;
+ si = huffsize[0];
+ p = 0;
+ while (huffsize[p]) {
+ while (((int) huffsize[p]) == si) {
+ huffcode[p++] = code;
+ code++;
+ }
+ /* code is now 1 more than the last code used for codelength si; but
+ * it must still fit in si bits, since no code is allowed to be all ones.
+ */
+ if (((INT32) code) >= (((INT32) 1) << si))
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ code <<= 1;
+ si++;
+ }
+
+ /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+ p = 0;
+ for (l = 1; l <= 16; l++) {
+ if (htbl->bits[l]) {
+ /* valoffset[l] = huffval[] index of 1st symbol of code length l,
+ * minus the minimum code of length l
+ */
+ dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
+ p += htbl->bits[l];
+ dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
+ } else {
+ dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
+ }
+ }
+ dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+ /* Compute lookahead tables to speed up decoding.
+ * First we set all the table entries to 0, indicating "too long";
+ * then we iterate through the Huffman codes that are short enough and
+ * fill in all the entries that correspond to bit sequences starting
+ * with that code.
+ */
+
+ MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
+
+ p = 0;
+ for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+ for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
+ /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+ /* Generate left-justified code followed by all possible bit sequences */
+ lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+ for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
+ dtbl->look_nbits[lookbits] = l;
+ dtbl->look_sym[lookbits] = htbl->huffval[p];
+ lookbits++;
+ }
+ }
+ }
+
+ /* Validate symbols as being reasonable.
+ * For AC tables, we make no check, but accept all byte values 0..255.
+ * For DC tables, we require the symbols to be in range 0..15.
+ * (Tighter bounds could be applied depending on the data depth and mode,
+ * but this is sufficient to ensure safe decoding.)
+ */
+ if (isDC) {
+ for (i = 0; i < numsymbols; i++) {
+ int sym = htbl->huffval[i];
+ if (sym < 0 || sym > 15)
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+ }
+ }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used. (On machines with wider words, an even larger
+ * buffer could be used.) However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.) In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS 15 /* minimum allowable value */
+#else
+#define MIN_GET_BITS (BIT_BUF_SIZE-7)
+#endif
+
+
+GLOBAL(boolean)
+jpeg_fill_bit_buffer (bitread_working_state * state,
+ register bit_buf_type get_buffer, register int bits_left,
+ int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+ /* Copy heavily used state fields into locals (hopefully registers) */
+ register const JOCTET * next_input_byte = state->next_input_byte;
+ register size_t bytes_in_buffer = state->bytes_in_buffer;
+ j_decompress_ptr cinfo = state->cinfo;
+
+ /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+ /* (It is assumed that no request will be for more than that many bits.) */
+ /* We fail to do so only if we hit a marker or are forced to suspend. */
+
+ if (cinfo->unread_marker == 0) { /* cannot advance past a marker */
+ while (bits_left < MIN_GET_BITS) {
+ register int c;
+
+ /* Attempt to read a byte */
+ if (bytes_in_buffer == 0) {
+ if (! (*cinfo->src->fill_input_buffer) (cinfo))
+ return FALSE;
+ next_input_byte = cinfo->src->next_input_byte;
+ bytes_in_buffer = cinfo->src->bytes_in_buffer;
+ }
+ bytes_in_buffer--;
+ c = GETJOCTET(*next_input_byte++);
+
+ /* If it's 0xFF, check and discard stuffed zero byte */
+ if (c == 0xFF) {
+ /* Loop here to discard any padding FF's on terminating marker,
+ * so that we can save a valid unread_marker value. NOTE: we will
+ * accept multiple FF's followed by a 0 as meaning a single FF data
+ * byte. This data pattern is not valid according to the standard.
+ */
+ do {
+ if (bytes_in_buffer == 0) {
+ if (! (*cinfo->src->fill_input_buffer) (cinfo))
+ return FALSE;
+ next_input_byte = cinfo->src->next_input_byte;
+ bytes_in_buffer = cinfo->src->bytes_in_buffer;
+ }
+ bytes_in_buffer--;
+ c = GETJOCTET(*next_input_byte++);
+ } while (c == 0xFF);
+
+ if (c == 0) {
+ /* Found FF/00, which represents an FF data byte */
+ c = 0xFF;
+ } else {
+ /* Oops, it's actually a marker indicating end of compressed data.
+ * Save the marker code for later use.
+ * Fine point: it might appear that we should save the marker into
+ * bitread working state, not straight into permanent state. But
+ * once we have hit a marker, we cannot need to suspend within the
+ * current MCU, because we will read no more bytes from the data
+ * source. So it is OK to update permanent state right away.
+ */
+ cinfo->unread_marker = c;
+ /* See if we need to insert some fake zero bits. */
+ goto no_more_bytes;
+ }
+ }
+
+ /* OK, load c into get_buffer */
+ get_buffer = (get_buffer << 8) | c;
+ bits_left += 8;
+ } /* end while */
+ } else {
+ no_more_bytes:
+ /* We get here if we've read the marker that terminates the compressed
+ * data segment. There should be enough bits in the buffer register
+ * to satisfy the request; if so, no problem.
+ */
+ if (nbits > bits_left) {
+ /* Uh-oh. Report corrupted data to user and stuff zeroes into
+ * the data stream, so that we can produce some kind of image.
+ * We use a nonvolatile flag to ensure that only one warning message
+ * appears per data segment.
+ */
+ if (! cinfo->entropy->insufficient_data) {
+ WARNMS(cinfo, JWRN_HIT_MARKER);
+ cinfo->entropy->insufficient_data = TRUE;
+ }
+ /* Fill the buffer with zero bits */
+ get_buffer <<= MIN_GET_BITS - bits_left;
+ bits_left = MIN_GET_BITS;
+ }
+ }
+
+ /* Unload the local registers */
+ state->next_input_byte = next_input_byte;
+ state->bytes_in_buffer = bytes_in_buffer;
+ state->get_buffer = get_buffer;
+ state->bits_left = bits_left;
+
+ return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL(int)
+jpeg_huff_decode (bitread_working_state * state,
+ register bit_buf_type get_buffer, register int bits_left,
+ d_derived_tbl * htbl, int min_bits)
+{
+ register int l = min_bits;
+ register INT32 code;
+
+ /* HUFF_DECODE has determined that the code is at least min_bits */
+ /* bits long, so fetch that many bits in one swoop. */
+
+ CHECK_BIT_BUFFER(*state, l, return -1);
+ code = GET_BITS(l);
+
+ /* Collect the rest of the Huffman code one bit at a time. */
+ /* This is per Figure F.16 in the JPEG spec. */
+
+ while (code > htbl->maxcode[l]) {
+ code <<= 1;
+ CHECK_BIT_BUFFER(*state, 1, return -1);
+ code |= GET_BITS(1);
+ l++;
+ }
+
+ /* Unload the local registers */
+ state->get_buffer = get_buffer;
+ state->bits_left = bits_left;
+
+ /* With garbage input we may reach the sentinel value l = 17. */
+
+ if (l > 16) {
+ WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+ return 0; /* fake a zero as the safest result */
+ }
+
+ return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = /* entry n is 2**(n-1) */
+ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+ 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+ ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+ ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+ ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int ci;
+
+ /* Throw away any unused bits remaining in bit buffer; */
+ /* include any full bytes in next_marker's count of discarded bytes */
+ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+ entropy->bitstate.bits_left = 0;
+
+ /* Advance past the RSTn marker */
+ if (! (*cinfo->marker->read_restart_marker) (cinfo))
+ return FALSE;
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+
+ /* Reset restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+
+ /* Reset out-of-data flag, unless read_restart_marker left us smack up
+ * against a marker. In that case we will end up treating the next data
+ * segment as empty, and we can avoid producing bogus output pixels by
+ * leaving the flag set.
+ */
+ if (cinfo->unread_marker == 0)
+ entropy->pub.insufficient_data = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension. In that case no
+ * changes have been made to permanent state. (Exception: some output
+ * coefficients may already have been assigned. This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+METHODDEF(boolean)
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+ int blkn;
+ BITREAD_STATE_VARS;
+ savable_state state;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(state, entropy->saved);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ JBLOCKROW block = MCU_data[blkn];
+ d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
+ d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
+ register int s, k, r;
+
+ /* Decode a single block's worth of coefficients */
+
+ /* Section F.2.2.1: decode the DC coefficient difference */
+ HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+ if (s) {
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ }
+
+ if (entropy->dc_needed[blkn]) {
+ /* Convert DC difference to actual value, update last_dc_val */
+ int ci = cinfo->MCU_membership[blkn];
+ s += state.last_dc_val[ci];
+ state.last_dc_val[ci] = s;
+ /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+ (*block)[0] = (JCOEF) s;
+ }
+
+ if (entropy->ac_needed[blkn]) {
+
+ /* Section F.2.2.2: decode the AC coefficients */
+ /* Since zeroes are skipped, output area must be cleared beforehand */
+ for (k = 1; k < DCTSIZE2; k++) {
+ HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+
+ r = s >> 4;
+ s &= 15;
+
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ /* Output coefficient in natural (dezigzagged) order.
+ * Note: the extra entries in jpeg_natural_order[] will save us
+ * if k >= DCTSIZE2, which could happen if the data is corrupted.
+ */
+ (*block)[jpeg_natural_order[k]] = (JCOEF) s;
+ } else {
+ if (r != 15)
+ break;
+ k += 15;
+ }
+ }
+
+ } else {
+
+ /* Section F.2.2.2: decode the AC coefficients */
+ /* In this path we just discard the values */
+ for (k = 1; k < DCTSIZE2; k++) {
+ HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+
+ r = s >> 4;
+ s &= 15;
+
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ DROP_BITS(s);
+ } else {
+ if (r != 15)
+ break;
+ k += 15;
+ }
+ }
+
+ }
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(entropy->saved, state);
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_huff_decoder (j_decompress_ptr cinfo)
+{
+ huff_entropy_ptr entropy;
+ int i;
+
+ entropy = (huff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(huff_entropy_decoder));
+ cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+ entropy->pub.start_pass = start_pass_huff_decoder;
+ entropy->pub.decode_mcu = decode_mcu;
+
+ /* Mark tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+ }
+}
--- /dev/null
+/*
+ * jdhuff.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c). No other modules need to see these.
+ */
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_d_derived_tbl jMkDDerived
+#define jpeg_fill_bit_buffer jFilBitBuf
+#define jpeg_huff_decode jHufDecode
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD 8 /* # of bits of lookahead */
+
+typedef struct {
+ /* Basic tables: (element [0] of each array is unused) */
+ INT32 maxcode[18]; /* largest code of length k (-1 if none) */
+ /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+ INT32 valoffset[17]; /* huffval[] offset for codes of length k */
+ /* valoffset[k] = huffval[] index of 1st symbol of code length k, less
+ * the smallest code of length k; so given a code of length k, the
+ * corresponding symbol is huffval[code + valoffset[k]]
+ */
+
+ /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+ JHUFF_TBL *pub;
+
+ /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
+ * the input data stream. If the next Huffman code is no more
+ * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+ * the corresponding symbol directly from these tables.
+ */
+ int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
+ UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN(void) jpeg_make_d_derived_tbl
+ JPP((j_decompress_ptr cinfo, boolean isDC, int tblno,
+ d_derived_tbl ** pdtbl));
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders. We implement it with a combination of inline
+ * macros and out-of-line subroutines. Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS. When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+typedef INT32 bit_buf_type; /* type of bit-extraction buffer */
+#define BIT_BUF_SIZE 32 /* size of buffer in bits */
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win. Unfortunately we can't define the size
+ * with something like #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct { /* Bitreading state saved across MCUs */
+ bit_buf_type get_buffer; /* current bit-extraction buffer */
+ int bits_left; /* # of unused bits in it */
+} bitread_perm_state;
+
+typedef struct { /* Bitreading working state within an MCU */
+ /* Current data source location */
+ /* We need a copy, rather than munging the original, in case of suspension */
+ const JOCTET * next_input_byte; /* => next byte to read from source */
+ size_t bytes_in_buffer; /* # of bytes remaining in source buffer */
+ /* Bit input buffer --- note these values are kept in register variables,
+ * not in this struct, inside the inner loops.
+ */
+ bit_buf_type get_buffer; /* current bit-extraction buffer */
+ int bits_left; /* # of unused bits in it */
+ /* Pointer needed by jpeg_fill_bit_buffer. */
+ j_decompress_ptr cinfo; /* back link to decompress master record */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS \
+ register bit_buf_type get_buffer; \
+ register int bits_left; \
+ bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop,permstate) \
+ br_state.cinfo = cinfop; \
+ br_state.next_input_byte = cinfop->src->next_input_byte; \
+ br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+ get_buffer = permstate.get_buffer; \
+ bits_left = permstate.bits_left;
+
+#define BITREAD_SAVE_STATE(cinfop,permstate) \
+ cinfop->src->next_input_byte = br_state.next_input_byte; \
+ cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+ permstate.get_buffer = get_buffer; \
+ permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ * CHECK_BIT_BUFFER(state,n,action);
+ * Ensure there are N bits in get_buffer; if suspend, take action.
+ * val = GET_BITS(n);
+ * Fetch next N bits.
+ * val = PEEK_BITS(n);
+ * Fetch next N bits without removing them from the buffer.
+ * DROP_BITS(n);
+ * Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+ { if (bits_left < (nbits)) { \
+ if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits)) \
+ { action; } \
+ get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
+
+#define GET_BITS(nbits) \
+ (((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))
+
+#define PEEK_BITS(nbits) \
+ (((int) (get_buffer >> (bits_left - (nbits)))) & ((1<<(nbits))-1))
+
+#define DROP_BITS(nbits) \
+ (bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN(boolean) jpeg_fill_bit_buffer
+ JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+ register int bits_left, int nbits));
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping. Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long. The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ * for a lookahead. In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ * more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
+ if (bits_left < HUFF_LOOKAHEAD) { \
+ if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+ get_buffer = state.get_buffer; bits_left = state.bits_left; \
+ if (bits_left < HUFF_LOOKAHEAD) { \
+ nb = 1; goto slowlabel; \
+ } \
+ } \
+ look = PEEK_BITS(HUFF_LOOKAHEAD); \
+ if ((nb = htbl->look_nbits[look]) != 0) { \
+ DROP_BITS(nb); \
+ result = htbl->look_sym[look]; \
+ } else { \
+ nb = HUFF_LOOKAHEAD+1; \
+slowlabel: \
+ if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+ { failaction; } \
+ get_buffer = state.get_buffer; bits_left = state.bits_left; \
+ } \
+}
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN(int) jpeg_huff_decode
+ JPP((bitread_working_state * state, register bit_buf_type get_buffer,
+ register int bits_left, d_derived_tbl * htbl, int min_bits));
--- /dev/null
+/*
+ * jdinput.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding). The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_input_controller pub; /* public fields */
+
+ boolean inheaders; /* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller * my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF(int) consume_markers JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL(void)
+initial_setup (j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+ int ci;
+ jpeg_component_info *compptr;
+
+ /* Make sure image isn't bigger than I can handle */
+ if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+ (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+ ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+ /* For now, precision must match compiled-in value... */
+ if (cinfo->data_precision != BITS_IN_JSAMPLE)
+ ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+ /* Check that number of components won't exceed internal array sizes */
+ if (cinfo->num_components > MAX_COMPONENTS)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+ MAX_COMPONENTS);
+
+ /* Compute maximum sampling factors; check factor validity */
+ cinfo->max_h_samp_factor = 1;
+ cinfo->max_v_samp_factor = 1;
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+ compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+ ERREXIT(cinfo, JERR_BAD_SAMPLING);
+ cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+ compptr->h_samp_factor);
+ cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+ compptr->v_samp_factor);
+ }
+
+ /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+ * In the full decompressor, this will be overridden by jdmaster.c;
+ * but in the transcoder, jdmaster.c is not used, so we must do it here.
+ */
+ cinfo->min_DCT_scaled_size = DCTSIZE;
+
+ /* Compute dimensions of components */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ compptr->DCT_scaled_size = DCTSIZE;
+ /* Size in DCT blocks */
+ compptr->width_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->height_in_blocks = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ /* downsampled_width and downsampled_height will also be overridden by
+ * jdmaster.c if we are doing full decompression. The transcoder library
+ * doesn't use these values, but the calling application might.
+ */
+ /* Size in samples */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+ (long) cinfo->max_h_samp_factor);
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+ (long) cinfo->max_v_samp_factor);
+ /* Mark component needed, until color conversion says otherwise */
+ compptr->component_needed = TRUE;
+ /* Mark no quantization table yet saved for component */
+ compptr->quant_table = NULL;
+ }
+
+ /* Compute number of fully interleaved MCU rows. */
+ cinfo->total_iMCU_rows = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ /* Decide whether file contains multiple scans */
+ if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+ cinfo->inputctl->has_multiple_scans = TRUE;
+ else
+ cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL(void)
+per_scan_setup (j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+ int ci, mcublks, tmp;
+ jpeg_component_info *compptr;
+
+ if (cinfo->comps_in_scan == 1) {
+
+ /* Noninterleaved (single-component) scan */
+ compptr = cinfo->cur_comp_info[0];
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = compptr->width_in_blocks;
+ cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+
+ /* For noninterleaved scan, always one block per MCU */
+ compptr->MCU_width = 1;
+ compptr->MCU_height = 1;
+ compptr->MCU_blocks = 1;
+ compptr->MCU_sample_width = compptr->DCT_scaled_size;
+ compptr->last_col_width = 1;
+ /* For noninterleaved scans, it is convenient to define last_row_height
+ * as the number of block rows present in the last iMCU row.
+ */
+ tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+ if (tmp == 0) tmp = compptr->v_samp_factor;
+ compptr->last_row_height = tmp;
+
+ /* Prepare array describing MCU composition */
+ cinfo->blocks_in_MCU = 1;
+ cinfo->MCU_membership[0] = 0;
+
+ } else {
+
+ /* Interleaved (multi-component) scan */
+ if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+ ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+ MAX_COMPS_IN_SCAN);
+
+ /* Overall image size in MCUs */
+ cinfo->MCUs_per_row = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width,
+ (long) (cinfo->max_h_samp_factor*DCTSIZE));
+ cinfo->MCU_rows_in_scan = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height,
+ (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+ cinfo->blocks_in_MCU = 0;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Sampling factors give # of blocks of component in each MCU */
+ compptr->MCU_width = compptr->h_samp_factor;
+ compptr->MCU_height = compptr->v_samp_factor;
+ compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+ compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
+ /* Figure number of non-dummy blocks in last MCU column & row */
+ tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+ if (tmp == 0) tmp = compptr->MCU_width;
+ compptr->last_col_width = tmp;
+ tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+ if (tmp == 0) tmp = compptr->MCU_height;
+ compptr->last_row_height = tmp;
+ /* Prepare array describing MCU composition */
+ mcublks = compptr->MCU_blocks;
+ if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+ ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+ while (mcublks-- > 0) {
+ cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+ }
+ }
+
+ }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table. (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.) Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot. If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL(void)
+latch_quant_tables (j_decompress_ptr cinfo)
+{
+ int ci, qtblno;
+ jpeg_component_info *compptr;
+ JQUANT_TBL * qtbl;
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* No work if we already saved Q-table for this component */
+ if (compptr->quant_table != NULL)
+ continue;
+ /* Make sure specified quantization table is present */
+ qtblno = compptr->quant_tbl_no;
+ if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+ cinfo->quant_tbl_ptrs[qtblno] == NULL)
+ ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+ /* OK, save away the quantization table */
+ qtbl = (JQUANT_TBL *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(JQUANT_TBL));
+ MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
+ compptr->quant_table = qtbl;
+ }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF(void)
+start_input_pass (j_decompress_ptr cinfo)
+{
+ per_scan_setup(cinfo);
+ latch_quant_tables(cinfo);
+ (*cinfo->entropy->start_pass) (cinfo);
+ (*cinfo->coef->start_input_pass) (cinfo);
+ cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF(void)
+finish_input_pass (j_decompress_ptr cinfo)
+{
+ cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF(int)
+consume_markers (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+ int val;
+
+ if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+ return JPEG_REACHED_EOI;
+
+ val = (*cinfo->marker->read_markers) (cinfo);
+
+ switch (val) {
+ case JPEG_REACHED_SOS: /* Found SOS */
+ if (inputctl->inheaders) { /* 1st SOS */
+ initial_setup(cinfo);
+ inputctl->inheaders = FALSE;
+ /* Note: start_input_pass must be called by jdmaster.c
+ * before any more input can be consumed. jdapimin.c is
+ * responsible for enforcing this sequencing.
+ */
+ } else { /* 2nd or later SOS marker */
+ if (! inputctl->pub.has_multiple_scans)
+ ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+ start_input_pass(cinfo);
+ }
+ break;
+ case JPEG_REACHED_EOI: /* Found EOI */
+ inputctl->pub.eoi_reached = TRUE;
+ if (inputctl->inheaders) { /* Tables-only datastream, apparently */
+ if (cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOF_NO_SOS);
+ } else {
+ /* Prevent infinite loop in coef ctlr's decompress_data routine
+ * if user set output_scan_number larger than number of scans.
+ */
+ if (cinfo->output_scan_number > cinfo->input_scan_number)
+ cinfo->output_scan_number = cinfo->input_scan_number;
+ }
+ break;
+ case JPEG_SUSPENDED:
+ break;
+ }
+
+ return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_input_controller (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+
+ inputctl->pub.consume_input = consume_markers;
+ inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+ inputctl->pub.eoi_reached = FALSE;
+ inputctl->inheaders = TRUE;
+ /* Reset other modules */
+ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+ (*cinfo->marker->reset_marker_reader) (cinfo);
+ /* Reset progression state -- would be cleaner if entropy decoder did this */
+ cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_input_controller (j_decompress_ptr cinfo)
+{
+ my_inputctl_ptr inputctl;
+
+ /* Create subobject in permanent pool */
+ inputctl = (my_inputctl_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_input_controller));
+ cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
+ /* Initialize method pointers */
+ inputctl->pub.consume_input = consume_markers;
+ inputctl->pub.reset_input_controller = reset_input_controller;
+ inputctl->pub.start_input_pass = start_input_pass;
+ inputctl->pub.finish_input_pass = finish_input_pass;
+ /* Initialize state: can't use reset_input_controller since we don't
+ * want to try to reset other modules yet.
+ */
+ inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+ inputctl->pub.eoi_reached = FALSE;
+ inputctl->inheaders = TRUE;
+}
--- /dev/null
+/*
+ * jdmainct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers. Nonetheless, the main controller is not
+ * trivial. Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups". A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component. (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers. In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups. (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.) Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not. Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so. When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed. Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer. At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with. The existing
+ * upsamplers really only need one sample row of context. An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row. (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow. We can avoid copying any data by creating a rather
+ * strange pointer structure. Here's how it works. We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row). We create two sets of redundant pointers to
+ * the workspace. Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ * M+1 M-1
+ * master pointer --> 0 master pointer --> 0
+ * 1 1
+ * ... ...
+ * M-3 M-3
+ * M-2 M
+ * M-1 M+1
+ * M M-2
+ * M+1 M-1
+ * 0 0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1. In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group). For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1. That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_main_controller pub; /* public fields */
+
+ /* Pointer to allocated workspace (M or M+2 row groups). */
+ JSAMPARRAY buffer[MAX_COMPONENTS];
+
+ boolean buffer_full; /* Have we gotten an iMCU row from decoder? */
+ JDIMENSION rowgroup_ctr; /* counts row groups output to postprocessor */
+
+ /* Remaining fields are only used in the context case. */
+
+ /* These are the master pointers to the funny-order pointer lists. */
+ JSAMPIMAGE xbuffer[2]; /* pointers to weird pointer lists */
+
+ int whichptr; /* indicates which pointer set is now in use */
+ int context_state; /* process_data state machine status */
+ JDIMENSION rowgroups_avail; /* row groups available to postprocessor */
+ JDIMENSION iMCU_row_ctr; /* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU 0 /* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU 1 /* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW 2 /* feeding postponed row group */
+
+
+/* Forward declarations */
+METHODDEF(void) process_data_simple_main
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+METHODDEF(void) process_data_context_main
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) process_data_crank_post
+ JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#endif
+
+
+LOCAL(void)
+alloc_funny_pointers (j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf;
+
+ /* Get top-level space for component array pointers.
+ * We alloc both arrays with one call to save a few cycles.
+ */
+ main->xbuffer[0] = (JSAMPIMAGE)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+ main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ /* Get space for pointer lists --- M+4 row groups in each list.
+ * We alloc both pointer lists with one call to save a few cycles.
+ */
+ xbuf = (JSAMPARRAY)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ 2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
+ xbuf += rgroup; /* want one row group at negative offsets */
+ main->xbuffer[0][ci] = xbuf;
+ xbuf += rgroup * (M + 4);
+ main->xbuffer[1][ci] = xbuf;
+ }
+}
+
+
+LOCAL(void)
+make_funny_pointers (j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY buf, xbuf0, xbuf1;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ xbuf0 = main->xbuffer[0][ci];
+ xbuf1 = main->xbuffer[1][ci];
+ /* First copy the workspace pointers as-is */
+ buf = main->buffer[ci];
+ for (i = 0; i < rgroup * (M + 2); i++) {
+ xbuf0[i] = xbuf1[i] = buf[i];
+ }
+ /* In the second list, put the last four row groups in swapped order */
+ for (i = 0; i < rgroup * 2; i++) {
+ xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+ xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
+ }
+ /* The wraparound pointers at top and bottom will be filled later
+ * (see set_wraparound_pointers, below). Initially we want the "above"
+ * pointers to duplicate the first actual data line. This only needs
+ * to happen in xbuffer[0].
+ */
+ for (i = 0; i < rgroup; i++) {
+ xbuf0[i - rgroup] = xbuf0[0];
+ }
+ }
+}
+
+
+LOCAL(void)
+set_wraparound_pointers (j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup;
+ int M = cinfo->min_DCT_scaled_size;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf0, xbuf1;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ xbuf0 = main->xbuffer[0][ci];
+ xbuf1 = main->xbuffer[1][ci];
+ for (i = 0; i < rgroup; i++) {
+ xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+ xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+ xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+ xbuf1[rgroup*(M+2) + i] = xbuf1[i];
+ }
+ }
+}
+
+
+LOCAL(void)
+set_bottom_pointers (j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image. whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ int ci, i, rgroup, iMCUheight, rows_left;
+ jpeg_component_info *compptr;
+ JSAMPARRAY xbuf;
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Count sample rows in one iMCU row and in one row group */
+ iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
+ rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
+ /* Count nondummy sample rows remaining for this component */
+ rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+ if (rows_left == 0) rows_left = iMCUheight;
+ /* Count nondummy row groups. Should get same answer for each component,
+ * so we need only do it once.
+ */
+ if (ci == 0) {
+ main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
+ }
+ /* Duplicate the last real sample row rgroup*2 times; this pads out the
+ * last partial rowgroup and ensures at least one full rowgroup of context.
+ */
+ xbuf = main->xbuffer[main->whichptr][ci];
+ for (i = 0; i < rgroup * 2; i++) {
+ xbuf[rows_left + i] = xbuf[rows_left-1];
+ }
+ }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (cinfo->upsample->need_context_rows) {
+ main->pub.process_data = process_data_context_main;
+ make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+ main->whichptr = 0; /* Read first iMCU row into xbuffer[0] */
+ main->context_state = CTX_PREPARE_FOR_IMCU;
+ main->iMCU_row_ctr = 0;
+ } else {
+ /* Simple case with no context needed */
+ main->pub.process_data = process_data_simple_main;
+ }
+ main->buffer_full = FALSE; /* Mark buffer empty */
+ main->rowgroup_ctr = 0;
+ break;
+#ifdef QUANT_2PASS_SUPPORTED
+ case JBUF_CRANK_DEST:
+ /* For last pass of 2-pass quantization, just crank the postprocessor */
+ main->pub.process_data = process_data_crank_post;
+ break;
+#endif
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF(void)
+process_data_simple_main (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+ JDIMENSION rowgroups_avail;
+
+ /* Read input data if we haven't filled the main buffer yet */
+ if (! main->buffer_full) {
+ if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))
+ return; /* suspension forced, can do nothing more */
+ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */
+ }
+
+ /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+ rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
+ /* Note: at the bottom of the image, we may pass extra garbage row groups
+ * to the postprocessor. The postprocessor has to check for bottom
+ * of image anyway (at row resolution), so no point in us doing it too.
+ */
+
+ /* Feed the postprocessor */
+ (*cinfo->post->post_process_data) (cinfo, main->buffer,
+ &main->rowgroup_ctr, rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+
+ /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+ if (main->rowgroup_ctr >= rowgroups_avail) {
+ main->buffer_full = FALSE;
+ main->rowgroup_ctr = 0;
+ }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF(void)
+process_data_context_main (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_main_ptr main = (my_main_ptr) cinfo->main;
+
+ /* Read input data if we haven't filled the main buffer yet */
+ if (! main->buffer_full) {
+ if (! (*cinfo->coef->decompress_data) (cinfo,
+ main->xbuffer[main->whichptr]))
+ return; /* suspension forced, can do nothing more */
+ main->buffer_full = TRUE; /* OK, we have an iMCU row to work with */
+ main->iMCU_row_ctr++; /* count rows received */
+ }
+
+ /* Postprocessor typically will not swallow all the input data it is handed
+ * in one call (due to filling the output buffer first). Must be prepared
+ * to exit and restart. This switch lets us keep track of how far we got.
+ * Note that each case falls through to the next on successful completion.
+ */
+ switch (main->context_state) {
+ case CTX_POSTPONED_ROW:
+ /* Call postprocessor using previously set pointers for postponed row */
+ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+ &main->rowgroup_ctr, main->rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+ if (main->rowgroup_ctr < main->rowgroups_avail)
+ return; /* Need to suspend */
+ main->context_state = CTX_PREPARE_FOR_IMCU;
+ if (*out_row_ctr >= out_rows_avail)
+ return; /* Postprocessor exactly filled output buf */
+ /*FALLTHROUGH*/
+ case CTX_PREPARE_FOR_IMCU:
+ /* Prepare to process first M-1 row groups of this iMCU row */
+ main->rowgroup_ctr = 0;
+ main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
+ /* Check for bottom of image: if so, tweak pointers to "duplicate"
+ * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+ */
+ if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)
+ set_bottom_pointers(cinfo);
+ main->context_state = CTX_PROCESS_IMCU;
+ /*FALLTHROUGH*/
+ case CTX_PROCESS_IMCU:
+ /* Call postprocessor using previously set pointers */
+ (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
+ &main->rowgroup_ctr, main->rowgroups_avail,
+ output_buf, out_row_ctr, out_rows_avail);
+ if (main->rowgroup_ctr < main->rowgroups_avail)
+ return; /* Need to suspend */
+ /* After the first iMCU, change wraparound pointers to normal state */
+ if (main->iMCU_row_ctr == 1)
+ set_wraparound_pointers(cinfo);
+ /* Prepare to load new iMCU row using other xbuffer list */
+ main->whichptr ^= 1; /* 0=>1 or 1=>0 */
+ main->buffer_full = FALSE;
+ /* Still need to process last row group of this iMCU row, */
+ /* which is saved at index M+1 of the other xbuffer */
+ main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
+ main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
+ main->context_state = CTX_POSTPONED_ROW;
+ }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF(void)
+process_data_crank_post (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+ (JDIMENSION *) NULL, (JDIMENSION) 0,
+ output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL(void)
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_main_ptr main;
+ int ci, rgroup, ngroups;
+ jpeg_component_info *compptr;
+
+ main = (my_main_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_main_controller));
+ cinfo->main = (struct jpeg_d_main_controller *) main;
+ main->pub.start_pass = start_pass_main;
+
+ if (need_full_buffer) /* shouldn't happen */
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+ /* Allocate the workspace.
+ * ngroups is the number of row groups we need.
+ */
+ if (cinfo->upsample->need_context_rows) {
+ if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
+ ERREXIT(cinfo, JERR_NOTIMPL);
+ alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+ ngroups = cinfo->min_DCT_scaled_size + 2;
+ } else {
+ ngroups = cinfo->min_DCT_scaled_size;
+ }
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size; /* height of a row group of component */
+ main->buffer[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ compptr->width_in_blocks * compptr->DCT_scaled_size,
+ (JDIMENSION) (rgroup * ngroups));
+ }
+}
--- /dev/null
+/*
+ * jdmarker.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application. On resumption, we reprocess
+ * the marker.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum { /* JPEG marker codes */
+ M_SOF0 = 0xc0,
+ M_SOF1 = 0xc1,
+ M_SOF2 = 0xc2,
+ M_SOF3 = 0xc3,
+
+ M_SOF5 = 0xc5,
+ M_SOF6 = 0xc6,
+ M_SOF7 = 0xc7,
+
+ M_JPG = 0xc8,
+ M_SOF9 = 0xc9,
+ M_SOF10 = 0xca,
+ M_SOF11 = 0xcb,
+
+ M_SOF13 = 0xcd,
+ M_SOF14 = 0xce,
+ M_SOF15 = 0xcf,
+
+ M_DHT = 0xc4,
+
+ M_DAC = 0xcc,
+
+ M_RST0 = 0xd0,
+ M_RST1 = 0xd1,
+ M_RST2 = 0xd2,
+ M_RST3 = 0xd3,
+ M_RST4 = 0xd4,
+ M_RST5 = 0xd5,
+ M_RST6 = 0xd6,
+ M_RST7 = 0xd7,
+
+ M_SOI = 0xd8,
+ M_EOI = 0xd9,
+ M_SOS = 0xda,
+ M_DQT = 0xdb,
+ M_DNL = 0xdc,
+ M_DRI = 0xdd,
+ M_DHP = 0xde,
+ M_EXP = 0xdf,
+
+ M_APP0 = 0xe0,
+ M_APP1 = 0xe1,
+ M_APP2 = 0xe2,
+ M_APP3 = 0xe3,
+ M_APP4 = 0xe4,
+ M_APP5 = 0xe5,
+ M_APP6 = 0xe6,
+ M_APP7 = 0xe7,
+ M_APP8 = 0xe8,
+ M_APP9 = 0xe9,
+ M_APP10 = 0xea,
+ M_APP11 = 0xeb,
+ M_APP12 = 0xec,
+ M_APP13 = 0xed,
+ M_APP14 = 0xee,
+ M_APP15 = 0xef,
+
+ M_JPG0 = 0xf0,
+ M_JPG13 = 0xfd,
+ M_COM = 0xfe,
+
+ M_TEM = 0x01,
+
+ M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_marker_reader pub; /* public fields */
+
+ /* Application-overridable marker processing methods */
+ jpeg_marker_parser_method process_COM;
+ jpeg_marker_parser_method process_APPn[16];
+
+ /* Limit on marker data length to save for each marker type */
+ unsigned int length_limit_COM;
+ unsigned int length_limit_APPn[16];
+
+ /* Status of COM/APPn marker saving */
+ jpeg_saved_marker_ptr cur_marker; /* NULL if not processing a marker */
+ unsigned int bytes_read; /* data bytes read so far in marker */
+ /* Note: cur_marker is not linked into marker_list until it's all read. */
+} my_marker_reader;
+
+typedef my_marker_reader * my_marker_ptr;
+
+
+/*
+ * Macros for fetching data from the data source module.
+ *
+ * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
+ * the current restart point; we update them only when we have reached a
+ * suitable place to restart if a suspension occurs.
+ */
+
+/* Declare and initialize local copies of input pointer/count */
+#define INPUT_VARS(cinfo) \
+ struct jpeg_source_mgr * datasrc = (cinfo)->src; \
+ const JOCTET * next_input_byte = datasrc->next_input_byte; \
+ size_t bytes_in_buffer = datasrc->bytes_in_buffer
+
+/* Unload the local copies --- do this only at a restart boundary */
+#define INPUT_SYNC(cinfo) \
+ ( datasrc->next_input_byte = next_input_byte, \
+ datasrc->bytes_in_buffer = bytes_in_buffer )
+
+/* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
+#define INPUT_RELOAD(cinfo) \
+ ( next_input_byte = datasrc->next_input_byte, \
+ bytes_in_buffer = datasrc->bytes_in_buffer )
+
+/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
+ * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
+ * but we must reload the local copies after a successful fill.
+ */
+#define MAKE_BYTE_AVAIL(cinfo,action) \
+ if (bytes_in_buffer == 0) { \
+ if (! (*datasrc->fill_input_buffer) (cinfo)) \
+ { action; } \
+ INPUT_RELOAD(cinfo); \
+ }
+
+/* Read a byte into variable V.
+ * If must suspend, take the specified action (typically "return FALSE").
+ */
+#define INPUT_BYTE(cinfo,V,action) \
+ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V = GETJOCTET(*next_input_byte++); )
+
+/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
+ * V should be declared unsigned int or perhaps INT32.
+ */
+#define INPUT_2BYTES(cinfo,V,action) \
+ MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
+ MAKE_BYTE_AVAIL(cinfo,action); \
+ bytes_in_buffer--; \
+ V += GETJOCTET(*next_input_byte++); )
+
+
+/*
+ * Routines to process JPEG markers.
+ *
+ * Entry condition: JPEG marker itself has been read and its code saved
+ * in cinfo->unread_marker; input restart point is just after the marker.
+ *
+ * Exit: if return TRUE, have read and processed any parameters, and have
+ * updated the restart point to point after the parameters.
+ * If return FALSE, was forced to suspend before reaching end of
+ * marker parameters; restart point has not been moved. Same routine
+ * will be called again after application supplies more input data.
+ *
+ * This approach to suspension assumes that all of a marker's parameters
+ * can fit into a single input bufferload. This should hold for "normal"
+ * markers. Some COM/APPn markers might have large parameter segments
+ * that might not fit. If we are simply dropping such a marker, we use
+ * skip_input_data to get past it, and thereby put the problem on the
+ * source manager's shoulders. If we are saving the marker's contents
+ * into memory, we use a slightly different convention: when forced to
+ * suspend, the marker processor updates the restart point to the end of
+ * what it's consumed (ie, the end of the buffer) before returning FALSE.
+ * On resumption, cinfo->unread_marker still contains the marker code,
+ * but the data source will point to the next chunk of marker data.
+ * The marker processor must retain internal state to deal with this.
+ *
+ * Note that we don't bother to avoid duplicate trace messages if a
+ * suspension occurs within marker parameters. Other side effects
+ * require more care.
+ */
+
+
+LOCAL(boolean)
+get_soi (j_decompress_ptr cinfo)
+/* Process an SOI marker */
+{
+ int i;
+
+ TRACEMS(cinfo, 1, JTRC_SOI);
+
+ if (cinfo->marker->saw_SOI)
+ ERREXIT(cinfo, JERR_SOI_DUPLICATE);
+
+ /* Reset all parameters that are defined to be reset by SOI */
+
+ for (i = 0; i < NUM_ARITH_TBLS; i++) {
+ cinfo->arith_dc_L[i] = 0;
+ cinfo->arith_dc_U[i] = 1;
+ cinfo->arith_ac_K[i] = 5;
+ }
+ cinfo->restart_interval = 0;
+
+ /* Set initial assumptions for colorspace etc */
+
+ cinfo->jpeg_color_space = JCS_UNKNOWN;
+ cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
+
+ cinfo->saw_JFIF_marker = FALSE;
+ cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
+ cinfo->JFIF_minor_version = 1;
+ cinfo->density_unit = 0;
+ cinfo->X_density = 1;
+ cinfo->Y_density = 1;
+ cinfo->saw_Adobe_marker = FALSE;
+ cinfo->Adobe_transform = 0;
+
+ cinfo->marker->saw_SOI = TRUE;
+
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+/* Process a SOFn marker */
+{
+ INT32 length;
+ int c, ci;
+ jpeg_component_info * compptr;
+ INPUT_VARS(cinfo);
+
+ cinfo->progressive_mode = is_prog;
+ cinfo->arith_code = is_arith;
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
+ INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
+ INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
+ INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
+
+ length -= 8;
+
+ TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
+ (int) cinfo->image_width, (int) cinfo->image_height,
+ cinfo->num_components);
+
+ if (cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOF_DUPLICATE);
+
+ /* We don't support files in which the image height is initially specified */
+ /* as 0 and is later redefined by DNL. As long as we have to check that, */
+ /* might as well have a general sanity check. */
+ if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+ || cinfo->num_components <= 0)
+ ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+ if (length != (cinfo->num_components * 3))
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ if (cinfo->comp_info == NULL) /* do only once, even if suspend */
+ cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components * SIZEOF(jpeg_component_info));
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ compptr->component_index = ci;
+ INPUT_BYTE(cinfo, compptr->component_id, return FALSE);
+ INPUT_BYTE(cinfo, c, return FALSE);
+ compptr->h_samp_factor = (c >> 4) & 15;
+ compptr->v_samp_factor = (c ) & 15;
+ INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
+
+ TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
+ compptr->component_id, compptr->h_samp_factor,
+ compptr->v_samp_factor, compptr->quant_tbl_no);
+ }
+
+ cinfo->marker->saw_SOF = TRUE;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_sos (j_decompress_ptr cinfo)
+/* Process a SOS marker */
+{
+ INT32 length;
+ int i, ci, n, c, cc;
+ jpeg_component_info * compptr;
+ INPUT_VARS(cinfo);
+
+ if (! cinfo->marker->saw_SOF)
+ ERREXIT(cinfo, JERR_SOS_NO_SOF);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
+
+ TRACEMS1(cinfo, 1, JTRC_SOS, n);
+
+ if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ cinfo->comps_in_scan = n;
+
+ /* Collect the component-spec parameters */
+
+ for (i = 0; i < n; i++) {
+ INPUT_BYTE(cinfo, cc, return FALSE);
+ INPUT_BYTE(cinfo, c, return FALSE);
+
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ if (cc == compptr->component_id)
+ goto id_found;
+ }
+
+ ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+
+ id_found:
+
+ cinfo->cur_comp_info[i] = compptr;
+ compptr->dc_tbl_no = (c >> 4) & 15;
+ compptr->ac_tbl_no = (c ) & 15;
+
+ TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
+ compptr->dc_tbl_no, compptr->ac_tbl_no);
+ }
+
+ /* Collect the additional scan parameters Ss, Se, Ah/Al. */
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Ss = c;
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Se = c;
+ INPUT_BYTE(cinfo, c, return FALSE);
+ cinfo->Ah = (c >> 4) & 15;
+ cinfo->Al = (c ) & 15;
+
+ TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
+ cinfo->Ah, cinfo->Al);
+
+ /* Prepare to scan data & restart markers */
+ cinfo->marker->next_restart_num = 0;
+
+ /* Count another SOS marker */
+ cinfo->input_scan_number++;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+#ifdef D_ARITH_CODING_SUPPORTED
+
+LOCAL(boolean)
+get_dac (j_decompress_ptr cinfo)
+/* Process a DAC marker */
+{
+ INT32 length;
+ int index, val;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 0) {
+ INPUT_BYTE(cinfo, index, return FALSE);
+ INPUT_BYTE(cinfo, val, return FALSE);
+
+ length -= 2;
+
+ TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
+
+ if (index < 0 || index >= (2*NUM_ARITH_TBLS))
+ ERREXIT1(cinfo, JERR_DAC_INDEX, index);
+
+ if (index >= NUM_ARITH_TBLS) { /* define AC table */
+ cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
+ } else { /* define DC table */
+ cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
+ cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
+ if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+ ERREXIT1(cinfo, JERR_DAC_VALUE, val);
+ }
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+#else /* ! D_ARITH_CODING_SUPPORTED */
+
+#define get_dac(cinfo) skip_variable(cinfo)
+
+#endif /* D_ARITH_CODING_SUPPORTED */
+
+
+LOCAL(boolean)
+get_dht (j_decompress_ptr cinfo)
+/* Process a DHT marker */
+{
+ INT32 length;
+ UINT8 bits[17];
+ UINT8 huffval[256];
+ int i, index, count;
+ JHUFF_TBL **htblptr;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 16) {
+ INPUT_BYTE(cinfo, index, return FALSE);
+
+ TRACEMS1(cinfo, 1, JTRC_DHT, index);
+
+ bits[0] = 0;
+ count = 0;
+ for (i = 1; i <= 16; i++) {
+ INPUT_BYTE(cinfo, bits[i], return FALSE);
+ count += bits[i];
+ }
+
+ length -= 1 + 16;
+
+ TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+ bits[1], bits[2], bits[3], bits[4],
+ bits[5], bits[6], bits[7], bits[8]);
+ TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+ bits[9], bits[10], bits[11], bits[12],
+ bits[13], bits[14], bits[15], bits[16]);
+
+ /* Here we just do minimal validation of the counts to avoid walking
+ * off the end of our table space. jdhuff.c will check more carefully.
+ */
+ if (count > 256 || ((INT32) count) > length)
+ ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
+
+ for (i = 0; i < count; i++)
+ INPUT_BYTE(cinfo, huffval[i], return FALSE);
+
+ length -= count;
+
+ if (index & 0x10) { /* AC table definition */
+ index -= 0x10;
+ htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+ } else { /* DC table definition */
+ htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+ }
+
+ if (index < 0 || index >= NUM_HUFF_TBLS)
+ ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+
+ if (*htblptr == NULL)
+ *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+
+ MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+ MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dqt (j_decompress_ptr cinfo)
+/* Process a DQT marker */
+{
+ INT32 length;
+ int n, i, prec;
+ unsigned int tmp;
+ JQUANT_TBL *quant_ptr;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ while (length > 0) {
+ INPUT_BYTE(cinfo, n, return FALSE);
+ prec = n >> 4;
+ n &= 0x0F;
+
+ TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
+
+ if (n >= NUM_QUANT_TBLS)
+ ERREXIT1(cinfo, JERR_DQT_INDEX, n);
+
+ if (cinfo->quant_tbl_ptrs[n] == NULL)
+ cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+ quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+ for (i = 0; i < DCTSIZE2; i++) {
+ if (prec)
+ INPUT_2BYTES(cinfo, tmp, return FALSE);
+ else
+ INPUT_BYTE(cinfo, tmp, return FALSE);
+ /* We convert the zigzag-order table to natural array order. */
+ quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp;
+ }
+
+ if (cinfo->err->trace_level >= 2) {
+ for (i = 0; i < DCTSIZE2; i += 8) {
+ TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
+ quant_ptr->quantval[i], quant_ptr->quantval[i+1],
+ quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
+ quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
+ quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
+ }
+ }
+
+ length -= DCTSIZE2+1;
+ if (prec) length -= DCTSIZE2;
+ }
+
+ if (length != 0)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+get_dri (j_decompress_ptr cinfo)
+/* Process a DRI marker */
+{
+ INT32 length;
+ unsigned int tmp;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+
+ if (length != 4)
+ ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+ INPUT_2BYTES(cinfo, tmp, return FALSE);
+
+ TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
+
+ cinfo->restart_interval = tmp;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Routines for processing APPn and COM markers.
+ * These are either saved in memory or discarded, per application request.
+ * APP0 and APP14 are specially checked to see if they are
+ * JFIF and Adobe markers, respectively.
+ */
+
+#define APP0_DATA_LEN 14 /* Length of interesting data in APP0 */
+#define APP14_DATA_LEN 12 /* Length of interesting data in APP14 */
+#define APPN_DATA_LEN 14 /* Must be the largest of the above!! */
+
+
+LOCAL(void)
+examine_app0 (j_decompress_ptr cinfo, JOCTET FAR * data,
+ unsigned int datalen, INT32 remaining)
+/* Examine first few bytes from an APP0.
+ * Take appropriate action if it is a JFIF marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+ INT32 totallen = (INT32) datalen + remaining;
+
+ if (datalen >= APP0_DATA_LEN &&
+ GETJOCTET(data[0]) == 0x4A &&
+ GETJOCTET(data[1]) == 0x46 &&
+ GETJOCTET(data[2]) == 0x49 &&
+ GETJOCTET(data[3]) == 0x46 &&
+ GETJOCTET(data[4]) == 0) {
+ /* Found JFIF APP0 marker: save info */
+ cinfo->saw_JFIF_marker = TRUE;
+ cinfo->JFIF_major_version = GETJOCTET(data[5]);
+ cinfo->JFIF_minor_version = GETJOCTET(data[6]);
+ cinfo->density_unit = GETJOCTET(data[7]);
+ cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
+ cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
+ /* Check version.
+ * Major version must be 1, anything else signals an incompatible change.
+ * (We used to treat this as an error, but now it's a nonfatal warning,
+ * because some bozo at Hijaak couldn't read the spec.)
+ * Minor version should be 0..2, but process anyway if newer.
+ */
+ if (cinfo->JFIF_major_version != 1)
+ WARNMS2(cinfo, JWRN_JFIF_MAJOR,
+ cinfo->JFIF_major_version, cinfo->JFIF_minor_version);
+ /* Generate trace messages */
+ TRACEMS5(cinfo, 1, JTRC_JFIF,
+ cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
+ cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+ /* Validate thumbnail dimensions and issue appropriate messages */
+ if (GETJOCTET(data[12]) | GETJOCTET(data[13]))
+ TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL,
+ GETJOCTET(data[12]), GETJOCTET(data[13]));
+ totallen -= APP0_DATA_LEN;
+ if (totallen !=
+ ((INT32)GETJOCTET(data[12]) * (INT32)GETJOCTET(data[13]) * (INT32) 3))
+ TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
+ } else if (datalen >= 6 &&
+ GETJOCTET(data[0]) == 0x4A &&
+ GETJOCTET(data[1]) == 0x46 &&
+ GETJOCTET(data[2]) == 0x58 &&
+ GETJOCTET(data[3]) == 0x58 &&
+ GETJOCTET(data[4]) == 0) {
+ /* Found JFIF "JFXX" extension APP0 marker */
+ /* The library doesn't actually do anything with these,
+ * but we try to produce a helpful trace message.
+ */
+ switch (GETJOCTET(data[5])) {
+ case 0x10:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
+ break;
+ case 0x11:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
+ break;
+ case 0x13:
+ TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
+ break;
+ default:
+ TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION,
+ GETJOCTET(data[5]), (int) totallen);
+ break;
+ }
+ } else {
+ /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
+ TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
+ }
+}
+
+
+LOCAL(void)
+examine_app14 (j_decompress_ptr cinfo, JOCTET FAR * data,
+ unsigned int datalen, INT32 remaining)
+/* Examine first few bytes from an APP14.
+ * Take appropriate action if it is an Adobe marker.
+ * datalen is # of bytes at data[], remaining is length of rest of marker data.
+ */
+{
+ unsigned int version, flags0, flags1, transform;
+
+ if (datalen >= APP14_DATA_LEN &&
+ GETJOCTET(data[0]) == 0x41 &&
+ GETJOCTET(data[1]) == 0x64 &&
+ GETJOCTET(data[2]) == 0x6F &&
+ GETJOCTET(data[3]) == 0x62 &&
+ GETJOCTET(data[4]) == 0x65) {
+ /* Found Adobe APP14 marker */
+ version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
+ flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
+ flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
+ transform = GETJOCTET(data[11]);
+ TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
+ cinfo->saw_Adobe_marker = TRUE;
+ cinfo->Adobe_transform = (UINT8) transform;
+ } else {
+ /* Start of APP14 does not match "Adobe", or too short */
+ TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
+ }
+}
+
+
+METHODDEF(boolean)
+get_interesting_appn (j_decompress_ptr cinfo)
+/* Process an APP0 or APP14 marker without saving it */
+{
+ INT32 length;
+ JOCTET b[APPN_DATA_LEN];
+ unsigned int i, numtoread;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ /* get the interesting part of the marker data */
+ if (length >= APPN_DATA_LEN)
+ numtoread = APPN_DATA_LEN;
+ else if (length > 0)
+ numtoread = (unsigned int) length;
+ else
+ numtoread = 0;
+ for (i = 0; i < numtoread; i++)
+ INPUT_BYTE(cinfo, b[i], return FALSE);
+ length -= numtoread;
+
+ /* process it */
+ switch (cinfo->unread_marker) {
+ case M_APP0:
+ examine_app0(cinfo, (JOCTET FAR *) b, numtoread, length);
+ break;
+ case M_APP14:
+ examine_app14(cinfo, (JOCTET FAR *) b, numtoread, length);
+ break;
+ default:
+ /* can't get here unless jpeg_save_markers chooses wrong processor */
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+ break;
+ }
+
+ /* skip any remaining data -- could be lots */
+ INPUT_SYNC(cinfo);
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+METHODDEF(boolean)
+save_marker (j_decompress_ptr cinfo)
+/* Save an APPn or COM marker into the marker list */
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ jpeg_saved_marker_ptr cur_marker = marker->cur_marker;
+ unsigned int bytes_read, data_length;
+ JOCTET FAR * data;
+ INT32 length = 0;
+ INPUT_VARS(cinfo);
+
+ if (cur_marker == NULL) {
+ /* begin reading a marker */
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+ if (length >= 0) { /* watch out for bogus length word */
+ /* figure out how much we want to save */
+ unsigned int limit;
+ if (cinfo->unread_marker == (int) M_COM)
+ limit = marker->length_limit_COM;
+ else
+ limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0];
+ if ((unsigned int) length < limit)
+ limit = (unsigned int) length;
+ /* allocate and initialize the marker item */
+ cur_marker = (jpeg_saved_marker_ptr)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(struct jpeg_marker_struct) + limit);
+ cur_marker->next = NULL;
+ cur_marker->marker = (UINT8) cinfo->unread_marker;
+ cur_marker->original_length = (unsigned int) length;
+ cur_marker->data_length = limit;
+ /* data area is just beyond the jpeg_marker_struct */
+ data = cur_marker->data = (JOCTET FAR *) (cur_marker + 1);
+ marker->cur_marker = cur_marker;
+ marker->bytes_read = 0;
+ bytes_read = 0;
+ data_length = limit;
+ } else {
+ /* deal with bogus length word */
+ bytes_read = data_length = 0;
+ data = NULL;
+ }
+ } else {
+ /* resume reading a marker */
+ bytes_read = marker->bytes_read;
+ data_length = cur_marker->data_length;
+ data = cur_marker->data + bytes_read;
+ }
+
+ while (bytes_read < data_length) {
+ INPUT_SYNC(cinfo); /* move the restart point to here */
+ marker->bytes_read = bytes_read;
+ /* If there's not at least one byte in buffer, suspend */
+ MAKE_BYTE_AVAIL(cinfo, return FALSE);
+ /* Copy bytes with reasonable rapidity */
+ while (bytes_read < data_length && bytes_in_buffer > 0) {
+ *data++ = *next_input_byte++;
+ bytes_in_buffer--;
+ bytes_read++;
+ }
+ }
+
+ /* Done reading what we want to read */
+ if (cur_marker != NULL) { /* will be NULL if bogus length word */
+ /* Add new marker to end of list */
+ if (cinfo->marker_list == NULL) {
+ cinfo->marker_list = cur_marker;
+ } else {
+ jpeg_saved_marker_ptr prev = cinfo->marker_list;
+ while (prev->next != NULL)
+ prev = prev->next;
+ prev->next = cur_marker;
+ }
+ /* Reset pointer & calc remaining data length */
+ data = cur_marker->data;
+ length = cur_marker->original_length - data_length;
+ }
+ /* Reset to initial state for next marker */
+ marker->cur_marker = NULL;
+
+ /* Process the marker if interesting; else just make a generic trace msg */
+ switch (cinfo->unread_marker) {
+ case M_APP0:
+ examine_app0(cinfo, data, data_length, length);
+ break;
+ case M_APP14:
+ examine_app14(cinfo, data, data_length, length);
+ break;
+ default:
+ TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker,
+ (int) (data_length + length));
+ break;
+ }
+
+ /* skip any remaining data -- could be lots */
+ INPUT_SYNC(cinfo); /* do before skip_input_data */
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+METHODDEF(boolean)
+skip_variable (j_decompress_ptr cinfo)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+ INT32 length;
+ INPUT_VARS(cinfo);
+
+ INPUT_2BYTES(cinfo, length, return FALSE);
+ length -= 2;
+
+ TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
+
+ INPUT_SYNC(cinfo); /* do before skip_input_data */
+ if (length > 0)
+ (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+ return TRUE;
+}
+
+
+/*
+ * Find the next JPEG marker, save it in cinfo->unread_marker.
+ * Returns FALSE if had to suspend before reaching a marker;
+ * in that case cinfo->unread_marker is unchanged.
+ *
+ * Note that the result might not be a valid marker code,
+ * but it will never be 0 or FF.
+ */
+
+LOCAL(boolean)
+next_marker (j_decompress_ptr cinfo)
+{
+ int c;
+ INPUT_VARS(cinfo);
+
+ for (;;) {
+ INPUT_BYTE(cinfo, c, return FALSE);
+ /* Skip any non-FF bytes.
+ * This may look a bit inefficient, but it will not occur in a valid file.
+ * We sync after each discarded byte so that a suspending data source
+ * can discard the byte from its buffer.
+ */
+ while (c != 0xFF) {
+ cinfo->marker->discarded_bytes++;
+ INPUT_SYNC(cinfo);
+ INPUT_BYTE(cinfo, c, return FALSE);
+ }
+ /* This loop swallows any duplicate FF bytes. Extra FFs are legal as
+ * pad bytes, so don't count them in discarded_bytes. We assume there
+ * will not be so many consecutive FF bytes as to overflow a suspending
+ * data source's input buffer.
+ */
+ do {
+ INPUT_BYTE(cinfo, c, return FALSE);
+ } while (c == 0xFF);
+ if (c != 0)
+ break; /* found a valid marker, exit loop */
+ /* Reach here if we found a stuffed-zero data sequence (FF/00).
+ * Discard it and loop back to try again.
+ */
+ cinfo->marker->discarded_bytes += 2;
+ INPUT_SYNC(cinfo);
+ }
+
+ if (cinfo->marker->discarded_bytes != 0) {
+ WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
+ cinfo->marker->discarded_bytes = 0;
+ }
+
+ cinfo->unread_marker = c;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+LOCAL(boolean)
+first_marker (j_decompress_ptr cinfo)
+/* Like next_marker, but used to obtain the initial SOI marker. */
+/* For this marker, we do not allow preceding garbage or fill; otherwise,
+ * we might well scan an entire input file before realizing it ain't JPEG.
+ * If an application wants to process non-JFIF files, it must seek to the
+ * SOI before calling the JPEG library.
+ */
+{
+ int c, c2;
+ INPUT_VARS(cinfo);
+
+ INPUT_BYTE(cinfo, c, return FALSE);
+ INPUT_BYTE(cinfo, c2, return FALSE);
+ if (c != 0xFF || c2 != (int) M_SOI)
+ ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
+
+ cinfo->unread_marker = c2;
+
+ INPUT_SYNC(cinfo);
+ return TRUE;
+}
+
+
+/*
+ * Read markers until SOS or EOI.
+ *
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+
+METHODDEF(int)
+read_markers (j_decompress_ptr cinfo)
+{
+ /* Outer loop repeats once for each marker. */
+ for (;;) {
+ /* Collect the marker proper, unless we already did. */
+ /* NB: first_marker() enforces the requirement that SOI appear first. */
+ if (cinfo->unread_marker == 0) {
+ if (! cinfo->marker->saw_SOI) {
+ if (! first_marker(cinfo))
+ return JPEG_SUSPENDED;
+ } else {
+ if (! next_marker(cinfo))
+ return JPEG_SUSPENDED;
+ }
+ }
+ /* At this point cinfo->unread_marker contains the marker code and the
+ * input point is just past the marker proper, but before any parameters.
+ * A suspension will cause us to return with this state still true.
+ */
+ switch (cinfo->unread_marker) {
+ case M_SOI:
+ if (! get_soi(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF0: /* Baseline */
+ case M_SOF1: /* Extended sequential, Huffman */
+ if (! get_sof(cinfo, FALSE, FALSE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF2: /* Progressive, Huffman */
+ if (! get_sof(cinfo, TRUE, FALSE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF9: /* Extended sequential, arithmetic */
+ if (! get_sof(cinfo, FALSE, TRUE))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_SOF10: /* Progressive, arithmetic */
+ if (! get_sof(cinfo, TRUE, TRUE))
+ return JPEG_SUSPENDED;
+ break;
+
+ /* Currently unsupported SOFn types */
+ case M_SOF3: /* Lossless, Huffman */
+ case M_SOF5: /* Differential sequential, Huffman */
+ case M_SOF6: /* Differential progressive, Huffman */
+ case M_SOF7: /* Differential lossless, Huffman */
+ case M_JPG: /* Reserved for JPEG extensions */
+ case M_SOF11: /* Lossless, arithmetic */
+ case M_SOF13: /* Differential sequential, arithmetic */
+ case M_SOF14: /* Differential progressive, arithmetic */
+ case M_SOF15: /* Differential lossless, arithmetic */
+ ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
+ break;
+
+ case M_SOS:
+ if (! get_sos(cinfo))
+ return JPEG_SUSPENDED;
+ cinfo->unread_marker = 0; /* processed the marker */
+ return JPEG_REACHED_SOS;
+
+ case M_EOI:
+ TRACEMS(cinfo, 1, JTRC_EOI);
+ cinfo->unread_marker = 0; /* processed the marker */
+ return JPEG_REACHED_EOI;
+
+ case M_DAC:
+ if (! get_dac(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DHT:
+ if (! get_dht(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DQT:
+ if (! get_dqt(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_DRI:
+ if (! get_dri(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_APP0:
+ case M_APP1:
+ case M_APP2:
+ case M_APP3:
+ case M_APP4:
+ case M_APP5:
+ case M_APP6:
+ case M_APP7:
+ case M_APP8:
+ case M_APP9:
+ case M_APP10:
+ case M_APP11:
+ case M_APP12:
+ case M_APP13:
+ case M_APP14:
+ case M_APP15:
+ if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[
+ cinfo->unread_marker - (int) M_APP0]) (cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_COM:
+ if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ case M_RST0: /* these are all parameterless */
+ case M_RST1:
+ case M_RST2:
+ case M_RST3:
+ case M_RST4:
+ case M_RST5:
+ case M_RST6:
+ case M_RST7:
+ case M_TEM:
+ TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
+ break;
+
+ case M_DNL: /* Ignore DNL ... perhaps the wrong thing */
+ if (! skip_variable(cinfo))
+ return JPEG_SUSPENDED;
+ break;
+
+ default: /* must be DHP, EXP, JPGn, or RESn */
+ /* For now, we treat the reserved markers as fatal errors since they are
+ * likely to be used to signal incompatible JPEG Part 3 extensions.
+ * Once the JPEG 3 version-number marker is well defined, this code
+ * ought to change!
+ */
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+ break;
+ }
+ /* Successfully processed marker, so reset state variable */
+ cinfo->unread_marker = 0;
+ } /* end loop */
+}
+
+
+/*
+ * Read a restart marker, which is expected to appear next in the datastream;
+ * if the marker is not there, take appropriate recovery action.
+ * Returns FALSE if suspension is required.
+ *
+ * This is called by the entropy decoder after it has read an appropriate
+ * number of MCUs. cinfo->unread_marker may be nonzero if the entropy decoder
+ * has already read a marker from the data source. Under normal conditions
+ * cinfo->unread_marker will be reset to 0 before returning; if not reset,
+ * it holds a marker which the decoder will be unable to read past.
+ */
+
+METHODDEF(boolean)
+read_restart_marker (j_decompress_ptr cinfo)
+{
+ /* Obtain a marker unless we already did. */
+ /* Note that next_marker will complain if it skips any data. */
+ if (cinfo->unread_marker == 0) {
+ if (! next_marker(cinfo))
+ return FALSE;
+ }
+
+ if (cinfo->unread_marker ==
+ ((int) M_RST0 + cinfo->marker->next_restart_num)) {
+ /* Normal case --- swallow the marker and let entropy decoder continue */
+ TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
+ cinfo->unread_marker = 0;
+ } else {
+ /* Uh-oh, the restart markers have been messed up. */
+ /* Let the data source manager determine how to resync. */
+ if (! (*cinfo->src->resync_to_restart) (cinfo,
+ cinfo->marker->next_restart_num))
+ return FALSE;
+ }
+
+ /* Update next-restart state */
+ cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
+
+ return TRUE;
+}
+
+
+/*
+ * This is the default resync_to_restart method for data source managers
+ * to use if they don't have any better approach. Some data source managers
+ * may be able to back up, or may have additional knowledge about the data
+ * which permits a more intelligent recovery strategy; such managers would
+ * presumably supply their own resync method.
+ *
+ * read_restart_marker calls resync_to_restart if it finds a marker other than
+ * the restart marker it was expecting. (This code is *not* used unless
+ * a nonzero restart interval has been declared.) cinfo->unread_marker is
+ * the marker code actually found (might be anything, except 0 or FF).
+ * The desired restart marker number (0..7) is passed as a parameter.
+ * This routine is supposed to apply whatever error recovery strategy seems
+ * appropriate in order to position the input stream to the next data segment.
+ * Note that cinfo->unread_marker is treated as a marker appearing before
+ * the current data-source input point; usually it should be reset to zero
+ * before returning.
+ * Returns FALSE if suspension is required.
+ *
+ * This implementation is substantially constrained by wanting to treat the
+ * input as a data stream; this means we can't back up. Therefore, we have
+ * only the following actions to work with:
+ * 1. Simply discard the marker and let the entropy decoder resume at next
+ * byte of file.
+ * 2. Read forward until we find another marker, discarding intervening
+ * data. (In theory we could look ahead within the current bufferload,
+ * without having to discard data if we don't find the desired marker.
+ * This idea is not implemented here, in part because it makes behavior
+ * dependent on buffer size and chance buffer-boundary positions.)
+ * 3. Leave the marker unread (by failing to zero cinfo->unread_marker).
+ * This will cause the entropy decoder to process an empty data segment,
+ * inserting dummy zeroes, and then we will reprocess the marker.
+ *
+ * #2 is appropriate if we think the desired marker lies ahead, while #3 is
+ * appropriate if the found marker is a future restart marker (indicating
+ * that we have missed the desired restart marker, probably because it got
+ * corrupted).
+ * We apply #2 or #3 if the found marker is a restart marker no more than
+ * two counts behind or ahead of the expected one. We also apply #2 if the
+ * found marker is not a legal JPEG marker code (it's certainly bogus data).
+ * If the found marker is a restart marker more than 2 counts away, we do #1
+ * (too much risk that the marker is erroneous; with luck we will be able to
+ * resync at some future point).
+ * For any valid non-restart JPEG marker, we apply #3. This keeps us from
+ * overrunning the end of a scan. An implementation limited to single-scan
+ * files might find it better to apply #2 for markers other than EOI, since
+ * any other marker would have to be bogus data in that case.
+ */
+
+GLOBAL(boolean)
+jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
+{
+ int marker = cinfo->unread_marker;
+ int action = 1;
+
+ /* Always put up a warning. */
+ WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
+
+ /* Outer loop handles repeated decision after scanning forward. */
+ for (;;) {
+ if (marker < (int) M_SOF0)
+ action = 2; /* invalid marker */
+ else if (marker < (int) M_RST0 || marker > (int) M_RST7)
+ action = 3; /* valid non-restart marker */
+ else {
+ if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
+ marker == ((int) M_RST0 + ((desired+2) & 7)))
+ action = 3; /* one of the next two expected restarts */
+ else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
+ marker == ((int) M_RST0 + ((desired-2) & 7)))
+ action = 2; /* a prior restart, so advance */
+ else
+ action = 1; /* desired restart or too far away */
+ }
+ TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
+ switch (action) {
+ case 1:
+ /* Discard marker and let entropy decoder resume processing. */
+ cinfo->unread_marker = 0;
+ return TRUE;
+ case 2:
+ /* Scan to the next marker, and repeat the decision loop. */
+ if (! next_marker(cinfo))
+ return FALSE;
+ marker = cinfo->unread_marker;
+ break;
+ case 3:
+ /* Return without advancing past this marker. */
+ /* Entropy decoder will be forced to process an empty segment. */
+ return TRUE;
+ }
+ } /* end loop */
+}
+
+
+/*
+ * Reset marker processing state to begin a fresh datastream.
+ */
+
+METHODDEF(void)
+reset_marker_reader (j_decompress_ptr cinfo)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ cinfo->comp_info = NULL; /* until allocated by get_sof */
+ cinfo->input_scan_number = 0; /* no SOS seen yet */
+ cinfo->unread_marker = 0; /* no pending marker */
+ marker->pub.saw_SOI = FALSE; /* set internal state too */
+ marker->pub.saw_SOF = FALSE;
+ marker->pub.discarded_bytes = 0;
+ marker->cur_marker = NULL;
+}
+
+
+/*
+ * Initialize the marker reader module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL(void)
+jinit_marker_reader (j_decompress_ptr cinfo)
+{
+ my_marker_ptr marker;
+ int i;
+
+ /* Create subobject in permanent pool */
+ marker = (my_marker_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ SIZEOF(my_marker_reader));
+ cinfo->marker = (struct jpeg_marker_reader *) marker;
+ /* Initialize public method pointers */
+ marker->pub.reset_marker_reader = reset_marker_reader;
+ marker->pub.read_markers = read_markers;
+ marker->pub.read_restart_marker = read_restart_marker;
+ /* Initialize COM/APPn processing.
+ * By default, we examine and then discard APP0 and APP14,
+ * but simply discard COM and all other APPn.
+ */
+ marker->process_COM = skip_variable;
+ marker->length_limit_COM = 0;
+ for (i = 0; i < 16; i++) {
+ marker->process_APPn[i] = skip_variable;
+ marker->length_limit_APPn[i] = 0;
+ }
+ marker->process_APPn[0] = get_interesting_appn;
+ marker->process_APPn[14] = get_interesting_appn;
+ /* Reset marker processing state */
+ reset_marker_reader(cinfo);
+}
+
+
+/*
+ * Control saving of COM and APPn markers into marker_list.
+ */
+
+#ifdef SAVE_MARKERS_SUPPORTED
+
+GLOBAL(void)
+jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,
+ unsigned int length_limit)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+ long maxlength;
+ jpeg_marker_parser_method processor;
+
+ /* Length limit mustn't be larger than what we can allocate
+ * (should only be a concern in a 16-bit environment).
+ */
+ maxlength = cinfo->mem->max_alloc_chunk - SIZEOF(struct jpeg_marker_struct);
+ if (((long) length_limit) > maxlength)
+ length_limit = (unsigned int) maxlength;
+
+ /* Choose processor routine to use.
+ * APP0/APP14 have special requirements.
+ */
+ if (length_limit) {
+ processor = save_marker;
+ /* If saving APP0/APP14, save at least enough for our internal use. */
+ if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN)
+ length_limit = APP0_DATA_LEN;
+ else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN)
+ length_limit = APP14_DATA_LEN;
+ } else {
+ processor = skip_variable;
+ /* If discarding APP0/APP14, use our regular on-the-fly processor. */
+ if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14)
+ processor = get_interesting_appn;
+ }
+
+ if (marker_code == (int) M_COM) {
+ marker->process_COM = processor;
+ marker->length_limit_COM = length_limit;
+ } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) {
+ marker->process_APPn[marker_code - (int) M_APP0] = processor;
+ marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit;
+ } else
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
+
+#endif /* SAVE_MARKERS_SUPPORTED */
+
+
+/*
+ * Install a special processing method for COM or APPn markers.
+ */
+
+GLOBAL(void)
+jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
+ jpeg_marker_parser_method routine)
+{
+ my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
+
+ if (marker_code == (int) M_COM)
+ marker->process_COM = routine;
+ else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
+ marker->process_APPn[marker_code - (int) M_APP0] = routine;
+ else
+ ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
--- /dev/null
+/*
+ * jdmaster.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+ struct jpeg_decomp_master pub; /* public fields */
+
+ int pass_number; /* # of passes completed */
+
+ boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
+
+ /* Saved references to initialized quantizer modules,
+ * in case we need to switch modes.
+ */
+ struct jpeg_color_quantizer * quantizer_1pass;
+ struct jpeg_color_quantizer * quantizer_2pass;
+} my_decomp_master;
+
+typedef my_decomp_master * my_master_ptr;
+
+
+/*
+ * Determine whether merged upsample/color conversion should be used.
+ * CRUCIAL: this must match the actual capabilities of jdmerge.c!
+ */
+
+LOCAL(boolean)
+use_merged_upsample (j_decompress_ptr cinfo)
+{
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+ /* Merging is the equivalent of plain box-filter upsampling */
+ if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
+ return FALSE;
+ /* jdmerge.c only supports YCC=>RGB color conversion */
+ if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
+ cinfo->out_color_space != JCS_RGB ||
+ cinfo->out_color_components != RGB_PIXELSIZE)
+ return FALSE;
+ /* and it only handles 2h1v or 2h2v sampling ratios */
+ if (cinfo->comp_info[0].h_samp_factor != 2 ||
+ cinfo->comp_info[1].h_samp_factor != 1 ||
+ cinfo->comp_info[2].h_samp_factor != 1 ||
+ cinfo->comp_info[0].v_samp_factor > 2 ||
+ cinfo->comp_info[1].v_samp_factor != 1 ||
+ cinfo->comp_info[2].v_samp_factor != 1)
+ return FALSE;
+ /* furthermore, it doesn't work if we've scaled the IDCTs differently */
+ if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+ cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+ cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
+ return FALSE;
+ /* ??? also need to test for upsample-time rescaling, when & if supported */
+ return TRUE; /* by golly, it'll work... */
+#else
+ return FALSE;
+#endif
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ * Also note that it may be called before the master module is initialized!
+ */
+
+GLOBAL(void)
+jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+#ifdef IDCT_SCALING_SUPPORTED
+ int ci;
+ jpeg_component_info *compptr;
+#endif
+
+ /* Prevent application from calling me at wrong times */
+ if (cinfo->global_state != DSTATE_READY)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+ /* Compute actual output image dimensions and DCT scaling choices. */
+ if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
+ /* Provide 1/8 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 8L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 8L);
+ cinfo->min_DCT_scaled_size = 1;
+ } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
+ /* Provide 1/4 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 4L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 4L);
+ cinfo->min_DCT_scaled_size = 2;
+ } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
+ /* Provide 1/2 scaling */
+ cinfo->output_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width, 2L);
+ cinfo->output_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height, 2L);
+ cinfo->min_DCT_scaled_size = 4;
+ } else {
+ /* Provide 1/1 scaling */
+ cinfo->output_width = cinfo->image_width;
+ cinfo->output_height = cinfo->image_height;
+ cinfo->min_DCT_scaled_size = DCTSIZE;
+ }
+ /* In selecting the actual DCT scaling for each component, we try to
+ * scale up the chroma components via IDCT scaling rather than upsampling.
+ * This saves time if the upsampler gets to use 1:1 scaling.
+ * Note this code assumes that the supported DCT scalings are powers of 2.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ int ssize = cinfo->min_DCT_scaled_size;
+ while (ssize < DCTSIZE &&
+ (compptr->h_samp_factor * ssize * 2 <=
+ cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
+ (compptr->v_samp_factor * ssize * 2 <=
+ cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
+ ssize = ssize * 2;
+ }
+ compptr->DCT_scaled_size = ssize;
+ }
+
+ /* Recompute downsampled dimensions of components;
+ * application needs to know these if using raw downsampled data.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Size in samples, after IDCT scaling */
+ compptr->downsampled_width = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_width *
+ (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
+ (long) (cinfo->max_h_samp_factor * DCTSIZE));
+ compptr->downsampled_height = (JDIMENSION)
+ jdiv_round_up((long) cinfo->image_height *
+ (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
+ (long) (cinfo->max_v_samp_factor * DCTSIZE));
+ }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+ /* Hardwire it to "no scaling" */
+ cinfo->output_width = cinfo->image_width;
+ cinfo->output_height = cinfo->image_height;
+ /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
+ * and has computed unscaled downsampled_width and downsampled_height.
+ */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+
+ /* Report number of components in selected colorspace. */
+ /* Probably this should be in the color conversion module... */
+ switch (cinfo->out_color_space) {
+ case JCS_GRAYSCALE:
+ cinfo->out_color_components = 1;
+ break;
+ case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+ cinfo->out_color_components = RGB_PIXELSIZE;
+ break;
+#endif /* else share code with YCbCr */
+ case JCS_YCbCr:
+ cinfo->out_color_components = 3;
+ break;
+ case JCS_CMYK:
+ case JCS_YCCK:
+ cinfo->out_color_components = 4;
+ break;
+ default: /* else must be same colorspace as in file */
+ cinfo->out_color_components = cinfo->num_components;
+ break;
+ }
+ cinfo->output_components = (cinfo->quantize_colors ? 1 :
+ cinfo->out_color_components);
+
+ /* See if upsampler will want to emit more than one row at a time */
+ if (use_merged_upsample(cinfo))
+ cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
+ else
+ cinfo->rec_outbuf_height = 1;
+}
+
+
+/*
+ * Several decompression processes need to range-limit values to the range
+ * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
+ * due to noise introduced by quantization, roundoff error, etc. These
+ * processes are inner loops and need to be as fast as possible. On most
+ * machines, particularly CPUs with pipelines or instruction prefetch,
+ * a (subscript-check-less) C table lookup
+ * x = sample_range_limit[x];
+ * is faster than explicit tests
+ * if (x < 0) x = 0;
+ * else if (x > MAXJSAMPLE) x = MAXJSAMPLE;
+ * These processes all use a common table prepared by the routine below.
+ *
+ * For most steps we can mathematically guarantee that the initial value
+ * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
+ * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient. But for the initial
+ * limiting step (just after the IDCT), a wildly out-of-range value is
+ * possible if the input data is corrupt. To avoid any chance of indexing
+ * off the end of memory and getting a bad-pointer trap, we perform the
+ * post-IDCT limiting thus:
+ * x = range_limit[x & MASK];
+ * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
+ * samples. Under normal circumstances this is more than enough range and
+ * a correct output will be generated; with bogus input data the mask will
+ * cause wraparound, and we will safely generate a bogus-but-in-range output.
+ * For the post-IDCT step, we want to convert the data from signed to unsigned
+ * representation by adding CENTERJSAMPLE at the same time that we limit it.
+ * So the post-IDCT limiting table ends up looking like this:
+ * CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
+ * MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ * 0 (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ * 0,1,...,CENTERJSAMPLE-1
+ * Negative inputs select values from the upper half of the table after
+ * masking.
+ *
+ * We can save some space by overlapping the start of the post-IDCT table
+ * with the simpler range limiting table. The post-IDCT table begins at
+ * sample_range_limit + CENTERJSAMPLE.
+ *
+ * Note that the table is allocated in near data space on PCs; it's small
+ * enough and used often enough to justify this.
+ */
+
+LOCAL(void)
+prepare_range_limit_table (j_decompress_ptr cinfo)
+/* Allocate and fill in the sample_range_limit table */
+{
+ JSAMPLE * table;
+ int i;
+
+ table = (JSAMPLE *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+ table += (MAXJSAMPLE+1); /* allow negative subscripts of simple table */
+ cinfo->sample_range_limit = table;
+ /* First segment of "simple" table: limit[x] = 0 for x < 0 */
+ MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
+ /* Main part of "simple" table: limit[x] = x */
+ for (i = 0; i <= MAXJSAMPLE; i++)
+ table[i] = (JSAMPLE) i;
+ table += CENTERJSAMPLE; /* Point to where post-IDCT table starts */
+ /* End of simple table, rest of first half of post-IDCT table */
+ for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
+ table[i] = MAXJSAMPLE;
+ /* Second half of post-IDCT table */
+ MEMZERO(table + (2 * (MAXJSAMPLE+1)),
+ (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+ MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
+ cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
+}
+
+
+/*
+ * Master selection of decompression modules.
+ * This is done once at jpeg_start_decompress time. We determine
+ * which modules will be used and give them appropriate initialization calls.
+ * We also initialize the decompressor input side to begin consuming data.
+ *
+ * Since jpeg_read_header has finished, we know what is in the SOF
+ * and (first) SOS markers. We also have all the application parameter
+ * settings.
+ */
+
+LOCAL(void)
+master_selection (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+ boolean use_c_buffer;
+ long samplesperrow;
+ JDIMENSION jd_samplesperrow;
+
+ /* Initialize dimensions and other stuff */
+ jpeg_calc_output_dimensions(cinfo);
+ prepare_range_limit_table(cinfo);
+
+ /* Width of an output scanline must be representable as JDIMENSION. */
+ samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
+ jd_samplesperrow = (JDIMENSION) samplesperrow;
+ if ((long) jd_samplesperrow != samplesperrow)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+ /* Initialize my private state */
+ master->pass_number = 0;
+ master->using_merged_upsample = use_merged_upsample(cinfo);
+
+ /* Color quantizer selection */
+ master->quantizer_1pass = NULL;
+ master->quantizer_2pass = NULL;
+ /* No mode changes if not using buffered-image mode. */
+ if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
+ cinfo->enable_1pass_quant = FALSE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+ }
+ if (cinfo->quantize_colors) {
+ if (cinfo->raw_data_out)
+ ERREXIT(cinfo, JERR_NOTIMPL);
+ /* 2-pass quantizer only works in 3-component color space. */
+ if (cinfo->out_color_components != 3) {
+ cinfo->enable_1pass_quant = TRUE;
+ cinfo->enable_external_quant = FALSE;
+ cinfo->enable_2pass_quant = FALSE;
+ cinfo->colormap = NULL;
+ } else if (cinfo->colormap != NULL) {
+ cinfo->enable_external_quant = TRUE;
+ } else if (cinfo->two_pass_quantize) {
+ cinfo->enable_2pass_quant = TRUE;
+ } else {
+ cinfo->enable_1pass_quant = TRUE;
+ }
+
+ if (cinfo->enable_1pass_quant) {
+#ifdef QUANT_1PASS_SUPPORTED
+ jinit_1pass_quantizer(cinfo);
+ master->quantizer_1pass = cinfo->cquantize;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ }
+
+ /* We use the 2-pass code to map to external colormaps. */
+ if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
+#ifdef QUANT_2PASS_SUPPORTED
+ jinit_2pass_quantizer(cinfo);
+ master->quantizer_2pass = cinfo->cquantize;
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ }
+ /* If both quantizers are initialized, the 2-pass one is left active;
+ * this is necessary for starting with quantization to an external map.
+ */
+ }
+
+ /* Post-processing: in particular, color conversion first */
+ if (! cinfo->raw_data_out) {
+ if (master->using_merged_upsample) {
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+ jinit_merged_upsampler(cinfo); /* does color conversion too */
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else {
+ jinit_color_deconverter(cinfo);
+ jinit_upsampler(cinfo);
+ }
+ jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
+ }
+ /* Inverse DCT */
+ jinit_inverse_dct(cinfo);
+ /* Entropy decoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+ jinit_phuff_decoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_decoder(cinfo);
+ }
+
+ /* Initialize principal buffer controllers. */
+ use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
+ jinit_d_coef_controller(cinfo, use_c_buffer);
+
+ if (! cinfo->raw_data_out)
+ jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Initialize input side of decompressor to consume first scan. */
+ (*cinfo->inputctl->start_input_pass) (cinfo);
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+ /* If jpeg_start_decompress will read the whole file, initialize
+ * progress monitoring appropriately. The input step is counted
+ * as one pass.
+ */
+ if (cinfo->progress != NULL && ! cinfo->buffered_image &&
+ cinfo->inputctl->has_multiple_scans) {
+ int nscans;
+ /* Estimate number of scans to set pass_limit. */
+ if (cinfo->progressive_mode) {
+ /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+ nscans = 2 + 3 * cinfo->num_components;
+ } else {
+ /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+ nscans = cinfo->num_components;
+ }
+ cinfo->progress->pass_counter = 0L;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+ cinfo->progress->completed_passes = 0;
+ cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
+ /* Count the input pass as done */
+ master->pass_number++;
+ }
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each output pass. We determine which
+ * modules will be active during this pass and give them appropriate
+ * start_pass calls. We also set is_dummy_pass to indicate whether this
+ * is a "real" output pass or a dummy pass for color quantization.
+ * (In the latter case, jdapistd.c will crank the pass to completion.)
+ */
+
+METHODDEF(void)
+prepare_for_output_pass (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ if (master->pub.is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+ /* Final pass of 2-pass quantization */
+ master->pub.is_dummy_pass = FALSE;
+ (*cinfo->cquantize->start_pass) (cinfo, FALSE);
+ (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
+ (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+ } else {
+ if (cinfo->quantize_colors && cinfo->colormap == NULL) {
+ /* Select new quantization method */
+ if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
+ cinfo->cquantize = master->quantizer_2pass;
+ master->pub.is_dummy_pass = TRUE;
+ } else if (cinfo->enable_1pass_quant) {
+ cinfo->cquantize = master->quantizer_1pass;
+ } else {
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+ }
+ }
+ (*cinfo->idct->start_pass) (cinfo);
+ (*cinfo->coef->start_output_pass) (cinfo);
+ if (! cinfo->raw_data_out) {
+ if (! master->using_merged_upsample)
+ (*cinfo->cconvert->start_pass) (cinfo);
+ (*cinfo->upsample->start_pass) (cinfo);
+ if (cinfo->quantize_colors)
+ (*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
+ (*cinfo->post->start_pass) (cinfo,
+ (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+ (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+ }
+ }
+
+ /* Set up progress monitor's pass info if present */
+ if (cinfo->progress != NULL) {
+ cinfo->progress->completed_passes = master->pass_number;
+ cinfo->progress->total_passes = master->pass_number +
+ (master->pub.is_dummy_pass ? 2 : 1);
+ /* In buffered-image mode, we assume one more output pass if EOI not
+ * yet reached, but no more passes if EOI has been reached.
+ */
+ if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
+ cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
+ }
+ }
+}
+
+
+/*
+ * Finish up at end of an output pass.
+ */
+
+METHODDEF(void)
+finish_output_pass (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ if (cinfo->quantize_colors)
+ (*cinfo->cquantize->finish_pass) (cinfo);
+ master->pass_number++;
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+GLOBAL(void)
+jpeg_new_colormap (j_decompress_ptr cinfo)
+{
+ my_master_ptr master = (my_master_ptr) cinfo->master;
+
+ /* Prevent application from calling me at wrong times */
+ if (cinfo->global_state != DSTATE_BUFIMAGE)
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+ if (cinfo->quantize_colors && cinfo->enable_external_quant &&
+ cinfo->colormap != NULL) {
+ /* Select 2-pass quantizer for external colormap use */
+ cinfo->cquantize = master->quantizer_2pass;
+ /* Notify quantizer of colormap change */
+ (*cinfo->cquantize->new_color_map) (cinfo);
+ master->pub.is_dummy_pass = FALSE; /* just in case */
+ } else
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Initialize master decompression control and select active modules.
+ * This is performed at the start of jpeg_start_decompress.
+ */
+
+GLOBAL(void)
+jinit_master_decompress (j_decompress_ptr cinfo)
+{
+ my_master_ptr master;
+
+ master = (my_master_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_decomp_master));
+ cinfo->master = (struct jpeg_decomp_master *) master;
+ master->pub.prepare_for_output_pass = prepare_for_output_pass;
+ master->pub.finish_output_pass = finish_output_pass;
+
+ master->pub.is_dummy_pass = FALSE;
+
+ master_selection(cinfo);
+}
--- /dev/null
+/*
+ * jdmerge.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains code for merged upsampling/color conversion.
+ *
+ * This file combines functions from jdsample.c and jdcolor.c;
+ * read those files first to understand what's going on.
+ *
+ * When the chroma components are to be upsampled by simple replication
+ * (ie, box filtering), we can save some work in color conversion by
+ * calculating all the output pixels corresponding to a pair of chroma
+ * samples at one time. In the conversion equations
+ * R = Y + K1 * Cr
+ * G = Y + K2 * Cb + K3 * Cr
+ * B = Y + K4 * Cb
+ * only the Y term varies among the group of pixels corresponding to a pair
+ * of chroma samples, so the rest of the terms can be calculated just once.
+ * At typical sampling ratios, this eliminates half or three-quarters of the
+ * multiplications needed for color conversion.
+ *
+ * This file currently provides implementations for the following cases:
+ * YCbCr => RGB color conversion only.
+ * Sampling ratios of 2h1v or 2h2v.
+ * No scaling needed at upsample time.
+ * Corner-aligned (non-CCIR601) sampling alignment.
+ * Other special cases could be added, but in most applications these are
+ * the only common cases. (For uncommon cases we fall back on the more
+ * general code in jdsample.c and jdcolor.c.)
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_upsampler pub; /* public fields */
+
+ /* Pointer to routine to do actual upsampling/conversion of one row group */
+ JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf));
+
+ /* Private state for YCC->RGB conversion */
+ int * Cr_r_tab; /* => table for Cr to R conversion */
+ int * Cb_b_tab; /* => table for Cb to B conversion */
+ INT32 * Cr_g_tab; /* => table for Cr to G conversion */
+ INT32 * Cb_g_tab; /* => table for Cb to G conversion */
+
+ /* For 2:1 vertical sampling, we produce two output rows at a time.
+ * We need a "spare" row buffer to hold the second output row if the
+ * application provides just a one-row buffer; we also use the spare
+ * to discard the dummy last row if the image height is odd.
+ */
+ JSAMPROW spare_row;
+ boolean spare_full; /* T if spare buffer is occupied */
+
+ JDIMENSION out_row_width; /* samples per output row */
+ JDIMENSION rows_to_go; /* counts rows remaining in image */
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+#define SCALEBITS 16 /* speediest right-shift on some machines */
+#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
+#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ * This is taken directly from jdcolor.c; see that file for more info.
+ */
+
+LOCAL(void)
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ int i;
+ INT32 x;
+ SHIFT_TEMPS
+
+ upsample->Cr_r_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ upsample->Cb_b_tab = (int *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(int));
+ upsample->Cr_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+ upsample->Cb_g_tab = (INT32 *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (MAXJSAMPLE+1) * SIZEOF(INT32));
+
+ for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+ /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+ /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+ /* Cr=>R value is nearest int to 1.40200 * x */
+ upsample->Cr_r_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+ /* Cb=>B value is nearest int to 1.77200 * x */
+ upsample->Cb_b_tab[i] = (int)
+ RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+ /* Cr=>G value is scaled-up -0.71414 * x */
+ upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+ /* Cb=>G value is scaled-up -0.34414 * x */
+ /* We also add in ONE_HALF so that need not do it in inner loop */
+ upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+ }
+}
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_merged_upsample (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Mark the spare buffer empty */
+ upsample->spare_full = FALSE;
+ /* Initialize total-height counter for detecting bottom of image */
+ upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * The control routine just handles the row buffering considerations.
+ */
+
+METHODDEF(void)
+merged_2v_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+/* 2:1 vertical sampling case: may need a spare row. */
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ JSAMPROW work_ptrs[2];
+ JDIMENSION num_rows; /* number of rows returned to caller */
+
+ if (upsample->spare_full) {
+ /* If we have a spare row saved from a previous cycle, just return it. */
+ jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
+ 1, upsample->out_row_width);
+ num_rows = 1;
+ upsample->spare_full = FALSE;
+ } else {
+ /* Figure number of rows to return to caller. */
+ num_rows = 2;
+ /* Not more than the distance to the end of the image. */
+ if (num_rows > upsample->rows_to_go)
+ num_rows = upsample->rows_to_go;
+ /* And not more than what the client can accept: */
+ out_rows_avail -= *out_row_ctr;
+ if (num_rows > out_rows_avail)
+ num_rows = out_rows_avail;
+ /* Create output pointer array for upsampler. */
+ work_ptrs[0] = output_buf[*out_row_ctr];
+ if (num_rows > 1) {
+ work_ptrs[1] = output_buf[*out_row_ctr + 1];
+ } else {
+ work_ptrs[1] = upsample->spare_row;
+ upsample->spare_full = TRUE;
+ }
+ /* Now do the upsampling. */
+ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
+ }
+
+ /* Adjust counts */
+ *out_row_ctr += num_rows;
+ upsample->rows_to_go -= num_rows;
+ /* When the buffer is emptied, declare this input row group consumed */
+ if (! upsample->spare_full)
+ (*in_row_group_ctr)++;
+}
+
+
+METHODDEF(void)
+merged_1v_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+/* 1:1 vertical sampling case: much easier, never need a spare row. */
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Just do the upsampling. */
+ (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
+ output_buf + *out_row_ctr);
+ /* Adjust counts */
+ (*out_row_ctr)++;
+ (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by the control routines to do
+ * the actual upsampling/conversion. One row group is processed per call.
+ *
+ * Note: since we may be writing directly into application-supplied buffers,
+ * we have to be honest about the output width; we can't assume the buffer
+ * has been rounded up to an even width.
+ */
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
+ */
+
+METHODDEF(void)
+h2v1_merged_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ register int y, cred, cgreen, cblue;
+ int cb, cr;
+ register JSAMPROW outptr;
+ JSAMPROW inptr0, inptr1, inptr2;
+ JDIMENSION col;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ int * Crrtab = upsample->Cr_r_tab;
+ int * Cbbtab = upsample->Cb_b_tab;
+ INT32 * Crgtab = upsample->Cr_g_tab;
+ INT32 * Cbgtab = upsample->Cb_g_tab;
+ SHIFT_TEMPS
+
+ inptr0 = input_buf[0][in_row_group_ctr];
+ inptr1 = input_buf[1][in_row_group_ctr];
+ inptr2 = input_buf[2][in_row_group_ctr];
+ outptr = output_buf[0];
+ /* Loop for each pair of output pixels */
+ for (col = cinfo->output_width >> 1; col > 0; col--) {
+ /* Do the chroma part of the calculation */
+ cb = GETJSAMPLE(*inptr1++);
+ cr = GETJSAMPLE(*inptr2++);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ /* Fetch 2 Y values and emit 2 pixels */
+ y = GETJSAMPLE(*inptr0++);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ outptr += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr0++);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ outptr += RGB_PIXELSIZE;
+ }
+ /* If image width is odd, do the last output column separately */
+ if (cinfo->output_width & 1) {
+ cb = GETJSAMPLE(*inptr1);
+ cr = GETJSAMPLE(*inptr2);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ y = GETJSAMPLE(*inptr0);
+ outptr[RGB_RED] = range_limit[y + cred];
+ outptr[RGB_GREEN] = range_limit[y + cgreen];
+ outptr[RGB_BLUE] = range_limit[y + cblue];
+ }
+}
+
+
+/*
+ * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
+ */
+
+METHODDEF(void)
+h2v2_merged_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
+ JSAMPARRAY output_buf)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ register int y, cred, cgreen, cblue;
+ int cb, cr;
+ register JSAMPROW outptr0, outptr1;
+ JSAMPROW inptr00, inptr01, inptr1, inptr2;
+ JDIMENSION col;
+ /* copy these pointers into registers if possible */
+ register JSAMPLE * range_limit = cinfo->sample_range_limit;
+ int * Crrtab = upsample->Cr_r_tab;
+ int * Cbbtab = upsample->Cb_b_tab;
+ INT32 * Crgtab = upsample->Cr_g_tab;
+ INT32 * Cbgtab = upsample->Cb_g_tab;
+ SHIFT_TEMPS
+
+ inptr00 = input_buf[0][in_row_group_ctr*2];
+ inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
+ inptr1 = input_buf[1][in_row_group_ctr];
+ inptr2 = input_buf[2][in_row_group_ctr];
+ outptr0 = output_buf[0];
+ outptr1 = output_buf[1];
+ /* Loop for each group of output pixels */
+ for (col = cinfo->output_width >> 1; col > 0; col--) {
+ /* Do the chroma part of the calculation */
+ cb = GETJSAMPLE(*inptr1++);
+ cr = GETJSAMPLE(*inptr2++);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ /* Fetch 4 Y values and emit 4 pixels */
+ y = GETJSAMPLE(*inptr00++);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ outptr0 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr00++);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ outptr0 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr01++);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ outptr1 += RGB_PIXELSIZE;
+ y = GETJSAMPLE(*inptr01++);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ outptr1 += RGB_PIXELSIZE;
+ }
+ /* If image width is odd, do the last output column separately */
+ if (cinfo->output_width & 1) {
+ cb = GETJSAMPLE(*inptr1);
+ cr = GETJSAMPLE(*inptr2);
+ cred = Crrtab[cr];
+ cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
+ cblue = Cbbtab[cb];
+ y = GETJSAMPLE(*inptr00);
+ outptr0[RGB_RED] = range_limit[y + cred];
+ outptr0[RGB_GREEN] = range_limit[y + cgreen];
+ outptr0[RGB_BLUE] = range_limit[y + cblue];
+ y = GETJSAMPLE(*inptr01);
+ outptr1[RGB_RED] = range_limit[y + cred];
+ outptr1[RGB_GREEN] = range_limit[y + cgreen];
+ outptr1[RGB_BLUE] = range_limit[y + cblue];
+ }
+}
+
+
+/*
+ * Module initialization routine for merged upsampling/color conversion.
+ *
+ * NB: this is called under the conditions determined by use_merged_upsample()
+ * in jdmaster.c. That routine MUST correspond to the actual capabilities
+ * of this module; no safety checks are made here.
+ */
+
+GLOBAL(void)
+jinit_merged_upsampler (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample;
+
+ upsample = (my_upsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_upsampler));
+ cinfo->upsample = (struct jpeg_upsampler *) upsample;
+ upsample->pub.start_pass = start_pass_merged_upsample;
+ upsample->pub.need_context_rows = FALSE;
+
+ upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
+
+ if (cinfo->max_v_samp_factor == 2) {
+ upsample->pub.upsample = merged_2v_upsample;
+ upsample->upmethod = h2v2_merged_upsample;
+ /* Allocate a spare row buffer */
+ upsample->spare_row = (JSAMPROW)
+ (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
+ } else {
+ upsample->pub.upsample = merged_1v_upsample;
+ upsample->upmethod = h2v1_merged_upsample;
+ /* No spare row needed */
+ upsample->spare_row = NULL;
+ }
+
+ build_ycc_rgb_table(cinfo);
+}
+
+#endif /* UPSAMPLE_MERGING_SUPPORTED */
--- /dev/null
+/*
+ * jdphuff.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines for progressive JPEG.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU. To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h" /* Declarations shared with jdhuff.c */
+
+
+#ifdef D_PROGRESSIVE_SUPPORTED
+
+/*
+ * Expanded entropy decoder object for progressive Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+ unsigned int EOBRUN; /* remaining EOBs in EOBRUN */
+ int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment. You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src) ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src) \
+ ((dest).EOBRUN = (src).EOBRUN, \
+ (dest).last_dc_val[0] = (src).last_dc_val[0], \
+ (dest).last_dc_val[1] = (src).last_dc_val[1], \
+ (dest).last_dc_val[2] = (src).last_dc_val[2], \
+ (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+ struct jpeg_entropy_decoder pub; /* public fields */
+
+ /* These fields are loaded into local variables at start of each MCU.
+ * In case of suspension, we exit WITHOUT updating them.
+ */
+ bitread_perm_state bitstate; /* Bit buffer at start of MCU */
+ savable_state saved; /* Other state at start of MCU */
+
+ /* These fields are NOT loaded into local working state. */
+ unsigned int restarts_to_go; /* MCUs left in this restart interval */
+
+ /* Pointers to derived tables (these workspaces have image lifespan) */
+ d_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+ d_derived_tbl * ac_derived_tbl; /* active table during an AC scan */
+} phuff_entropy_decoder;
+
+typedef phuff_entropy_decoder * phuff_entropy_ptr;
+
+/* Forward declarations */
+METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF(void)
+start_pass_phuff_decoder (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ boolean is_DC_band, bad;
+ int ci, coefi, tbl;
+ int *coef_bit_ptr;
+ jpeg_component_info * compptr;
+
+ is_DC_band = (cinfo->Ss == 0);
+
+ /* Validate scan parameters */
+ bad = FALSE;
+ if (is_DC_band) {
+ if (cinfo->Se != 0)
+ bad = TRUE;
+ } else {
+ /* need not check Ss/Se < 0 since they came from unsigned bytes */
+ if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
+ bad = TRUE;
+ /* AC scans may have only one component */
+ if (cinfo->comps_in_scan != 1)
+ bad = TRUE;
+ }
+ if (cinfo->Ah != 0) {
+ /* Successive approximation refinement scan: must have Al = Ah-1. */
+ if (cinfo->Al != cinfo->Ah-1)
+ bad = TRUE;
+ }
+ if (cinfo->Al > 13) /* need not check for < 0 */
+ bad = TRUE;
+ /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
+ * but the spec doesn't say so, and we try to be liberal about what we
+ * accept. Note: large Al values could result in out-of-range DC
+ * coefficients during early scans, leading to bizarre displays due to
+ * overflows in the IDCT math. But we won't crash.
+ */
+ if (bad)
+ ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
+ cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
+ /* Update progression status, and verify that scan order is legal.
+ * Note that inter-scan inconsistencies are treated as warnings
+ * not fatal errors ... not clear if this is right way to behave.
+ */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ int cindex = cinfo->cur_comp_info[ci]->component_index;
+ coef_bit_ptr = & cinfo->coef_bits[cindex][0];
+ if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
+ WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
+ for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
+ int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
+ if (cinfo->Ah != expected)
+ WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
+ coef_bit_ptr[coefi] = cinfo->Al;
+ }
+ }
+
+ /* Select MCU decoding routine */
+ if (cinfo->Ah == 0) {
+ if (is_DC_band)
+ entropy->pub.decode_mcu = decode_mcu_DC_first;
+ else
+ entropy->pub.decode_mcu = decode_mcu_AC_first;
+ } else {
+ if (is_DC_band)
+ entropy->pub.decode_mcu = decode_mcu_DC_refine;
+ else
+ entropy->pub.decode_mcu = decode_mcu_AC_refine;
+ }
+
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+ compptr = cinfo->cur_comp_info[ci];
+ /* Make sure requested tables are present, and compute derived tables.
+ * We may build same derived table more than once, but it's not expensive.
+ */
+ if (is_DC_band) {
+ if (cinfo->Ah == 0) { /* DC refinement needs no table */
+ tbl = compptr->dc_tbl_no;
+ jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
+ & entropy->derived_tbls[tbl]);
+ }
+ } else {
+ tbl = compptr->ac_tbl_no;
+ jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
+ & entropy->derived_tbls[tbl]);
+ /* remember the single active table */
+ entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
+ }
+ /* Initialize DC predictions to 0 */
+ entropy->saved.last_dc_val[ci] = 0;
+ }
+
+ /* Initialize bitread state variables */
+ entropy->bitstate.bits_left = 0;
+ entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+ entropy->pub.insufficient_data = FALSE;
+
+ /* Initialize private state variables */
+ entropy->saved.EOBRUN = 0;
+
+ /* Initialize restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s) ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] = /* entry n is 2**(n-1) */
+ { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+ 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+ { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+ ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+ ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+ ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL(boolean)
+process_restart (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int ci;
+
+ /* Throw away any unused bits remaining in bit buffer; */
+ /* include any full bytes in next_marker's count of discarded bytes */
+ cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+ entropy->bitstate.bits_left = 0;
+
+ /* Advance past the RSTn marker */
+ if (! (*cinfo->marker->read_restart_marker) (cinfo))
+ return FALSE;
+
+ /* Re-initialize DC predictions to 0 */
+ for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+ entropy->saved.last_dc_val[ci] = 0;
+ /* Re-init EOB run count, too */
+ entropy->saved.EOBRUN = 0;
+
+ /* Reset restart counter */
+ entropy->restarts_to_go = cinfo->restart_interval;
+
+ /* Reset out-of-data flag, unless read_restart_marker left us smack up
+ * against a marker. In that case we will end up treating the next data
+ * segment as empty, and we can avoid producing bogus output pixels by
+ * leaving the flag set.
+ */
+ if (cinfo->unread_marker == 0)
+ entropy->pub.insufficient_data = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Huffman MCU decoding.
+ * Each of these routines decodes and returns one MCU's worth of
+ * Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i]. WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
+ *
+ * We return FALSE if data source requested suspension. In that case no
+ * changes have been made to permanent state. (Exception: some output
+ * coefficients may already have been assigned. This is harmless for
+ * spectral selection, since we'll just re-assign them on the next call.
+ * Successive approximation AC refinement has to be more careful, however.)
+ */
+
+/*
+ * MCU decoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Al = cinfo->Al;
+ register int s, r;
+ int blkn, ci;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+ savable_state state;
+ d_derived_tbl * tbl;
+ jpeg_component_info * compptr;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(state, entropy->saved);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+ ci = cinfo->MCU_membership[blkn];
+ compptr = cinfo->cur_comp_info[ci];
+ tbl = entropy->derived_tbls[compptr->dc_tbl_no];
+
+ /* Decode a single block's worth of coefficients */
+
+ /* Section F.2.2.1: decode the DC coefficient difference */
+ HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
+ if (s) {
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ }
+
+ /* Convert DC difference to actual value, update last_dc_val */
+ s += state.last_dc_val[ci];
+ state.last_dc_val[ci] = s;
+ /* Scale and output the coefficient (assumes jpeg_natural_order[0]=0) */
+ (*block)[0] = (JCOEF) (s << Al);
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ ASSIGN_STATE(entropy->saved, state);
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Se = cinfo->Se;
+ int Al = cinfo->Al;
+ register int s, k, r;
+ unsigned int EOBRUN;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+ d_derived_tbl * tbl;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, just leave the MCU set to zeroes.
+ * This way, we return uniform gray for the remainder of the segment.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state.
+ * We can avoid loading/saving bitread state if in an EOB run.
+ */
+ EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
+
+ /* There is always only one block per MCU */
+
+ if (EOBRUN > 0) /* if it's a band of zeroes... */
+ EOBRUN--; /* ...process it now (we do nothing) */
+ else {
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ block = MCU_data[0];
+ tbl = entropy->ac_derived_tbl;
+
+ for (k = cinfo->Ss; k <= Se; k++) {
+ HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
+ r = s >> 4;
+ s &= 15;
+ if (s) {
+ k += r;
+ CHECK_BIT_BUFFER(br_state, s, return FALSE);
+ r = GET_BITS(s);
+ s = HUFF_EXTEND(r, s);
+ /* Scale and output coefficient in natural (dezigzagged) order */
+ (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
+ } else {
+ if (r == 15) { /* ZRL */
+ k += 15; /* skip 15 zeroes in band */
+ } else { /* EOBr, run length is 2^r + appended bits */
+ EOBRUN = 1 << r;
+ if (r) { /* EOBr, r > 0 */
+ CHECK_BIT_BUFFER(br_state, r, return FALSE);
+ r = GET_BITS(r);
+ EOBRUN += r;
+ }
+ EOBRUN--; /* this band is processed at this moment */
+ break; /* force end-of-band */
+ }
+ }
+ }
+
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ }
+
+ /* Completed MCU, so update state */
+ entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF(boolean)
+decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
+ int blkn;
+ JBLOCKROW block;
+ BITREAD_STATE_VARS;
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* Not worth the cycles to check insufficient_data here,
+ * since we will not change the data anyway if we read zeroes.
+ */
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+
+ /* Outer loop handles each block in the MCU */
+
+ for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+ block = MCU_data[blkn];
+
+ /* Encoded data is simply the next bit of the two's-complement DC value */
+ CHECK_BIT_BUFFER(br_state, 1, return FALSE);
+ if (GET_BITS(1))
+ (*block)[0] |= p1;
+ /* Note: since we use |=, repeating the assignment later is safe */
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+}
+
+
+/*
+ * MCU decoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF(boolean)
+decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+ phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+ int Se = cinfo->Se;
+ int p1 = 1 << cinfo->Al; /* 1 in the bit position being coded */
+ int m1 = (-1) << cinfo->Al; /* -1 in the bit position being coded */
+ register int s, k, r;
+ unsigned int EOBRUN;
+ JBLOCKROW block;
+ JCOEFPTR thiscoef;
+ BITREAD_STATE_VARS;
+ d_derived_tbl * tbl;
+ int num_newnz;
+ int newnz_pos[DCTSIZE2];
+
+ /* Process restart marker if needed; may have to suspend */
+ if (cinfo->restart_interval) {
+ if (entropy->restarts_to_go == 0)
+ if (! process_restart(cinfo))
+ return FALSE;
+ }
+
+ /* If we've run out of data, don't modify the MCU.
+ */
+ if (! entropy->pub.insufficient_data) {
+
+ /* Load up working state */
+ BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+ EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */
+
+ /* There is always only one block per MCU */
+ block = MCU_data[0];
+ tbl = entropy->ac_derived_tbl;
+
+ /* If we are forced to suspend, we must undo the assignments to any newly
+ * nonzero coefficients in the block, because otherwise we'd get confused
+ * next time about which coefficients were already nonzero.
+ * But we need not undo addition of bits to already-nonzero coefficients;
+ * instead, we can test the current bit to see if we already did it.
+ */
+ num_newnz = 0;
+
+ /* initialize coefficient loop counter to start of band */
+ k = cinfo->Ss;
+
+ if (EOBRUN == 0) {
+ for (; k <= Se; k++) {
+ HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
+ r = s >> 4;
+ s &= 15;
+ if (s) {
+ if (s != 1) /* size of new coef should always be 1 */
+ WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1))
+ s = p1; /* newly nonzero coef is positive */
+ else
+ s = m1; /* newly nonzero coef is negative */
+ } else {
+ if (r != 15) {
+ EOBRUN = 1 << r; /* EOBr, run length is 2^r + appended bits */
+ if (r) {
+ CHECK_BIT_BUFFER(br_state, r, goto undoit);
+ r = GET_BITS(r);
+ EOBRUN += r;
+ }
+ break; /* rest of block is handled by EOB logic */
+ }
+ /* note s = 0 for processing ZRL */
+ }
+ /* Advance over already-nonzero coefs and r still-zero coefs,
+ * appending correction bits to the nonzeroes. A correction bit is 1
+ * if the absolute value of the coefficient must be increased.
+ */
+ do {
+ thiscoef = *block + jpeg_natural_order[k];
+ if (*thiscoef != 0) {
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1)) {
+ if ((*thiscoef & p1) == 0) { /* do nothing if already set it */
+ if (*thiscoef >= 0)
+ *thiscoef += p1;
+ else
+ *thiscoef += m1;
+ }
+ }
+ } else {
+ if (--r < 0)
+ break; /* reached target zero coefficient */
+ }
+ k++;
+ } while (k <= Se);
+ if (s) {
+ int pos = jpeg_natural_order[k];
+ /* Output newly nonzero coefficient */
+ (*block)[pos] = (JCOEF) s;
+ /* Remember its position in case we have to suspend */
+ newnz_pos[num_newnz++] = pos;
+ }
+ }
+ }
+
+ if (EOBRUN > 0) {
+ /* Scan any remaining coefficient positions after the end-of-band
+ * (the last newly nonzero coefficient, if any). Append a correction
+ * bit to each already-nonzero coefficient. A correction bit is 1
+ * if the absolute value of the coefficient must be increased.
+ */
+ for (; k <= Se; k++) {
+ thiscoef = *block + jpeg_natural_order[k];
+ if (*thiscoef != 0) {
+ CHECK_BIT_BUFFER(br_state, 1, goto undoit);
+ if (GET_BITS(1)) {
+ if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
+ if (*thiscoef >= 0)
+ *thiscoef += p1;
+ else
+ *thiscoef += m1;
+ }
+ }
+ }
+ }
+ /* Count one block completed in EOB run */
+ EOBRUN--;
+ }
+
+ /* Completed MCU, so update state */
+ BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+ entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we need */
+ }
+
+ /* Account for restart interval (no-op if not using restarts) */
+ entropy->restarts_to_go--;
+
+ return TRUE;
+
+undoit:
+ /* Re-zero any output coefficients that we made newly nonzero */
+ while (num_newnz > 0)
+ (*block)[newnz_pos[--num_newnz]] = 0;
+
+ return FALSE;
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy decoding.
+ */
+
+GLOBAL(void)
+jinit_phuff_decoder (j_decompress_ptr cinfo)
+{
+ phuff_entropy_ptr entropy;
+ int *coef_bit_ptr;
+ int ci, i;
+
+ entropy = (phuff_entropy_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(phuff_entropy_decoder));
+ cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+ entropy->pub.start_pass = start_pass_phuff_decoder;
+
+ /* Mark derived tables unallocated */
+ for (i = 0; i < NUM_HUFF_TBLS; i++) {
+ entropy->derived_tbls[i] = NULL;
+ }
+
+ /* Create progression status table */
+ cinfo->coef_bits = (int (*)[DCTSIZE2])
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->num_components*DCTSIZE2*SIZEOF(int));
+ coef_bit_ptr = & cinfo->coef_bits[0][0];
+ for (ci = 0; ci < cinfo->num_components; ci++)
+ for (i = 0; i < DCTSIZE2; i++)
+ *coef_bit_ptr++ = -1;
+}
+
+#endif /* D_PROGRESSIVE_SUPPORTED */
--- /dev/null
+/*
+ * jdpostct.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+ struct jpeg_d_post_controller pub; /* public fields */
+
+ /* Color quantization source buffer: this holds output data from
+ * the upsample/color conversion step to be passed to the quantizer.
+ * For two-pass color quantization, we need a full-image buffer;
+ * for one-pass operation, a strip buffer is sufficient.
+ */
+ jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
+ JSAMPARRAY buffer; /* strip buffer, or current strip of virtual */
+ JDIMENSION strip_height; /* buffer size in rows */
+ /* for two-pass mode only: */
+ JDIMENSION starting_row; /* row # of first row in current strip */
+ JDIMENSION next_row; /* index of next row to fill/empty in strip */
+} my_post_controller;
+
+typedef my_post_controller * my_post_ptr;
+
+
+/* Forward declarations */
+METHODDEF(void) post_process_1pass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF(void) post_process_prepass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+METHODDEF(void) post_process_2pass
+ JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF(void)
+start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+
+ switch (pass_mode) {
+ case JBUF_PASS_THRU:
+ if (cinfo->quantize_colors) {
+ /* Single-pass processing with color quantization. */
+ post->pub.post_process_data = post_process_1pass;
+ /* We could be doing buffered-image output before starting a 2-pass
+ * color quantization; in that case, jinit_d_post_controller did not
+ * allocate a strip buffer. Use the virtual-array buffer as workspace.
+ */
+ if (post->buffer == NULL) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ (JDIMENSION) 0, post->strip_height, TRUE);
+ }
+ } else {
+ /* For single-pass processing without color quantization,
+ * I have no work to do; just call the upsampler directly.
+ */
+ post->pub.post_process_data = cinfo->upsample->upsample;
+ }
+ break;
+#ifdef QUANT_2PASS_SUPPORTED
+ case JBUF_SAVE_AND_PASS:
+ /* First pass of 2-pass quantization */
+ if (post->whole_image == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ post->pub.post_process_data = post_process_prepass;
+ break;
+ case JBUF_CRANK_DEST:
+ /* Second pass of 2-pass quantization */
+ if (post->whole_image == NULL)
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ post->pub.post_process_data = post_process_2pass;
+ break;
+#endif /* QUANT_2PASS_SUPPORTED */
+ default:
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+ break;
+ }
+ post->starting_row = post->next_row = 0;
+}
+
+
+/*
+ * Process some data in the one-pass (strip buffer) case.
+ * This is used for color precision reduction as well as one-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_1pass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION num_rows, max_rows;
+
+ /* Fill the buffer, but not more than what we can dump out in one go. */
+ /* Note we rely on the upsampler to detect bottom of image. */
+ max_rows = out_rows_avail - *out_row_ctr;
+ if (max_rows > post->strip_height)
+ max_rows = post->strip_height;
+ num_rows = 0;
+ (*cinfo->upsample->upsample) (cinfo,
+ input_buf, in_row_group_ctr, in_row_groups_avail,
+ post->buffer, &num_rows, max_rows);
+ /* Quantize and emit data. */
+ (*cinfo->cquantize->color_quantize) (cinfo,
+ post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+ *out_row_ctr += num_rows;
+}
+
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+/*
+ * Process some data in the first pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_prepass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION old_next_row, num_rows;
+
+ /* Reposition virtual buffer if at start of strip. */
+ if (post->next_row == 0) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ post->starting_row, post->strip_height, TRUE);
+ }
+
+ /* Upsample some data (up to a strip height's worth). */
+ old_next_row = post->next_row;
+ (*cinfo->upsample->upsample) (cinfo,
+ input_buf, in_row_group_ctr, in_row_groups_avail,
+ post->buffer, &post->next_row, post->strip_height);
+
+ /* Allow quantizer to scan new data. No data is emitted, */
+ /* but we advance out_row_ctr so outer loop can tell when we're done. */
+ if (post->next_row > old_next_row) {
+ num_rows = post->next_row - old_next_row;
+ (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
+ (JSAMPARRAY) NULL, (int) num_rows);
+ *out_row_ctr += num_rows;
+ }
+
+ /* Advance if we filled the strip. */
+ if (post->next_row >= post->strip_height) {
+ post->starting_row += post->strip_height;
+ post->next_row = 0;
+ }
+}
+
+
+/*
+ * Process some data in the second pass of 2-pass quantization.
+ */
+
+METHODDEF(void)
+post_process_2pass (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_post_ptr post = (my_post_ptr) cinfo->post;
+ JDIMENSION num_rows, max_rows;
+
+ /* Reposition virtual buffer if at start of strip. */
+ if (post->next_row == 0) {
+ post->buffer = (*cinfo->mem->access_virt_sarray)
+ ((j_common_ptr) cinfo, post->whole_image,
+ post->starting_row, post->strip_height, FALSE);
+ }
+
+ /* Determine number of rows to emit. */
+ num_rows = post->strip_height - post->next_row; /* available in strip */
+ max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
+ if (num_rows > max_rows)
+ num_rows = max_rows;
+ /* We have to check bottom of image here, can't depend on upsampler. */
+ max_rows = cinfo->output_height - post->starting_row;
+ if (num_rows > max_rows)
+ num_rows = max_rows;
+
+ /* Quantize and emit data. */
+ (*cinfo->cquantize->color_quantize) (cinfo,
+ post->buffer + post->next_row, output_buf + *out_row_ctr,
+ (int) num_rows);
+ *out_row_ctr += num_rows;
+
+ /* Advance if we filled the strip. */
+ post->next_row += num_rows;
+ if (post->next_row >= post->strip_height) {
+ post->starting_row += post->strip_height;
+ post->next_row = 0;
+ }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize postprocessing controller.
+ */
+
+GLOBAL(void)
+jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+ my_post_ptr post;
+
+ post = (my_post_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_post_controller));
+ cinfo->post = (struct jpeg_d_post_controller *) post;
+ post->pub.start_pass = start_pass_dpost;
+ post->whole_image = NULL; /* flag for no virtual arrays */
+ post->buffer = NULL; /* flag for no strip buffer */
+
+ /* Create the quantization buffer, if needed */
+ if (cinfo->quantize_colors) {
+ /* The buffer strip height is max_v_samp_factor, which is typically
+ * an efficient number of rows for upsampling to return.
+ * (In the presence of output rescaling, we might want to be smarter?)
+ */
+ post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
+ if (need_full_buffer) {
+ /* Two-pass color quantization: need full-image storage. */
+ /* We round up the number of rows to a multiple of the strip height. */
+#ifdef QUANT_2PASS_SUPPORTED
+ post->whole_image = (*cinfo->mem->request_virt_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+ cinfo->output_width * cinfo->out_color_components,
+ (JDIMENSION) jround_up((long) cinfo->output_height,
+ (long) post->strip_height),
+ post->strip_height);
+#else
+ ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif /* QUANT_2PASS_SUPPORTED */
+ } else {
+ /* One-pass color quantization: just make a strip buffer. */
+ post->buffer = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ cinfo->output_width * cinfo->out_color_components,
+ post->strip_height);
+ }
+ }
+}
--- /dev/null
+/*
+ * jdsample.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups". A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component. Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ * Digital Image Warping, George Wolberg, 1990.
+ * Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to upsample a single component */
+typedef JMETHOD(void, upsample1_ptr,
+ (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_upsampler pub; /* public fields */
+
+ /* Color conversion buffer. When using separate upsampling and color
+ * conversion steps, this buffer holds one upsampled row group until it
+ * has been color converted and output.
+ * Note: we do not allocate any storage for component(s) which are full-size,
+ * ie do not need rescaling. The corresponding entry of color_buf[] is
+ * simply set to point to the input data array, thereby avoiding copying.
+ */
+ JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+ /* Per-component upsampling method pointers */
+ upsample1_ptr methods[MAX_COMPONENTS];
+
+ int next_row_out; /* counts rows emitted from color_buf */
+ JDIMENSION rows_to_go; /* counts rows remaining in image */
+
+ /* Height of an input row group for each component. */
+ int rowgroup_height[MAX_COMPONENTS];
+
+ /* These arrays save pixel expansion factors so that int_expand need not
+ * recompute them each time. They are unused for other upsampling methods.
+ */
+ UINT8 h_expand[MAX_COMPONENTS];
+ UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF(void)
+start_pass_upsample (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+ /* Mark the conversion buffer empty */
+ upsample->next_row_out = cinfo->max_v_samp_factor;
+ /* Initialize total-height counter for detecting bottom of image */
+ upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * In this version we upsample each component independently.
+ * We upsample one row group into the conversion buffer, then apply
+ * color conversion a row at a time.
+ */
+
+METHODDEF(void)
+sep_upsample (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ int ci;
+ jpeg_component_info * compptr;
+ JDIMENSION num_rows;
+
+ /* Fill the conversion buffer, if it's empty */
+ if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Invoke per-component upsample method. Notice we pass a POINTER
+ * to color_buf[ci], so that fullsize_upsample can change it.
+ */
+ (*upsample->methods[ci]) (cinfo, compptr,
+ input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+ upsample->color_buf + ci);
+ }
+ upsample->next_row_out = 0;
+ }
+
+ /* Color-convert and emit rows */
+
+ /* How many we have in the buffer: */
+ num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
+ /* Not more than the distance to the end of the image. Need this test
+ * in case the image height is not a multiple of max_v_samp_factor:
+ */
+ if (num_rows > upsample->rows_to_go)
+ num_rows = upsample->rows_to_go;
+ /* And not more than what the client can accept: */
+ out_rows_avail -= *out_row_ctr;
+ if (num_rows > out_rows_avail)
+ num_rows = out_rows_avail;
+
+ (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
+ (JDIMENSION) upsample->next_row_out,
+ output_buf + *out_row_ctr,
+ (int) num_rows);
+
+ /* Adjust counts */
+ *out_row_ctr += num_rows;
+ upsample->rows_to_go -= num_rows;
+ upsample->next_row_out += num_rows;
+ /* When the buffer is emptied, declare this input row group consumed */
+ if (upsample->next_row_out >= cinfo->max_v_samp_factor)
+ (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by sep_upsample to upsample pixel values
+ * of a single component. One row group is processed per call.
+ */
+
+
+/*
+ * For full-size components, we just make color_buf[ci] point at the
+ * input buffer, and thus avoid copying any data. Note that this is
+ * safe only because sep_upsample doesn't declare the input row group
+ * "consumed" until we are done color converting and emitting it.
+ */
+
+METHODDEF(void)
+fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ *output_data_ptr = input_data;
+}
+
+
+/*
+ * This is a no-op version used for "uninteresting" components.
+ * These components will not be referenced by color conversion.
+ */
+
+METHODDEF(void)
+noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ *output_data_ptr = NULL; /* safety check */
+}
+
+
+/*
+ * This version handles any integral sampling ratios.
+ * This is not used for typical JPEG files, so it need not be fast.
+ * Nor, for that matter, is it particularly accurate: the algorithm is
+ * simple replication of the input pixel onto the corresponding output
+ * pixels. The hi-falutin sampling literature refers to this as a
+ * "box filter". A box filter tends to introduce visible artifacts,
+ * so if you are actually going to use 3:1 or 4:1 sampling ratios
+ * you would be well advised to improve this code.
+ */
+
+METHODDEF(void)
+int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ register int h;
+ JSAMPROW outend;
+ int h_expand, v_expand;
+ int inrow, outrow;
+
+ h_expand = upsample->h_expand[compptr->component_index];
+ v_expand = upsample->v_expand[compptr->component_index];
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ /* Generate one output row with proper horizontal expansion */
+ inptr = input_data[inrow];
+ outptr = output_data[outrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ for (h = h_expand; h > 0; h--) {
+ *outptr++ = invalue;
+ }
+ }
+ /* Generate any additional output rows by duplicating the first one */
+ if (v_expand > 1) {
+ jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+ v_expand-1, cinfo->output_width);
+ }
+ inrow++;
+ outrow += v_expand;
+ }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ JSAMPROW outend;
+ int inrow;
+
+ for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+ inptr = input_data[inrow];
+ outptr = output_data[inrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ *outptr++ = invalue;
+ *outptr++ = invalue;
+ }
+ }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF(void)
+h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register JSAMPLE invalue;
+ JSAMPROW outend;
+ int inrow, outrow;
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ inptr = input_data[inrow];
+ outptr = output_data[outrow];
+ outend = outptr + cinfo->output_width;
+ while (outptr < outend) {
+ invalue = *inptr++; /* don't need GETJSAMPLE() here */
+ *outptr++ = invalue;
+ *outptr++ = invalue;
+ }
+ jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+ 1, cinfo->output_width);
+ inrow++;
+ outrow += 2;
+ }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+ *
+ * The upsampling algorithm is linear interpolation between pixel centers,
+ * also known as a "triangle filter". This is a good compromise between
+ * speed and visual quality. The centers of the output pixels are 1/4 and 3/4
+ * of the way between input pixel centers.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF(void)
+h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr, outptr;
+ register int invalue;
+ register JDIMENSION colctr;
+ int inrow;
+
+ for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+ inptr = input_data[inrow];
+ outptr = output_data[inrow];
+ /* Special case for first column */
+ invalue = GETJSAMPLE(*inptr++);
+ *outptr++ = (JSAMPLE) invalue;
+ *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
+
+ for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+ /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
+ invalue = GETJSAMPLE(*inptr++) * 3;
+ *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
+ *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
+ }
+
+ /* Special case for last column */
+ invalue = GETJSAMPLE(*inptr);
+ *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
+ *outptr++ = (JSAMPLE) invalue;
+ }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * Again a triangle filter; see comments for h2v1 case, above.
+ *
+ * It is OK for us to reference the adjacent input rows because we demanded
+ * context from the main buffer controller (see initialization code).
+ */
+
+METHODDEF(void)
+h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+ JSAMPARRAY output_data = *output_data_ptr;
+ register JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+ register int thiscolsum, lastcolsum, nextcolsum;
+#else
+ register INT32 thiscolsum, lastcolsum, nextcolsum;
+#endif
+ register JDIMENSION colctr;
+ int inrow, outrow, v;
+
+ inrow = outrow = 0;
+ while (outrow < cinfo->max_v_samp_factor) {
+ for (v = 0; v < 2; v++) {
+ /* inptr0 points to nearest input row, inptr1 points to next nearest */
+ inptr0 = input_data[inrow];
+ if (v == 0) /* next nearest is row above */
+ inptr1 = input_data[inrow-1];
+ else /* next nearest is row below */
+ inptr1 = input_data[inrow+1];
+ outptr = output_data[outrow++];
+
+ /* Special case for first column */
+ thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+ lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+
+ for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+ /* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+ /* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+ nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+ lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+ }
+
+ /* Special case for last column */
+ *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+ *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
+ }
+ inrow++;
+ }
+}
+
+
+/*
+ * Module initialization routine for upsampling.
+ */
+
+GLOBAL(void)
+jinit_upsampler (j_decompress_ptr cinfo)
+{
+ my_upsample_ptr upsample;
+ int ci;
+ jpeg_component_info * compptr;
+ boolean need_buffer, do_fancy;
+ int h_in_group, v_in_group, h_out_group, v_out_group;
+
+ upsample = (my_upsample_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_upsampler));
+ cinfo->upsample = (struct jpeg_upsampler *) upsample;
+ upsample->pub.start_pass = start_pass_upsample;
+ upsample->pub.upsample = sep_upsample;
+ upsample->pub.need_context_rows = FALSE; /* until we find out differently */
+
+ if (cinfo->CCIR601_sampling) /* this isn't supported */
+ ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+ /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
+ * so don't ask for it.
+ */
+ do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
+
+ /* Verify we can handle the sampling factors, select per-component methods,
+ * and create storage as needed.
+ */
+ for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+ ci++, compptr++) {
+ /* Compute size of an "input group" after IDCT scaling. This many samples
+ * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
+ */
+ h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size;
+ v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+ cinfo->min_DCT_scaled_size;
+ h_out_group = cinfo->max_h_samp_factor;
+ v_out_group = cinfo->max_v_samp_factor;
+ upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
+ need_buffer = TRUE;
+ if (! compptr->component_needed) {
+ /* Don't bother to upsample an uninteresting component. */
+ upsample->methods[ci] = noop_upsample;
+ need_buffer = FALSE;
+ } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
+ /* Fullsize components can be processed without any work. */
+ upsample->methods[ci] = fullsize_upsample;
+ need_buffer = FALSE;
+ } else if (h_in_group * 2 == h_out_group &&
+ v_in_group == v_out_group) {
+ /* Special cases for 2h1v upsampling */
+ if (do_fancy && compptr->downsampled_width > 2)
+ upsample->methods[ci] = h2v1_fancy_upsample;
+ else
+ upsample->methods[ci] = h2v1_upsample;
+ } else if (h_in_group * 2 == h_out_group &&
+ v_in_group * 2 == v_out_group) {
+ /* Special cases for 2h2v upsampling */
+ if (do_fancy && compptr->downsampled_width > 2) {
+ upsample->methods[ci] = h2v2_fancy_upsample;
+ upsample->pub.need_context_rows = TRUE;
+ } else
+ upsample->methods[ci] = h2v2_upsample;
+ } else if ((h_out_group % h_in_group) == 0 &&
+ (v_out_group % v_in_group) == 0) {
+ /* Generic integral-factors upsampling method */
+ upsample->methods[ci] = int_upsample;
+ upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
+ upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
+ } else
+ ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+ if (need_buffer) {
+ upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) jround_up((long) cinfo->output_width,
+ (long) cinfo->max_h_samp_factor),
+ (JDIMENSION) cinfo->max_v_samp_factor);
+ }
+ }
+}
--- /dev/null
+/*
+ * jdtrans.c
+ *
+ * Copyright (C) 1995-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL(void) transdecode_master_selection JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component. The return value is a pointer to the array of
+ * virtual-array descriptors. These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * An alternative usage is to simply obtain access to the coefficient arrays
+ * during a buffered-image-mode decompression operation. This is allowed
+ * after any jpeg_finish_output() call. The arrays can be accessed until
+ * jpeg_finish_decompress() is called. (Note that any call to the library
+ * may reposition the arrays, so don't rely on access_virt_barray() results
+ * to stay valid across library calls.)
+ *
+ * Returns NULL if suspended. This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL(jvirt_barray_ptr *)
+jpeg_read_coefficients (j_decompress_ptr cinfo)
+{
+ if (cinfo->global_state == DSTATE_READY) {
+ /* First call: initialize active modules */
+ transdecode_master_selection(cinfo);
+ cinfo->global_state = DSTATE_RDCOEFS;
+ }
+ if (cinfo->global_state == DSTATE_RDCOEFS) {
+ /* Absorb whole file into the coef buffer */
+ for (;;) {
+ int retcode;
+ /* Call progress monitor hook if present */
+ if (cinfo->progress != NULL)
+ (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+ /* Absorb some more input */
+ retcode = (*cinfo->inputctl->consume_input) (cinfo);
+ if (retcode == JPEG_SUSPENDED)
+ return NULL;
+ if (retcode == JPEG_REACHED_EOI)
+ break;
+ /* Advance progress counter if appropriate */
+ if (cinfo->progress != NULL &&
+ (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+ if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+ /* startup underestimated number of scans; ratchet up one scan */
+ cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+ }
+ }
+ }
+ /* Set state so that jpeg_finish_decompress does the right thing */
+ cinfo->global_state = DSTATE_STOPPING;
+ }
+ /* At this point we should be in state DSTATE_STOPPING if being used
+ * standalone, or in state DSTATE_BUFIMAGE if being invoked to get access
+ * to the coefficients during a full buffered-image-mode decompression.
+ */
+ if ((cinfo->global_state == DSTATE_STOPPING ||
+ cinfo->global_state == DSTATE_BUFIMAGE) && cinfo->buffered_image) {
+ return cinfo->coef->coef_arrays;
+ }
+ /* Oops, improper usage */
+ ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+ return NULL; /* keep compiler happy */
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL(void)
+transdecode_master_selection (j_decompress_ptr cinfo)
+{
+ /* This is effectively a buffered-image operation. */
+ cinfo->buffered_image = TRUE;
+
+ /* Entropy decoding: either Huffman or arithmetic coding. */
+ if (cinfo->arith_code) {
+ ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+ } else {
+ if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+ jinit_phuff_decoder(cinfo);
+#else
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+ } else
+ jinit_huff_decoder(cinfo);
+ }
+
+ /* Always get a full-image coefficient buffer. */
+ jinit_d_coef_controller(cinfo, TRUE);
+
+ /* We can now tell the memory manager to allocate virtual arrays. */
+ (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+ /* Initialize input side of decompressor to consume first scan. */
+ (*cinfo->inputctl->start_input_pass) (cinfo);
+
+ /* Initialize progress monitoring. */
+ if (cinfo->progress != NULL) {
+ int nscans;
+ /* Estimate number of scans to set pass_limit. */
+ if (cinfo->progressive_mode) {
+ /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+ nscans = 2 + 3 * cinfo->num_components;
+ } else if (cinfo->inputctl->has_multiple_scans) {
+ /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+ nscans = cinfo->num_components;
+ } else {
+ nscans = 1;
+ }
+ cinfo->progress->pass_counter = 0L;
+ cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+ cinfo->progress->completed_passes = 0;
+ cinfo->progress->total_passes = 1;
+ }
+}
--- /dev/null
+/*
+ * jerror.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do. Many applications will want to replace
+ * some or all of these routines.
+ *
+ * If you define USE_WINDOWS_MESSAGEBOX in jconfig.h or in the makefile,
+ * you get a Windows-specific hack to display error messages in a dialog box.
+ * It ain't much, but it beats dropping error messages into the bit bucket,
+ * which is what happens to output to stderr under most Windows C compilers.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jversion.h"
+#include "jerror.h"
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+#include <windows.h>
+#endif
+
+#ifndef EXIT_FAILURE /* define exit() codes if not provided */
+#define EXIT_FAILURE 1
+#endif
+
+
+/*
+ * Create the message string table.
+ * We do this from the master message list in jerror.h by re-reading
+ * jerror.h with a suitable definition for macro JMESSAGE.
+ * The message table is made an external symbol just in case any applications
+ * want to refer to it directly.
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_message_table jMsgTable
+#endif
+
+#define JMESSAGE(code,string) string ,
+
+const char * const jpeg_std_message_table[] = {
+#include "jerror.h"
+ NULL
+};
+
+
+/*
+ * Error exit handler: must not return to caller.
+ *
+ * Applications may override this if they want to get control back after
+ * an error. Typically one would longjmp somewhere instead of exiting.
+ * The setjmp buffer can be made a private field within an expanded error
+ * handler object. Note that the info needed to generate an error message
+ * is stored in the error object, so you can generate the message now or
+ * later, at your convenience.
+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort
+ * or jpeg_destroy) at some point.
+ */
+
+METHODDEF(void)
+error_exit (j_common_ptr cinfo)
+{
+ /* Always display the message */
+ (*cinfo->err->output_message) (cinfo);
+
+ /* Let the memory manager delete any temp files before we die */
+ jpeg_destroy(cinfo);
+
+ exit(EXIT_FAILURE);
+}
+
+
+/*
+ * Actual output of an error or trace message.
+ * Applications may override this method to send JPEG messages somewhere
+ * other than stderr.
+ *
+ * On Windows, printing to stderr is generally completely useless,
+ * so we provide optional code to produce an error-dialog popup.
+ * Most Windows applications will still prefer to override this routine,
+ * but if they don't, it'll do something at least marginally useful.
+ *
+ * NOTE: to use the library in an environment that doesn't support the
+ * C stdio library, you may have to delete the call to fprintf() entirely,
+ * not just not use this routine.
+ */
+
+METHODDEF(void)
+output_message (j_common_ptr cinfo)
+{
+ char buffer[JMSG_LENGTH_MAX];
+
+ /* Create the message */
+ (*cinfo->err->format_message) (cinfo, buffer);
+
+#ifdef USE_WINDOWS_MESSAGEBOX
+ /* Display it in a message dialog box */
+ MessageBox(GetActiveWindow(), buffer, "JPEG Library Error",
+ MB_OK | MB_ICONERROR);
+#else
+ /* Send it to stderr, adding a newline */
+ fprintf(stderr, "%s\n", buffer);
+#endif
+}
+
+
+/*
+ * Decide whether to emit a trace or warning message.
+ * msg_level is one of:
+ * -1: recoverable corrupt-data warning, may want to abort.
+ * 0: important advisory messages (always display to user).
+ * 1: first level of tracing detail.
+ * 2,3,...: successively more detailed tracing messages.
+ * An application might override this method if it wanted to abort on warnings
+ * or change the policy about which messages to display.
+ */
+
+METHODDEF(void)
+emit_message (j_common_ptr cinfo, int msg_level)
+{
+ struct jpeg_error_mgr * err = cinfo->err;
+
+ if (msg_level < 0) {
+ /* It's a warning message. Since corrupt files may generate many warnings,
+ * the policy implemented here is to show only the first warning,
+ * unless trace_level >= 3.
+ */
+ if (err->num_warnings == 0 || err->trace_level >= 3)
+ (*err->output_message) (cinfo);
+ /* Always count warnings in num_warnings. */
+ err->num_warnings++;
+ } else {
+ /* It's a trace message. Show it if trace_level >= msg_level. */
+ if (err->trace_level >= msg_level)
+ (*err->output_message) (cinfo);
+ }
+}
+
+
+/*
+ * Format a message string for the most recent JPEG error or message.
+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
+ * characters. Note that no '\n' character is added to the string.
+ * Few applications should need to override this method.
+ */
+
+METHODDEF(void)
+format_message (j_common_ptr cinfo, char * buffer)
+{
+ struct jpeg_error_mgr * err = cinfo->err;
+ int msg_code = err->msg_code;
+ const char * msgtext = NULL;
+ const char * msgptr;
+ char ch;
+ boolean isstring;
+
+ /* Look up message string in proper table */
+ if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
+ msgtext = err->jpeg_message_table[msg_code];
+ } else if (err->addon_message_table != NULL &&
+ msg_code >= err->first_addon_message &&
+ msg_code <= err->last_addon_message) {
+ msgtext = err->addon_message_table[msg_code - err->first_addon_message];
+ }
+
+ /* Defend against bogus message number */
+ if (msgtext == NULL) {
+ err->msg_parm.i[0] = msg_code;
+ msgtext = err->jpeg_message_table[0];
+ }
+
+ /* Check for string parameter, as indicated by %s in the message text */
+ isstring = FALSE;
+ msgptr = msgtext;
+ while ((ch = *msgptr++) != '\0') {
+ if (ch == '%') {
+ if (*msgptr == 's') isstring = TRUE;
+ break;
+ }
+ }
+
+ /* Format the message into the passed buffer */
+ if (isstring)
+ sprintf(buffer, msgtext, err->msg_parm.s);
+ else
+ sprintf(buffer, msgtext,
+ err->msg_parm.i[0], err->msg_parm.i[1],
+ err->msg_parm.i[2], err->msg_parm.i[3],
+ err->msg_parm.i[4], err->msg_parm.i[5],
+ err->msg_parm.i[6], err->msg_parm.i[7]);
+}
+
+
+/*
+ * Reset error state variables at start of a new image.
+ * This is called during compression startup to reset trace/error
+ * processing to default state, without losing any application-specific
+ * method pointers. An application might possibly want to override
+ * this method if it has additional error processing state.
+ */
+
+METHODDEF(void)
+reset_error_mgr (j_common_ptr cinfo)
+{
+ cinfo->err->num_warnings = 0;
+ /* trace_level is not reset since it is an application-supplied parameter */
+ cinfo->err->msg_code = 0; /* may be useful as a flag for "no error" */
+}
+
+
+/*
+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.
+ * Typical call is:
+ * struct jpeg_compress_struct cinfo;
+ * struct jpeg_error_mgr err;
+ *
+ * cinfo.err = jpeg_std_error(&err);
+ * after which the application may override some of the methods.
+ */
+
+GLOBAL(struct jpeg_error_mgr *)
+jpeg_std_error (struct jpeg_error_mgr * err)
+{
+ err->error_exit = error_exit;
+ err->emit_message = emit_message;
+ err->output_message = output_message;
+ err->format_message = format_message;
+ err->reset_error_mgr = reset_error_mgr;
+
+ err->trace_level = 0; /* default = no tracing */
+ err->num_warnings = 0; /* no warnings emitted yet */
+ err->msg_code = 0; /* may be useful as a flag for "no error" */
+
+ /* Initialize message table pointers */
+ err->jpeg_message_table = jpeg_std_message_table;
+ err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
+
+ err->addon_message_table = NULL;
+ err->first_addon_message = 0; /* for safety */
+ err->last_addon_message = 0;
+
+ return err;
+}
--- /dev/null
+/*
+ * jerror.h
+ *
+ * Copyright (C) 1994-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too. Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE. To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string) code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+JMESSAGE(JERR_ARITH_NOTIMPL,
+ "Sorry, there are legal restrictions on arithmetic coding")
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range")
+JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported")
+JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_LIB_VERSION,
+ "Wrong JPEG library version: library is %d, caller expects %d")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+ "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+ "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_STRUCT_SIZE,
+ "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+ "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+ "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+ "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+ "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+ "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+ "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_EXTENSION,
+ "JFIF extension marker: type 0x%02x, length %u")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+ "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_THUMB_JPEG,
+ "JFIF extension marker: JPEG-compressed thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_PALETTE,
+ "JFIF extension marker: palette thumbnail image, length %u")
+JMESSAGE(JTRC_THUMB_RGB,
+ "JFIF extension marker: RGB thumbnail image, length %u")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+ "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+ "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+ "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+ "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+
+#ifdef JMAKE_ENUM_LIST
+
+ JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (cinfo)->err->msg_parm.i[2] = (p3), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (cinfo)->err->msg_parm.i[2] = (p3), \
+ (cinfo)->err->msg_parm.i[3] = (p4), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str) \
+ ((cinfo)->err->msg_code = (code), \
+ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+ (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+
+#define MAKESTMT(stuff) do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo,lvl,code) \
+ ((cinfo)->err->msg_code = (code), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2) \
+ ((cinfo)->err->msg_code = (code), \
+ (cinfo)->err->msg_parm.i[0] = (p1), \
+ (cinfo)->err->msg_parm.i[1] = (p2), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ _mp[4] = (p5); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \
+ MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+ _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+ _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
+ (cinfo)->err->msg_code = (code); \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str) \
+ ((cinfo)->err->msg_code = (code), \
+ strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+ (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+
+#endif /* JERROR_H */
--- /dev/null
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations. However, it may not give the same results on all
+ * machines because of differences in roundoff behavior. Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values. However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_float (FAST_FLOAT * data)
+{
+ FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+ FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
+ FAST_FLOAT *dataptr;
+ int ctr;
+
+ /* Pass 1: process rows. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[4] = tmp10 - tmp11;
+
+ z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+ dataptr[2] = tmp13 + z1; /* phase 5 */
+ dataptr[6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[5] = z13 + z2; /* phase 6 */
+ dataptr[3] = z13 - z2;
+ dataptr[1] = z11 + z4;
+ dataptr[7] = z11 - z4;
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[DCTSIZE*4] = tmp10 - tmp11;
+
+ z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+ dataptr[DCTSIZE*6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+ z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+ z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+ z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+ dataptr[DCTSIZE*3] = z13 - z2;
+ dataptr[DCTSIZE*1] = z11 + z4;
+ dataptr[DCTSIZE*7] = z11 - z4;
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
--- /dev/null
+/*
+ * jfdctfst.c
+ *
+ * Copyright (C) 1994-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values. The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jfdctint.c for more details. However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * Again to save a few shifts, the intermediate results between pass 1 and
+ * pass 2 are not upscaled, but are represented only to integral precision.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13. This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#define CONST_BITS 8
+
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_0_382683433 ((INT32) 98) /* FIX(0.382683433) */
+#define FIX_0_541196100 ((INT32) 139) /* FIX(0.541196100) */
+#define FIX_0_707106781 ((INT32) 181) /* FIX(0.707106781) */
+#define FIX_1_306562965 ((INT32) 334) /* FIX(1.306562965) */
+#else
+#define FIX_0_382683433 FIX(0.382683433)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_707106781 FIX(0.707106781)
+#define FIX_1_306562965 FIX(1.306562965)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift. This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x,n) RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS))
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_ifast (DCTELEM * data)
+{
+ DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ DCTELEM tmp10, tmp11, tmp12, tmp13;
+ DCTELEM z1, z2, z3, z4, z5, z11, z13;
+ DCTELEM *dataptr;
+ int ctr;
+ SHIFT_TEMPS
+
+ /* Pass 1: process rows. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[4] = tmp10 - tmp11;
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+ dataptr[2] = tmp13 + z1; /* phase 5 */
+ dataptr[6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[5] = z13 + z2; /* phase 6 */
+ dataptr[3] = z13 - z2;
+ dataptr[1] = z11 + z4;
+ dataptr[7] = z11 - z4;
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part */
+
+ tmp10 = tmp0 + tmp3; /* phase 2 */
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+ dataptr[DCTSIZE*4] = tmp10 - tmp11;
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_707106781); /* c4 */
+ dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+ dataptr[DCTSIZE*6] = tmp13 - z1;
+
+ /* Odd part */
+
+ tmp10 = tmp4 + tmp5; /* phase 2 */
+ tmp11 = tmp5 + tmp6;
+ tmp12 = tmp6 + tmp7;
+
+ /* The rotator is modified from fig 4-8 to avoid extra negations. */
+ z5 = MULTIPLY(tmp10 - tmp12, FIX_0_382683433); /* c6 */
+ z2 = MULTIPLY(tmp10, FIX_0_541196100) + z5; /* c2-c6 */
+ z4 = MULTIPLY(tmp12, FIX_1_306562965) + z5; /* c2+c6 */
+ z3 = MULTIPLY(tmp11, FIX_0_707106781); /* c4 */
+
+ z11 = tmp7 + z3; /* phase 5 */
+ z13 = tmp7 - z3;
+
+ dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+ dataptr[DCTSIZE*3] = z13 - z2;
+ dataptr[DCTSIZE*1] = z11 + z4;
+ dataptr[DCTSIZE*7] = z11 - z4;
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
--- /dev/null
+/*
+ * jfdctint.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a slow-but-accurate integer implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column. Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D DCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true DCT outputs. The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm. The advantage of
+ * this arrangement is that we save two multiplications per 1-D DCT,
+ * because the y0 and y4 outputs need not be divided by sqrt(N).
+ * In the IJG code, this factor of 8 is removed by the quantization step
+ * (in jcdctmgr.c), NOT in this module.
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic. We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants). After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output. This division can be done
+ * cheaply as a right shift of CONST_BITS bits. We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision. These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling. (For 12-bit sample data, the intermediate
+ * array is INT32 anyway.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */
+#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */
+#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */
+#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */
+#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336 FIX(0.298631336)
+#define FIX_0_390180644 FIX(0.390180644)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_175875602 FIX(1.175875602)
+#define FIX_1_501321110 FIX(1.501321110)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_1_961570560 FIX(1.961570560)
+#define FIX_2_053119869 FIX(2.053119869)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_072711026 FIX(3.072711026)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL(void)
+jpeg_fdct_islow (DCTELEM * data)
+{
+ INT32 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ INT32 tmp10, tmp11, tmp12, tmp13;
+ INT32 z1, z2, z3, z4, z5;
+ DCTELEM *dataptr;
+ int ctr;
+ SHIFT_TEMPS
+
+ /* Pass 1: process rows. */
+ /* Note results are scaled up by sqrt(8) compared to a true DCT; */
+ /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[0] + dataptr[7];
+ tmp7 = dataptr[0] - dataptr[7];
+ tmp1 = dataptr[1] + dataptr[6];
+ tmp6 = dataptr[1] - dataptr[6];
+ tmp2 = dataptr[2] + dataptr[5];
+ tmp5 = dataptr[2] - dataptr[5];
+ tmp3 = dataptr[3] + dataptr[4];
+ tmp4 = dataptr[3] - dataptr[4];
+
+ /* Even part per LL&M figure 1 --- note that published figure is faulty;
+ * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+ */
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS);
+ dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+ dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+ CONST_BITS-PASS1_BITS);
+ dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+ CONST_BITS-PASS1_BITS);
+
+ /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+ * cK represents cos(K*pi/16).
+ * i0..i3 in the paper are tmp4..tmp7 here.
+ */
+
+ z1 = tmp4 + tmp7;
+ z2 = tmp5 + tmp6;
+ z3 = tmp4 + tmp6;
+ z4 = tmp5 + tmp7;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS);
+ dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS);
+ dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS);
+ dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS);
+
+ dataptr += DCTSIZE; /* advance pointer to next row */
+ }
+
+ /* Pass 2: process columns.
+ * We remove the PASS1_BITS scaling, but leave the results scaled up
+ * by an overall factor of 8.
+ */
+
+ dataptr = data;
+ for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+ tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+ tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+ tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+ tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+ tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+ tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+ tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+ tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+
+ /* Even part per LL&M figure 1 --- note that published figure is faulty;
+ * rotator "sqrt(2)*c1" should be "sqrt(2)*c6".
+ */
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp11, PASS1_BITS);
+ dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp10 - tmp11, PASS1_BITS);
+
+ z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
+ dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
+ CONST_BITS+PASS1_BITS);
+
+ /* Odd part per figure 8 --- note paper omits factor of sqrt(2).
+ * cK represents cos(K*pi/16).
+ * i0..i3 in the paper are tmp4..tmp7 here.
+ */
+
+ z1 = tmp4 + tmp7;
+ z2 = tmp5 + tmp6;
+ z3 = tmp4 + tmp6;
+ z4 = tmp5 + tmp7;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp4 + z1 + z3,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp5 + z2 + z4,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp6 + z2 + z3,
+ CONST_BITS+PASS1_BITS);
+ dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp7 + z1 + z4,
+ CONST_BITS+PASS1_BITS);
+
+ dataptr++; /* advance pointer to next column */
+ }
+}
+
+#endif /* DCT_ISLOW_SUPPORTED */
--- /dev/null
+/*
+ * jidctflt.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations. However, it may not give the same results on all
+ * machines because of differences in roundoff behavior. Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values. However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a float result.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((FAST_FLOAT) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+ FAST_FLOAT z5, z10, z11, z12, z13;
+ JCOEFPTR inptr;
+ FLOAT_MULT_TYPE * quantptr;
+ FAST_FLOAT * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp10 = tmp0 + tmp2; /* phase 3 */
+ tmp11 = tmp0 - tmp2;
+
+ tmp13 = tmp1 + tmp3; /* phases 5-3 */
+ tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */
+
+ tmp0 = tmp10 + tmp13; /* phase 2 */
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+ z13 = tmp6 + tmp5; /* phase 6 */
+ z10 = tmp6 - tmp5;
+ z11 = tmp4 + tmp7;
+ z12 = tmp4 - tmp7;
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */
+
+ z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ wsptr[DCTSIZE*0] = tmp0 + tmp7;
+ wsptr[DCTSIZE*7] = tmp0 - tmp7;
+ wsptr[DCTSIZE*1] = tmp1 + tmp6;
+ wsptr[DCTSIZE*6] = tmp1 - tmp6;
+ wsptr[DCTSIZE*2] = tmp2 + tmp5;
+ wsptr[DCTSIZE*5] = tmp2 - tmp5;
+ wsptr[DCTSIZE*4] = tmp3 + tmp4;
+ wsptr[DCTSIZE*3] = tmp3 - tmp4;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * And testing floats for zero is relatively expensive, so we don't bother.
+ */
+
+ /* Even part */
+
+ tmp10 = wsptr[0] + wsptr[4];
+ tmp11 = wsptr[0] - wsptr[4];
+
+ tmp13 = wsptr[2] + wsptr[6];
+ tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;
+
+ tmp0 = tmp10 + tmp13;
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ z13 = wsptr[5] + wsptr[3];
+ z10 = wsptr[5] - wsptr[3];
+ z11 = wsptr[1] + wsptr[7];
+ z12 = wsptr[1] - wsptr[7];
+
+ tmp7 = z11 + z13;
+ tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);
+
+ z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+ tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+ tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7;
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ /* Final output stage: scale down by a factor of 8 and range-limit */
+
+ outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
--- /dev/null
+/*
+ * jidctfst.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values. The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jidctint.c for more details. However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * The dequantized coefficients are not integers because the AA&N scaling
+ * factors have been incorporated. We represent them scaled up by PASS1_BITS,
+ * so that the first and second IDCT rounds have the same input scaling.
+ * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to
+ * avoid a descaling shift; this compromises accuracy rather drastically
+ * for small quantization table entries, but it saves a lot of shifts.
+ * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway,
+ * so we use a much larger scaling factor to preserve accuracy.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13. This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 8
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 8
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_1_082392200 ((INT32) 277) /* FIX(1.082392200) */
+#define FIX_1_414213562 ((INT32) 362) /* FIX(1.414213562) */
+#define FIX_1_847759065 ((INT32) 473) /* FIX(1.847759065) */
+#define FIX_2_613125930 ((INT32) 669) /* FIX(2.613125930) */
+#else
+#define FIX_1_082392200 FIX(1.082392200)
+#define FIX_1_414213562 FIX(1.414213562)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_2_613125930 FIX(2.613125930)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift. This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x,n) RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS))
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a DCTELEM result. For 8-bit data a 16x16->16
+ * multiplication will do. For 12-bit data, the multiplier table is
+ * declared INT32, so a 32-bit multiply will be used.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define DEQUANTIZE(coef,quantval) (((IFAST_MULT_TYPE) (coef)) * (quantval))
+#else
+#define DEQUANTIZE(coef,quantval) \
+ DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS)
+#endif
+
+
+/* Like DESCALE, but applies to a DCTELEM and produces an int.
+ * We assume that int right shift is unsigned if INT32 right shift is.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS DCTELEM ishift_temp;
+#if BITS_IN_JSAMPLE == 8
+#define DCTELEMBITS 16 /* DCTELEM may be 16 or 32 bits */
+#else
+#define DCTELEMBITS 32 /* DCTELEM must be 32 bits */
+#endif
+#define IRIGHT_SHIFT(x,shft) \
+ ((ishift_temp = (x)) < 0 ? \
+ (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \
+ (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+#ifdef USE_ACCURATE_ROUNDING
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n))
+#else
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT(x, n))
+#endif
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+ DCTELEM tmp10, tmp11, tmp12, tmp13;
+ DCTELEM z5, z10, z11, z12, z13;
+ JCOEFPTR inptr;
+ IFAST_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS /* for DESCALE */
+ ISHIFT_TEMPS /* for IDESCALE */
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (IFAST_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ int dcval = (int) DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp10 = tmp0 + tmp2; /* phase 3 */
+ tmp11 = tmp0 - tmp2;
+
+ tmp13 = tmp1 + tmp3; /* phases 5-3 */
+ tmp12 = MULTIPLY(tmp1 - tmp3, FIX_1_414213562) - tmp13; /* 2*c4 */
+
+ tmp0 = tmp10 + tmp13; /* phase 2 */
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+ z13 = tmp6 + tmp5; /* phase 6 */
+ z10 = tmp6 - tmp5;
+ z11 = tmp4 + tmp7;
+ z12 = tmp4 - tmp7;
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ wsptr[DCTSIZE*0] = (int) (tmp0 + tmp7);
+ wsptr[DCTSIZE*7] = (int) (tmp0 - tmp7);
+ wsptr[DCTSIZE*1] = (int) (tmp1 + tmp6);
+ wsptr[DCTSIZE*6] = (int) (tmp1 - tmp6);
+ wsptr[DCTSIZE*2] = (int) (tmp2 + tmp5);
+ wsptr[DCTSIZE*5] = (int) (tmp2 - tmp5);
+ wsptr[DCTSIZE*4] = (int) (tmp3 + tmp4);
+ wsptr[DCTSIZE*3] = (int) (tmp3 - tmp4);
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3, */
+ /* and also undo the PASS1_BITS scaling. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * On machines with very fast multiplication, it's possible that the
+ * test takes more time than it's worth. In that case this section
+ * may be commented out.
+ */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[IDESCALE(wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+ outptr[4] = dcval;
+ outptr[5] = dcval;
+ outptr[6] = dcval;
+ outptr[7] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp10 = ((DCTELEM) wsptr[0] + (DCTELEM) wsptr[4]);
+ tmp11 = ((DCTELEM) wsptr[0] - (DCTELEM) wsptr[4]);
+
+ tmp13 = ((DCTELEM) wsptr[2] + (DCTELEM) wsptr[6]);
+ tmp12 = MULTIPLY((DCTELEM) wsptr[2] - (DCTELEM) wsptr[6], FIX_1_414213562)
+ - tmp13;
+
+ tmp0 = tmp10 + tmp13;
+ tmp3 = tmp10 - tmp13;
+ tmp1 = tmp11 + tmp12;
+ tmp2 = tmp11 - tmp12;
+
+ /* Odd part */
+
+ z13 = (DCTELEM) wsptr[5] + (DCTELEM) wsptr[3];
+ z10 = (DCTELEM) wsptr[5] - (DCTELEM) wsptr[3];
+ z11 = (DCTELEM) wsptr[1] + (DCTELEM) wsptr[7];
+ z12 = (DCTELEM) wsptr[1] - (DCTELEM) wsptr[7];
+
+ tmp7 = z11 + z13; /* phase 5 */
+ tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562); /* 2*c4 */
+
+ z5 = MULTIPLY(z10 + z12, FIX_1_847759065); /* 2*c2 */
+ tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5; /* 2*(c2-c6) */
+ tmp12 = MULTIPLY(z10, - FIX_2_613125930) + z5; /* -2*(c2+c6) */
+
+ tmp6 = tmp12 - tmp7; /* phase 2 */
+ tmp5 = tmp11 - tmp6;
+ tmp4 = tmp10 + tmp5;
+
+ /* Final output stage: scale down by a factor of 8 and range-limit */
+
+ outptr[0] = range_limit[IDESCALE(tmp0 + tmp7, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[IDESCALE(tmp0 - tmp7, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[IDESCALE(tmp1 + tmp6, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[IDESCALE(tmp1 - tmp6, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[IDESCALE(tmp2 + tmp5, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[IDESCALE(tmp2 - tmp5, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[IDESCALE(tmp3 + tmp4, PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[IDESCALE(tmp3 - tmp4, PASS1_BITS+3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
--- /dev/null
+/*
+ * jidctint.c
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a slow-but-accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on an algorithm described in
+ * C. Loeffler, A. Ligtenberg and G. Moschytz, "Practical Fast 1-D DCT
+ * Algorithms with 11 Multiplications", Proc. Int'l. Conf. on Acoustics,
+ * Speech, and Signal Processing 1989 (ICASSP '89), pp. 988-991.
+ * The primary algorithm described there uses 11 multiplies and 29 adds.
+ * We use their alternate method with 12 multiplies and 32 adds.
+ * The advantage of this method is that no data path contains more than one
+ * multiplication; this allows a very simple and accurate implementation in
+ * scaled fixed-point arithmetic, with a minimal number of shifts.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_ISLOW_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * The poop on this scaling stuff is as follows:
+ *
+ * Each 1-D IDCT step produces outputs which are a factor of sqrt(N)
+ * larger than the true IDCT outputs. The final outputs are therefore
+ * a factor of N larger than desired; since N=8 this can be cured by
+ * a simple right shift at the end of the algorithm. The advantage of
+ * this arrangement is that we save two multiplications per 1-D IDCT,
+ * because the y0 and y4 inputs need not be divided by sqrt(N).
+ *
+ * We have to do addition and subtraction of the integer inputs, which
+ * is no problem, and multiplication by fractional constants, which is
+ * a problem to do in integer arithmetic. We multiply all the constants
+ * by CONST_SCALE and convert them to integer constants (thus retaining
+ * CONST_BITS bits of precision in the constants). After doing a
+ * multiplication we have to divide the product by CONST_SCALE, with proper
+ * rounding, to produce the correct output. This division can be done
+ * cheaply as a right shift of CONST_BITS bits. We postpone shifting
+ * as long as possible so that partial sums can be added together with
+ * full fractional precision.
+ *
+ * The outputs of the first pass are scaled up by PASS1_BITS bits so that
+ * they are represented to better-than-integral precision. These outputs
+ * require BITS_IN_JSAMPLE + PASS1_BITS + 3 bits; this fits in a 16-bit word
+ * with the recommended scaling. (To scale up 12-bit sample data further, an
+ * intermediate INT32 array would be needed.)
+ *
+ * To avoid overflow of the 32-bit intermediate results in pass 2, we must
+ * have BITS_IN_JSAMPLE + CONST_BITS + PASS1_BITS <= 26. Error analysis
+ * shows that the values given below are the most effective.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_298631336 ((INT32) 2446) /* FIX(0.298631336) */
+#define FIX_0_390180644 ((INT32) 3196) /* FIX(0.390180644) */
+#define FIX_0_541196100 ((INT32) 4433) /* FIX(0.541196100) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_175875602 ((INT32) 9633) /* FIX(1.175875602) */
+#define FIX_1_501321110 ((INT32) 12299) /* FIX(1.501321110) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_1_961570560 ((INT32) 16069) /* FIX(1.961570560) */
+#define FIX_2_053119869 ((INT32) 16819) /* FIX(2.053119869) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_072711026 ((INT32) 25172) /* FIX(3.072711026) */
+#else
+#define FIX_0_298631336 FIX(0.298631336)
+#define FIX_0_390180644 FIX(0.390180644)
+#define FIX_0_541196100 FIX(0.541196100)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_175875602 FIX(1.175875602)
+#define FIX_1_501321110 FIX(1.501321110)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_1_961570560 FIX(1.961570560)
+#define FIX_2_053119869 FIX(2.053119869)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_072711026 FIX(3.072711026)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result. In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp1, tmp2, tmp3;
+ INT32 tmp10, tmp11, tmp12, tmp13;
+ INT32 z1, z2, z3, z4, z5;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+ /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
+ /* furthermore, we scale the results by 2**PASS1_BITS. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; ctr--) {
+ /* Due to quantization, we will usually find that many of the input
+ * coefficients are zero, especially the AC terms. We can exploit this
+ * by short-circuiting the IDCT calculation for any column in which all
+ * the AC terms are zero. In that case each output is equal to the
+ * DC coefficient (with scale factor as needed).
+ * With typical images and quantization tables, half or more of the
+ * column DCT calculations can be simplified this way.
+ */
+
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*4] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*6] == 0 &&
+ inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+ wsptr[DCTSIZE*4] = dcval;
+ wsptr[DCTSIZE*5] = dcval;
+ wsptr[DCTSIZE*6] = dcval;
+ wsptr[DCTSIZE*7] = dcval;
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ continue;
+ }
+
+ /* Even part: reverse the even part of the forward DCT. */
+ /* The rotator is sqrt(2)*c(-6). */
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+ tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
+ tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+
+ tmp0 = (z2 + z3) << CONST_BITS;
+ tmp1 = (z2 - z3) << CONST_BITS;
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ /* Odd part per figure 8; the matrix is unitary and hence its
+ * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
+ */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ tmp1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp2 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp3 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+
+ z1 = tmp0 + tmp3;
+ z2 = tmp1 + tmp2;
+ z3 = tmp0 + tmp2;
+ z4 = tmp1 + tmp3;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ tmp0 += z1 + z3;
+ tmp1 += z2 + z4;
+ tmp2 += z2 + z3;
+ tmp3 += z1 + z4;
+
+ /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*7] = (int) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*6] = (int) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*5] = (int) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*3] = (int) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
+ wsptr[DCTSIZE*4] = (int) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
+
+ inptr++; /* advance pointers to next column */
+ quantptr++;
+ wsptr++;
+ }
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3, */
+ /* and also undo the PASS1_BITS scaling. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < DCTSIZE; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* Rows of zeroes can be exploited in the same way as we did with columns.
+ * However, the column calculation has created many nonzero AC terms, so
+ * the simplification applies less often (typically 5% to 10% of the time).
+ * On machines with very fast multiplication, it's possible that the
+ * test takes more time than it's worth. In that case this section
+ * may be commented out.
+ */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 && wsptr[4] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+ outptr[4] = dcval;
+ outptr[5] = dcval;
+ outptr[6] = dcval;
+ outptr[7] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part: reverse the even part of the forward DCT. */
+ /* The rotator is sqrt(2)*c(-6). */
+
+ z2 = (INT32) wsptr[2];
+ z3 = (INT32) wsptr[6];
+
+ z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
+ tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
+ tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
+
+ tmp0 = ((INT32) wsptr[0] + (INT32) wsptr[4]) << CONST_BITS;
+ tmp1 = ((INT32) wsptr[0] - (INT32) wsptr[4]) << CONST_BITS;
+
+ tmp10 = tmp0 + tmp3;
+ tmp13 = tmp0 - tmp3;
+ tmp11 = tmp1 + tmp2;
+ tmp12 = tmp1 - tmp2;
+
+ /* Odd part per figure 8; the matrix is unitary and hence its
+ * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
+ */
+
+ tmp0 = (INT32) wsptr[7];
+ tmp1 = (INT32) wsptr[5];
+ tmp2 = (INT32) wsptr[3];
+ tmp3 = (INT32) wsptr[1];
+
+ z1 = tmp0 + tmp3;
+ z2 = tmp1 + tmp2;
+ z3 = tmp0 + tmp2;
+ z4 = tmp1 + tmp3;
+ z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
+
+ tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
+ tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
+ tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
+ tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
+ z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
+ z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
+ z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
+ z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
+
+ z3 += z5;
+ z4 += z5;
+
+ tmp0 += z1 + z3;
+ tmp1 += z2 + z4;
+ tmp2 += z2 + z3;
+ tmp3 += z1 + z4;
+
+ /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp3,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[7] = range_limit[(int) DESCALE(tmp10 - tmp3,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp11 + tmp2,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[6] = range_limit[(int) DESCALE(tmp11 - tmp2,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE(tmp12 + tmp1,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[5] = range_limit[(int) DESCALE(tmp12 - tmp1,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE(tmp13 + tmp0,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+ outptr[4] = range_limit[(int) DESCALE(tmp13 - tmp0,
+ CONST_BITS+PASS1_BITS+3)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+#endif /* DCT_ISLOW_SUPPORTED */
--- /dev/null
+/*
+ * jidctred.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains inverse-DCT routines that produce reduced-size output:
+ * either 4x4, 2x2, or 1x1 pixels from an 8x8 DCT block.
+ *
+ * The implementation is based on the Loeffler, Ligtenberg and Moschytz (LL&M)
+ * algorithm used in jidctint.c. We simply replace each 8-to-8 1-D IDCT step
+ * with an 8-to-4 step that produces the four averages of two adjacent outputs
+ * (or an 8-to-2 step producing two averages of four outputs, for 2x2 output).
+ * These steps were derived by computing the corresponding values at the end
+ * of the normal LL&M code, then simplifying as much as possible.
+ *
+ * 1x1 is trivial: just take the DC coefficient divided by 8.
+ *
+ * See jidctint.c for additional comments.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling is the same as in jidctint.c. */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 13
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 13
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 13
+#define FIX_0_211164243 ((INT32) 1730) /* FIX(0.211164243) */
+#define FIX_0_509795579 ((INT32) 4176) /* FIX(0.509795579) */
+#define FIX_0_601344887 ((INT32) 4926) /* FIX(0.601344887) */
+#define FIX_0_720959822 ((INT32) 5906) /* FIX(0.720959822) */
+#define FIX_0_765366865 ((INT32) 6270) /* FIX(0.765366865) */
+#define FIX_0_850430095 ((INT32) 6967) /* FIX(0.850430095) */
+#define FIX_0_899976223 ((INT32) 7373) /* FIX(0.899976223) */
+#define FIX_1_061594337 ((INT32) 8697) /* FIX(1.061594337) */
+#define FIX_1_272758580 ((INT32) 10426) /* FIX(1.272758580) */
+#define FIX_1_451774981 ((INT32) 11893) /* FIX(1.451774981) */
+#define FIX_1_847759065 ((INT32) 15137) /* FIX(1.847759065) */
+#define FIX_2_172734803 ((INT32) 17799) /* FIX(2.172734803) */
+#define FIX_2_562915447 ((INT32) 20995) /* FIX(2.562915447) */
+#define FIX_3_624509785 ((INT32) 29692) /* FIX(3.624509785) */
+#else
+#define FIX_0_211164243 FIX(0.211164243)
+#define FIX_0_509795579 FIX(0.509795579)
+#define FIX_0_601344887 FIX(0.601344887)
+#define FIX_0_720959822 FIX(0.720959822)
+#define FIX_0_765366865 FIX(0.765366865)
+#define FIX_0_850430095 FIX(0.850430095)
+#define FIX_0_899976223 FIX(0.899976223)
+#define FIX_1_061594337 FIX(1.061594337)
+#define FIX_1_272758580 FIX(1.272758580)
+#define FIX_1_451774981 FIX(1.451774981)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_2_172734803 FIX(2.172734803)
+#define FIX_2_562915447 FIX(2.562915447)
+#define FIX_3_624509785 FIX(3.624509785)
+#endif
+
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * For 8-bit samples with the recommended scaling, all the variable
+ * and constant values involved are no more than 16 bits wide, so a
+ * 16x16->32 bit multiply can be used instead of a full 32x32 multiply.
+ * For 12-bit samples, a full 32-bit multiplication will be needed.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define MULTIPLY(var,const) MULTIPLY16C16(var,const)
+#else
+#define MULTIPLY(var,const) ((var) * (const))
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce an int result. In this module, both inputs and result
+ * are 16 bits or less, so either int or short multiply will work.
+ */
+
+#define DEQUANTIZE(coef,quantval) (((ISLOW_MULT_TYPE) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 4x4 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp2, tmp10, tmp12;
+ INT32 z1, z2, z3, z4;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE*4]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+ /* Don't bother to process column 4, because second pass won't use it */
+ if (ctr == DCTSIZE-4)
+ continue;
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*2] == 0 &&
+ inptr[DCTSIZE*3] == 0 && inptr[DCTSIZE*5] == 0 &&
+ inptr[DCTSIZE*6] == 0 && inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero; we need not examine term 4 for 4x4 output */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+ wsptr[DCTSIZE*2] = dcval;
+ wsptr[DCTSIZE*3] = dcval;
+
+ continue;
+ }
+
+ /* Even part */
+
+ tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp0 <<= (CONST_BITS+1);
+
+ z2 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+ tmp2 = MULTIPLY(z2, FIX_1_847759065) + MULTIPLY(z3, - FIX_0_765366865);
+
+ tmp10 = tmp0 + tmp2;
+ tmp12 = tmp0 - tmp2;
+
+ /* Odd part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ z2 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ z3 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ z4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+
+ tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
+ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
+ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
+ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
+
+ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
+ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
+ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
+ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
+
+ /* Final output stage */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp2, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*3] = (int) DESCALE(tmp10 - tmp2, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp12 + tmp0, CONST_BITS-PASS1_BITS+1);
+ wsptr[DCTSIZE*2] = (int) DESCALE(tmp12 - tmp0, CONST_BITS-PASS1_BITS+1);
+ }
+
+ /* Pass 2: process 4 rows from work array, store into output array. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < 4; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[2] == 0 && wsptr[3] == 0 &&
+ wsptr[5] == 0 && wsptr[6] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+ outptr[2] = dcval;
+ outptr[3] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp0 = ((INT32) wsptr[0]) << (CONST_BITS+1);
+
+ tmp2 = MULTIPLY((INT32) wsptr[2], FIX_1_847759065)
+ + MULTIPLY((INT32) wsptr[6], - FIX_0_765366865);
+
+ tmp10 = tmp0 + tmp2;
+ tmp12 = tmp0 - tmp2;
+
+ /* Odd part */
+
+ z1 = (INT32) wsptr[7];
+ z2 = (INT32) wsptr[5];
+ z3 = (INT32) wsptr[3];
+ z4 = (INT32) wsptr[1];
+
+ tmp0 = MULTIPLY(z1, - FIX_0_211164243) /* sqrt(2) * (c3-c1) */
+ + MULTIPLY(z2, FIX_1_451774981) /* sqrt(2) * (c3+c7) */
+ + MULTIPLY(z3, - FIX_2_172734803) /* sqrt(2) * (-c1-c5) */
+ + MULTIPLY(z4, FIX_1_061594337); /* sqrt(2) * (c5+c7) */
+
+ tmp2 = MULTIPLY(z1, - FIX_0_509795579) /* sqrt(2) * (c7-c5) */
+ + MULTIPLY(z2, - FIX_0_601344887) /* sqrt(2) * (c5-c1) */
+ + MULTIPLY(z3, FIX_0_899976223) /* sqrt(2) * (c3-c7) */
+ + MULTIPLY(z4, FIX_2_562915447); /* sqrt(2) * (c1+c3) */
+
+ /* Final output stage */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp2,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[3] = range_limit[(int) DESCALE(tmp10 - tmp2,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp12 + tmp0,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+ outptr[2] = range_limit[(int) DESCALE(tmp12 - tmp0,
+ CONST_BITS+PASS1_BITS+3+1)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 2x2 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ INT32 tmp0, tmp10, z1;
+ JCOEFPTR inptr;
+ ISLOW_MULT_TYPE * quantptr;
+ int * wsptr;
+ JSAMPROW outptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ int ctr;
+ int workspace[DCTSIZE*2]; /* buffers data between passes */
+ SHIFT_TEMPS
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ wsptr = workspace;
+ for (ctr = DCTSIZE; ctr > 0; inptr++, quantptr++, wsptr++, ctr--) {
+ /* Don't bother to process columns 2,4,6 */
+ if (ctr == DCTSIZE-2 || ctr == DCTSIZE-4 || ctr == DCTSIZE-6)
+ continue;
+ if (inptr[DCTSIZE*1] == 0 && inptr[DCTSIZE*3] == 0 &&
+ inptr[DCTSIZE*5] == 0 && inptr[DCTSIZE*7] == 0) {
+ /* AC terms all zero; we need not examine terms 2,4,6 for 2x2 output */
+ int dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]) << PASS1_BITS;
+
+ wsptr[DCTSIZE*0] = dcval;
+ wsptr[DCTSIZE*1] = dcval;
+
+ continue;
+ }
+
+ /* Even part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+ tmp10 = z1 << (CONST_BITS+2);
+
+ /* Odd part */
+
+ z1 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+ tmp0 = MULTIPLY(z1, - FIX_0_720959822); /* sqrt(2) * (c7-c5+c3-c1) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+ tmp0 += MULTIPLY(z1, FIX_0_850430095); /* sqrt(2) * (-c1+c3+c5+c7) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+ tmp0 += MULTIPLY(z1, - FIX_1_272758580); /* sqrt(2) * (-c1+c3-c5-c7) */
+ z1 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+ tmp0 += MULTIPLY(z1, FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
+
+ /* Final output stage */
+
+ wsptr[DCTSIZE*0] = (int) DESCALE(tmp10 + tmp0, CONST_BITS-PASS1_BITS+2);
+ wsptr[DCTSIZE*1] = (int) DESCALE(tmp10 - tmp0, CONST_BITS-PASS1_BITS+2);
+ }
+
+ /* Pass 2: process 2 rows from work array, store into output array. */
+
+ wsptr = workspace;
+ for (ctr = 0; ctr < 2; ctr++) {
+ outptr = output_buf[ctr] + output_col;
+ /* It's not clear whether a zero row test is worthwhile here ... */
+
+#ifndef NO_ZERO_ROW_TEST
+ if (wsptr[1] == 0 && wsptr[3] == 0 && wsptr[5] == 0 && wsptr[7] == 0) {
+ /* AC terms all zero */
+ JSAMPLE dcval = range_limit[(int) DESCALE((INT32) wsptr[0], PASS1_BITS+3)
+ & RANGE_MASK];
+
+ outptr[0] = dcval;
+ outptr[1] = dcval;
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ continue;
+ }
+#endif
+
+ /* Even part */
+
+ tmp10 = ((INT32) wsptr[0]) << (CONST_BITS+2);
+
+ /* Odd part */
+
+ tmp0 = MULTIPLY((INT32) wsptr[7], - FIX_0_720959822) /* sqrt(2) * (c7-c5+c3-c1) */
+ + MULTIPLY((INT32) wsptr[5], FIX_0_850430095) /* sqrt(2) * (-c1+c3+c5+c7) */
+ + MULTIPLY((INT32) wsptr[3], - FIX_1_272758580) /* sqrt(2) * (-c1+c3-c5-c7) */
+ + MULTIPLY((INT32) wsptr[1], FIX_3_624509785); /* sqrt(2) * (c1+c3+c5+c7) */
+
+ /* Final output stage */
+
+ outptr[0] = range_limit[(int) DESCALE(tmp10 + tmp0,
+ CONST_BITS+PASS1_BITS+3+2)
+ & RANGE_MASK];
+ outptr[1] = range_limit[(int) DESCALE(tmp10 - tmp0,
+ CONST_BITS+PASS1_BITS+3+2)
+ & RANGE_MASK];
+
+ wsptr += DCTSIZE; /* advance pointer to next row */
+ }
+}
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients,
+ * producing a reduced-size 1x1 output block.
+ */
+
+GLOBAL(void)
+jpeg_idct_1x1 (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ int dcval;
+ ISLOW_MULT_TYPE * quantptr;
+ JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+ SHIFT_TEMPS
+
+ /* We hardly need an inverse DCT routine for this: just take the
+ * average pixel value, which is one-eighth of the DC coefficient.
+ */
+ quantptr = (ISLOW_MULT_TYPE *) compptr->dct_table;
+ dcval = DEQUANTIZE(coef_block[0], quantptr[0]);
+ dcval = (int) DESCALE((INT32) dcval, 3);
+
+ output_buf[0][output_col] = range_limit[dcval & RANGE_MASK];
+}
+
+#endif /* IDCT_SCALING_SUPPORTED */
--- /dev/null
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files. (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library. Most applications need only include jpeglib.h.
+ */
+
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "jconfig.h" /* auto configuration options */
+#define JCONFIG_INCLUDED /* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target,size) bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest,src,size) bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target,size) memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size) memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof(). However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long. To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object) ((size_t) sizeof(object))
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros. On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file,buf,sizeofbuf) \
+ ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf) \
+ ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
--- /dev/null
+/*
+ * jmemmgr.c
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the JPEG system-independent memory management
+ * routines. This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ * * pool-based allocation and freeing of memory;
+ * * policy decisions about how to divide available memory among the
+ * virtual arrays;
+ * * control logic for swapping virtual arrays between main memory and
+ * backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems. For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed. (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+
+#define JPEG_INTERNALS
+#define AM_MEMORY_MANAGER /* we define jvirt_Xarray_control structs */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h" /* import the system-dependent declarations */
+
+#ifndef NO_GETENV
+#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare getenv() */
+extern char * getenv JPP((const char * name));
+#endif
+#endif
+
+
+/*
+ * Some important notes:
+ * The allocation routines provided here must never return NULL.
+ * They should exit to error_exit if unsuccessful.
+ *
+ * It's not a good idea to try to merge the sarray and barray routines,
+ * even though they are textually almost the same, because samples are
+ * usually stored as bytes while coefficients are shorts or ints. Thus,
+ * in machines where byte pointers have a different representation from
+ * word pointers, the resulting machine code could not be the same.
+ */
+
+
+/*
+ * Many machines require storage alignment: longs must start on 4-byte
+ * boundaries, doubles on 8-byte boundaries, etc. On such machines, malloc()
+ * always returns pointers that are multiples of the worst-case alignment
+ * requirement, and we had better do so too.
+ * There isn't any really portable way to determine the worst-case alignment
+ * requirement. This module assumes that the alignment requirement is
+ * multiples of sizeof(ALIGN_TYPE).
+ * By default, we define ALIGN_TYPE as double. This is necessary on some
+ * workstations (where doubles really do need 8-byte alignment) and will work
+ * fine on nearly everything. If your machine has lesser alignment needs,
+ * you can save a few bytes by making ALIGN_TYPE smaller.
+ * The only place I know of where this will NOT work is certain Macintosh
+ * 680x0 compilers that define double as a 10-byte IEEE extended float.
+ * Doing 10-byte alignment is counterproductive because longwords won't be
+ * aligned well. Put "#define ALIGN_TYPE long" in jconfig.h if you have
+ * such a compiler.
+ */
+
+#ifndef ALIGN_TYPE /* so can override from jconfig.h */
+#define ALIGN_TYPE double
+#endif
+
+
+/*
+ * We allocate objects from "pools", where each pool is gotten with a single
+ * request to jpeg_get_small() or jpeg_get_large(). There is no per-object
+ * overhead within a pool, except for alignment padding. Each pool has a
+ * header with a link to the next pool of the same class.
+ * Small and large pool headers are identical except that the latter's
+ * link pointer must be FAR on 80x86 machines.
+ * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE
+ * field. This forces the compiler to make SIZEOF(small_pool_hdr) a multiple
+ * of the alignment requirement of ALIGN_TYPE.
+ */
+
+typedef union small_pool_struct * small_pool_ptr;
+
+typedef union small_pool_struct {
+ struct {
+ small_pool_ptr next; /* next in list of pools */
+ size_t bytes_used; /* how many bytes already used within pool */
+ size_t bytes_left; /* bytes still available in this pool */
+ } hdr;
+ ALIGN_TYPE dummy; /* included in union to ensure alignment */
+} small_pool_hdr;
+
+typedef union large_pool_struct FAR * large_pool_ptr;
+
+typedef union large_pool_struct {
+ struct {
+ large_pool_ptr next; /* next in list of pools */
+ size_t bytes_used; /* how many bytes already used within pool */
+ size_t bytes_left; /* bytes still available in this pool */
+ } hdr;
+ ALIGN_TYPE dummy; /* included in union to ensure alignment */
+} large_pool_hdr;
+
+
+/*
+ * Here is the full definition of a memory manager object.
+ */
+
+typedef struct {
+ struct jpeg_memory_mgr pub; /* public fields */
+
+ /* Each pool identifier (lifetime class) names a linked list of pools. */
+ small_pool_ptr small_list[JPOOL_NUMPOOLS];
+ large_pool_ptr large_list[JPOOL_NUMPOOLS];
+
+ /* Since we only have one lifetime class of virtual arrays, only one
+ * linked list is necessary (for each datatype). Note that the virtual
+ * array control blocks being linked together are actually stored somewhere
+ * in the small-pool list.
+ */
+ jvirt_sarray_ptr virt_sarray_list;
+ jvirt_barray_ptr virt_barray_list;
+
+ /* This counts total space obtained from jpeg_get_small/large */
+ long total_space_allocated;
+
+ /* alloc_sarray and alloc_barray set this value for use by virtual
+ * array routines.
+ */
+ JDIMENSION last_rowsperchunk; /* from most recent alloc_sarray/barray */
+} my_memory_mgr;
+
+typedef my_memory_mgr * my_mem_ptr;
+
+
+/*
+ * The control blocks for virtual arrays.
+ * Note that these blocks are allocated in the "small" pool area.
+ * System-dependent info for the associated backing store (if any) is hidden
+ * inside the backing_store_info struct.
+ */
+
+struct jvirt_sarray_control {
+ JSAMPARRAY mem_buffer; /* => the in-memory buffer */
+ JDIMENSION rows_in_array; /* total virtual array height */
+ JDIMENSION samplesperrow; /* width of array (and of memory buffer) */
+ JDIMENSION maxaccess; /* max rows accessed by access_virt_sarray */
+ JDIMENSION rows_in_mem; /* height of memory buffer */
+ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */
+ JDIMENSION cur_start_row; /* first logical row # in the buffer */
+ JDIMENSION first_undef_row; /* row # of first uninitialized row */
+ boolean pre_zero; /* pre-zero mode requested? */
+ boolean dirty; /* do current buffer contents need written? */
+ boolean b_s_open; /* is backing-store data valid? */
+ jvirt_sarray_ptr next; /* link to next virtual sarray control block */
+ backing_store_info b_s_info; /* System-dependent control info */
+};
+
+struct jvirt_barray_control {
+ JBLOCKARRAY mem_buffer; /* => the in-memory buffer */
+ JDIMENSION rows_in_array; /* total virtual array height */
+ JDIMENSION blocksperrow; /* width of array (and of memory buffer) */
+ JDIMENSION maxaccess; /* max rows accessed by access_virt_barray */
+ JDIMENSION rows_in_mem; /* height of memory buffer */
+ JDIMENSION rowsperchunk; /* allocation chunk size in mem_buffer */
+ JDIMENSION cur_start_row; /* first logical row # in the buffer */
+ JDIMENSION first_undef_row; /* row # of first uninitialized row */
+ boolean pre_zero; /* pre-zero mode requested? */
+ boolean dirty; /* do current buffer contents need written? */
+ boolean b_s_open; /* is backing-store data valid? */
+ jvirt_barray_ptr next; /* link to next virtual barray control block */
+ backing_store_info b_s_info; /* System-dependent control info */
+};
+
+
+#ifdef MEM_STATS /* optional extra stuff for statistics */
+
+LOCAL(void)
+print_mem_stats (j_common_ptr cinfo, int pool_id)
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr shdr_ptr;
+ large_pool_ptr lhdr_ptr;
+
+ /* Since this is only a debugging stub, we can cheat a little by using
+ * fprintf directly rather than going through the trace message code.
+ * This is helpful because message parm array can't handle longs.
+ */
+ fprintf(stderr, "Freeing pool %d, total space = %ld\n",
+ pool_id, mem->total_space_allocated);
+
+ for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
+ lhdr_ptr = lhdr_ptr->hdr.next) {
+ fprintf(stderr, " Large chunk used %ld\n",
+ (long) lhdr_ptr->hdr.bytes_used);
+ }
+
+ for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
+ shdr_ptr = shdr_ptr->hdr.next) {
+ fprintf(stderr, " Small chunk used %ld free %ld\n",
+ (long) shdr_ptr->hdr.bytes_used,
+ (long) shdr_ptr->hdr.bytes_left);
+ }
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL(void)
+out_of_memory (j_common_ptr cinfo, int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+ cinfo->err->trace_level = 2; /* force self_destruct to report stats */
+#endif
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
+}
+
+
+/*
+ * Allocation of "small" objects.
+ *
+ * For these, we use pooled storage. When a new pool must be created,
+ * we try to get enough space for the current request plus a "slop" factor,
+ * where the slop will be the amount of leftover space in the new pool.
+ * The speed vs. space tradeoff is largely determined by the slop values.
+ * A different slop value is provided for each pool class (lifetime),
+ * and we also distinguish the first pool of a class from later ones.
+ * NOTE: the values given work fairly well on both 16- and 32-bit-int
+ * machines, but may be too small if longs are 64 bits or more.
+ */
+
+static const size_t first_pool_slop[JPOOL_NUMPOOLS] =
+{
+ 1600, /* first PERMANENT pool */
+ 16000 /* first IMAGE pool */
+};
+
+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] =
+{
+ 0, /* additional PERMANENT pools */
+ 5000 /* additional IMAGE pools */
+};
+
+#define MIN_SLOP 50 /* greater than 0 to avoid futile looping */
+
+
+METHODDEF(void *)
+alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "small" object */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr hdr_ptr, prev_hdr_ptr;
+ char * data_ptr;
+ size_t odd_bytes, min_request, slop;
+
+ /* Check for unsatisfiable request (do now to ensure no overflow below) */
+ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
+ out_of_memory(cinfo, 1); /* request exceeds malloc's ability */
+
+ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+ if (odd_bytes > 0)
+ sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+ /* See if space is available in any existing pool */
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+ prev_hdr_ptr = NULL;
+ hdr_ptr = mem->small_list[pool_id];
+ while (hdr_ptr != NULL) {
+ if (hdr_ptr->hdr.bytes_left >= sizeofobject)
+ break; /* found pool with enough space */
+ prev_hdr_ptr = hdr_ptr;
+ hdr_ptr = hdr_ptr->hdr.next;
+ }
+
+ /* Time to make a new pool? */
+ if (hdr_ptr == NULL) {
+ /* min_request is what we need now, slop is what will be leftover */
+ min_request = sizeofobject + SIZEOF(small_pool_hdr);
+ if (prev_hdr_ptr == NULL) /* first pool in class? */
+ slop = first_pool_slop[pool_id];
+ else
+ slop = extra_pool_slop[pool_id];
+ /* Don't ask for more than MAX_ALLOC_CHUNK */
+ if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
+ slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
+ /* Try to get space, if fail reduce slop and try again */
+ for (;;) {
+ hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
+ if (hdr_ptr != NULL)
+ break;
+ slop /= 2;
+ if (slop < MIN_SLOP) /* give up when it gets real small */
+ out_of_memory(cinfo, 2); /* jpeg_get_small failed */
+ }
+ mem->total_space_allocated += min_request + slop;
+ /* Success, initialize the new pool header and add to end of list */
+ hdr_ptr->hdr.next = NULL;
+ hdr_ptr->hdr.bytes_used = 0;
+ hdr_ptr->hdr.bytes_left = sizeofobject + slop;
+ if (prev_hdr_ptr == NULL) /* first pool in class? */
+ mem->small_list[pool_id] = hdr_ptr;
+ else
+ prev_hdr_ptr->hdr.next = hdr_ptr;
+ }
+
+ /* OK, allocate the object from the current pool */
+ data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
+ data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
+ hdr_ptr->hdr.bytes_used += sizeofobject;
+ hdr_ptr->hdr.bytes_left -= sizeofobject;
+
+ return (void *) data_ptr;
+}
+
+
+/*
+ * Allocation of "large" objects.
+ *
+ * The external semantics of these are the same as "small" objects,
+ * except that FAR pointers are used on 80x86. However the pool
+ * management heuristics are quite different. We assume that each
+ * request is large enough that it may as well be passed directly to
+ * jpeg_get_large; the pool management just links everything together
+ * so that we can free it all on demand.
+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
+ * structures. The routines that create these structures (see below)
+ * deliberately bunch rows together to ensure a large request size.
+ */
+
+METHODDEF(void FAR *)
+alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "large" object */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ large_pool_ptr hdr_ptr;
+ size_t odd_bytes;
+
+ /* Check for unsatisfiable request (do now to ensure no overflow below) */
+ if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
+ out_of_memory(cinfo, 3); /* request exceeds malloc's ability */
+
+ /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+ odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+ if (odd_bytes > 0)
+ sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+ /* Always make a new pool */
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
+ SIZEOF(large_pool_hdr));
+ if (hdr_ptr == NULL)
+ out_of_memory(cinfo, 4); /* jpeg_get_large failed */
+ mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
+
+ /* Success, initialize the new pool header and add to list */
+ hdr_ptr->hdr.next = mem->large_list[pool_id];
+ /* We maintain space counts in each pool header for statistical purposes,
+ * even though they are not needed for allocation.
+ */
+ hdr_ptr->hdr.bytes_used = sizeofobject;
+ hdr_ptr->hdr.bytes_left = 0;
+ mem->large_list[pool_id] = hdr_ptr;
+
+ return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
+}
+
+
+/*
+ * Creation of 2-D sample arrays.
+ * The pointers are in near heap, the samples themselves in FAR heap.
+ *
+ * To minimize allocation overhead and to allow I/O of large contiguous
+ * blocks, we allocate the sample rows in groups of as many rows as possible
+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
+ * NB: the virtual array control routines, later in this file, know about
+ * this chunking of rows. The rowsperchunk value is left in the mem manager
+ * object so that it can be saved away if this sarray is the workspace for
+ * a virtual array.
+ */
+
+METHODDEF(JSAMPARRAY)
+alloc_sarray (j_common_ptr cinfo, int pool_id,
+ JDIMENSION samplesperrow, JDIMENSION numrows)
+/* Allocate a 2-D sample array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ JSAMPARRAY result;
+ JSAMPROW workspace;
+ JDIMENSION rowsperchunk, currow, i;
+ long ltemp;
+
+ /* Calculate max # of rows allowed in one allocation chunk */
+ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+ ((long) samplesperrow * SIZEOF(JSAMPLE));
+ if (ltemp <= 0)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+ if (ltemp < (long) numrows)
+ rowsperchunk = (JDIMENSION) ltemp;
+ else
+ rowsperchunk = numrows;
+ mem->last_rowsperchunk = rowsperchunk;
+
+ /* Get space for row pointers (small object) */
+ result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
+ (size_t) (numrows * SIZEOF(JSAMPROW)));
+
+ /* Get the rows themselves (large objects) */
+ currow = 0;
+ while (currow < numrows) {
+ rowsperchunk = MIN(rowsperchunk, numrows - currow);
+ workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
+ (size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
+ * SIZEOF(JSAMPLE)));
+ for (i = rowsperchunk; i > 0; i--) {
+ result[currow++] = workspace;
+ workspace += samplesperrow;
+ }
+ }
+
+ return result;
+}
+
+
+/*
+ * Creation of 2-D coefficient-block arrays.
+ * This is essentially the same as the code for sample arrays, above.
+ */
+
+METHODDEF(JBLOCKARRAY)
+alloc_barray (j_common_ptr cinfo, int pool_id,
+ JDIMENSION blocksperrow, JDIMENSION numrows)
+/* Allocate a 2-D coefficient-block array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ JBLOCKARRAY result;
+ JBLOCKROW workspace;
+ JDIMENSION rowsperchunk, currow, i;
+ long ltemp;
+
+ /* Calculate max # of rows allowed in one allocation chunk */
+ ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+ ((long) blocksperrow * SIZEOF(JBLOCK));
+ if (ltemp <= 0)
+ ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+ if (ltemp < (long) numrows)
+ rowsperchunk = (JDIMENSION) ltemp;
+ else
+ rowsperchunk = numrows;
+ mem->last_rowsperchunk = rowsperchunk;
+
+ /* Get space for row pointers (small object) */
+ result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
+ (size_t) (numrows * SIZEOF(JBLOCKROW)));
+
+ /* Get the rows themselves (large objects) */
+ currow = 0;
+ while (currow < numrows) {
+ rowsperchunk = MIN(rowsperchunk, numrows - currow);
+ workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
+ (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
+ * SIZEOF(JBLOCK)));
+ for (i = rowsperchunk; i > 0; i--) {
+ result[currow++] = workspace;
+ workspace += blocksperrow;
+ }
+ }
+
+ return result;
+}
+
+
+/*
+ * About virtual array management:
+ *
+ * The above "normal" array routines are only used to allocate strip buffers
+ * (as wide as the image, but just a few rows high). Full-image-sized buffers
+ * are handled as "virtual" arrays. The array is still accessed a strip at a
+ * time, but the memory manager must save the whole array for repeated
+ * accesses. The intended implementation is that there is a strip buffer in
+ * memory (as high as is possible given the desired memory limit), plus a
+ * backing file that holds the rest of the array.
+ *
+ * The request_virt_array routines are told the total size of the image and
+ * the maximum number of rows that will be accessed at once. The in-memory
+ * buffer must be at least as large as the maxaccess value.
+ *
+ * The request routines create control blocks but not the in-memory buffers.
+ * That is postponed until realize_virt_arrays is called. At that time the
+ * total amount of space needed is known (approximately, anyway), so free
+ * memory can be divided up fairly.
+ *
+ * The access_virt_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk. The access routines are also responsible for pre-zeroing
+ * any newly accessed rows, if pre-zeroing was requested.
+ *
+ * In current usage, the access requests are usually for nonoverlapping
+ * strips; that is, successive access start_row numbers differ by exactly
+ * num_rows = maxaccess. This means we can get good performance with simple
+ * buffer dump/reload logic, by making the in-memory buffer be a multiple
+ * of the access height; then there will never be accesses across bufferload
+ * boundaries. The code will still work with overlapping access requests,
+ * but it doesn't handle bufferload overlaps very efficiently.
+ */
+
+
+METHODDEF(jvirt_sarray_ptr)
+request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+ JDIMENSION samplesperrow, JDIMENSION numrows,
+ JDIMENSION maxaccess)
+/* Request a virtual 2-D sample array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ jvirt_sarray_ptr result;
+
+ /* Only IMAGE-lifetime virtual arrays are currently supported */
+ if (pool_id != JPOOL_IMAGE)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ /* get control block */
+ result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
+ SIZEOF(struct jvirt_sarray_control));
+
+ result->mem_buffer = NULL; /* marks array not yet realized */
+ result->rows_in_array = numrows;
+ result->samplesperrow = samplesperrow;
+ result->maxaccess = maxaccess;
+ result->pre_zero = pre_zero;
+ result->b_s_open = FALSE; /* no associated backing-store object */
+ result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
+ mem->virt_sarray_list = result;
+
+ return result;
+}
+
+
+METHODDEF(jvirt_barray_ptr)
+request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+ JDIMENSION blocksperrow, JDIMENSION numrows,
+ JDIMENSION maxaccess)
+/* Request a virtual 2-D coefficient-block array */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ jvirt_barray_ptr result;
+
+ /* Only IMAGE-lifetime virtual arrays are currently supported */
+ if (pool_id != JPOOL_IMAGE)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+ /* get control block */
+ result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
+ SIZEOF(struct jvirt_barray_control));
+
+ result->mem_buffer = NULL; /* marks array not yet realized */
+ result->rows_in_array = numrows;
+ result->blocksperrow = blocksperrow;
+ result->maxaccess = maxaccess;
+ result->pre_zero = pre_zero;
+ result->b_s_open = FALSE; /* no associated backing-store object */
+ result->next = mem->virt_barray_list; /* add to list of virtual arrays */
+ mem->virt_barray_list = result;
+
+ return result;
+}
+
+
+METHODDEF(void)
+realize_virt_arrays (j_common_ptr cinfo)
+/* Allocate the in-memory buffers for any unrealized virtual arrays */
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ long space_per_minheight, maximum_space, avail_mem;
+ long minheights, max_minheights;
+ jvirt_sarray_ptr sptr;
+ jvirt_barray_ptr bptr;
+
+ /* Compute the minimum space needed (maxaccess rows in each buffer)
+ * and the maximum space needed (full image height in each buffer).
+ * These may be of use to the system-dependent jpeg_mem_available routine.
+ */
+ space_per_minheight = 0;
+ maximum_space = 0;
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->mem_buffer == NULL) { /* if not realized yet */
+ space_per_minheight += (long) sptr->maxaccess *
+ (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+ maximum_space += (long) sptr->rows_in_array *
+ (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+ }
+ }
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->mem_buffer == NULL) { /* if not realized yet */
+ space_per_minheight += (long) bptr->maxaccess *
+ (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+ maximum_space += (long) bptr->rows_in_array *
+ (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+ }
+ }
+
+ if (space_per_minheight <= 0)
+ return; /* no unrealized arrays, no work */
+
+ /* Determine amount of memory to actually use; this is system-dependent. */
+ avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
+ mem->total_space_allocated);
+
+ /* If the maximum space needed is available, make all the buffers full
+ * height; otherwise parcel it out with the same number of minheights
+ * in each buffer.
+ */
+ if (avail_mem >= maximum_space)
+ max_minheights = 1000000000L;
+ else {
+ max_minheights = avail_mem / space_per_minheight;
+ /* If there doesn't seem to be enough space, try to get the minimum
+ * anyway. This allows a "stub" implementation of jpeg_mem_available().
+ */
+ if (max_minheights <= 0)
+ max_minheights = 1;
+ }
+
+ /* Allocate the in-memory buffers and initialize backing store as needed. */
+
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->mem_buffer == NULL) { /* if not realized yet */
+ minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
+ if (minheights <= max_minheights) {
+ /* This buffer fits in memory */
+ sptr->rows_in_mem = sptr->rows_in_array;
+ } else {
+ /* It doesn't fit in memory, create backing store. */
+ sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
+ jpeg_open_backing_store(cinfo, & sptr->b_s_info,
+ (long) sptr->rows_in_array *
+ (long) sptr->samplesperrow *
+ (long) SIZEOF(JSAMPLE));
+ sptr->b_s_open = TRUE;
+ }
+ sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
+ sptr->samplesperrow, sptr->rows_in_mem);
+ sptr->rowsperchunk = mem->last_rowsperchunk;
+ sptr->cur_start_row = 0;
+ sptr->first_undef_row = 0;
+ sptr->dirty = FALSE;
+ }
+ }
+
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->mem_buffer == NULL) { /* if not realized yet */
+ minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
+ if (minheights <= max_minheights) {
+ /* This buffer fits in memory */
+ bptr->rows_in_mem = bptr->rows_in_array;
+ } else {
+ /* It doesn't fit in memory, create backing store. */
+ bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
+ jpeg_open_backing_store(cinfo, & bptr->b_s_info,
+ (long) bptr->rows_in_array *
+ (long) bptr->blocksperrow *
+ (long) SIZEOF(JBLOCK));
+ bptr->b_s_open = TRUE;
+ }
+ bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
+ bptr->blocksperrow, bptr->rows_in_mem);
+ bptr->rowsperchunk = mem->last_rowsperchunk;
+ bptr->cur_start_row = 0;
+ bptr->first_undef_row = 0;
+ bptr->dirty = FALSE;
+ }
+ }
+}
+
+
+LOCAL(void)
+do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual sample array */
+{
+ long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+ bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
+ file_offset = ptr->cur_start_row * bytesperrow;
+ /* Loop to read or write each allocation chunk in mem_buffer */
+ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+ /* One chunk, but check for short chunk at end of buffer */
+ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+ /* Transfer no more than is currently defined */
+ thisrow = (long) ptr->cur_start_row + i;
+ rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+ /* Transfer no more than fits in file */
+ rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+ if (rows <= 0) /* this chunk might be past end of file! */
+ break;
+ byte_count = rows * bytesperrow;
+ if (writing)
+ (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ else
+ (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ file_offset += byte_count;
+ }
+}
+
+
+LOCAL(void)
+do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual coefficient-block array */
+{
+ long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+ bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
+ file_offset = ptr->cur_start_row * bytesperrow;
+ /* Loop to read or write each allocation chunk in mem_buffer */
+ for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+ /* One chunk, but check for short chunk at end of buffer */
+ rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+ /* Transfer no more than is currently defined */
+ thisrow = (long) ptr->cur_start_row + i;
+ rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+ /* Transfer no more than fits in file */
+ rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+ if (rows <= 0) /* this chunk might be past end of file! */
+ break;
+ byte_count = rows * bytesperrow;
+ if (writing)
+ (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ else
+ (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+ (void FAR *) ptr->mem_buffer[i],
+ file_offset, byte_count);
+ file_offset += byte_count;
+ }
+}
+
+
+METHODDEF(JSAMPARRAY)
+access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+ JDIMENSION start_row, JDIMENSION num_rows,
+ boolean writable)
+/* Access the part of a virtual sample array starting at start_row */
+/* and extending for num_rows rows. writable is true if */
+/* caller intends to modify the accessed area. */
+{
+ JDIMENSION end_row = start_row + num_rows;
+ JDIMENSION undef_row;
+
+ /* debugging check */
+ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+ ptr->mem_buffer == NULL)
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+ /* Make the desired part of the virtual array accessible */
+ if (start_row < ptr->cur_start_row ||
+ end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+ if (! ptr->b_s_open)
+ ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+ /* Flush old buffer contents if necessary */
+ if (ptr->dirty) {
+ do_sarray_io(cinfo, ptr, TRUE);
+ ptr->dirty = FALSE;
+ }
+ /* Decide what part of virtual array to access.
+ * Algorithm: if target address > current window, assume forward scan,
+ * load starting at target address. If target address < current window,
+ * assume backward scan, load so that target area is top of window.
+ * Note that when switching from forward write to forward read, will have
+ * start_row = 0, so the limiting case applies and we load from 0 anyway.
+ */
+ if (start_row > ptr->cur_start_row) {
+ ptr->cur_start_row = start_row;
+ } else {
+ /* use long arithmetic here to avoid overflow & unsigned problems */
+ long ltemp;
+
+ ltemp = (long) end_row - (long) ptr->rows_in_mem;
+ if (ltemp < 0)
+ ltemp = 0; /* don't fall off front end of file */
+ ptr->cur_start_row = (JDIMENSION) ltemp;
+ }
+ /* Read in the selected part of the array.
+ * During the initial write pass, we will do no actual read
+ * because the selected part is all undefined.
+ */
+ do_sarray_io(cinfo, ptr, FALSE);
+ }
+ /* Ensure the accessed part of the array is defined; prezero if needed.
+ * To improve locality of access, we only prezero the part of the array
+ * that the caller is about to access, not the entire in-memory array.
+ */
+ if (ptr->first_undef_row < end_row) {
+ if (ptr->first_undef_row < start_row) {
+ if (writable) /* writer skipped over a section of array */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ undef_row = start_row; /* but reader is allowed to read ahead */
+ } else {
+ undef_row = ptr->first_undef_row;
+ }
+ if (writable)
+ ptr->first_undef_row = end_row;
+ if (ptr->pre_zero) {
+ size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
+ undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+ end_row -= ptr->cur_start_row;
+ while (undef_row < end_row) {
+ jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+ undef_row++;
+ }
+ } else {
+ if (! writable) /* reader looking at undefined data */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ }
+ }
+ /* Flag the buffer dirty if caller will write in it */
+ if (writable)
+ ptr->dirty = TRUE;
+ /* Return address of proper part of the buffer */
+ return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+METHODDEF(JBLOCKARRAY)
+access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,
+ JDIMENSION start_row, JDIMENSION num_rows,
+ boolean writable)
+/* Access the part of a virtual block array starting at start_row */
+/* and extending for num_rows rows. writable is true if */
+/* caller intends to modify the accessed area. */
+{
+ JDIMENSION end_row = start_row + num_rows;
+ JDIMENSION undef_row;
+
+ /* debugging check */
+ if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+ ptr->mem_buffer == NULL)
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+ /* Make the desired part of the virtual array accessible */
+ if (start_row < ptr->cur_start_row ||
+ end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+ if (! ptr->b_s_open)
+ ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+ /* Flush old buffer contents if necessary */
+ if (ptr->dirty) {
+ do_barray_io(cinfo, ptr, TRUE);
+ ptr->dirty = FALSE;
+ }
+ /* Decide what part of virtual array to access.
+ * Algorithm: if target address > current window, assume forward scan,
+ * load starting at target address. If target address < current window,
+ * assume backward scan, load so that target area is top of window.
+ * Note that when switching from forward write to forward read, will have
+ * start_row = 0, so the limiting case applies and we load from 0 anyway.
+ */
+ if (start_row > ptr->cur_start_row) {
+ ptr->cur_start_row = start_row;
+ } else {
+ /* use long arithmetic here to avoid overflow & unsigned problems */
+ long ltemp;
+
+ ltemp = (long) end_row - (long) ptr->rows_in_mem;
+ if (ltemp < 0)
+ ltemp = 0; /* don't fall off front end of file */
+ ptr->cur_start_row = (JDIMENSION) ltemp;
+ }
+ /* Read in the selected part of the array.
+ * During the initial write pass, we will do no actual read
+ * because the selected part is all undefined.
+ */
+ do_barray_io(cinfo, ptr, FALSE);
+ }
+ /* Ensure the accessed part of the array is defined; prezero if needed.
+ * To improve locality of access, we only prezero the part of the array
+ * that the caller is about to access, not the entire in-memory array.
+ */
+ if (ptr->first_undef_row < end_row) {
+ if (ptr->first_undef_row < start_row) {
+ if (writable) /* writer skipped over a section of array */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ undef_row = start_row; /* but reader is allowed to read ahead */
+ } else {
+ undef_row = ptr->first_undef_row;
+ }
+ if (writable)
+ ptr->first_undef_row = end_row;
+ if (ptr->pre_zero) {
+ size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
+ undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+ end_row -= ptr->cur_start_row;
+ while (undef_row < end_row) {
+ jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+ undef_row++;
+ }
+ } else {
+ if (! writable) /* reader looking at undefined data */
+ ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+ }
+ }
+ /* Flag the buffer dirty if caller will write in it */
+ if (writable)
+ ptr->dirty = TRUE;
+ /* Return address of proper part of the buffer */
+ return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+/*
+ * Release all objects belonging to a specified pool.
+ */
+
+METHODDEF(void)
+free_pool (j_common_ptr cinfo, int pool_id)
+{
+ my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+ small_pool_ptr shdr_ptr;
+ large_pool_ptr lhdr_ptr;
+ size_t space_freed;
+
+ if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+ ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id); /* safety check */
+
+#ifdef MEM_STATS
+ if (cinfo->err->trace_level > 1)
+ print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
+#endif
+
+ /* If freeing IMAGE pool, close any virtual arrays first */
+ if (pool_id == JPOOL_IMAGE) {
+ jvirt_sarray_ptr sptr;
+ jvirt_barray_ptr bptr;
+
+ for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+ if (sptr->b_s_open) { /* there may be no backing store */
+ sptr->b_s_open = FALSE; /* prevent recursive close if error */
+ (*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
+ }
+ }
+ mem->virt_sarray_list = NULL;
+ for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+ if (bptr->b_s_open) { /* there may be no backing store */
+ bptr->b_s_open = FALSE; /* prevent recursive close if error */
+ (*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
+ }
+ }
+ mem->virt_barray_list = NULL;
+ }
+
+ /* Release large objects */
+ lhdr_ptr = mem->large_list[pool_id];
+ mem->large_list[pool_id] = NULL;
+
+ while (lhdr_ptr != NULL) {
+ large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
+ space_freed = lhdr_ptr->hdr.bytes_used +
+ lhdr_ptr->hdr.bytes_left +
+ SIZEOF(large_pool_hdr);
+ jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
+ mem->total_space_allocated -= space_freed;
+ lhdr_ptr = next_lhdr_ptr;
+ }
+
+ /* Release small objects */
+ shdr_ptr = mem->small_list[pool_id];
+ mem->small_list[pool_id] = NULL;
+
+ while (shdr_ptr != NULL) {
+ small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
+ space_freed = shdr_ptr->hdr.bytes_used +
+ shdr_ptr->hdr.bytes_left +
+ SIZEOF(small_pool_hdr);
+ jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
+ mem->total_space_allocated -= space_freed;
+ shdr_ptr = next_shdr_ptr;
+ }
+}
+
+
+/*
+ * Close up shop entirely.
+ * Note that this cannot be called unless cinfo->mem is non-NULL.
+ */
+
+METHODDEF(void)
+self_destruct (j_common_ptr cinfo)
+{
+ int pool;
+
+ /* Close all backing store, release all memory.
+ * Releasing pools in reverse order might help avoid fragmentation
+ * with some (brain-damaged) malloc libraries.
+ */
+ for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+ free_pool(cinfo, pool);
+ }
+
+ /* Release the memory manager control block too. */
+ jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
+ cinfo->mem = NULL; /* ensures I will be called only once */
+
+ jpeg_mem_term(cinfo); /* system-dependent cleanup */
+}
+
+
+/*
+ * Memory manager initialization.
+ * When this is called, only the error manager pointer is valid in cinfo!
+ */
+
+GLOBAL(void)
+jinit_memory_mgr (j_common_ptr cinfo)
+{
+ my_mem_ptr mem;
+ long max_to_use;
+ int pool;
+ size_t test_mac;
+
+ cinfo->mem = NULL; /* for safety if init fails */
+
+ /* Check for configuration errors.
+ * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
+ * doesn't reflect any real hardware alignment requirement.
+ * The test is a little tricky: for X>0, X and X-1 have no one-bits
+ * in common if and only if X is a power of 2, ie has only one one-bit.
+ * Some compilers may give an "unreachable code" warning here; ignore it.
+ */
+ if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
+ ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
+ /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
+ * a multiple of SIZEOF(ALIGN_TYPE).
+ * Again, an "unreachable code" warning may be ignored here.
+ * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
+ */
+ test_mac = (size_t) MAX_ALLOC_CHUNK;
+ if ((long) test_mac != MAX_ALLOC_CHUNK ||
+ (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
+ ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
+
+ max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
+
+ /* Attempt to allocate memory manager's control block */
+ mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));
+
+ if (mem == NULL) {
+ jpeg_mem_term(cinfo); /* system-dependent cleanup */
+ ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
+ }
+
+ /* OK, fill in the method pointers */
+ mem->pub.alloc_small = alloc_small;
+ mem->pub.alloc_large = alloc_large;
+ mem->pub.alloc_sarray = alloc_sarray;
+ mem->pub.alloc_barray = alloc_barray;
+ mem->pub.request_virt_sarray = request_virt_sarray;
+ mem->pub.request_virt_barray = request_virt_barray;
+ mem->pub.realize_virt_arrays = realize_virt_arrays;
+ mem->pub.access_virt_sarray = access_virt_sarray;
+ mem->pub.access_virt_barray = access_virt_barray;
+ mem->pub.free_pool = free_pool;
+ mem->pub.self_destruct = self_destruct;
+
+ /* Make MAX_ALLOC_CHUNK accessible to other modules */
+ mem->pub.max_alloc_chunk = MAX_ALLOC_CHUNK;
+
+ /* Initialize working state */
+ mem->pub.max_memory_to_use = max_to_use;
+
+ for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+ mem->small_list[pool] = NULL;
+ mem->large_list[pool] = NULL;
+ }
+ mem->virt_sarray_list = NULL;
+ mem->virt_barray_list = NULL;
+
+ mem->total_space_allocated = SIZEOF(my_memory_mgr);
+
+ /* Declare ourselves open for business */
+ cinfo->mem = & mem->pub;
+
+ /* Check for an environment variable JPEGMEM; if found, override the
+ * default max_memory setting from jpeg_mem_init. Note that the
+ * surrounding application may again override this value.
+ * If your system doesn't support getenv(), define NO_GETENV to disable
+ * this feature.
+ */
+#ifndef NO_GETENV
+ { char * memenv;
+
+ if ((memenv = getenv("JPEGMEM")) != NULL) {
+ char ch = 'x';
+
+ if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
+ if (ch == 'm' || ch == 'M')
+ max_to_use *= 1000L;
+ mem->pub.max_memory_to_use = max_to_use * 1000L;
+ }
+ }
+ }
+#endif
+
+}
--- /dev/null
+/*
+ * jmemnobs.c
+ *
+ * Copyright (C) 1992-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager. This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ * Note that the max_memory_to_use option is ignored by this implementation.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h" /* import the system-dependent declarations */
+
+#ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
+extern void * malloc JPP((size_t size));
+extern void free JPP((void *ptr));
+#endif
+
+
+/*
+ * Memory allocation and freeing are controlled by the regular library
+ * routines malloc() and free().
+ */
+
+GLOBAL(void *)
+jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
+{
+ return (void *) malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
+{
+ free(object);
+}
+
+
+/*
+ * "Large" objects are treated the same as "small" ones.
+ * NB: although we include FAR keywords in the routine declarations,
+ * this file won't actually work in 80x86 small/medium model; at least,
+ * you probably won't be able to process useful-size images in only 64KB.
+ */
+
+GLOBAL(void FAR *)
+jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
+{
+ return (void FAR *) malloc(sizeofobject);
+}
+
+GLOBAL(void)
+jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
+{
+ free(object);
+}
+
+
+/*
+ * This routine computes the total memory space available for allocation.
+ * Here we always say, "we got all you want bud!"
+ */
+
+GLOBAL(long)
+jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
+ long max_bytes_needed, long already_allocated)
+{
+ return max_bytes_needed;
+}
+
+
+/*
+ * Backing store (temporary file) management.
+ * Since jpeg_mem_available always promised the moon,
+ * this should never be called and we can just error out.
+ */
+
+GLOBAL(void)
+jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
+ long total_bytes_needed)
+{
+ ERREXIT(cinfo, JERR_NO_BACKING_STORE);
+}
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required. Here, there isn't any.
+ */
+
+GLOBAL(long)
+jpeg_mem_init (j_common_ptr cinfo)
+{
+ return 0; /* just set max_memory_to_use to 0 */
+}
+
+GLOBAL(void)
+jpeg_mem_term (j_common_ptr cinfo)
+{
+ /* no work */
+}
--- /dev/null
+/*
+ * jmemsys.h
+ *
+ * Copyright (C) 1992-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager. No other
+ * modules need include it. (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution. You may need to modify it if you write a
+ * custom memory manager. If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR
+ * and USE_MAC_MEMMGR.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_get_small jGetSmall
+#define jpeg_free_small jFreeSmall
+#define jpeg_get_large jGetLarge
+#define jpeg_free_large jFreeLarge
+#define jpeg_mem_available jMemAvail
+#define jpeg_open_backing_store jOpenBackStore
+#define jpeg_mem_init jMemInit
+#define jpeg_mem_term jMemTerm
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory. (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free. jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ * On an 80x86 machine using small-data memory model, these manage near heap.
+ */
+
+EXTERN(void *) jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject));
+EXTERN(void) jpeg_free_small JPP((j_common_ptr cinfo, void * object,
+ size_t sizeofobject));
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * The interface is the same as above, except that on an 80x86 machine,
+ * far pointers are used. On most other machines these are identical to
+ * the jpeg_get/free_small routines; but we keep them separate anyway,
+ * in case a different allocation strategy is desirable for large chunks.
+ */
+
+EXTERN(void FAR *) jpeg_get_large JPP((j_common_ptr cinfo,
+ size_t sizeofobject));
+EXTERN(void) jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
+ size_t sizeofobject));
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play). This macro is needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On those machines, we expect that jconfig.h will provide a proper value.
+ * On machines with 32-bit flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK /* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK 1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large. If more space than this is needed, backing store will be
+ * used. NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero. The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed. If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure. Hence it's wise to subtract
+ * a slop factor from the true available space. 5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN(long) jpeg_mem_available JPP((j_common_ptr cinfo,
+ long min_bytes_needed,
+ long max_bytes_needed,
+ long already_allocated));
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object. The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH 64 /* max length of a temporary file's name */
+
+
+#ifdef USE_MSDOS_MEMMGR /* DOS-specific junk */
+
+typedef unsigned short XMSH; /* type of extended-memory handles */
+typedef unsigned short EMSH; /* type of expanded-memory handles */
+
+typedef union {
+ short file_handle; /* DOS file handle if it's a temp file */
+ XMSH xms_handle; /* handle if it's a chunk of XMS */
+ EMSH ems_handle; /* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+#ifdef USE_MAC_MEMMGR /* Mac-specific junk */
+#include <Files.h>
+#endif /* USE_MAC_MEMMGR */
+
+
+typedef struct backing_store_struct * backing_store_ptr;
+
+typedef struct backing_store_struct {
+ /* Methods for reading/writing/closing this backing-store object */
+ JMETHOD(void, read_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info,
+ void FAR * buffer_address,
+ long file_offset, long byte_count));
+ JMETHOD(void, write_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info,
+ void FAR * buffer_address,
+ long file_offset, long byte_count));
+ JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
+ backing_store_ptr info));
+
+ /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+ /* For the MS-DOS manager (jmemdos.c), we need: */
+ handle_union handle; /* reference to backing-store storage object */
+ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+#ifdef USE_MAC_MEMMGR
+ /* For the Mac manager (jmemmac.c), we need: */
+ short temp_file; /* file reference number to temp file */
+ FSSpec tempSpec; /* the FSSpec for the temp file */
+ char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+ /* For a typical implementation with temp files, we need: */
+ FILE * temp_file; /* stdio reference to temp file */
+ char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+#endif
+} backing_store_info;
+
+
+/*
+ * Initial opening of a backing-store object. This must fill in the
+ * read/write/close pointers in the object. The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN(void) jpeg_open_backing_store JPP((j_common_ptr cinfo,
+ backing_store_ptr info,
+ long total_bytes_needed));
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required. jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer). It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application. (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN(long) jpeg_mem_init JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_mem_term JPP((j_common_ptr cinfo));
--- /dev/null
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations. Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ * 8 for 8-bit sample values (the usual setting)
+ * 12 for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255. However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask). We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory. (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS 10 /* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small. But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value) ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value) ((int) (value))
+#else
+#define GETJSAMPLE(value) ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE 255
+#define CENTERJSAMPLE 128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value) ((int) (value))
+
+#define MAXJSAMPLE 4095
+#define CENTERJSAMPLE 2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage. Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value) (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value) (value)
+#else
+#define GETJOCTET(value) ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE. (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */
+typedef int INT32;
+#endif
+
+/* Datatype used for image dimensions. The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
+ * "unsigned int" is sufficient on all machines. However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
+
+
+/* These macros are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions;
+ * in particular, you'll need to do that to make the library a Windows DLL.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+/* a function called through method pointers: */
+#define METHODDEF(type) static type
+/* a function used only in its module: */
+#define LOCAL(type) static type
+/* a function referenced thru EXTERNs: */
+#define GLOBAL(type) type
+/* a reference to a GLOBAL function: */
+#define EXTERN(type) extern type
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ * Again, you can customize this if you need special linkage keywords.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist) type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist) type (*methodname) ()
+#endif
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines. Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed. In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifdef FAR
+#undef FAR
+#endif
+
+#ifdef NEED_FAR_POINTERS
+#define FAR far
+#else
+#define FAR
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files. Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+#ifndef HAVE_BOOLEAN
+typedef int boolean;
+#endif
+#ifndef FALSE /* in case these macros already exist */
+#define FALSE 0 /* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library. Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */
+
+/* Capability options common to encoder and decoder: */
+
+#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */
+#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision. If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode. (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */
+#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
+#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
+#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
+#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
+#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
+#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
+#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
+#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros. You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
+ * useful if you are using JPEG color spaces other than YCbCr or grayscale.
+ * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ * is not 3 (they don't understand about dummy color components!). So you
+ * can't use color quantization if you change that value.
+ */
+
+#define RGB_RED 0 /* Offset of Red in an RGB scanline element */
+#define RGB_GREEN 1 /* Offset of Green */
+#define RGB_BLUE 2 /* Offset of Blue */
+#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__ /* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE /* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
+ * as short on such a machine. MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER int /* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler. (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT float
+#else
+#define FAST_FLOAT double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
--- /dev/null
+/*
+ * jpegint.h
+ *
+ * Copyright (C) 1991-1997, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum { /* Operating modes for buffer controllers */
+ JBUF_PASS_THRU, /* Plain stripwise operation */
+ /* Remaining modes require a full-image buffer to have been created */
+ JBUF_SAVE_SOURCE, /* Run source subobject only, save output */
+ JBUF_CRANK_DEST, /* Run dest subobject only, using saved data */
+ JBUF_SAVE_AND_PASS /* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START 100 /* after create_compress */
+#define CSTATE_SCANNING 101 /* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK 102 /* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS 103 /* jpeg_write_coefficients done */
+#define DSTATE_START 200 /* after create_decompress */
+#define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */
+#define DSTATE_READY 202 /* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD 203 /* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN 204 /* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING 205 /* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK 206 /* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE 207 /* expecting jpeg_start_output */
+#define DSTATE_BUFPOST 208 /* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS 209 /* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING 210 /* looking for EOI in jpeg_finish_decompress */
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+ JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean call_pass_startup; /* True if pass_startup must be called */
+ boolean is_last_pass; /* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, process_data, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail));
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf,
+ JDIMENSION *in_row_ctr,
+ JDIMENSION in_rows_avail,
+ JSAMPIMAGE output_buf,
+ JDIMENSION *out_row_group_ctr,
+ JDIMENSION out_row_groups_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf));
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+ JDIMENSION output_row, int num_rows));
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ JMETHOD(void, downsample, (j_compress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+ JSAMPIMAGE output_buf,
+ JDIMENSION out_row_group_index));
+
+ boolean need_context_rows; /* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+struct jpeg_forward_dct {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+ /* perhaps this should be an array??? */
+ JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
+ jpeg_component_info * compptr,
+ JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+ JDIMENSION start_row, JDIMENSION start_col,
+ JDIMENSION num_blocks));
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+ JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+ JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+ JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+ JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
+ JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+ JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+ /* These routines are exported to allow insertion of extra markers */
+ /* Probably only COM and APPn markers should be written this way */
+ JMETHOD(void, write_marker_header, (j_compress_ptr cinfo, int marker,
+ unsigned int datalen));
+ JMETHOD(void, write_marker_byte, (j_compress_ptr cinfo, int val));
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+ JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean is_dummy_pass; /* True during 1st pass for 2-pass quant */
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+ JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
+ JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+
+ /* State variables made visible to other modules */
+ boolean has_multiple_scans; /* True if file has multiple scans */
+ boolean eoi_reached; /* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+ JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+ JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+ JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
+ JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+ JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+ JSAMPIMAGE output_buf));
+ /* Pointer to array of coefficient virtual arrays, or NULL if none */
+ jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+ JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf,
+ JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+ JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+ /* Read markers until SOS or EOI.
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+ JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+ /* Read a restart marker --- exported for use by entropy decoder only */
+ jpeg_marker_parser_method read_restart_marker;
+
+ /* State of marker reader --- nominally internal, but applications
+ * supplying COM or APPn handlers might like to know the state.
+ */
+ boolean saw_SOI; /* found SOI? */
+ boolean saw_SOF; /* found SOF? */
+ int next_restart_num; /* next restart number expected (0-7) */
+ unsigned int discarded_bytes; /* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
+ JBLOCKROW *MCU_data));
+
+ /* This is here to share code between baseline and progressive decoders; */
+ /* other modules probably should not use it */
+ boolean insufficient_data; /* set TRUE after emitting warning */
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef JMETHOD(void, inverse_DCT_method_ptr,
+ (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col));
+
+struct jpeg_inverse_dct {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ /* It is useful to allow each component to have a separate IDCT method. */
+ inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf,
+ JDIMENSION *in_row_group_ctr,
+ JDIMENSION in_row_groups_avail,
+ JSAMPARRAY output_buf,
+ JDIMENSION *out_row_ctr,
+ JDIMENSION out_rows_avail));
+
+ boolean need_context_rows; /* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+ JSAMPIMAGE input_buf, JDIMENSION input_row,
+ JSAMPARRAY output_buf, int num_rows));
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+ JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+ JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf,
+ int num_rows));
+ JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+ JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity. This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit. But some
+ * C compilers implement >> with an unsigned shift. For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts. SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft) \
+ ((shift_temp = (x)) < 0 ? \
+ (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+ (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_compress_master jICompress
+#define jinit_c_master_control jICMaster
+#define jinit_c_main_controller jICMainC
+#define jinit_c_prep_controller jICPrepC
+#define jinit_c_coef_controller jICCoefC
+#define jinit_color_converter jICColor
+#define jinit_downsampler jIDownsampler
+#define jinit_forward_dct jIFDCT
+#define jinit_huff_encoder jIHEncoder
+#define jinit_phuff_encoder jIPHEncoder
+#define jinit_marker_writer jIMWriter
+#define jinit_master_decompress jIDMaster
+#define jinit_d_main_controller jIDMainC
+#define jinit_d_coef_controller jIDCoefC
+#define jinit_d_post_controller jIDPostC
+#define jinit_input_controller jIInCtlr
+#define jinit_marker_reader jIMReader
+#define jinit_huff_decoder jIHDecoder
+#define jinit_phuff_decoder jIPHDecoder
+#define jinit_inverse_dct jIIDCT
+#define jinit_upsampler jIUpsampler
+#define jinit_color_deconverter jIDColor
+#define jinit_1pass_quantizer jI1Quant
+#define jinit_2pass_quantizer jI2Quant
+#define jinit_merged_upsampler jIMUpsampler
+#define jinit_memory_mgr jIMemMgr
+#define jdiv_round_up jDivRound
+#define jround_up jRound
+#define jcopy_sample_rows jCopySamples
+#define jcopy_block_row jCopyBlocks
+#define jzero_far jZeroFar
+#define jpeg_zigzag_order jZIGTable
+#define jpeg_natural_order jZAGTable
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Compression module initialization routines */
+EXTERN(void) jinit_compress_master JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_c_master_control JPP((j_compress_ptr cinfo,
+ boolean transcode_only));
+EXTERN(void) jinit_c_main_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_c_prep_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_c_coef_controller JPP((j_compress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_color_converter JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_downsampler JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_forward_dct JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_huff_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_phuff_encoder JPP((j_compress_ptr cinfo));
+EXTERN(void) jinit_marker_writer JPP((j_compress_ptr cinfo));
+/* Decompression module initialization routines */
+EXTERN(void) jinit_master_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_d_main_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_d_post_controller JPP((j_decompress_ptr cinfo,
+ boolean need_full_buffer));
+EXTERN(void) jinit_input_controller JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_marker_reader JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_huff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_inverse_dct JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_upsampler JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_color_deconverter JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN(void) jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
+/* Memory manager initialization */
+EXTERN(void) jinit_memory_mgr JPP((j_common_ptr cinfo));
+
+/* Utility routines in jutils.c */
+EXTERN(long) jdiv_round_up JPP((long a, long b));
+EXTERN(long) jround_up JPP((long a, long b));
+EXTERN(void) jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+ JSAMPARRAY output_array, int dest_row,
+ int num_rows, JDIMENSION num_cols));
+EXTERN(void) jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
+ JDIMENSION num_blocks));
+EXTERN(void) jzero_far JPP((void FAR * target, size_t bytestozero));
+/* Constant tables in jutils.c */
+#if 0 /* This table is not actually needed in v6a */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+#endif
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER /* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
--- /dev/null
+/*
+ * jpeglib.h
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up. jconfig.h can be
+ * generated automatically for many systems. jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */
+#include "jconfig.h" /* widely used configuration options */
+#endif
+#include "jmorecfg.h" /* seldom changed options */
+
+
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+
+#define JPEG_LIB_VERSION 62 /* Version 6b */
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */
+#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it. We even let you do this from the jconfig.h file. However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ * On 80x86 machines, the image arrays are too big for near pointers,
+ * but the pointer arrays can fit in near memory.
+ */
+
+typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+ /* This array gives the coefficient quantizers in natural array order
+ * (not the zigzag order in which they are stored in a JPEG DQT marker).
+ * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
+ */
+ UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */
+ /* This field is used only during compression. It's initialized FALSE when
+ * the table is created, and set TRUE when it's been output to the file.
+ * You could suppress output of a table by setting this to TRUE.
+ * (See jpeg_suppress_tables for an example.)
+ */
+ boolean sent_table; /* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+ /* These two fields directly represent the contents of a JPEG DHT marker */
+ UINT8 bits[17]; /* bits[k] = # of symbols with codes of */
+ /* length k bits; bits[0] is unused */
+ UINT8 huffval[256]; /* The symbols, in order of incr code length */
+ /* This field is used only during compression. It's initialized FALSE when
+ * the table is created, and set TRUE when it's been output to the file.
+ * You could suppress output of a table by setting this to TRUE.
+ * (See jpeg_suppress_tables for an example.)
+ */
+ boolean sent_table; /* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+ /* These values are fixed over the whole image. */
+ /* For compression, they must be supplied by parameter setup; */
+ /* for decompression, they are read from the SOF marker. */
+ int component_id; /* identifier for this component (0..255) */
+ int component_index; /* its index in SOF or cinfo->comp_info[] */
+ int h_samp_factor; /* horizontal sampling factor (1..4) */
+ int v_samp_factor; /* vertical sampling factor (1..4) */
+ int quant_tbl_no; /* quantization table selector (0..3) */
+ /* These values may vary between scans. */
+ /* For compression, they must be supplied by parameter setup; */
+ /* for decompression, they are read from the SOS marker. */
+ /* The decompressor output side may not use these variables. */
+ int dc_tbl_no; /* DC entropy table selector (0..3) */
+ int ac_tbl_no; /* AC entropy table selector (0..3) */
+
+ /* Remaining fields should be treated as private by applications. */
+
+ /* These values are computed during compression or decompression startup: */
+ /* Component's size in DCT blocks.
+ * Any dummy blocks added to complete an MCU are not counted; therefore
+ * these values do not depend on whether a scan is interleaved or not.
+ */
+ JDIMENSION width_in_blocks;
+ JDIMENSION height_in_blocks;
+ /* Size of a DCT block in samples. Always DCTSIZE for compression.
+ * For decompression this is the size of the output from one DCT block,
+ * reflecting any scaling we choose to apply during the IDCT step.
+ * Values of 1,2,4,8 are likely to be supported. Note that different
+ * components may receive different IDCT scalings.
+ */
+ int DCT_scaled_size;
+ /* The downsampled dimensions are the component's actual, unpadded number
+ * of samples at the main buffer (preprocessing/compression interface), thus
+ * downsampled_width = ceil(image_width * Hi/Hmax)
+ * and similarly for height. For decompression, IDCT scaling is included, so
+ * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
+ */
+ JDIMENSION downsampled_width; /* actual width in samples */
+ JDIMENSION downsampled_height; /* actual height in samples */
+ /* This flag is used only for decompression. In cases where some of the
+ * components will be ignored (eg grayscale output from YCbCr image),
+ * we can skip most computations for the unused components.
+ */
+ boolean component_needed; /* do we need the value of this component? */
+
+ /* These values are computed before starting a scan of the component. */
+ /* The decompressor output side may not use these variables. */
+ int MCU_width; /* number of blocks per MCU, horizontally */
+ int MCU_height; /* number of blocks per MCU, vertically */
+ int MCU_blocks; /* MCU_width * MCU_height */
+ int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */
+ int last_col_width; /* # of non-dummy blocks across in last MCU */
+ int last_row_height; /* # of non-dummy blocks down in last MCU */
+
+ /* Saved quantization table for component; NULL if none yet saved.
+ * See jdinput.c comments about the need for this information.
+ * This field is currently used only for decompression.
+ */
+ JQUANT_TBL * quant_table;
+
+ /* Private per-component storage for DCT or IDCT subsystem. */
+ void * dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+ int comps_in_scan; /* number of components encoded in this scan */
+ int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+ int Ss, Se; /* progressive JPEG spectral selection parms */
+ int Ah, Al; /* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+/* The decompressor can save APPn and COM markers in a list of these: */
+
+typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr;
+
+struct jpeg_marker_struct {
+ jpeg_saved_marker_ptr next; /* next in list, or NULL */
+ UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */
+ unsigned int original_length; /* # bytes of data in the file */
+ unsigned int data_length; /* # bytes of data saved at data[] */
+ JOCTET FAR * data; /* the data contained in the marker */
+ /* the marker length word is not counted in data_length or original_length */
+};
+
+/* Known color spaces. */
+
+typedef enum {
+ JCS_UNKNOWN, /* error/unspecified */
+ JCS_GRAYSCALE, /* monochrome */
+ JCS_RGB, /* red/green/blue */
+ JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */
+ JCS_CMYK, /* C/M/Y/K */
+ JCS_YCCK /* Y/Cb/Cr/K */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+ JDCT_ISLOW, /* slow but accurate integer algorithm */
+ JDCT_IFAST, /* faster, less accurate integer method */
+ JDCT_FLOAT /* floating-point: accurate, fast on fast HW */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */
+#define JDCT_DEFAULT JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */
+#define JDCT_FASTEST JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+ JDITHER_NONE, /* no dithering */
+ JDITHER_ORDERED, /* simple ordered dither */
+ JDITHER_FS /* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+ struct jpeg_error_mgr * err; /* Error handler module */\
+ struct jpeg_memory_mgr * mem; /* Memory manager module */\
+ struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
+ void * client_data; /* Available for use by application */\
+ boolean is_decompressor; /* So common code can tell which is which */\
+ int global_state /* For checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure. There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+ jpeg_common_fields; /* Fields common to both master struct types */
+ /* Additional fields follow in an actual jpeg_compress_struct or
+ * jpeg_decompress_struct. All three structs must agree on these
+ * initial fields! (This would be a lot cleaner in C++.)
+ */
+};
+
+typedef struct jpeg_common_struct * j_common_ptr;
+typedef struct jpeg_compress_struct * j_compress_ptr;
+typedef struct jpeg_decompress_struct * j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+ jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */
+
+ /* Destination for compressed data */
+ struct jpeg_destination_mgr * dest;
+
+ /* Description of source image --- these fields must be filled in by
+ * outer application before starting compression. in_color_space must
+ * be correct before you can even call jpeg_set_defaults().
+ */
+
+ JDIMENSION image_width; /* input image width */
+ JDIMENSION image_height; /* input image height */
+ int input_components; /* # of color components in input image */
+ J_COLOR_SPACE in_color_space; /* colorspace of input image */
+
+ double input_gamma; /* image gamma of input image */
+
+ /* Compression parameters --- these fields must be set before calling
+ * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to
+ * initialize everything to reasonable defaults, then changing anything
+ * the application specifically wants to change. That way you won't get
+ * burnt when new parameters are added. Also note that there are several
+ * helper routines to simplify changing parameters.
+ */
+
+ int data_precision; /* bits of precision in image data */
+
+ int num_components; /* # of color components in JPEG image */
+ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+ jpeg_component_info * comp_info;
+ /* comp_info[i] describes component that appears i'th in SOF */
+
+ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+ /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ /* ptrs to Huffman coding tables, or NULL if not defined */
+
+ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+ int num_scans; /* # of entries in scan_info array */
+ const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
+ /* The default value of scan_info is NULL, which causes a single-scan
+ * sequential JPEG file to be emitted. To create a multi-scan file,
+ * set num_scans and scan_info to point to an array of scan definitions.
+ */
+
+ boolean raw_data_in; /* TRUE=caller supplies downsampled data */
+ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
+ boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
+ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+ int smoothing_factor; /* 1..100, or 0 for no input smoothing */
+ J_DCT_METHOD dct_method; /* DCT algorithm selector */
+
+ /* The restart interval can be specified in absolute MCUs by setting
+ * restart_interval, or in MCU rows by setting restart_in_rows
+ * (in which case the correct restart_interval will be figured
+ * for each scan).
+ */
+ unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+ int restart_in_rows; /* if > 0, MCU rows per restart interval */
+
+ /* Parameters controlling emission of special markers. */
+
+ boolean write_JFIF_header; /* should a JFIF marker be written? */
+ UINT8 JFIF_major_version; /* What to write for the JFIF version number */
+ UINT8 JFIF_minor_version;
+ /* These three values are not used by the JPEG code, merely copied */
+ /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */
+ /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */
+ /* ratio is defined by X_density/Y_density even when density_unit=0. */
+ UINT8 density_unit; /* JFIF code for pixel size units */
+ UINT16 X_density; /* Horizontal pixel density */
+ UINT16 Y_density; /* Vertical pixel density */
+ boolean write_Adobe_marker; /* should an Adobe marker be written? */
+
+ /* State variable: index of next scanline to be written to
+ * jpeg_write_scanlines(). Application may use this to control its
+ * processing loop, e.g., "while (next_scanline < image_height)".
+ */
+
+ JDIMENSION next_scanline; /* 0 .. image_height-1 */
+
+ /* Remaining fields are known throughout compressor, but generally
+ * should not be touched by a surrounding application.
+ */
+
+ /*
+ * These fields are computed during compression startup
+ */
+ boolean progressive_mode; /* TRUE if scan script uses progressive mode */
+ int max_h_samp_factor; /* largest h_samp_factor */
+ int max_v_samp_factor; /* largest v_samp_factor */
+
+ JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */
+ /* The coefficient controller receives data in units of MCU rows as defined
+ * for fully interleaved scans (whether the JPEG file is interleaved or not).
+ * There are v_samp_factor * DCTSIZE sample rows of each component in an
+ * "iMCU" (interleaved MCU) row.
+ */
+
+ /*
+ * These fields are valid during any one scan.
+ * They describe the components and MCUs actually appearing in the scan.
+ */
+ int comps_in_scan; /* # of JPEG components in this scan */
+ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+ /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
+ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
+
+ int blocks_in_MCU; /* # of DCT blocks per MCU */
+ int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+ /* MCU_membership[i] is index in cur_comp_info of component owning */
+ /* i'th block in an MCU */
+
+ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
+
+ /*
+ * Links to compression subobjects (methods and private variables of modules)
+ */
+ struct jpeg_comp_master * master;
+ struct jpeg_c_main_controller * main;
+ struct jpeg_c_prep_controller * prep;
+ struct jpeg_c_coef_controller * coef;
+ struct jpeg_marker_writer * marker;
+ struct jpeg_color_converter * cconvert;
+ struct jpeg_downsampler * downsample;
+ struct jpeg_forward_dct * fdct;
+ struct jpeg_entropy_encoder * entropy;
+ jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */
+ int script_space_size;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+ jpeg_common_fields; /* Fields shared with jpeg_compress_struct */
+
+ /* Source of compressed data */
+ struct jpeg_source_mgr * src;
+
+ /* Basic description of image --- filled in by jpeg_read_header(). */
+ /* Application may inspect these values to decide how to process image. */
+
+ JDIMENSION image_width; /* nominal image width (from SOF marker) */
+ JDIMENSION image_height; /* nominal image height */
+ int num_components; /* # of color components in JPEG image */
+ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+ /* Decompression processing parameters --- these fields must be set before
+ * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes
+ * them to default values.
+ */
+
+ J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+ unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+ double output_gamma; /* image gamma wanted in output */
+
+ boolean buffered_image; /* TRUE=multiple output passes */
+ boolean raw_data_out; /* TRUE=downsampled data wanted */
+
+ J_DCT_METHOD dct_method; /* IDCT algorithm selector */
+ boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */
+ boolean do_block_smoothing; /* TRUE=apply interblock smoothing */
+
+ boolean quantize_colors; /* TRUE=colormapped output wanted */
+ /* the following are ignored if not quantize_colors: */
+ J_DITHER_MODE dither_mode; /* type of color dithering to use */
+ boolean two_pass_quantize; /* TRUE=use two-pass color quantization */
+ int desired_number_of_colors; /* max # colors to use in created colormap */
+ /* these are significant only in buffered-image mode: */
+ boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */
+ boolean enable_external_quant;/* enable future use of external colormap */
+ boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */
+
+ /* Description of actual output image that will be returned to application.
+ * These fields are computed by jpeg_start_decompress().
+ * You can also use jpeg_calc_output_dimensions() to determine these values
+ * in advance of calling jpeg_start_decompress().
+ */
+
+ JDIMENSION output_width; /* scaled image width */
+ JDIMENSION output_height; /* scaled image height */
+ int out_color_components; /* # of color components in out_color_space */
+ int output_components; /* # of color components returned */
+ /* output_components is 1 (a colormap index) when quantizing colors;
+ * otherwise it equals out_color_components.
+ */
+ int rec_outbuf_height; /* min recommended height of scanline buffer */
+ /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+ * high, space and time will be wasted due to unnecessary data copying.
+ * Usually rec_outbuf_height will be 1 or 2, at most 4.
+ */
+
+ /* When quantizing colors, the output colormap is described by these fields.
+ * The application can supply a colormap by setting colormap non-NULL before
+ * calling jpeg_start_decompress; otherwise a colormap is created during
+ * jpeg_start_decompress or jpeg_start_output.
+ * The map has out_color_components rows and actual_number_of_colors columns.
+ */
+ int actual_number_of_colors; /* number of entries in use */
+ JSAMPARRAY colormap; /* The color map as a 2-D pixel array */
+
+ /* State variables: these variables indicate the progress of decompression.
+ * The application may examine these but must not modify them.
+ */
+
+ /* Row index of next scanline to be read from jpeg_read_scanlines().
+ * Application may use this to control its processing loop, e.g.,
+ * "while (output_scanline < output_height)".
+ */
+ JDIMENSION output_scanline; /* 0 .. output_height-1 */
+
+ /* Current input scan number and number of iMCU rows completed in scan.
+ * These indicate the progress of the decompressor input side.
+ */
+ int input_scan_number; /* Number of SOS markers seen so far */
+ JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */
+
+ /* The "output scan number" is the notional scan being displayed by the
+ * output side. The decompressor will not allow output scan/row number
+ * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+ */
+ int output_scan_number; /* Nominal scan number being displayed */
+ JDIMENSION output_iMCU_row; /* Number of iMCU rows read */
+
+ /* Current progression status. coef_bits[c][i] indicates the precision
+ * with which component c's DCT coefficient i (in zigzag order) is known.
+ * It is -1 when no data has yet been received, otherwise it is the point
+ * transform (shift) value for the most recent scan of the coefficient
+ * (thus, 0 at completion of the progression).
+ * This pointer is NULL when reading a non-progressive file.
+ */
+ int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */
+
+ /* Internal JPEG parameters --- the application usually need not look at
+ * these fields. Note that the decompressor output side may not use
+ * any parameters that can change between scans.
+ */
+
+ /* Quantization and Huffman tables are carried forward across input
+ * datastreams when processing abbreviated JPEG datastreams.
+ */
+
+ JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+ /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+ JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+ /* ptrs to Huffman coding tables, or NULL if not defined */
+
+ /* These parameters are never carried across datastreams, since they
+ * are given in SOF/SOS markers or defined to be reset by SOI.
+ */
+
+ int data_precision; /* bits of precision in image data */
+
+ jpeg_component_info * comp_info;
+ /* comp_info[i] describes component that appears i'th in SOF */
+
+ boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */
+ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
+
+ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+ unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+ /* These fields record data obtained from optional markers recognized by
+ * the JPEG library.
+ */
+ boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */
+ /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
+ UINT8 JFIF_major_version; /* JFIF version number */
+ UINT8 JFIF_minor_version;
+ UINT8 density_unit; /* JFIF code for pixel size units */
+ UINT16 X_density; /* Horizontal pixel density */
+ UINT16 Y_density; /* Vertical pixel density */
+ boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */
+ UINT8 Adobe_transform; /* Color transform code from Adobe marker */
+
+ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
+
+ /* Aside from the specific data retained from APPn markers known to the
+ * library, the uninterpreted contents of any or all APPn and COM markers
+ * can be saved in a list for examination by the application.
+ */
+ jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
+
+ /* Remaining fields are known throughout decompressor, but generally
+ * should not be touched by a surrounding application.
+ */
+
+ /*
+ * These fields are computed during decompression startup
+ */
+ int max_h_samp_factor; /* largest h_samp_factor */
+ int max_v_samp_factor; /* largest v_samp_factor */
+
+ int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */
+
+ JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */
+ /* The coefficient controller's input and output progress is measured in
+ * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows
+ * in fully interleaved JPEG scans, but are used whether the scan is
+ * interleaved or not. We define an iMCU row as v_samp_factor DCT block
+ * rows of each component. Therefore, the IDCT output contains
+ * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
+ */
+
+ JSAMPLE * sample_range_limit; /* table for fast range-limiting */
+
+ /*
+ * These fields are valid during any one scan.
+ * They describe the components and MCUs actually appearing in the scan.
+ * Note that the decompressor output side must not use these fields.
+ */
+ int comps_in_scan; /* # of JPEG components in this scan */
+ jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+ /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
+ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
+
+ int blocks_in_MCU; /* # of DCT blocks per MCU */
+ int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+ /* MCU_membership[i] is index in cur_comp_info of component owning */
+ /* i'th block in an MCU */
+
+ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
+
+ /* This field is shared between entropy decoder and marker parser.
+ * It is either zero or the code of a JPEG marker that has been
+ * read from the data source, but has not yet been processed.
+ */
+ int unread_marker;
+
+ /*
+ * Links to decompression subobjects (methods, private variables of modules)
+ */
+ struct jpeg_decomp_master * master;
+ struct jpeg_d_main_controller * main;
+ struct jpeg_d_coef_controller * coef;
+ struct jpeg_d_post_controller * post;
+ struct jpeg_input_controller * inputctl;
+ struct jpeg_marker_reader * marker;
+ struct jpeg_entropy_decoder * entropy;
+ struct jpeg_inverse_dct * idct;
+ struct jpeg_upsampler * upsample;
+ struct jpeg_color_deconverter * cconvert;
+ struct jpeg_color_quantizer * cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module. Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+ /* Error exit handler: does not return to caller */
+ JMETHOD(void, error_exit, (j_common_ptr cinfo));
+ /* Conditionally emit a trace or warning message */
+ JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
+ /* Routine that actually outputs a trace or error message */
+ JMETHOD(void, output_message, (j_common_ptr cinfo));
+ /* Format a message string for the most recent JPEG error or message */
+ JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
+#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */
+ /* Reset error state variables at start of a new image */
+ JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
+
+ /* The message ID code and any parameters are saved here.
+ * A message can have one string parameter or up to 8 int parameters.
+ */
+ int msg_code;
+#define JMSG_STR_PARM_MAX 80
+ union {
+ int i[8];
+ char s[JMSG_STR_PARM_MAX];
+ } msg_parm;
+
+ /* Standard state variables for error facility */
+
+ int trace_level; /* max msg_level that will be displayed */
+
+ /* For recoverable corrupt-data errors, we emit a warning message,
+ * but keep going unless emit_message chooses to abort. emit_message
+ * should count warnings in num_warnings. The surrounding application
+ * can check for bad data by seeing if num_warnings is nonzero at the
+ * end of processing.
+ */
+ long num_warnings; /* number of corrupt-data warnings */
+
+ /* These fields point to the table(s) of error message strings.
+ * An application can change the table pointer to switch to a different
+ * message list (typically, to change the language in which errors are
+ * reported). Some applications may wish to add additional error codes
+ * that will be handled by the JPEG library error mechanism; the second
+ * table pointer is used for this purpose.
+ *
+ * First table includes all errors generated by JPEG library itself.
+ * Error code 0 is reserved for a "no such error string" message.
+ */
+ const char * const * jpeg_message_table; /* Library errors */
+ int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */
+ /* Second table can be added by application (see cjpeg/djpeg for example).
+ * It contains strings numbered first_addon_message..last_addon_message.
+ */
+ const char * const * addon_message_table; /* Non-library errors */
+ int first_addon_message; /* code for first string in addon table */
+ int last_addon_message; /* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+ JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
+
+ long pass_counter; /* work units completed in this pass */
+ long pass_limit; /* total number of work units in this pass */
+ int completed_passes; /* passes completed so far */
+ int total_passes; /* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+ JOCTET * next_output_byte; /* => next byte to write in buffer */
+ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
+
+ JMETHOD(void, init_destination, (j_compress_ptr cinfo));
+ JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
+ JMETHOD(void, term_destination, (j_compress_ptr cinfo));
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+ const JOCTET * next_input_byte; /* => next byte to read from buffer */
+ size_t bytes_in_buffer; /* # of bytes remaining in buffer */
+
+ JMETHOD(void, init_source, (j_decompress_ptr cinfo));
+ JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
+ JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
+ JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
+ JMETHOD(void, term_source, (j_decompress_ptr cinfo));
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once. This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL. They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */
+#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS 2
+
+typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
+typedef struct jvirt_barray_control * jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+ /* Method pointers */
+ JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
+ size_t sizeofobject));
+ JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
+ size_t sizeofobject));
+ JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
+ JDIMENSION samplesperrow,
+ JDIMENSION numrows));
+ JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
+ JDIMENSION blocksperrow,
+ JDIMENSION numrows));
+ JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
+ int pool_id,
+ boolean pre_zero,
+ JDIMENSION samplesperrow,
+ JDIMENSION numrows,
+ JDIMENSION maxaccess));
+ JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
+ int pool_id,
+ boolean pre_zero,
+ JDIMENSION blocksperrow,
+ JDIMENSION numrows,
+ JDIMENSION maxaccess));
+ JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
+ JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
+ jvirt_sarray_ptr ptr,
+ JDIMENSION start_row,
+ JDIMENSION num_rows,
+ boolean writable));
+ JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
+ jvirt_barray_ptr ptr,
+ JDIMENSION start_row,
+ JDIMENSION num_rows,
+ boolean writable));
+ JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
+ JMETHOD(void, self_destruct, (j_common_ptr cinfo));
+
+ /* Limit on memory allocation for this JPEG object. (Note that this is
+ * merely advisory, not a guaranteed maximum; it only affects the space
+ * used for virtual-array buffers.) May be changed by outer application
+ * after creating the JPEG object.
+ */
+ long max_memory_to_use;
+
+ /* Maximum allocation request accepted by alloc_large. */
+ long max_alloc_chunk;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
+
+
+/* Declarations for routines called by application.
+ * The JPP macro hides prototype parameters from compilers that can't cope.
+ * Note JPP requires double parentheses.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JPP(arglist) arglist
+#else
+#define JPP(arglist) ()
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers.
+ * We shorten external names to be unique in the first six letters, which
+ * is good enough for all known systems.
+ * (If your compiler itself needs names to be unique in less than 15
+ * characters, you are out of luck. Get a better compiler.)
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_error jStdError
+#define jpeg_CreateCompress jCreaCompress
+#define jpeg_CreateDecompress jCreaDecompress
+#define jpeg_destroy_compress jDestCompress
+#define jpeg_destroy_decompress jDestDecompress
+#define jpeg_stdio_dest jStdDest
+#define jpeg_stdio_src jStdSrc
+#define jpeg_set_defaults jSetDefaults
+#define jpeg_set_colorspace jSetColorspace
+#define jpeg_default_colorspace jDefColorspace
+#define jpeg_set_quality jSetQuality
+#define jpeg_set_linear_quality jSetLQuality
+#define jpeg_add_quant_table jAddQuantTable
+#define jpeg_quality_scaling jQualityScaling
+#define jpeg_simple_progression jSimProgress
+#define jpeg_suppress_tables jSuppressTables
+#define jpeg_alloc_quant_table jAlcQTable
+#define jpeg_alloc_huff_table jAlcHTable
+#define jpeg_start_compress jStrtCompress
+#define jpeg_write_scanlines jWrtScanlines
+#define jpeg_finish_compress jFinCompress
+#define jpeg_write_raw_data jWrtRawData
+#define jpeg_write_marker jWrtMarker
+#define jpeg_write_m_header jWrtMHeader
+#define jpeg_write_m_byte jWrtMByte
+#define jpeg_write_tables jWrtTables
+#define jpeg_read_header jReadHeader
+#define jpeg_start_decompress jStrtDecompress
+#define jpeg_read_scanlines jReadScanlines
+#define jpeg_finish_decompress jFinDecompress
+#define jpeg_read_raw_data jReadRawData
+#define jpeg_has_multiple_scans jHasMultScn
+#define jpeg_start_output jStrtOutput
+#define jpeg_finish_output jFinOutput
+#define jpeg_input_complete jInComplete
+#define jpeg_new_colormap jNewCMap
+#define jpeg_consume_input jConsumeInput
+#define jpeg_calc_output_dimensions jCalcDimensions
+#define jpeg_save_markers jSaveMarkers
+#define jpeg_set_marker_processor jSetMarker
+#define jpeg_read_coefficients jReadCoefs
+#define jpeg_write_coefficients jWrtCoefs
+#define jpeg_copy_critical_parameters jCopyCrit
+#define jpeg_abort_compress jAbrtCompress
+#define jpeg_abort_decompress jAbrtDecompress
+#define jpeg_abort jAbort
+#define jpeg_destroy jDestroy
+#define jpeg_resync_to_restart jResyncRestart
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Default error-management setup */
+EXTERN(struct jpeg_error_mgr *) jpeg_std_error
+ JPP((struct jpeg_error_mgr * err));
+
+/* Initialization of JPEG compression objects.
+ * jpeg_create_compress() and jpeg_create_decompress() are the exported
+ * names that applications should call. These expand to calls on
+ * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
+ * passed for version mismatch checking.
+ * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
+ */
+#define jpeg_create_compress(cinfo) \
+ jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
+ (size_t) sizeof(struct jpeg_compress_struct))
+#define jpeg_create_decompress(cinfo) \
+ jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
+ (size_t) sizeof(struct jpeg_decompress_struct))
+EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo,
+ int version, size_t structsize));
+EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo,
+ int version, size_t structsize));
+/* Destruction of JPEG compression objects */
+EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
+EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile));
+
+/* Default parameter setup for compression */
+EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo));
+/* Compression parameter setup aids */
+EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+ J_COLOR_SPACE colorspace));
+EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+ boolean force_baseline));
+EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+ int scale_factor,
+ boolean force_baseline));
+EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
+ const unsigned int *basic_table,
+ int scale_factor,
+ boolean force_baseline));
+EXTERN(int) jpeg_quality_scaling JPP((int quality));
+EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo,
+ boolean suppress));
+EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
+EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
+
+/* Main entry points for compression */
+EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo,
+ boolean write_all_tables));
+EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo,
+ JSAMPARRAY scanlines,
+ JDIMENSION num_lines));
+EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo));
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo,
+ JSAMPIMAGE data,
+ JDIMENSION num_lines));
+
+/* Write a special marker. See libjpeg.doc concerning safe usage. */
+EXTERN(void) jpeg_write_marker
+ JPP((j_compress_ptr cinfo, int marker,
+ const JOCTET * dataptr, unsigned int datalen));
+/* Same, but piecemeal. */
+EXTERN(void) jpeg_write_m_header
+ JPP((j_compress_ptr cinfo, int marker, unsigned int datalen));
+EXTERN(void) jpeg_write_m_byte
+ JPP((j_compress_ptr cinfo, int val));
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo));
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo,
+ boolean require_image));
+/* Return value is one of: */
+#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK 1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo));
+EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
+ JSAMPARRAY scanlines,
+ JDIMENSION max_lines));
+EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
+ JSAMPIMAGE data,
+ JDIMENSION max_lines));
+
+/* Additional entry points for buffered-image mode. */
+EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo,
+ int scan_number));
+EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo));
+EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo));
+EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo));
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */
+#define JPEG_REACHED_SOS 1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI 2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
+
+/* Control saving of COM and APPn markers into marker_list. */
+EXTERN(void) jpeg_save_markers
+ JPP((j_decompress_ptr cinfo, int marker_code,
+ unsigned int length_limit));
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN(void) jpeg_set_marker_processor
+ JPP((j_decompress_ptr cinfo, int marker_code,
+ jpeg_marker_parser_method routine));
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
+EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo,
+ jvirt_barray_ptr * coef_arrays));
+EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
+ j_compress_ptr dstinfo));
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc. You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo));
+EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object. These may be more convenient in some places.
+ */
+EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo));
+EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo));
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
+ int desired));
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0 0xD0 /* RST0 marker code */
+#define JPEG_EOI 0xD9 /* EOI marker code */
+#define JPEG_APP0 0xE0 /* APP0 marker code */
+#define JPEG_COM 0xFE /* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "jpegint.h" /* fetch private declarations */
+#include "jerror.h" /* fetch error codes too */
+#endif
+
+#endif /* JPEGLIB_H */
--- /dev/null
+/*
+ * jquant1.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains 1-pass color quantization (color mapping) routines.
+ * These routines provide mapping to a fixed color map using equally spaced
+ * color values. Optional Floyd-Steinberg or ordered dithering is available.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_1PASS_SUPPORTED
+
+
+/*
+ * The main purpose of 1-pass quantization is to provide a fast, if not very
+ * high quality, colormapped output capability. A 2-pass quantizer usually
+ * gives better visual quality; however, for quantized grayscale output this
+ * quantizer is perfectly adequate. Dithering is highly recommended with this
+ * quantizer, though you can turn it off if you really want to.
+ *
+ * In 1-pass quantization the colormap must be chosen in advance of seeing the
+ * image. We use a map consisting of all combinations of Ncolors[i] color
+ * values for the i'th component. The Ncolors[] values are chosen so that
+ * their product, the total number of colors, is no more than that requested.
+ * (In most cases, the product will be somewhat less.)
+ *
+ * Since the colormap is orthogonal, the representative value for each color
+ * component can be determined without considering the other components;
+ * then these indexes can be combined into a colormap index by a standard
+ * N-dimensional-array-subscript calculation. Most of the arithmetic involved
+ * can be precalculated and stored in the lookup table colorindex[].
+ * colorindex[i][j] maps pixel value j in component i to the nearest
+ * representative value (grid plane) for that component; this index is
+ * multiplied by the array stride for component i, so that the
+ * index of the colormap entry closest to a given pixel value is just
+ * sum( colorindex[component-number][pixel-component-value] )
+ * Aside from being fast, this scheme allows for variable spacing between
+ * representative values with no additional lookup cost.
+ *
+ * If gamma correction has been applied in color conversion, it might be wise
+ * to adjust the color grid spacing so that the representative colors are
+ * equidistant in linear space. At this writing, gamma correction is not
+ * implemented by jdcolor, so nothing is done here.
+ */
+
+
+/* Declarations for ordered dithering.
+ *
+ * We use a standard 16x16 ordered dither array. The basic concept of ordered
+ * dithering is described in many references, for instance Dale Schumacher's
+ * chapter II.2 of Graphics Gems II (James Arvo, ed. Academic Press, 1991).
+ * In place of Schumacher's comparisons against a "threshold" value, we add a
+ * "dither" value to the input pixel and then round the result to the nearest
+ * output value. The dither value is equivalent to (0.5 - threshold) times
+ * the distance between output values. For ordered dithering, we assume that
+ * the output colors are equally spaced; if not, results will probably be
+ * worse, since the dither may be too much or too little at a given point.
+ *
+ * The normal calculation would be to form pixel value + dither, range-limit
+ * this to 0..MAXJSAMPLE, and then index into the colorindex table as usual.
+ * We can skip the separate range-limiting step by extending the colorindex
+ * table in both directions.
+ */
+
+#define ODITHER_SIZE 16 /* dimension of dither matrix */
+/* NB: if ODITHER_SIZE is not a power of 2, ODITHER_MASK uses will break */
+#define ODITHER_CELLS (ODITHER_SIZE*ODITHER_SIZE) /* # cells in matrix */
+#define ODITHER_MASK (ODITHER_SIZE-1) /* mask for wrapping around counters */
+
+typedef int ODITHER_MATRIX[ODITHER_SIZE][ODITHER_SIZE];
+typedef int (*ODITHER_MATRIX_PTR)[ODITHER_SIZE];
+
+static const UINT8 base_dither_matrix[ODITHER_SIZE][ODITHER_SIZE] = {
+ /* Bayer's order-4 dither array. Generated by the code given in
+ * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
+ * The values in this array must range from 0 to ODITHER_CELLS-1.
+ */
+ { 0,192, 48,240, 12,204, 60,252, 3,195, 51,243, 15,207, 63,255 },
+ { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
+ { 32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
+ { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
+ { 8,200, 56,248, 4,196, 52,244, 11,203, 59,251, 7,199, 55,247 },
+ { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
+ { 40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
+ { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
+ { 2,194, 50,242, 14,206, 62,254, 1,193, 49,241, 13,205, 61,253 },
+ { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
+ { 34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
+ { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
+ { 10,202, 58,250, 6,198, 54,246, 9,201, 57,249, 5,197, 53,245 },
+ { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
+ { 42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
+ { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
+};
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count. The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ * ... (here) 7/16
+ * 3/16 5/16 1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed. We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column. (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array is indexed [component#][position].
+ * We provide (#columns + 2) entries per component; the extra entry at each
+ * end saves us from special-casing the first and last pixels.
+ *
+ * Note: on a wide image, we might not have enough room in a PC's near data
+ * segment to hold the error array; so it is allocated with alloc_large.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR; /* 16 bits should be enough */
+typedef int LOCFSERROR; /* use 'int' for calculation temps */
+#else
+typedef INT32 FSERROR; /* may need more than 16 bits */
+typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+
+
+/* Private subobject */
+
+#define MAX_Q_COMPS 4 /* max components I can handle */
+
+typedef struct {
+ struct jpeg_color_quantizer pub; /* public fields */
+
+ /* Initially allocated colormap is saved here */
+ JSAMPARRAY sv_colormap; /* The color map as a 2-D pixel array */
+ int sv_actual; /* number of entries in use */
+
+ JSAMPARRAY colorindex; /* Precomputed mapping for speed */
+ /* colorindex[i][j] = index of color closest to pixel value j in component i,
+ * premultiplied as described above. Since colormap indexes must fit into
+ * JSAMPLEs, the entries of this array will too.
+ */
+ boolean is_padded; /* is the colorindex padded for odither? */
+
+ int Ncolors[MAX_Q_COMPS]; /* # of values alloced to each component */
+
+ /* Variables for ordered dithering */
+ int row_index; /* cur row's vertical index in dither matrix */
+ ODITHER_MATRIX_PTR odither[MAX_Q_COMPS]; /* one dither array per component */
+
+ /* Variables for Floyd-Steinberg dithering */
+ FSERRPTR fserrors[MAX_Q_COMPS]; /* accumulated errors */
+ boolean on_odd_row; /* flag to remember which row we are on */
+} my_cquantizer;
+
+typedef my_cquantizer * my_cquantize_ptr;
+
+
+/*
+ * Policy-making subroutines for create_colormap and create_colorindex.
+ * These routines determine the colormap to be used. The rest of the module
+ * only assumes that the colormap is orthogonal.
+ *
+ * * select_ncolors decides how to divvy up the available colors
+ * among the components.
+ * * output_value defines the set of representative values for a component.
+ * * largest_input_value defines the mapping from input values to
+ * representative values for a component.
+ * Note that the latter two routines may impose different policies for
+ * different components, though this is not currently done.
+ */
+
+
+LOCAL(int)
+select_ncolors (j_decompress_ptr cinfo, int Ncolors[])
+/* Determine allocation of desired colors to components, */
+/* and fill in Ncolors[] array to indicate choice. */
+/* Return value is total number of colors (product of Ncolors[] values). */
+{
+ int nc = cinfo->out_color_components; /* number of color components */
+ int max_colors = cinfo->desired_number_of_colors;
+ int total_colors, iroot, i, j;
+ boolean changed;
+ long temp;
+ static const int RGB_order[3] = { RGB_GREEN, RGB_RED, RGB_BLUE };
+
+ /* We can allocate at least the nc'th root of max_colors per component. */
+ /* Compute floor(nc'th root of max_colors). */
+ iroot = 1;
+ do {
+ iroot++;
+ temp = iroot; /* set temp = iroot ** nc */
+ for (i = 1; i < nc; i++)
+ temp *= iroot;
+ } while (temp <= (long) max_colors); /* repeat till iroot exceeds root */
+ iroot--; /* now iroot = floor(root) */
+
+ /* Must have at least 2 color values per component */
+ if (iroot < 2)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, (int) temp);
+
+ /* Initialize to iroot color values for each component */
+ total_colors = 1;
+ for (i = 0; i < nc; i++) {
+ Ncolors[i] = iroot;
+ total_colors *= iroot;
+ }
+ /* We may be able to increment the count for one or more components without
+ * exceeding max_colors, though we know not all can be incremented.
+ * Sometimes, the first component can be incremented more than once!
+ * (Example: for 16 colors, we start at 2*2*2, go to 3*2*2, then 4*2*2.)
+ * In RGB colorspace, try to increment G first, then R, then B.
+ */
+ do {
+ changed = FALSE;
+ for (i = 0; i < nc; i++) {
+ j = (cinfo->out_color_space == JCS_RGB ? RGB_order[i] : i);
+ /* calculate new total_colors if Ncolors[j] is incremented */
+ temp = total_colors / Ncolors[j];
+ temp *= Ncolors[j]+1; /* done in long arith to avoid oflo */
+ if (temp > (long) max_colors)
+ break; /* won't fit, done with this pass */
+ Ncolors[j]++; /* OK, apply the increment */
+ total_colors = (int) temp;
+ changed = TRUE;
+ }
+ } while (changed);
+
+ return total_colors;
+}
+
+
+LOCAL(int)
+output_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return j'th output value, where j will range from 0 to maxj */
+/* The output values must fall in 0..MAXJSAMPLE in increasing order */
+{
+ /* We always provide values 0 and MAXJSAMPLE for each component;
+ * any additional values are equally spaced between these limits.
+ * (Forcing the upper and lower values to the limits ensures that
+ * dithering can't produce a color outside the selected gamut.)
+ */
+ return (int) (((INT32) j * MAXJSAMPLE + maxj/2) / maxj);
+}
+
+
+LOCAL(int)
+largest_input_value (j_decompress_ptr cinfo, int ci, int j, int maxj)
+/* Return largest input value that should map to j'th output value */
+/* Must have largest(j=0) >= 0, and largest(j=maxj) >= MAXJSAMPLE */
+{
+ /* Breakpoints are halfway between values returned by output_value */
+ return (int) (((INT32) (2*j + 1) * MAXJSAMPLE + maxj) / (2*maxj));
+}
+
+
+/*
+ * Create the colormap.
+ */
+
+LOCAL(void)
+create_colormap (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPARRAY colormap; /* Created colormap */
+ int total_colors; /* Number of distinct output colors */
+ int i,j,k, nci, blksize, blkdist, ptr, val;
+
+ /* Select number of colors for each component */
+ total_colors = select_ncolors(cinfo, cquantize->Ncolors);
+
+ /* Report selected color counts */
+ if (cinfo->out_color_components == 3)
+ TRACEMS4(cinfo, 1, JTRC_QUANT_3_NCOLORS,
+ total_colors, cquantize->Ncolors[0],
+ cquantize->Ncolors[1], cquantize->Ncolors[2]);
+ else
+ TRACEMS1(cinfo, 1, JTRC_QUANT_NCOLORS, total_colors);
+
+ /* Allocate and fill in the colormap. */
+ /* The colors are ordered in the map in standard row-major order, */
+ /* i.e. rightmost (highest-indexed) color changes most rapidly. */
+
+ colormap = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) total_colors, (JDIMENSION) cinfo->out_color_components);
+
+ /* blksize is number of adjacent repeated entries for a component */
+ /* blkdist is distance between groups of identical entries for a component */
+ blkdist = total_colors;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ /* fill in colormap entries for i'th color component */
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ blksize = blkdist / nci;
+ for (j = 0; j < nci; j++) {
+ /* Compute j'th output value (out of nci) for component */
+ val = output_value(cinfo, i, j, nci-1);
+ /* Fill in all colormap entries that have this value of this component */
+ for (ptr = j * blksize; ptr < total_colors; ptr += blkdist) {
+ /* fill in blksize entries beginning at ptr */
+ for (k = 0; k < blksize; k++)
+ colormap[i][ptr+k] = (JSAMPLE) val;
+ }
+ }
+ blkdist = blksize; /* blksize of this color is blkdist of next */
+ }
+
+ /* Save the colormap in private storage,
+ * where it will survive color quantization mode changes.
+ */
+ cquantize->sv_colormap = colormap;
+ cquantize->sv_actual = total_colors;
+}
+
+
+/*
+ * Create the color index table.
+ */
+
+LOCAL(void)
+create_colorindex (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPROW indexptr;
+ int i,j,k, nci, blksize, val, pad;
+
+ /* For ordered dither, we pad the color index tables by MAXJSAMPLE in
+ * each direction (input index values can be -MAXJSAMPLE .. 2*MAXJSAMPLE).
+ * This is not necessary in the other dithering modes. However, we
+ * flag whether it was done in case user changes dithering mode.
+ */
+ if (cinfo->dither_mode == JDITHER_ORDERED) {
+ pad = MAXJSAMPLE*2;
+ cquantize->is_padded = TRUE;
+ } else {
+ pad = 0;
+ cquantize->is_padded = FALSE;
+ }
+
+ cquantize->colorindex = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (JDIMENSION) (MAXJSAMPLE+1 + pad),
+ (JDIMENSION) cinfo->out_color_components);
+
+ /* blksize is number of adjacent repeated entries for a component */
+ blksize = cquantize->sv_actual;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ /* fill in colorindex entries for i'th color component */
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ blksize = blksize / nci;
+
+ /* adjust colorindex pointers to provide padding at negative indexes. */
+ if (pad)
+ cquantize->colorindex[i] += MAXJSAMPLE;
+
+ /* in loop, val = index of current output value, */
+ /* and k = largest j that maps to current val */
+ indexptr = cquantize->colorindex[i];
+ val = 0;
+ k = largest_input_value(cinfo, i, 0, nci-1);
+ for (j = 0; j <= MAXJSAMPLE; j++) {
+ while (j > k) /* advance val if past boundary */
+ k = largest_input_value(cinfo, i, ++val, nci-1);
+ /* premultiply so that no multiplication needed in main processing */
+ indexptr[j] = (JSAMPLE) (val * blksize);
+ }
+ /* Pad at both ends if necessary */
+ if (pad)
+ for (j = 1; j <= MAXJSAMPLE; j++) {
+ indexptr[-j] = indexptr[0];
+ indexptr[MAXJSAMPLE+j] = indexptr[MAXJSAMPLE];
+ }
+ }
+}
+
+
+/*
+ * Create an ordered-dither array for a component having ncolors
+ * distinct output values.
+ */
+
+LOCAL(ODITHER_MATRIX_PTR)
+make_odither_array (j_decompress_ptr cinfo, int ncolors)
+{
+ ODITHER_MATRIX_PTR odither;
+ int j,k;
+ INT32 num,den;
+
+ odither = (ODITHER_MATRIX_PTR)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(ODITHER_MATRIX));
+ /* The inter-value distance for this color is MAXJSAMPLE/(ncolors-1).
+ * Hence the dither value for the matrix cell with fill order f
+ * (f=0..N-1) should be (N-1-2*f)/(2*N) * MAXJSAMPLE/(ncolors-1).
+ * On 16-bit-int machine, be careful to avoid overflow.
+ */
+ den = 2 * ODITHER_CELLS * ((INT32) (ncolors - 1));
+ for (j = 0; j < ODITHER_SIZE; j++) {
+ for (k = 0; k < ODITHER_SIZE; k++) {
+ num = ((INT32) (ODITHER_CELLS-1 - 2*((int)base_dither_matrix[j][k])))
+ * MAXJSAMPLE;
+ /* Ensure round towards zero despite C's lack of consistency
+ * about rounding negative values in integer division...
+ */
+ odither[j][k] = (int) (num<0 ? -((-num)/den) : num/den);
+ }
+ }
+ return odither;
+}
+
+
+/*
+ * Create the ordered-dither tables.
+ * Components having the same number of representative colors may
+ * share a dither table.
+ */
+
+LOCAL(void)
+create_odither_tables (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ ODITHER_MATRIX_PTR odither;
+ int i, j, nci;
+
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ nci = cquantize->Ncolors[i]; /* # of distinct values for this color */
+ odither = NULL; /* search for matching prior component */
+ for (j = 0; j < i; j++) {
+ if (nci == cquantize->Ncolors[j]) {
+ odither = cquantize->odither[j];
+ break;
+ }
+ }
+ if (odither == NULL) /* need a new table? */
+ odither = make_odither_array(cinfo, nci);
+ cquantize->odither[i] = odither;
+ }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+color_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ JSAMPARRAY colorindex = cquantize->colorindex;
+ register int pixcode, ci;
+ register JSAMPROW ptrin, ptrout;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ register int nc = cinfo->out_color_components;
+
+ for (row = 0; row < num_rows; row++) {
+ ptrin = input_buf[row];
+ ptrout = output_buf[row];
+ for (col = width; col > 0; col--) {
+ pixcode = 0;
+ for (ci = 0; ci < nc; ci++) {
+ pixcode += GETJSAMPLE(colorindex[ci][GETJSAMPLE(*ptrin++)]);
+ }
+ *ptrout++ = (JSAMPLE) pixcode;
+ }
+ }
+}
+
+
+METHODDEF(void)
+color_quantize3 (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register int pixcode;
+ register JSAMPROW ptrin, ptrout;
+ JSAMPROW colorindex0 = cquantize->colorindex[0];
+ JSAMPROW colorindex1 = cquantize->colorindex[1];
+ JSAMPROW colorindex2 = cquantize->colorindex[2];
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ ptrin = input_buf[row];
+ ptrout = output_buf[row];
+ for (col = width; col > 0; col--) {
+ pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*ptrin++)]);
+ pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*ptrin++)]);
+ pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*ptrin++)]);
+ *ptrout++ = (JSAMPLE) pixcode;
+ }
+ }
+}
+
+
+METHODDEF(void)
+quantize_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, with ordered dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex_ci;
+ int * dither; /* points to active row of dither matrix */
+ int row_index, col_index; /* current indexes into dither matrix */
+ int nc = cinfo->out_color_components;
+ int ci;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ /* Initialize output values to 0 so can process components separately */
+ jzero_far((void FAR *) output_buf[row],
+ (size_t) (width * SIZEOF(JSAMPLE)));
+ row_index = cquantize->row_index;
+ for (ci = 0; ci < nc; ci++) {
+ input_ptr = input_buf[row] + ci;
+ output_ptr = output_buf[row];
+ colorindex_ci = cquantize->colorindex[ci];
+ dither = cquantize->odither[ci][row_index];
+ col_index = 0;
+
+ for (col = width; col > 0; col--) {
+ /* Form pixel value + dither, range-limit to 0..MAXJSAMPLE,
+ * select output value, accumulate into output code for this pixel.
+ * Range-limiting need not be done explicitly, as we have extended
+ * the colorindex table to produce the right answers for out-of-range
+ * inputs. The maximum dither is +- MAXJSAMPLE; this sets the
+ * required amount of padding.
+ */
+ *output_ptr += colorindex_ci[GETJSAMPLE(*input_ptr)+dither[col_index]];
+ input_ptr += nc;
+ output_ptr++;
+ col_index = (col_index + 1) & ODITHER_MASK;
+ }
+ }
+ /* Advance row index for next row */
+ row_index = (row_index + 1) & ODITHER_MASK;
+ cquantize->row_index = row_index;
+ }
+}
+
+
+METHODDEF(void)
+quantize3_ord_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* Fast path for out_color_components==3, with ordered dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register int pixcode;
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex0 = cquantize->colorindex[0];
+ JSAMPROW colorindex1 = cquantize->colorindex[1];
+ JSAMPROW colorindex2 = cquantize->colorindex[2];
+ int * dither0; /* points to active row of dither matrix */
+ int * dither1;
+ int * dither2;
+ int row_index, col_index; /* current indexes into dither matrix */
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ row_index = cquantize->row_index;
+ input_ptr = input_buf[row];
+ output_ptr = output_buf[row];
+ dither0 = cquantize->odither[0][row_index];
+ dither1 = cquantize->odither[1][row_index];
+ dither2 = cquantize->odither[2][row_index];
+ col_index = 0;
+
+ for (col = width; col > 0; col--) {
+ pixcode = GETJSAMPLE(colorindex0[GETJSAMPLE(*input_ptr++) +
+ dither0[col_index]]);
+ pixcode += GETJSAMPLE(colorindex1[GETJSAMPLE(*input_ptr++) +
+ dither1[col_index]]);
+ pixcode += GETJSAMPLE(colorindex2[GETJSAMPLE(*input_ptr++) +
+ dither2[col_index]]);
+ *output_ptr++ = (JSAMPLE) pixcode;
+ col_index = (col_index + 1) & ODITHER_MASK;
+ }
+ row_index = (row_index + 1) & ODITHER_MASK;
+ cquantize->row_index = row_index;
+ }
+}
+
+
+METHODDEF(void)
+quantize_fs_dither (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+/* General case, with Floyd-Steinberg dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register LOCFSERROR cur; /* current error or pixel value */
+ LOCFSERROR belowerr; /* error for pixel below cur */
+ LOCFSERROR bpreverr; /* error for below/prev col */
+ LOCFSERROR bnexterr; /* error for below/next col */
+ LOCFSERROR delta;
+ register FSERRPTR errorptr; /* => fserrors[] at column before current */
+ register JSAMPROW input_ptr;
+ register JSAMPROW output_ptr;
+ JSAMPROW colorindex_ci;
+ JSAMPROW colormap_ci;
+ int pixcode;
+ int nc = cinfo->out_color_components;
+ int dir; /* 1 for left-to-right, -1 for right-to-left */
+ int dirnc; /* dir * nc */
+ int ci;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ JSAMPLE *range_limit = cinfo->sample_range_limit;
+ SHIFT_TEMPS
+
+ for (row = 0; row < num_rows; row++) {
+ /* Initialize output values to 0 so can process components separately */
+ jzero_far((void FAR *) output_buf[row],
+ (size_t) (width * SIZEOF(JSAMPLE)));
+ for (ci = 0; ci < nc; ci++) {
+ input_ptr = input_buf[row] + ci;
+ output_ptr = output_buf[row];
+ if (cquantize->on_odd_row) {
+ /* work right to left in this row */
+ input_ptr += (width-1) * nc; /* so point to rightmost pixel */
+ output_ptr += width-1;
+ dir = -1;
+ dirnc = -nc;
+ errorptr = cquantize->fserrors[ci] + (width+1); /* => entry after last column */
+ } else {
+ /* work left to right in this row */
+ dir = 1;
+ dirnc = nc;
+ errorptr = cquantize->fserrors[ci]; /* => entry before first column */
+ }
+ colorindex_ci = cquantize->colorindex[ci];
+ colormap_ci = cquantize->sv_colormap[ci];
+ /* Preset error values: no error propagated to first pixel from left */
+ cur = 0;
+ /* and no error propagated to row below yet */
+ belowerr = bpreverr = 0;
+
+ for (col = width; col > 0; col--) {
+ /* cur holds the error propagated from the previous pixel on the
+ * current line. Add the error propagated from the previous line
+ * to form the complete error correction term for this pixel, and
+ * round the error term (which is expressed * 16) to an integer.
+ * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+ * for either sign of the error value.
+ * Note: errorptr points to *previous* column's array entry.
+ */
+ cur = RIGHT_SHIFT(cur + errorptr[dir] + 8, 4);
+ /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+ * The maximum error is +- MAXJSAMPLE; this sets the required size
+ * of the range_limit array.
+ */
+ cur += GETJSAMPLE(*input_ptr);
+ cur = GETJSAMPLE(range_limit[cur]);
+ /* Select output value, accumulate into output code for this pixel */
+ pixcode = GETJSAMPLE(colorindex_ci[cur]);
+ *output_ptr += (JSAMPLE) pixcode;
+ /* Compute actual representation error at this pixel */
+ /* Note: we can do this even though we don't have the final */
+ /* pixel code, because the colormap is orthogonal. */
+ cur -= GETJSAMPLE(colormap_ci[pixcode]);
+ /* Compute error fractions to be propagated to adjacent pixels.
+ * Add these into the running sums, and simultaneously shift the
+ * next-line error sums left by 1 column.
+ */
+ bnexterr = cur;
+ delta = cur * 2;
+ cur += delta; /* form error * 3 */
+ errorptr[0] = (FSERROR) (bpreverr + cur);
+ cur += delta; /* form error * 5 */
+ bpreverr = belowerr + cur;
+ belowerr = bnexterr;
+ cur += delta; /* form error * 7 */
+ /* At this point cur contains the 7/16 error value to be propagated
+ * to the next pixel on the current line, and all the errors for the
+ * next line have been shifted over. We are therefore ready to move on.
+ */
+ input_ptr += dirnc; /* advance input ptr to next column */
+ output_ptr += dir; /* advance output ptr to next column */
+ errorptr += dir; /* advance errorptr to current column */
+ }
+ /* Post-loop cleanup: we must unload the final error value into the
+ * final fserrors[] entry. Note we need not unload belowerr because
+ * it is for the dummy column before or after the actual array.
+ */
+ errorptr[0] = (FSERROR) bpreverr; /* unload prev err into array */
+ }
+ cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE);
+ }
+}
+
+
+/*
+ * Allocate workspace for Floyd-Steinberg errors.
+ */
+
+LOCAL(void)
+alloc_fs_workspace (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ size_t arraysize;
+ int i;
+
+ arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+ for (i = 0; i < cinfo->out_color_components; i++) {
+ cquantize->fserrors[i] = (FSERRPTR)
+ (*cinfo->mem->alloc_large)((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+ }
+}
+
+
+/*
+ * Initialize for one-pass color quantization.
+ */
+
+METHODDEF(void)
+start_pass_1_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ size_t arraysize;
+ int i;
+
+ /* Install my colormap. */
+ cinfo->colormap = cquantize->sv_colormap;
+ cinfo->actual_number_of_colors = cquantize->sv_actual;
+
+ /* Initialize for desired dithering mode. */
+ switch (cinfo->dither_mode) {
+ case JDITHER_NONE:
+ if (cinfo->out_color_components == 3)
+ cquantize->pub.color_quantize = color_quantize3;
+ else
+ cquantize->pub.color_quantize = color_quantize;
+ break;
+ case JDITHER_ORDERED:
+ if (cinfo->out_color_components == 3)
+ cquantize->pub.color_quantize = quantize3_ord_dither;
+ else
+ cquantize->pub.color_quantize = quantize_ord_dither;
+ cquantize->row_index = 0; /* initialize state for ordered dither */
+ /* If user changed to ordered dither from another mode,
+ * we must recreate the color index table with padding.
+ * This will cost extra space, but probably isn't very likely.
+ */
+ if (! cquantize->is_padded)
+ create_colorindex(cinfo);
+ /* Create ordered-dither tables if we didn't already. */
+ if (cquantize->odither[0] == NULL)
+ create_odither_tables(cinfo);
+ break;
+ case JDITHER_FS:
+ cquantize->pub.color_quantize = quantize_fs_dither;
+ cquantize->on_odd_row = FALSE; /* initialize state for F-S dither */
+ /* Allocate Floyd-Steinberg workspace if didn't already. */
+ if (cquantize->fserrors[0] == NULL)
+ alloc_fs_workspace(cinfo);
+ /* Initialize the propagated errors to zero. */
+ arraysize = (size_t) ((cinfo->output_width + 2) * SIZEOF(FSERROR));
+ for (i = 0; i < cinfo->out_color_components; i++)
+ jzero_far((void FAR *) cquantize->fserrors[i], arraysize);
+ break;
+ default:
+ ERREXIT(cinfo, JERR_NOT_COMPILED);
+ break;
+ }
+}
+
+
+/*
+ * Finish up at the end of the pass.
+ */
+
+METHODDEF(void)
+finish_pass_1_quant (j_decompress_ptr cinfo)
+{
+ /* no work in 1-pass case */
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ * Shouldn't get to this module!
+ */
+
+METHODDEF(void)
+new_color_map_1_quant (j_decompress_ptr cinfo)
+{
+ ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+
+/*
+ * Module initialization routine for 1-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_1pass_quantizer (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize;
+
+ cquantize = (my_cquantize_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_cquantizer));
+ cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
+ cquantize->pub.start_pass = start_pass_1_quant;
+ cquantize->pub.finish_pass = finish_pass_1_quant;
+ cquantize->pub.new_color_map = new_color_map_1_quant;
+ cquantize->fserrors[0] = NULL; /* Flag FS workspace not allocated */
+ cquantize->odither[0] = NULL; /* Also flag odither arrays not allocated */
+
+ /* Make sure my internal arrays won't overflow */
+ if (cinfo->out_color_components > MAX_Q_COMPS)
+ ERREXIT1(cinfo, JERR_QUANT_COMPONENTS, MAX_Q_COMPS);
+ /* Make sure colormap indexes can be represented by JSAMPLEs */
+ if (cinfo->desired_number_of_colors > (MAXJSAMPLE+1))
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXJSAMPLE+1);
+
+ /* Create the colormap and color index table. */
+ create_colormap(cinfo);
+ create_colorindex(cinfo);
+
+ /* Allocate Floyd-Steinberg workspace now if requested.
+ * We do this now since it is FAR storage and may affect the memory
+ * manager's space calculations. If the user changes to FS dither
+ * mode in a later pass, we will allocate the space then, and will
+ * possibly overrun the max_memory_to_use setting.
+ */
+ if (cinfo->dither_mode == JDITHER_FS)
+ alloc_fs_workspace(cinfo);
+}
+
+#endif /* QUANT_1PASS_SUPPORTED */
--- /dev/null
+/*
+ * jquant2.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains 2-pass color quantization (color mapping) routines.
+ * These routines provide selection of a custom color map for an image,
+ * followed by mapping of the image to that color map, with optional
+ * Floyd-Steinberg dithering.
+ * It is also possible to use just the second pass to map to an arbitrary
+ * externally-given color map.
+ *
+ * Note: ordered dithering is not supported, since there isn't any fast
+ * way to compute intercolor distances; it's unclear that ordered dither's
+ * fundamental assumptions even hold with an irregularly spaced color map.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+
+/*
+ * This module implements the well-known Heckbert paradigm for color
+ * quantization. Most of the ideas used here can be traced back to
+ * Heckbert's seminal paper
+ * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display",
+ * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.
+ *
+ * In the first pass over the image, we accumulate a histogram showing the
+ * usage count of each possible color. To keep the histogram to a reasonable
+ * size, we reduce the precision of the input; typical practice is to retain
+ * 5 or 6 bits per color, so that 8 or 4 different input values are counted
+ * in the same histogram cell.
+ *
+ * Next, the color-selection step begins with a box representing the whole
+ * color space, and repeatedly splits the "largest" remaining box until we
+ * have as many boxes as desired colors. Then the mean color in each
+ * remaining box becomes one of the possible output colors.
+ *
+ * The second pass over the image maps each input pixel to the closest output
+ * color (optionally after applying a Floyd-Steinberg dithering correction).
+ * This mapping is logically trivial, but making it go fast enough requires
+ * considerable care.
+ *
+ * Heckbert-style quantizers vary a good deal in their policies for choosing
+ * the "largest" box and deciding where to cut it. The particular policies
+ * used here have proved out well in experimental comparisons, but better ones
+ * may yet be found.
+ *
+ * In earlier versions of the IJG code, this module quantized in YCbCr color
+ * space, processing the raw upsampled data without a color conversion step.
+ * This allowed the color conversion math to be done only once per colormap
+ * entry, not once per pixel. However, that optimization precluded other
+ * useful optimizations (such as merging color conversion with upsampling)
+ * and it also interfered with desired capabilities such as quantizing to an
+ * externally-supplied colormap. We have therefore abandoned that approach.
+ * The present code works in the post-conversion color space, typically RGB.
+ *
+ * To improve the visual quality of the results, we actually work in scaled
+ * RGB space, giving G distances more weight than R, and R in turn more than
+ * B. To do everything in integer math, we must use integer scale factors.
+ * The 2/3/1 scale factors used here correspond loosely to the relative
+ * weights of the colors in the NTSC grayscale equation.
+ * If you want to use this code to quantize a non-RGB color space, you'll
+ * probably need to change these scale factors.
+ */
+
+#define R_SCALE 2 /* scale R distances by this much */
+#define G_SCALE 3 /* scale G distances by this much */
+#define B_SCALE 1 /* and B by this much */
+
+/* Relabel R/G/B as components 0/1/2, respecting the RGB ordering defined
+ * in jmorecfg.h. As the code stands, it will do the right thing for R,G,B
+ * and B,G,R orders. If you define some other weird order in jmorecfg.h,
+ * you'll get compile errors until you extend this logic. In that case
+ * you'll probably want to tweak the histogram sizes too.
+ */
+
+#if RGB_RED == 0
+#define C0_SCALE R_SCALE
+#endif
+#if RGB_BLUE == 0
+#define C0_SCALE B_SCALE
+#endif
+#if RGB_GREEN == 1
+#define C1_SCALE G_SCALE
+#endif
+#if RGB_RED == 2
+#define C2_SCALE R_SCALE
+#endif
+#if RGB_BLUE == 2
+#define C2_SCALE B_SCALE
+#endif
+
+
+/*
+ * First we have the histogram data structure and routines for creating it.
+ *
+ * The number of bits of precision can be adjusted by changing these symbols.
+ * We recommend keeping 6 bits for G and 5 each for R and B.
+ * If you have plenty of memory and cycles, 6 bits all around gives marginally
+ * better results; if you are short of memory, 5 bits all around will save
+ * some space but degrade the results.
+ * To maintain a fully accurate histogram, we'd need to allocate a "long"
+ * (preferably unsigned long) for each cell. In practice this is overkill;
+ * we can get by with 16 bits per cell. Few of the cell counts will overflow,
+ * and clamping those that do overflow to the maximum value will give close-
+ * enough results. This reduces the recommended histogram size from 256Kb
+ * to 128Kb, which is a useful savings on PC-class machines.
+ * (In the second pass the histogram space is re-used for pixel mapping data;
+ * in that capacity, each cell must be able to store zero to the number of
+ * desired colors. 16 bits/cell is plenty for that too.)
+ * Since the JPEG code is intended to run in small memory model on 80x86
+ * machines, we can't just allocate the histogram in one chunk. Instead
+ * of a true 3-D array, we use a row of pointers to 2-D arrays. Each
+ * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and
+ * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that
+ * on 80x86 machines, the pointer row is in near memory but the actual
+ * arrays are in far memory (same arrangement as we use for image arrays).
+ */
+
+#define MAXNUMCOLORS (MAXJSAMPLE+1) /* maximum size of colormap */
+
+/* These will do the right thing for either R,G,B or B,G,R color order,
+ * but you may not like the results for other color orders.
+ */
+#define HIST_C0_BITS 5 /* bits of precision in R/B histogram */
+#define HIST_C1_BITS 6 /* bits of precision in G histogram */
+#define HIST_C2_BITS 5 /* bits of precision in B/R histogram */
+
+/* Number of elements along histogram axes. */
+#define HIST_C0_ELEMS (1<<HIST_C0_BITS)
+#define HIST_C1_ELEMS (1<<HIST_C1_BITS)
+#define HIST_C2_ELEMS (1<<HIST_C2_BITS)
+
+/* These are the amounts to shift an input value to get a histogram index. */
+#define C0_SHIFT (BITS_IN_JSAMPLE-HIST_C0_BITS)
+#define C1_SHIFT (BITS_IN_JSAMPLE-HIST_C1_BITS)
+#define C2_SHIFT (BITS_IN_JSAMPLE-HIST_C2_BITS)
+
+
+typedef UINT16 histcell; /* histogram cell; prefer an unsigned type */
+
+typedef histcell FAR * histptr; /* for pointers to histogram cells */
+
+typedef histcell hist1d[HIST_C2_ELEMS]; /* typedefs for the array */
+typedef hist1d FAR * hist2d; /* type for the 2nd-level pointers */
+typedef hist2d * hist3d; /* type for top-level pointer */
+
+
+/* Declarations for Floyd-Steinberg dithering.
+ *
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count. The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ * ... (here) 7/16
+ * 3/16 5/16 1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed. We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column. (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array has (#columns + 2) entries; the extra entry at
+ * each end saves us from special-casing the first and last pixels.
+ * Each entry is three values long, one value for each color component.
+ *
+ * Note: on a wide image, we might not have enough room in a PC's near data
+ * segment to hold the error array; so it is allocated with alloc_large.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef INT16 FSERROR; /* 16 bits should be enough */
+typedef int LOCFSERROR; /* use 'int' for calculation temps */
+#else
+typedef INT32 FSERROR; /* may need more than 16 bits */
+typedef INT32 LOCFSERROR; /* be sure calculation temps are big enough */
+#endif
+
+typedef FSERROR FAR *FSERRPTR; /* pointer to error array (in FAR storage!) */
+
+
+/* Private subobject */
+
+typedef struct {
+ struct jpeg_color_quantizer pub; /* public fields */
+
+ /* Space for the eventually created colormap is stashed here */
+ JSAMPARRAY sv_colormap; /* colormap allocated at init time */
+ int desired; /* desired # of colors = size of colormap */
+
+ /* Variables for accumulating image statistics */
+ hist3d histogram; /* pointer to the histogram */
+
+ boolean needs_zeroed; /* TRUE if next pass must zero histogram */
+
+ /* Variables for Floyd-Steinberg dithering */
+ FSERRPTR fserrors; /* accumulated errors */
+ boolean on_odd_row; /* flag to remember which row we are on */
+ int * error_limiter; /* table for clamping the applied error */
+} my_cquantizer;
+
+typedef my_cquantizer * my_cquantize_ptr;
+
+
+/*
+ * Prescan some rows of pixels.
+ * In this module the prescan simply updates the histogram, which has been
+ * initialized to zeroes by start_pass.
+ * An output_buf parameter is required by the method signature, but no data
+ * is actually output (in fact the buffer controller is probably passing a
+ * NULL pointer).
+ */
+
+METHODDEF(void)
+prescan_quantize (j_decompress_ptr cinfo, JSAMPARRAY input_buf,
+ JSAMPARRAY output_buf, int num_rows)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ register JSAMPROW ptr;
+ register histptr histp;
+ register hist3d histogram = cquantize->histogram;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ ptr = input_buf[row];
+ for (col = width; col > 0; col--) {
+ /* get pixel value and index into the histogram */
+ histp = & histogram[GETJSAMPLE(ptr[0]) >> C0_SHIFT]
+ [GETJSAMPLE(ptr[1]) >> C1_SHIFT]
+ [GETJSAMPLE(ptr[2]) >> C2_SHIFT];
+ /* increment, check for overflow and undo increment if so. */
+ if (++(*histp) <= 0)
+ (*histp)--;
+ ptr += 3;
+ }
+ }
+}
+
+
+/*
+ * Next we have the really interesting routines: selection of a colormap
+ * given the completed histogram.
+ * These routines work with a list of "boxes", each representing a rectangular
+ * subset of the input color space (to histogram precision).
+ */
+
+typedef struct {
+ /* The bounds of the box (inclusive); expressed as histogram indexes */
+ int c0min, c0max;
+ int c1min, c1max;
+ int c2min, c2max;
+ /* The volume (actually 2-norm) of the box */
+ INT32 volume;
+ /* The number of nonzero histogram cells within this box */
+ long colorcount;
+} box;
+
+typedef box * boxptr;
+
+
+LOCAL(boxptr)
+find_biggest_color_pop (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest color population */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register long maxc = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+ if (boxp->colorcount > maxc && boxp->volume > 0) {
+ which = boxp;
+ maxc = boxp->colorcount;
+ }
+ }
+ return which;
+}
+
+
+LOCAL(boxptr)
+find_biggest_volume (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest (scaled) volume */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register INT32 maxv = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++) {
+ if (boxp->volume > maxv) {
+ which = boxp;
+ maxv = boxp->volume;
+ }
+ }
+ return which;
+}
+
+
+LOCAL(void)
+update_box (j_decompress_ptr cinfo, boxptr boxp)
+/* Shrink the min/max bounds of a box to enclose only nonzero elements, */
+/* and recompute its volume and population */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ histptr histp;
+ int c0,c1,c2;
+ int c0min,c0max,c1min,c1max,c2min,c2max;
+ INT32 dist0,dist1,dist2;
+ long ccount;
+
+ c0min = boxp->c0min; c0max = boxp->c0max;
+ c1min = boxp->c1min; c1max = boxp->c1max;
+ c2min = boxp->c2min; c2max = boxp->c2max;
+
+ if (c0max > c0min)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c0min = c0min = c0;
+ goto have_c0min;
+ }
+ }
+ have_c0min:
+ if (c0max > c0min)
+ for (c0 = c0max; c0 >= c0min; c0--)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c0max = c0max = c0;
+ goto have_c0max;
+ }
+ }
+ have_c0max:
+ if (c1max > c1min)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c1min = c1min = c1;
+ goto have_c1min;
+ }
+ }
+ have_c1min:
+ if (c1max > c1min)
+ for (c1 = c1max; c1 >= c1min; c1--)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (*histp++ != 0) {
+ boxp->c1max = c1max = c1;
+ goto have_c1max;
+ }
+ }
+ have_c1max:
+ if (c2max > c2min)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1min][c2];
+ for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+ if (*histp != 0) {
+ boxp->c2min = c2min = c2;
+ goto have_c2min;
+ }
+ }
+ have_c2min:
+ if (c2max > c2min)
+ for (c2 = c2max; c2 >= c2min; c2--)
+ for (c0 = c0min; c0 <= c0max; c0++) {
+ histp = & histogram[c0][c1min][c2];
+ for (c1 = c1min; c1 <= c1max; c1++, histp += HIST_C2_ELEMS)
+ if (*histp != 0) {
+ boxp->c2max = c2max = c2;
+ goto have_c2max;
+ }
+ }
+ have_c2max:
+
+ /* Update box volume.
+ * We use 2-norm rather than real volume here; this biases the method
+ * against making long narrow boxes, and it has the side benefit that
+ * a box is splittable iff norm > 0.
+ * Since the differences are expressed in histogram-cell units,
+ * we have to shift back to JSAMPLE units to get consistent distances;
+ * after which, we scale according to the selected distance scale factors.
+ */
+ dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE;
+ dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;
+ dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;
+ boxp->volume = dist0*dist0 + dist1*dist1 + dist2*dist2;
+
+ /* Now scan remaining volume of box and compute population */
+ ccount = 0;
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++, histp++)
+ if (*histp != 0) {
+ ccount++;
+ }
+ }
+ boxp->colorcount = ccount;
+}
+
+
+LOCAL(int)
+median_cut (j_decompress_ptr cinfo, boxptr boxlist, int numboxes,
+ int desired_colors)
+/* Repeatedly select and split the largest box until we have enough boxes */
+{
+ int n,lb;
+ int c0,c1,c2,cmax;
+ register boxptr b1,b2;
+
+ while (numboxes < desired_colors) {
+ /* Select box to split.
+ * Current algorithm: by population for first half, then by volume.
+ */
+ if (numboxes*2 <= desired_colors) {
+ b1 = find_biggest_color_pop(boxlist, numboxes);
+ } else {
+ b1 = find_biggest_volume(boxlist, numboxes);
+ }
+ if (b1 == NULL) /* no splittable boxes left! */
+ break;
+ b2 = &boxlist[numboxes]; /* where new box will go */
+ /* Copy the color bounds to the new box. */
+ b2->c0max = b1->c0max; b2->c1max = b1->c1max; b2->c2max = b1->c2max;
+ b2->c0min = b1->c0min; b2->c1min = b1->c1min; b2->c2min = b1->c2min;
+ /* Choose which axis to split the box on.
+ * Current algorithm: longest scaled axis.
+ * See notes in update_box about scaling distances.
+ */
+ c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE;
+ c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE;
+ c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE;
+ /* We want to break any ties in favor of green, then red, blue last.
+ * This code does the right thing for R,G,B or B,G,R color orders only.
+ */
+#if RGB_RED == 0
+ cmax = c1; n = 1;
+ if (c0 > cmax) { cmax = c0; n = 0; }
+ if (c2 > cmax) { n = 2; }
+#else
+ cmax = c1; n = 1;
+ if (c2 > cmax) { cmax = c2; n = 2; }
+ if (c0 > cmax) { n = 0; }
+#endif
+ /* Choose split point along selected axis, and update box bounds.
+ * Current algorithm: split at halfway point.
+ * (Since the box has been shrunk to minimum volume,
+ * any split will produce two nonempty subboxes.)
+ * Note that lb value is max for lower box, so must be < old max.
+ */
+ switch (n) {
+ case 0:
+ lb = (b1->c0max + b1->c0min) / 2;
+ b1->c0max = lb;
+ b2->c0min = lb+1;
+ break;
+ case 1:
+ lb = (b1->c1max + b1->c1min) / 2;
+ b1->c1max = lb;
+ b2->c1min = lb+1;
+ break;
+ case 2:
+ lb = (b1->c2max + b1->c2min) / 2;
+ b1->c2max = lb;
+ b2->c2min = lb+1;
+ break;
+ }
+ /* Update stats for boxes */
+ update_box(cinfo, b1);
+ update_box(cinfo, b2);
+ numboxes++;
+ }
+ return numboxes;
+}
+
+
+LOCAL(void)
+compute_color (j_decompress_ptr cinfo, boxptr boxp, int icolor)
+/* Compute representative color for a box, put it in colormap[icolor] */
+{
+ /* Current algorithm: mean weighted by pixels (not colors) */
+ /* Note it is important to get the rounding correct! */
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ histptr histp;
+ int c0,c1,c2;
+ int c0min,c0max,c1min,c1max,c2min,c2max;
+ long count;
+ long total = 0;
+ long c0total = 0;
+ long c1total = 0;
+ long c2total = 0;
+
+ c0min = boxp->c0min; c0max = boxp->c0max;
+ c1min = boxp->c1min; c1max = boxp->c1max;
+ c2min = boxp->c2min; c2max = boxp->c2max;
+
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++) {
+ histp = & histogram[c0][c1][c2min];
+ for (c2 = c2min; c2 <= c2max; c2++) {
+ if ((count = *histp++) != 0) {
+ total += count;
+ c0total += ((c0 << C0_SHIFT) + ((1<<C0_SHIFT)>>1)) * count;
+ c1total += ((c1 << C1_SHIFT) + ((1<<C1_SHIFT)>>1)) * count;
+ c2total += ((c2 << C2_SHIFT) + ((1<<C2_SHIFT)>>1)) * count;
+ }
+ }
+ }
+
+ cinfo->colormap[0][icolor] = (JSAMPLE) ((c0total + (total>>1)) / total);
+ cinfo->colormap[1][icolor] = (JSAMPLE) ((c1total + (total>>1)) / total);
+ cinfo->colormap[2][icolor] = (JSAMPLE) ((c2total + (total>>1)) / total);
+}
+
+
+LOCAL(void)
+select_colors (j_decompress_ptr cinfo, int desired_colors)
+/* Master routine for color selection */
+{
+ boxptr boxlist;
+ int numboxes;
+ int i;
+
+ /* Allocate workspace for box list */
+ boxlist = (boxptr) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, desired_colors * SIZEOF(box));
+ /* Initialize one box containing whole space */
+ numboxes = 1;
+ boxlist[0].c0min = 0;
+ boxlist[0].c0max = MAXJSAMPLE >> C0_SHIFT;
+ boxlist[0].c1min = 0;
+ boxlist[0].c1max = MAXJSAMPLE >> C1_SHIFT;
+ boxlist[0].c2min = 0;
+ boxlist[0].c2max = MAXJSAMPLE >> C2_SHIFT;
+ /* Shrink it to actually-used volume and set its statistics */
+ update_box(cinfo, & boxlist[0]);
+ /* Perform median-cut to produce final box list */
+ numboxes = median_cut(cinfo, boxlist, numboxes, desired_colors);
+ /* Compute the representative color for each box, fill colormap */
+ for (i = 0; i < numboxes; i++)
+ compute_color(cinfo, & boxlist[i], i);
+ cinfo->actual_number_of_colors = numboxes;
+ TRACEMS1(cinfo, 1, JTRC_QUANT_SELECTED, numboxes);
+}
+
+
+/*
+ * These routines are concerned with the time-critical task of mapping input
+ * colors to the nearest color in the selected colormap.
+ *
+ * We re-use the histogram space as an "inverse color map", essentially a
+ * cache for the results of nearest-color searches. All colors within a
+ * histogram cell will be mapped to the same colormap entry, namely the one
+ * closest to the cell's center. This may not be quite the closest entry to
+ * the actual input color, but it's almost as good. A zero in the cache
+ * indicates we haven't found the nearest color for that cell yet; the array
+ * is cleared to zeroes before starting the mapping pass. When we find the
+ * nearest color for a cell, its colormap index plus one is recorded in the
+ * cache for future use. The pass2 scanning routines call fill_inverse_cmap
+ * when they need to use an unfilled entry in the cache.
+ *
+ * Our method of efficiently finding nearest colors is based on the "locally
+ * sorted search" idea described by Heckbert and on the incremental distance
+ * calculation described by Spencer W. Thomas in chapter III.1 of Graphics
+ * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that
+ * the distances from a given colormap entry to each cell of the histogram can
+ * be computed quickly using an incremental method: the differences between
+ * distances to adjacent cells themselves differ by a constant. This allows a
+ * fairly fast implementation of the "brute force" approach of computing the
+ * distance from every colormap entry to every histogram cell. Unfortunately,
+ * it needs a work array to hold the best-distance-so-far for each histogram
+ * cell (because the inner loop has to be over cells, not colormap entries).
+ * The work array elements have to be INT32s, so the work array would need
+ * 256Kb at our recommended precision. This is not feasible in DOS machines.
+ *
+ * To get around these problems, we apply Thomas' method to compute the
+ * nearest colors for only the cells within a small subbox of the histogram.
+ * The work array need be only as big as the subbox, so the memory usage
+ * problem is solved. Furthermore, we need not fill subboxes that are never
+ * referenced in pass2; many images use only part of the color gamut, so a
+ * fair amount of work is saved. An additional advantage of this
+ * approach is that we can apply Heckbert's locality criterion to quickly
+ * eliminate colormap entries that are far away from the subbox; typically
+ * three-fourths of the colormap entries are rejected by Heckbert's criterion,
+ * and we need not compute their distances to individual cells in the subbox.
+ * The speed of this approach is heavily influenced by the subbox size: too
+ * small means too much overhead, too big loses because Heckbert's criterion
+ * can't eliminate as many colormap entries. Empirically the best subbox
+ * size seems to be about 1/512th of the histogram (1/8th in each direction).
+ *
+ * Thomas' article also describes a refined method which is asymptotically
+ * faster than the brute-force method, but it is also far more complex and
+ * cannot efficiently be applied to small subboxes. It is therefore not
+ * useful for programs intended to be portable to DOS machines. On machines
+ * with plenty of memory, filling the whole histogram in one shot with Thomas'
+ * refined method might be faster than the present code --- but then again,
+ * it might not be any faster, and it's certainly more complicated.
+ */
+
+
+/* log2(histogram cells in update box) for each axis; this can be adjusted */
+#define BOX_C0_LOG (HIST_C0_BITS-3)
+#define BOX_C1_LOG (HIST_C1_BITS-3)
+#define BOX_C2_LOG (HIST_C2_BITS-3)
+
+#define BOX_C0_ELEMS (1<<BOX_C0_LOG) /* # of hist cells in update box */
+#define BOX_C1_ELEMS (1<<BOX_C1_LOG)
+#define BOX_C2_ELEMS (1<<BOX_C2_LOG)
+
+#define BOX_C0_SHIFT (C0_SHIFT + BOX_C0_LOG)
+#define BOX_C1_SHIFT (C1_SHIFT + BOX_C1_LOG)
+#define BOX_C2_SHIFT (C2_SHIFT + BOX_C2_LOG)
+
+
+/*
+ * The next three routines implement inverse colormap filling. They could
+ * all be folded into one big routine, but splitting them up this way saves
+ * some stack space (the mindist[] and bestdist[] arrays need not coexist)
+ * and may allow some compilers to produce better code by registerizing more
+ * inner-loop variables.
+ */
+
+LOCAL(int)
+find_nearby_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+ JSAMPLE colorlist[])
+/* Locate the colormap entries close enough to an update box to be candidates
+ * for the nearest entry to some cell(s) in the update box. The update box
+ * is specified by the center coordinates of its first cell. The number of
+ * candidate colormap entries is returned, and their colormap indexes are
+ * placed in colorlist[].
+ * This routine uses Heckbert's "locally sorted search" criterion to select
+ * the colors that need further consideration.
+ */
+{
+ int numcolors = cinfo->actual_number_of_colors;
+ int maxc0, maxc1, maxc2;
+ int centerc0, centerc1, centerc2;
+ int i, x, ncolors;
+ INT32 minmaxdist, min_dist, max_dist, tdist;
+ INT32 mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */
+
+ /* Compute true coordinates of update box's upper corner and center.
+ * Actually we compute the coordinates of the center of the upper-corner
+ * histogram cell, which are the upper bounds of the volume we care about.
+ * Note that since ">>" rounds down, the "center" values may be closer to
+ * min than to max; hence comparisons to them must be "<=", not "<".
+ */
+ maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT));
+ centerc0 = (minc0 + maxc0) >> 1;
+ maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT));
+ centerc1 = (minc1 + maxc1) >> 1;
+ maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT));
+ centerc2 = (minc2 + maxc2) >> 1;
+
+ /* For each color in colormap, find:
+ * 1. its minimum squared-distance to any point in the update box
+ * (zero if color is within update box);
+ * 2. its maximum squared-distance to any point in the update box.
+ * Both of these can be found by considering only the corners of the box.
+ * We save the minimum distance for each color in mindist[];
+ * only the smallest maximum distance is of interest.
+ */
+ minmaxdist = 0x7FFFFFFFL;
+
+ for (i = 0; i < numcolors; i++) {
+ /* We compute the squared-c0-distance term, then add in the other two. */
+ x = GETJSAMPLE(cinfo->colormap[0][i]);
+ if (x < minc0) {
+ tdist = (x - minc0) * C0_SCALE;
+ min_dist = tdist*tdist;
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else if (x > maxc0) {
+ tdist = (x - maxc0) * C0_SCALE;
+ min_dist = tdist*tdist;
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ min_dist = 0;
+ if (x <= centerc0) {
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ } else {
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist*tdist;
+ }
+ }
+
+ x = GETJSAMPLE(cinfo->colormap[1][i]);
+ if (x < minc1) {
+ tdist = (x - minc1) * C1_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else if (x > maxc1) {
+ tdist = (x - maxc1) * C1_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc1) {
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist*tdist;
+ }
+ }
+
+ x = GETJSAMPLE(cinfo->colormap[2][i]);
+ if (x < minc2) {
+ tdist = (x - minc2) * C2_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else if (x > maxc2) {
+ tdist = (x - maxc2) * C2_SCALE;
+ min_dist += tdist*tdist;
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc2) {
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ } else {
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist*tdist;
+ }
+ }
+
+ mindist[i] = min_dist; /* save away the results */
+ if (max_dist < minmaxdist)
+ minmaxdist = max_dist;
+ }
+
+ /* Now we know that no cell in the update box is more than minmaxdist
+ * away from some colormap entry. Therefore, only colors that are
+ * within minmaxdist of some part of the box need be considered.
+ */
+ ncolors = 0;
+ for (i = 0; i < numcolors; i++) {
+ if (mindist[i] <= minmaxdist)
+ colorlist[ncolors++] = (JSAMPLE) i;
+ }
+ return ncolors;
+}
+
+
+LOCAL(void)
+find_best_colors (j_decompress_ptr cinfo, int minc0, int minc1, int minc2,
+ int numcolors, JSAMPLE colorlist[], JSAMPLE bestcolor[])
+/* Find the closest colormap entry for each cell in the update box,
+ * given the list of candidate colors prepared by find_nearby_colors.
+ * Return the indexes of the closest entries in the bestcolor[] array.
+ * This routine uses Thomas' incremental distance calculation method to
+ * find the distance from a colormap entry to successive cells in the box.
+ */
+{
+ int ic0, ic1, ic2;
+ int i, icolor;
+ register INT32 * bptr; /* pointer into bestdist[] array */
+ JSAMPLE * cptr; /* pointer into bestcolor[] array */
+ INT32 dist0, dist1; /* initial distance values */
+ register INT32 dist2; /* current distance in inner loop */
+ INT32 xx0, xx1; /* distance increments */
+ register INT32 xx2;
+ INT32 inc0, inc1, inc2; /* initial values for increments */
+ /* This array holds the distance to the nearest-so-far color for each cell */
+ INT32 bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+ /* Initialize best-distance for each cell of the update box */
+ bptr = bestdist;
+ for (i = BOX_C0_ELEMS*BOX_C1_ELEMS*BOX_C2_ELEMS-1; i >= 0; i--)
+ *bptr++ = 0x7FFFFFFFL;
+
+ /* For each color selected by find_nearby_colors,
+ * compute its distance to the center of each cell in the box.
+ * If that's less than best-so-far, update best distance and color number.
+ */
+
+ /* Nominal steps between cell centers ("x" in Thomas article) */
+#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE)
+#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE)
+#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE)
+
+ for (i = 0; i < numcolors; i++) {
+ icolor = GETJSAMPLE(colorlist[i]);
+ /* Compute (square of) distance from minc0/c1/c2 to this color */
+ inc0 = (minc0 - GETJSAMPLE(cinfo->colormap[0][icolor])) * C0_SCALE;
+ dist0 = inc0*inc0;
+ inc1 = (minc1 - GETJSAMPLE(cinfo->colormap[1][icolor])) * C1_SCALE;
+ dist0 += inc1*inc1;
+ inc2 = (minc2 - GETJSAMPLE(cinfo->colormap[2][icolor])) * C2_SCALE;
+ dist0 += inc2*inc2;
+ /* Form the initial difference increments */
+ inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0;
+ inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1;
+ inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2;
+ /* Now loop over all cells in box, updating distance per Thomas method */
+ bptr = bestdist;
+ cptr = bestcolor;
+ xx0 = inc0;
+ for (ic0 = BOX_C0_ELEMS-1; ic0 >= 0; ic0--) {
+ dist1 = dist0;
+ xx1 = inc1;
+ for (ic1 = BOX_C1_ELEMS-1; ic1 >= 0; ic1--) {
+ dist2 = dist1;
+ xx2 = inc2;
+ for (ic2 = BOX_C2_ELEMS-1; ic2 >= 0; ic2--) {
+ if (dist2 < *bptr) {
+ *bptr = dist2;
+ *cptr = (JSAMPLE) icolor;
+ }
+ dist2 += xx2;
+ xx2 += 2 * STEP_C2 * STEP_C2;
+ bptr++;
+ cptr++;
+ }
+ dist1 += xx1;
+ xx1 += 2 * STEP_C1 * STEP_C1;
+ }
+ dist0 += xx0;
+ xx0 += 2 * STEP_C0 * STEP_C0;
+ }
+ }
+}
+
+
+LOCAL(void)
+fill_inverse_cmap (j_decompress_ptr cinfo, int c0, int c1, int c2)
+/* Fill the inverse-colormap entries in the update box that contains */
+/* histogram cell c0/c1/c2. (Only that one cell MUST be filled, but */
+/* we can fill as many others as we wish.) */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ int minc0, minc1, minc2; /* lower left corner of update box */
+ int ic0, ic1, ic2;
+ register JSAMPLE * cptr; /* pointer into bestcolor[] array */
+ register histptr cachep; /* pointer into main cache array */
+ /* This array lists the candidate colormap indexes. */
+ JSAMPLE colorlist[MAXNUMCOLORS];
+ int numcolors; /* number of candidate colors */
+ /* This array holds the actually closest colormap index for each cell. */
+ JSAMPLE bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS];
+
+ /* Convert cell coordinates to update box ID */
+ c0 >>= BOX_C0_LOG;
+ c1 >>= BOX_C1_LOG;
+ c2 >>= BOX_C2_LOG;
+
+ /* Compute true coordinates of update box's origin corner.
+ * Actually we compute the coordinates of the center of the corner
+ * histogram cell, which are the lower bounds of the volume we care about.
+ */
+ minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);
+ minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);
+ minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);
+
+ /* Determine which colormap entries are close enough to be candidates
+ * for the nearest entry to some cell in the update box.
+ */
+ numcolors = find_nearby_colors(cinfo, minc0, minc1, minc2, colorlist);
+
+ /* Determine the actually nearest colors. */
+ find_best_colors(cinfo, minc0, minc1, minc2, numcolors, colorlist,
+ bestcolor);
+
+ /* Save the best color numbers (plus 1) in the main cache array */
+ c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */
+ c1 <<= BOX_C1_LOG;
+ c2 <<= BOX_C2_LOG;
+ cptr = bestcolor;
+ for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++) {
+ for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++) {
+ cachep = & histogram[c0+ic0][c1+ic1][c2];
+ for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++) {
+ *cachep++ = (histcell) (GETJSAMPLE(*cptr++) + 1);
+ }
+ }
+ }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+METHODDEF(void)
+pass2_no_dither (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+/* This version performs no dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ register JSAMPROW inptr, outptr;
+ register histptr cachep;
+ register int c0, c1, c2;
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+
+ for (row = 0; row < num_rows; row++) {
+ inptr = input_buf[row];
+ outptr = output_buf[row];
+ for (col = width; col > 0; col--) {
+ /* get pixel value and index into the cache */
+ c0 = GETJSAMPLE(*inptr++) >> C0_SHIFT;
+ c1 = GETJSAMPLE(*inptr++) >> C1_SHIFT;
+ c2 = GETJSAMPLE(*inptr++) >> C2_SHIFT;
+ cachep = & histogram[c0][c1][c2];
+ /* If we have not seen this color before, find nearest colormap entry */
+ /* and update the cache */
+ if (*cachep == 0)
+ fill_inverse_cmap(cinfo, c0,c1,c2);
+ /* Now emit the colormap index for this cell */
+ *outptr++ = (JSAMPLE) (*cachep - 1);
+ }
+ }
+}
+
+
+METHODDEF(void)
+pass2_fs_dither (j_decompress_ptr cinfo,
+ JSAMPARRAY input_buf, JSAMPARRAY output_buf, int num_rows)
+/* This version performs Floyd-Steinberg dithering */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ register LOCFSERROR cur0, cur1, cur2; /* current error or pixel value */
+ LOCFSERROR belowerr0, belowerr1, belowerr2; /* error for pixel below cur */
+ LOCFSERROR bpreverr0, bpreverr1, bpreverr2; /* error for below/prev col */
+ register FSERRPTR errorptr; /* => fserrors[] at column before current */
+ JSAMPROW inptr; /* => current input pixel */
+ JSAMPROW outptr; /* => current output pixel */
+ histptr cachep;
+ int dir; /* +1 or -1 depending on direction */
+ int dir3; /* 3*dir, for advancing inptr & errorptr */
+ int row;
+ JDIMENSION col;
+ JDIMENSION width = cinfo->output_width;
+ JSAMPLE *range_limit = cinfo->sample_range_limit;
+ int *error_limit = cquantize->error_limiter;
+ JSAMPROW colormap0 = cinfo->colormap[0];
+ JSAMPROW colormap1 = cinfo->colormap[1];
+ JSAMPROW colormap2 = cinfo->colormap[2];
+ SHIFT_TEMPS
+
+ for (row = 0; row < num_rows; row++) {
+ inptr = input_buf[row];
+ outptr = output_buf[row];
+ if (cquantize->on_odd_row) {
+ /* work right to left in this row */
+ inptr += (width-1) * 3; /* so point to rightmost pixel */
+ outptr += width-1;
+ dir = -1;
+ dir3 = -3;
+ errorptr = cquantize->fserrors + (width+1)*3; /* => entry after last column */
+ cquantize->on_odd_row = FALSE; /* flip for next time */
+ } else {
+ /* work left to right in this row */
+ dir = 1;
+ dir3 = 3;
+ errorptr = cquantize->fserrors; /* => entry before first real column */
+ cquantize->on_odd_row = TRUE; /* flip for next time */
+ }
+ /* Preset error values: no error propagated to first pixel from left */
+ cur0 = cur1 = cur2 = 0;
+ /* and no error propagated to row below yet */
+ belowerr0 = belowerr1 = belowerr2 = 0;
+ bpreverr0 = bpreverr1 = bpreverr2 = 0;
+
+ for (col = width; col > 0; col--) {
+ /* curN holds the error propagated from the previous pixel on the
+ * current line. Add the error propagated from the previous line
+ * to form the complete error correction term for this pixel, and
+ * round the error term (which is expressed * 16) to an integer.
+ * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+ * for either sign of the error value.
+ * Note: errorptr points to *previous* column's array entry.
+ */
+ cur0 = RIGHT_SHIFT(cur0 + errorptr[dir3+0] + 8, 4);
+ cur1 = RIGHT_SHIFT(cur1 + errorptr[dir3+1] + 8, 4);
+ cur2 = RIGHT_SHIFT(cur2 + errorptr[dir3+2] + 8, 4);
+ /* Limit the error using transfer function set by init_error_limit.
+ * See comments with init_error_limit for rationale.
+ */
+ cur0 = error_limit[cur0];
+ cur1 = error_limit[cur1];
+ cur2 = error_limit[cur2];
+ /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+ * The maximum error is +- MAXJSAMPLE (or less with error limiting);
+ * this sets the required size of the range_limit array.
+ */
+ cur0 += GETJSAMPLE(inptr[0]);
+ cur1 += GETJSAMPLE(inptr[1]);
+ cur2 += GETJSAMPLE(inptr[2]);
+ cur0 = GETJSAMPLE(range_limit[cur0]);
+ cur1 = GETJSAMPLE(range_limit[cur1]);
+ cur2 = GETJSAMPLE(range_limit[cur2]);
+ /* Index into the cache with adjusted pixel value */
+ cachep = & histogram[cur0>>C0_SHIFT][cur1>>C1_SHIFT][cur2>>C2_SHIFT];
+ /* If we have not seen this color before, find nearest colormap */
+ /* entry and update the cache */
+ if (*cachep == 0)
+ fill_inverse_cmap(cinfo, cur0>>C0_SHIFT,cur1>>C1_SHIFT,cur2>>C2_SHIFT);
+ /* Now emit the colormap index for this cell */
+ { register int pixcode = *cachep - 1;
+ *outptr = (JSAMPLE) pixcode;
+ /* Compute representation error for this pixel */
+ cur0 -= GETJSAMPLE(colormap0[pixcode]);
+ cur1 -= GETJSAMPLE(colormap1[pixcode]);
+ cur2 -= GETJSAMPLE(colormap2[pixcode]);
+ }
+ /* Compute error fractions to be propagated to adjacent pixels.
+ * Add these into the running sums, and simultaneously shift the
+ * next-line error sums left by 1 column.
+ */
+ { register LOCFSERROR bnexterr, delta;
+
+ bnexterr = cur0; /* Process component 0 */
+ delta = cur0 * 2;
+ cur0 += delta; /* form error * 3 */
+ errorptr[0] = (FSERROR) (bpreverr0 + cur0);
+ cur0 += delta; /* form error * 5 */
+ bpreverr0 = belowerr0 + cur0;
+ belowerr0 = bnexterr;
+ cur0 += delta; /* form error * 7 */
+ bnexterr = cur1; /* Process component 1 */
+ delta = cur1 * 2;
+ cur1 += delta; /* form error * 3 */
+ errorptr[1] = (FSERROR) (bpreverr1 + cur1);
+ cur1 += delta; /* form error * 5 */
+ bpreverr1 = belowerr1 + cur1;
+ belowerr1 = bnexterr;
+ cur1 += delta; /* form error * 7 */
+ bnexterr = cur2; /* Process component 2 */
+ delta = cur2 * 2;
+ cur2 += delta; /* form error * 3 */
+ errorptr[2] = (FSERROR) (bpreverr2 + cur2);
+ cur2 += delta; /* form error * 5 */
+ bpreverr2 = belowerr2 + cur2;
+ belowerr2 = bnexterr;
+ cur2 += delta; /* form error * 7 */
+ }
+ /* At this point curN contains the 7/16 error value to be propagated
+ * to the next pixel on the current line, and all the errors for the
+ * next line have been shifted over. We are therefore ready to move on.
+ */
+ inptr += dir3; /* Advance pixel pointers to next column */
+ outptr += dir;
+ errorptr += dir3; /* advance errorptr to current column */
+ }
+ /* Post-loop cleanup: we must unload the final error values into the
+ * final fserrors[] entry. Note we need not unload belowerrN because
+ * it is for the dummy column before or after the actual array.
+ */
+ errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */
+ errorptr[1] = (FSERROR) bpreverr1;
+ errorptr[2] = (FSERROR) bpreverr2;
+ }
+}
+
+
+/*
+ * Initialize the error-limiting transfer function (lookup table).
+ * The raw F-S error computation can potentially compute error values of up to
+ * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be
+ * much less, otherwise obviously wrong pixels will be created. (Typical
+ * effects include weird fringes at color-area boundaries, isolated bright
+ * pixels in a dark area, etc.) The standard advice for avoiding this problem
+ * is to ensure that the "corners" of the color cube are allocated as output
+ * colors; then repeated errors in the same direction cannot cause cascading
+ * error buildup. However, that only prevents the error from getting
+ * completely out of hand; Aaron Giles reports that error limiting improves
+ * the results even with corner colors allocated.
+ * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty
+ * well, but the smoother transfer function used below is even better. Thanks
+ * to Aaron Giles for this idea.
+ */
+
+LOCAL(void)
+init_error_limit (j_decompress_ptr cinfo)
+/* Allocate and fill in the error_limiter table */
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ int * table;
+ int in, out;
+
+ table = (int *) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE*2+1) * SIZEOF(int));
+ table += MAXJSAMPLE; /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+ cquantize->error_limiter = table;
+
+#define STEPSIZE ((MAXJSAMPLE+1)/16)
+ /* Map errors 1:1 up to +- MAXJSAMPLE/16 */
+ out = 0;
+ for (in = 0; in < STEPSIZE; in++, out++) {
+ table[in] = out; table[-in] = -out;
+ }
+ /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */
+ for (; in < STEPSIZE*3; in++, out += (in&1) ? 0 : 1) {
+ table[in] = out; table[-in] = -out;
+ }
+ /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */
+ for (; in <= MAXJSAMPLE; in++) {
+ table[in] = out; table[-in] = -out;
+ }
+#undef STEPSIZE
+}
+
+
+/*
+ * Finish up at the end of each pass.
+ */
+
+METHODDEF(void)
+finish_pass1 (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+
+ /* Select the representative colors and fill in cinfo->colormap */
+ cinfo->colormap = cquantize->sv_colormap;
+ select_colors(cinfo, cquantize->desired);
+ /* Force next pass to zero the color index table */
+ cquantize->needs_zeroed = TRUE;
+}
+
+
+METHODDEF(void)
+finish_pass2 (j_decompress_ptr cinfo)
+{
+ /* no work */
+}
+
+
+/*
+ * Initialize for each processing pass.
+ */
+
+METHODDEF(void)
+start_pass_2_quant (j_decompress_ptr cinfo, boolean is_pre_scan)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+ hist3d histogram = cquantize->histogram;
+ int i;
+
+ /* Only F-S dithering or no dithering is supported. */
+ /* If user asks for ordered dither, give him F-S. */
+ if (cinfo->dither_mode != JDITHER_NONE)
+ cinfo->dither_mode = JDITHER_FS;
+
+ if (is_pre_scan) {
+ /* Set up method pointers */
+ cquantize->pub.color_quantize = prescan_quantize;
+ cquantize->pub.finish_pass = finish_pass1;
+ cquantize->needs_zeroed = TRUE; /* Always zero histogram */
+ } else {
+ /* Set up method pointers */
+ if (cinfo->dither_mode == JDITHER_FS)
+ cquantize->pub.color_quantize = pass2_fs_dither;
+ else
+ cquantize->pub.color_quantize = pass2_no_dither;
+ cquantize->pub.finish_pass = finish_pass2;
+
+ /* Make sure color count is acceptable */
+ i = cinfo->actual_number_of_colors;
+ if (i < 1)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 1);
+ if (i > MAXNUMCOLORS)
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+
+ if (cinfo->dither_mode == JDITHER_FS) {
+ size_t arraysize = (size_t) ((cinfo->output_width + 2) *
+ (3 * SIZEOF(FSERROR)));
+ /* Allocate Floyd-Steinberg workspace if we didn't already. */
+ if (cquantize->fserrors == NULL)
+ cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, arraysize);
+ /* Initialize the propagated errors to zero. */
+ jzero_far((void FAR *) cquantize->fserrors, arraysize);
+ /* Make the error-limit table if we didn't already. */
+ if (cquantize->error_limiter == NULL)
+ init_error_limit(cinfo);
+ cquantize->on_odd_row = FALSE;
+ }
+
+ }
+ /* Zero the histogram or inverse color map, if necessary */
+ if (cquantize->needs_zeroed) {
+ for (i = 0; i < HIST_C0_ELEMS; i++) {
+ jzero_far((void FAR *) histogram[i],
+ HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+ }
+ cquantize->needs_zeroed = FALSE;
+ }
+}
+
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+METHODDEF(void)
+new_color_map_2_quant (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize = (my_cquantize_ptr) cinfo->cquantize;
+
+ /* Reset the inverse color map */
+ cquantize->needs_zeroed = TRUE;
+}
+
+
+/*
+ * Module initialization routine for 2-pass color quantization.
+ */
+
+GLOBAL(void)
+jinit_2pass_quantizer (j_decompress_ptr cinfo)
+{
+ my_cquantize_ptr cquantize;
+ int i;
+
+ cquantize = (my_cquantize_ptr)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ SIZEOF(my_cquantizer));
+ cinfo->cquantize = (struct jpeg_color_quantizer *) cquantize;
+ cquantize->pub.start_pass = start_pass_2_quant;
+ cquantize->pub.new_color_map = new_color_map_2_quant;
+ cquantize->fserrors = NULL; /* flag optional arrays not allocated */
+ cquantize->error_limiter = NULL;
+
+ /* Make sure jdmaster didn't give me a case I can't handle */
+ if (cinfo->out_color_components != 3)
+ ERREXIT(cinfo, JERR_NOTIMPL);
+
+ /* Allocate the histogram/inverse colormap storage */
+ cquantize->histogram = (hist3d) (*cinfo->mem->alloc_small)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE, HIST_C0_ELEMS * SIZEOF(hist2d));
+ for (i = 0; i < HIST_C0_ELEMS; i++) {
+ cquantize->histogram[i] = (hist2d) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ HIST_C1_ELEMS*HIST_C2_ELEMS * SIZEOF(histcell));
+ }
+ cquantize->needs_zeroed = TRUE; /* histogram is garbage now */
+
+ /* Allocate storage for the completed colormap, if required.
+ * We do this now since it is FAR storage and may affect
+ * the memory manager's space calculations.
+ */
+ if (cinfo->enable_2pass_quant) {
+ /* Make sure color count is acceptable */
+ int desired = cinfo->desired_number_of_colors;
+ /* Lower bound on # of colors ... somewhat arbitrary as long as > 0 */
+ if (desired < 8)
+ ERREXIT1(cinfo, JERR_QUANT_FEW_COLORS, 8);
+ /* Make sure colormap indexes can be represented by JSAMPLEs */
+ if (desired > MAXNUMCOLORS)
+ ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, MAXNUMCOLORS);
+ cquantize->sv_colormap = (*cinfo->mem->alloc_sarray)
+ ((j_common_ptr) cinfo,JPOOL_IMAGE, (JDIMENSION) desired, (JDIMENSION) 3);
+ cquantize->desired = desired;
+ } else
+ cquantize->sv_colormap = NULL;
+
+ /* Only F-S dithering or no dithering is supported. */
+ /* If user asks for ordered dither, give him F-S. */
+ if (cinfo->dither_mode != JDITHER_NONE)
+ cinfo->dither_mode = JDITHER_FS;
+
+ /* Allocate Floyd-Steinberg workspace if necessary.
+ * This isn't really needed until pass 2, but again it is FAR storage.
+ * Although we will cope with a later change in dither_mode,
+ * we do not promise to honor max_memory_to_use if dither_mode changes.
+ */
+ if (cinfo->dither_mode == JDITHER_FS) {
+ cquantize->fserrors = (FSERRPTR) (*cinfo->mem->alloc_large)
+ ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ (size_t) ((cinfo->output_width + 2) * (3 * SIZEOF(FSERROR))));
+ /* Might as well create the error-limiting table too. */
+ init_error_limit(cinfo);
+ }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
--- /dev/null
+/*
+ * jutils.c
+ *
+ * Copyright (C) 1991-1996, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains tables and miscellaneous utility routines needed
+ * for both compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
+ * of a DCT block read in natural order (left to right, top to bottom).
+ */
+
+#if 0 /* This table is not actually needed in v6a */
+
+const int jpeg_zigzag_order[DCTSIZE2] = {
+ 0, 1, 5, 6, 14, 15, 27, 28,
+ 2, 4, 7, 13, 16, 26, 29, 42,
+ 3, 8, 12, 17, 25, 30, 41, 43,
+ 9, 11, 18, 24, 31, 40, 44, 53,
+ 10, 19, 23, 32, 39, 45, 52, 54,
+ 20, 22, 33, 38, 46, 51, 55, 60,
+ 21, 34, 37, 47, 50, 56, 59, 61,
+ 35, 36, 48, 49, 57, 58, 62, 63
+};
+
+#endif
+
+/*
+ * jpeg_natural_order[i] is the natural-order position of the i'th element
+ * of zigzag order.
+ *
+ * When reading corrupted data, the Huffman decoders could attempt
+ * to reference an entry beyond the end of this array (if the decoded
+ * zero run length reaches past the end of the block). To prevent
+ * wild stores without adding an inner-loop test, we put some extra
+ * "63"s after the real entries. This will cause the extra coefficient
+ * to be stored in location 63 of the block, not somewhere random.
+ * The worst case would be a run-length of 15, which means we need 16
+ * fake entries.
+ */
+
+const int jpeg_natural_order[DCTSIZE2+16] = {
+ 0, 1, 8, 16, 9, 2, 3, 10,
+ 17, 24, 32, 25, 18, 11, 4, 5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13, 6, 7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+ 63, 63, 63, 63, 63, 63, 63, 63
+};
+
+
+/*
+ * Arithmetic utilities
+ */
+
+GLOBAL(long)
+jdiv_round_up (long a, long b)
+/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
+/* Assumes a >= 0, b > 0 */
+{
+ return (a + b - 1L) / b;
+}
+
+
+GLOBAL(long)
+jround_up (long a, long b)
+/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
+/* Assumes a >= 0, b > 0 */
+{
+ a += b - 1L;
+ return a - (a % b);
+}
+
+
+/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
+ * and coefficient-block arrays. This won't work on 80x86 because the arrays
+ * are FAR and we're assuming a small-pointer memory model. However, some
+ * DOS compilers provide far-pointer versions of memcpy() and memset() even
+ * in the small-model libraries. These will be used if USE_FMEM is defined.
+ * Otherwise, the routines below do it the hard way. (The performance cost
+ * is not all that great, because these routines aren't very heavily used.)
+ */
+
+#ifndef NEED_FAR_POINTERS /* normal case, same as regular macros */
+#define FMEMCOPY(dest,src,size) MEMCOPY(dest,src,size)
+#define FMEMZERO(target,size) MEMZERO(target,size)
+#else /* 80x86 case, define if we can */
+#ifdef USE_FMEM
+#define FMEMCOPY(dest,src,size) _fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
+#define FMEMZERO(target,size) _fmemset((void FAR *)(target), 0, (size_t)(size))
+#endif
+#endif
+
+
+GLOBAL(void)
+jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
+ JSAMPARRAY output_array, int dest_row,
+ int num_rows, JDIMENSION num_cols)
+/* Copy some rows of samples from one place to another.
+ * num_rows rows are copied from input_array[source_row++]
+ * to output_array[dest_row++]; these areas may overlap for duplication.
+ * The source and destination arrays must be at least as wide as num_cols.
+ */
+{
+ register JSAMPROW inptr, outptr;
+#ifdef FMEMCOPY
+ register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
+#else
+ register JDIMENSION count;
+#endif
+ register int row;
+
+ input_array += source_row;
+ output_array += dest_row;
+
+ for (row = num_rows; row > 0; row--) {
+ inptr = *input_array++;
+ outptr = *output_array++;
+#ifdef FMEMCOPY
+ FMEMCOPY(outptr, inptr, count);
+#else
+ for (count = num_cols; count > 0; count--)
+ *outptr++ = *inptr++; /* needn't bother with GETJSAMPLE() here */
+#endif
+ }
+}
+
+
+GLOBAL(void)
+jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
+ JDIMENSION num_blocks)
+/* Copy a row of coefficient blocks from one place to another. */
+{
+#ifdef FMEMCOPY
+ FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
+#else
+ register JCOEFPTR inptr, outptr;
+ register long count;
+
+ inptr = (JCOEFPTR) input_row;
+ outptr = (JCOEFPTR) output_row;
+ for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
+ *outptr++ = *inptr++;
+ }
+#endif
+}
+
+
+GLOBAL(void)
+jzero_far (void FAR * target, size_t bytestozero)
+/* Zero out a chunk of FAR memory. */
+/* This might be sample-array data, block-array data, or alloc_large data. */
+{
+#ifdef FMEMZERO
+ FMEMZERO(target, bytestozero);
+#else
+ register char FAR * ptr = (char FAR *) target;
+ register size_t count;
+
+ for (count = bytestozero; count > 0; count--) {
+ *ptr++ = 0;
+ }
+#endif
+}
--- /dev/null
+/*
+ * jversion.h
+ *
+ * Copyright (C) 1991-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains software version identification.
+ */
+
+
+#define JVERSION "6b 27-Mar-1998"
+
+#define JCOPYRIGHT "Copyright (C) 1998, Thomas G. Lane"
--- /dev/null
+
+This copy of the libpng notices is provided for your convenience. In case of
+any discrepancy between this copy and the notices in the file png.h that is
+included in the libpng distribution, the latter shall prevail.
+
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+
+If you modify libpng you may insert additional notices immediately following
+this sentence.
+
+This code is released under the libpng license.
+
+libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
+Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+ Cosmin Truta
+
+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are
+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.0.6
+with the following individuals added to the list of Contributing Authors
+
+ Simon-Pierre Cadieux
+ Eric S. Raymond
+ Gilles Vollant
+
+and with the following additions to the disclaimer:
+
+ There is no warranty against interference with your enjoyment of the
+ library or against infringement. There is no warranty that our
+ efforts or the library will fulfill any of your particular purposes
+ or needs. This library is provided with all faults, and the entire
+ risk of satisfactory quality, performance, accuracy, and effort is with
+ the user.
+
+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-0.96,
+with the following individuals added to the list of Contributing Authors:
+
+ Tom Lane
+ Glenn Randers-Pehrson
+ Willem van Schaik
+
+libpng versions 0.89, June 1996, through 0.96, May 1997, are
+Copyright (c) 1996, 1997 Andreas Dilger
+Distributed according to the same disclaimer and license as libpng-0.88,
+with the following individuals added to the list of Contributing Authors:
+
+ John Bowler
+ Kevin Bracey
+ Sam Bushell
+ Magnus Holmgren
+ Greg Roelofs
+ Tom Tanner
+
+libpng versions 0.5, May 1995, through 0.88, January 1996, are
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+ Andreas Dilger
+ Dave Martindale
+ Guy Eric Schalnat
+ Paul Schmidt
+ Tim Wegner
+
+The PNG Reference Library is supplied "AS IS". The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose. The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+1. The origin of this source code must not be misrepresented.
+
+2. Altered versions must be plainly marked as such and must not
+ be misrepresented as being the original source.
+
+3. This Copyright notice may not be removed or altered from any
+ source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products. If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+
+A "png_get_copyright" function is available, for convenient use in "about"
+boxes and the like:
+
+ printf("%s",png_get_copyright(NULL));
+
+Also, the PNG logo (in PNG format, of course) is supplied in the
+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+
+Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a
+certification mark of the Open Source Initiative.
+
+Glenn Randers-Pehrson
+glennrp at users.sourceforge.net
+July 7, 2011
--- /dev/null
+\r
+/* png.c - location for general purpose libpng functions\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#define PNG_NO_EXTERN\r
+#include "png.h"\r
+\r
+/* Generate a compiler error if there is an old png.h in the search path. */\r
+typedef version_1_2_33 Your_png_h_is_not_version_1_2_33;\r
+\r
+/* Version information for C files. This had better match the version\r
+ * string defined in png.h. */\r
+\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+/* png_libpng_ver was changed to a function in version 1.0.5c */\r
+PNG_CONST char png_libpng_ver[18] = PNG_LIBPNG_VER_STRING;\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+\r
+/* png_sig was changed to a function in version 1.0.5c */\r
+/* Place to hold the signature string for a PNG file. */\r
+PNG_CONST png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10};\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+/* Invoke global declarations for constant strings for known chunk types */\r
+PNG_IHDR;\r
+PNG_IDAT;\r
+PNG_IEND;\r
+PNG_PLTE;\r
+PNG_bKGD;\r
+PNG_cHRM;\r
+PNG_gAMA;\r
+PNG_hIST;\r
+PNG_iCCP;\r
+PNG_iTXt;\r
+PNG_oFFs;\r
+PNG_pCAL;\r
+PNG_sCAL;\r
+PNG_pHYs;\r
+PNG_sBIT;\r
+PNG_sPLT;\r
+PNG_sRGB;\r
+PNG_tEXt;\r
+PNG_tIME;\r
+PNG_tRNS;\r
+PNG_zTXt;\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+/* start of interlace block */\r
+PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+/* offset to next interlace block */\r
+PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+/* start of interlace block in the y direction */\r
+PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+/* offset to next interlace block in the y direction */\r
+PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};\r
+\r
+/* Height of interlace block. This is not currently used - if you need\r
+ * it, uncomment it here and in png.h\r
+PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};\r
+*/\r
+\r
+/* Mask to determine which pixels are valid in a pass */\r
+PNG_CONST int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};\r
+\r
+/* Mask to determine which pixels to overwrite while displaying */\r
+PNG_CONST int FARDATA png_pass_dsp_mask[]\r
+ = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};\r
+\r
+#endif /* PNG_READ_SUPPORTED */\r
+#endif /* PNG_USE_GLOBAL_ARRAYS */\r
+\r
+/* Tells libpng that we have already handled the first "num_bytes" bytes\r
+ * of the PNG file signature. If the PNG data is embedded into another\r
+ * stream we can set num_bytes = 8 so that libpng will not attempt to read\r
+ * or write any of the magic bytes before it starts on the IHDR.\r
+ */\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+void PNGAPI\r
+png_set_sig_bytes(png_structp png_ptr, int num_bytes)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_debug(1, "in png_set_sig_bytes\n");\r
+ if (num_bytes > 8)\r
+ png_error(png_ptr, "Too many bytes for PNG signature.");\r
+\r
+ png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);\r
+}\r
+\r
+/* Checks whether the supplied bytes match the PNG signature. We allow\r
+ * checking less than the full 8-byte signature so that those apps that\r
+ * already read the first few bytes of a file to determine the file type\r
+ * can simply check the remaining bytes for extra assurance. Returns\r
+ * an integer less than, equal to, or greater than zero if sig is found,\r
+ * respectively, to be less than, to match, or be greater than the correct\r
+ * PNG signature (this is the same behaviour as strcmp, memcmp, etc).\r
+ */\r
+int PNGAPI\r
+png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)\r
+{\r
+ png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};\r
+ if (num_to_check > 8)\r
+ num_to_check = 8;\r
+ else if (num_to_check < 1)\r
+ return (-1);\r
+\r
+ if (start > 7)\r
+ return (-1);\r
+\r
+ if (start + num_to_check > 8)\r
+ num_to_check = 8 - start;\r
+\r
+ return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));\r
+}\r
+\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+/* (Obsolete) function to check signature bytes. It does not allow one\r
+ * to check a partial signature. This function might be removed in the\r
+ * future - use png_sig_cmp(). Returns true (nonzero) if the file is PNG.\r
+ */\r
+int PNGAPI\r
+png_check_sig(png_bytep sig, int num)\r
+{\r
+ return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num));\r
+}\r
+#endif\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+/* Function to allocate memory for zlib and clear it to 0. */\r
+#ifdef PNG_1_0_X\r
+voidpf PNGAPI\r
+#else\r
+voidpf /* private */\r
+#endif\r
+png_zalloc(voidpf png_ptr, uInt items, uInt size)\r
+{\r
+ png_voidp ptr;\r
+ png_structp p=(png_structp)png_ptr;\r
+ png_uint_32 save_flags=p->flags;\r
+ png_uint_32 num_bytes;\r
+\r
+ if (png_ptr == NULL) return (NULL);\r
+ if (items > PNG_UINT_32_MAX/size)\r
+ {\r
+ png_warning (p, "Potential overflow in png_zalloc()");\r
+ return (NULL);\r
+ }\r
+ num_bytes = (png_uint_32)items * size;\r
+\r
+ p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;\r
+ ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);\r
+ p->flags=save_flags;\r
+\r
+#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO)\r
+ if (ptr == NULL)\r
+ return ((voidpf)ptr);\r
+\r
+ if (num_bytes > (png_uint_32)0x8000L)\r
+ {\r
+ png_memset(ptr, 0, (png_size_t)0x8000L);\r
+ png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0,\r
+ (png_size_t)(num_bytes - (png_uint_32)0x8000L));\r
+ }\r
+ else\r
+ {\r
+ png_memset(ptr, 0, (png_size_t)num_bytes);\r
+ }\r
+#endif\r
+ return ((voidpf)ptr);\r
+}\r
+\r
+/* function to free memory for zlib */\r
+#ifdef PNG_1_0_X\r
+void PNGAPI\r
+#else\r
+void /* private */\r
+#endif\r
+png_zfree(voidpf png_ptr, voidpf ptr)\r
+{\r
+ png_free((png_structp)png_ptr, (png_voidp)ptr);\r
+}\r
+\r
+/* Reset the CRC variable to 32 bits of 1's. Care must be taken\r
+ * in case CRC is > 32 bits to leave the top bits 0.\r
+ */\r
+void /* PRIVATE */\r
+png_reset_crc(png_structp png_ptr)\r
+{\r
+ png_ptr->crc = crc32(0, Z_NULL, 0);\r
+}\r
+\r
+/* Calculate the CRC over a section of data. We can only pass as\r
+ * much data to this routine as the largest single buffer size. We\r
+ * also check that this data will actually be used before going to the\r
+ * trouble of calculating it.\r
+ */\r
+void /* PRIVATE */\r
+png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)\r
+{\r
+ int need_crc = 1;\r
+\r
+ if (png_ptr->chunk_name[0] & 0x20) /* ancillary */\r
+ {\r
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==\r
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))\r
+ need_crc = 0;\r
+ }\r
+ else /* critical */\r
+ {\r
+ if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)\r
+ need_crc = 0;\r
+ }\r
+\r
+ if (need_crc)\r
+ png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);\r
+}\r
+\r
+/* Allocate the memory for an info_struct for the application. We don't\r
+ * really need the png_ptr, but it could potentially be useful in the\r
+ * future. This should be used in favour of malloc(png_sizeof(png_info))\r
+ * and png_info_init() so that applications that want to use a shared\r
+ * libpng don't have to be recompiled if png_info changes size.\r
+ */\r
+png_infop PNGAPI\r
+png_create_info_struct(png_structp png_ptr)\r
+{\r
+ png_infop info_ptr;\r
+\r
+ png_debug(1, "in png_create_info_struct\n");\r
+ if (png_ptr == NULL) return (NULL);\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,\r
+ png_ptr->malloc_fn, png_ptr->mem_ptr);\r
+#else\r
+ info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);\r
+#endif\r
+ if (info_ptr != NULL)\r
+ png_info_init_3(&info_ptr, png_sizeof(png_info));\r
+\r
+ return (info_ptr);\r
+}\r
+\r
+/* This function frees the memory associated with a single info struct.\r
+ * Normally, one would use either png_destroy_read_struct() or\r
+ * png_destroy_write_struct() to free an info struct, but this may be\r
+ * useful for some applications.\r
+ */\r
+void PNGAPI\r
+png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)\r
+{\r
+ png_infop info_ptr = NULL;\r
+ if (png_ptr == NULL) return;\r
+\r
+ png_debug(1, "in png_destroy_info_struct\n");\r
+ if (info_ptr_ptr != NULL)\r
+ info_ptr = *info_ptr_ptr;\r
+\r
+ if (info_ptr != NULL)\r
+ {\r
+ png_info_destroy(png_ptr, info_ptr);\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,\r
+ png_ptr->mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)info_ptr);\r
+#endif\r
+ *info_ptr_ptr = NULL;\r
+ }\r
+}\r
+\r
+/* Initialize the info structure. This is now an internal function (0.89)\r
+ * and applications using it are urged to use png_create_info_struct()\r
+ * instead.\r
+ */\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+#undef png_info_init\r
+void PNGAPI\r
+png_info_init(png_infop info_ptr)\r
+{\r
+ /* We only come here via pre-1.0.12-compiled applications */\r
+ png_info_init_3(&info_ptr, 0);\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)\r
+{\r
+ png_infop info_ptr = *ptr_ptr;\r
+\r
+ if (info_ptr == NULL) return;\r
+\r
+ png_debug(1, "in png_info_init_3\n");\r
+\r
+ if (png_sizeof(png_info) > png_info_struct_size)\r
+ {\r
+ png_destroy_struct(info_ptr);\r
+ info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);\r
+ *ptr_ptr = info_ptr;\r
+ }\r
+\r
+ /* set everything to 0 */\r
+ png_memset(info_ptr, 0, png_sizeof(png_info));\r
+}\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+void PNGAPI\r
+png_data_freer(png_structp png_ptr, png_infop info_ptr,\r
+ int freer, png_uint_32 mask)\r
+{\r
+ png_debug(1, "in png_data_freer\n");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+ if (freer == PNG_DESTROY_WILL_FREE_DATA)\r
+ info_ptr->free_me |= mask;\r
+ else if (freer == PNG_USER_WILL_FREE_DATA)\r
+ info_ptr->free_me &= ~mask;\r
+ else\r
+ png_warning(png_ptr,\r
+ "Unknown freer parameter in png_data_freer.");\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,\r
+ int num)\r
+{\r
+ png_debug(1, "in png_free_data\n");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+/* free text item num or (if num == -1) all text items */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_TEXT)\r
+#endif\r
+{\r
+ if (num != -1)\r
+ {\r
+ if (info_ptr->text && info_ptr->text[num].key)\r
+ {\r
+ png_free(png_ptr, info_ptr->text[num].key);\r
+ info_ptr->text[num].key = NULL;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ int i;\r
+ for (i = 0; i < info_ptr->num_text; i++)\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);\r
+ png_free(png_ptr, info_ptr->text);\r
+ info_ptr->text = NULL;\r
+ info_ptr->num_text=0;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+/* free any tRNS entry */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)\r
+#else\r
+if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))\r
+#endif\r
+{\r
+ png_free(png_ptr, info_ptr->trans);\r
+ info_ptr->trans = NULL;\r
+ info_ptr->valid &= ~PNG_INFO_tRNS;\r
+#ifndef PNG_FREE_ME_SUPPORTED\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sCAL_SUPPORTED)\r
+/* free any sCAL entry */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_SCAL)\r
+#endif\r
+{\r
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ png_free(png_ptr, info_ptr->scal_s_width);\r
+ png_free(png_ptr, info_ptr->scal_s_height);\r
+ info_ptr->scal_s_width = NULL;\r
+ info_ptr->scal_s_height = NULL;\r
+#endif\r
+ info_ptr->valid &= ~PNG_INFO_sCAL;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+/* free any pCAL entry */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_PCAL)\r
+#endif\r
+{\r
+ png_free(png_ptr, info_ptr->pcal_purpose);\r
+ png_free(png_ptr, info_ptr->pcal_units);\r
+ info_ptr->pcal_purpose = NULL;\r
+ info_ptr->pcal_units = NULL;\r
+ if (info_ptr->pcal_params != NULL)\r
+ {\r
+ int i;\r
+ for (i = 0; i < (int)info_ptr->pcal_nparams; i++)\r
+ {\r
+ png_free(png_ptr, info_ptr->pcal_params[i]);\r
+ info_ptr->pcal_params[i]=NULL;\r
+ }\r
+ png_free(png_ptr, info_ptr->pcal_params);\r
+ info_ptr->pcal_params = NULL;\r
+ }\r
+ info_ptr->valid &= ~PNG_INFO_pCAL;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+/* free any iCCP entry */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_ICCP)\r
+#endif\r
+{\r
+ png_free(png_ptr, info_ptr->iccp_name);\r
+ png_free(png_ptr, info_ptr->iccp_profile);\r
+ info_ptr->iccp_name = NULL;\r
+ info_ptr->iccp_profile = NULL;\r
+ info_ptr->valid &= ~PNG_INFO_iCCP;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+/* free a given sPLT entry, or (if num == -1) all sPLT entries */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_SPLT)\r
+#endif\r
+{\r
+ if (num != -1)\r
+ {\r
+ if (info_ptr->splt_palettes)\r
+ {\r
+ png_free(png_ptr, info_ptr->splt_palettes[num].name);\r
+ png_free(png_ptr, info_ptr->splt_palettes[num].entries);\r
+ info_ptr->splt_palettes[num].name = NULL;\r
+ info_ptr->splt_palettes[num].entries = NULL;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (info_ptr->splt_palettes_num)\r
+ {\r
+ int i;\r
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);\r
+\r
+ png_free(png_ptr, info_ptr->splt_palettes);\r
+ info_ptr->splt_palettes = NULL;\r
+ info_ptr->splt_palettes_num = 0;\r
+ }\r
+ info_ptr->valid &= ~PNG_INFO_sPLT;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_ptr->unknown_chunk.data)\r
+ {\r
+ png_free(png_ptr, png_ptr->unknown_chunk.data);\r
+ png_ptr->unknown_chunk.data = NULL;\r
+ }\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_UNKN)\r
+#endif\r
+{\r
+ if (num != -1)\r
+ {\r
+ if (info_ptr->unknown_chunks)\r
+ {\r
+ png_free(png_ptr, info_ptr->unknown_chunks[num].data);\r
+ info_ptr->unknown_chunks[num].data = NULL;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ int i;\r
+\r
+ if (info_ptr->unknown_chunks_num)\r
+ {\r
+ for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);\r
+\r
+ png_free(png_ptr, info_ptr->unknown_chunks);\r
+ info_ptr->unknown_chunks = NULL;\r
+ info_ptr->unknown_chunks_num = 0;\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+/* free any hIST entry */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_HIST) & info_ptr->free_me)\r
+#else\r
+if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))\r
+#endif\r
+{\r
+ png_free(png_ptr, info_ptr->hist);\r
+ info_ptr->hist = NULL;\r
+ info_ptr->valid &= ~PNG_INFO_hIST;\r
+#ifndef PNG_FREE_ME_SUPPORTED\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_HIST;\r
+#endif\r
+}\r
+#endif\r
+\r
+/* free any PLTE entry that was internally allocated */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)\r
+#else\r
+if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))\r
+#endif\r
+{\r
+ png_zfree(png_ptr, info_ptr->palette);\r
+ info_ptr->palette = NULL;\r
+ info_ptr->valid &= ~PNG_INFO_PLTE;\r
+#ifndef PNG_FREE_ME_SUPPORTED\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;\r
+#endif\r
+ info_ptr->num_palette = 0;\r
+}\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+/* free any image bits attached to the info structure */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)\r
+#else\r
+if (mask & PNG_FREE_ROWS)\r
+#endif\r
+{\r
+ if (info_ptr->row_pointers)\r
+ {\r
+ int row;\r
+ for (row = 0; row < (int)info_ptr->height; row++)\r
+ {\r
+ png_free(png_ptr, info_ptr->row_pointers[row]);\r
+ info_ptr->row_pointers[row]=NULL;\r
+ }\r
+ png_free(png_ptr, info_ptr->row_pointers);\r
+ info_ptr->row_pointers=NULL;\r
+ }\r
+ info_ptr->valid &= ~PNG_INFO_IDAT;\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ if (num == -1)\r
+ info_ptr->free_me &= ~mask;\r
+ else\r
+ info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);\r
+#endif\r
+}\r
+\r
+/* This is an internal routine to free any memory that the info struct is\r
+ * pointing to before re-using it or freeing the struct itself. Recall\r
+ * that png_free() checks for NULL pointers for us.\r
+ */\r
+void /* PRIVATE */\r
+png_info_destroy(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_info_destroy\n");\r
+\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_ptr->num_chunk_list)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunk_list);\r
+ png_ptr->chunk_list=NULL;\r
+ png_ptr->num_chunk_list = 0;\r
+ }\r
+#endif\r
+\r
+ png_info_init_3(&info_ptr, png_sizeof(png_info));\r
+}\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
+\r
+/* This function returns a pointer to the io_ptr associated with the user\r
+ * functions. The application should free any memory associated with this\r
+ * pointer before png_write_destroy() or png_read_destroy() are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_io_ptr(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL) return (NULL);\r
+ return (png_ptr->io_ptr);\r
+}\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+#if !defined(PNG_NO_STDIO)\r
+/* Initialize the default input/output functions for the PNG file. If you\r
+ * use your own read or write routines, you can call either png_set_read_fn()\r
+ * or png_set_write_fn() instead of png_init_io(). If you have defined\r
+ * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't\r
+ * necessarily available.\r
+ */\r
+void PNGAPI\r
+png_init_io(png_structp png_ptr, png_FILE_p fp)\r
+{\r
+ png_debug(1, "in png_init_io\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->io_ptr = (png_voidp)fp;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_TIME_RFC1123_SUPPORTED)\r
+/* Convert the supplied time into an RFC 1123 string suitable for use in\r
+ * a "Creation Time" or other text-based time string.\r
+ */\r
+png_charp PNGAPI\r
+png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)\r
+{\r
+ static PNG_CONST char short_months[12][4] =\r
+ {"Jan", "Feb", "Mar", "Apr", "May", "Jun",\r
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};\r
+\r
+ if (png_ptr == NULL) return (NULL);\r
+ if (png_ptr->time_buffer == NULL)\r
+ {\r
+ png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*\r
+ png_sizeof(char)));\r
+ }\r
+\r
+#if defined(_WIN32_WCE)\r
+ {\r
+ wchar_t time_buf[29];\r
+ wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"),\r
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],\r
+ ptime->year, ptime->hour % 24, ptime->minute % 60,\r
+ ptime->second % 61);\r
+ WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29,\r
+ NULL, NULL);\r
+ }\r
+#else\r
+#ifdef USE_FAR_KEYWORD\r
+ {\r
+ char near_time_buf[29];\r
+ png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",\r
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],\r
+ ptime->year, ptime->hour % 24, ptime->minute % 60,\r
+ ptime->second % 61);\r
+ png_memcpy(png_ptr->time_buffer, near_time_buf,\r
+ 29*png_sizeof(char));\r
+ }\r
+#else\r
+ png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",\r
+ ptime->day % 32, short_months[(ptime->month - 1) % 12],\r
+ ptime->year, ptime->hour % 24, ptime->minute % 60,\r
+ ptime->second % 61);\r
+#endif\r
+#endif /* _WIN32_WCE */\r
+ return ((png_charp)png_ptr->time_buffer);\r
+}\r
+#endif /* PNG_TIME_RFC1123_SUPPORTED */\r
+\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
+\r
+png_charp PNGAPI\r
+png_get_copyright(png_structp png_ptr)\r
+{\r
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */\r
+ return ((png_charp) "\n libpng version 1.2.33 - October 31, 2008\n\\r
+ Copyright (c) 1998-2008 Glenn Randers-Pehrson\n\\r
+ Copyright (c) 1996-1997 Andreas Dilger\n\\r
+ Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");\r
+}\r
+\r
+/* The following return the library version as a short string in the\r
+ * format 1.0.0 through 99.99.99zz. To get the version of *.h files\r
+ * used with your application, print out PNG_LIBPNG_VER_STRING, which\r
+ * is defined in png.h.\r
+ * Note: now there is no difference between png_get_libpng_ver() and\r
+ * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,\r
+ * it is guaranteed that png.c uses the correct version of png.h.\r
+ */\r
+png_charp PNGAPI\r
+png_get_libpng_ver(png_structp png_ptr)\r
+{\r
+ /* Version of *.c files used when building libpng */\r
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */\r
+ return ((png_charp) PNG_LIBPNG_VER_STRING);\r
+}\r
+\r
+png_charp PNGAPI\r
+png_get_header_ver(png_structp png_ptr)\r
+{\r
+ /* Version of *.h files used when building libpng */\r
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */\r
+ return ((png_charp) PNG_LIBPNG_VER_STRING);\r
+}\r
+\r
+png_charp PNGAPI\r
+png_get_header_version(png_structp png_ptr)\r
+{\r
+ /* Returns longer string containing both version and date */\r
+ png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */\r
+ return ((png_charp) PNG_HEADER_VERSION_STRING\r
+#ifndef PNG_READ_SUPPORTED\r
+ " (NO READ SUPPORT)"\r
+#endif\r
+ "\n");\r
+}\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+int PNGAPI\r
+png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)\r
+{\r
+ /* check chunk_name and return "keep" value if it's on the list, else 0 */\r
+ int i;\r
+ png_bytep p;\r
+ if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)\r
+ return 0;\r
+ p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;\r
+ for (i = png_ptr->num_chunk_list; i; i--, p -= 5)\r
+ if (!png_memcmp(chunk_name, p, 4))\r
+ return ((int)*(p + 4));\r
+ return 0;\r
+}\r
+#endif\r
+\r
+/* This function, added to libpng-1.0.6g, is untested. */\r
+int PNGAPI\r
+png_reset_zstream(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL) return Z_STREAM_ERROR;\r
+ return (inflateReset(&png_ptr->zstream));\r
+}\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
+\r
+/* This function was added to libpng-1.0.7 */\r
+png_uint_32 PNGAPI\r
+png_access_version_number(void)\r
+{\r
+ /* Version of *.c files used when building libpng */\r
+ return((png_uint_32) PNG_LIBPNG_VER);\r
+}\r
+\r
+\r
+#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)\r
+#if !defined(PNG_1_0_X)\r
+/* this function was added to libpng 1.2.0 */\r
+int PNGAPI\r
+png_mmx_support(void)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ return -1;\r
+}\r
+#endif /* PNG_1_0_X */\r
+#endif /* PNG_READ_SUPPORTED && PNG_ASSEMBLER_CODE_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+#ifdef PNG_SIZE_T\r
+/* Added at libpng version 1.2.6 */\r
+ PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));\r
+png_size_t PNGAPI\r
+png_convert_size(size_t size)\r
+{\r
+ if (size > (png_size_t)-1)\r
+ PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */\r
+ return ((png_size_t)size);\r
+}\r
+#endif /* PNG_SIZE_T */\r
+#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */\r
--- /dev/null
+/* png.h - header file for PNG reference library\r
+ *\r
+ * libpng version 1.2.33 - October 31, 2008\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * Authors and maintainers:\r
+ * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat\r
+ * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger\r
+ * libpng versions 0.97, January 1998, through 1.2.33 - October 31, 2008: Glenn\r
+ * See also "Contributing Authors", below.\r
+ *\r
+ * Note about libpng version numbers:\r
+ *\r
+ * Due to various miscommunications, unforeseen code incompatibilities\r
+ * and occasional factors outside the authors' control, version numbering\r
+ * on the library has not always been consistent and straightforward.\r
+ * The following table summarizes matters since version 0.89c, which was\r
+ * the first widely used release:\r
+ *\r
+ * source png.h png.h shared-lib\r
+ * version string int version\r
+ * ------- ------ ----- ----------\r
+ * 0.89c "1.0 beta 3" 0.89 89 1.0.89\r
+ * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90]\r
+ * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95]\r
+ * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96]\r
+ * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97]\r
+ * 0.97c 0.97 97 2.0.97\r
+ * 0.98 0.98 98 2.0.98\r
+ * 0.99 0.99 98 2.0.99\r
+ * 0.99a-m 0.99 99 2.0.99\r
+ * 1.00 1.00 100 2.1.0 [100 should be 10000]\r
+ * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000]\r
+ * 1.0.1 png.h string is 10001 2.1.0\r
+ * 1.0.1a-e identical to the 10002 from here on, the shared library\r
+ * 1.0.2 source version) 10002 is 2.V where V is the source code\r
+ * 1.0.2a-b 10003 version, except as noted.\r
+ * 1.0.3 10003\r
+ * 1.0.3a-d 10004\r
+ * 1.0.4 10004\r
+ * 1.0.4a-f 10005\r
+ * 1.0.5 (+ 2 patches) 10005\r
+ * 1.0.5a-d 10006\r
+ * 1.0.5e-r 10100 (not source compatible)\r
+ * 1.0.5s-v 10006 (not binary compatible)\r
+ * 1.0.6 (+ 3 patches) 10006 (still binary incompatible)\r
+ * 1.0.6d-f 10007 (still binary incompatible)\r
+ * 1.0.6g 10007\r
+ * 1.0.6h 10007 10.6h (testing xy.z so-numbering)\r
+ * 1.0.6i 10007 10.6i\r
+ * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0)\r
+ * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible)\r
+ * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible)\r
+ * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible)\r
+ * 1.0.7 1 10007 (still compatible)\r
+ * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4\r
+ * 1.0.8rc1 1 10008 2.1.0.8rc1\r
+ * 1.0.8 1 10008 2.1.0.8\r
+ * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6\r
+ * 1.0.9rc1 1 10009 2.1.0.9rc1\r
+ * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10\r
+ * 1.0.9rc2 1 10009 2.1.0.9rc2\r
+ * 1.0.9 1 10009 2.1.0.9\r
+ * 1.0.10beta1 1 10010 2.1.0.10beta1\r
+ * 1.0.10rc1 1 10010 2.1.0.10rc1\r
+ * 1.0.10 1 10010 2.1.0.10\r
+ * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3\r
+ * 1.0.11rc1 1 10011 2.1.0.11rc1\r
+ * 1.0.11 1 10011 2.1.0.11\r
+ * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2\r
+ * 1.0.12rc1 2 10012 2.1.0.12rc1\r
+ * 1.0.12 2 10012 2.1.0.12\r
+ * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned)\r
+ * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2\r
+ * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5\r
+ * 1.2.0rc1 3 10200 3.1.2.0rc1\r
+ * 1.2.0 3 10200 3.1.2.0\r
+ * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4\r
+ * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2\r
+ * 1.2.1 3 10201 3.1.2.1\r
+ * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6\r
+ * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1\r
+ * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1\r
+ * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1\r
+ * 1.0.13 10 10013 10.so.0.1.0.13\r
+ * 1.2.2 12 10202 12.so.0.1.2.2\r
+ * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6\r
+ * 1.2.3 12 10203 12.so.0.1.2.3\r
+ * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3\r
+ * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1\r
+ * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1\r
+ * 1.0.14 10 10014 10.so.0.1.0.14\r
+ * 1.2.4 13 10204 12.so.0.1.2.4\r
+ * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2\r
+ * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3\r
+ * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3\r
+ * 1.0.15 10 10015 10.so.0.1.0.15\r
+ * 1.2.5 13 10205 12.so.0.1.2.5\r
+ * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4\r
+ * 1.0.16 10 10016 10.so.0.1.0.16\r
+ * 1.2.6 13 10206 12.so.0.1.2.6\r
+ * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2\r
+ * 1.0.17rc1 10 10017 10.so.0.1.0.17rc1\r
+ * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1\r
+ * 1.0.17 10 10017 10.so.0.1.0.17\r
+ * 1.2.7 13 10207 12.so.0.1.2.7\r
+ * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5\r
+ * 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5\r
+ * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5\r
+ * 1.0.18 10 10018 10.so.0.1.0.18\r
+ * 1.2.8 13 10208 12.so.0.1.2.8\r
+ * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3\r
+ * 1.2.9beta4-11 13 10209 12.so.0.9[.0]\r
+ * 1.2.9rc1 13 10209 12.so.0.9[.0]\r
+ * 1.2.9 13 10209 12.so.0.9[.0]\r
+ * 1.2.10beta1-8 13 10210 12.so.0.10[.0]\r
+ * 1.2.10rc1-3 13 10210 12.so.0.10[.0]\r
+ * 1.2.10 13 10210 12.so.0.10[.0]\r
+ * 1.2.11beta1-4 13 10211 12.so.0.11[.0]\r
+ * 1.0.19rc1-5 10 10019 10.so.0.19[.0]\r
+ * 1.2.11rc1-5 13 10211 12.so.0.11[.0]\r
+ * 1.0.19 10 10019 10.so.0.19[.0]\r
+ * 1.2.11 13 10211 12.so.0.11[.0]\r
+ * 1.0.20 10 10020 10.so.0.20[.0]\r
+ * 1.2.12 13 10212 12.so.0.12[.0]\r
+ * 1.2.13beta1 13 10213 12.so.0.13[.0]\r
+ * 1.0.21 10 10021 10.so.0.21[.0]\r
+ * 1.2.13 13 10213 12.so.0.13[.0]\r
+ * 1.2.14beta1-2 13 10214 12.so.0.14[.0]\r
+ * 1.0.22rc1 10 10022 10.so.0.22[.0]\r
+ * 1.2.14rc1 13 10214 12.so.0.14[.0]\r
+ * 1.0.22 10 10022 10.so.0.22[.0]\r
+ * 1.2.14 13 10214 12.so.0.14[.0]\r
+ * 1.2.15beta1-6 13 10215 12.so.0.15[.0]\r
+ * 1.0.23rc1-5 10 10023 10.so.0.23[.0]\r
+ * 1.2.15rc1-5 13 10215 12.so.0.15[.0]\r
+ * 1.0.23 10 10023 10.so.0.23[.0]\r
+ * 1.2.15 13 10215 12.so.0.15[.0]\r
+ * 1.2.16beta1-2 13 10216 12.so.0.16[.0]\r
+ * 1.2.16rc1 13 10216 12.so.0.16[.0]\r
+ * 1.0.24 10 10024 10.so.0.24[.0]\r
+ * 1.2.16 13 10216 12.so.0.16[.0]\r
+ * 1.2.17beta1-2 13 10217 12.so.0.17[.0]\r
+ * 1.0.25rc1 10 10025 10.so.0.25[.0]\r
+ * 1.2.17rc1-3 13 10217 12.so.0.17[.0]\r
+ * 1.0.25 10 10025 10.so.0.25[.0]\r
+ * 1.2.17 13 10217 12.so.0.17[.0]\r
+ * 1.0.26 10 10026 10.so.0.26[.0]\r
+ * 1.2.18 13 10218 12.so.0.18[.0]\r
+ * 1.2.19beta1-31 13 10219 12.so.0.19[.0]\r
+ * 1.0.27rc1-6 10 10027 10.so.0.27[.0]\r
+ * 1.2.19rc1-6 13 10219 12.so.0.19[.0]\r
+ * 1.0.27 10 10027 10.so.0.27[.0]\r
+ * 1.2.19 13 10219 12.so.0.19[.0]\r
+ * 1.2.20beta01-04 13 10220 12.so.0.20[.0]\r
+ * 1.0.28rc1-6 10 10028 10.so.0.28[.0]\r
+ * 1.2.20rc1-6 13 10220 12.so.0.20[.0]\r
+ * 1.0.28 10 10028 10.so.0.28[.0]\r
+ * 1.2.20 13 10220 12.so.0.20[.0]\r
+ * 1.2.21beta1-2 13 10221 12.so.0.21[.0]\r
+ * 1.2.21rc1-3 13 10221 12.so.0.21[.0]\r
+ * 1.0.29 10 10029 10.so.0.29[.0]\r
+ * 1.2.21 13 10221 12.so.0.21[.0]\r
+ * 1.2.22beta1-4 13 10222 12.so.0.22[.0]\r
+ * 1.0.30rc1 10 10030 10.so.0.30[.0]\r
+ * 1.2.22rc1 13 10222 12.so.0.22[.0]\r
+ * 1.0.30 10 10030 10.so.0.30[.0]\r
+ * 1.2.22 13 10222 12.so.0.22[.0]\r
+ * 1.2.23beta01-05 13 10223 12.so.0.23[.0]\r
+ * 1.2.23rc01 13 10223 12.so.0.23[.0]\r
+ * 1.2.23 13 10223 12.so.0.23[.0]\r
+ * 1.2.24beta01-02 13 10224 12.so.0.24[.0]\r
+ * 1.2.24rc01 13 10224 12.so.0.24[.0]\r
+ * 1.2.24 13 10224 12.so.0.24[.0]\r
+ * 1.2.25beta01-06 13 10225 12.so.0.25[.0]\r
+ * 1.2.25rc01-02 13 10225 12.so.0.25[.0]\r
+ * 1.0.31 10 10031 10.so.0.31[.0]\r
+ * 1.2.25 13 10225 12.so.0.25[.0]\r
+ * 1.2.26beta01-06 13 10226 12.so.0.26[.0]\r
+ * 1.2.26rc01 13 10226 12.so.0.26[.0]\r
+ * 1.2.26 13 10226 12.so.0.26[.0]\r
+ * 1.0.32 10 10032 10.so.0.32[.0]\r
+ * 1.2.27beta01-06 13 10227 12.so.0.27[.0]\r
+ * 1.2.27rc01 13 10227 12.so.0.27[.0]\r
+ * 1.0.33 10 10033 10.so.0.33[.0]\r
+ * 1.2.27 13 10227 12.so.0.27[.0]\r
+ * 1.0.34 10 10034 10.so.0.34[.0]\r
+ * 1.2.28 13 10228 12.so.0.28[.0]\r
+ * 1.2.29beta01-03 13 10229 12.so.0.29[.0]\r
+ * 1.2.29rc01 13 10229 12.so.0.29[.0]\r
+ * 1.0.35 10 10035 10.so.0.35[.0]\r
+ * 1.2.29 13 10229 12.so.0.29[.0]\r
+ * 1.0.37 10 10037 10.so.0.37[.0]\r
+ * 1.2.30beta01-04 13 10230 12.so.0.30[.0]\r
+ * 1.0.38rc01-08 10 10038 10.so.0.38[.0]\r
+ * 1.2.30rc01-08 13 10230 12.so.0.30[.0]\r
+ * 1.0.38 10 10038 10.so.0.38[.0]\r
+ * 1.2.30 13 10230 12.so.0.30[.0]\r
+ * 1.0.39rc01-03 10 10039 10.so.0.39[.0]\r
+ * 1.2.31rc01-03 13 10231 12.so.0.31[.0]\r
+ * 1.0.39 10 10039 10.so.0.39[.0]\r
+ * 1.2.31 13 10231 12.so.0.31[.0]\r
+ * 1.2.32beta01-02 13 10232 12.so.0.32[.0]\r
+ * 1.0.40rc01 10 10040 10.so.0.40[.0]\r
+ * 1.2.32rc01 13 10232 12.so.0.32[.0]\r
+ * 1.0.40 10 10040 10.so.0.40[.0]\r
+ * 1.2.32 13 10232 12.so.0.32[.0]\r
+ * 1.2.33beta01-02 13 10233 12.so.0.33[.0]\r
+ * 1.2.33rc01-02 13 10233 12.so.0.33[.0]\r
+ * 1.0.41rc01 10 10041 10.so.0.41[.0]\r
+ * 1.2.33 13 10233 12.so.0.33[.0]\r
+ * 1.0.41 10 10041 10.so.0.41[.0]\r
+ *\r
+ * Henceforth the source version will match the shared-library major\r
+ * and minor numbers; the shared-library major version number will be\r
+ * used for changes in backward compatibility, as it is intended. The\r
+ * PNG_LIBPNG_VER macro, which is not used within libpng but is available\r
+ * for applications, is an unsigned integer of the form xyyzz corresponding\r
+ * to the source version x.y.z (leading zeros in y and z). Beta versions\r
+ * were given the previous public release number plus a letter, until\r
+ * version 1.0.6j; from then on they were given the upcoming public\r
+ * release number plus "betaNN" or "rcNN".\r
+ *\r
+ * Binary incompatibility exists only when applications make direct access\r
+ * to the info_ptr or png_ptr members through png.h, and the compiled\r
+ * application is loaded with a different version of the library.\r
+ *\r
+ * DLLNUM will change each time there are forward or backward changes\r
+ * in binary compatibility (e.g., when a new feature is added).\r
+ *\r
+ * See libpng.txt or libpng.3 for more information. The PNG specification\r
+ * is available as a W3C Recommendation and as an ISO Specification,\r
+ * <http://www.w3.org/TR/2003/REC-PNG-20031110/\r
+ */\r
+\r
+/*\r
+ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:\r
+ *\r
+ * If you modify libpng you may insert additional notices immediately following\r
+ * this sentence.\r
+ *\r
+ * libpng versions 1.2.6, August 15, 2004, through 1.2.33, October 31, 2008, are\r
+ * Copyright (c) 2004, 2006-2008 Glenn Randers-Pehrson, and are\r
+ * distributed according to the same disclaimer and license as libpng-1.2.5\r
+ * with the following individual added to the list of Contributing Authors:\r
+ *\r
+ * Cosmin Truta\r
+ *\r
+ * libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are\r
+ * Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are\r
+ * distributed according to the same disclaimer and license as libpng-1.0.6\r
+ * with the following individuals added to the list of Contributing Authors:\r
+ *\r
+ * Simon-Pierre Cadieux\r
+ * Eric S. Raymond\r
+ * Gilles Vollant\r
+ *\r
+ * and with the following additions to the disclaimer:\r
+ *\r
+ * There is no warranty against interference with your enjoyment of the\r
+ * library or against infringement. There is no warranty that our\r
+ * efforts or the library will fulfill any of your particular purposes\r
+ * or needs. This library is provided with all faults, and the entire\r
+ * risk of satisfactory quality, performance, accuracy, and effort is with\r
+ * the user.\r
+ *\r
+ * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are\r
+ * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson, and are\r
+ * distributed according to the same disclaimer and license as libpng-0.96,\r
+ * with the following individuals added to the list of Contributing Authors:\r
+ *\r
+ * Tom Lane\r
+ * Glenn Randers-Pehrson\r
+ * Willem van Schaik\r
+ *\r
+ * libpng versions 0.89, June 1996, through 0.96, May 1997, are\r
+ * Copyright (c) 1996, 1997 Andreas Dilger\r
+ * Distributed according to the same disclaimer and license as libpng-0.88,\r
+ * with the following individuals added to the list of Contributing Authors:\r
+ *\r
+ * John Bowler\r
+ * Kevin Bracey\r
+ * Sam Bushell\r
+ * Magnus Holmgren\r
+ * Greg Roelofs\r
+ * Tom Tanner\r
+ *\r
+ * libpng versions 0.5, May 1995, through 0.88, January 1996, are\r
+ * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\r
+ *\r
+ * For the purposes of this copyright and license, "Contributing Authors"\r
+ * is defined as the following set of individuals:\r
+ *\r
+ * Andreas Dilger\r
+ * Dave Martindale\r
+ * Guy Eric Schalnat\r
+ * Paul Schmidt\r
+ * Tim Wegner\r
+ *\r
+ * The PNG Reference Library is supplied "AS IS". The Contributing Authors\r
+ * and Group 42, Inc. disclaim all warranties, expressed or implied,\r
+ * including, without limitation, the warranties of merchantability and of\r
+ * fitness for any purpose. The Contributing Authors and Group 42, Inc.\r
+ * assume no liability for direct, indirect, incidental, special, exemplary,\r
+ * or consequential damages, which may result from the use of the PNG\r
+ * Reference Library, even if advised of the possibility of such damage.\r
+ *\r
+ * Permission is hereby granted to use, copy, modify, and distribute this\r
+ * source code, or portions hereof, for any purpose, without fee, subject\r
+ * to the following restrictions:\r
+ *\r
+ * 1. The origin of this source code must not be misrepresented.\r
+ *\r
+ * 2. Altered versions must be plainly marked as such and\r
+ * must not be misrepresented as being the original source.\r
+ *\r
+ * 3. This Copyright notice may not be removed or altered from\r
+ * any source or altered source distribution.\r
+ *\r
+ * The Contributing Authors and Group 42, Inc. specifically permit, without\r
+ * fee, and encourage the use of this source code as a component to\r
+ * supporting the PNG file format in commercial products. If you use this\r
+ * source code in a product, acknowledgment is not required but would be\r
+ * appreciated.\r
+ */\r
+\r
+/*\r
+ * A "png_get_copyright" function is available, for convenient use in "about"\r
+ * boxes and the like:\r
+ *\r
+ * printf("%s",png_get_copyright(NULL));\r
+ *\r
+ * Also, the PNG logo (in PNG format, of course) is supplied in the\r
+ * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).\r
+ */\r
+\r
+/*\r
+ * Libpng is OSI Certified Open Source Software. OSI Certified is a\r
+ * certification mark of the Open Source Initiative.\r
+ */\r
+\r
+/*\r
+ * The contributing authors would like to thank all those who helped\r
+ * with testing, bug fixes, and patience. This wouldn't have been\r
+ * possible without all of you.\r
+ *\r
+ * Thanks to Frank J. T. Wojcik for helping with the documentation.\r
+ */\r
+\r
+/*\r
+ * Y2K compliance in libpng:\r
+ * =========================\r
+ *\r
+ * October 31, 2008\r
+ *\r
+ * Since the PNG Development group is an ad-hoc body, we can't make\r
+ * an official declaration.\r
+ *\r
+ * This is your unofficial assurance that libpng from version 0.71 and\r
+ * upward through 1.2.33 are Y2K compliant. It is my belief that earlier\r
+ * versions were also Y2K compliant.\r
+ *\r
+ * Libpng only has three year fields. One is a 2-byte unsigned integer\r
+ * that will hold years up to 65535. The other two hold the date in text\r
+ * format, and will hold years up to 9999.\r
+ *\r
+ * The integer is\r
+ * "png_uint_16 year" in png_time_struct.\r
+ *\r
+ * The strings are\r
+ * "png_charp time_buffer" in png_struct and\r
+ * "near_time_buffer", which is a local character string in png.c.\r
+ *\r
+ * There are seven time-related functions:\r
+ * png.c: png_convert_to_rfc_1123() in png.c\r
+ * (formerly png_convert_to_rfc_1152() in error)\r
+ * png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c\r
+ * png_convert_from_time_t() in pngwrite.c\r
+ * png_get_tIME() in pngget.c\r
+ * png_handle_tIME() in pngrutil.c, called in pngread.c\r
+ * png_set_tIME() in pngset.c\r
+ * png_write_tIME() in pngwutil.c, called in pngwrite.c\r
+ *\r
+ * All handle dates properly in a Y2K environment. The\r
+ * png_convert_from_time_t() function calls gmtime() to convert from system\r
+ * clock time, which returns (year - 1900), which we properly convert to\r
+ * the full 4-digit year. There is a possibility that applications using\r
+ * libpng are not passing 4-digit years into the png_convert_to_rfc_1123()\r
+ * function, or that they are incorrectly passing only a 2-digit year\r
+ * instead of "year - 1900" into the png_convert_from_struct_tm() function,\r
+ * but this is not under our control. The libpng documentation has always\r
+ * stated that it works with 4-digit years, and the APIs have been\r
+ * documented as such.\r
+ *\r
+ * The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned\r
+ * integer to hold the year, and can hold years as large as 65535.\r
+ *\r
+ * zlib, upon which libpng depends, is also Y2K compliant. It contains\r
+ * no date-related code.\r
+ *\r
+ * Glenn Randers-Pehrson\r
+ * libpng maintainer\r
+ * PNG Development Group\r
+ */\r
+\r
+#ifndef PNG_H\r
+#define PNG_H\r
+\r
+/* This is not the place to learn how to use libpng. The file libpng.txt\r
+ * describes how to use libpng, and the file example.c summarizes it\r
+ * with some code on which to build. This file is useful for looking\r
+ * at the actual function definitions and structure components.\r
+ */\r
+\r
+/* Version information for png.h - this should match the version in png.c */\r
+#define PNG_LIBPNG_VER_STRING "1.2.33"\r
+#define PNG_HEADER_VERSION_STRING \\r
+ " libpng version 1.2.33 - October 31, 2008\n"\r
+\r
+#define PNG_LIBPNG_VER_SONUM 0\r
+#define PNG_LIBPNG_VER_DLLNUM 13\r
+\r
+/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */\r
+#define PNG_LIBPNG_VER_MAJOR 1\r
+#define PNG_LIBPNG_VER_MINOR 2\r
+#define PNG_LIBPNG_VER_RELEASE 33\r
+/* This should match the numeric part of the final component of\r
+ * PNG_LIBPNG_VER_STRING, omitting any leading zero: */\r
+\r
+#define PNG_LIBPNG_VER_BUILD 0\r
+\r
+/* Release Status */\r
+#define PNG_LIBPNG_BUILD_ALPHA 1\r
+#define PNG_LIBPNG_BUILD_BETA 2\r
+#define PNG_LIBPNG_BUILD_RC 3\r
+#define PNG_LIBPNG_BUILD_STABLE 4\r
+#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7\r
+ \r
+/* Release-Specific Flags */\r
+#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with\r
+ PNG_LIBPNG_BUILD_STABLE only */\r
+#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with\r
+ PNG_LIBPNG_BUILD_SPECIAL */\r
+#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with\r
+ PNG_LIBPNG_BUILD_PRIVATE */\r
+\r
+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE\r
+\r
+/* Careful here. At one time, Guy wanted to use 082, but that would be octal.\r
+ * We must not include leading zeros.\r
+ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only\r
+ * version 1.0.0 was mis-numbered 100 instead of 10000). From\r
+ * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */\r
+#define PNG_LIBPNG_VER 10233 /* 1.2.33 */\r
+\r
+#ifndef PNG_VERSION_INFO_ONLY\r
+/* include the compression library's header */\r
+#include "zlib.h"\r
+#endif\r
+\r
+/* include all user configurable info, including optional assembler routines */\r
+#include "pngconf.h"\r
+\r
+/*\r
+ * Added at libpng-1.2.8 */\r
+/* Ref MSDN: Private as priority over Special\r
+ * VS_FF_PRIVATEBUILD File *was not* built using standard release\r
+ * procedures. If this value is given, the StringFileInfo block must\r
+ * contain a PrivateBuild string. \r
+ *\r
+ * VS_FF_SPECIALBUILD File *was* built by the original company using\r
+ * standard release procedures but is a variation of the standard\r
+ * file of the same version number. If this value is given, the\r
+ * StringFileInfo block must contain a SpecialBuild string. \r
+ */\r
+\r
+#if defined(PNG_USER_PRIVATEBUILD)\r
+# define PNG_LIBPNG_BUILD_TYPE \\r
+ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)\r
+#else\r
+# if defined(PNG_LIBPNG_SPECIALBUILD)\r
+# define PNG_LIBPNG_BUILD_TYPE \\r
+ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)\r
+# else\r
+# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)\r
+# endif\r
+#endif\r
+\r
+#ifndef PNG_VERSION_INFO_ONLY\r
+\r
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif /* __cplusplus */\r
+\r
+/* This file is arranged in several sections. The first section contains\r
+ * structure and type definitions. The second section contains the external\r
+ * library functions, while the third has the internal library functions,\r
+ * which applications aren't expected to use directly.\r
+ */\r
+\r
+#ifndef PNG_NO_TYPECAST_NULL\r
+#define int_p_NULL (int *)NULL\r
+#define png_bytep_NULL (png_bytep)NULL\r
+#define png_bytepp_NULL (png_bytepp)NULL\r
+#define png_doublep_NULL (png_doublep)NULL\r
+#define png_error_ptr_NULL (png_error_ptr)NULL\r
+#define png_flush_ptr_NULL (png_flush_ptr)NULL\r
+#define png_free_ptr_NULL (png_free_ptr)NULL\r
+#define png_infopp_NULL (png_infopp)NULL\r
+#define png_malloc_ptr_NULL (png_malloc_ptr)NULL\r
+#define png_read_status_ptr_NULL (png_read_status_ptr)NULL\r
+#define png_rw_ptr_NULL (png_rw_ptr)NULL\r
+#define png_structp_NULL (png_structp)NULL\r
+#define png_uint_16p_NULL (png_uint_16p)NULL\r
+#define png_voidp_NULL (png_voidp)NULL\r
+#define png_write_status_ptr_NULL (png_write_status_ptr)NULL\r
+#else\r
+#define int_p_NULL NULL\r
+#define png_bytep_NULL NULL\r
+#define png_bytepp_NULL NULL\r
+#define png_doublep_NULL NULL\r
+#define png_error_ptr_NULL NULL\r
+#define png_flush_ptr_NULL NULL\r
+#define png_free_ptr_NULL NULL\r
+#define png_infopp_NULL NULL\r
+#define png_malloc_ptr_NULL NULL\r
+#define png_read_status_ptr_NULL NULL\r
+#define png_rw_ptr_NULL NULL\r
+#define png_structp_NULL NULL\r
+#define png_uint_16p_NULL NULL\r
+#define png_voidp_NULL NULL\r
+#define png_write_status_ptr_NULL NULL\r
+#endif\r
+\r
+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */\r
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)\r
+/* Version information for C files, stored in png.c. This had better match\r
+ * the version above.\r
+ */\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+PNG_EXPORT_VAR (PNG_CONST char) png_libpng_ver[18];\r
+ /* need room for 99.99.99beta99z */\r
+#else\r
+#define png_libpng_ver png_get_header_ver(NULL)\r
+#endif\r
+\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+/* This was removed in version 1.0.5c */\r
+/* Structures to facilitate easy interlacing. See png.c for more details */\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_start[7];\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_inc[7];\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_ystart[7];\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_yinc[7];\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_mask[7];\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_dsp_mask[7];\r
+/* This isn't currently used. If you need it, see png.c for more details.\r
+PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_height[7];\r
+*/\r
+#endif\r
+\r
+#endif /* PNG_NO_EXTERN */\r
+\r
+/* Three color definitions. The order of the red, green, and blue, (and the\r
+ * exact size) is not important, although the size of the fields need to\r
+ * be png_byte or png_uint_16 (as defined below).\r
+ */\r
+typedef struct png_color_struct\r
+{\r
+ png_byte red;\r
+ png_byte green;\r
+ png_byte blue;\r
+} png_color;\r
+typedef png_color FAR * png_colorp;\r
+typedef png_color FAR * FAR * png_colorpp;\r
+\r
+typedef struct png_color_16_struct\r
+{\r
+ png_byte index; /* used for palette files */\r
+ png_uint_16 red; /* for use in red green blue files */\r
+ png_uint_16 green;\r
+ png_uint_16 blue;\r
+ png_uint_16 gray; /* for use in grayscale files */\r
+} png_color_16;\r
+typedef png_color_16 FAR * png_color_16p;\r
+typedef png_color_16 FAR * FAR * png_color_16pp;\r
+\r
+typedef struct png_color_8_struct\r
+{\r
+ png_byte red; /* for use in red green blue files */\r
+ png_byte green;\r
+ png_byte blue;\r
+ png_byte gray; /* for use in grayscale files */\r
+ png_byte alpha; /* for alpha channel files */\r
+} png_color_8;\r
+typedef png_color_8 FAR * png_color_8p;\r
+typedef png_color_8 FAR * FAR * png_color_8pp;\r
+\r
+/*\r
+ * The following two structures are used for the in-core representation\r
+ * of sPLT chunks.\r
+ */\r
+typedef struct png_sPLT_entry_struct\r
+{\r
+ png_uint_16 red;\r
+ png_uint_16 green;\r
+ png_uint_16 blue;\r
+ png_uint_16 alpha;\r
+ png_uint_16 frequency;\r
+} png_sPLT_entry;\r
+typedef png_sPLT_entry FAR * png_sPLT_entryp;\r
+typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;\r
+\r
+/* When the depth of the sPLT palette is 8 bits, the color and alpha samples\r
+ * occupy the LSB of their respective members, and the MSB of each member\r
+ * is zero-filled. The frequency member always occupies the full 16 bits.\r
+ */\r
+\r
+typedef struct png_sPLT_struct\r
+{\r
+ png_charp name; /* palette name */\r
+ png_byte depth; /* depth of palette samples */\r
+ png_sPLT_entryp entries; /* palette entries */\r
+ png_int_32 nentries; /* number of palette entries */\r
+} png_sPLT_t;\r
+typedef png_sPLT_t FAR * png_sPLT_tp;\r
+typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;\r
+\r
+#ifdef PNG_TEXT_SUPPORTED\r
+/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,\r
+ * and whether that contents is compressed or not. The "key" field\r
+ * points to a regular zero-terminated C string. The "text", "lang", and\r
+ * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.\r
+ * However, the * structure returned by png_get_text() will always contain\r
+ * regular zero-terminated C strings (possibly empty), never NULL pointers,\r
+ * so they can be safely used in printf() and other string-handling functions.\r
+ */\r
+typedef struct png_text_struct\r
+{\r
+ int compression; /* compression value:\r
+ -1: tEXt, none\r
+ 0: zTXt, deflate\r
+ 1: iTXt, none\r
+ 2: iTXt, deflate */\r
+ png_charp key; /* keyword, 1-79 character description of "text" */\r
+ png_charp text; /* comment, may be an empty string (ie "")\r
+ or a NULL pointer */\r
+ png_size_t text_length; /* length of the text string */\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ png_size_t itxt_length; /* length of the itxt string */\r
+ png_charp lang; /* language code, 0-79 characters\r
+ or a NULL pointer */\r
+ png_charp lang_key; /* keyword translated UTF-8 string, 0 or more\r
+ chars or a NULL pointer */\r
+#endif\r
+} png_text;\r
+typedef png_text FAR * png_textp;\r
+typedef png_text FAR * FAR * png_textpp;\r
+#endif\r
+\r
+/* Supported compression types for text in PNG files (tEXt, and zTXt).\r
+ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */\r
+#define PNG_TEXT_COMPRESSION_NONE_WR -3\r
+#define PNG_TEXT_COMPRESSION_zTXt_WR -2\r
+#define PNG_TEXT_COMPRESSION_NONE -1\r
+#define PNG_TEXT_COMPRESSION_zTXt 0\r
+#define PNG_ITXT_COMPRESSION_NONE 1\r
+#define PNG_ITXT_COMPRESSION_zTXt 2\r
+#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */\r
+\r
+/* png_time is a way to hold the time in an machine independent way.\r
+ * Two conversions are provided, both from time_t and struct tm. There\r
+ * is no portable way to convert to either of these structures, as far\r
+ * as I know. If you know of a portable way, send it to me. As a side\r
+ * note - PNG has always been Year 2000 compliant!\r
+ */\r
+typedef struct png_time_struct\r
+{\r
+ png_uint_16 year; /* full year, as in, 1995 */\r
+ png_byte month; /* month of year, 1 - 12 */\r
+ png_byte day; /* day of month, 1 - 31 */\r
+ png_byte hour; /* hour of day, 0 - 23 */\r
+ png_byte minute; /* minute of hour, 0 - 59 */\r
+ png_byte second; /* second of minute, 0 - 60 (for leap seconds) */\r
+} png_time;\r
+typedef png_time FAR * png_timep;\r
+typedef png_time FAR * FAR * png_timepp;\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+/* png_unknown_chunk is a structure to hold queued chunks for which there is\r
+ * no specific support. The idea is that we can use this to queue\r
+ * up private chunks for output even though the library doesn't actually\r
+ * know about their semantics.\r
+ */\r
+#define PNG_CHUNK_NAME_LENGTH 5\r
+typedef struct png_unknown_chunk_t\r
+{\r
+ png_byte name[PNG_CHUNK_NAME_LENGTH];\r
+ png_byte *data;\r
+ png_size_t size;\r
+\r
+ /* libpng-using applications should NOT directly modify this byte. */\r
+ png_byte location; /* mode of operation at read time */\r
+}\r
+png_unknown_chunk;\r
+typedef png_unknown_chunk FAR * png_unknown_chunkp;\r
+typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;\r
+#endif\r
+\r
+/* png_info is a structure that holds the information in a PNG file so\r
+ * that the application can find out the characteristics of the image.\r
+ * If you are reading the file, this structure will tell you what is\r
+ * in the PNG file. If you are writing the file, fill in the information\r
+ * you want to put into the PNG file, then call png_write_info().\r
+ * The names chosen should be very close to the PNG specification, so\r
+ * consult that document for information about the meaning of each field.\r
+ *\r
+ * With libpng < 0.95, it was only possible to directly set and read the\r
+ * the values in the png_info_struct, which meant that the contents and\r
+ * order of the values had to remain fixed. With libpng 0.95 and later,\r
+ * however, there are now functions that abstract the contents of\r
+ * png_info_struct from the application, so this makes it easier to use\r
+ * libpng with dynamic libraries, and even makes it possible to use\r
+ * libraries that don't have all of the libpng ancillary chunk-handing\r
+ * functionality.\r
+ *\r
+ * In any case, the order of the parameters in png_info_struct should NOT\r
+ * be changed for as long as possible to keep compatibility with applications\r
+ * that use the old direct-access method with png_info_struct.\r
+ *\r
+ * The following members may have allocated storage attached that should be\r
+ * cleaned up before the structure is discarded: palette, trans, text,\r
+ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,\r
+ * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these\r
+ * are automatically freed when the info structure is deallocated, if they were\r
+ * allocated internally by libpng. This behavior can be changed by means\r
+ * of the png_data_freer() function.\r
+ *\r
+ * More allocation details: all the chunk-reading functions that\r
+ * change these members go through the corresponding png_set_*\r
+ * functions. A function to clear these members is available: see\r
+ * png_free_data(). The png_set_* functions do not depend on being\r
+ * able to point info structure members to any of the storage they are\r
+ * passed (they make their own copies), EXCEPT that the png_set_text\r
+ * functions use the same storage passed to them in the text_ptr or\r
+ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns\r
+ * functions do not make their own copies.\r
+ */\r
+typedef struct png_info_struct\r
+{\r
+ /* the following are necessary for every PNG file */\r
+ png_uint_32 width; /* width of image in pixels (from IHDR) */\r
+ png_uint_32 height; /* height of image in pixels (from IHDR) */\r
+ png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */\r
+ png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */\r
+ png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */\r
+ png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */\r
+ png_uint_16 num_trans; /* number of transparent palette color (tRNS) */\r
+ png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */\r
+ png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */\r
+ /* The following three should have been named *_method not *_type */\r
+ png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */\r
+ png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */\r
+ png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */\r
+\r
+ /* The following is informational only on read, and not used on writes. */\r
+ png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */\r
+ png_byte pixel_depth; /* number of bits per pixel */\r
+ png_byte spare_byte; /* to align the data, and for future use */\r
+ png_byte signature[8]; /* magic bytes read by libpng from start of file */\r
+\r
+ /* The rest of the data is optional. If you are reading, check the\r
+ * valid field to see if the information in these are valid. If you\r
+ * are writing, set the valid field to those chunks you want written,\r
+ * and initialize the appropriate fields below.\r
+ */\r
+\r
+#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ /* The gAMA chunk describes the gamma characteristics of the system\r
+ * on which the image was created, normally in the range [1.0, 2.5].\r
+ * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.\r
+ */\r
+ float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */\r
+#endif\r
+\r
+#if defined(PNG_sRGB_SUPPORTED)\r
+ /* GR-P, 0.96a */\r
+ /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */\r
+ png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */\r
+#endif\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+ /* The tEXt, and zTXt chunks contain human-readable textual data in\r
+ * uncompressed, compressed, and optionally compressed forms, respectively.\r
+ * The data in "text" is an array of pointers to uncompressed,\r
+ * null-terminated C strings. Each chunk has a keyword that describes the\r
+ * textual data contained in that chunk. Keywords are not required to be\r
+ * unique, and the text string may be empty. Any number of text chunks may\r
+ * be in an image.\r
+ */\r
+ int num_text; /* number of comments read/to write */\r
+ int max_text; /* current size of text array */\r
+ png_textp text; /* array of comments read/to write */\r
+#endif /* PNG_TEXT_SUPPORTED */\r
+\r
+#if defined(PNG_tIME_SUPPORTED)\r
+ /* The tIME chunk holds the last time the displayed image data was\r
+ * modified. See the png_time struct for the contents of this struct.\r
+ */\r
+ png_time mod_time;\r
+#endif\r
+\r
+#if defined(PNG_sBIT_SUPPORTED)\r
+ /* The sBIT chunk specifies the number of significant high-order bits\r
+ * in the pixel data. Values are in the range [1, bit_depth], and are\r
+ * only specified for the channels in the pixel data. The contents of\r
+ * the low-order bits is not specified. Data is valid if\r
+ * (valid & PNG_INFO_sBIT) is non-zero.\r
+ */\r
+ png_color_8 sig_bit; /* significant bits in color channels */\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \\r
+defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ /* The tRNS chunk supplies transparency data for paletted images and\r
+ * other image types that don't need a full alpha channel. There are\r
+ * "num_trans" transparency values for a paletted image, stored in the\r
+ * same order as the palette colors, starting from index 0. Values\r
+ * for the data are in the range [0, 255], ranging from fully transparent\r
+ * to fully opaque, respectively. For non-paletted images, there is a\r
+ * single color specified that should be treated as fully transparent.\r
+ * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.\r
+ */\r
+ png_bytep trans; /* transparent values for paletted image */\r
+ png_color_16 trans_values; /* transparent color for non-palette image */\r
+#endif\r
+\r
+#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ /* The bKGD chunk gives the suggested image background color if the\r
+ * display program does not have its own background color and the image\r
+ * is needs to composited onto a background before display. The colors\r
+ * in "background" are normally in the same color space/depth as the\r
+ * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero.\r
+ */\r
+ png_color_16 background;\r
+#endif\r
+\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+ /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards\r
+ * and downwards from the top-left corner of the display, page, or other\r
+ * application-specific co-ordinate space. See the PNG_OFFSET_ defines\r
+ * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero.\r
+ */\r
+ png_int_32 x_offset; /* x offset on page */\r
+ png_int_32 y_offset; /* y offset on page */\r
+ png_byte offset_unit_type; /* offset units type */\r
+#endif\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+ /* The pHYs chunk gives the physical pixel density of the image for\r
+ * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_\r
+ * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero.\r
+ */\r
+ png_uint_32 x_pixels_per_unit; /* horizontal pixel density */\r
+ png_uint_32 y_pixels_per_unit; /* vertical pixel density */\r
+ png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+ /* The hIST chunk contains the relative frequency or importance of the\r
+ * various palette entries, so that a viewer can intelligently select a\r
+ * reduced-color palette, if required. Data is an array of "num_palette"\r
+ * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)\r
+ * is non-zero.\r
+ */\r
+ png_uint_16p hist;\r
+#endif\r
+\r
+#ifdef PNG_cHRM_SUPPORTED\r
+ /* The cHRM chunk describes the CIE color characteristics of the monitor\r
+ * on which the PNG was created. This data allows the viewer to do gamut\r
+ * mapping of the input image to ensure that the viewer sees the same\r
+ * colors in the image as the creator. Values are in the range\r
+ * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero.\r
+ */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float x_white;\r
+ float y_white;\r
+ float x_red;\r
+ float y_red;\r
+ float x_green;\r
+ float y_green;\r
+ float x_blue;\r
+ float y_blue;\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+ /* The pCAL chunk describes a transformation between the stored pixel\r
+ * values and original physical data values used to create the image.\r
+ * The integer range [0, 2^bit_depth - 1] maps to the floating-point\r
+ * range given by [pcal_X0, pcal_X1], and are further transformed by a\r
+ * (possibly non-linear) transformation function given by "pcal_type"\r
+ * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_\r
+ * defines below, and the PNG-Group's PNG extensions document for a\r
+ * complete description of the transformations and how they should be\r
+ * implemented, and for a description of the ASCII parameter strings.\r
+ * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.\r
+ */\r
+ png_charp pcal_purpose; /* pCAL chunk description string */\r
+ png_int_32 pcal_X0; /* minimum value */\r
+ png_int_32 pcal_X1; /* maximum value */\r
+ png_charp pcal_units; /* Latin-1 string giving physical units */\r
+ png_charpp pcal_params; /* ASCII strings containing parameter values */\r
+ png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */\r
+ png_byte pcal_nparams; /* number of parameters given in pcal_params */\r
+#endif\r
+\r
+/* New members added in libpng-1.0.6 */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_uint_32 free_me; /* flags items libpng is responsible for freeing */\r
+#endif\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ /* storage for unknown chunks that the library doesn't recognize. */\r
+ png_unknown_chunkp unknown_chunks;\r
+ png_size_t unknown_chunks_num;\r
+#endif\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+ /* iCCP chunk data. */\r
+ png_charp iccp_name; /* profile name */\r
+ png_charp iccp_profile; /* International Color Consortium profile data */\r
+ /* Note to maintainer: should be png_bytep */\r
+ png_uint_32 iccp_proflen; /* ICC profile data length */\r
+ png_byte iccp_compression; /* Always zero */\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+ /* data on sPLT chunks (there may be more than one). */\r
+ png_sPLT_tp splt_palettes;\r
+ png_uint_32 splt_palettes_num;\r
+#endif\r
+\r
+#if defined(PNG_sCAL_SUPPORTED)\r
+ /* The sCAL chunk describes the actual physical dimensions of the\r
+ * subject matter of the graphic. The chunk contains a unit specification\r
+ * a byte value, and two ASCII strings representing floating-point\r
+ * values. The values are width and height corresponsing to one pixel\r
+ * in the image. This external representation is converted to double\r
+ * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.\r
+ */\r
+ png_byte scal_unit; /* unit of physical scale */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ double scal_pixel_width; /* width of one pixel */\r
+ double scal_pixel_height; /* height of one pixel */\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_charp scal_s_width; /* string containing height */\r
+ png_charp scal_s_height; /* string containing width */\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+ /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */\r
+ /* Data valid if (valid & PNG_INFO_IDAT) non-zero */\r
+ png_bytepp row_pointers; /* the image bits */\r
+#endif\r
+\r
+#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED)\r
+ png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED)\r
+ png_fixed_point int_x_white;\r
+ png_fixed_point int_y_white;\r
+ png_fixed_point int_x_red;\r
+ png_fixed_point int_y_red;\r
+ png_fixed_point int_x_green;\r
+ png_fixed_point int_y_green;\r
+ png_fixed_point int_x_blue;\r
+ png_fixed_point int_y_blue;\r
+#endif\r
+\r
+} png_info;\r
+\r
+typedef png_info FAR * png_infop;\r
+typedef png_info FAR * FAR * png_infopp;\r
+\r
+/* Maximum positive integer used in PNG is (2^31)-1 */\r
+#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)\r
+#define PNG_UINT_32_MAX ((png_uint_32)(-1))\r
+#define PNG_SIZE_MAX ((png_size_t)(-1))\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */\r
+#define PNG_MAX_UINT PNG_UINT_31_MAX\r
+#endif\r
+\r
+/* These describe the color_type field in png_info. */\r
+/* color type masks */\r
+#define PNG_COLOR_MASK_PALETTE 1\r
+#define PNG_COLOR_MASK_COLOR 2\r
+#define PNG_COLOR_MASK_ALPHA 4\r
+\r
+/* color types. Note that not all combinations are legal */\r
+#define PNG_COLOR_TYPE_GRAY 0\r
+#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)\r
+#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)\r
+#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)\r
+#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)\r
+/* aliases */\r
+#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA\r
+#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA\r
+\r
+/* This is for compression type. PNG 1.0-1.2 only define the single type. */\r
+#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */\r
+#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE\r
+\r
+/* This is for filter type. PNG 1.0-1.2 only define the single type. */\r
+#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */\r
+#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */\r
+#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE\r
+\r
+/* These are for the interlacing type. These values should NOT be changed. */\r
+#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */\r
+#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */\r
+#define PNG_INTERLACE_LAST 2 /* Not a valid value */\r
+\r
+/* These are for the oFFs chunk. These values should NOT be changed. */\r
+#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */\r
+#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */\r
+#define PNG_OFFSET_LAST 2 /* Not a valid value */\r
+\r
+/* These are for the pCAL chunk. These values should NOT be changed. */\r
+#define PNG_EQUATION_LINEAR 0 /* Linear transformation */\r
+#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */\r
+#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */\r
+#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */\r
+#define PNG_EQUATION_LAST 4 /* Not a valid value */\r
+\r
+/* These are for the sCAL chunk. These values should NOT be changed. */\r
+#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */\r
+#define PNG_SCALE_METER 1 /* meters per pixel */\r
+#define PNG_SCALE_RADIAN 2 /* radians per pixel */\r
+#define PNG_SCALE_LAST 3 /* Not a valid value */\r
+\r
+/* These are for the pHYs chunk. These values should NOT be changed. */\r
+#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */\r
+#define PNG_RESOLUTION_METER 1 /* pixels/meter */\r
+#define PNG_RESOLUTION_LAST 2 /* Not a valid value */\r
+\r
+/* These are for the sRGB chunk. These values should NOT be changed. */\r
+#define PNG_sRGB_INTENT_PERCEPTUAL 0\r
+#define PNG_sRGB_INTENT_RELATIVE 1\r
+#define PNG_sRGB_INTENT_SATURATION 2\r
+#define PNG_sRGB_INTENT_ABSOLUTE 3\r
+#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */\r
+\r
+/* This is for text chunks */\r
+#define PNG_KEYWORD_MAX_LENGTH 79\r
+\r
+/* Maximum number of entries in PLTE/sPLT/tRNS arrays */\r
+#define PNG_MAX_PALETTE_LENGTH 256\r
+\r
+/* These determine if an ancillary chunk's data has been successfully read\r
+ * from the PNG header, or if the application has filled in the corresponding\r
+ * data in the info_struct to be written into the output file. The values\r
+ * of the PNG_INFO_<chunk> defines should NOT be changed.\r
+ */\r
+#define PNG_INFO_gAMA 0x0001\r
+#define PNG_INFO_sBIT 0x0002\r
+#define PNG_INFO_cHRM 0x0004\r
+#define PNG_INFO_PLTE 0x0008\r
+#define PNG_INFO_tRNS 0x0010\r
+#define PNG_INFO_bKGD 0x0020\r
+#define PNG_INFO_hIST 0x0040\r
+#define PNG_INFO_pHYs 0x0080\r
+#define PNG_INFO_oFFs 0x0100\r
+#define PNG_INFO_tIME 0x0200\r
+#define PNG_INFO_pCAL 0x0400\r
+#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */\r
+#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */\r
+#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */\r
+#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */\r
+#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */\r
+\r
+/* This is used for the transformation routines, as some of them\r
+ * change these values for the row. It also should enable using\r
+ * the routines for other purposes.\r
+ */\r
+typedef struct png_row_info_struct\r
+{\r
+ png_uint_32 width; /* width of row */\r
+ png_uint_32 rowbytes; /* number of bytes in row */\r
+ png_byte color_type; /* color type of row */\r
+ png_byte bit_depth; /* bit depth of row */\r
+ png_byte channels; /* number of channels (1, 2, 3, or 4) */\r
+ png_byte pixel_depth; /* bits per pixel (depth * channels) */\r
+} png_row_info;\r
+\r
+typedef png_row_info FAR * png_row_infop;\r
+typedef png_row_info FAR * FAR * png_row_infopp;\r
+\r
+/* These are the function types for the I/O functions and for the functions\r
+ * that allow the user to override the default I/O functions with his or her\r
+ * own. The png_error_ptr type should match that of user-supplied warning\r
+ * and error functions, while the png_rw_ptr type should match that of the\r
+ * user read/write data functions.\r
+ */\r
+typedef struct png_struct_def png_struct;\r
+typedef png_struct FAR * png_structp;\r
+\r
+typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp));\r
+typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));\r
+typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));\r
+typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,\r
+ int));\r
+typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,\r
+ int));\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));\r
+typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));\r
+typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,\r
+ png_uint_32, int));\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,\r
+ png_row_infop, png_bytep));\r
+#endif\r
+\r
+#if defined(PNG_USER_CHUNKS_SUPPORTED)\r
+typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));\r
+#endif\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));\r
+#endif\r
+\r
+/* Transform masks for the high-level interface */\r
+#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */\r
+#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */\r
+#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */\r
+#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */\r
+#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */\r
+#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */\r
+#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */\r
+#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */\r
+#define PNG_TRANSFORM_BGR 0x0080 /* read and write */\r
+#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */\r
+#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */\r
+#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */\r
+#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */\r
+\r
+/* Flags for MNG supported features */\r
+#define PNG_FLAG_MNG_EMPTY_PLTE 0x01\r
+#define PNG_FLAG_MNG_FILTER_64 0x04\r
+#define PNG_ALL_MNG_FEATURES 0x05\r
+\r
+typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t));\r
+typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));\r
+\r
+/* The structure that holds the information to read and write PNG files.\r
+ * The only people who need to care about what is inside of this are the\r
+ * people who will be modifying the library for their own special needs.\r
+ * It should NOT be accessed directly by an application, except to store\r
+ * the jmp_buf.\r
+ */\r
+\r
+struct png_struct_def\r
+{\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ jmp_buf jmpbuf; /* used in png_error */\r
+#endif\r
+ png_error_ptr error_fn; /* function for printing errors and aborting */\r
+ png_error_ptr warning_fn; /* function for printing warnings */\r
+ png_voidp error_ptr; /* user supplied struct for error functions */\r
+ png_rw_ptr write_data_fn; /* function for writing output data */\r
+ png_rw_ptr read_data_fn; /* function for reading input data */\r
+ png_voidp io_ptr; /* ptr to application struct for I/O functions */\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)\r
+ png_user_transform_ptr read_user_transform_fn; /* user read transform */\r
+#endif\r
+\r
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
+ png_user_transform_ptr write_user_transform_fn; /* user write transform */\r
+#endif\r
+\r
+/* These were added in libpng-1.0.2 */\r
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
+ png_voidp user_transform_ptr; /* user supplied struct for user transform */\r
+ png_byte user_transform_depth; /* bit depth of user transformed pixels */\r
+ png_byte user_transform_channels; /* channels in user transformed pixels */\r
+#endif\r
+#endif\r
+\r
+ png_uint_32 mode; /* tells us where we are in the PNG file */\r
+ png_uint_32 flags; /* flags indicating various things to libpng */\r
+ png_uint_32 transformations; /* which transformations to perform */\r
+\r
+ z_stream zstream; /* pointer to decompression structure (below) */\r
+ png_bytep zbuf; /* buffer for zlib */\r
+ png_size_t zbuf_size; /* size of zbuf */\r
+ int zlib_level; /* holds zlib compression level */\r
+ int zlib_method; /* holds zlib compression method */\r
+ int zlib_window_bits; /* holds zlib compression window bits */\r
+ int zlib_mem_level; /* holds zlib compression memory level */\r
+ int zlib_strategy; /* holds zlib compression strategy */\r
+\r
+ png_uint_32 width; /* width of image in pixels */\r
+ png_uint_32 height; /* height of image in pixels */\r
+ png_uint_32 num_rows; /* number of rows in current pass */\r
+ png_uint_32 usr_width; /* width of row at start of write */\r
+ png_uint_32 rowbytes; /* size of row in bytes */\r
+ png_uint_32 irowbytes; /* size of current interlaced row in bytes */\r
+ png_uint_32 iwidth; /* width of current interlaced row in pixels */\r
+ png_uint_32 row_number; /* current row in interlace pass */\r
+ png_bytep prev_row; /* buffer to save previous (unfiltered) row */\r
+ png_bytep row_buf; /* buffer to save current (unfiltered) row */\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ png_bytep sub_row; /* buffer to save "sub" row when filtering */\r
+ png_bytep up_row; /* buffer to save "up" row when filtering */\r
+ png_bytep avg_row; /* buffer to save "avg" row when filtering */\r
+ png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */\r
+#endif\r
+ png_row_info row_info; /* used for transformation routines */\r
+\r
+ png_uint_32 idat_size; /* current IDAT size for read */\r
+ png_uint_32 crc; /* current chunk CRC value */\r
+ png_colorp palette; /* palette from the input file */\r
+ png_uint_16 num_palette; /* number of color entries in palette */\r
+ png_uint_16 num_trans; /* number of transparency values */\r
+ png_byte chunk_name[5]; /* null-terminated name of current chunk */\r
+ png_byte compression; /* file compression type (always 0) */\r
+ png_byte filter; /* file filter type (always 0) */\r
+ png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */\r
+ png_byte pass; /* current interlace pass (0 - 6) */\r
+ png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */\r
+ png_byte color_type; /* color type of file */\r
+ png_byte bit_depth; /* bit depth of file */\r
+ png_byte usr_bit_depth; /* bit depth of users row */\r
+ png_byte pixel_depth; /* number of bits per pixel */\r
+ png_byte channels; /* number of channels in file */\r
+ png_byte usr_channels; /* channels at start of write */\r
+ png_byte sig_bytes; /* magic bytes read/written from start of file */\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)\r
+#ifdef PNG_LEGACY_SUPPORTED\r
+ png_byte filler; /* filler byte for pixel expansion */\r
+#else\r
+ png_uint_16 filler; /* filler bytes for pixel expansion */\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_bKGD_SUPPORTED)\r
+ png_byte background_gamma_type;\r
+# ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float background_gamma;\r
+# endif\r
+ png_color_16 background; /* background color in screen gamma space */\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ png_color_16 background_1; /* background normalized to gamma 1.0 */\r
+#endif\r
+#endif /* PNG_bKGD_SUPPORTED */\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+ png_flush_ptr output_flush_fn;/* Function for flushing output */\r
+ png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */\r
+ png_uint_32 flush_rows; /* number of rows written since last flush */\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ int gamma_shift; /* number of "insignificant" bits 16-bit gamma */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float gamma; /* file gamma value */\r
+ float screen_gamma; /* screen gamma value (display_exponent) */\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ png_bytep gamma_table; /* gamma table for 8-bit depth files */\r
+ png_bytep gamma_from_1; /* converts from 1.0 to screen */\r
+ png_bytep gamma_to_1; /* converts from file to 1.0 */\r
+ png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */\r
+ png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */\r
+ png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)\r
+ png_color_8 sig_bit; /* significant bits in each available channel */\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+ png_color_8 shift; /* shift for significant bit tranformation */\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \\r
+ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ png_bytep trans; /* transparency values for paletted files */\r
+ png_color_16 trans_values; /* transparency values for non-paletted files */\r
+#endif\r
+\r
+ png_read_status_ptr read_row_fn; /* called after each row is decoded */\r
+ png_write_status_ptr write_row_fn; /* called after each row is encoded */\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+ png_progressive_info_ptr info_fn; /* called after header data fully read */\r
+ png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */\r
+ png_progressive_end_ptr end_fn; /* called after image is complete */\r
+ png_bytep save_buffer_ptr; /* current location in save_buffer */\r
+ png_bytep save_buffer; /* buffer for previously read data */\r
+ png_bytep current_buffer_ptr; /* current location in current_buffer */\r
+ png_bytep current_buffer; /* buffer for recently used data */\r
+ png_uint_32 push_length; /* size of current input chunk */\r
+ png_uint_32 skip_length; /* bytes to skip in input data */\r
+ png_size_t save_buffer_size; /* amount of data now in save_buffer */\r
+ png_size_t save_buffer_max; /* total size of save_buffer */\r
+ png_size_t buffer_size; /* total amount of available input data */\r
+ png_size_t current_buffer_size; /* amount of data now in current_buffer */\r
+ int process_mode; /* what push library is currently doing */\r
+ int cur_palette; /* current push library palette index */\r
+\r
+# if defined(PNG_TEXT_SUPPORTED)\r
+ png_size_t current_text_size; /* current size of text input data */\r
+ png_size_t current_text_left; /* how much text left to read in input */\r
+ png_charp current_text; /* current text chunk buffer */\r
+ png_charp current_text_ptr; /* current location in current_text */\r
+# endif /* PNG_TEXT_SUPPORTED */\r
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */\r
+\r
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)\r
+/* for the Borland special 64K segment handler */\r
+ png_bytepp offset_table_ptr;\r
+ png_bytep offset_table;\r
+ png_uint_16 offset_table_number;\r
+ png_uint_16 offset_table_count;\r
+ png_uint_16 offset_table_count_free;\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+ png_bytep palette_lookup; /* lookup table for dithering */\r
+ png_bytep dither_index; /* index translation for palette files */\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED)\r
+ png_uint_16p hist; /* histogram */\r
+#endif\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ png_byte heuristic_method; /* heuristic for row filter selection */\r
+ png_byte num_prev_filters; /* number of weights for previous rows */\r
+ png_bytep prev_filters; /* filter type(s) of previous row(s) */\r
+ png_uint_16p filter_weights; /* weight(s) for previous line(s) */\r
+ png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */\r
+ png_uint_16p filter_costs; /* relative filter calculation cost */\r
+ png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */\r
+#endif\r
+\r
+#if defined(PNG_TIME_RFC1123_SUPPORTED)\r
+ png_charp time_buffer; /* String to hold RFC 1123 time text */\r
+#endif\r
+\r
+/* New members added in libpng-1.0.6 */\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_uint_32 free_me; /* flags items libpng is responsible for freeing */\r
+#endif\r
+\r
+#if defined(PNG_USER_CHUNKS_SUPPORTED)\r
+ png_voidp user_chunk_ptr;\r
+ png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */\r
+#endif\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ int num_chunk_list;\r
+ png_bytep chunk_list;\r
+#endif\r
+\r
+/* New members added in libpng-1.0.3 */\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+ png_byte rgb_to_gray_status;\r
+ /* These were changed from png_byte in libpng-1.0.6 */\r
+ png_uint_16 rgb_to_gray_red_coeff;\r
+ png_uint_16 rgb_to_gray_green_coeff;\r
+ png_uint_16 rgb_to_gray_blue_coeff;\r
+#endif\r
+\r
+/* New member added in libpng-1.0.4 (renamed in 1.0.9) */\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED) || \\r
+ defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \\r
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)\r
+/* changed from png_byte to png_uint_32 at version 1.2.0 */\r
+#ifdef PNG_1_0_X\r
+ png_byte mng_features_permitted;\r
+#else\r
+ png_uint_32 mng_features_permitted;\r
+#endif /* PNG_1_0_X */\r
+#endif\r
+\r
+/* New member added in libpng-1.0.7 */\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ png_fixed_point int_gamma;\r
+#endif\r
+\r
+/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ png_byte filter_type;\r
+#endif\r
+\r
+#if defined(PNG_1_0_X)\r
+/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */\r
+ png_uint_32 row_buf_size;\r
+#endif\r
+\r
+/* New members added in libpng-1.2.0 */\r
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)\r
+# if !defined(PNG_1_0_X)\r
+# if defined(PNG_MMX_CODE_SUPPORTED)\r
+ png_byte mmx_bitdepth_threshold;\r
+ png_uint_32 mmx_rowbytes_threshold;\r
+# endif\r
+ png_uint_32 asm_flags;\r
+# endif\r
+#endif\r
+\r
+/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_voidp mem_ptr; /* user supplied struct for mem functions */\r
+ png_malloc_ptr malloc_fn; /* function for allocating memory */\r
+ png_free_ptr free_fn; /* function for freeing memory */\r
+#endif\r
+\r
+/* New member added in libpng-1.0.13 and 1.2.0 */\r
+ png_bytep big_row_buf; /* buffer to save current (unfiltered) row */\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+/* The following three members were added at version 1.0.14 and 1.2.4 */\r
+ png_bytep dither_sort; /* working sort array */\r
+ png_bytep index_to_palette; /* where the original index currently is */\r
+ /* in the palette */\r
+ png_bytep palette_to_index; /* which original index points to this */\r
+ /* palette color */\r
+#endif\r
+\r
+/* New members added in libpng-1.0.16 and 1.2.6 */\r
+ png_byte compression_type;\r
+\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ png_uint_32 user_width_max;\r
+ png_uint_32 user_height_max;\r
+#endif\r
+\r
+/* New member added in libpng-1.0.25 and 1.2.17 */\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ /* storage for unknown chunk that the library doesn't recognize. */\r
+ png_unknown_chunk unknown_chunk;\r
+#endif\r
+\r
+/* New members added in libpng-1.2.26 */\r
+ png_uint_32 old_big_row_buf_size, old_prev_row_size;\r
+\r
+/* New member added in libpng-1.2.30 */\r
+ png_charp chunkdata; /* buffer for reading chunk data */\r
+\r
+};\r
+\r
+\r
+/* This triggers a compiler error in png.c, if png.c and png.h\r
+ * do not agree upon the version number.\r
+ */\r
+typedef png_structp version_1_2_33;\r
+\r
+typedef png_struct FAR * FAR * png_structpp;\r
+\r
+/* Here are the function definitions most commonly used. This is not\r
+ * the place to find out how to use libpng. See libpng.txt for the\r
+ * full explanation, see example.c for the summary. This just provides\r
+ * a simple one line description of the use of each function.\r
+ */\r
+\r
+/* Returns the version number of the library */\r
+extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void));\r
+\r
+/* Tell lib we have already handled the first <num_bytes> magic bytes.\r
+ * Handling more than 8 bytes from the beginning of the file is an error.\r
+ */\r
+extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr,\r
+ int num_bytes));\r
+\r
+/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a\r
+ * PNG file. Returns zero if the supplied bytes match the 8-byte PNG\r
+ * signature, and non-zero otherwise. Having num_to_check == 0 or\r
+ * start > 7 will always fail (ie return non-zero).\r
+ */\r
+extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start,\r
+ png_size_t num_to_check));\r
+\r
+/* Simple signature checking function. This is the same as calling\r
+ * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).\r
+ */\r
+extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num));\r
+\r
+/* Allocate and initialize png_ptr struct for reading, and any other memory. */\r
+extern PNG_EXPORT(png_structp,png_create_read_struct)\r
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn));\r
+\r
+/* Allocate and initialize png_ptr struct for writing, and any other memory */\r
+extern PNG_EXPORT(png_structp,png_create_write_struct)\r
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn));\r
+\r
+#ifdef PNG_WRITE_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size)\r
+ PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#ifdef PNG_WRITE_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_compression_buffer_size)\r
+ PNGARG((png_structp png_ptr, png_uint_32 size));\r
+#endif\r
+\r
+/* Reset the compression stream */\r
+extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr));\r
+\r
+/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+extern PNG_EXPORT(png_structp,png_create_read_struct_2)\r
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn));\r
+extern PNG_EXPORT(png_structp,png_create_write_struct_2)\r
+ PNGARG((png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn));\r
+#endif\r
+\r
+/* Write a PNG chunk - size, type, (optional) data, CRC. */\r
+extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr,\r
+ png_bytep chunk_name, png_bytep data, png_size_t length));\r
+\r
+/* Write the start of a PNG chunk - length and chunk name. */\r
+extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr,\r
+ png_bytep chunk_name, png_uint_32 length));\r
+\r
+/* Write the data of a PNG chunk started with png_write_chunk_start(). */\r
+extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr,\r
+ png_bytep data, png_size_t length));\r
+\r
+/* Finish a chunk started with png_write_chunk_start() (includes CRC). */\r
+extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr));\r
+\r
+/* Allocate and initialize the info structure */\r
+extern PNG_EXPORT(png_infop,png_create_info_struct)\r
+ PNGARG((png_structp png_ptr));\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Initialize the info structure (old interface - DEPRECATED) */\r
+extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr));\r
+#undef png_info_init\r
+#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\\r
+ png_sizeof(png_info));\r
+#endif\r
+\r
+extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr,\r
+ png_size_t png_info_struct_size));\r
+\r
+/* Writes all the PNG information before the image. */\r
+extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* read the information before the actual image data. */\r
+extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+#endif\r
+\r
+#if defined(PNG_TIME_RFC1123_SUPPORTED)\r
+extern PNG_EXPORT(png_charp,png_convert_to_rfc1123)\r
+ PNGARG((png_structp png_ptr, png_timep ptime));\r
+#endif\r
+\r
+#if !defined(_WIN32_WCE)\r
+/* "time.h" functions are not supported on WindowsCE */\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+/* convert from a struct tm to png_time */\r
+extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime,\r
+ struct tm FAR * ttime));\r
+\r
+/* convert from time_t to png_time. Uses gmtime() */\r
+extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime,\r
+ time_t ttime));\r
+#endif /* PNG_WRITE_tIME_SUPPORTED */\r
+#endif /* _WIN32_WCE */\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */\r
+extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr));\r
+#if !defined(PNG_1_0_X)\r
+extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp\r
+ png_ptr));\r
+#endif\r
+extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr));\r
+extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr));\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Deprecated */\r
+extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
+/* Use blue, green, red order for pixels. */\r
+extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+/* Expand the grayscale to 24-bit RGB if necessary. */\r
+extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+/* Reduce RGB to grayscale. */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr,\r
+ int error_action, double red, double green ));\r
+#endif\r
+extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr,\r
+ int error_action, png_fixed_point red, png_fixed_point green ));\r
+extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp\r
+ png_ptr));\r
+#endif\r
+\r
+extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth,\r
+ png_colorp palette));\r
+\r
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \\r
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \\r
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)\r
+/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */\r
+extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr,\r
+ png_uint_32 filler, int flags));\r
+/* The values of the PNG_FILLER_ defines should NOT be changed */\r
+#define PNG_FILLER_BEFORE 0\r
+#define PNG_FILLER_AFTER 1\r
+/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */\r
+#if !defined(PNG_1_0_X)\r
+extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr,\r
+ png_uint_32 filler, int flags));\r
+#endif\r
+#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
+/* Swap bytes in 16-bit depth files. */\r
+extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)\r
+/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */\r
+extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+/* Swap packing order of pixels in bytes. */\r
+extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+/* Converts files to legal bit depths. */\r
+extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr,\r
+ png_color_8p true_bits));\r
+#endif\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \\r
+ defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+/* Have the code handle the interlacing. Returns the number of passes. */\r
+extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)\r
+/* Invert monochrome files */\r
+extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+/* Handle alpha and tRNS by replacing with a background color. */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr,\r
+ png_color_16p background_color, int background_gamma_code,\r
+ int need_expand, double background_gamma));\r
+#endif\r
+#define PNG_BACKGROUND_GAMMA_UNKNOWN 0\r
+#define PNG_BACKGROUND_GAMMA_SCREEN 1\r
+#define PNG_BACKGROUND_GAMMA_FILE 2\r
+#define PNG_BACKGROUND_GAMMA_UNIQUE 3\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+/* strip the second byte of information from a 16-bit depth file. */\r
+extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+/* Turn on dithering, and reduce the palette to the number of colors available. */\r
+extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr,\r
+ png_colorp palette, int num_palette, int maximum_colors,\r
+ png_uint_16p histogram, int full_dither));\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+/* Handle gamma correction. Screen_gamma=(display_exponent) */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr,\r
+ double screen_gamma, double default_file_gamma));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \\r
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)\r
+/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */\r
+/* Deprecated and will be removed. Use png_permit_mng_features() instead. */\r
+extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr,\r
+ int empty_plte_permitted));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+/* Set how many lines between output flushes - 0 for no flushing */\r
+extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows));\r
+/* Flush the current PNG output buffer */\r
+extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+/* optional update palette with requested transformations */\r
+extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr));\r
+\r
+/* optional call to update the users info structure */\r
+extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* read one or more rows of image data. */\r
+extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr,\r
+ png_bytepp row, png_bytepp display_row, png_uint_32 num_rows));\r
+#endif\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* read a row of data. */\r
+extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr,\r
+ png_bytep row,\r
+ png_bytep display_row));\r
+#endif\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* read the whole image into memory at once. */\r
+extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr,\r
+ png_bytepp image));\r
+#endif\r
+\r
+/* write a row of image data */\r
+extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr,\r
+ png_bytep row));\r
+\r
+/* write a few rows of image data */\r
+extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr,\r
+ png_bytepp row, png_uint_32 num_rows));\r
+\r
+/* write the image data */\r
+extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr,\r
+ png_bytepp image));\r
+\r
+/* writes the end of the PNG file. */\r
+extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* read the end of the PNG file. */\r
+extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+#endif\r
+\r
+/* free any memory associated with the png_info_struct */\r
+extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr,\r
+ png_infopp info_ptr_ptr));\r
+\r
+/* free any memory associated with the png_struct and the png_info_structs */\r
+extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp\r
+ png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));\r
+\r
+/* free all memory used by the read (old method - NOT DLL EXPORTED) */\r
+extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_infop end_info_ptr));\r
+\r
+/* free any memory associated with the png_struct and the png_info_structs */\r
+extern PNG_EXPORT(void,png_destroy_write_struct)\r
+ PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr));\r
+\r
+/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */\r
+extern void png_write_destroy PNGARG((png_structp png_ptr));\r
+\r
+/* set the libpng method of handling chunk CRC errors */\r
+extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr,\r
+ int crit_action, int ancil_action));\r
+\r
+/* Values for png_set_crc_action() to say how to handle CRC errors in\r
+ * ancillary and critical chunks, and whether to use the data contained\r
+ * therein. Note that it is impossible to "discard" data in a critical\r
+ * chunk. For versions prior to 0.90, the action was always error/quit,\r
+ * whereas in version 0.90 and later, the action for CRC errors in ancillary\r
+ * chunks is warn/discard. These values should NOT be changed.\r
+ *\r
+ * value action:critical action:ancillary\r
+ */\r
+#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */\r
+#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */\r
+#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */\r
+#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */\r
+#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */\r
+#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */\r
+\r
+/* These functions give the user control over the scan-line filtering in\r
+ * libpng and the compression methods used by zlib. These functions are\r
+ * mainly useful for testing, as the defaults should work with most users.\r
+ * Those users who are tight on memory or want faster performance at the\r
+ * expense of compression can modify them. See the compression library\r
+ * header file (zlib.h) for an explination of the compression functions.\r
+ */\r
+\r
+/* set the filtering method(s) used by libpng. Currently, the only valid\r
+ * value for "method" is 0.\r
+ */\r
+extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method,\r
+ int filters));\r
+\r
+/* Flags for png_set_filter() to say which filters to use. The flags\r
+ * are chosen so that they don't conflict with real filter types\r
+ * below, in case they are supplied instead of the #defined constants.\r
+ * These values should NOT be changed.\r
+ */\r
+#define PNG_NO_FILTERS 0x00\r
+#define PNG_FILTER_NONE 0x08\r
+#define PNG_FILTER_SUB 0x10\r
+#define PNG_FILTER_UP 0x20\r
+#define PNG_FILTER_AVG 0x40\r
+#define PNG_FILTER_PAETH 0x80\r
+#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \\r
+ PNG_FILTER_AVG | PNG_FILTER_PAETH)\r
+\r
+/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.\r
+ * These defines should NOT be changed.\r
+ */\r
+#define PNG_FILTER_VALUE_NONE 0\r
+#define PNG_FILTER_VALUE_SUB 1\r
+#define PNG_FILTER_VALUE_UP 2\r
+#define PNG_FILTER_VALUE_AVG 3\r
+#define PNG_FILTER_VALUE_PAETH 4\r
+#define PNG_FILTER_VALUE_LAST 5\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */\r
+/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_\r
+ * defines, either the default (minimum-sum-of-absolute-differences), or\r
+ * the experimental method (weighted-minimum-sum-of-absolute-differences).\r
+ *\r
+ * Weights are factors >= 1.0, indicating how important it is to keep the\r
+ * filter type consistent between rows. Larger numbers mean the current\r
+ * filter is that many times as likely to be the same as the "num_weights"\r
+ * previous filters. This is cumulative for each previous row with a weight.\r
+ * There needs to be "num_weights" values in "filter_weights", or it can be\r
+ * NULL if the weights aren't being specified. Weights have no influence on\r
+ * the selection of the first row filter. Well chosen weights can (in theory)\r
+ * improve the compression for a given image.\r
+ *\r
+ * Costs are factors >= 1.0 indicating the relative decoding costs of a\r
+ * filter type. Higher costs indicate more decoding expense, and are\r
+ * therefore less likely to be selected over a filter with lower computational\r
+ * costs. There needs to be a value in "filter_costs" for each valid filter\r
+ * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't\r
+ * setting the costs. Costs try to improve the speed of decompression without\r
+ * unduly increasing the compressed image size.\r
+ *\r
+ * A negative weight or cost indicates the default value is to be used, and\r
+ * values in the range [0.0, 1.0) indicate the value is to remain unchanged.\r
+ * The default values for both weights and costs are currently 1.0, but may\r
+ * change if good general weighting/cost heuristics can be found. If both\r
+ * the weights and costs are set to 1.0, this degenerates the WEIGHTED method\r
+ * to the UNWEIGHTED method, but with added encoding time/computation.\r
+ */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr,\r
+ int heuristic_method, int num_weights, png_doublep filter_weights,\r
+ png_doublep filter_costs));\r
+#endif\r
+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */\r
+\r
+/* Heuristic used for row filter selection. These defines should NOT be\r
+ * changed.\r
+ */\r
+#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */\r
+#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */\r
+#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */\r
+#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */\r
+\r
+/* Set the library compression level. Currently, valid values range from\r
+ * 0 - 9, corresponding directly to the zlib compression levels 0 - 9\r
+ * (0 - no compression, 9 - "maximal" compression). Note that tests have\r
+ * shown that zlib compression levels 3-6 usually perform as well as level 9\r
+ * for PNG images, and do considerably fewer caclulations. In the future,\r
+ * these values may not correspond directly to the zlib compression levels.\r
+ */\r
+extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr,\r
+ int level));\r
+\r
+extern PNG_EXPORT(void,png_set_compression_mem_level)\r
+ PNGARG((png_structp png_ptr, int mem_level));\r
+\r
+extern PNG_EXPORT(void,png_set_compression_strategy)\r
+ PNGARG((png_structp png_ptr, int strategy));\r
+\r
+extern PNG_EXPORT(void,png_set_compression_window_bits)\r
+ PNGARG((png_structp png_ptr, int window_bits));\r
+\r
+extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr,\r
+ int method));\r
+\r
+/* These next functions are called for input/output, memory, and error\r
+ * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c,\r
+ * and call standard C I/O routines such as fread(), fwrite(), and\r
+ * fprintf(). These functions can be made to use other I/O routines\r
+ * at run time for those applications that need to handle I/O in a\r
+ * different manner by calling png_set_???_fn(). See libpng.txt for\r
+ * more information.\r
+ */\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+/* Initialize the input/output for the PNG file to the default functions. */\r
+extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp));\r
+#endif\r
+\r
+/* Replace the (error and abort), and warning functions with user\r
+ * supplied functions. If no messages are to be printed you must still\r
+ * write and use replacement functions. The replacement error_fn should\r
+ * still do a longjmp to the last setjmp location if you are using this\r
+ * method of error handling. If error_fn or warning_fn is NULL, the\r
+ * default function will be used.\r
+ */\r
+\r
+extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));\r
+\r
+/* Return the user pointer associated with the error functions */\r
+extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));\r
+\r
+/* Replace the default data output functions with a user supplied one(s).\r
+ * If buffered output is not used, then output_flush_fn can be set to NULL.\r
+ * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time\r
+ * output_flush_fn will be ignored (and thus can be NULL).\r
+ */\r
+extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));\r
+\r
+/* Replace the default data input function with a user supplied one. */\r
+extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp io_ptr, png_rw_ptr read_data_fn));\r
+\r
+/* Return the user pointer associated with the I/O functions */\r
+extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr));\r
+\r
+extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr,\r
+ png_read_status_ptr read_row_fn));\r
+\r
+extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr,\r
+ png_write_status_ptr write_row_fn));\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+/* Replace the default memory allocation functions with user supplied one(s). */\r
+extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn));\r
+/* Return the user pointer associated with the memory functions */\r
+extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp\r
+ png_ptr, png_user_transform_ptr read_user_transform_fn));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp\r
+ png_ptr, png_user_transform_ptr write_user_transform_fn));\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp\r
+ png_ptr, png_voidp user_transform_ptr, int user_transform_depth,\r
+ int user_transform_channels));\r
+/* Return the user pointer associated with the user transform functions */\r
+extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr)\r
+ PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#ifdef PNG_USER_CHUNKS_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));\r
+extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp\r
+ png_ptr));\r
+#endif\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+/* Sets the function callbacks for the push reader, and a pointer to a\r
+ * user-defined structure available to the callback functions.\r
+ */\r
+extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr,\r
+ png_voidp progressive_ptr,\r
+ png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,\r
+ png_progressive_end_ptr end_fn));\r
+\r
+/* returns the user pointer associated with the push read functions */\r
+extern PNG_EXPORT(png_voidp,png_get_progressive_ptr)\r
+ PNGARG((png_structp png_ptr));\r
+\r
+/* function to be called when data becomes available */\r
+extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_bytep buffer, png_size_t buffer_size));\r
+\r
+/* function that combines rows. Not very much different than the\r
+ * png_combine_row() call. Is this even used?????\r
+ */\r
+extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr,\r
+ png_bytep old_row, png_bytep new_row));\r
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */\r
+\r
+extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr,\r
+ png_uint_32 size));\r
+\r
+#if defined(PNG_1_0_X)\r
+# define png_malloc_warn png_malloc\r
+#else\r
+/* Added at libpng version 1.2.4 */\r
+extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr,\r
+ png_uint_32 size));\r
+#endif\r
+\r
+/* frees a pointer allocated by png_malloc() */\r
+extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr));\r
+\r
+#if defined(PNG_1_0_X)\r
+/* Function to allocate memory for zlib. */\r
+extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items,\r
+ uInt size));\r
+\r
+/* Function to free memory for zlib */\r
+extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr));\r
+#endif\r
+\r
+/* Free data that was allocated internally */\r
+extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 free_me, int num));\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+/* Reassign responsibility for freeing existing data, whether allocated\r
+ * by libpng or by the application */\r
+extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int freer, png_uint_32 mask));\r
+#endif\r
+/* assignments for png_data_freer */\r
+#define PNG_DESTROY_WILL_FREE_DATA 1\r
+#define PNG_SET_WILL_FREE_DATA 1\r
+#define PNG_USER_WILL_FREE_DATA 2\r
+/* Flags for png_ptr->free_me and info_ptr->free_me */\r
+#define PNG_FREE_HIST 0x0008\r
+#define PNG_FREE_ICCP 0x0010\r
+#define PNG_FREE_SPLT 0x0020\r
+#define PNG_FREE_ROWS 0x0040\r
+#define PNG_FREE_PCAL 0x0080\r
+#define PNG_FREE_SCAL 0x0100\r
+#define PNG_FREE_UNKN 0x0200\r
+#define PNG_FREE_LIST 0x0400\r
+#define PNG_FREE_PLTE 0x1000\r
+#define PNG_FREE_TRNS 0x2000\r
+#define PNG_FREE_TEXT 0x4000\r
+#define PNG_FREE_ALL 0x7fff\r
+#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr,\r
+ png_uint_32 size));\r
+extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr,\r
+ png_voidp ptr));\r
+#endif\r
+\r
+extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr,\r
+ png_voidp s1, png_voidp s2, png_uint_32 size));\r
+\r
+extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr,\r
+ png_voidp s1, int value, png_uint_32 size));\r
+\r
+#if defined(USE_FAR_KEYWORD) /* memory model conversion function */\r
+extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr,\r
+ int check));\r
+#endif /* USE_FAR_KEYWORD */\r
+\r
+#ifndef PNG_NO_ERROR_TEXT\r
+/* Fatal error in PNG image of libpng - can't continue */\r
+extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr,\r
+ png_const_charp error_message));\r
+\r
+/* The same, but the chunk name is prepended to the error string. */\r
+extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr,\r
+ png_const_charp error_message));\r
+#else\r
+/* Fatal error in PNG image of libpng - can't continue */\r
+extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+#ifndef PNG_NO_WARNINGS\r
+/* Non-fatal error in libpng. Can continue, but may have a problem. */\r
+extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr,\r
+ png_const_charp warning_message));\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+/* Non-fatal error in libpng, chunk name is prepended to message. */\r
+extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr,\r
+ png_const_charp warning_message));\r
+#endif /* PNG_READ_SUPPORTED */\r
+#endif /* PNG_NO_WARNINGS */\r
+\r
+/* The png_set_<chunk> functions are for storing values in the png_info_struct.\r
+ * Similarly, the png_get_<chunk> calls are used to read values from the\r
+ * png_info_struct, either storing the parameters in the passed variables, or\r
+ * setting pointers into the png_info_struct where the data is stored. The\r
+ * png_get_<chunk> functions return a non-zero value if the data was available\r
+ * in info_ptr, or return zero and do not change any of the parameters if the\r
+ * data was not available.\r
+ *\r
+ * These functions should be used instead of directly accessing png_info\r
+ * to avoid problems with future changes in the size and internal layout of\r
+ * png_info_struct.\r
+ */\r
+/* Returns "flag" if chunk data is valid in info_ptr. */\r
+extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr,\r
+png_infop info_ptr, png_uint_32 flag));\r
+\r
+/* Returns number of bytes needed to hold a transformed row. */\r
+extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+/* Returns row_pointers, which is an array of pointers to scanlines that was\r
+returned from png_read_png(). */\r
+extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+/* Set row_pointers, which is an array of pointers to scanlines for use\r
+by png_write_png(). */\r
+extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_bytepp row_pointers));\r
+#endif\r
+\r
+/* Returns number of color channels in image. */\r
+extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+#ifdef PNG_EASY_ACCESS_SUPPORTED\r
+/* Returns image width in pixels. */\r
+extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image height in pixels. */\r
+extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image bit_depth. */\r
+extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image color_type. */\r
+extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image filter_type. */\r
+extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image interlace_type. */\r
+extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image compression_type. */\r
+extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns image resolution in pixels per meter, from pHYs chunk data. */\r
+extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+/* Returns pixel aspect ratio, computed from pHYs chunk data. */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+#endif\r
+\r
+/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */\r
+extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp\r
+png_ptr, png_infop info_ptr));\r
+\r
+#endif /* PNG_EASY_ACCESS_SUPPORTED */\r
+\r
+/* Returns pointer to signature string read from PNG header */\r
+extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+#if defined(PNG_bKGD_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_color_16p *background));\r
+#endif\r
+\r
+#if defined(PNG_bKGD_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_color_16p background));\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, double *white_x, double *white_y, double *red_x,\r
+ double *red_y, double *green_x, double *green_y, double *blue_x,\r
+ double *blue_y));\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point\r
+ *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y,\r
+ png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point\r
+ *int_blue_x, png_fixed_point *int_blue_y));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, double white_x, double white_y, double red_x,\r
+ double red_y, double green_x, double green_y, double blue_x, double blue_y));\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y,\r
+ png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point\r
+ int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,\r
+ png_fixed_point int_blue_y));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, double *file_gamma));\r
+#endif\r
+extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_fixed_point *int_file_gamma));\r
+#endif\r
+\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, double file_gamma));\r
+#endif\r
+extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_fixed_point int_file_gamma));\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_16p *hist));\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_16p hist));\r
+#endif\r
+\r
+extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 *width, png_uint_32 *height,\r
+ int *bit_depth, int *color_type, int *interlace_method,\r
+ int *compression_method, int *filter_method));\r
+\r
+extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,\r
+ int color_type, int interlace_method, int compression_method,\r
+ int filter_method));\r
+\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,\r
+ int *unit_type));\r
+#endif\r
+\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y,\r
+ int unit_type));\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1,\r
+ int *type, int *nparams, png_charp *units, png_charpp *params));\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1,\r
+ int type, int nparams, png_charp units, png_charpp params));\r
+#endif\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));\r
+#endif\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));\r
+#endif\r
+\r
+extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_colorp *palette, int *num_palette));\r
+\r
+extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_colorp palette, int num_palette));\r
+\r
+#if defined(PNG_sBIT_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_color_8p *sig_bit));\r
+#endif\r
+\r
+#if defined(PNG_sBIT_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_color_8p sig_bit));\r
+#endif\r
+\r
+#if defined(PNG_sRGB_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int *intent));\r
+#endif\r
+\r
+#if defined(PNG_sRGB_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int intent));\r
+extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int intent));\r
+#endif\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_charpp name, int *compression_type,\r
+ png_charpp profile, png_uint_32 *proflen));\r
+ /* Note to maintainer: profile should be png_bytepp */\r
+#endif\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_charp name, int compression_type,\r
+ png_charp profile, png_uint_32 proflen));\r
+ /* Note to maintainer: profile should be png_bytep */\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_sPLT_tpp entries));\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_sPLT_tp entries, int nentries));\r
+#endif\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+/* png_get_text also returns the number of text chunks in *num_text */\r
+extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_textp *text_ptr, int *num_text));\r
+#endif\r
+\r
+/*\r
+ * Note while png_set_text() will accept a structure whose text,\r
+ * language, and translated keywords are NULL pointers, the structure\r
+ * returned by png_get_text will always contain regular\r
+ * zero-terminated C strings. They might be empty strings but\r
+ * they will never be NULL pointers.\r
+ */\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_textp text_ptr, int num_text));\r
+#endif\r
+\r
+#if defined(PNG_tIME_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_timep *mod_time));\r
+#endif\r
+\r
+#if defined(PNG_tIME_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_timep mod_time));\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_bytep *trans, int *num_trans,\r
+ png_color_16p *trans_values));\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_bytep trans, int num_trans,\r
+ png_color_16p trans_values));\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+#endif\r
+\r
+#if defined(PNG_sCAL_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int *unit, double *width, double *height));\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight));\r
+#endif\r
+#endif\r
+#endif /* PNG_sCAL_SUPPORTED */\r
+\r
+#if defined(PNG_sCAL_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int unit, double width, double height));\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int unit, png_charp swidth, png_charp sheight));\r
+#endif\r
+#endif\r
+#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+/* provide a list of chunks and how they are to be handled, if the built-in\r
+ handling or default unknown chunk handling is not desired. Any chunks not\r
+ listed will be handled in the default manner. The IHDR and IEND chunks\r
+ must not be listed.\r
+ keep = 0: follow default behaviour\r
+ = 1: do not keep\r
+ = 2: keep only if safe-to-copy\r
+ = 3: keep even if unsafe-to-copy\r
+*/\r
+extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp\r
+ png_ptr, int keep, png_bytep chunk_list, int num_chunks));\r
+extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns));\r
+extern PNG_EXPORT(void, png_set_unknown_chunk_location)\r
+ PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location));\r
+extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp\r
+ png_ptr, png_infop info_ptr, png_unknown_chunkpp entries));\r
+#endif\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep\r
+ chunk_name));\r
+#endif\r
+\r
+/* Png_free_data() will turn off the "valid" flag for anything it frees.\r
+ If you need to turn it off for a chunk that your application has freed,\r
+ you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */\r
+extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, int mask));\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+/* The "params" pointer is currently not used and is for future expansion. */\r
+extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr,\r
+ int transforms,\r
+ png_voidp params));\r
+extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr,\r
+ int transforms,\r
+ png_voidp params));\r
+#endif\r
+\r
+/* Define PNG_DEBUG at compile time for debugging information. Higher\r
+ * numbers for PNG_DEBUG mean more debugging information. This has\r
+ * only been added since version 0.95 so it is not implemented throughout\r
+ * libpng yet, but more support will be added as needed.\r
+ */\r
+#ifdef PNG_DEBUG\r
+#if (PNG_DEBUG > 0)\r
+#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER)\r
+#include <crtdbg.h>\r
+#if (PNG_DEBUG > 1)\r
+#define png_debug(l,m) _RPT0(_CRT_WARN,m)\r
+#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1)\r
+#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2)\r
+#endif\r
+#else /* PNG_DEBUG_FILE || !_MSC_VER */\r
+#ifndef PNG_DEBUG_FILE\r
+#define PNG_DEBUG_FILE stderr\r
+#endif /* PNG_DEBUG_FILE */\r
+#if (PNG_DEBUG > 1)\r
+#define png_debug(l,m) \\r
+{ \\r
+ int num_tabs=l; \\r
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \\r
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \\r
+}\r
+#define png_debug1(l,m,p1) \\r
+{ \\r
+ int num_tabs=l; \\r
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \\r
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \\r
+}\r
+#define png_debug2(l,m,p1,p2) \\r
+{ \\r
+ int num_tabs=l; \\r
+ fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \\r
+ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \\r
+}\r
+#endif /* (PNG_DEBUG > 1) */\r
+#endif /* _MSC_VER */\r
+#endif /* (PNG_DEBUG > 0) */\r
+#endif /* PNG_DEBUG */\r
+#ifndef png_debug\r
+#define png_debug(l, m)\r
+#endif\r
+#ifndef png_debug1\r
+#define png_debug1(l, m, p1)\r
+#endif\r
+#ifndef png_debug2\r
+#define png_debug2(l, m, p1, p2)\r
+#endif\r
+\r
+extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr));\r
+extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr));\r
+extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr));\r
+extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr));\r
+\r
+#ifdef PNG_MNG_FEATURES_SUPPORTED\r
+extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp\r
+ png_ptr, png_uint_32 mng_features_permitted));\r
+#endif\r
+\r
+/* For use in png_set_keep_unknown, added to version 1.2.6 */\r
+#define PNG_HANDLE_CHUNK_AS_DEFAULT 0\r
+#define PNG_HANDLE_CHUNK_NEVER 1\r
+#define PNG_HANDLE_CHUNK_IF_SAFE 2\r
+#define PNG_HANDLE_CHUNK_ALWAYS 3\r
+\r
+/* Added to version 1.2.0 */\r
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)\r
+#if defined(PNG_MMX_CODE_SUPPORTED)\r
+#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */\r
+#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */\r
+#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04\r
+#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08\r
+#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10\r
+#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20\r
+#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40\r
+#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80\r
+#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */\r
+\r
+#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \\r
+ | PNG_ASM_FLAG_MMX_READ_INTERLACE \\r
+ | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \\r
+ | PNG_ASM_FLAG_MMX_READ_FILTER_UP \\r
+ | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \\r
+ | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH )\r
+#define PNG_MMX_WRITE_FLAGS ( 0 )\r
+\r
+#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \\r
+ | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \\r
+ | PNG_MMX_READ_FLAGS \\r
+ | PNG_MMX_WRITE_FLAGS )\r
+\r
+#define PNG_SELECT_READ 1\r
+#define PNG_SELECT_WRITE 2\r
+#endif /* PNG_MMX_CODE_SUPPORTED */\r
+\r
+#if !defined(PNG_1_0_X)\r
+/* pngget.c */\r
+extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask)\r
+ PNGARG((int flag_select, int *compilerID));\r
+\r
+/* pngget.c */\r
+extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask)\r
+ PNGARG((int flag_select));\r
+\r
+/* pngget.c */\r
+extern PNG_EXPORT(png_uint_32,png_get_asm_flags)\r
+ PNGARG((png_structp png_ptr));\r
+\r
+/* pngget.c */\r
+extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold)\r
+ PNGARG((png_structp png_ptr));\r
+\r
+/* pngget.c */\r
+extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold)\r
+ PNGARG((png_structp png_ptr));\r
+\r
+/* pngset.c */\r
+extern PNG_EXPORT(void,png_set_asm_flags)\r
+ PNGARG((png_structp png_ptr, png_uint_32 asm_flags));\r
+\r
+/* pngset.c */\r
+extern PNG_EXPORT(void,png_set_mmx_thresholds)\r
+ PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold,\r
+ png_uint_32 mmx_rowbytes_threshold));\r
+\r
+#endif /* PNG_1_0_X */\r
+\r
+#if !defined(PNG_1_0_X)\r
+/* png.c, pnggccrd.c, or pngvcrd.c */\r
+extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));\r
+#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */\r
+\r
+/* Strip the prepended error numbers ("#nnn ") from error and warning\r
+ * messages before passing them to the error or warning handler. */\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp\r
+ png_ptr, png_uint_32 strip_mode));\r
+#endif\r
+\r
+#endif /* PNG_1_0_X */\r
+\r
+/* Added at libpng-1.2.6 */\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp\r
+ png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max));\r
+extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp\r
+ png_ptr));\r
+extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp\r
+ png_ptr));\r
+#endif\r
+\r
+\r
+/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */\r
+\r
+#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED\r
+/* With these routines we avoid an integer divide, which will be slower on\r
+ * most machines. However, it does take more operations than the corresponding\r
+ * divide method, so it may be slower on a few RISC systems. There are two\r
+ * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.\r
+ *\r
+ * Note that the rounding factors are NOT supposed to be the same! 128 and\r
+ * 32768 are correct for the NODIV code; 127 and 32767 are correct for the\r
+ * standard method.\r
+ *\r
+ * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]\r
+ */\r
+\r
+ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */\r
+\r
+# define png_composite(composite, fg, alpha, bg) \\r
+ { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \\r
+ + (png_uint_16)(bg)*(png_uint_16)(255 - \\r
+ (png_uint_16)(alpha)) + (png_uint_16)128); \\r
+ (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }\r
+\r
+# define png_composite_16(composite, fg, alpha, bg) \\r
+ { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \\r
+ + (png_uint_32)(bg)*(png_uint_32)(65535L - \\r
+ (png_uint_32)(alpha)) + (png_uint_32)32768L); \\r
+ (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }\r
+\r
+#else /* standard method using integer division */\r
+\r
+# define png_composite(composite, fg, alpha, bg) \\r
+ (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \\r
+ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \\r
+ (png_uint_16)127) / 255)\r
+\r
+# define png_composite_16(composite, fg, alpha, bg) \\r
+ (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \\r
+ (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \\r
+ (png_uint_32)32767) / (png_uint_32)65535L)\r
+\r
+#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */\r
+\r
+/* Inline macros to do direct reads of bytes from the input buffer. These\r
+ * require that you are using an architecture that uses PNG byte ordering\r
+ * (MSB first) and supports unaligned data storage. I think that PowerPC\r
+ * in big-endian mode and 680x0 are the only ones that will support this.\r
+ * The x86 line of processors definitely do not. The png_get_int_32()\r
+ * routine also assumes we are using two's complement format for negative\r
+ * values, which is almost certainly true.\r
+ */\r
+#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED)\r
+# define png_get_uint_32(buf) ( *((png_uint_32p) (buf)))\r
+# define png_get_uint_16(buf) ( *((png_uint_16p) (buf)))\r
+# define png_get_int_32(buf) ( *((png_int_32p) (buf)))\r
+#else\r
+extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf));\r
+extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf));\r
+extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf));\r
+#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */\r
+extern PNG_EXPORT(png_uint_32,png_get_uint_31)\r
+ PNGARG((png_structp png_ptr, png_bytep buf));\r
+/* No png_get_int_16 -- may be added if there's a real need for it. */\r
+\r
+/* Place a 32-bit number into a buffer in PNG byte order (big-endian).\r
+ */\r
+extern PNG_EXPORT(void,png_save_uint_32)\r
+ PNGARG((png_bytep buf, png_uint_32 i));\r
+extern PNG_EXPORT(void,png_save_int_32)\r
+ PNGARG((png_bytep buf, png_int_32 i));\r
+\r
+/* Place a 16-bit number into a buffer in PNG byte order.\r
+ * The parameter is declared unsigned int, not png_uint_16,\r
+ * just to avoid potential problems on pre-ANSI C compilers.\r
+ */\r
+extern PNG_EXPORT(void,png_save_uint_16)\r
+ PNGARG((png_bytep buf, unsigned int i));\r
+/* No png_save_int_16 -- may be added if there's a real need for it. */\r
+\r
+/* ************************************************************************* */\r
+\r
+/* These next functions are used internally in the code. They generally\r
+ * shouldn't be used unless you are writing code to add or replace some\r
+ * functionality in libpng. More information about most functions can\r
+ * be found in the files where the functions are located.\r
+ */\r
+\r
+\r
+/* Various modes of operation, that are visible to applications because\r
+ * they are used for unknown chunk location.\r
+ */\r
+#define PNG_HAVE_IHDR 0x01\r
+#define PNG_HAVE_PLTE 0x02\r
+#define PNG_HAVE_IDAT 0x04\r
+#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */\r
+#define PNG_HAVE_IEND 0x10\r
+\r
+#if defined(PNG_INTERNAL)\r
+\r
+/* More modes of operation. Note that after an init, mode is set to\r
+ * zero automatically when the structure is created.\r
+ */\r
+#define PNG_HAVE_gAMA 0x20\r
+#define PNG_HAVE_cHRM 0x40\r
+#define PNG_HAVE_sRGB 0x80\r
+#define PNG_HAVE_CHUNK_HEADER 0x100\r
+#define PNG_WROTE_tIME 0x200\r
+#define PNG_WROTE_INFO_BEFORE_PLTE 0x400\r
+#define PNG_BACKGROUND_IS_GRAY 0x800\r
+#define PNG_HAVE_PNG_SIGNATURE 0x1000\r
+#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */\r
+\r
+/* flags for the transformations the PNG library does on the image data */\r
+#define PNG_BGR 0x0001\r
+#define PNG_INTERLACE 0x0002\r
+#define PNG_PACK 0x0004\r
+#define PNG_SHIFT 0x0008\r
+#define PNG_SWAP_BYTES 0x0010\r
+#define PNG_INVERT_MONO 0x0020\r
+#define PNG_DITHER 0x0040\r
+#define PNG_BACKGROUND 0x0080\r
+#define PNG_BACKGROUND_EXPAND 0x0100\r
+ /* 0x0200 unused */\r
+#define PNG_16_TO_8 0x0400\r
+#define PNG_RGBA 0x0800\r
+#define PNG_EXPAND 0x1000\r
+#define PNG_GAMMA 0x2000\r
+#define PNG_GRAY_TO_RGB 0x4000\r
+#define PNG_FILLER 0x8000L\r
+#define PNG_PACKSWAP 0x10000L\r
+#define PNG_SWAP_ALPHA 0x20000L\r
+#define PNG_STRIP_ALPHA 0x40000L\r
+#define PNG_INVERT_ALPHA 0x80000L\r
+#define PNG_USER_TRANSFORM 0x100000L\r
+#define PNG_RGB_TO_GRAY_ERR 0x200000L\r
+#define PNG_RGB_TO_GRAY_WARN 0x400000L\r
+#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */\r
+ /* 0x800000L Unused */\r
+#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */\r
+#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */\r
+ /* 0x4000000L unused */\r
+ /* 0x8000000L unused */\r
+ /* 0x10000000L unused */\r
+ /* 0x20000000L unused */\r
+ /* 0x40000000L unused */\r
+\r
+/* flags for png_create_struct */\r
+#define PNG_STRUCT_PNG 0x0001\r
+#define PNG_STRUCT_INFO 0x0002\r
+\r
+/* Scaling factor for filter heuristic weighting calculations */\r
+#define PNG_WEIGHT_SHIFT 8\r
+#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))\r
+#define PNG_COST_SHIFT 3\r
+#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))\r
+\r
+/* flags for the png_ptr->flags rather than declaring a byte for each one */\r
+#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001\r
+#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002\r
+#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004\r
+#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008\r
+#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010\r
+#define PNG_FLAG_ZLIB_FINISHED 0x0020\r
+#define PNG_FLAG_ROW_INIT 0x0040\r
+#define PNG_FLAG_FILLER_AFTER 0x0080\r
+#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100\r
+#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200\r
+#define PNG_FLAG_CRC_CRITICAL_USE 0x0400\r
+#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800\r
+#define PNG_FLAG_FREE_PLTE 0x1000\r
+#define PNG_FLAG_FREE_TRNS 0x2000\r
+#define PNG_FLAG_FREE_HIST 0x4000\r
+#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L\r
+#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L\r
+#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L\r
+#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L\r
+#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L\r
+#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L\r
+#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */\r
+#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */\r
+ /* 0x800000L unused */\r
+ /* 0x1000000L unused */\r
+ /* 0x2000000L unused */\r
+ /* 0x4000000L unused */\r
+ /* 0x8000000L unused */\r
+ /* 0x10000000L unused */\r
+ /* 0x20000000L unused */\r
+ /* 0x40000000L unused */\r
+\r
+#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \\r
+ PNG_FLAG_CRC_ANCILLARY_NOWARN)\r
+\r
+#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \\r
+ PNG_FLAG_CRC_CRITICAL_IGNORE)\r
+\r
+#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \\r
+ PNG_FLAG_CRC_CRITICAL_MASK)\r
+\r
+/* save typing and make code easier to understand */\r
+\r
+#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \\r
+ abs((int)((c1).green) - (int)((c2).green)) + \\r
+ abs((int)((c1).blue) - (int)((c2).blue)))\r
+\r
+/* Added to libpng-1.2.6 JB */\r
+#define PNG_ROWBYTES(pixel_bits, width) \\r
+ ((pixel_bits) >= 8 ? \\r
+ ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \\r
+ (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) )\r
+\r
+/* PNG_OUT_OF_RANGE returns true if value is outside the range\r
+ ideal-delta..ideal+delta. Each argument is evaluated twice.\r
+ "ideal" and "delta" should be constants, normally simple\r
+ integers, "value" a variable. Added to libpng-1.2.6 JB */\r
+#define PNG_OUT_OF_RANGE(value, ideal, delta) \\r
+ ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )\r
+\r
+/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */\r
+#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)\r
+/* place to hold the signature string for a PNG file. */\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+ PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8];\r
+#else\r
+#endif\r
+#endif /* PNG_NO_EXTERN */\r
+\r
+/* Constant strings for known chunk types. If you need to add a chunk,\r
+ * define the name here, and add an invocation of the macro in png.c and\r
+ * wherever it's needed.\r
+ */\r
+#define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'}\r
+#define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'}\r
+#define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'}\r
+#define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'}\r
+#define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'}\r
+#define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'}\r
+#define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'}\r
+#define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'}\r
+#define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'}\r
+#define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'}\r
+#define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'}\r
+#define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'}\r
+#define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'}\r
+#define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'}\r
+#define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'}\r
+#define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'}\r
+#define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'}\r
+#define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'}\r
+#define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'}\r
+#define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'}\r
+#define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'}\r
+\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5];\r
+PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5];\r
+#endif /* PNG_USE_GLOBAL_ARRAYS */\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Initialize png_ptr struct for reading, and allocate any other memory.\r
+ * (old interface - DEPRECATED - use png_create_read_struct instead).\r
+ */\r
+extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr));\r
+#undef png_read_init\r
+#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \\r
+ PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));\r
+#endif\r
+\r
+extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr,\r
+ png_const_charp user_png_ver, png_size_t png_struct_size));\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr,\r
+ png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t\r
+ png_info_size));\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Initialize png_ptr struct for writing, and allocate any other memory.\r
+ * (old interface - DEPRECATED - use png_create_write_struct instead).\r
+ */\r
+extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr));\r
+#undef png_write_init\r
+#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \\r
+ PNG_LIBPNG_VER_STRING, png_sizeof(png_struct));\r
+#endif\r
+\r
+extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr,\r
+ png_const_charp user_png_ver, png_size_t png_struct_size));\r
+extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr,\r
+ png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t\r
+ png_info_size));\r
+\r
+/* Allocate memory for an internal libpng struct */\r
+PNG_EXTERN png_voidp png_create_struct PNGARG((int type));\r
+\r
+/* Free memory from internal libpng struct */\r
+PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));\r
+\r
+PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr\r
+ malloc_fn, png_voidp mem_ptr));\r
+PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,\r
+ png_free_ptr free_fn, png_voidp mem_ptr));\r
+\r
+/* Free any memory that info_ptr points to and reset struct. */\r
+PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+\r
+#ifndef PNG_1_0_X\r
+/* Function to allocate memory for zlib. */\r
+PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size));\r
+\r
+/* Function to free memory for zlib */\r
+PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));\r
+\r
+#ifdef PNG_SIZE_T\r
+/* Function to convert a sizeof an item to png_sizeof item */\r
+ PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size));\r
+#endif\r
+\r
+/* Next four functions are used internally as callbacks. PNGAPI is required\r
+ * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */\r
+\r
+PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr,\r
+ png_bytep data, png_size_t length));\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr,\r
+ png_bytep buffer, png_size_t length));\r
+#endif\r
+\r
+PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr,\r
+ png_bytep data, png_size_t length));\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+#if !defined(PNG_NO_STDIO)\r
+PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr));\r
+#endif\r
+#endif\r
+#else /* PNG_1_0_X */\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr,\r
+ png_bytep buffer, png_size_t length));\r
+#endif\r
+#endif /* PNG_1_0_X */\r
+\r
+/* Reset the CRC variable */\r
+PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));\r
+\r
+/* Write the "data" buffer to whatever output you are using. */\r
+PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data,\r
+ png_size_t length));\r
+\r
+/* Read data from whatever input you are using into the "data" buffer */\r
+PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,\r
+ png_size_t length));\r
+\r
+/* Read bytes into buf, and update png_ptr->crc */\r
+PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,\r
+ png_size_t length));\r
+\r
+/* Decompress data in a chunk that uses compression */\r
+#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \\r
+ defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)\r
+PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,\r
+ int comp_type, png_size_t chunklength,\r
+ png_size_t prefix_length, png_size_t *data_length));\r
+#endif\r
+\r
+/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */\r
+PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));\r
+\r
+/* Read the CRC from the file and compare it to the libpng calculated CRC */\r
+PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));\r
+\r
+/* Calculate the CRC over a section of data. Note that we are only\r
+ * passing a maximum of 64K on systems that have this as a memory limit,\r
+ * since this is the maximum buffer size we can specify.\r
+ */\r
+PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr,\r
+ png_size_t length));\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+/* simple function to write the signature */\r
+PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr));\r
+\r
+/* write various chunks */\r
+\r
+/* Write the IHDR chunk, and update the png_struct with the necessary\r
+ * information.\r
+ */\r
+PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,\r
+ png_uint_32 height,\r
+ int bit_depth, int color_type, int compression_method, int filter_method,\r
+ int interlace_method));\r
+\r
+PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette,\r
+ png_uint_32 num_pal));\r
+\r
+PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data,\r
+ png_size_t length));\r
+\r
+PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr));\r
+\r
+#if defined(PNG_WRITE_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point\r
+ file_gamma));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sBIT_SUPPORTED)\r
+PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit,\r
+ int color_type));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,\r
+ double white_x, double white_y,\r
+ double red_x, double red_y, double green_x, double green_y,\r
+ double blue_x, double blue_y));\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,\r
+ png_fixed_point int_white_x, png_fixed_point int_white_y,\r
+ png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point\r
+ int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,\r
+ png_fixed_point int_blue_y));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sRGB_SUPPORTED)\r
+PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,\r
+ int intent));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_iCCP_SUPPORTED)\r
+PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,\r
+ png_charp name, int compression_type,\r
+ png_charp profile, int proflen));\r
+ /* Note to maintainer: profile should be png_bytep */\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sPLT_SUPPORTED)\r
+PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,\r
+ png_sPLT_tp palette));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tRNS_SUPPORTED)\r
+PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans,\r
+ png_color_16p values, int number, int color_type));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_bKGD_SUPPORTED)\r
+PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,\r
+ png_color_16p values, int color_type));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_hIST_SUPPORTED)\r
+PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist,\r
+ int num_hist));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \\r
+ defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)\r
+PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,\r
+ png_charp key, png_charpp new_key));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tEXt_SUPPORTED)\r
+PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key,\r
+ png_charp text, png_size_t text_len));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_zTXt_SUPPORTED)\r
+PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key,\r
+ png_charp text, png_size_t text_len, int compression));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_iTXt_SUPPORTED)\r
+PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,\r
+ int compression, png_charp key, png_charp lang, png_charp lang_key,\r
+ png_charp text));\r
+#endif\r
+\r
+#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */\r
+PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_textp text_ptr, int num_text));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_oFFs_SUPPORTED)\r
+PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,\r
+ png_int_32 x_offset, png_int_32 y_offset, int unit_type));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_pCAL_SUPPORTED)\r
+PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,\r
+ png_int_32 X0, png_int_32 X1, int type, int nparams,\r
+ png_charp units, png_charpp params));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_pHYs_SUPPORTED)\r
+PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,\r
+ png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,\r
+ int unit_type));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,\r
+ png_timep mod_time));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sCAL_SUPPORTED)\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)\r
+PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr,\r
+ int unit, double width, double height));\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,\r
+ int unit, png_charp width, png_charp height));\r
+#endif\r
+#endif\r
+#endif\r
+\r
+/* Called when finished processing a row of data */\r
+PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));\r
+\r
+/* Internal use only. Called before first row of data */\r
+PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+/* combine a row of data, dealing with alpha, etc. if requested */\r
+PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,\r
+ int mask));\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED)\r
+/* expand an interlaced row */\r
+/* OLD pre-1.0.9 interface:\r
+PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,\r
+ png_bytep row, int pass, png_uint_32 transformations));\r
+ */\r
+PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));\r
+#endif\r
+\r
+/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */\r
+\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+/* grab pixels out of a row for an interlaced pass */\r
+PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,\r
+ png_bytep row, int pass));\r
+#endif\r
+\r
+/* unfilter a row */\r
+PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,\r
+ png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter));\r
+\r
+/* Choose the best filter to use and filter the row data */\r
+PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,\r
+ png_row_infop row_info));\r
+\r
+/* Write out the filtered row. */\r
+PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,\r
+ png_bytep filtered_row));\r
+/* finish a row while reading, dealing with interlacing passes, etc. */\r
+PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));\r
+\r
+/* initialize the row buffers, etc. */\r
+PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));\r
+/* optional call to update the users info structure */\r
+PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+\r
+/* these are the functions that do the transformations */\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_uint_32 filler, png_uint_32 flags));\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)\r
+PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)\r
+PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \\r
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_uint_32 flags));\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
+PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop\r
+ row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED)\r
+PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED)\r
+PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row,\r
+ png_color_8p sig_bits));\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)\r
+PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup));\r
+\r
+# if defined(PNG_CORRECT_PALETTE_SUPPORTED)\r
+PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,\r
+ png_colorp palette, int num_palette));\r
+# endif\r
+#endif\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
+PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_PACK_SUPPORTED)\r
+PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_uint_32 bit_depth));\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row,\r
+ png_color_8p bit_depth));\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,\r
+ png_color_16p trans_values, png_color_16p background,\r
+ png_color_16p background_1,\r
+ png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,\r
+ png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,\r
+ png_uint_16pp gamma_16_to_1, int gamma_shift));\r
+#else\r
+PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row,\r
+ png_color_16p trans_values, png_color_16p background));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row,\r
+ png_bytep gamma_table, png_uint_16pp gamma_16_table,\r
+ int gamma_shift));\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_colorp palette, png_bytep trans, int num_trans));\r
+PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,\r
+ png_bytep row, png_color_16p trans_value));\r
+#endif\r
+\r
+/* The following decodes the appropriate chunks, and does error correction,\r
+ * then calls the appropriate callback for the chunk if it is valid.\r
+ */\r
+\r
+/* decode the IHDR chunk */\r
+PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif /* PNG_READ_iCCP_SUPPORTED */\r
+\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif /* PNG_READ_sPLT_SUPPORTED */\r
+\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 length));\r
+#endif\r
+\r
+PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 length));\r
+\r
+PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr,\r
+ png_bytep chunk_name));\r
+\r
+/* handle the transformations for reading and writing */\r
+PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));\r
+\r
+PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr));\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,\r
+ png_uint_32 length));\r
+PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,\r
+ png_bytep buffer, png_size_t buffer_length));\r
+PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,\r
+ png_bytep buffer, png_size_t buffer_length));\r
+PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));\r
+PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 length));\r
+PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));\r
+PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 length));\r
+PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 length));\r
+PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr, png_uint_32 length));\r
+PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,\r
+ png_infop info_ptr));\r
+#endif\r
+\r
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */\r
+\r
+#ifdef PNG_MNG_FEATURES_SUPPORTED\r
+PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,\r
+ png_bytep row));\r
+#endif\r
+\r
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED)\r
+#if defined(PNG_MMX_CODE_SUPPORTED)\r
+/* png.c */ /* PRIVATE */\r
+PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr));\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr,\r
+png_infop info_ptr));\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr,\r
+png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type));\r
+#endif /* PNG_pHYs_SUPPORTED */\r
+#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */\r
+\r
+/* Read the chunk header (length + type name) */\r
+PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));\r
+\r
+/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */\r
+\r
+#endif /* PNG_INTERNAL */\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif /* PNG_VERSION_INFO_ONLY */\r
+/* do not put anything past this line */\r
+#endif /* PNG_H */\r
--- /dev/null
+\r
+/* pngconf.h - machine configurable file for libpng\r
+ *\r
+ * libpng version 1.2.33 - October 31, 2008\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+/* Any machine specific code is near the front of this file, so if you\r
+ * are configuring libpng for a machine, you may want to read the section\r
+ * starting here down to where it starts to typedef png_color, png_text,\r
+ * and png_info.\r
+ */\r
+\r
+#ifndef PNGCONF_H\r
+#define PNGCONF_H\r
+\r
+#define PNG_1_2_X\r
+\r
+/* \r
+ * PNG_USER_CONFIG has to be defined on the compiler command line. This\r
+ * includes the resource compiler for Windows DLL configurations.\r
+ */\r
+#ifdef PNG_USER_CONFIG\r
+# ifndef PNG_USER_PRIVATEBUILD\r
+# define PNG_USER_PRIVATEBUILD\r
+# endif\r
+#include "pngusr.h"\r
+#endif\r
+\r
+/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */\r
+#ifdef PNG_CONFIGURE_LIBPNG\r
+#ifdef HAVE_CONFIG_H\r
+#include "config.h"\r
+#endif\r
+#endif\r
+\r
+/*\r
+ * Added at libpng-1.2.8\r
+ * \r
+ * If you create a private DLL you need to define in "pngusr.h" the followings:\r
+ * #define PNG_USER_PRIVATEBUILD <Describes by whom and why this version of\r
+ * the DLL was built>\r
+ * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons."\r
+ * #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to\r
+ * distinguish your DLL from those of the official release. These\r
+ * correspond to the trailing letters that come after the version\r
+ * number and must match your private DLL name>\r
+ * e.g. // private DLL "libpng13gx.dll"\r
+ * #define PNG_USER_DLLFNAME_POSTFIX "gx"\r
+ * \r
+ * The following macros are also at your disposal if you want to complete the \r
+ * DLL VERSIONINFO structure.\r
+ * - PNG_USER_VERSIONINFO_COMMENTS\r
+ * - PNG_USER_VERSIONINFO_COMPANYNAME\r
+ * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS\r
+ */\r
+\r
+#ifdef __STDC__\r
+#ifdef SPECIALBUILD\r
+# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\\r
+ are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.")\r
+#endif\r
+\r
+#ifdef PRIVATEBUILD\r
+# pragma message("PRIVATEBUILD is deprecated.\\r
+ Use PNG_USER_PRIVATEBUILD instead.")\r
+# define PNG_USER_PRIVATEBUILD PRIVATEBUILD\r
+#endif\r
+#endif /* __STDC__ */\r
+\r
+#ifndef PNG_VERSION_INFO_ONLY\r
+\r
+/* End of material added to libpng-1.2.8 */\r
+\r
+/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble\r
+ Restored at libpng-1.2.21 */\r
+#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \\r
+ !defined(PNG_WARN_UNINITIALIZED_ROW)\r
+# define PNG_WARN_UNINITIALIZED_ROW 1\r
+#endif\r
+/* End of material added at libpng-1.2.19/1.2.21 */\r
+\r
+/* This is the size of the compression buffer, and thus the size of\r
+ * an IDAT chunk. Make this whatever size you feel is best for your\r
+ * machine. One of these will be allocated per png_struct. When this\r
+ * is full, it writes the data to the disk, and does some other\r
+ * calculations. Making this an extremely small size will slow\r
+ * the library down, but you may want to experiment to determine\r
+ * where it becomes significant, if you are concerned with memory\r
+ * usage. Note that zlib allocates at least 32Kb also. For readers,\r
+ * this describes the size of the buffer available to read the data in.\r
+ * Unless this gets smaller than the size of a row (compressed),\r
+ * it should not make much difference how big this is.\r
+ */\r
+\r
+#ifndef PNG_ZBUF_SIZE\r
+# define PNG_ZBUF_SIZE 8192\r
+#endif\r
+\r
+/* Enable if you want a write-only libpng */\r
+\r
+#ifndef PNG_NO_READ_SUPPORTED\r
+# define PNG_READ_SUPPORTED\r
+#endif\r
+\r
+/* Enable if you want a read-only libpng */\r
+\r
+#ifndef PNG_NO_WRITE_SUPPORTED\r
+# define PNG_WRITE_SUPPORTED\r
+#endif\r
+\r
+/* Enabled by default in 1.2.0. You can disable this if you don't need to\r
+ support PNGs that are embedded in MNG datastreams */\r
+#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES)\r
+# ifndef PNG_MNG_FEATURES_SUPPORTED\r
+# define PNG_MNG_FEATURES_SUPPORTED\r
+# endif\r
+#endif\r
+\r
+#ifndef PNG_NO_FLOATING_POINT_SUPPORTED\r
+# ifndef PNG_FLOATING_POINT_SUPPORTED\r
+# define PNG_FLOATING_POINT_SUPPORTED\r
+# endif\r
+#endif\r
+\r
+/* If you are running on a machine where you cannot allocate more\r
+ * than 64K of memory at once, uncomment this. While libpng will not\r
+ * normally need that much memory in a chunk (unless you load up a very\r
+ * large file), zlib needs to know how big of a chunk it can use, and\r
+ * libpng thus makes sure to check any memory allocation to verify it\r
+ * will fit into memory.\r
+#define PNG_MAX_MALLOC_64K\r
+ */\r
+#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)\r
+# define PNG_MAX_MALLOC_64K\r
+#endif\r
+\r
+/* Special munging to support doing things the 'cygwin' way:\r
+ * 'Normal' png-on-win32 defines/defaults:\r
+ * PNG_BUILD_DLL -- building dll\r
+ * PNG_USE_DLL -- building an application, linking to dll\r
+ * (no define) -- building static library, or building an\r
+ * application and linking to the static lib\r
+ * 'Cygwin' defines/defaults:\r
+ * PNG_BUILD_DLL -- (ignored) building the dll\r
+ * (no define) -- (ignored) building an application, linking to the dll\r
+ * PNG_STATIC -- (ignored) building the static lib, or building an \r
+ * application that links to the static lib.\r
+ * ALL_STATIC -- (ignored) building various static libs, or building an \r
+ * application that links to the static libs.\r
+ * Thus,\r
+ * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and\r
+ * this bit of #ifdefs will define the 'correct' config variables based on\r
+ * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but\r
+ * unnecessary.\r
+ *\r
+ * Also, the precedence order is:\r
+ * ALL_STATIC (since we can't #undef something outside our namespace)\r
+ * PNG_BUILD_DLL\r
+ * PNG_STATIC\r
+ * (nothing) == PNG_USE_DLL\r
+ * \r
+ * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent\r
+ * of auto-import in binutils, we no longer need to worry about \r
+ * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore,\r
+ * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes\r
+ * to __declspec() stuff. However, we DO need to worry about \r
+ * PNG_BUILD_DLL and PNG_STATIC because those change some defaults\r
+ * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed.\r
+ */\r
+#if defined(__CYGWIN__)\r
+# if defined(ALL_STATIC)\r
+# if defined(PNG_BUILD_DLL)\r
+# undef PNG_BUILD_DLL\r
+# endif\r
+# if defined(PNG_USE_DLL)\r
+# undef PNG_USE_DLL\r
+# endif\r
+# if defined(PNG_DLL)\r
+# undef PNG_DLL\r
+# endif\r
+# if !defined(PNG_STATIC)\r
+# define PNG_STATIC\r
+# endif\r
+# else\r
+# if defined (PNG_BUILD_DLL)\r
+# if defined(PNG_STATIC)\r
+# undef PNG_STATIC\r
+# endif\r
+# if defined(PNG_USE_DLL)\r
+# undef PNG_USE_DLL\r
+# endif\r
+# if !defined(PNG_DLL)\r
+# define PNG_DLL\r
+# endif\r
+# else\r
+# if defined(PNG_STATIC)\r
+# if defined(PNG_USE_DLL)\r
+# undef PNG_USE_DLL\r
+# endif\r
+# if defined(PNG_DLL)\r
+# undef PNG_DLL\r
+# endif\r
+# else\r
+# if !defined(PNG_USE_DLL)\r
+# define PNG_USE_DLL\r
+# endif\r
+# if !defined(PNG_DLL)\r
+# define PNG_DLL\r
+# endif\r
+# endif \r
+# endif \r
+# endif\r
+#endif\r
+\r
+/* This protects us against compilers that run on a windowing system\r
+ * and thus don't have or would rather us not use the stdio types:\r
+ * stdin, stdout, and stderr. The only one currently used is stderr\r
+ * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will\r
+ * prevent these from being compiled and used. #defining PNG_NO_STDIO\r
+ * will also prevent these, plus will prevent the entire set of stdio\r
+ * macros and functions (FILE *, printf, etc.) from being compiled and used,\r
+ * unless (PNG_DEBUG > 0) has been #defined.\r
+ *\r
+ * #define PNG_NO_CONSOLE_IO\r
+ * #define PNG_NO_STDIO\r
+ */\r
+\r
+#if defined(_WIN32_WCE)\r
+# include <windows.h>\r
+ /* Console I/O functions are not supported on WindowsCE */\r
+# define PNG_NO_CONSOLE_IO\r
+# ifdef PNG_DEBUG\r
+# undef PNG_DEBUG\r
+# endif\r
+#endif\r
+\r
+#ifdef PNG_BUILD_DLL\r
+# ifndef PNG_CONSOLE_IO_SUPPORTED\r
+# ifndef PNG_NO_CONSOLE_IO\r
+# define PNG_NO_CONSOLE_IO\r
+# endif\r
+# endif\r
+#endif\r
+\r
+# ifdef PNG_NO_STDIO\r
+# ifndef PNG_NO_CONSOLE_IO\r
+# define PNG_NO_CONSOLE_IO\r
+# endif\r
+# ifdef PNG_DEBUG\r
+# if (PNG_DEBUG > 0)\r
+# include <stdio.h>\r
+# endif\r
+# endif\r
+# else\r
+# if !defined(_WIN32_WCE)\r
+/* "stdio.h" functions are not supported on WindowsCE */\r
+# include <stdio.h>\r
+# endif\r
+# endif\r
+\r
+/* This macro protects us against machines that don't have function\r
+ * prototypes (ie K&R style headers). If your compiler does not handle\r
+ * function prototypes, define this macro and use the included ansi2knr.\r
+ * I've always been able to use _NO_PROTO as the indicator, but you may\r
+ * need to drag the empty declaration out in front of here, or change the\r
+ * ifdef to suit your own needs.\r
+ */\r
+#ifndef PNGARG\r
+\r
+#ifdef OF /* zlib prototype munger */\r
+# define PNGARG(arglist) OF(arglist)\r
+#else\r
+\r
+#ifdef _NO_PROTO\r
+# define PNGARG(arglist) ()\r
+# ifndef PNG_TYPECAST_NULL\r
+# define PNG_TYPECAST_NULL\r
+# endif\r
+#else\r
+# define PNGARG(arglist) arglist\r
+#endif /* _NO_PROTO */\r
+\r
+\r
+#endif /* OF */\r
+\r
+#endif /* PNGARG */\r
+\r
+/* Try to determine if we are compiling on a Mac. Note that testing for\r
+ * just __MWERKS__ is not good enough, because the Codewarrior is now used\r
+ * on non-Mac platforms.\r
+ */\r
+#ifndef MACOS\r
+# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \\r
+ defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)\r
+# define MACOS\r
+# endif\r
+#endif\r
+\r
+/* enough people need this for various reasons to include it here */\r
+#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE)\r
+# include <sys/types.h>\r
+#endif\r
+\r
+#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED)\r
+# define PNG_SETJMP_SUPPORTED\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+/* This is an attempt to force a single setjmp behaviour on Linux. If\r
+ * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.\r
+ */\r
+\r
+# ifdef __linux__\r
+# ifdef _BSD_SOURCE\r
+# define PNG_SAVE_BSD_SOURCE\r
+# undef _BSD_SOURCE\r
+# endif\r
+# ifdef _SETJMP_H\r
+ /* If you encounter a compiler error here, see the explanation\r
+ * near the end of INSTALL.\r
+ */\r
+ __pngconf.h__ already includes setjmp.h;\r
+ __dont__ include it again.;\r
+# endif\r
+# endif /* __linux__ */\r
+\r
+ /* include setjmp.h for error handling */\r
+# include <setjmp.h>\r
+\r
+# ifdef __linux__\r
+# ifdef PNG_SAVE_BSD_SOURCE\r
+# ifndef _BSD_SOURCE\r
+# define _BSD_SOURCE\r
+# endif\r
+# undef PNG_SAVE_BSD_SOURCE\r
+# endif\r
+# endif /* __linux__ */\r
+#endif /* PNG_SETJMP_SUPPORTED */\r
+\r
+#ifdef BSD\r
+# include <strings.h>\r
+#else\r
+# include <string.h>\r
+#endif\r
+\r
+/* Other defines for things like memory and the like can go here. */\r
+#ifdef PNG_INTERNAL\r
+\r
+#include <stdlib.h>\r
+\r
+/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which\r
+ * aren't usually used outside the library (as far as I know), so it is\r
+ * debatable if they should be exported at all. In the future, when it is\r
+ * possible to have run-time registry of chunk-handling functions, some of\r
+ * these will be made available again.\r
+#define PNG_EXTERN extern\r
+ */\r
+#define PNG_EXTERN\r
+\r
+/* Other defines specific to compilers can go here. Try to keep\r
+ * them inside an appropriate ifdef/endif pair for portability.\r
+ */\r
+\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED)\r
+# if defined(MACOS)\r
+ /* We need to check that <math.h> hasn't already been included earlier\r
+ * as it seems it doesn't agree with <fp.h>, yet we should really use\r
+ * <fp.h> if possible.\r
+ */\r
+# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)\r
+# include <fp.h>\r
+# endif\r
+# else\r
+# include <math.h>\r
+# endif\r
+# if defined(_AMIGA) && defined(__SASC) && defined(_M68881)\r
+ /* Amiga SAS/C: We must include builtin FPU functions when compiling using\r
+ * MATH=68881\r
+ */\r
+# include <m68881.h>\r
+# endif\r
+#endif\r
+\r
+/* Codewarrior on NT has linking problems without this. */\r
+#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__)\r
+# define PNG_ALWAYS_EXTERN\r
+#endif\r
+\r
+/* This provides the non-ANSI (far) memory allocation routines. */\r
+#if defined(__TURBOC__) && defined(__MSDOS__)\r
+# include <mem.h>\r
+# include <alloc.h>\r
+#endif\r
+\r
+/* I have no idea why is this necessary... */\r
+#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \\r
+ defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__))\r
+# include <malloc.h>\r
+#endif\r
+\r
+/* This controls how fine the dithering gets. As this allocates\r
+ * a largish chunk of memory (32K), those who are not as concerned\r
+ * with dithering quality can decrease some or all of these.\r
+ */\r
+#ifndef PNG_DITHER_RED_BITS\r
+# define PNG_DITHER_RED_BITS 5\r
+#endif\r
+#ifndef PNG_DITHER_GREEN_BITS\r
+# define PNG_DITHER_GREEN_BITS 5\r
+#endif\r
+#ifndef PNG_DITHER_BLUE_BITS\r
+# define PNG_DITHER_BLUE_BITS 5\r
+#endif\r
+\r
+/* This controls how fine the gamma correction becomes when you\r
+ * are only interested in 8 bits anyway. Increasing this value\r
+ * results in more memory being used, and more pow() functions\r
+ * being called to fill in the gamma tables. Don't set this value\r
+ * less then 8, and even that may not work (I haven't tested it).\r
+ */\r
+\r
+#ifndef PNG_MAX_GAMMA_8\r
+# define PNG_MAX_GAMMA_8 11\r
+#endif\r
+\r
+/* This controls how much a difference in gamma we can tolerate before\r
+ * we actually start doing gamma conversion.\r
+ */\r
+#ifndef PNG_GAMMA_THRESHOLD\r
+# define PNG_GAMMA_THRESHOLD 0.05\r
+#endif\r
+\r
+#endif /* PNG_INTERNAL */\r
+\r
+/* The following uses const char * instead of char * for error\r
+ * and warning message functions, so some compilers won't complain.\r
+ * If you do not want to use const, define PNG_NO_CONST here.\r
+ */\r
+\r
+#ifndef PNG_NO_CONST\r
+# define PNG_CONST const\r
+#else\r
+# define PNG_CONST\r
+#endif\r
+\r
+/* The following defines give you the ability to remove code from the\r
+ * library that you will not be using. I wish I could figure out how to\r
+ * automate this, but I can't do that without making it seriously hard\r
+ * on the users. So if you are not using an ability, change the #define\r
+ * to and #undef, and that part of the library will not be compiled. If\r
+ * your linker can't find a function, you may want to make sure the\r
+ * ability is defined here. Some of these depend upon some others being\r
+ * defined. I haven't figured out all the interactions here, so you may\r
+ * have to experiment awhile to get everything to compile. If you are\r
+ * creating or using a shared library, you probably shouldn't touch this,\r
+ * as it will affect the size of the structures, and this will cause bad\r
+ * things to happen if the library and/or application ever change.\r
+ */\r
+\r
+/* Any features you will not be using can be undef'ed here */\r
+\r
+/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user\r
+ * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS\r
+ * on the compile line, then pick and choose which ones to define without\r
+ * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED\r
+ * if you only want to have a png-compliant reader/writer but don't need\r
+ * any of the extra transformations. This saves about 80 kbytes in a\r
+ * typical installation of the library. (PNG_NO_* form added in version\r
+ * 1.0.1c, for consistency)\r
+ */\r
+\r
+/* The size of the png_text structure changed in libpng-1.0.6 when\r
+ * iTXt support was added. iTXt support was turned off by default through\r
+ * libpng-1.2.x, to support old apps that malloc the png_text structure\r
+ * instead of calling png_set_text() and letting libpng malloc it. It\r
+ * was turned on by default in libpng-1.3.0.\r
+ */\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+# ifndef PNG_NO_iTXt_SUPPORTED\r
+# define PNG_NO_iTXt_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_iTXt\r
+# define PNG_NO_READ_iTXt\r
+# endif\r
+# ifndef PNG_NO_WRITE_iTXt\r
+# define PNG_NO_WRITE_iTXt\r
+# endif\r
+#endif\r
+\r
+#if !defined(PNG_NO_iTXt_SUPPORTED)\r
+# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt)\r
+# define PNG_READ_iTXt\r
+# endif\r
+# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt)\r
+# define PNG_WRITE_iTXt\r
+# endif\r
+#endif\r
+\r
+/* The following support, added after version 1.0.0, can be turned off here en\r
+ * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility\r
+ * with old applications that require the length of png_struct and png_info\r
+ * to remain unchanged.\r
+ */\r
+\r
+#ifdef PNG_LEGACY_SUPPORTED\r
+# define PNG_NO_FREE_ME\r
+# define PNG_NO_READ_UNKNOWN_CHUNKS\r
+# define PNG_NO_WRITE_UNKNOWN_CHUNKS\r
+# define PNG_NO_READ_USER_CHUNKS\r
+# define PNG_NO_READ_iCCP\r
+# define PNG_NO_WRITE_iCCP\r
+# define PNG_NO_READ_iTXt\r
+# define PNG_NO_WRITE_iTXt\r
+# define PNG_NO_READ_sCAL\r
+# define PNG_NO_WRITE_sCAL\r
+# define PNG_NO_READ_sPLT\r
+# define PNG_NO_WRITE_sPLT\r
+# define PNG_NO_INFO_IMAGE\r
+# define PNG_NO_READ_RGB_TO_GRAY\r
+# define PNG_NO_READ_USER_TRANSFORM\r
+# define PNG_NO_WRITE_USER_TRANSFORM\r
+# define PNG_NO_USER_MEM\r
+# define PNG_NO_READ_EMPTY_PLTE\r
+# define PNG_NO_MNG_FEATURES\r
+# define PNG_NO_FIXED_POINT_SUPPORTED\r
+#endif\r
+\r
+/* Ignore attempt to turn off both floating and fixed point support */\r
+#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \\r
+ !defined(PNG_NO_FIXED_POINT_SUPPORTED)\r
+# define PNG_FIXED_POINT_SUPPORTED\r
+#endif\r
+\r
+#ifndef PNG_NO_FREE_ME\r
+# define PNG_FREE_ME_SUPPORTED\r
+#endif\r
+\r
+#if defined(PNG_READ_SUPPORTED)\r
+\r
+#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \\r
+ !defined(PNG_NO_READ_TRANSFORMS)\r
+# define PNG_READ_TRANSFORMS_SUPPORTED\r
+#endif\r
+\r
+#ifdef PNG_READ_TRANSFORMS_SUPPORTED\r
+# ifndef PNG_NO_READ_EXPAND\r
+# define PNG_READ_EXPAND_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_SHIFT\r
+# define PNG_READ_SHIFT_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_PACK\r
+# define PNG_READ_PACK_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_BGR\r
+# define PNG_READ_BGR_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_SWAP\r
+# define PNG_READ_SWAP_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_PACKSWAP\r
+# define PNG_READ_PACKSWAP_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_INVERT\r
+# define PNG_READ_INVERT_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_DITHER\r
+# define PNG_READ_DITHER_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_BACKGROUND\r
+# define PNG_READ_BACKGROUND_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_16_TO_8\r
+# define PNG_READ_16_TO_8_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_FILLER\r
+# define PNG_READ_FILLER_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_GAMMA\r
+# define PNG_READ_GAMMA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_GRAY_TO_RGB\r
+# define PNG_READ_GRAY_TO_RGB_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_SWAP_ALPHA\r
+# define PNG_READ_SWAP_ALPHA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_INVERT_ALPHA\r
+# define PNG_READ_INVERT_ALPHA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_STRIP_ALPHA\r
+# define PNG_READ_STRIP_ALPHA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_USER_TRANSFORM\r
+# define PNG_READ_USER_TRANSFORM_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_READ_RGB_TO_GRAY\r
+# define PNG_READ_RGB_TO_GRAY_SUPPORTED\r
+# endif\r
+#endif /* PNG_READ_TRANSFORMS_SUPPORTED */\r
+\r
+#if !defined(PNG_NO_PROGRESSIVE_READ) && \\r
+ !defined(PNG_PROGRESSIVE_READ_SUPPORTED) /* if you don't do progressive */\r
+# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */\r
+#endif /* about interlacing capability! You'll */\r
+ /* still have interlacing unless you change the following line: */\r
+\r
+#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */\r
+\r
+#ifndef PNG_NO_READ_COMPOSITE_NODIV\r
+# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */\r
+# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */\r
+# endif\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Deprecated, will be removed from version 2.0.0.\r
+ Use PNG_MNG_FEATURES_SUPPORTED instead. */\r
+#ifndef PNG_NO_READ_EMPTY_PLTE\r
+# define PNG_READ_EMPTY_PLTE_SUPPORTED\r
+#endif\r
+#endif\r
+\r
+#endif /* PNG_READ_SUPPORTED */\r
+\r
+#if defined(PNG_WRITE_SUPPORTED)\r
+\r
+# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \\r
+ !defined(PNG_NO_WRITE_TRANSFORMS)\r
+# define PNG_WRITE_TRANSFORMS_SUPPORTED\r
+#endif\r
+\r
+#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED\r
+# ifndef PNG_NO_WRITE_SHIFT\r
+# define PNG_WRITE_SHIFT_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_PACK\r
+# define PNG_WRITE_PACK_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_BGR\r
+# define PNG_WRITE_BGR_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_SWAP\r
+# define PNG_WRITE_SWAP_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_PACKSWAP\r
+# define PNG_WRITE_PACKSWAP_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_INVERT\r
+# define PNG_WRITE_INVERT_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_FILLER\r
+# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */\r
+# endif\r
+# ifndef PNG_NO_WRITE_SWAP_ALPHA\r
+# define PNG_WRITE_SWAP_ALPHA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_INVERT_ALPHA\r
+# define PNG_WRITE_INVERT_ALPHA_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_WRITE_USER_TRANSFORM\r
+# define PNG_WRITE_USER_TRANSFORM_SUPPORTED\r
+# endif\r
+#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */\r
+\r
+#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \\r
+ !defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant\r
+ encoders, but can cause trouble\r
+ if left undefined */\r
+#endif\r
+\r
+#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \\r
+ !defined(PNG_WRITE_WEIGHTED_FILTER) && \\r
+ defined(PNG_FLOATING_POINT_SUPPORTED)\r
+# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED\r
+#endif\r
+\r
+#ifndef PNG_NO_WRITE_FLUSH\r
+# define PNG_WRITE_FLUSH_SUPPORTED\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined (PNG_1_2_X)\r
+/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */\r
+#ifndef PNG_NO_WRITE_EMPTY_PLTE\r
+# define PNG_WRITE_EMPTY_PLTE_SUPPORTED\r
+#endif\r
+#endif\r
+\r
+#endif /* PNG_WRITE_SUPPORTED */\r
+\r
+#ifndef PNG_1_0_X\r
+# ifndef PNG_NO_ERROR_NUMBERS\r
+# define PNG_ERROR_NUMBERS_SUPPORTED\r
+# endif\r
+#endif /* PNG_1_0_X */\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
+# ifndef PNG_NO_USER_TRANSFORM_PTR\r
+# define PNG_USER_TRANSFORM_PTR_SUPPORTED\r
+# endif\r
+#endif\r
+\r
+#ifndef PNG_NO_STDIO\r
+# define PNG_TIME_RFC1123_SUPPORTED\r
+#endif\r
+\r
+/* This adds extra functions in pngget.c for accessing data from the\r
+ * info pointer (added in version 0.99)\r
+ * png_get_image_width()\r
+ * png_get_image_height()\r
+ * png_get_bit_depth()\r
+ * png_get_color_type()\r
+ * png_get_compression_type()\r
+ * png_get_filter_type()\r
+ * png_get_interlace_type()\r
+ * png_get_pixel_aspect_ratio()\r
+ * png_get_pixels_per_meter()\r
+ * png_get_x_offset_pixels()\r
+ * png_get_y_offset_pixels()\r
+ * png_get_x_offset_microns()\r
+ * png_get_y_offset_microns()\r
+ */\r
+#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED)\r
+# define PNG_EASY_ACCESS_SUPPORTED\r
+#endif\r
+\r
+/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 \r
+ * and removed from version 1.2.20. The following will be removed\r
+ * from libpng-1.4.0\r
+*/\r
+\r
+#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE)\r
+# ifndef PNG_OPTIMIZED_CODE_SUPPORTED\r
+# define PNG_OPTIMIZED_CODE_SUPPORTED\r
+# endif\r
+#endif\r
+\r
+#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE)\r
+# ifndef PNG_ASSEMBLER_CODE_SUPPORTED\r
+# define PNG_ASSEMBLER_CODE_SUPPORTED\r
+# endif\r
+\r
+# if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4)\r
+ /* work around 64-bit gcc compiler bugs in gcc-3.x */\r
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)\r
+# define PNG_NO_MMX_CODE\r
+# endif\r
+# endif\r
+\r
+# if defined(__APPLE__)\r
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)\r
+# define PNG_NO_MMX_CODE\r
+# endif\r
+# endif\r
+\r
+# if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh))\r
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)\r
+# define PNG_NO_MMX_CODE\r
+# endif\r
+# endif\r
+\r
+# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE)\r
+# define PNG_MMX_CODE_SUPPORTED\r
+# endif\r
+\r
+#endif\r
+/* end of obsolete code to be removed from libpng-1.4.0 */\r
+\r
+#if !defined(PNG_1_0_X)\r
+#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED)\r
+# define PNG_USER_MEM_SUPPORTED\r
+#endif\r
+#endif /* PNG_1_0_X */\r
+\r
+/* Added at libpng-1.2.6 */\r
+#if !defined(PNG_1_0_X)\r
+#ifndef PNG_SET_USER_LIMITS_SUPPORTED\r
+#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED)\r
+# define PNG_SET_USER_LIMITS_SUPPORTED\r
+#endif\r
+#endif\r
+#endif /* PNG_1_0_X */\r
+\r
+/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter\r
+ * how large, set these limits to 0x7fffffffL\r
+ */\r
+#ifndef PNG_USER_WIDTH_MAX\r
+# define PNG_USER_WIDTH_MAX 1000000L\r
+#endif\r
+#ifndef PNG_USER_HEIGHT_MAX\r
+# define PNG_USER_HEIGHT_MAX 1000000L\r
+#endif\r
+\r
+/* These are currently experimental features, define them if you want */\r
+\r
+/* very little testing */\r
+/*\r
+#ifdef PNG_READ_SUPPORTED\r
+# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED\r
+# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED\r
+# endif\r
+#endif\r
+*/\r
+\r
+/* This is only for PowerPC big-endian and 680x0 systems */\r
+/* some testing */\r
+/*\r
+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED\r
+# define PNG_READ_BIG_ENDIAN_SUPPORTED\r
+#endif\r
+*/\r
+\r
+/* Buggy compilers (e.g., gcc 2.7.2.2) need this */\r
+/*\r
+#define PNG_NO_POINTER_INDEXING\r
+*/\r
+\r
+/* These functions are turned off by default, as they will be phased out. */\r
+/*\r
+#define PNG_USELESS_TESTS_SUPPORTED\r
+#define PNG_CORRECT_PALETTE_SUPPORTED\r
+*/\r
+\r
+/* Any chunks you are not interested in, you can undef here. The\r
+ * ones that allocate memory may be expecially important (hIST,\r
+ * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info\r
+ * a bit smaller.\r
+ */\r
+\r
+#if defined(PNG_READ_SUPPORTED) && \\r
+ !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \\r
+ !defined(PNG_NO_READ_ANCILLARY_CHUNKS)\r
+# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SUPPORTED) && \\r
+ !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \\r
+ !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS)\r
+# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED\r
+#endif\r
+\r
+#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED\r
+\r
+#ifdef PNG_NO_READ_TEXT\r
+# define PNG_NO_READ_iTXt\r
+# define PNG_NO_READ_tEXt\r
+# define PNG_NO_READ_zTXt\r
+#endif\r
+#ifndef PNG_NO_READ_bKGD\r
+# define PNG_READ_bKGD_SUPPORTED\r
+# define PNG_bKGD_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_cHRM\r
+# define PNG_READ_cHRM_SUPPORTED\r
+# define PNG_cHRM_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_gAMA\r
+# define PNG_READ_gAMA_SUPPORTED\r
+# define PNG_gAMA_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_hIST\r
+# define PNG_READ_hIST_SUPPORTED\r
+# define PNG_hIST_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_iCCP\r
+# define PNG_READ_iCCP_SUPPORTED\r
+# define PNG_iCCP_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_iTXt\r
+# ifndef PNG_READ_iTXt_SUPPORTED\r
+# define PNG_READ_iTXt_SUPPORTED\r
+# endif\r
+# ifndef PNG_iTXt_SUPPORTED\r
+# define PNG_iTXt_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_READ_oFFs\r
+# define PNG_READ_oFFs_SUPPORTED\r
+# define PNG_oFFs_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_pCAL\r
+# define PNG_READ_pCAL_SUPPORTED\r
+# define PNG_pCAL_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_sCAL\r
+# define PNG_READ_sCAL_SUPPORTED\r
+# define PNG_sCAL_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_pHYs\r
+# define PNG_READ_pHYs_SUPPORTED\r
+# define PNG_pHYs_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_sBIT\r
+# define PNG_READ_sBIT_SUPPORTED\r
+# define PNG_sBIT_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_sPLT\r
+# define PNG_READ_sPLT_SUPPORTED\r
+# define PNG_sPLT_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_sRGB\r
+# define PNG_READ_sRGB_SUPPORTED\r
+# define PNG_sRGB_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_tEXt\r
+# define PNG_READ_tEXt_SUPPORTED\r
+# define PNG_tEXt_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_tIME\r
+# define PNG_READ_tIME_SUPPORTED\r
+# define PNG_tIME_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_tRNS\r
+# define PNG_READ_tRNS_SUPPORTED\r
+# define PNG_tRNS_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_zTXt\r
+# define PNG_READ_zTXt_SUPPORTED\r
+# define PNG_zTXt_SUPPORTED\r
+#endif\r
+#ifndef PNG_NO_READ_UNKNOWN_CHUNKS\r
+# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED\r
+# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED\r
+# define PNG_UNKNOWN_CHUNKS_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_HANDLE_AS_UNKNOWN\r
+# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+# endif\r
+#endif\r
+#if !defined(PNG_NO_READ_USER_CHUNKS) && \\r
+ defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
+# define PNG_READ_USER_CHUNKS_SUPPORTED\r
+# define PNG_USER_CHUNKS_SUPPORTED\r
+# ifdef PNG_NO_READ_UNKNOWN_CHUNKS\r
+# undef PNG_NO_READ_UNKNOWN_CHUNKS\r
+# endif\r
+# ifdef PNG_NO_HANDLE_AS_UNKNOWN\r
+# undef PNG_NO_HANDLE_AS_UNKNOWN\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_READ_OPT_PLTE\r
+# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */\r
+#endif /* optional PLTE chunk in RGB and RGBA images */\r
+#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \\r
+ defined(PNG_READ_zTXt_SUPPORTED)\r
+# define PNG_READ_TEXT_SUPPORTED\r
+# define PNG_TEXT_SUPPORTED\r
+#endif\r
+\r
+#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */\r
+\r
+#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED\r
+\r
+#ifdef PNG_NO_WRITE_TEXT\r
+# define PNG_NO_WRITE_iTXt\r
+# define PNG_NO_WRITE_tEXt\r
+# define PNG_NO_WRITE_zTXt\r
+#endif\r
+#ifndef PNG_NO_WRITE_bKGD\r
+# define PNG_WRITE_bKGD_SUPPORTED\r
+# ifndef PNG_bKGD_SUPPORTED\r
+# define PNG_bKGD_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_cHRM\r
+# define PNG_WRITE_cHRM_SUPPORTED\r
+# ifndef PNG_cHRM_SUPPORTED\r
+# define PNG_cHRM_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_gAMA\r
+# define PNG_WRITE_gAMA_SUPPORTED\r
+# ifndef PNG_gAMA_SUPPORTED\r
+# define PNG_gAMA_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_hIST\r
+# define PNG_WRITE_hIST_SUPPORTED\r
+# ifndef PNG_hIST_SUPPORTED\r
+# define PNG_hIST_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_iCCP\r
+# define PNG_WRITE_iCCP_SUPPORTED\r
+# ifndef PNG_iCCP_SUPPORTED\r
+# define PNG_iCCP_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_iTXt\r
+# ifndef PNG_WRITE_iTXt_SUPPORTED\r
+# define PNG_WRITE_iTXt_SUPPORTED\r
+# endif\r
+# ifndef PNG_iTXt_SUPPORTED\r
+# define PNG_iTXt_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_oFFs\r
+# define PNG_WRITE_oFFs_SUPPORTED\r
+# ifndef PNG_oFFs_SUPPORTED\r
+# define PNG_oFFs_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_pCAL\r
+# define PNG_WRITE_pCAL_SUPPORTED\r
+# ifndef PNG_pCAL_SUPPORTED\r
+# define PNG_pCAL_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_sCAL\r
+# define PNG_WRITE_sCAL_SUPPORTED\r
+# ifndef PNG_sCAL_SUPPORTED\r
+# define PNG_sCAL_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_pHYs\r
+# define PNG_WRITE_pHYs_SUPPORTED\r
+# ifndef PNG_pHYs_SUPPORTED\r
+# define PNG_pHYs_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_sBIT\r
+# define PNG_WRITE_sBIT_SUPPORTED\r
+# ifndef PNG_sBIT_SUPPORTED\r
+# define PNG_sBIT_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_sPLT\r
+# define PNG_WRITE_sPLT_SUPPORTED\r
+# ifndef PNG_sPLT_SUPPORTED\r
+# define PNG_sPLT_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_sRGB\r
+# define PNG_WRITE_sRGB_SUPPORTED\r
+# ifndef PNG_sRGB_SUPPORTED\r
+# define PNG_sRGB_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_tEXt\r
+# define PNG_WRITE_tEXt_SUPPORTED\r
+# ifndef PNG_tEXt_SUPPORTED\r
+# define PNG_tEXt_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_tIME\r
+# define PNG_WRITE_tIME_SUPPORTED\r
+# ifndef PNG_tIME_SUPPORTED\r
+# define PNG_tIME_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_tRNS\r
+# define PNG_WRITE_tRNS_SUPPORTED\r
+# ifndef PNG_tRNS_SUPPORTED\r
+# define PNG_tRNS_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_zTXt\r
+# define PNG_WRITE_zTXt_SUPPORTED\r
+# ifndef PNG_zTXt_SUPPORTED\r
+# define PNG_zTXt_SUPPORTED\r
+# endif\r
+#endif\r
+#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS\r
+# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED\r
+# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED\r
+# define PNG_UNKNOWN_CHUNKS_SUPPORTED\r
+# endif\r
+# ifndef PNG_NO_HANDLE_AS_UNKNOWN\r
+# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+# endif\r
+# endif\r
+#endif\r
+#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \\r
+ defined(PNG_WRITE_zTXt_SUPPORTED)\r
+# define PNG_WRITE_TEXT_SUPPORTED\r
+# ifndef PNG_TEXT_SUPPORTED\r
+# define PNG_TEXT_SUPPORTED\r
+# endif\r
+#endif\r
+\r
+#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */\r
+\r
+/* Turn this off to disable png_read_png() and\r
+ * png_write_png() and leave the row_pointers member\r
+ * out of the info structure.\r
+ */\r
+#ifndef PNG_NO_INFO_IMAGE\r
+# define PNG_INFO_IMAGE_SUPPORTED\r
+#endif\r
+\r
+/* need the time information for reading tIME chunks */\r
+#if defined(PNG_tIME_SUPPORTED)\r
+# if !defined(_WIN32_WCE)\r
+ /* "time.h" functions are not supported on WindowsCE */\r
+# include <time.h>\r
+# endif\r
+#endif\r
+\r
+/* Some typedefs to get us started. These should be safe on most of the\r
+ * common platforms. The typedefs should be at least as large as the\r
+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they\r
+ * don't have to be exactly that size. Some compilers dislike passing\r
+ * unsigned shorts as function parameters, so you may be better off using\r
+ * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may\r
+ * want to have unsigned int for png_uint_32 instead of unsigned long.\r
+ */\r
+\r
+typedef unsigned long png_uint_32;\r
+typedef long png_int_32;\r
+typedef unsigned short png_uint_16;\r
+typedef short png_int_16;\r
+typedef unsigned char png_byte;\r
+\r
+/* This is usually size_t. It is typedef'ed just in case you need it to\r
+ change (I'm not sure if you will or not, so I thought I'd be safe) */\r
+#ifdef PNG_SIZE_T\r
+ typedef PNG_SIZE_T png_size_t;\r
+# define png_sizeof(x) png_convert_size(sizeof(x))\r
+#else\r
+ typedef size_t png_size_t;\r
+# define png_sizeof(x) sizeof(x)\r
+#endif\r
+\r
+/* The following is needed for medium model support. It cannot be in the\r
+ * PNG_INTERNAL section. Needs modification for other compilers besides\r
+ * MSC. Model independent support declares all arrays and pointers to be\r
+ * large using the far keyword. The zlib version used must also support\r
+ * model independent data. As of version zlib 1.0.4, the necessary changes\r
+ * have been made in zlib. The USE_FAR_KEYWORD define triggers other\r
+ * changes that are needed. (Tim Wegner)\r
+ */\r
+\r
+/* Separate compiler dependencies (problem here is that zlib.h always\r
+ defines FAR. (SJT) */\r
+#ifdef __BORLANDC__\r
+# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)\r
+# define LDATA 1\r
+# else\r
+# define LDATA 0\r
+# endif\r
+ /* GRR: why is Cygwin in here? Cygwin is not Borland C... */\r
+# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)\r
+# define PNG_MAX_MALLOC_64K\r
+# if (LDATA != 1)\r
+# ifndef FAR\r
+# define FAR __far\r
+# endif\r
+# define USE_FAR_KEYWORD\r
+# endif /* LDATA != 1 */\r
+ /* Possibly useful for moving data out of default segment.\r
+ * Uncomment it if you want. Could also define FARDATA as\r
+ * const if your compiler supports it. (SJT)\r
+# define FARDATA FAR\r
+ */\r
+# endif /* __WIN32__, __FLAT__, __CYGWIN__ */\r
+#endif /* __BORLANDC__ */\r
+\r
+\r
+/* Suggest testing for specific compiler first before testing for\r
+ * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM,\r
+ * making reliance oncertain keywords suspect. (SJT)\r
+ */\r
+\r
+/* MSC Medium model */\r
+#if defined(FAR)\r
+# if defined(M_I86MM)\r
+# define USE_FAR_KEYWORD\r
+# define FARDATA FAR\r
+# include <dos.h>\r
+# endif\r
+#endif\r
+\r
+/* SJT: default case */\r
+#ifndef FAR\r
+# define FAR\r
+#endif\r
+\r
+/* At this point FAR is always defined */\r
+#ifndef FARDATA\r
+# define FARDATA\r
+#endif\r
+\r
+/* Typedef for floating-point numbers that are converted\r
+ to fixed-point with a multiple of 100,000, e.g., int_gamma */\r
+typedef png_int_32 png_fixed_point;\r
+\r
+/* Add typedefs for pointers */\r
+typedef void FAR * png_voidp;\r
+typedef png_byte FAR * png_bytep;\r
+typedef png_uint_32 FAR * png_uint_32p;\r
+typedef png_int_32 FAR * png_int_32p;\r
+typedef png_uint_16 FAR * png_uint_16p;\r
+typedef png_int_16 FAR * png_int_16p;\r
+typedef PNG_CONST char FAR * png_const_charp;\r
+typedef char FAR * png_charp;\r
+typedef png_fixed_point FAR * png_fixed_point_p;\r
+\r
+#ifndef PNG_NO_STDIO\r
+#if defined(_WIN32_WCE)\r
+typedef HANDLE png_FILE_p;\r
+#else\r
+typedef FILE * png_FILE_p;\r
+#endif\r
+#endif\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+typedef double FAR * png_doublep;\r
+#endif\r
+\r
+/* Pointers to pointers; i.e. arrays */\r
+typedef png_byte FAR * FAR * png_bytepp;\r
+typedef png_uint_32 FAR * FAR * png_uint_32pp;\r
+typedef png_int_32 FAR * FAR * png_int_32pp;\r
+typedef png_uint_16 FAR * FAR * png_uint_16pp;\r
+typedef png_int_16 FAR * FAR * png_int_16pp;\r
+typedef PNG_CONST char FAR * FAR * png_const_charpp;\r
+typedef char FAR * FAR * png_charpp;\r
+typedef png_fixed_point FAR * FAR * png_fixed_point_pp;\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+typedef double FAR * FAR * png_doublepp;\r
+#endif\r
+\r
+/* Pointers to pointers to pointers; i.e., pointer to array */\r
+typedef char FAR * FAR * FAR * png_charppp;\r
+\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+/* SPC - Is this stuff deprecated? */\r
+/* It'll be removed as of libpng-1.3.0 - GR-P */\r
+/* libpng typedefs for types in zlib. If zlib changes\r
+ * or another compression library is used, then change these.\r
+ * Eliminates need to change all the source files.\r
+ */\r
+typedef charf * png_zcharp;\r
+typedef charf * FAR * png_zcharpp;\r
+typedef z_stream FAR * png_zstreamp;\r
+#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */\r
+\r
+/*\r
+ * Define PNG_BUILD_DLL if the module being built is a Windows\r
+ * LIBPNG DLL.\r
+ *\r
+ * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL.\r
+ * It is equivalent to Microsoft predefined macro _DLL that is\r
+ * automatically defined when you compile using the share\r
+ * version of the CRT (C Run-Time library)\r
+ *\r
+ * The cygwin mods make this behavior a little different:\r
+ * Define PNG_BUILD_DLL if you are building a dll for use with cygwin\r
+ * Define PNG_STATIC if you are building a static library for use with cygwin,\r
+ * -or- if you are building an application that you want to link to the\r
+ * static library.\r
+ * PNG_USE_DLL is defined by default (no user action needed) unless one of\r
+ * the other flags is defined.\r
+ */\r
+\r
+#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL))\r
+# define PNG_DLL\r
+#endif\r
+/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib.\r
+ * When building a static lib, default to no GLOBAL ARRAYS, but allow\r
+ * command-line override\r
+ */\r
+#if defined(__CYGWIN__)\r
+# if !defined(PNG_STATIC)\r
+# if defined(PNG_USE_GLOBAL_ARRAYS)\r
+# undef PNG_USE_GLOBAL_ARRAYS\r
+# endif\r
+# if !defined(PNG_USE_LOCAL_ARRAYS)\r
+# define PNG_USE_LOCAL_ARRAYS\r
+# endif\r
+# else\r
+# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS)\r
+# if defined(PNG_USE_GLOBAL_ARRAYS)\r
+# undef PNG_USE_GLOBAL_ARRAYS\r
+# endif\r
+# endif\r
+# endif\r
+# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)\r
+# define PNG_USE_LOCAL_ARRAYS\r
+# endif\r
+#endif\r
+\r
+/* Do not use global arrays (helps with building DLL's)\r
+ * They are no longer used in libpng itself, since version 1.0.5c,\r
+ * but might be required for some pre-1.0.5c applications.\r
+ */\r
+#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS)\r
+# if defined(PNG_NO_GLOBAL_ARRAYS) || \\r
+ (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER)\r
+# define PNG_USE_LOCAL_ARRAYS\r
+# else\r
+# define PNG_USE_GLOBAL_ARRAYS\r
+# endif\r
+#endif\r
+\r
+#if defined(__CYGWIN__)\r
+# undef PNGAPI\r
+# define PNGAPI __cdecl\r
+# undef PNG_IMPEXP\r
+# define PNG_IMPEXP\r
+#endif \r
+\r
+/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall",\r
+ * you may get warnings regarding the linkage of png_zalloc and png_zfree.\r
+ * Don't ignore those warnings; you must also reset the default calling\r
+ * convention in your compiler to match your PNGAPI, and you must build\r
+ * zlib and your applications the same way you build libpng.\r
+ */\r
+\r
+#if defined(__MINGW32__) && !defined(PNG_MODULEDEF)\r
+# ifndef PNG_NO_MODULEDEF\r
+# define PNG_NO_MODULEDEF\r
+# endif\r
+#endif\r
+\r
+#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF)\r
+# define PNG_IMPEXP\r
+#endif\r
+\r
+#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \\r
+ (( defined(_Windows) || defined(_WINDOWS) || \\r
+ defined(WIN32) || defined(_WIN32) || defined(__WIN32__) ))\r
+\r
+# ifndef PNGAPI\r
+# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800))\r
+# define PNGAPI __cdecl\r
+# else\r
+# define PNGAPI _cdecl\r
+# endif\r
+# endif\r
+\r
+# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \\r
+ 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */)\r
+# define PNG_IMPEXP\r
+# endif\r
+\r
+# if !defined(PNG_IMPEXP)\r
+\r
+# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol\r
+# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol\r
+\r
+ /* Borland/Microsoft */\r
+# if defined(_MSC_VER) || defined(__BORLANDC__)\r
+# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500)\r
+# define PNG_EXPORT PNG_EXPORT_TYPE1\r
+# else\r
+# define PNG_EXPORT PNG_EXPORT_TYPE2\r
+# if defined(PNG_BUILD_DLL)\r
+# define PNG_IMPEXP __export\r
+# else\r
+# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in\r
+ VC++ */\r
+# endif /* Exists in Borland C++ for\r
+ C++ classes (== huge) */\r
+# endif\r
+# endif\r
+\r
+# if !defined(PNG_IMPEXP)\r
+# if defined(PNG_BUILD_DLL)\r
+# define PNG_IMPEXP __declspec(dllexport)\r
+# else\r
+# define PNG_IMPEXP __declspec(dllimport)\r
+# endif\r
+# endif\r
+# endif /* PNG_IMPEXP */\r
+#else /* !(DLL || non-cygwin WINDOWS) */\r
+# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)\r
+# ifndef PNGAPI\r
+# define PNGAPI _System\r
+# endif\r
+# else\r
+# if 0 /* ... other platforms, with other meanings */\r
+# endif\r
+# endif\r
+#endif\r
+\r
+#ifndef PNGAPI\r
+# define PNGAPI\r
+#endif\r
+#ifndef PNG_IMPEXP\r
+# define PNG_IMPEXP\r
+#endif\r
+\r
+#ifdef PNG_BUILDSYMS\r
+# ifndef PNG_EXPORT\r
+# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END\r
+# endif\r
+# ifdef PNG_USE_GLOBAL_ARRAYS\r
+# ifndef PNG_EXPORT_VAR\r
+# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT\r
+# endif\r
+# endif\r
+#endif\r
+\r
+#ifndef PNG_EXPORT\r
+# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol\r
+#endif\r
+\r
+#ifdef PNG_USE_GLOBAL_ARRAYS\r
+# ifndef PNG_EXPORT_VAR\r
+# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type\r
+# endif\r
+#endif\r
+\r
+/* User may want to use these so they are not in PNG_INTERNAL. Any library\r
+ * functions that are passed far data must be model independent.\r
+ */\r
+\r
+#ifndef PNG_ABORT\r
+# define PNG_ABORT() abort()\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)\r
+#else\r
+# define png_jmpbuf(png_ptr) \\r
+ (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED)\r
+#endif\r
+\r
+#if defined(USE_FAR_KEYWORD) /* memory model independent fns */\r
+/* use this to make far-to-near assignments */\r
+# define CHECK 1\r
+# define NOCHECK 0\r
+# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))\r
+# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))\r
+# define png_snprintf _fsnprintf /* Added to v 1.2.19 */\r
+# define png_strlen _fstrlen\r
+# define png_memcmp _fmemcmp /* SJT: added */\r
+# define png_memcpy _fmemcpy\r
+# define png_memset _fmemset\r
+#else /* use the usual functions */\r
+# define CVT_PTR(ptr) (ptr)\r
+# define CVT_PTR_NOCHECK(ptr) (ptr)\r
+# ifndef PNG_NO_SNPRINTF\r
+# ifdef _MSC_VER\r
+# define png_snprintf _snprintf /* Added to v 1.2.19 */\r
+# define png_snprintf2 _snprintf\r
+# define png_snprintf6 _snprintf\r
+# else\r
+# define png_snprintf snprintf /* Added to v 1.2.19 */\r
+# define png_snprintf2 snprintf\r
+# define png_snprintf6 snprintf\r
+# endif\r
+# else\r
+ /* You don't have or don't want to use snprintf(). Caution: Using\r
+ * sprintf instead of snprintf exposes your application to accidental\r
+ * or malevolent buffer overflows. If you don't have snprintf()\r
+ * as a general rule you should provide one (you can get one from\r
+ * Portable OpenSSH). */\r
+# define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1)\r
+# define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2)\r
+# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \\r
+ sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)\r
+# endif\r
+# define png_strlen strlen\r
+# define png_memcmp memcmp /* SJT: added */\r
+# define png_memcpy memcpy\r
+# define png_memset memset\r
+#endif\r
+/* End of memory model independent support */\r
+\r
+/* Just a little check that someone hasn't tried to define something\r
+ * contradictory.\r
+ */\r
+#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)\r
+# undef PNG_ZBUF_SIZE\r
+# define PNG_ZBUF_SIZE 65536L\r
+#endif\r
+\r
+/* Added at libpng-1.2.8 */\r
+#endif /* PNG_VERSION_INFO_ONLY */\r
+\r
+#endif /* PNGCONF_H */\r
--- /dev/null
+\r
+/* pngerror.c - stub functions for i/o and memory allocation\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file provides a location for all error handling. Users who\r
+ * need special error handling are expected to write replacement functions\r
+ * and use png_set_error_fn() to use those functions. See the instructions\r
+ * at each function.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+static void /* PRIVATE */\r
+png_default_error PNGARG((png_structp png_ptr,\r
+ png_const_charp error_message));\r
+#ifndef PNG_NO_WARNINGS\r
+static void /* PRIVATE */\r
+png_default_warning PNGARG((png_structp png_ptr,\r
+ png_const_charp warning_message));\r
+#endif /* PNG_NO_WARNINGS */\r
+\r
+/* This function is called whenever there is a fatal error. This function\r
+ * should not be changed. If there is a need to handle errors differently,\r
+ * you should supply a replacement error function and use png_set_error_fn()\r
+ * to replace the error function at run-time.\r
+ */\r
+#ifndef PNG_NO_ERROR_TEXT\r
+void PNGAPI\r
+png_error(png_structp png_ptr, png_const_charp error_message)\r
+{\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ char msg[16];\r
+ if (png_ptr != NULL)\r
+ {\r
+ if (png_ptr->flags&\r
+ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
+ {\r
+ if (*error_message == '#')\r
+ {\r
+ /* Strip "#nnnn " from beginning of error message. */\r
+ int offset;\r
+ for (offset = 1; offset<15; offset++)\r
+ if (error_message[offset] == ' ')\r
+ break;\r
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
+ {\r
+ int i;\r
+ for (i = 0; i < offset - 1; i++)\r
+ msg[i] = error_message[i + 1];\r
+ msg[i - 1] = '\0';\r
+ error_message = msg;\r
+ }\r
+ else\r
+ error_message += offset;\r
+ }\r
+ else\r
+ {\r
+ if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)\r
+ {\r
+ msg[0] = '0';\r
+ msg[1] = '\0';\r
+ error_message = msg;\r
+ }\r
+ }\r
+ }\r
+ }\r
+#endif\r
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
+ (*(png_ptr->error_fn))(png_ptr, error_message);\r
+\r
+ /* If the custom handler doesn't exist, or if it returns,\r
+ use the default handler, which will not return. */\r
+ png_default_error(png_ptr, error_message);\r
+}\r
+#else\r
+void PNGAPI\r
+png_err(png_structp png_ptr)\r
+{\r
+ if (png_ptr != NULL && png_ptr->error_fn != NULL)\r
+ (*(png_ptr->error_fn))(png_ptr, '\0');\r
+\r
+ /* If the custom handler doesn't exist, or if it returns,\r
+ use the default handler, which will not return. */\r
+ png_default_error(png_ptr, '\0');\r
+}\r
+#endif /* PNG_NO_ERROR_TEXT */\r
+\r
+#ifndef PNG_NO_WARNINGS\r
+/* This function is called whenever there is a non-fatal error. This function\r
+ * should not be changed. If there is a need to handle warnings differently,\r
+ * you should supply a replacement warning function and use\r
+ * png_set_error_fn() to replace the warning function at run-time.\r
+ */\r
+void PNGAPI\r
+png_warning(png_structp png_ptr, png_const_charp warning_message)\r
+{\r
+ int offset = 0;\r
+ if (png_ptr != NULL)\r
+ {\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ if (png_ptr->flags&\r
+ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))\r
+#endif\r
+ {\r
+ if (*warning_message == '#')\r
+ {\r
+ for (offset = 1; offset < 15; offset++)\r
+ if (warning_message[offset] == ' ')\r
+ break;\r
+ }\r
+ }\r
+ if (png_ptr != NULL && png_ptr->warning_fn != NULL)\r
+ (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);\r
+ }\r
+ else\r
+ png_default_warning(png_ptr, warning_message + offset);\r
+}\r
+#endif /* PNG_NO_WARNINGS */\r
+\r
+\r
+/* These utilities are used internally to build an error message that relates\r
+ * to the current chunk. The chunk name comes from png_ptr->chunk_name,\r
+ * this is used to prefix the message. The message is limited in length\r
+ * to 63 bytes, the name characters are output as hex digits wrapped in []\r
+ * if the character is invalid.\r
+ */\r
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))\r
+static PNG_CONST char png_digit[16] = {\r
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\r
+ 'A', 'B', 'C', 'D', 'E', 'F'\r
+};\r
+\r
+#define PNG_MAX_ERROR_TEXT 64\r
+\r
+#if !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT)\r
+static void /* PRIVATE */\r
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp\r
+ error_message)\r
+{\r
+ int iout = 0, iin = 0;\r
+\r
+ while (iin < 4)\r
+ {\r
+ int c = png_ptr->chunk_name[iin++];\r
+ if (isnonalpha(c))\r
+ {\r
+ buffer[iout++] = '[';\r
+ buffer[iout++] = png_digit[(c & 0xf0) >> 4];\r
+ buffer[iout++] = png_digit[c & 0x0f];\r
+ buffer[iout++] = ']';\r
+ }\r
+ else\r
+ {\r
+ buffer[iout++] = (png_byte)c;\r
+ }\r
+ }\r
+\r
+ if (error_message == NULL)\r
+ buffer[iout] = '\0';\r
+ else\r
+ {\r
+ buffer[iout++] = ':';\r
+ buffer[iout++] = ' ';\r
+ png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);\r
+ buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';\r
+ }\r
+}\r
+\r
+#ifdef PNG_READ_SUPPORTED\r
+void PNGAPI\r
+png_chunk_error(png_structp png_ptr, png_const_charp error_message)\r
+{\r
+ char msg[18+PNG_MAX_ERROR_TEXT];\r
+ if (png_ptr == NULL)\r
+ png_error(png_ptr, error_message);\r
+ else\r
+ {\r
+ png_format_buffer(png_ptr, msg, error_message);\r
+ png_error(png_ptr, msg);\r
+ }\r
+}\r
+#endif /* PNG_READ_SUPPORTED */\r
+#endif /* !defined(PNG_NO_WARNINGS) || !defined(PNG_NO_ERROR_TEXT) */\r
+\r
+#ifndef PNG_NO_WARNINGS\r
+void PNGAPI\r
+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)\r
+{\r
+ char msg[18+PNG_MAX_ERROR_TEXT];\r
+ if (png_ptr == NULL)\r
+ png_warning(png_ptr, warning_message);\r
+ else\r
+ {\r
+ png_format_buffer(png_ptr, msg, warning_message);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+}\r
+#endif /* PNG_NO_WARNINGS */\r
+\r
+\r
+/* This is the default error handling function. Note that replacements for\r
+ * this function MUST NOT RETURN, or the program will likely crash. This\r
+ * function is used by default, or if the program supplies NULL for the\r
+ * error function pointer in png_set_error_fn().\r
+ */\r
+static void /* PRIVATE */\r
+png_default_error(png_structp png_ptr, png_const_charp error_message)\r
+{\r
+#ifndef PNG_NO_CONSOLE_IO\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ if (*error_message == '#')\r
+ {\r
+ /* Strip "#nnnn " from beginning of warning message. */\r
+ int offset;\r
+ char error_number[16];\r
+ for (offset = 0; offset<15; offset++)\r
+ {\r
+ error_number[offset] = error_message[offset + 1];\r
+ if (error_message[offset] == ' ')\r
+ break;\r
+ }\r
+ if ((offset > 1) && (offset < 15))\r
+ {\r
+ error_number[offset - 1] = '\0';\r
+ fprintf(stderr, "libpng error no. %s: %s\n", error_number,\r
+ error_message + offset + 1);\r
+ }\r
+ else\r
+ fprintf(stderr, "libpng error: %s, offset=%d\n", error_message, offset);\r
+ }\r
+ else\r
+#endif\r
+ fprintf(stderr, "libpng error: %s\n", error_message);\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ if (png_ptr)\r
+ {\r
+# ifdef USE_FAR_KEYWORD\r
+ {\r
+ jmp_buf jmpbuf;\r
+ png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
+ longjmp(jmpbuf, 1);\r
+ }\r
+# else\r
+ longjmp(png_ptr->jmpbuf, 1);\r
+# endif\r
+ }\r
+#else\r
+ PNG_ABORT();\r
+#endif\r
+#ifdef PNG_NO_CONSOLE_IO\r
+ error_message = error_message; /* make compiler happy */\r
+#endif\r
+}\r
+\r
+#ifndef PNG_NO_WARNINGS\r
+/* This function is called when there is a warning, but the library thinks\r
+ * it can continue anyway. Replacement functions don't have to do anything\r
+ * here if you don't want them to. In the default configuration, png_ptr is\r
+ * not used, but it is passed in case it may be useful.\r
+ */\r
+static void /* PRIVATE */\r
+png_default_warning(png_structp png_ptr, png_const_charp warning_message)\r
+{\r
+#ifndef PNG_NO_CONSOLE_IO\r
+# ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ if (*warning_message == '#')\r
+ {\r
+ int offset;\r
+ char warning_number[16];\r
+ for (offset = 0; offset < 15; offset++)\r
+ {\r
+ warning_number[offset] = warning_message[offset + 1];\r
+ if (warning_message[offset] == ' ')\r
+ break;\r
+ }\r
+ if ((offset > 1) && (offset < 15))\r
+ {\r
+ warning_number[offset + 1] = '\0';\r
+ fprintf(stderr, "libpng warning no. %s: %s\n", warning_number,\r
+ warning_message + offset);\r
+ }\r
+ else\r
+ fprintf(stderr, "libpng warning: %s\n", warning_message);\r
+ }\r
+ else\r
+# endif\r
+ fprintf(stderr, "libpng warning: %s\n", warning_message);\r
+#else\r
+ warning_message = warning_message; /* make compiler happy */\r
+#endif\r
+ png_ptr = png_ptr; /* make compiler happy */\r
+}\r
+#endif /* PNG_NO_WARNINGS */\r
+\r
+/* This function is called when the application wants to use another method\r
+ * of handling errors and warnings. Note that the error function MUST NOT\r
+ * return to the calling routine or serious problems will occur. The return\r
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)\r
+ */\r
+void PNGAPI\r
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warning_fn)\r
+{\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->error_ptr = error_ptr;\r
+ png_ptr->error_fn = error_fn;\r
+ png_ptr->warning_fn = warning_fn;\r
+}\r
+\r
+\r
+/* This function returns a pointer to the error_ptr associated with the user\r
+ * functions. The application should free any memory associated with this\r
+ * pointer before png_write_destroy and png_read_destroy are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_error_ptr(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL)\r
+ return NULL;\r
+ return ((png_voidp)png_ptr->error_ptr);\r
+}\r
+\r
+\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+void PNGAPI\r
+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)\r
+{\r
+ if (png_ptr != NULL)\r
+ {\r
+ png_ptr->flags &=\r
+ ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);\r
+ }\r
+}\r
+#endif\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngget.c - retrieval of values from info struct\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+png_uint_32 PNGAPI\r
+png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ return(info_ptr->valid & flag);\r
+ else\r
+ return(0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ return(info_ptr->rowbytes);\r
+ else\r
+ return(0);\r
+}\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+png_bytepp PNGAPI\r
+png_get_rows(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ return(info_ptr->row_pointers);\r
+ else\r
+ return(0);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_EASY_ACCESS_SUPPORTED\r
+/* easy access to info, added in libpng-0.99 */\r
+png_uint_32 PNGAPI\r
+png_get_image_width(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->width;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_image_height(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->height;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->bit_depth;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_color_type(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->color_type;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_filter_type(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->filter_type;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->interlace_type;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_byte PNGAPI\r
+png_get_compression_type(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ {\r
+ return info_ptr->compression_type;\r
+ }\r
+ return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pHYs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter");\r
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)\r
+ return (0);\r
+ else return (info_ptr->x_pixels_per_unit);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pHYs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter");\r
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)\r
+ return (0);\r
+ else return (info_ptr->y_pixels_per_unit);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pHYs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter");\r
+ if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||\r
+ info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)\r
+ return (0);\r
+ else return (info_ptr->x_pixels_per_unit);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+float PNGAPI\r
+png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)\r
+ {\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pHYs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio");\r
+ if (info_ptr->x_pixels_per_unit == 0)\r
+ return ((float)0.0);\r
+ else\r
+ return ((float)((float)info_ptr->y_pixels_per_unit\r
+ /(float)info_ptr->x_pixels_per_unit));\r
+ }\r
+#else\r
+ return (0.0);\r
+#endif\r
+ return ((float)0.0);\r
+}\r
+#endif\r
+\r
+png_int_32 PNGAPI\r
+png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_oFFs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");\r
+ if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)\r
+ return (0);\r
+ else return (info_ptr->x_offset);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_oFFs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");\r
+ if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)\r
+ return (0);\r
+ else return (info_ptr->y_offset);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_oFFs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns");\r
+ if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)\r
+ return (0);\r
+ else return (info_ptr->x_offset);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+png_int_32 PNGAPI\r
+png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_oFFs)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns");\r
+ if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)\r
+ return (0);\r
+ else return (info_ptr->y_offset);\r
+ }\r
+#else\r
+ return (0);\r
+#endif\r
+ return (0);\r
+}\r
+\r
+#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr)\r
+ *.0254 +.5));\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr)\r
+ *.0254 +.5));\r
+}\r
+\r
+png_uint_32 PNGAPI\r
+png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr)\r
+ *.0254 +.5));\r
+}\r
+\r
+float PNGAPI\r
+png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ return ((float)png_get_x_offset_microns(png_ptr, info_ptr)\r
+ *.00003937);\r
+}\r
+\r
+float PNGAPI\r
+png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ return ((float)png_get_y_offset_microns(png_ptr, info_ptr)\r
+ *.00003937);\r
+}\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
+{\r
+ png_uint_32 retval = 0;\r
+\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "pHYs");\r
+ if (res_x != NULL)\r
+ {\r
+ *res_x = info_ptr->x_pixels_per_unit;\r
+ retval |= PNG_INFO_pHYs;\r
+ }\r
+ if (res_y != NULL)\r
+ {\r
+ *res_y = info_ptr->y_pixels_per_unit;\r
+ retval |= PNG_INFO_pHYs;\r
+ }\r
+ if (unit_type != NULL)\r
+ {\r
+ *unit_type = (int)info_ptr->phys_unit_type;\r
+ retval |= PNG_INFO_pHYs;\r
+ if (*unit_type == 1)\r
+ {\r
+ if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);\r
+ if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);\r
+ }\r
+ }\r
+ }\r
+ return (retval);\r
+}\r
+#endif /* PNG_pHYs_SUPPORTED */\r
+#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */\r
+\r
+/* png_get_channels really belongs in here, too, but it's been around longer */\r
+\r
+#endif /* PNG_EASY_ACCESS_SUPPORTED */\r
+\r
+png_byte PNGAPI\r
+png_get_channels(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ return(info_ptr->channels);\r
+ else\r
+ return (0);\r
+}\r
+\r
+png_bytep PNGAPI\r
+png_get_signature(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL)\r
+ return(info_ptr->signature);\r
+ else\r
+ return (NULL);\r
+}\r
+\r
+#if defined(PNG_bKGD_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_bKGD(png_structp png_ptr, png_infop info_ptr,\r
+ png_color_16p *background)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)\r
+ && background != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "bKGD");\r
+ *background = &(info_ptr->background);\r
+ return (PNG_INFO_bKGD);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_cHRM(png_structp png_ptr, png_infop info_ptr,\r
+ double *white_x, double *white_y, double *red_x, double *red_y,\r
+ double *green_x, double *green_y, double *blue_x, double *blue_y)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "cHRM");\r
+ if (white_x != NULL)\r
+ *white_x = (double)info_ptr->x_white;\r
+ if (white_y != NULL)\r
+ *white_y = (double)info_ptr->y_white;\r
+ if (red_x != NULL)\r
+ *red_x = (double)info_ptr->x_red;\r
+ if (red_y != NULL)\r
+ *red_y = (double)info_ptr->y_red;\r
+ if (green_x != NULL)\r
+ *green_x = (double)info_ptr->x_green;\r
+ if (green_y != NULL)\r
+ *green_y = (double)info_ptr->y_green;\r
+ if (blue_x != NULL)\r
+ *blue_x = (double)info_ptr->x_blue;\r
+ if (blue_y != NULL)\r
+ *blue_y = (double)info_ptr->y_blue;\r
+ return (PNG_INFO_cHRM);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,\r
+ png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,\r
+ png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,\r
+ png_fixed_point *blue_x, png_fixed_point *blue_y)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "cHRM");\r
+ if (white_x != NULL)\r
+ *white_x = info_ptr->int_x_white;\r
+ if (white_y != NULL)\r
+ *white_y = info_ptr->int_y_white;\r
+ if (red_x != NULL)\r
+ *red_x = info_ptr->int_x_red;\r
+ if (red_y != NULL)\r
+ *red_y = info_ptr->int_y_red;\r
+ if (green_x != NULL)\r
+ *green_x = info_ptr->int_x_green;\r
+ if (green_y != NULL)\r
+ *green_y = info_ptr->int_y_green;\r
+ if (blue_x != NULL)\r
+ *blue_x = info_ptr->int_x_blue;\r
+ if (blue_y != NULL)\r
+ *blue_y = info_ptr->int_y_blue;\r
+ return (PNG_INFO_cHRM);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)\r
+ && file_gamma != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "gAMA");\r
+ *file_gamma = (double)info_ptr->gamma;\r
+ return (PNG_INFO_gAMA);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,\r
+ png_fixed_point *int_file_gamma)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)\r
+ && int_file_gamma != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "gAMA");\r
+ *int_file_gamma = info_ptr->int_gamma;\r
+ return (PNG_INFO_gAMA);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_sRGB_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)\r
+ && file_srgb_intent != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "sRGB");\r
+ *file_srgb_intent = (int)info_ptr->srgb_intent;\r
+ return (PNG_INFO_sRGB);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_iCCP(png_structp png_ptr, png_infop info_ptr,\r
+ png_charpp name, int *compression_type,\r
+ png_charpp profile, png_uint_32 *proflen)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)\r
+ && name != NULL && profile != NULL && proflen != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "iCCP");\r
+ *name = info_ptr->iccp_name;\r
+ *profile = info_ptr->iccp_profile;\r
+ /* compression_type is a dummy so the API won't have to change\r
+ if we introduce multiple compression types later. */\r
+ *proflen = (int)info_ptr->iccp_proflen;\r
+ *compression_type = (int)info_ptr->iccp_compression;\r
+ return (PNG_INFO_iCCP);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_sPLT(png_structp png_ptr, png_infop info_ptr,\r
+ png_sPLT_tpp spalettes)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)\r
+ {\r
+ *spalettes = info_ptr->splt_palettes;\r
+ return ((png_uint_32)info_ptr->splt_palettes_num);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)\r
+ && hist != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "hIST");\r
+ *hist = info_ptr->hist;\r
+ return (PNG_INFO_hIST);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+png_uint_32 PNGAPI\r
+png_get_IHDR(png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 *width, png_uint_32 *height, int *bit_depth,\r
+ int *color_type, int *interlace_type, int *compression_type,\r
+ int *filter_type)\r
+\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL &&\r
+ bit_depth != NULL && color_type != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "IHDR");\r
+ *width = info_ptr->width;\r
+ *height = info_ptr->height;\r
+ *bit_depth = info_ptr->bit_depth;\r
+ if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)\r
+ png_error(png_ptr, "Invalid bit depth");\r
+ *color_type = info_ptr->color_type;\r
+ if (info_ptr->color_type > 6)\r
+ png_error(png_ptr, "Invalid color type");\r
+ if (compression_type != NULL)\r
+ *compression_type = info_ptr->compression_type;\r
+ if (filter_type != NULL)\r
+ *filter_type = info_ptr->filter_type;\r
+ if (interlace_type != NULL)\r
+ *interlace_type = info_ptr->interlace_type;\r
+\r
+ /* check for potential overflow of rowbytes */\r
+ if (*width == 0 || *width > PNG_UINT_31_MAX)\r
+ png_error(png_ptr, "Invalid image width");\r
+ if (*height == 0 || *height > PNG_UINT_31_MAX)\r
+ png_error(png_ptr, "Invalid image height");\r
+ if (info_ptr->width > (PNG_UINT_32_MAX\r
+ >> 3) /* 8-byte RGBA pixels */\r
+ - 64 /* bigrowbuf hack */\r
+ - 1 /* filter byte */\r
+ - 7*8 /* rounding of width to multiple of 8 pixels */\r
+ - 8) /* extra max_pixel_depth pad */\r
+ {\r
+ png_warning(png_ptr,\r
+ "Width too large for libpng to process image data.");\r
+ }\r
+ return (1);\r
+ }\r
+ return (0);\r
+}\r
+\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_oFFs(png_structp png_ptr, png_infop info_ptr,\r
+ png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)\r
+ && offset_x != NULL && offset_y != NULL && unit_type != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "oFFs");\r
+ *offset_x = info_ptr->x_offset;\r
+ *offset_y = info_ptr->y_offset;\r
+ *unit_type = (int)info_ptr->offset_unit_type;\r
+ return (PNG_INFO_oFFs);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_pCAL(png_structp png_ptr, png_infop info_ptr,\r
+ png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,\r
+ png_charp *units, png_charpp *params)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)\r
+ && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&\r
+ nparams != NULL && units != NULL && params != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "pCAL");\r
+ *purpose = info_ptr->pcal_purpose;\r
+ *X0 = info_ptr->pcal_X0;\r
+ *X1 = info_ptr->pcal_X1;\r
+ *type = (int)info_ptr->pcal_type;\r
+ *nparams = (int)info_ptr->pcal_nparams;\r
+ *units = info_ptr->pcal_units;\r
+ *params = info_ptr->pcal_params;\r
+ return (PNG_INFO_pCAL);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sCAL_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_sCAL(png_structp png_ptr, png_infop info_ptr,\r
+ int *unit, double *width, double *height)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL &&\r
+ (info_ptr->valid & PNG_INFO_sCAL))\r
+ {\r
+ *unit = info_ptr->scal_unit;\r
+ *width = info_ptr->scal_pixel_width;\r
+ *height = info_ptr->scal_pixel_height;\r
+ return (PNG_INFO_sCAL);\r
+ }\r
+ return(0);\r
+}\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,\r
+ int *unit, png_charpp width, png_charpp height)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL &&\r
+ (info_ptr->valid & PNG_INFO_sCAL))\r
+ {\r
+ *unit = info_ptr->scal_unit;\r
+ *width = info_ptr->scal_s_width;\r
+ *height = info_ptr->scal_s_height;\r
+ return (PNG_INFO_sCAL);\r
+ }\r
+ return(0);\r
+}\r
+#endif\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_pHYs(png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)\r
+{\r
+ png_uint_32 retval = 0;\r
+\r
+ if (png_ptr != NULL && info_ptr != NULL &&\r
+ (info_ptr->valid & PNG_INFO_pHYs))\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "pHYs");\r
+ if (res_x != NULL)\r
+ {\r
+ *res_x = info_ptr->x_pixels_per_unit;\r
+ retval |= PNG_INFO_pHYs;\r
+ }\r
+ if (res_y != NULL)\r
+ {\r
+ *res_y = info_ptr->y_pixels_per_unit;\r
+ retval |= PNG_INFO_pHYs;\r
+ }\r
+ if (unit_type != NULL)\r
+ {\r
+ *unit_type = (int)info_ptr->phys_unit_type;\r
+ retval |= PNG_INFO_pHYs;\r
+ }\r
+ }\r
+ return (retval);\r
+}\r
+#endif\r
+\r
+png_uint_32 PNGAPI\r
+png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,\r
+ int *num_palette)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)\r
+ && palette != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "PLTE");\r
+ *palette = info_ptr->palette;\r
+ *num_palette = info_ptr->num_palette;\r
+ png_debug1(3, "num_palette = %d\n", *num_palette);\r
+ return (PNG_INFO_PLTE);\r
+ }\r
+ return (0);\r
+}\r
+\r
+#if defined(PNG_sBIT_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)\r
+ && sig_bit != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "sBIT");\r
+ *sig_bit = &(info_ptr->sig_bit);\r
+ return (PNG_INFO_sBIT);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,\r
+ int *num_text)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n",\r
+ (png_ptr->chunk_name[0] == '\0' ? "text"\r
+ : (png_const_charp)png_ptr->chunk_name));\r
+ if (text_ptr != NULL)\r
+ *text_ptr = info_ptr->text;\r
+ if (num_text != NULL)\r
+ *num_text = info_ptr->num_text;\r
+ return ((png_uint_32)info_ptr->num_text);\r
+ }\r
+ if (num_text != NULL)\r
+ *num_text = 0;\r
+ return(0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_tIME_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)\r
+ && mod_time != NULL)\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "tIME");\r
+ *mod_time = &(info_ptr->mod_time);\r
+ return (PNG_INFO_tIME);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_tRNS(png_structp png_ptr, png_infop info_ptr,\r
+ png_bytep *trans, int *num_trans, png_color_16p *trans_values)\r
+{\r
+ png_uint_32 retval = 0;\r
+ if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))\r
+ {\r
+ png_debug1(1, "in %s retrieval function\n", "tRNS");\r
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (trans != NULL)\r
+ {\r
+ *trans = info_ptr->trans;\r
+ retval |= PNG_INFO_tRNS;\r
+ }\r
+ if (trans_values != NULL)\r
+ *trans_values = &(info_ptr->trans_values);\r
+ }\r
+ else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */\r
+ {\r
+ if (trans_values != NULL)\r
+ {\r
+ *trans_values = &(info_ptr->trans_values);\r
+ retval |= PNG_INFO_tRNS;\r
+ }\r
+ if (trans != NULL)\r
+ *trans = NULL;\r
+ }\r
+ if (num_trans != NULL)\r
+ {\r
+ *num_trans = info_ptr->num_trans;\r
+ retval |= PNG_INFO_tRNS;\r
+ }\r
+ }\r
+ return (retval);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,\r
+ png_unknown_chunkpp unknowns)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)\r
+ {\r
+ *unknowns = info_ptr->unknown_chunks;\r
+ return ((png_uint_32)info_ptr->unknown_chunks_num);\r
+ }\r
+ return (0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+png_byte PNGAPI\r
+png_get_rgb_to_gray_status (png_structp png_ptr)\r
+{\r
+ return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_USER_CHUNKS_SUPPORTED)\r
+png_voidp PNGAPI\r
+png_get_user_chunk_ptr(png_structp png_ptr)\r
+{\r
+ return (png_ptr? png_ptr->user_chunk_ptr : NULL);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_WRITE_SUPPORTED\r
+png_uint_32 PNGAPI\r
+png_get_compression_buffer_size(png_structp png_ptr)\r
+{\r
+ return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L);\r
+}\r
+#endif\r
+\r
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED\r
+#ifndef PNG_1_0_X\r
+/* this function was added to libpng 1.2.0 and should exist by default */\r
+png_uint_32 PNGAPI\r
+png_get_asm_flags (png_structp png_ptr)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ return (png_ptr? 0L: 0L);\r
+}\r
+\r
+/* this function was added to libpng 1.2.0 and should exist by default */\r
+png_uint_32 PNGAPI\r
+png_get_asm_flagmask (int flag_select)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ flag_select=flag_select;\r
+ return 0L;\r
+}\r
+\r
+ /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */\r
+/* this function was added to libpng 1.2.0 */\r
+png_uint_32 PNGAPI\r
+png_get_mmx_flagmask (int flag_select, int *compilerID)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ flag_select=flag_select;\r
+ *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */\r
+ return 0L;\r
+}\r
+\r
+/* this function was added to libpng 1.2.0 */\r
+png_byte PNGAPI\r
+png_get_mmx_bitdepth_threshold (png_structp png_ptr)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ return (png_ptr? 0: 0);\r
+}\r
+\r
+/* this function was added to libpng 1.2.0 */\r
+png_uint_32 PNGAPI\r
+png_get_mmx_rowbytes_threshold (png_structp png_ptr)\r
+{\r
+ /* obsolete, to be removed from libpng-1.4.0 */\r
+ return (png_ptr? 0L: 0L);\r
+}\r
+#endif /* ?PNG_1_0_X */\r
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */\r
+\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+/* these functions were added to libpng 1.2.6 */\r
+png_uint_32 PNGAPI\r
+png_get_user_width_max (png_structp png_ptr)\r
+{\r
+ return (png_ptr? png_ptr->user_width_max : 0);\r
+}\r
+png_uint_32 PNGAPI\r
+png_get_user_height_max (png_structp png_ptr)\r
+{\r
+ return (png_ptr? png_ptr->user_height_max : 0);\r
+}\r
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */\r
+ \r
+\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngmem.c - stub functions for memory allocation\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file provides a location for all memory allocation. Users who\r
+ * need special memory handling are expected to supply replacement\r
+ * functions for png_malloc() and png_free(), and to use\r
+ * png_create_read_struct_2() and png_create_write_struct_2() to\r
+ * identify the replacement functions.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+/* Borland DOS special memory handler */\r
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)\r
+/* if you change this, be sure to change the one in png.h also */\r
+\r
+/* Allocate memory for a png_struct. The malloc and memset can be replaced\r
+ by a single call to calloc() if this is thought to improve performance. */\r
+png_voidp /* PRIVATE */\r
+png_create_struct(int type)\r
+{\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));\r
+}\r
+\r
+/* Alternate version of png_create_struct, for use with user-defined malloc. */\r
+png_voidp /* PRIVATE */\r
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ png_size_t size;\r
+ png_voidp struct_ptr;\r
+\r
+ if (type == PNG_STRUCT_INFO)\r
+ size = png_sizeof(png_info);\r
+ else if (type == PNG_STRUCT_PNG)\r
+ size = png_sizeof(png_struct);\r
+ else\r
+ return (png_get_copyright(NULL));\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (malloc_fn != NULL)\r
+ {\r
+ png_struct dummy_struct;\r
+ png_structp png_ptr = &dummy_struct;\r
+ png_ptr->mem_ptr=mem_ptr;\r
+ struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);\r
+ }\r
+ else\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ struct_ptr = (png_voidp)farmalloc(size);\r
+ if (struct_ptr != NULL)\r
+ png_memset(struct_ptr, 0, size);\r
+ return (struct_ptr);\r
+}\r
+\r
+/* Free memory allocated by a png_create_struct() call */\r
+void /* PRIVATE */\r
+png_destroy_struct(png_voidp struct_ptr)\r
+{\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);\r
+}\r
+\r
+/* Free memory allocated by a png_create_struct() call */\r
+void /* PRIVATE */\r
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,\r
+ png_voidp mem_ptr)\r
+{\r
+#endif\r
+ if (struct_ptr != NULL)\r
+ {\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (free_fn != NULL)\r
+ {\r
+ png_struct dummy_struct;\r
+ png_structp png_ptr = &dummy_struct;\r
+ png_ptr->mem_ptr=mem_ptr;\r
+ (*(free_fn))(png_ptr, struct_ptr);\r
+ return;\r
+ }\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ farfree (struct_ptr);\r
+ }\r
+}\r
+\r
+/* Allocate memory. For reasonable files, size should never exceed\r
+ * 64K. However, zlib may allocate more then 64K if you don't tell\r
+ * it not to. See zconf.h and png.h for more information. zlib does\r
+ * need to allocate exactly 64K, so whatever you call here must\r
+ * have the ability to do that.\r
+ *\r
+ * Borland seems to have a problem in DOS mode for exactly 64K.\r
+ * It gives you a segment with an offset of 8 (perhaps to store its\r
+ * memory stuff). zlib doesn't like this at all, so we have to\r
+ * detect and deal with it. This code should not be needed in\r
+ * Windows or OS/2 modes, and only in 16 bit mode. This code has\r
+ * been updated by Alexander Lehmann for version 0.89 to waste less\r
+ * memory.\r
+ *\r
+ * Note that we can't use png_size_t for the "size" declaration,\r
+ * since on some systems a png_size_t is a 16-bit quantity, and as a\r
+ * result, we would be truncating potentially larger memory requests\r
+ * (which should cause a fatal error) and introducing major problems.\r
+ */\r
+\r
+png_voidp PNGAPI\r
+png_malloc(png_structp png_ptr, png_uint_32 size)\r
+{\r
+ png_voidp ret;\r
+\r
+ if (png_ptr == NULL || size == 0)\r
+ return (NULL);\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (png_ptr->malloc_fn != NULL)\r
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));\r
+ else\r
+ ret = (png_malloc_default(png_ptr, size));\r
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out of memory!");\r
+ return (ret);\r
+}\r
+\r
+png_voidp PNGAPI\r
+png_malloc_default(png_structp png_ptr, png_uint_32 size)\r
+{\r
+ png_voidp ret;\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+ if (png_ptr == NULL || size == 0)\r
+ return (NULL);\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (size > (png_uint_32)65536L)\r
+ {\r
+ png_warning(png_ptr, "Cannot Allocate > 64K");\r
+ ret = NULL;\r
+ }\r
+ else\r
+#endif\r
+\r
+ if (size != (size_t)size)\r
+ ret = NULL;\r
+ else if (size == (png_uint_32)65536L)\r
+ {\r
+ if (png_ptr->offset_table == NULL)\r
+ {\r
+ /* try to see if we need to do any of this fancy stuff */\r
+ ret = farmalloc(size);\r
+ if (ret == NULL || ((png_size_t)ret & 0xffff))\r
+ {\r
+ int num_blocks;\r
+ png_uint_32 total_size;\r
+ png_bytep table;\r
+ int i;\r
+ png_byte huge * hptr;\r
+\r
+ if (ret != NULL)\r
+ {\r
+ farfree(ret);\r
+ ret = NULL;\r
+ }\r
+\r
+ if (png_ptr->zlib_window_bits > 14)\r
+ num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));\r
+ else\r
+ num_blocks = 1;\r
+ if (png_ptr->zlib_mem_level >= 7)\r
+ num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));\r
+ else\r
+ num_blocks++;\r
+\r
+ total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;\r
+\r
+ table = farmalloc(total_size);\r
+\r
+ if (table == NULL)\r
+ {\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */\r
+ else\r
+ png_warning(png_ptr, "Out Of Memory.");\r
+#endif\r
+ return (NULL);\r
+ }\r
+\r
+ if ((png_size_t)table & 0xfff0)\r
+ {\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr,\r
+ "Farmalloc didn't return normalized pointer");\r
+ else\r
+ png_warning(png_ptr,\r
+ "Farmalloc didn't return normalized pointer");\r
+#endif\r
+ return (NULL);\r
+ }\r
+\r
+ png_ptr->offset_table = table;\r
+ png_ptr->offset_table_ptr = farmalloc(num_blocks *\r
+ png_sizeof(png_bytep));\r
+\r
+ if (png_ptr->offset_table_ptr == NULL)\r
+ {\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */\r
+ else\r
+ png_warning(png_ptr, "Out Of memory.");\r
+#endif\r
+ return (NULL);\r
+ }\r
+\r
+ hptr = (png_byte huge *)table;\r
+ if ((png_size_t)hptr & 0xf)\r
+ {\r
+ hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);\r
+ hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */\r
+ }\r
+ for (i = 0; i < num_blocks; i++)\r
+ {\r
+ png_ptr->offset_table_ptr[i] = (png_bytep)hptr;\r
+ hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */\r
+ }\r
+\r
+ png_ptr->offset_table_number = num_blocks;\r
+ png_ptr->offset_table_count = 0;\r
+ png_ptr->offset_table_count_free = 0;\r
+ }\r
+ }\r
+\r
+ if (png_ptr->offset_table_count >= png_ptr->offset_table_number)\r
+ {\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */\r
+ else\r
+ png_warning(png_ptr, "Out of Memory.");\r
+#endif\r
+ return (NULL);\r
+ }\r
+\r
+ ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];\r
+ }\r
+ else\r
+ ret = farmalloc(size);\r
+\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if (ret == NULL)\r
+ {\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */\r
+ else\r
+ png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */\r
+ }\r
+#endif\r
+\r
+ return (ret);\r
+}\r
+\r
+/* free a pointer allocated by png_malloc(). In the default\r
+ configuration, png_ptr is not used, but is passed in case it\r
+ is needed. If ptr is NULL, return without taking any action. */\r
+\r
+void PNGAPI\r
+png_free(png_structp png_ptr, png_voidp ptr)\r
+{\r
+ if (png_ptr == NULL || ptr == NULL)\r
+ return;\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (png_ptr->free_fn != NULL)\r
+ {\r
+ (*(png_ptr->free_fn))(png_ptr, ptr);\r
+ return;\r
+ }\r
+ else png_free_default(png_ptr, ptr);\r
+}\r
+\r
+void PNGAPI\r
+png_free_default(png_structp png_ptr, png_voidp ptr)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+ if (png_ptr == NULL || ptr == NULL) return;\r
+\r
+ if (png_ptr->offset_table != NULL)\r
+ {\r
+ int i;\r
+\r
+ for (i = 0; i < png_ptr->offset_table_count; i++)\r
+ {\r
+ if (ptr == png_ptr->offset_table_ptr[i])\r
+ {\r
+ ptr = NULL;\r
+ png_ptr->offset_table_count_free++;\r
+ break;\r
+ }\r
+ }\r
+ if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)\r
+ {\r
+ farfree(png_ptr->offset_table);\r
+ farfree(png_ptr->offset_table_ptr);\r
+ png_ptr->offset_table = NULL;\r
+ png_ptr->offset_table_ptr = NULL;\r
+ }\r
+ }\r
+\r
+ if (ptr != NULL)\r
+ {\r
+ farfree(ptr);\r
+ }\r
+}\r
+\r
+#else /* Not the Borland DOS special memory handler */\r
+\r
+/* Allocate memory for a png_struct or a png_info. The malloc and\r
+ memset can be replaced by a single call to calloc() if this is thought\r
+ to improve performance noticably. */\r
+png_voidp /* PRIVATE */\r
+png_create_struct(int type)\r
+{\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));\r
+}\r
+\r
+/* Allocate memory for a png_struct or a png_info. The malloc and\r
+ memset can be replaced by a single call to calloc() if this is thought\r
+ to improve performance noticably. */\r
+png_voidp /* PRIVATE */\r
+png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ png_size_t size;\r
+ png_voidp struct_ptr;\r
+\r
+ if (type == PNG_STRUCT_INFO)\r
+ size = png_sizeof(png_info);\r
+ else if (type == PNG_STRUCT_PNG)\r
+ size = png_sizeof(png_struct);\r
+ else\r
+ return (NULL);\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (malloc_fn != NULL)\r
+ {\r
+ png_struct dummy_struct;\r
+ png_structp png_ptr = &dummy_struct;\r
+ png_ptr->mem_ptr=mem_ptr;\r
+ struct_ptr = (*(malloc_fn))(png_ptr, size);\r
+ if (struct_ptr != NULL)\r
+ png_memset(struct_ptr, 0, size);\r
+ return (struct_ptr);\r
+ }\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+#if defined(__TURBOC__) && !defined(__FLAT__)\r
+ struct_ptr = (png_voidp)farmalloc(size);\r
+#else\r
+# if defined(_MSC_VER) && defined(MAXSEG_64K)\r
+ struct_ptr = (png_voidp)halloc(size, 1);\r
+# else\r
+ struct_ptr = (png_voidp)malloc(size);\r
+# endif\r
+#endif\r
+ if (struct_ptr != NULL)\r
+ png_memset(struct_ptr, 0, size);\r
+\r
+ return (struct_ptr);\r
+}\r
+\r
+\r
+/* Free memory allocated by a png_create_struct() call */\r
+void /* PRIVATE */\r
+png_destroy_struct(png_voidp struct_ptr)\r
+{\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);\r
+}\r
+\r
+/* Free memory allocated by a png_create_struct() call */\r
+void /* PRIVATE */\r
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,\r
+ png_voidp mem_ptr)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ if (struct_ptr != NULL)\r
+ {\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (free_fn != NULL)\r
+ {\r
+ png_struct dummy_struct;\r
+ png_structp png_ptr = &dummy_struct;\r
+ png_ptr->mem_ptr=mem_ptr;\r
+ (*(free_fn))(png_ptr, struct_ptr);\r
+ return;\r
+ }\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+#if defined(__TURBOC__) && !defined(__FLAT__)\r
+ farfree(struct_ptr);\r
+#else\r
+# if defined(_MSC_VER) && defined(MAXSEG_64K)\r
+ hfree(struct_ptr);\r
+# else\r
+ free(struct_ptr);\r
+# endif\r
+#endif\r
+ }\r
+}\r
+\r
+/* Allocate memory. For reasonable files, size should never exceed\r
+ 64K. However, zlib may allocate more then 64K if you don't tell\r
+ it not to. See zconf.h and png.h for more information. zlib does\r
+ need to allocate exactly 64K, so whatever you call here must\r
+ have the ability to do that. */\r
+\r
+png_voidp PNGAPI\r
+png_malloc(png_structp png_ptr, png_uint_32 size)\r
+{\r
+ png_voidp ret;\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (png_ptr == NULL || size == 0)\r
+ return (NULL);\r
+\r
+ if (png_ptr->malloc_fn != NULL)\r
+ ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));\r
+ else\r
+ ret = (png_malloc_default(png_ptr, size));\r
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out of Memory!");\r
+ return (ret);\r
+}\r
+\r
+png_voidp PNGAPI\r
+png_malloc_default(png_structp png_ptr, png_uint_32 size)\r
+{\r
+ png_voidp ret;\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+ if (png_ptr == NULL || size == 0)\r
+ return (NULL);\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (size > (png_uint_32)65536L)\r
+ {\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Cannot Allocate > 64K");\r
+ else\r
+#endif\r
+ return NULL;\r
+ }\r
+#endif\r
+\r
+ /* Check for overflow */\r
+#if defined(__TURBOC__) && !defined(__FLAT__)\r
+ if (size != (unsigned long)size)\r
+ ret = NULL;\r
+ else\r
+ ret = farmalloc(size);\r
+#else\r
+# if defined(_MSC_VER) && defined(MAXSEG_64K)\r
+ if (size != (unsigned long)size)\r
+ ret = NULL;\r
+ else\r
+ ret = halloc(size, 1);\r
+# else\r
+ if (size != (size_t)size)\r
+ ret = NULL;\r
+ else\r
+ ret = malloc((size_t)size);\r
+# endif\r
+#endif\r
+\r
+#ifndef PNG_USER_MEM_SUPPORTED\r
+ if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)\r
+ png_error(png_ptr, "Out of Memory");\r
+#endif\r
+\r
+ return (ret);\r
+}\r
+\r
+/* Free a pointer allocated by png_malloc(). If ptr is NULL, return\r
+ without taking any action. */\r
+void PNGAPI\r
+png_free(png_structp png_ptr, png_voidp ptr)\r
+{\r
+ if (png_ptr == NULL || ptr == NULL)\r
+ return;\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (png_ptr->free_fn != NULL)\r
+ {\r
+ (*(png_ptr->free_fn))(png_ptr, ptr);\r
+ return;\r
+ }\r
+ else png_free_default(png_ptr, ptr);\r
+}\r
+void PNGAPI\r
+png_free_default(png_structp png_ptr, png_voidp ptr)\r
+{\r
+ if (png_ptr == NULL || ptr == NULL)\r
+ return;\r
+\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+#if defined(__TURBOC__) && !defined(__FLAT__)\r
+ farfree(ptr);\r
+#else\r
+# if defined(_MSC_VER) && defined(MAXSEG_64K)\r
+ hfree(ptr);\r
+# else\r
+ free(ptr);\r
+# endif\r
+#endif\r
+}\r
+\r
+#endif /* Not Borland DOS special memory handler */\r
+\r
+#if defined(PNG_1_0_X)\r
+# define png_malloc_warn png_malloc\r
+#else\r
+/* This function was added at libpng version 1.2.3. The png_malloc_warn()\r
+ * function will set up png_malloc() to issue a png_warning and return NULL\r
+ * instead of issuing a png_error, if it fails to allocate the requested\r
+ * memory.\r
+ */\r
+png_voidp PNGAPI\r
+png_malloc_warn(png_structp png_ptr, png_uint_32 size)\r
+{\r
+ png_voidp ptr;\r
+ png_uint_32 save_flags;\r
+ if (png_ptr == NULL) return (NULL);\r
+\r
+ save_flags = png_ptr->flags;\r
+ png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;\r
+ ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);\r
+ png_ptr->flags=save_flags;\r
+ return(ptr);\r
+}\r
+#endif\r
+\r
+png_voidp PNGAPI\r
+png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,\r
+ png_uint_32 length)\r
+{\r
+ png_size_t size;\r
+\r
+ size = (png_size_t)length;\r
+ if ((png_uint_32)size != length)\r
+ png_error(png_ptr, "Overflow in png_memcpy_check.");\r
+\r
+ return(png_memcpy (s1, s2, size));\r
+}\r
+\r
+png_voidp PNGAPI\r
+png_memset_check (png_structp png_ptr, png_voidp s1, int value,\r
+ png_uint_32 length)\r
+{\r
+ png_size_t size;\r
+\r
+ size = (png_size_t)length;\r
+ if ((png_uint_32)size != length)\r
+ png_error(png_ptr, "Overflow in png_memset_check.");\r
+\r
+ return (png_memset (s1, value, size));\r
+\r
+}\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+/* This function is called when the application wants to use another method\r
+ * of allocating and freeing memory.\r
+ */\r
+void PNGAPI\r
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr\r
+ malloc_fn, png_free_ptr free_fn)\r
+{\r
+ if (png_ptr != NULL)\r
+ {\r
+ png_ptr->mem_ptr = mem_ptr;\r
+ png_ptr->malloc_fn = malloc_fn;\r
+ png_ptr->free_fn = free_fn;\r
+ }\r
+}\r
+\r
+/* This function returns a pointer to the mem_ptr associated with the user\r
+ * functions. The application should free any memory associated with this\r
+ * pointer before png_write_destroy and png_read_destroy are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_mem_ptr(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL) return (NULL);\r
+ return ((png_voidp)png_ptr->mem_ptr);\r
+}\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngpread.c - read a png file in push mode\r
+ *\r
+ * Last changed in libpng 1.2.32 [September 18, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+\r
+/* push model modes */\r
+#define PNG_READ_SIG_MODE 0\r
+#define PNG_READ_CHUNK_MODE 1\r
+#define PNG_READ_IDAT_MODE 2\r
+#define PNG_SKIP_MODE 3\r
+#define PNG_READ_tEXt_MODE 4\r
+#define PNG_READ_zTXt_MODE 5\r
+#define PNG_READ_DONE_MODE 6\r
+#define PNG_READ_iTXt_MODE 7\r
+#define PNG_ERROR_MODE 8\r
+\r
+void PNGAPI\r
+png_process_data(png_structp png_ptr, png_infop info_ptr,\r
+ png_bytep buffer, png_size_t buffer_size)\r
+{\r
+ if (png_ptr == NULL || info_ptr == NULL) return;\r
+ png_push_restore_buffer(png_ptr, buffer, buffer_size);\r
+\r
+ while (png_ptr->buffer_size)\r
+ {\r
+ png_process_some_data(png_ptr, info_ptr);\r
+ }\r
+}\r
+\r
+/* What we do with the incoming data depends on what we were previously\r
+ * doing before we ran out of data...\r
+ */\r
+void /* PRIVATE */\r
+png_process_some_data(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ switch (png_ptr->process_mode)\r
+ {\r
+ case PNG_READ_SIG_MODE:\r
+ {\r
+ png_push_read_sig(png_ptr, info_ptr);\r
+ break;\r
+ }\r
+ case PNG_READ_CHUNK_MODE:\r
+ {\r
+ png_push_read_chunk(png_ptr, info_ptr);\r
+ break;\r
+ }\r
+ case PNG_READ_IDAT_MODE:\r
+ {\r
+ png_push_read_IDAT(png_ptr);\r
+ break;\r
+ }\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ case PNG_READ_tEXt_MODE:\r
+ {\r
+ png_push_read_tEXt(png_ptr, info_ptr);\r
+ break;\r
+ }\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ case PNG_READ_zTXt_MODE:\r
+ {\r
+ png_push_read_zTXt(png_ptr, info_ptr);\r
+ break;\r
+ }\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ case PNG_READ_iTXt_MODE:\r
+ {\r
+ png_push_read_iTXt(png_ptr, info_ptr);\r
+ break;\r
+ }\r
+#endif\r
+ case PNG_SKIP_MODE:\r
+ {\r
+ png_push_crc_finish(png_ptr);\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ png_ptr->buffer_size = 0;\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+/* Read any remaining signature bytes from the stream and compare them with\r
+ * the correct PNG signature. It is possible that this routine is called\r
+ * with bytes already read from the signature, either because they have been\r
+ * checked by the calling application, or because of multiple calls to this\r
+ * routine.\r
+ */\r
+void /* PRIVATE */\r
+png_push_read_sig(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_size_t num_checked = png_ptr->sig_bytes,\r
+ num_to_check = 8 - num_checked;\r
+\r
+ if (png_ptr->buffer_size < num_to_check)\r
+ {\r
+ num_to_check = png_ptr->buffer_size;\r
+ }\r
+\r
+ png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),\r
+ num_to_check);\r
+ png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);\r
+\r
+ if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))\r
+ {\r
+ if (num_checked < 4 &&\r
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))\r
+ png_error(png_ptr, "Not a PNG file");\r
+ else\r
+ png_error(png_ptr, "PNG file corrupted by ASCII conversion");\r
+ }\r
+ else\r
+ {\r
+ if (png_ptr->sig_bytes >= 8)\r
+ {\r
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+ }\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IHDR;\r
+ PNG_CONST PNG_IDAT;\r
+ PNG_CONST PNG_IEND;\r
+ PNG_CONST PNG_PLTE;\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ PNG_CONST PNG_bKGD;\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ PNG_CONST PNG_cHRM;\r
+#endif\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ PNG_CONST PNG_gAMA;\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ PNG_CONST PNG_hIST;\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ PNG_CONST PNG_iCCP;\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ PNG_CONST PNG_iTXt;\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ PNG_CONST PNG_oFFs;\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ PNG_CONST PNG_pCAL;\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ PNG_CONST PNG_pHYs;\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ PNG_CONST PNG_sBIT;\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ PNG_CONST PNG_sCAL;\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ PNG_CONST PNG_sRGB;\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ PNG_CONST PNG_sPLT;\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ PNG_CONST PNG_tEXt;\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ PNG_CONST PNG_tIME;\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ PNG_CONST PNG_tRNS;\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ PNG_CONST PNG_zTXt;\r
+#endif\r
+#endif /* PNG_USE_LOCAL_ARRAYS */\r
+ /* First we make sure we have enough data for the 4 byte chunk name\r
+ * and the 4 byte chunk length before proceeding with decoding the\r
+ * chunk data. To fully decode each of these chunks, we also make\r
+ * sure we have enough data in the buffer for the 4 byte CRC at the\r
+ * end of every chunk (except IDAT, which is handled separately).\r
+ */\r
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))\r
+ {\r
+ png_byte chunk_length[4];\r
+\r
+ if (png_ptr->buffer_size < 8)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_push_fill_buffer(png_ptr, chunk_length, 4);\r
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);\r
+ png_reset_crc(png_ptr);\r
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);\r
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);\r
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;\r
+ }\r
+\r
+ if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ if (png_ptr->mode & PNG_AFTER_IDAT)\r
+ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;\r
+\r
+ if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))\r
+ {\r
+ if (png_ptr->push_length != 13)\r
+ png_error(png_ptr, "Invalid IHDR length");\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);\r
+\r
+ png_ptr->process_mode = PNG_READ_DONE_MODE;\r
+ png_push_have_end(png_ptr, info_ptr);\r
+ }\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+ else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ png_ptr->mode |= PNG_HAVE_IDAT;\r
+ png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);\r
+ if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))\r
+ png_ptr->mode |= PNG_HAVE_PLTE;\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ {\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before IDAT");\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ !(png_ptr->mode & PNG_HAVE_PLTE))\r
+ png_error(png_ptr, "Missing PLTE before IDAT");\r
+ }\r
+ }\r
+#endif\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ {\r
+ /* If we reach an IDAT chunk, this means we have read all of the\r
+ * header chunks, and we can start reading the image (or if this\r
+ * is called after the image has been read - we have an error).\r
+ */\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before IDAT");\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ !(png_ptr->mode & PNG_HAVE_PLTE))\r
+ png_error(png_ptr, "Missing PLTE before IDAT");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
+ if (png_ptr->push_length == 0)\r
+ return;\r
+\r
+ if (png_ptr->mode & PNG_AFTER_IDAT)\r
+ png_error(png_ptr, "Too many IDAT's found");\r
+ }\r
+\r
+ png_ptr->idat_size = png_ptr->push_length;\r
+ png_ptr->mode |= PNG_HAVE_IDAT;\r
+ png_ptr->process_mode = PNG_READ_IDAT_MODE;\r
+ png_push_have_info(png_ptr, info_ptr);\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;\r
+ png_ptr->zstream.next_out = png_ptr->row_buf;\r
+ return;\r
+ }\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+#endif\r
+ else\r
+ {\r
+ if (png_ptr->push_length + 4 > png_ptr->buffer_size)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+ png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);\r
+ }\r
+\r
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)\r
+{\r
+ png_ptr->process_mode = PNG_SKIP_MODE;\r
+ png_ptr->skip_length = skip;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_crc_finish(png_structp png_ptr)\r
+{\r
+ if (png_ptr->skip_length && png_ptr->save_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size)\r
+ save_size = (png_size_t)png_ptr->skip_length;\r
+ else\r
+ save_size = png_ptr->save_buffer_size;\r
+\r
+ png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+\r
+ png_ptr->skip_length -= save_size;\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->save_buffer_size -= save_size;\r
+ png_ptr->save_buffer_ptr += save_size;\r
+ }\r
+ if (png_ptr->skip_length && png_ptr->current_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size)\r
+ save_size = (png_size_t)png_ptr->skip_length;\r
+ else\r
+ save_size = png_ptr->current_buffer_size;\r
+\r
+ png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+\r
+ png_ptr->skip_length -= save_size;\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->current_buffer_size -= save_size;\r
+ png_ptr->current_buffer_ptr += save_size;\r
+ }\r
+ if (!png_ptr->skip_length)\r
+ {\r
+ if (png_ptr->buffer_size < 4)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_crc_finish(png_ptr, 0);\r
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+ }\r
+}\r
+\r
+void PNGAPI\r
+png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)\r
+{\r
+ png_bytep ptr;\r
+\r
+ if (png_ptr == NULL) return;\r
+ ptr = buffer;\r
+ if (png_ptr->save_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (length < png_ptr->save_buffer_size)\r
+ save_size = length;\r
+ else\r
+ save_size = png_ptr->save_buffer_size;\r
+\r
+ png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);\r
+ length -= save_size;\r
+ ptr += save_size;\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->save_buffer_size -= save_size;\r
+ png_ptr->save_buffer_ptr += save_size;\r
+ }\r
+ if (length && png_ptr->current_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (length < png_ptr->current_buffer_size)\r
+ save_size = length;\r
+ else\r
+ save_size = png_ptr->current_buffer_size;\r
+\r
+ png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->current_buffer_size -= save_size;\r
+ png_ptr->current_buffer_ptr += save_size;\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_save_buffer(png_structp png_ptr)\r
+{\r
+ if (png_ptr->save_buffer_size)\r
+ {\r
+ if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)\r
+ {\r
+ png_size_t i, istop;\r
+ png_bytep sp;\r
+ png_bytep dp;\r
+\r
+ istop = png_ptr->save_buffer_size;\r
+ for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;\r
+ i < istop; i++, sp++, dp++)\r
+ {\r
+ *dp = *sp;\r
+ }\r
+ }\r
+ }\r
+ if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >\r
+ png_ptr->save_buffer_max)\r
+ {\r
+ png_size_t new_max;\r
+ png_bytep old_buffer;\r
+\r
+ if (png_ptr->save_buffer_size > PNG_SIZE_MAX -\r
+ (png_ptr->current_buffer_size + 256))\r
+ {\r
+ png_error(png_ptr, "Potential overflow of save_buffer");\r
+ }\r
+ new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;\r
+ old_buffer = png_ptr->save_buffer;\r
+ png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)new_max);\r
+ png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);\r
+ png_free(png_ptr, old_buffer);\r
+ png_ptr->save_buffer_max = new_max;\r
+ }\r
+ if (png_ptr->current_buffer_size)\r
+ {\r
+ png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,\r
+ png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);\r
+ png_ptr->save_buffer_size += png_ptr->current_buffer_size;\r
+ png_ptr->current_buffer_size = 0;\r
+ }\r
+ png_ptr->save_buffer_ptr = png_ptr->save_buffer;\r
+ png_ptr->buffer_size = 0;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,\r
+ png_size_t buffer_length)\r
+{\r
+ png_ptr->current_buffer = buffer;\r
+ png_ptr->current_buffer_size = buffer_length;\r
+ png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;\r
+ png_ptr->current_buffer_ptr = png_ptr->current_buffer;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_IDAT(png_structp png_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IDAT;\r
+#endif\r
+ if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))\r
+ {\r
+ png_byte chunk_length[4];\r
+\r
+ if (png_ptr->buffer_size < 8)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_push_fill_buffer(png_ptr, chunk_length, 4);\r
+ png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);\r
+ png_reset_crc(png_ptr);\r
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);\r
+ png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;\r
+\r
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ {\r
+ png_ptr->process_mode = PNG_READ_CHUNK_MODE;\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))\r
+ png_error(png_ptr, "Not enough compressed data");\r
+ return;\r
+ }\r
+\r
+ png_ptr->idat_size = png_ptr->push_length;\r
+ }\r
+ if (png_ptr->idat_size && png_ptr->save_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)\r
+ {\r
+ save_size = (png_size_t)png_ptr->idat_size;\r
+ /* check for overflow */\r
+ if ((png_uint_32)save_size != png_ptr->idat_size)\r
+ png_error(png_ptr, "save_size overflowed in pngpread");\r
+ }\r
+ else\r
+ save_size = png_ptr->save_buffer_size;\r
+\r
+ png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))\r
+ png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);\r
+ png_ptr->idat_size -= save_size;\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->save_buffer_size -= save_size;\r
+ png_ptr->save_buffer_ptr += save_size;\r
+ }\r
+ if (png_ptr->idat_size && png_ptr->current_buffer_size)\r
+ {\r
+ png_size_t save_size;\r
+\r
+ if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)\r
+ {\r
+ save_size = (png_size_t)png_ptr->idat_size;\r
+ /* check for overflow */\r
+ if ((png_uint_32)save_size != png_ptr->idat_size)\r
+ png_error(png_ptr, "save_size overflowed in pngpread");\r
+ }\r
+ else\r
+ save_size = png_ptr->current_buffer_size;\r
+\r
+ png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))\r
+ png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);\r
+\r
+ png_ptr->idat_size -= save_size;\r
+ png_ptr->buffer_size -= save_size;\r
+ png_ptr->current_buffer_size -= save_size;\r
+ png_ptr->current_buffer_ptr += save_size;\r
+ }\r
+ if (!png_ptr->idat_size)\r
+ {\r
+ if (png_ptr->buffer_size < 4)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_crc_finish(png_ptr, 0);\r
+ png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,\r
+ png_size_t buffer_length)\r
+{\r
+ int ret;\r
+\r
+ if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length)\r
+ png_error(png_ptr, "Extra compression data");\r
+\r
+ png_ptr->zstream.next_in = buffer;\r
+ png_ptr->zstream.avail_in = (uInt)buffer_length;\r
+ for (;;)\r
+ {\r
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);\r
+ if (ret != Z_OK)\r
+ {\r
+ if (ret == Z_STREAM_END)\r
+ {\r
+ if (png_ptr->zstream.avail_in)\r
+ png_error(png_ptr, "Extra compressed data");\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ png_push_process_row(png_ptr);\r
+ }\r
+\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;\r
+ break;\r
+ }\r
+ else if (ret == Z_BUF_ERROR)\r
+ break;\r
+ else\r
+ png_error(png_ptr, "Decompression Error");\r
+ }\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ if ((\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED)\r
+ png_ptr->interlaced && png_ptr->pass > 6) ||\r
+ (!png_ptr->interlaced &&\r
+#endif\r
+ png_ptr->row_number == png_ptr->num_rows))\r
+ {\r
+ if (png_ptr->zstream.avail_in)\r
+ png_warning(png_ptr, "Too much data in IDAT chunks");\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;\r
+ break;\r
+ }\r
+ png_push_process_row(png_ptr);\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;\r
+ png_ptr->zstream.next_out = png_ptr->row_buf;\r
+ }\r
+ else\r
+ break;\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_process_row(png_structp png_ptr)\r
+{\r
+ png_ptr->row_info.color_type = png_ptr->color_type;\r
+ png_ptr->row_info.width = png_ptr->iwidth;\r
+ png_ptr->row_info.channels = png_ptr->channels;\r
+ png_ptr->row_info.bit_depth = png_ptr->bit_depth;\r
+ png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;\r
+\r
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,\r
+ png_ptr->row_info.width);\r
+\r
+ png_read_filter_row(png_ptr, &(png_ptr->row_info),\r
+ png_ptr->row_buf + 1, png_ptr->prev_row + 1,\r
+ (int)(png_ptr->row_buf[0]));\r
+\r
+ png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,\r
+ png_ptr->rowbytes + 1);\r
+\r
+ if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))\r
+ png_do_read_transformations(png_ptr);\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED)\r
+ /* blow up interlaced rows to full size */\r
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ if (png_ptr->pass < 6)\r
+/* old interface (pre-1.0.9):\r
+ png_do_read_interlace(&(png_ptr->row_info),\r
+ png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);\r
+ */\r
+ png_do_read_interlace(png_ptr);\r
+\r
+ switch (png_ptr->pass)\r
+ {\r
+ case 0:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 8 && png_ptr->pass == 0; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */\r
+ }\r
+ if (png_ptr->pass == 2) /* pass 1 might be empty */\r
+ {\r
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ if (png_ptr->pass == 4 && png_ptr->height <= 4)\r
+ {\r
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ if (png_ptr->pass == 6 && png_ptr->height <= 4)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ break;\r
+ }\r
+ case 1:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 8 && png_ptr->pass == 1; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ if (png_ptr->pass == 2) /* skip top 4 generated rows */\r
+ {\r
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ for (i = 0; i < 4 && png_ptr->pass == 2; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ if (png_ptr->pass == 4) /* pass 3 might be empty */\r
+ {\r
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 3:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 4 && png_ptr->pass == 3; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ if (png_ptr->pass == 4) /* skip top two generated rows */\r
+ {\r
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ for (i = 0; i < 2 && png_ptr->pass == 4; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ if (png_ptr->pass == 6) /* pass 5 might be empty */\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ break;\r
+ }\r
+ case 5:\r
+ {\r
+ int i;\r
+ for (i = 0; i < 2 && png_ptr->pass == 5; i++)\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ if (png_ptr->pass == 6) /* skip top generated row */\r
+ {\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ break;\r
+ }\r
+ case 6:\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ if (png_ptr->pass != 6)\r
+ break;\r
+ png_push_have_row(png_ptr, png_bytep_NULL);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_push_have_row(png_ptr, png_ptr->row_buf + 1);\r
+ png_read_push_finish_row(png_ptr);\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_read_push_finish_row(png_structp png_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+ /* start of interlace block in the y direction */\r
+ PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+ /* offset to next interlace block in the y direction */\r
+ PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};\r
+\r
+ /* Height of interlace block. This is not currently used - if you need\r
+ * it, uncomment it here and in png.h\r
+ PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};\r
+ */\r
+#endif\r
+\r
+ png_ptr->row_number++;\r
+ if (png_ptr->row_number < png_ptr->num_rows)\r
+ return;\r
+\r
+ if (png_ptr->interlaced)\r
+ {\r
+ png_ptr->row_number = 0;\r
+ png_memset_check(png_ptr, png_ptr->prev_row, 0,\r
+ png_ptr->rowbytes + 1);\r
+ do\r
+ {\r
+ png_ptr->pass++;\r
+ if ((png_ptr->pass == 1 && png_ptr->width < 5) ||\r
+ (png_ptr->pass == 3 && png_ptr->width < 3) ||\r
+ (png_ptr->pass == 5 && png_ptr->width < 2))\r
+ png_ptr->pass++;\r
+\r
+ if (png_ptr->pass > 7)\r
+ png_ptr->pass--;\r
+ if (png_ptr->pass >= 7)\r
+ break;\r
+\r
+ png_ptr->iwidth = (png_ptr->width +\r
+ png_pass_inc[png_ptr->pass] - 1 -\r
+ png_pass_start[png_ptr->pass]) /\r
+ png_pass_inc[png_ptr->pass];\r
+\r
+ png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,\r
+ png_ptr->iwidth) + 1;\r
+\r
+ if (png_ptr->transformations & PNG_INTERLACE)\r
+ break;\r
+\r
+ png_ptr->num_rows = (png_ptr->height +\r
+ png_pass_yinc[png_ptr->pass] - 1 -\r
+ png_pass_ystart[png_ptr->pass]) /\r
+ png_pass_yinc[png_ptr->pass];\r
+\r
+ } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);\r
+ }\r
+}\r
+\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+void /* PRIVATE */\r
+png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32\r
+ length)\r
+{\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))\r
+ {\r
+ png_error(png_ptr, "Out of place tEXt");\r
+ info_ptr = info_ptr; /* to quiet some compiler warnings */\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ png_ptr->skip_length = 0; /* This may not be necessary */\r
+\r
+ if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */\r
+ {\r
+ png_warning(png_ptr, "tEXt chunk too large to fit in memory");\r
+ png_ptr->skip_length = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+\r
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)(length + 1));\r
+ png_ptr->current_text[length] = '\0';\r
+ png_ptr->current_text_ptr = png_ptr->current_text;\r
+ png_ptr->current_text_size = (png_size_t)length;\r
+ png_ptr->current_text_left = (png_size_t)length;\r
+ png_ptr->process_mode = PNG_READ_tEXt_MODE;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr->buffer_size && png_ptr->current_text_left)\r
+ {\r
+ png_size_t text_size;\r
+\r
+ if (png_ptr->buffer_size < png_ptr->current_text_left)\r
+ text_size = png_ptr->buffer_size;\r
+ else\r
+ text_size = png_ptr->current_text_left;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);\r
+ png_ptr->current_text_left -= text_size;\r
+ png_ptr->current_text_ptr += text_size;\r
+ }\r
+ if (!(png_ptr->current_text_left))\r
+ {\r
+ png_textp text_ptr;\r
+ png_charp text;\r
+ png_charp key;\r
+ int ret;\r
+\r
+ if (png_ptr->buffer_size < 4)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_push_crc_finish(png_ptr);\r
+\r
+#if defined(PNG_MAX_MALLOC_64K)\r
+ if (png_ptr->skip_length)\r
+ return;\r
+#endif\r
+\r
+ key = png_ptr->current_text;\r
+\r
+ for (text = key; *text; text++)\r
+ /* empty loop */ ;\r
+\r
+ if (text < key + png_ptr->current_text_size)\r
+ text++;\r
+\r
+ text_ptr = (png_textp)png_malloc(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;\r
+ text_ptr->key = key;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ text_ptr->lang = NULL;\r
+ text_ptr->lang_key = NULL;\r
+#endif\r
+ text_ptr->text = text;\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_free(png_ptr, key);\r
+ png_free(png_ptr, text_ptr);\r
+ png_ptr->current_text = NULL;\r
+\r
+ if (ret)\r
+ png_warning(png_ptr, "Insufficient memory to store text chunk.");\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+void /* PRIVATE */\r
+png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32\r
+ length)\r
+{\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))\r
+ {\r
+ png_error(png_ptr, "Out of place zTXt");\r
+ info_ptr = info_ptr; /* to quiet some compiler warnings */\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ /* We can't handle zTXt chunks > 64K, since we don't have enough space\r
+ * to be able to store the uncompressed data. Actually, the threshold\r
+ * is probably around 32K, but it isn't as definite as 64K is.\r
+ */\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "zTXt chunk too large to fit in memory");\r
+ png_push_crc_skip(png_ptr, length);\r
+ return;\r
+ }\r
+#endif\r
+\r
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)(length + 1));\r
+ png_ptr->current_text[length] = '\0';\r
+ png_ptr->current_text_ptr = png_ptr->current_text;\r
+ png_ptr->current_text_size = (png_size_t)length;\r
+ png_ptr->current_text_left = (png_size_t)length;\r
+ png_ptr->process_mode = PNG_READ_zTXt_MODE;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr->buffer_size && png_ptr->current_text_left)\r
+ {\r
+ png_size_t text_size;\r
+\r
+ if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)\r
+ text_size = png_ptr->buffer_size;\r
+ else\r
+ text_size = png_ptr->current_text_left;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);\r
+ png_ptr->current_text_left -= text_size;\r
+ png_ptr->current_text_ptr += text_size;\r
+ }\r
+ if (!(png_ptr->current_text_left))\r
+ {\r
+ png_textp text_ptr;\r
+ png_charp text;\r
+ png_charp key;\r
+ int ret;\r
+ png_size_t text_size, key_size;\r
+\r
+ if (png_ptr->buffer_size < 4)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_push_crc_finish(png_ptr);\r
+\r
+ key = png_ptr->current_text;\r
+\r
+ for (text = key; *text; text++)\r
+ /* empty loop */ ;\r
+\r
+ /* zTXt can't have zero text */\r
+ if (text >= key + png_ptr->current_text_size)\r
+ {\r
+ png_ptr->current_text = NULL;\r
+ png_free(png_ptr, key);\r
+ return;\r
+ }\r
+\r
+ text++;\r
+\r
+ if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */\r
+ {\r
+ png_ptr->current_text = NULL;\r
+ png_free(png_ptr, key);\r
+ return;\r
+ }\r
+\r
+ text++;\r
+\r
+ png_ptr->zstream.next_in = (png_bytep )text;\r
+ png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -\r
+ (text - key));\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+\r
+ key_size = text - key;\r
+ text_size = 0;\r
+ text = NULL;\r
+ ret = Z_STREAM_END;\r
+\r
+ while (png_ptr->zstream.avail_in)\r
+ {\r
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);\r
+ if (ret != Z_OK && ret != Z_STREAM_END)\r
+ {\r
+ inflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.avail_in = 0;\r
+ png_ptr->current_text = NULL;\r
+ png_free(png_ptr, key);\r
+ png_free(png_ptr, text);\r
+ return;\r
+ }\r
+ if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END)\r
+ {\r
+ if (text == NULL)\r
+ {\r
+ text = (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)(png_ptr->zbuf_size\r
+ - png_ptr->zstream.avail_out + key_size + 1));\r
+ png_memcpy(text + key_size, png_ptr->zbuf,\r
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);\r
+ png_memcpy(text, key, key_size);\r
+ text_size = key_size + png_ptr->zbuf_size -\r
+ png_ptr->zstream.avail_out;\r
+ *(text + text_size) = '\0';\r
+ }\r
+ else\r
+ {\r
+ png_charp tmp;\r
+\r
+ tmp = text;\r
+ text = (png_charp)png_malloc(png_ptr, text_size +\r
+ (png_uint_32)(png_ptr->zbuf_size \r
+ - png_ptr->zstream.avail_out + 1));\r
+ png_memcpy(text, tmp, text_size);\r
+ png_free(png_ptr, tmp);\r
+ png_memcpy(text + text_size, png_ptr->zbuf,\r
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);\r
+ text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;\r
+ *(text + text_size) = '\0';\r
+ }\r
+ if (ret != Z_STREAM_END)\r
+ {\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ break;\r
+ }\r
+\r
+ if (ret == Z_STREAM_END)\r
+ break;\r
+ }\r
+\r
+ inflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.avail_in = 0;\r
+\r
+ if (ret != Z_STREAM_END)\r
+ {\r
+ png_ptr->current_text = NULL;\r
+ png_free(png_ptr, key);\r
+ png_free(png_ptr, text);\r
+ return;\r
+ }\r
+\r
+ png_ptr->current_text = NULL;\r
+ png_free(png_ptr, key);\r
+ key = text;\r
+ text += key_size;\r
+\r
+ text_ptr = (png_textp)png_malloc(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt;\r
+ text_ptr->key = key;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ text_ptr->lang = NULL;\r
+ text_ptr->lang_key = NULL;\r
+#endif\r
+ text_ptr->text = text;\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_free(png_ptr, key);\r
+ png_free(png_ptr, text_ptr);\r
+\r
+ if (ret)\r
+ png_warning(png_ptr, "Insufficient memory to store text chunk.");\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+void /* PRIVATE */\r
+png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32\r
+ length)\r
+{\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))\r
+ {\r
+ png_error(png_ptr, "Out of place iTXt");\r
+ info_ptr = info_ptr; /* to quiet some compiler warnings */\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ png_ptr->skip_length = 0; /* This may not be necessary */\r
+\r
+ if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */\r
+ {\r
+ png_warning(png_ptr, "iTXt chunk too large to fit in memory");\r
+ png_ptr->skip_length = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+\r
+ png_ptr->current_text = (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)(length + 1));\r
+ png_ptr->current_text[length] = '\0';\r
+ png_ptr->current_text_ptr = png_ptr->current_text;\r
+ png_ptr->current_text_size = (png_size_t)length;\r
+ png_ptr->current_text_left = (png_size_t)length;\r
+ png_ptr->process_mode = PNG_READ_iTXt_MODE;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+\r
+ if (png_ptr->buffer_size && png_ptr->current_text_left)\r
+ {\r
+ png_size_t text_size;\r
+\r
+ if (png_ptr->buffer_size < png_ptr->current_text_left)\r
+ text_size = png_ptr->buffer_size;\r
+ else\r
+ text_size = png_ptr->current_text_left;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);\r
+ png_ptr->current_text_left -= text_size;\r
+ png_ptr->current_text_ptr += text_size;\r
+ }\r
+ if (!(png_ptr->current_text_left))\r
+ {\r
+ png_textp text_ptr;\r
+ png_charp key;\r
+ int comp_flag;\r
+ png_charp lang;\r
+ png_charp lang_key;\r
+ png_charp text;\r
+ int ret;\r
+\r
+ if (png_ptr->buffer_size < 4)\r
+ {\r
+ png_push_save_buffer(png_ptr);\r
+ return;\r
+ }\r
+\r
+ png_push_crc_finish(png_ptr);\r
+\r
+#if defined(PNG_MAX_MALLOC_64K)\r
+ if (png_ptr->skip_length)\r
+ return;\r
+#endif\r
+\r
+ key = png_ptr->current_text;\r
+\r
+ for (lang = key; *lang; lang++)\r
+ /* empty loop */ ;\r
+\r
+ if (lang < key + png_ptr->current_text_size - 3)\r
+ lang++;\r
+\r
+ comp_flag = *lang++;\r
+ lang++; /* skip comp_type, always zero */\r
+\r
+ for (lang_key = lang; *lang_key; lang_key++)\r
+ /* empty loop */ ;\r
+ lang_key++; /* skip NUL separator */\r
+\r
+ text=lang_key;\r
+ if (lang_key < key + png_ptr->current_text_size - 1)\r
+ {\r
+ for (; *text; text++)\r
+ /* empty loop */ ;\r
+ }\r
+\r
+ if (text < key + png_ptr->current_text_size)\r
+ text++;\r
+\r
+ text_ptr = (png_textp)png_malloc(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ text_ptr->compression = comp_flag + 2;\r
+ text_ptr->key = key;\r
+ text_ptr->lang = lang;\r
+ text_ptr->lang_key = lang_key;\r
+ text_ptr->text = text;\r
+ text_ptr->text_length = 0;\r
+ text_ptr->itxt_length = png_strlen(text);\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_ptr->current_text = NULL;\r
+\r
+ png_free(png_ptr, text_ptr);\r
+ if (ret)\r
+ png_warning(png_ptr, "Insufficient memory to store iTXt chunk.");\r
+ }\r
+}\r
+#endif\r
+\r
+/* This function is called when we haven't found a handler for this\r
+ * chunk. If there isn't a problem with the chunk itself (ie a bad chunk\r
+ * name or a critical chunk), the chunk is (currently) silently ignored.\r
+ */\r
+void /* PRIVATE */\r
+png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32\r
+ length)\r
+{\r
+ png_uint_32 skip = 0;\r
+\r
+ if (!(png_ptr->chunk_name[0] & 0x20))\r
+ {\r
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=\r
+ PNG_HANDLE_CHUNK_ALWAYS\r
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+ && png_ptr->read_user_chunk_fn == NULL\r
+#endif\r
+ )\r
+#endif\r
+ png_chunk_error(png_ptr, "unknown critical chunk");\r
+\r
+ info_ptr = info_ptr; /* to quiet some compiler warnings */\r
+ }\r
+\r
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS)\r
+ {\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "unknown chunk too large to fit in memory");\r
+ skip = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+ png_memcpy((png_charp)png_ptr->unknown_chunk.name,\r
+ (png_charp)png_ptr->chunk_name, \r
+ png_sizeof(png_ptr->unknown_chunk.name));\r
+ png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]\r
+ = '\0';\r
+\r
+ png_ptr->unknown_chunk.size = (png_size_t)length;\r
+ if (length == 0)\r
+ png_ptr->unknown_chunk.data = NULL;\r
+ else\r
+ {\r
+ png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)length);\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);\r
+ }\r
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+ if (png_ptr->read_user_chunk_fn != NULL)\r
+ {\r
+ /* callback to user unknown chunk handler */\r
+ int ret;\r
+ ret = (*(png_ptr->read_user_chunk_fn))\r
+ (png_ptr, &png_ptr->unknown_chunk);\r
+ if (ret < 0)\r
+ png_chunk_error(png_ptr, "error in user chunk");\r
+ if (ret == 0)\r
+ {\r
+ if (!(png_ptr->chunk_name[0] & 0x20))\r
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=\r
+ PNG_HANDLE_CHUNK_ALWAYS)\r
+ png_chunk_error(png_ptr, "unknown critical chunk");\r
+ png_set_unknown_chunks(png_ptr, info_ptr,\r
+ &png_ptr->unknown_chunk, 1);\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);\r
+ png_free(png_ptr, png_ptr->unknown_chunk.data);\r
+ png_ptr->unknown_chunk.data = NULL;\r
+ }\r
+ else\r
+#endif\r
+ skip=length;\r
+ png_push_crc_skip(png_ptr, skip);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_info(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr->info_fn != NULL)\r
+ (*(png_ptr->info_fn))(png_ptr, info_ptr);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_end(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr->end_fn != NULL)\r
+ (*(png_ptr->end_fn))(png_ptr, info_ptr);\r
+}\r
+\r
+void /* PRIVATE */\r
+png_push_have_row(png_structp png_ptr, png_bytep row)\r
+{\r
+ if (png_ptr->row_fn != NULL)\r
+ (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,\r
+ (int)png_ptr->pass);\r
+}\r
+\r
+void PNGAPI\r
+png_progressive_combine_row (png_structp png_ptr,\r
+ png_bytep old_row, png_bytep new_row)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST int FARDATA png_pass_dsp_mask[7] =\r
+ {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};\r
+#endif\r
+ if (png_ptr == NULL) return;\r
+ if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */\r
+ png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);\r
+}\r
+\r
+void PNGAPI\r
+png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,\r
+ png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,\r
+ png_progressive_end_ptr end_fn)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->info_fn = info_fn;\r
+ png_ptr->row_fn = row_fn;\r
+ png_ptr->end_fn = end_fn;\r
+\r
+ png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);\r
+}\r
+\r
+png_voidp PNGAPI\r
+png_get_progressive_ptr(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL) return (NULL);\r
+ return png_ptr->io_ptr;\r
+}\r
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */\r
--- /dev/null
+\r
+/* pngread.c - read a PNG file\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file contains routines that an application calls directly to\r
+ * read a PNG file or stream.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED)\r
+\r
+/* Create a PNG structure for reading, and allocate any memory needed. */\r
+png_structp PNGAPI\r
+png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn)\r
+{\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn,\r
+ warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));\r
+}\r
+\r
+/* Alternate create PNG structure for reading, and allocate any memory needed. */\r
+png_structp PNGAPI\r
+png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ volatile\r
+#endif\r
+ png_structp png_ptr;\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+#ifdef USE_FAR_KEYWORD\r
+ jmp_buf jmpbuf;\r
+#endif\r
+#endif\r
+\r
+ int i;\r
+\r
+ png_debug(1, "in png_create_read_struct\n");\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,\r
+ (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);\r
+#else\r
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);\r
+#endif\r
+ if (png_ptr == NULL)\r
+ return (NULL);\r
+\r
+ /* added at libpng-1.2.6 */\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;\r
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+#ifdef USE_FAR_KEYWORD\r
+ if (setjmp(jmpbuf))\r
+#else\r
+ if (setjmp(png_ptr->jmpbuf))\r
+#endif\r
+ {\r
+ png_free(png_ptr, png_ptr->zbuf);\r
+ png_ptr->zbuf = NULL;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)png_ptr,\r
+ (png_free_ptr)free_fn, (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)png_ptr);\r
+#endif\r
+ return (NULL);\r
+ }\r
+#ifdef USE_FAR_KEYWORD\r
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+#endif\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);\r
+#endif\r
+\r
+ png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);\r
+\r
+ if (user_png_ver)\r
+ {\r
+ i = 0;\r
+ do\r
+ {\r
+ if (user_png_ver[i] != png_libpng_ver[i])\r
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+ } while (png_libpng_ver[i++]);\r
+ }\r
+ else\r
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+ \r
+\r
+ if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)\r
+ {\r
+ /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so\r
+ * we must recompile any applications that use any older library version.\r
+ * For versions after libpng 1.0, we will be compatible, so we need\r
+ * only check the first digit.\r
+ */\r
+ if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||\r
+ (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||\r
+ (user_png_ver[0] == '0' && user_png_ver[2] < '9'))\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char msg[80];\r
+ if (user_png_ver)\r
+ {\r
+ png_snprintf(msg, 80,\r
+ "Application was compiled with png.h from libpng-%.20s",\r
+ user_png_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+ png_snprintf(msg, 80,\r
+ "Application is running with png.c from libpng-%.20s",\r
+ png_libpng_ver);\r
+ png_warning(png_ptr, msg);\r
+#endif\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags = 0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "Incompatible libpng version in application and library");\r
+ }\r
+ }\r
+\r
+ /* initialize zbuf - compression buffer */\r
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;\r
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+ png_ptr->zstream.zalloc = png_zalloc;\r
+ png_ptr->zstream.zfree = png_zfree;\r
+ png_ptr->zstream.opaque = (voidpf)png_ptr;\r
+\r
+ switch (inflateInit(&png_ptr->zstream))\r
+ {\r
+ case Z_OK: /* Do nothing */ break;\r
+ case Z_MEM_ERROR:\r
+ case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break;\r
+ case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break;\r
+ default: png_error(png_ptr, "Unknown zlib error");\r
+ }\r
+\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+\r
+ png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+/* Applications that neglect to set up their own setjmp() and then encounter\r
+ a png_error() will longjmp here. Since the jmpbuf is then meaningless we\r
+ abort instead of returning. */\r
+#ifdef USE_FAR_KEYWORD\r
+ if (setjmp(jmpbuf))\r
+ PNG_ABORT();\r
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));\r
+#else\r
+ if (setjmp(png_ptr->jmpbuf))\r
+ PNG_ABORT();\r
+#endif\r
+#endif\r
+ return (png_ptr);\r
+}\r
+\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+/* Initialize PNG structure for reading, and allocate any memory needed.\r
+ This interface is deprecated in favour of the png_create_read_struct(),\r
+ and it will disappear as of libpng-1.3.0. */\r
+#undef png_read_init\r
+void PNGAPI\r
+png_read_init(png_structp png_ptr)\r
+{\r
+ /* We only come here via pre-1.0.7-compiled applications */\r
+ png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0);\r
+}\r
+\r
+void PNGAPI\r
+png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,\r
+ png_size_t png_struct_size, png_size_t png_info_size)\r
+{\r
+ /* We only come here via pre-1.0.12-compiled applications */\r
+ if (png_ptr == NULL) return;\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ if (png_sizeof(png_struct) > png_struct_size ||\r
+ png_sizeof(png_info) > png_info_size)\r
+ {\r
+ char msg[80];\r
+ png_ptr->warning_fn = NULL;\r
+ if (user_png_ver)\r
+ {\r
+ png_snprintf(msg, 80,\r
+ "Application was compiled with png.h from libpng-%.20s",\r
+ user_png_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+ png_snprintf(msg, 80,\r
+ "Application is running with png.c from libpng-%.20s",\r
+ png_libpng_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+#endif\r
+ if (png_sizeof(png_struct) > png_struct_size)\r
+ {\r
+ png_ptr->error_fn = NULL;\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags = 0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "The png struct allocated by the application for reading is too small.");\r
+ }\r
+ if (png_sizeof(png_info) > png_info_size)\r
+ {\r
+ png_ptr->error_fn = NULL;\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags = 0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "The info struct allocated by application for reading is too small.");\r
+ }\r
+ png_read_init_3(&png_ptr, user_png_ver, png_struct_size);\r
+}\r
+#endif /* PNG_1_0_X || PNG_1_2_X */\r
+\r
+void PNGAPI\r
+png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,\r
+ png_size_t png_struct_size)\r
+{\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ jmp_buf tmp_jmp; /* to save current jump buffer */\r
+#endif\r
+\r
+ int i = 0;\r
+\r
+ png_structp png_ptr=*ptr_ptr;\r
+\r
+ if (png_ptr == NULL) return;\r
+\r
+ do\r
+ {\r
+ if (user_png_ver[i] != png_libpng_ver[i])\r
+ {\r
+#ifdef PNG_LEGACY_SUPPORTED\r
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+#else\r
+ png_ptr->warning_fn = NULL;\r
+ png_warning(png_ptr,\r
+ "Application uses deprecated png_read_init() and should be recompiled.");\r
+ break;\r
+#endif\r
+ }\r
+ } while (png_libpng_ver[i++]);\r
+\r
+ png_debug(1, "in png_read_init_3\n");\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ /* save jump buffer and error functions */\r
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ if (png_sizeof(png_struct) > png_struct_size)\r
+ {\r
+ png_destroy_struct(png_ptr);\r
+ *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);\r
+ png_ptr = *ptr_ptr;\r
+ }\r
+\r
+ /* reset all variables to 0 */\r
+ png_memset(png_ptr, 0, png_sizeof(png_struct));\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ /* restore jump buffer */\r
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ /* added at libpng-1.2.6 */\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;\r
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;\r
+#endif\r
+\r
+ /* initialize zbuf - compression buffer */\r
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;\r
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+ png_ptr->zstream.zalloc = png_zalloc;\r
+ png_ptr->zstream.zfree = png_zfree;\r
+ png_ptr->zstream.opaque = (voidpf)png_ptr;\r
+\r
+ switch (inflateInit(&png_ptr->zstream))\r
+ {\r
+ case Z_OK: /* Do nothing */ break;\r
+ case Z_MEM_ERROR:\r
+ case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break;\r
+ case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break;\r
+ default: png_error(png_ptr, "Unknown zlib error");\r
+ }\r
+\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+\r
+ png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL);\r
+}\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* Read the information before the actual image data. This has been\r
+ * changed in v0.90 to allow reading a file that already has the magic\r
+ * bytes read from the stream. You can tell libpng how many bytes have\r
+ * been read from the beginning of the stream (up to the maximum of 8)\r
+ * via png_set_sig_bytes(), and we will only check the remaining bytes\r
+ * here. The application can then have access to the signature bytes we\r
+ * read if it is determined that this isn't a valid PNG file.\r
+ */\r
+void PNGAPI\r
+png_read_info(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ if (png_ptr == NULL || info_ptr == NULL) return;\r
+ png_debug(1, "in png_read_info\n");\r
+ /* If we haven't checked all of the PNG signature bytes, do so now. */\r
+ if (png_ptr->sig_bytes < 8)\r
+ {\r
+ png_size_t num_checked = png_ptr->sig_bytes,\r
+ num_to_check = 8 - num_checked;\r
+\r
+ png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);\r
+ png_ptr->sig_bytes = 8;\r
+\r
+ if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))\r
+ {\r
+ if (num_checked < 4 &&\r
+ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))\r
+ png_error(png_ptr, "Not a PNG file");\r
+ else\r
+ png_error(png_ptr, "PNG file corrupted by ASCII conversion");\r
+ }\r
+ if (num_checked < 3)\r
+ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;\r
+ }\r
+\r
+ for (;;)\r
+ {\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IHDR;\r
+ PNG_CONST PNG_IDAT;\r
+ PNG_CONST PNG_IEND;\r
+ PNG_CONST PNG_PLTE;\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ PNG_CONST PNG_bKGD;\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ PNG_CONST PNG_cHRM;\r
+#endif\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ PNG_CONST PNG_gAMA;\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ PNG_CONST PNG_hIST;\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ PNG_CONST PNG_iCCP;\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ PNG_CONST PNG_iTXt;\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ PNG_CONST PNG_oFFs;\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ PNG_CONST PNG_pCAL;\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ PNG_CONST PNG_pHYs;\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ PNG_CONST PNG_sBIT;\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ PNG_CONST PNG_sCAL;\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ PNG_CONST PNG_sPLT;\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ PNG_CONST PNG_sRGB;\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ PNG_CONST PNG_tEXt;\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ PNG_CONST PNG_tIME;\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ PNG_CONST PNG_tRNS;\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ PNG_CONST PNG_zTXt;\r
+#endif\r
+#endif /* PNG_USE_LOCAL_ARRAYS */\r
+ png_uint_32 length = png_read_chunk_header(png_ptr);\r
+ PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;\r
+\r
+ /* This should be a binary subdivision search or a hash for\r
+ * matching the chunk name rather than a linear search.\r
+ */\r
+ if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ if (png_ptr->mode & PNG_AFTER_IDAT)\r
+ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;\r
+\r
+ if (!png_memcmp(chunk_name, png_IHDR, 4))\r
+ png_handle_IHDR(png_ptr, info_ptr, length);\r
+ else if (!png_memcmp(chunk_name, png_IEND, 4))\r
+ png_handle_IEND(png_ptr, info_ptr, length);\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+ else if (png_handle_as_unknown(png_ptr, chunk_name))\r
+ {\r
+ if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ png_ptr->mode |= PNG_HAVE_IDAT;\r
+ png_handle_unknown(png_ptr, info_ptr, length);\r
+ if (!png_memcmp(chunk_name, png_PLTE, 4))\r
+ png_ptr->mode |= PNG_HAVE_PLTE;\r
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ {\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before IDAT");\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ !(png_ptr->mode & PNG_HAVE_PLTE))\r
+ png_error(png_ptr, "Missing PLTE before IDAT");\r
+ break;\r
+ }\r
+ }\r
+#endif\r
+ else if (!png_memcmp(chunk_name, png_PLTE, 4))\r
+ png_handle_PLTE(png_ptr, info_ptr, length);\r
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ {\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before IDAT");\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ !(png_ptr->mode & PNG_HAVE_PLTE))\r
+ png_error(png_ptr, "Missing PLTE before IDAT");\r
+\r
+ png_ptr->idat_size = length;\r
+ png_ptr->mode |= PNG_HAVE_IDAT;\r
+ break;\r
+ }\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_bKGD, 4))\r
+ png_handle_bKGD(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_cHRM, 4))\r
+ png_handle_cHRM(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_gAMA, 4))\r
+ png_handle_gAMA(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_hIST, 4))\r
+ png_handle_hIST(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_oFFs, 4))\r
+ png_handle_oFFs(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_pCAL, 4))\r
+ png_handle_pCAL(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sCAL, 4))\r
+ png_handle_sCAL(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_pHYs, 4))\r
+ png_handle_pHYs(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sBIT, 4))\r
+ png_handle_sBIT(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sRGB, 4))\r
+ png_handle_sRGB(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_iCCP, 4))\r
+ png_handle_iCCP(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sPLT, 4))\r
+ png_handle_sPLT(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tEXt, 4))\r
+ png_handle_tEXt(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tIME, 4))\r
+ png_handle_tIME(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tRNS, 4))\r
+ png_handle_tRNS(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_zTXt, 4))\r
+ png_handle_zTXt(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_iTXt, 4))\r
+ png_handle_iTXt(png_ptr, info_ptr, length);\r
+#endif\r
+ else\r
+ png_handle_unknown(png_ptr, info_ptr, length);\r
+ }\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+/* optional call to update the users info_ptr structure */\r
+void PNGAPI\r
+png_read_update_info(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_read_update_info\n");\r
+ if (png_ptr == NULL) return;\r
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
+ png_read_start_row(png_ptr);\r
+ else\r
+ png_warning(png_ptr,\r
+ "Ignoring extra png_read_update_info() call; row buffer not reallocated");\r
+ png_read_transform_info(png_ptr, info_ptr);\r
+}\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* Initialize palette, background, etc, after transformations\r
+ * are set, but before any reading takes place. This allows\r
+ * the user to obtain a gamma-corrected palette, for example.\r
+ * If the user doesn't call this, we will do it ourselves.\r
+ */\r
+void PNGAPI\r
+png_start_read_image(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_start_read_image\n");\r
+ if (png_ptr == NULL) return;\r
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
+ png_read_start_row(png_ptr);\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+void PNGAPI\r
+png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IDAT;\r
+ PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,\r
+ 0xff};\r
+ PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};\r
+#endif\r
+ int ret;\r
+ if (png_ptr == NULL) return;\r
+ png_debug2(1, "in png_read_row (row %lu, pass %d)\n",\r
+ png_ptr->row_number, png_ptr->pass);\r
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
+ png_read_start_row(png_ptr);\r
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)\r
+ {\r
+ /* check for transforms that have been set but were defined out */\r
+#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_MONO)\r
+ png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_FILLER)\r
+ png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACK)\r
+ png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SHIFT)\r
+ png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BGR)\r
+ png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined.");\r
+#endif\r
+#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_BYTES)\r
+ png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined.");\r
+#endif\r
+ }\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED)\r
+ /* if interlaced and we do not need a new row, combine row and return */\r
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ switch (png_ptr->pass)\r
+ {\r
+ case 0:\r
+ if (png_ptr->row_number & 0x07)\r
+ {\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 1:\r
+ if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)\r
+ {\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 2:\r
+ if ((png_ptr->row_number & 0x07) != 4)\r
+ {\r
+ if (dsp_row != NULL && (png_ptr->row_number & 4))\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 3:\r
+ if ((png_ptr->row_number & 3) || png_ptr->width < 3)\r
+ {\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 4:\r
+ if ((png_ptr->row_number & 3) != 2)\r
+ {\r
+ if (dsp_row != NULL && (png_ptr->row_number & 2))\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 5:\r
+ if ((png_ptr->row_number & 1) || png_ptr->width < 2)\r
+ {\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 6:\r
+ if (!(png_ptr->row_number & 1))\r
+ {\r
+ png_read_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+#endif\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IDAT))\r
+ png_error(png_ptr, "Invalid attempt to read row data");\r
+\r
+ png_ptr->zstream.next_out = png_ptr->row_buf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;\r
+ do\r
+ {\r
+ if (!(png_ptr->zstream.avail_in))\r
+ {\r
+ while (!png_ptr->idat_size)\r
+ {\r
+ png_crc_finish(png_ptr, 0);\r
+\r
+ png_ptr->idat_size = png_read_chunk_header(png_ptr);\r
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ png_error(png_ptr, "Not enough image data");\r
+ }\r
+ png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_in = png_ptr->zbuf;\r
+ if (png_ptr->zbuf_size > png_ptr->idat_size)\r
+ png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;\r
+ png_crc_read(png_ptr, png_ptr->zbuf,\r
+ (png_size_t)png_ptr->zstream.avail_in);\r
+ png_ptr->idat_size -= png_ptr->zstream.avail_in;\r
+ }\r
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);\r
+ if (ret == Z_STREAM_END)\r
+ {\r
+ if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in ||\r
+ png_ptr->idat_size)\r
+ png_error(png_ptr, "Extra compressed data");\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;\r
+ break;\r
+ }\r
+ if (ret != Z_OK)\r
+ png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :\r
+ "Decompression error");\r
+\r
+ } while (png_ptr->zstream.avail_out);\r
+\r
+ png_ptr->row_info.color_type = png_ptr->color_type;\r
+ png_ptr->row_info.width = png_ptr->iwidth;\r
+ png_ptr->row_info.channels = png_ptr->channels;\r
+ png_ptr->row_info.bit_depth = png_ptr->bit_depth;\r
+ png_ptr->row_info.pixel_depth = png_ptr->pixel_depth;\r
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,\r
+ png_ptr->row_info.width);\r
+\r
+ if (png_ptr->row_buf[0])\r
+ png_read_filter_row(png_ptr, &(png_ptr->row_info),\r
+ png_ptr->row_buf + 1, png_ptr->prev_row + 1,\r
+ (int)(png_ptr->row_buf[0]));\r
+\r
+ png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf,\r
+ png_ptr->rowbytes + 1);\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))\r
+ {\r
+ /* Intrapixel differencing */\r
+ png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+ }\r
+#endif\r
+\r
+\r
+ if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA))\r
+ png_do_read_transformations(png_ptr);\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED)\r
+ /* blow up interlaced rows to full size */\r
+ if (png_ptr->interlaced &&\r
+ (png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ if (png_ptr->pass < 6)\r
+/* old interface (pre-1.0.9):\r
+ png_do_read_interlace(&(png_ptr->row_info),\r
+ png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);\r
+ */\r
+ png_do_read_interlace(png_ptr);\r
+\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row,\r
+ png_pass_dsp_mask[png_ptr->pass]);\r
+ if (row != NULL)\r
+ png_combine_row(png_ptr, row,\r
+ png_pass_mask[png_ptr->pass]);\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ if (row != NULL)\r
+ png_combine_row(png_ptr, row, 0xff);\r
+ if (dsp_row != NULL)\r
+ png_combine_row(png_ptr, dsp_row, 0xff);\r
+ }\r
+ png_read_finish_row(png_ptr);\r
+\r
+ if (png_ptr->read_row_fn != NULL)\r
+ (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* Read one or more rows of image data. If the image is interlaced,\r
+ * and png_set_interlace_handling() has been called, the rows need to\r
+ * contain the contents of the rows from the previous pass. If the\r
+ * image has alpha or transparency, and png_handle_alpha()[*] has been\r
+ * called, the rows contents must be initialized to the contents of the\r
+ * screen.\r
+ *\r
+ * "row" holds the actual image, and pixels are placed in it\r
+ * as they arrive. If the image is displayed after each pass, it will\r
+ * appear to "sparkle" in. "display_row" can be used to display a\r
+ * "chunky" progressive image, with finer detail added as it becomes\r
+ * available. If you do not want this "chunky" display, you may pass\r
+ * NULL for display_row. If you do not want the sparkle display, and\r
+ * you have not called png_handle_alpha(), you may pass NULL for rows.\r
+ * If you have called png_handle_alpha(), and the image has either an\r
+ * alpha channel or a transparency chunk, you must provide a buffer for\r
+ * rows. In this case, you do not have to provide a display_row buffer\r
+ * also, but you may. If the image is not interlaced, or if you have\r
+ * not called png_set_interlace_handling(), the display_row buffer will\r
+ * be ignored, so pass NULL to it.\r
+ *\r
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng\r
+ */\r
+\r
+void PNGAPI\r
+png_read_rows(png_structp png_ptr, png_bytepp row,\r
+ png_bytepp display_row, png_uint_32 num_rows)\r
+{\r
+ png_uint_32 i;\r
+ png_bytepp rp;\r
+ png_bytepp dp;\r
+\r
+ png_debug(1, "in png_read_rows\n");\r
+ if (png_ptr == NULL) return;\r
+ rp = row;\r
+ dp = display_row;\r
+ if (rp != NULL && dp != NULL)\r
+ for (i = 0; i < num_rows; i++)\r
+ {\r
+ png_bytep rptr = *rp++;\r
+ png_bytep dptr = *dp++;\r
+\r
+ png_read_row(png_ptr, rptr, dptr);\r
+ }\r
+ else if (rp != NULL)\r
+ for (i = 0; i < num_rows; i++)\r
+ {\r
+ png_bytep rptr = *rp;\r
+ png_read_row(png_ptr, rptr, png_bytep_NULL);\r
+ rp++;\r
+ }\r
+ else if (dp != NULL)\r
+ for (i = 0; i < num_rows; i++)\r
+ {\r
+ png_bytep dptr = *dp;\r
+ png_read_row(png_ptr, png_bytep_NULL, dptr);\r
+ dp++;\r
+ }\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* Read the entire image. If the image has an alpha channel or a tRNS\r
+ * chunk, and you have called png_handle_alpha()[*], you will need to\r
+ * initialize the image to the current image that PNG will be overlaying.\r
+ * We set the num_rows again here, in case it was incorrectly set in\r
+ * png_read_start_row() by a call to png_read_update_info() or\r
+ * png_start_read_image() if png_set_interlace_handling() wasn't called\r
+ * prior to either of these functions like it should have been. You can\r
+ * only call this function once. If you desire to have an image for\r
+ * each pass of a interlaced image, use png_read_rows() instead.\r
+ *\r
+ * [*] png_handle_alpha() does not exist yet, as of this version of libpng\r
+ */\r
+void PNGAPI\r
+png_read_image(png_structp png_ptr, png_bytepp image)\r
+{\r
+ png_uint_32 i, image_height;\r
+ int pass, j;\r
+ png_bytepp rp;\r
+\r
+ png_debug(1, "in png_read_image\n");\r
+ if (png_ptr == NULL) return;\r
+\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+ pass = png_set_interlace_handling(png_ptr);\r
+#else\r
+ if (png_ptr->interlaced)\r
+ png_error(png_ptr,\r
+ "Cannot read interlaced image -- interlace handler disabled.");\r
+ pass = 1;\r
+#endif\r
+\r
+\r
+ image_height=png_ptr->height;\r
+ png_ptr->num_rows = image_height; /* Make sure this is set correctly */\r
+\r
+ for (j = 0; j < pass; j++)\r
+ {\r
+ rp = image;\r
+ for (i = 0; i < image_height; i++)\r
+ {\r
+ png_read_row(png_ptr, *rp, png_bytep_NULL);\r
+ rp++;\r
+ }\r
+ }\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+/* Read the end of the PNG file. Will not read past the end of the\r
+ * file, will verify the end is accurate, and will read any comments\r
+ * or time information at the end of the file, if info is not NULL.\r
+ */\r
+void PNGAPI\r
+png_read_end(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_read_end\n");\r
+ if (png_ptr == NULL) return;\r
+ png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */\r
+\r
+ do\r
+ {\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IHDR;\r
+ PNG_CONST PNG_IDAT;\r
+ PNG_CONST PNG_IEND;\r
+ PNG_CONST PNG_PLTE;\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ PNG_CONST PNG_bKGD;\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ PNG_CONST PNG_cHRM;\r
+#endif\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ PNG_CONST PNG_gAMA;\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ PNG_CONST PNG_hIST;\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ PNG_CONST PNG_iCCP;\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ PNG_CONST PNG_iTXt;\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ PNG_CONST PNG_oFFs;\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ PNG_CONST PNG_pCAL;\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ PNG_CONST PNG_pHYs;\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ PNG_CONST PNG_sBIT;\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ PNG_CONST PNG_sCAL;\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ PNG_CONST PNG_sPLT;\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ PNG_CONST PNG_sRGB;\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ PNG_CONST PNG_tEXt;\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ PNG_CONST PNG_tIME;\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ PNG_CONST PNG_tRNS;\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ PNG_CONST PNG_zTXt;\r
+#endif\r
+#endif /* PNG_USE_LOCAL_ARRAYS */\r
+ png_uint_32 length = png_read_chunk_header(png_ptr);\r
+ PNG_CONST png_bytep chunk_name = png_ptr->chunk_name;\r
+\r
+ if (!png_memcmp(chunk_name, png_IHDR, 4))\r
+ png_handle_IHDR(png_ptr, info_ptr, length);\r
+ else if (!png_memcmp(chunk_name, png_IEND, 4))\r
+ png_handle_IEND(png_ptr, info_ptr, length);\r
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED\r
+ else if (png_handle_as_unknown(png_ptr, chunk_name))\r
+ {\r
+ if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ {\r
+ if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
+ png_error(png_ptr, "Too many IDAT's found");\r
+ }\r
+ png_handle_unknown(png_ptr, info_ptr, length);\r
+ if (!png_memcmp(chunk_name, png_PLTE, 4))\r
+ png_ptr->mode |= PNG_HAVE_PLTE;\r
+ }\r
+#endif\r
+ else if (!png_memcmp(chunk_name, png_IDAT, 4))\r
+ {\r
+ /* Zero length IDATs are legal after the last IDAT has been\r
+ * read, but not after other chunks have been read.\r
+ */\r
+ if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))\r
+ png_error(png_ptr, "Too many IDAT's found");\r
+ png_crc_finish(png_ptr, length);\r
+ }\r
+ else if (!png_memcmp(chunk_name, png_PLTE, 4))\r
+ png_handle_PLTE(png_ptr, info_ptr, length);\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_bKGD, 4))\r
+ png_handle_bKGD(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_cHRM, 4))\r
+ png_handle_cHRM(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_gAMA, 4))\r
+ png_handle_gAMA(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_hIST, 4))\r
+ png_handle_hIST(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_oFFs, 4))\r
+ png_handle_oFFs(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_pCAL, 4))\r
+ png_handle_pCAL(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sCAL, 4))\r
+ png_handle_sCAL(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_pHYs, 4))\r
+ png_handle_pHYs(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sBIT, 4))\r
+ png_handle_sBIT(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sRGB, 4))\r
+ png_handle_sRGB(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_iCCP, 4))\r
+ png_handle_iCCP(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_sPLT, 4))\r
+ png_handle_sPLT(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tEXt, 4))\r
+ png_handle_tEXt(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tIME, 4))\r
+ png_handle_tIME(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_tRNS, 4))\r
+ png_handle_tRNS(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_zTXt, 4))\r
+ png_handle_zTXt(png_ptr, info_ptr, length);\r
+#endif\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+ else if (!png_memcmp(chunk_name, png_iTXt, 4))\r
+ png_handle_iTXt(png_ptr, info_ptr, length);\r
+#endif\r
+ else\r
+ png_handle_unknown(png_ptr, info_ptr, length);\r
+ } while (!(png_ptr->mode & PNG_HAVE_IEND));\r
+}\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+\r
+/* free all memory used by the read */\r
+void PNGAPI\r
+png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,\r
+ png_infopp end_info_ptr_ptr)\r
+{\r
+ png_structp png_ptr = NULL;\r
+ png_infop info_ptr = NULL, end_info_ptr = NULL;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_free_ptr free_fn = NULL;\r
+ png_voidp mem_ptr = NULL;\r
+#endif\r
+\r
+ png_debug(1, "in png_destroy_read_struct\n");\r
+ if (png_ptr_ptr != NULL)\r
+ png_ptr = *png_ptr_ptr;\r
+ if (png_ptr == NULL)\r
+ return;\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ free_fn = png_ptr->free_fn;\r
+ mem_ptr = png_ptr->mem_ptr;\r
+#endif\r
+\r
+ if (info_ptr_ptr != NULL)\r
+ info_ptr = *info_ptr_ptr;\r
+\r
+ if (end_info_ptr_ptr != NULL)\r
+ end_info_ptr = *end_info_ptr_ptr;\r
+\r
+ png_read_destroy(png_ptr, info_ptr, end_info_ptr);\r
+\r
+ if (info_ptr != NULL)\r
+ {\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1);\r
+#endif\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,\r
+ (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)info_ptr);\r
+#endif\r
+ *info_ptr_ptr = NULL;\r
+ }\r
+\r
+ if (end_info_ptr != NULL)\r
+ {\r
+#if defined(PNG_READ_TEXT_SUPPORTED)\r
+ png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1);\r
+#endif\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,\r
+ (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)end_info_ptr);\r
+#endif\r
+ *end_info_ptr_ptr = NULL;\r
+ }\r
+\r
+ if (png_ptr != NULL)\r
+ {\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,\r
+ (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)png_ptr);\r
+#endif\r
+ *png_ptr_ptr = NULL;\r
+ }\r
+}\r
+\r
+/* free all memory used by the read (old method) */\r
+void /* PRIVATE */\r
+png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)\r
+{\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ jmp_buf tmp_jmp;\r
+#endif\r
+ png_error_ptr error_fn;\r
+ png_error_ptr warning_fn;\r
+ png_voidp error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_free_ptr free_fn;\r
+#endif\r
+\r
+ png_debug(1, "in png_read_destroy\n");\r
+ if (info_ptr != NULL)\r
+ png_info_destroy(png_ptr, info_ptr);\r
+\r
+ if (end_info_ptr != NULL)\r
+ png_info_destroy(png_ptr, end_info_ptr);\r
+\r
+ png_free(png_ptr, png_ptr->zbuf);\r
+ png_free(png_ptr, png_ptr->big_row_buf);\r
+ png_free(png_ptr, png_ptr->prev_row);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->palette_lookup);\r
+ png_free(png_ptr, png_ptr->dither_index);\r
+#endif\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->gamma_table);\r
+#endif\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->gamma_from_1);\r
+ png_free(png_ptr, png_ptr->gamma_to_1);\r
+#endif\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ if (png_ptr->free_me & PNG_FREE_PLTE)\r
+ png_zfree(png_ptr, png_ptr->palette);\r
+ png_ptr->free_me &= ~PNG_FREE_PLTE;\r
+#else\r
+ if (png_ptr->flags & PNG_FLAG_FREE_PLTE)\r
+ png_zfree(png_ptr, png_ptr->palette);\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;\r
+#endif\r
+#if defined(PNG_tRNS_SUPPORTED) || \\r
+ defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ if (png_ptr->free_me & PNG_FREE_TRNS)\r
+ png_free(png_ptr, png_ptr->trans);\r
+ png_ptr->free_me &= ~PNG_FREE_TRNS;\r
+#else\r
+ if (png_ptr->flags & PNG_FLAG_FREE_TRNS)\r
+ png_free(png_ptr, png_ptr->trans);\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;\r
+#endif\r
+#endif\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ if (png_ptr->free_me & PNG_FREE_HIST)\r
+ png_free(png_ptr, png_ptr->hist);\r
+ png_ptr->free_me &= ~PNG_FREE_HIST;\r
+#else\r
+ if (png_ptr->flags & PNG_FLAG_FREE_HIST)\r
+ png_free(png_ptr, png_ptr->hist);\r
+ png_ptr->flags &= ~PNG_FLAG_FREE_HIST;\r
+#endif\r
+#endif\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (png_ptr->gamma_16_table != NULL)\r
+ {\r
+ int i;\r
+ int istop = (1 << (8 - png_ptr->gamma_shift));\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ png_free(png_ptr, png_ptr->gamma_16_table[i]);\r
+ }\r
+ png_free(png_ptr, png_ptr->gamma_16_table);\r
+ }\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->gamma_16_from_1 != NULL)\r
+ {\r
+ int i;\r
+ int istop = (1 << (8 - png_ptr->gamma_shift));\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ png_free(png_ptr, png_ptr->gamma_16_from_1[i]);\r
+ }\r
+ png_free(png_ptr, png_ptr->gamma_16_from_1);\r
+ }\r
+ if (png_ptr->gamma_16_to_1 != NULL)\r
+ {\r
+ int i;\r
+ int istop = (1 << (8 - png_ptr->gamma_shift));\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ png_free(png_ptr, png_ptr->gamma_16_to_1[i]);\r
+ }\r
+ png_free(png_ptr, png_ptr->gamma_16_to_1);\r
+ }\r
+#endif\r
+#endif\r
+#if defined(PNG_TIME_RFC1123_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->time_buffer);\r
+#endif\r
+\r
+ inflateEnd(&png_ptr->zstream);\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+ png_free(png_ptr, png_ptr->save_buffer);\r
+#endif\r
+\r
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED\r
+#ifdef PNG_TEXT_SUPPORTED\r
+ png_free(png_ptr, png_ptr->current_text);\r
+#endif /* PNG_TEXT_SUPPORTED */\r
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */\r
+\r
+ /* Save the important info out of the png_struct, in case it is\r
+ * being used again.\r
+ */\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ error_fn = png_ptr->error_fn;\r
+ warning_fn = png_ptr->warning_fn;\r
+ error_ptr = png_ptr->error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ free_fn = png_ptr->free_fn;\r
+#endif\r
+\r
+ png_memset(png_ptr, 0, png_sizeof(png_struct));\r
+\r
+ png_ptr->error_fn = error_fn;\r
+ png_ptr->warning_fn = warning_fn;\r
+ png_ptr->error_ptr = error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_ptr->free_fn = free_fn;\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+}\r
+\r
+void PNGAPI\r
+png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->read_row_fn = read_row_fn;\r
+}\r
+\r
+\r
+#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+void PNGAPI\r
+png_read_png(png_structp png_ptr, png_infop info_ptr,\r
+ int transforms,\r
+ voidp params)\r
+{\r
+ int row;\r
+\r
+ if (png_ptr == NULL) return;\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)\r
+ /* invert the alpha channel from opacity to transparency\r
+ */\r
+ if (transforms & PNG_TRANSFORM_INVERT_ALPHA)\r
+ png_set_invert_alpha(png_ptr);\r
+#endif\r
+\r
+ /* png_read_info() gives us all of the information from the\r
+ * PNG file before the first IDAT (image data chunk).\r
+ */\r
+ png_read_info(png_ptr, info_ptr);\r
+ if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep))\r
+ png_error(png_ptr, "Image is too high to process with png_read_png()");\r
+\r
+ /* -------------- image transformations start here ------------------- */\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+ /* tell libpng to strip 16 bit/color files down to 8 bits per color\r
+ */\r
+ if (transforms & PNG_TRANSFORM_STRIP_16)\r
+ png_set_strip_16(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+ /* Strip alpha bytes from the input data without combining with\r
+ * the background (not recommended).\r
+ */\r
+ if (transforms & PNG_TRANSFORM_STRIP_ALPHA)\r
+ png_set_strip_alpha(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)\r
+ /* Extract multiple pixels with bit depths of 1, 2, or 4 from a single\r
+ * byte into separate bytes (useful for paletted and grayscale images).\r
+ */\r
+ if (transforms & PNG_TRANSFORM_PACKING)\r
+ png_set_packing(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ /* Change the order of packed pixels to least significant bit first\r
+ * (not useful if you are using png_set_packing).\r
+ */\r
+ if (transforms & PNG_TRANSFORM_PACKSWAP)\r
+ png_set_packswap(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ /* Expand paletted colors into true RGB triplets\r
+ * Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel\r
+ * Expand paletted or RGB images with transparency to full alpha\r
+ * channels so the data will be available as RGBA quartets.\r
+ */\r
+ if (transforms & PNG_TRANSFORM_EXPAND)\r
+ if ((png_ptr->bit_depth < 8) ||\r
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||\r
+ (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))\r
+ png_set_expand(png_ptr);\r
+#endif\r
+\r
+ /* We don't handle background color or gamma transformation or dithering.\r
+ */\r
+\r
+#if defined(PNG_READ_INVERT_SUPPORTED)\r
+ /* invert monochrome files to have 0 as white and 1 as black\r
+ */\r
+ if (transforms & PNG_TRANSFORM_INVERT_MONO)\r
+ png_set_invert_mono(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED)\r
+ /* If you want to shift the pixel values from the range [0,255] or\r
+ * [0,65535] to the original [0,7] or [0,31], or whatever range the\r
+ * colors were originally in:\r
+ */\r
+ if ((transforms & PNG_TRANSFORM_SHIFT)\r
+ && png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))\r
+ {\r
+ png_color_8p sig_bit;\r
+\r
+ png_get_sBIT(png_ptr, info_ptr, &sig_bit);\r
+ png_set_shift(png_ptr, sig_bit);\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED)\r
+ /* flip the RGB pixels to BGR (or RGBA to BGRA)\r
+ */\r
+ if (transforms & PNG_TRANSFORM_BGR)\r
+ png_set_bgr(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)\r
+ /* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)\r
+ */\r
+ if (transforms & PNG_TRANSFORM_SWAP_ALPHA)\r
+ png_set_swap_alpha(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED)\r
+ /* swap bytes of 16 bit files to least significant byte first\r
+ */\r
+ if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)\r
+ png_set_swap(png_ptr);\r
+#endif\r
+\r
+ /* We don't handle adding filler bytes */\r
+\r
+ /* Optional call to gamma correct and add the background to the palette\r
+ * and update info structure. REQUIRED if you are expecting libpng to\r
+ * update the palette for you (i.e., you selected such a transform above).\r
+ */\r
+ png_read_update_info(png_ptr, info_ptr);\r
+\r
+ /* -------------- image transformations end here ------------------- */\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);\r
+#endif\r
+ if (info_ptr->row_pointers == NULL)\r
+ {\r
+ info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,\r
+ info_ptr->height * png_sizeof(png_bytep));\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_ROWS;\r
+#endif\r
+ for (row = 0; row < (int)info_ptr->height; row++)\r
+ {\r
+ info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,\r
+ png_get_rowbytes(png_ptr, info_ptr));\r
+ }\r
+ }\r
+\r
+ png_read_image(png_ptr, info_ptr->row_pointers);\r
+ info_ptr->valid |= PNG_INFO_IDAT;\r
+\r
+ /* read rest of file, and get additional chunks in info_ptr - REQUIRED */\r
+ png_read_end(png_ptr, info_ptr);\r
+\r
+ transforms = transforms; /* quiet compiler warnings */\r
+ params = params;\r
+\r
+}\r
+#endif /* PNG_INFO_IMAGE_SUPPORTED */\r
+#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */\r
+#endif /* PNG_READ_SUPPORTED */\r
--- /dev/null
+\r
+/* pngrio.c - functions for data input\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file provides a location for all input. Users who need\r
+ * special handling are expected to write a function that has the same\r
+ * arguments as this and performs a similar function, but that possibly\r
+ * has a different input method. Note that you shouldn't change this\r
+ * function, but rather write a replacement function and then make\r
+ * libpng use it at run time with png_set_read_fn(...).\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED)\r
+\r
+/* Read the data from whatever input you are using. The default routine\r
+ reads from a file pointer. Note that this routine sometimes gets called\r
+ with very small lengths, so you should implement some kind of simple\r
+ buffering if you are using unbuffered reads. This should never be asked\r
+ to read more then 64K on a 16 bit machine. */\r
+void /* PRIVATE */\r
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ png_debug1(4, "reading %d bytes\n", (int)length);\r
+ if (png_ptr->read_data_fn != NULL)\r
+ (*(png_ptr->read_data_fn))(png_ptr, data, length);\r
+ else\r
+ png_error(png_ptr, "Call to NULL read function");\r
+}\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+/* This is the function that does the actual reading of data. If you are\r
+ not reading from a standard C stream, you should create a replacement\r
+ read_data function and use it at run time with png_set_read_fn(), rather\r
+ than changing the library. */\r
+#ifndef USE_FAR_KEYWORD\r
+void PNGAPI\r
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ png_size_t check;\r
+\r
+ if (png_ptr == NULL) return;\r
+ /* fread() returns 0 on error, so it is OK to store this in a png_size_t\r
+ * instead of an int, which is what fread() actually returns.\r
+ */\r
+#if defined(_WIN32_WCE)\r
+ if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )\r
+ check = 0;\r
+#else\r
+ check = (png_size_t)fread(data, (png_size_t)1, length,\r
+ (png_FILE_p)png_ptr->io_ptr);\r
+#endif\r
+\r
+ if (check != length)\r
+ png_error(png_ptr, "Read Error");\r
+}\r
+#else\r
+/* this is the model-independent version. Since the standard I/O library\r
+ can't handle far buffers in the medium and small models, we have to copy\r
+ the data.\r
+*/\r
+\r
+#define NEAR_BUF_SIZE 1024\r
+#define MIN(a,b) (a <= b ? a : b)\r
+\r
+static void PNGAPI\r
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ int check;\r
+ png_byte *n_data;\r
+ png_FILE_p io_ptr;\r
+\r
+ if (png_ptr == NULL) return;\r
+ /* Check if data really is near. If so, use usual code. */\r
+ n_data = (png_byte *)CVT_PTR_NOCHECK(data);\r
+ io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);\r
+ if ((png_bytep)n_data == data)\r
+ {\r
+#if defined(_WIN32_WCE)\r
+ if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )\r
+ check = 0;\r
+#else\r
+ check = fread(n_data, 1, length, io_ptr);\r
+#endif\r
+ }\r
+ else\r
+ {\r
+ png_byte buf[NEAR_BUF_SIZE];\r
+ png_size_t read, remaining, err;\r
+ check = 0;\r
+ remaining = length;\r
+ do\r
+ {\r
+ read = MIN(NEAR_BUF_SIZE, remaining);\r
+#if defined(_WIN32_WCE)\r
+ if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )\r
+ err = 0;\r
+#else\r
+ err = fread(buf, (png_size_t)1, read, io_ptr);\r
+#endif\r
+ png_memcpy(data, buf, read); /* copy far buffer to near buffer */\r
+ if (err != read)\r
+ break;\r
+ else\r
+ check += err;\r
+ data += read;\r
+ remaining -= read;\r
+ }\r
+ while (remaining != 0);\r
+ }\r
+ if ((png_uint_32)check != (png_uint_32)length)\r
+ png_error(png_ptr, "read Error");\r
+}\r
+#endif\r
+#endif\r
+\r
+/* This function allows the application to supply a new input function\r
+ for libpng if standard C streams aren't being used.\r
+\r
+ This function takes as its arguments:\r
+ png_ptr - pointer to a png input data structure\r
+ io_ptr - pointer to user supplied structure containing info about\r
+ the input functions. May be NULL.\r
+ read_data_fn - pointer to a new input function that takes as its\r
+ arguments a pointer to a png_struct, a pointer to\r
+ a location where input data can be stored, and a 32-bit\r
+ unsigned int that is the number of bytes to be read.\r
+ To exit and output any fatal error messages the new write\r
+ function should call png_error(png_ptr, "Error msg"). */\r
+void PNGAPI\r
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,\r
+ png_rw_ptr read_data_fn)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->io_ptr = io_ptr;\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+ if (read_data_fn != NULL)\r
+ png_ptr->read_data_fn = read_data_fn;\r
+ else\r
+ png_ptr->read_data_fn = png_default_read_data;\r
+#else\r
+ png_ptr->read_data_fn = read_data_fn;\r
+#endif\r
+\r
+ /* It is an error to write to a read device */\r
+ if (png_ptr->write_data_fn != NULL)\r
+ {\r
+ png_ptr->write_data_fn = NULL;\r
+ png_warning(png_ptr,\r
+ "It's an error to set both read_data_fn and write_data_fn in the ");\r
+ png_warning(png_ptr,\r
+ "same structure. Resetting write_data_fn to NULL.");\r
+ }\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+ png_ptr->output_flush_fn = NULL;\r
+#endif\r
+}\r
+#endif /* PNG_READ_SUPPORTED */\r
--- /dev/null
+\r
+/* pngrtran.c - transforms the data in a row for PNG readers\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file contains functions optionally called by an application\r
+ * in order to tell libpng how to handle data when reading a PNG.\r
+ * Transformations that are used in both reading and writing are\r
+ * in pngtrans.c.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED)\r
+\r
+/* Set the action on getting a CRC error for an ancillary or critical chunk. */\r
+void PNGAPI\r
+png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action)\r
+{\r
+ png_debug(1, "in png_set_crc_action\n");\r
+ /* Tell libpng how we react to CRC errors in critical chunks */\r
+ if (png_ptr == NULL) return;\r
+ switch (crit_action)\r
+ {\r
+ case PNG_CRC_NO_CHANGE: /* leave setting as is */\r
+ break;\r
+ case PNG_CRC_WARN_USE: /* warn/use data */\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;\r
+ png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;\r
+ break;\r
+ case PNG_CRC_QUIET_USE: /* quiet/use data */\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;\r
+ png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |\r
+ PNG_FLAG_CRC_CRITICAL_IGNORE;\r
+ break;\r
+ case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */\r
+ png_warning(png_ptr,\r
+ "Can't discard critical data on CRC error.");\r
+ case PNG_CRC_ERROR_QUIT: /* error/quit */\r
+ case PNG_CRC_DEFAULT:\r
+ default:\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;\r
+ break;\r
+ }\r
+\r
+ switch (ancil_action)\r
+ {\r
+ case PNG_CRC_NO_CHANGE: /* leave setting as is */\r
+ break;\r
+ case PNG_CRC_WARN_USE: /* warn/use data */\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;\r
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;\r
+ break;\r
+ case PNG_CRC_QUIET_USE: /* quiet/use data */\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;\r
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |\r
+ PNG_FLAG_CRC_ANCILLARY_NOWARN;\r
+ break;\r
+ case PNG_CRC_ERROR_QUIT: /* error/quit */\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;\r
+ png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;\r
+ break;\r
+ case PNG_CRC_WARN_DISCARD: /* warn/discard data */\r
+ case PNG_CRC_DEFAULT:\r
+ default:\r
+ png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;\r
+ break;\r
+ }\r
+}\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \\r
+ defined(PNG_FLOATING_POINT_SUPPORTED)\r
+/* handle alpha and tRNS via a background color */\r
+void PNGAPI\r
+png_set_background(png_structp png_ptr,\r
+ png_color_16p background_color, int background_gamma_code,\r
+ int need_expand, double background_gamma)\r
+{\r
+ png_debug(1, "in png_set_background\n");\r
+ if (png_ptr == NULL) return;\r
+ if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)\r
+ {\r
+ png_warning(png_ptr, "Application must supply a known background gamma");\r
+ return;\r
+ }\r
+\r
+ png_ptr->transformations |= PNG_BACKGROUND;\r
+ png_memcpy(&(png_ptr->background), background_color,\r
+ png_sizeof(png_color_16));\r
+ png_ptr->background_gamma = (float)background_gamma;\r
+ png_ptr->background_gamma_type = (png_byte)(background_gamma_code);\r
+ png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+/* strip 16 bit depth files to 8 bit depth */\r
+void PNGAPI\r
+png_set_strip_16(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_strip_16\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_16_TO_8;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+void PNGAPI\r
+png_set_strip_alpha(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_strip_alpha\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->flags |= PNG_FLAG_STRIP_ALPHA;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+/* Dither file to 8 bit. Supply a palette, the current number\r
+ * of elements in the palette, the maximum number of elements\r
+ * allowed, and a histogram if possible. If the current number\r
+ * of colors is greater then the maximum number, the palette will be\r
+ * modified to fit in the maximum number. "full_dither" indicates\r
+ * whether we need a dithering cube set up for RGB images, or if we\r
+ * simply are reducing the number of colors in a paletted image.\r
+ */\r
+\r
+typedef struct png_dsort_struct\r
+{\r
+ struct png_dsort_struct FAR * next;\r
+ png_byte left;\r
+ png_byte right;\r
+} png_dsort;\r
+typedef png_dsort FAR * png_dsortp;\r
+typedef png_dsort FAR * FAR * png_dsortpp;\r
+\r
+void PNGAPI\r
+png_set_dither(png_structp png_ptr, png_colorp palette,\r
+ int num_palette, int maximum_colors, png_uint_16p histogram,\r
+ int full_dither)\r
+{\r
+ png_debug(1, "in png_set_dither\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_DITHER;\r
+\r
+ if (!full_dither)\r
+ {\r
+ int i;\r
+\r
+ png_ptr->dither_index = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));\r
+ for (i = 0; i < num_palette; i++)\r
+ png_ptr->dither_index[i] = (png_byte)i;\r
+ }\r
+\r
+ if (num_palette > maximum_colors)\r
+ {\r
+ if (histogram != NULL)\r
+ {\r
+ /* This is easy enough, just throw out the least used colors.\r
+ Perhaps not the best solution, but good enough. */\r
+\r
+ int i;\r
+\r
+ /* initialize an array to sort colors */\r
+ png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));\r
+\r
+ /* initialize the dither_sort array */\r
+ for (i = 0; i < num_palette; i++)\r
+ png_ptr->dither_sort[i] = (png_byte)i;\r
+\r
+ /* Find the least used palette entries by starting a\r
+ bubble sort, and running it until we have sorted\r
+ out enough colors. Note that we don't care about\r
+ sorting all the colors, just finding which are\r
+ least used. */\r
+\r
+ for (i = num_palette - 1; i >= maximum_colors; i--)\r
+ {\r
+ int done; /* to stop early if the list is pre-sorted */\r
+ int j;\r
+\r
+ done = 1;\r
+ for (j = 0; j < i; j++)\r
+ {\r
+ if (histogram[png_ptr->dither_sort[j]]\r
+ < histogram[png_ptr->dither_sort[j + 1]])\r
+ {\r
+ png_byte t;\r
+\r
+ t = png_ptr->dither_sort[j];\r
+ png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1];\r
+ png_ptr->dither_sort[j + 1] = t;\r
+ done = 0;\r
+ }\r
+ }\r
+ if (done)\r
+ break;\r
+ }\r
+\r
+ /* swap the palette around, and set up a table, if necessary */\r
+ if (full_dither)\r
+ {\r
+ int j = num_palette;\r
+\r
+ /* put all the useful colors within the max, but don't\r
+ move the others */\r
+ for (i = 0; i < maximum_colors; i++)\r
+ {\r
+ if ((int)png_ptr->dither_sort[i] >= maximum_colors)\r
+ {\r
+ do\r
+ j--;\r
+ while ((int)png_ptr->dither_sort[j] >= maximum_colors);\r
+ palette[i] = palette[j];\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ int j = num_palette;\r
+\r
+ /* move all the used colors inside the max limit, and\r
+ develop a translation table */\r
+ for (i = 0; i < maximum_colors; i++)\r
+ {\r
+ /* only move the colors we need to */\r
+ if ((int)png_ptr->dither_sort[i] >= maximum_colors)\r
+ {\r
+ png_color tmp_color;\r
+\r
+ do\r
+ j--;\r
+ while ((int)png_ptr->dither_sort[j] >= maximum_colors);\r
+\r
+ tmp_color = palette[j];\r
+ palette[j] = palette[i];\r
+ palette[i] = tmp_color;\r
+ /* indicate where the color went */\r
+ png_ptr->dither_index[j] = (png_byte)i;\r
+ png_ptr->dither_index[i] = (png_byte)j;\r
+ }\r
+ }\r
+\r
+ /* find closest color for those colors we are not using */\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ if ((int)png_ptr->dither_index[i] >= maximum_colors)\r
+ {\r
+ int min_d, k, min_k, d_index;\r
+\r
+ /* find the closest color to one we threw out */\r
+ d_index = png_ptr->dither_index[i];\r
+ min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);\r
+ for (k = 1, min_k = 0; k < maximum_colors; k++)\r
+ {\r
+ int d;\r
+\r
+ d = PNG_COLOR_DIST(palette[d_index], palette[k]);\r
+\r
+ if (d < min_d)\r
+ {\r
+ min_d = d;\r
+ min_k = k;\r
+ }\r
+ }\r
+ /* point to closest color */\r
+ png_ptr->dither_index[i] = (png_byte)min_k;\r
+ }\r
+ }\r
+ }\r
+ png_free(png_ptr, png_ptr->dither_sort);\r
+ png_ptr->dither_sort = NULL;\r
+ }\r
+ else\r
+ {\r
+ /* This is much harder to do simply (and quickly). Perhaps\r
+ we need to go through a median cut routine, but those\r
+ don't always behave themselves with only a few colors\r
+ as input. So we will just find the closest two colors,\r
+ and throw out one of them (chosen somewhat randomly).\r
+ [We don't understand this at all, so if someone wants to\r
+ work on improving it, be our guest - AED, GRP]\r
+ */\r
+ int i;\r
+ int max_d;\r
+ int num_new_palette;\r
+ png_dsortp t;\r
+ png_dsortpp hash;\r
+\r
+ t = NULL;\r
+\r
+ /* initialize palette index arrays */\r
+ png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));\r
+ png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(num_palette * png_sizeof(png_byte)));\r
+\r
+ /* initialize the sort array */\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ png_ptr->index_to_palette[i] = (png_byte)i;\r
+ png_ptr->palette_to_index[i] = (png_byte)i;\r
+ }\r
+\r
+ hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 *\r
+ png_sizeof(png_dsortp)));\r
+ for (i = 0; i < 769; i++)\r
+ hash[i] = NULL;\r
+/* png_memset(hash, 0, 769 * png_sizeof(png_dsortp)); */\r
+\r
+ num_new_palette = num_palette;\r
+\r
+ /* initial wild guess at how far apart the farthest pixel\r
+ pair we will be eliminating will be. Larger\r
+ numbers mean more areas will be allocated, Smaller\r
+ numbers run the risk of not saving enough data, and\r
+ having to do this all over again.\r
+\r
+ I have not done extensive checking on this number.\r
+ */\r
+ max_d = 96;\r
+\r
+ while (num_new_palette > maximum_colors)\r
+ {\r
+ for (i = 0; i < num_new_palette - 1; i++)\r
+ {\r
+ int j;\r
+\r
+ for (j = i + 1; j < num_new_palette; j++)\r
+ {\r
+ int d;\r
+\r
+ d = PNG_COLOR_DIST(palette[i], palette[j]);\r
+\r
+ if (d <= max_d)\r
+ {\r
+\r
+ t = (png_dsortp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_dsort)));\r
+ if (t == NULL)\r
+ break;\r
+ t->next = hash[d];\r
+ t->left = (png_byte)i;\r
+ t->right = (png_byte)j;\r
+ hash[d] = t;\r
+ }\r
+ }\r
+ if (t == NULL)\r
+ break;\r
+ }\r
+\r
+ if (t != NULL)\r
+ for (i = 0; i <= max_d; i++)\r
+ {\r
+ if (hash[i] != NULL)\r
+ {\r
+ png_dsortp p;\r
+\r
+ for (p = hash[i]; p; p = p->next)\r
+ {\r
+ if ((int)png_ptr->index_to_palette[p->left]\r
+ < num_new_palette &&\r
+ (int)png_ptr->index_to_palette[p->right]\r
+ < num_new_palette)\r
+ {\r
+ int j, next_j;\r
+\r
+ if (num_new_palette & 0x01)\r
+ {\r
+ j = p->left;\r
+ next_j = p->right;\r
+ }\r
+ else\r
+ {\r
+ j = p->right;\r
+ next_j = p->left;\r
+ }\r
+\r
+ num_new_palette--;\r
+ palette[png_ptr->index_to_palette[j]]\r
+ = palette[num_new_palette];\r
+ if (!full_dither)\r
+ {\r
+ int k;\r
+\r
+ for (k = 0; k < num_palette; k++)\r
+ {\r
+ if (png_ptr->dither_index[k] ==\r
+ png_ptr->index_to_palette[j])\r
+ png_ptr->dither_index[k] =\r
+ png_ptr->index_to_palette[next_j];\r
+ if ((int)png_ptr->dither_index[k] ==\r
+ num_new_palette)\r
+ png_ptr->dither_index[k] =\r
+ png_ptr->index_to_palette[j];\r
+ }\r
+ }\r
+\r
+ png_ptr->index_to_palette[png_ptr->palette_to_index\r
+ [num_new_palette]] = png_ptr->index_to_palette[j];\r
+ png_ptr->palette_to_index[png_ptr->index_to_palette[j]]\r
+ = png_ptr->palette_to_index[num_new_palette];\r
+\r
+ png_ptr->index_to_palette[j] = (png_byte)num_new_palette;\r
+ png_ptr->palette_to_index[num_new_palette] = (png_byte)j;\r
+ }\r
+ if (num_new_palette <= maximum_colors)\r
+ break;\r
+ }\r
+ if (num_new_palette <= maximum_colors)\r
+ break;\r
+ }\r
+ }\r
+\r
+ for (i = 0; i < 769; i++)\r
+ {\r
+ if (hash[i] != NULL)\r
+ {\r
+ png_dsortp p = hash[i];\r
+ while (p)\r
+ {\r
+ t = p->next;\r
+ png_free(png_ptr, p);\r
+ p = t;\r
+ }\r
+ }\r
+ hash[i] = 0;\r
+ }\r
+ max_d += 96;\r
+ }\r
+ png_free(png_ptr, hash);\r
+ png_free(png_ptr, png_ptr->palette_to_index);\r
+ png_free(png_ptr, png_ptr->index_to_palette);\r
+ png_ptr->palette_to_index = NULL;\r
+ png_ptr->index_to_palette = NULL;\r
+ }\r
+ num_palette = maximum_colors;\r
+ }\r
+ if (png_ptr->palette == NULL)\r
+ {\r
+ png_ptr->palette = palette;\r
+ }\r
+ png_ptr->num_palette = (png_uint_16)num_palette;\r
+\r
+ if (full_dither)\r
+ {\r
+ int i;\r
+ png_bytep distance;\r
+ int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS +\r
+ PNG_DITHER_BLUE_BITS;\r
+ int num_red = (1 << PNG_DITHER_RED_BITS);\r
+ int num_green = (1 << PNG_DITHER_GREEN_BITS);\r
+ int num_blue = (1 << PNG_DITHER_BLUE_BITS);\r
+ png_size_t num_entries = ((png_size_t)1 << total_bits);\r
+\r
+ png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr,\r
+ (png_uint_32)(num_entries * png_sizeof(png_byte)));\r
+\r
+ png_memset(png_ptr->palette_lookup, 0, num_entries *\r
+ png_sizeof(png_byte));\r
+\r
+ distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *\r
+ png_sizeof(png_byte)));\r
+\r
+ png_memset(distance, 0xff, num_entries * png_sizeof(png_byte));\r
+\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ int ir, ig, ib;\r
+ int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS));\r
+ int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS));\r
+ int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS));\r
+\r
+ for (ir = 0; ir < num_red; ir++)\r
+ {\r
+ /* int dr = abs(ir - r); */\r
+ int dr = ((ir > r) ? ir - r : r - ir);\r
+ int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS));\r
+\r
+ for (ig = 0; ig < num_green; ig++)\r
+ {\r
+ /* int dg = abs(ig - g); */\r
+ int dg = ((ig > g) ? ig - g : g - ig);\r
+ int dt = dr + dg;\r
+ int dm = ((dr > dg) ? dr : dg);\r
+ int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS);\r
+\r
+ for (ib = 0; ib < num_blue; ib++)\r
+ {\r
+ int d_index = index_g | ib;\r
+ /* int db = abs(ib - b); */\r
+ int db = ((ib > b) ? ib - b : b - ib);\r
+ int dmax = ((dm > db) ? dm : db);\r
+ int d = dmax + dt + db;\r
+\r
+ if (d < (int)distance[d_index])\r
+ {\r
+ distance[d_index] = (png_byte)d;\r
+ png_ptr->palette_lookup[d_index] = (png_byte)i;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ png_free(png_ptr, distance);\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+/* Transform the image from the file_gamma to the screen_gamma. We\r
+ * only do transformations on images where the file_gamma and screen_gamma\r
+ * are not close reciprocals, otherwise it slows things down slightly, and\r
+ * also needlessly introduces small errors.\r
+ *\r
+ * We will turn off gamma transformation later if no semitransparent entries\r
+ * are present in the tRNS array for palette images. We can't do it here\r
+ * because we don't necessarily have the tRNS chunk yet.\r
+ */\r
+void PNGAPI\r
+png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma)\r
+{\r
+ png_debug(1, "in png_set_gamma\n");\r
+ if (png_ptr == NULL) return;\r
+ if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) ||\r
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) ||\r
+ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))\r
+ png_ptr->transformations |= PNG_GAMMA;\r
+ png_ptr->gamma = (float)file_gamma;\r
+ png_ptr->screen_gamma = (float)scrn_gamma;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+/* Expand paletted images to RGB, expand grayscale images of\r
+ * less than 8-bit depth to 8-bit depth, and expand tRNS chunks\r
+ * to alpha channels.\r
+ */\r
+void PNGAPI\r
+png_set_expand(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_expand\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);\r
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;\r
+}\r
+\r
+/* GRR 19990627: the following three functions currently are identical\r
+ * to png_set_expand(). However, it is entirely reasonable that someone\r
+ * might wish to expand an indexed image to RGB but *not* expand a single,\r
+ * fully transparent palette entry to a full alpha channel--perhaps instead\r
+ * convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace\r
+ * the transparent color with a particular RGB value, or drop tRNS entirely.\r
+ * IOW, a future version of the library may make the transformations flag\r
+ * a bit more fine-grained, with separate bits for each of these three\r
+ * functions.\r
+ *\r
+ * More to the point, these functions make it obvious what libpng will be\r
+ * doing, whereas "expand" can (and does) mean any number of things.\r
+ *\r
+ * GRP 20060307: In libpng-1.4.0, png_set_gray_1_2_4_to_8() was modified\r
+ * to expand only the sample depth but not to expand the tRNS to alpha.\r
+ */\r
+\r
+/* Expand paletted images to RGB. */\r
+void PNGAPI\r
+png_set_palette_to_rgb(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_palette_to_rgb\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);\r
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;\r
+}\r
+\r
+#if !defined(PNG_1_0_X)\r
+/* Expand grayscale images of less than 8-bit depth to 8 bits. */\r
+void PNGAPI\r
+png_set_expand_gray_1_2_4_to_8(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_expand_gray_1_2_4_to_8\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_EXPAND;\r
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+/* Expand grayscale images of less than 8-bit depth to 8 bits. */\r
+/* Deprecated as of libpng-1.2.9 */\r
+void PNGAPI\r
+png_set_gray_1_2_4_to_8(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_gray_1_2_4_to_8\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);\r
+}\r
+#endif\r
+\r
+\r
+/* Expand tRNS chunks to alpha channels. */\r
+void PNGAPI\r
+png_set_tRNS_to_alpha(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_tRNS_to_alpha\n");\r
+ png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);\r
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;\r
+}\r
+#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+void PNGAPI\r
+png_set_gray_to_rgb(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_gray_to_rgb\n");\r
+ png_ptr->transformations |= PNG_GRAY_TO_RGB;\r
+ png_ptr->flags &= ~PNG_FLAG_ROW_INIT;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED)\r
+/* Convert a RGB image to a grayscale of the same width. This allows us,\r
+ * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image.\r
+ */\r
+\r
+void PNGAPI\r
+png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red,\r
+ double green)\r
+{\r
+ int red_fixed = (int)((float)red*100000.0 + 0.5);\r
+ int green_fixed = (int)((float)green*100000.0 + 0.5);\r
+ if (png_ptr == NULL) return;\r
+ png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed);\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action,\r
+ png_fixed_point red, png_fixed_point green)\r
+{\r
+ png_debug(1, "in png_set_rgb_to_gray\n");\r
+ if (png_ptr == NULL) return;\r
+ switch(error_action)\r
+ {\r
+ case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY;\r
+ break;\r
+ case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;\r
+ break;\r
+ case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;\r
+ }\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ png_ptr->transformations |= PNG_EXPAND;\r
+#else\r
+ {\r
+ png_warning(png_ptr,\r
+ "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED.");\r
+ png_ptr->transformations &= ~PNG_RGB_TO_GRAY;\r
+ }\r
+#endif\r
+ {\r
+ png_uint_16 red_int, green_int;\r
+ if (red < 0 || green < 0)\r
+ {\r
+ red_int = 6968; /* .212671 * 32768 + .5 */\r
+ green_int = 23434; /* .715160 * 32768 + .5 */\r
+ }\r
+ else if (red + green < 100000L)\r
+ {\r
+ red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L);\r
+ green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L);\r
+ }\r
+ else\r
+ {\r
+ png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients");\r
+ red_int = 6968;\r
+ green_int = 23434;\r
+ }\r
+ png_ptr->rgb_to_gray_red_coeff = red_int;\r
+ png_ptr->rgb_to_gray_green_coeff = green_int;\r
+ png_ptr->rgb_to_gray_blue_coeff = \r
+ (png_uint_16)(32768 - red_int - green_int);\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+void PNGAPI\r
+png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr\r
+ read_user_transform_fn)\r
+{\r
+ png_debug(1, "in png_set_read_user_transform_fn\n");\r
+ if (png_ptr == NULL) return;\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)\r
+ png_ptr->transformations |= PNG_USER_TRANSFORM;\r
+ png_ptr->read_user_transform_fn = read_user_transform_fn;\r
+#endif\r
+#ifdef PNG_LEGACY_SUPPORTED\r
+ if (read_user_transform_fn)\r
+ png_warning(png_ptr,\r
+ "This version of libpng does not support user transforms");\r
+#endif\r
+}\r
+#endif\r
+\r
+/* Initialize everything needed for the read. This includes modifying\r
+ * the palette.\r
+ */\r
+void /* PRIVATE */\r
+png_init_read_transformations(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_init_read_transformations\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (png_ptr != NULL)\r
+#endif\r
+ {\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \\r
+ || defined(PNG_READ_GAMMA_SUPPORTED)\r
+ int color_type = png_ptr->color_type;\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+ /* Detect gray background and attempt to enable optimization\r
+ * for gray --> RGB case */\r
+ /* Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or\r
+ * RGB_ALPHA (in which case need_expand is superfluous anyway), the\r
+ * background color might actually be gray yet not be flagged as such.\r
+ * This is not a problem for the current code, which uses\r
+ * PNG_BACKGROUND_IS_GRAY only to decide when to do the\r
+ * png_do_gray_to_rgb() transformation.\r
+ */\r
+ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&\r
+ !(color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;\r
+ } else if ((png_ptr->transformations & PNG_BACKGROUND) &&\r
+ !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&\r
+ (png_ptr->transformations & PNG_GRAY_TO_RGB) &&\r
+ png_ptr->background.red == png_ptr->background.green &&\r
+ png_ptr->background.red == png_ptr->background.blue)\r
+ {\r
+ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;\r
+ png_ptr->background.gray = png_ptr->background.red;\r
+ }\r
+#endif\r
+\r
+ if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) &&\r
+ (png_ptr->transformations & PNG_EXPAND))\r
+ {\r
+ if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */\r
+ {\r
+ /* expand background and tRNS chunks */\r
+ switch (png_ptr->bit_depth)\r
+ {\r
+ case 1:\r
+ png_ptr->background.gray *= (png_uint_16)0xff;\r
+ png_ptr->background.red = png_ptr->background.green\r
+ = png_ptr->background.blue = png_ptr->background.gray;\r
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))\r
+ {\r
+ png_ptr->trans_values.gray *= (png_uint_16)0xff;\r
+ png_ptr->trans_values.red = png_ptr->trans_values.green\r
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;\r
+ }\r
+ break;\r
+ case 2:\r
+ png_ptr->background.gray *= (png_uint_16)0x55;\r
+ png_ptr->background.red = png_ptr->background.green\r
+ = png_ptr->background.blue = png_ptr->background.gray;\r
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))\r
+ {\r
+ png_ptr->trans_values.gray *= (png_uint_16)0x55;\r
+ png_ptr->trans_values.red = png_ptr->trans_values.green\r
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;\r
+ }\r
+ break;\r
+ case 4:\r
+ png_ptr->background.gray *= (png_uint_16)0x11;\r
+ png_ptr->background.red = png_ptr->background.green\r
+ = png_ptr->background.blue = png_ptr->background.gray;\r
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))\r
+ {\r
+ png_ptr->trans_values.gray *= (png_uint_16)0x11;\r
+ png_ptr->trans_values.red = png_ptr->trans_values.green\r
+ = png_ptr->trans_values.blue = png_ptr->trans_values.gray;\r
+ }\r
+ break;\r
+ case 8:\r
+ case 16:\r
+ png_ptr->background.red = png_ptr->background.green\r
+ = png_ptr->background.blue = png_ptr->background.gray;\r
+ break;\r
+ }\r
+ }\r
+ else if (color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_ptr->background.red =\r
+ png_ptr->palette[png_ptr->background.index].red;\r
+ png_ptr->background.green =\r
+ png_ptr->palette[png_ptr->background.index].green;\r
+ png_ptr->background.blue =\r
+ png_ptr->palette[png_ptr->background.index].blue;\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)\r
+ {\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ if (!(png_ptr->transformations & PNG_EXPAND_tRNS))\r
+#endif\r
+ {\r
+ /* invert the alpha channel (in tRNS) unless the pixels are\r
+ going to be expanded, in which case leave it for later */\r
+ int i, istop;\r
+ istop=(int)png_ptr->num_trans;\r
+ for (i=0; i<istop; i++)\r
+ png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]);\r
+ }\r
+ }\r
+#endif\r
+\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)\r
+ png_ptr->background_1 = png_ptr->background;\r
+#endif\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+\r
+ if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0)\r
+ && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0)\r
+ < PNG_GAMMA_THRESHOLD))\r
+ {\r
+ int i, k;\r
+ k=0;\r
+ for (i=0; i<png_ptr->num_trans; i++)\r
+ {\r
+ if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff)\r
+ k=1; /* partial transparency is present */\r
+ }\r
+ if (k == 0)\r
+ png_ptr->transformations &= ~PNG_GAMMA;\r
+ }\r
+\r
+ if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) &&\r
+ png_ptr->gamma != 0.0)\r
+ {\r
+ png_build_gamma_table(png_ptr);\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BACKGROUND)\r
+ {\r
+ if (color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ /* could skip if no transparency and\r
+ */\r
+ png_color back, back_1;\r
+ png_colorp palette = png_ptr->palette;\r
+ int num_palette = png_ptr->num_palette;\r
+ int i;\r
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)\r
+ {\r
+ back.red = png_ptr->gamma_table[png_ptr->background.red];\r
+ back.green = png_ptr->gamma_table[png_ptr->background.green];\r
+ back.blue = png_ptr->gamma_table[png_ptr->background.blue];\r
+\r
+ back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];\r
+ back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];\r
+ back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];\r
+ }\r
+ else\r
+ {\r
+ double g, gs;\r
+\r
+ switch (png_ptr->background_gamma_type)\r
+ {\r
+ case PNG_BACKGROUND_GAMMA_SCREEN:\r
+ g = (png_ptr->screen_gamma);\r
+ gs = 1.0;\r
+ break;\r
+ case PNG_BACKGROUND_GAMMA_FILE:\r
+ g = 1.0 / (png_ptr->gamma);\r
+ gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);\r
+ break;\r
+ case PNG_BACKGROUND_GAMMA_UNIQUE:\r
+ g = 1.0 / (png_ptr->background_gamma);\r
+ gs = 1.0 / (png_ptr->background_gamma *\r
+ png_ptr->screen_gamma);\r
+ break;\r
+ default:\r
+ g = 1.0; /* back_1 */\r
+ gs = 1.0; /* back */\r
+ }\r
+\r
+ if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD)\r
+ {\r
+ back.red = (png_byte)png_ptr->background.red;\r
+ back.green = (png_byte)png_ptr->background.green;\r
+ back.blue = (png_byte)png_ptr->background.blue;\r
+ }\r
+ else\r
+ {\r
+ back.red = (png_byte)(pow(\r
+ (double)png_ptr->background.red/255, gs) * 255.0 + .5);\r
+ back.green = (png_byte)(pow(\r
+ (double)png_ptr->background.green/255, gs) * 255.0 + .5);\r
+ back.blue = (png_byte)(pow(\r
+ (double)png_ptr->background.blue/255, gs) * 255.0 + .5);\r
+ }\r
+\r
+ back_1.red = (png_byte)(pow(\r
+ (double)png_ptr->background.red/255, g) * 255.0 + .5);\r
+ back_1.green = (png_byte)(pow(\r
+ (double)png_ptr->background.green/255, g) * 255.0 + .5);\r
+ back_1.blue = (png_byte)(pow(\r
+ (double)png_ptr->background.blue/255, g) * 255.0 + .5);\r
+ }\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff)\r
+ {\r
+ if (png_ptr->trans[i] == 0)\r
+ {\r
+ palette[i] = back;\r
+ }\r
+ else /* if (png_ptr->trans[i] != 0xff) */\r
+ {\r
+ png_byte v, w;\r
+\r
+ v = png_ptr->gamma_to_1[palette[i].red];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.red);\r
+ palette[i].red = png_ptr->gamma_from_1[w];\r
+\r
+ v = png_ptr->gamma_to_1[palette[i].green];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.green);\r
+ palette[i].green = png_ptr->gamma_from_1[w];\r
+\r
+ v = png_ptr->gamma_to_1[palette[i].blue];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.blue);\r
+ palette[i].blue = png_ptr->gamma_from_1[w];\r
+ }\r
+ }\r
+ else\r
+ {\r
+ palette[i].red = png_ptr->gamma_table[palette[i].red];\r
+ palette[i].green = png_ptr->gamma_table[palette[i].green];\r
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];\r
+ }\r
+ }\r
+ /* Prevent the transformations being done again, and make sure\r
+ * that the now spurious alpha channel is stripped - the code\r
+ * has just reduced background composition and gamma correction\r
+ * to a simple alpha channel strip.\r
+ */\r
+ png_ptr->transformations &= ~PNG_BACKGROUND;\r
+ png_ptr->transformations &= ~PNG_GAMMA;\r
+ png_ptr->transformations |= PNG_STRIP_ALPHA;\r
+ }\r
+ /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */\r
+ else\r
+ /* color_type != PNG_COLOR_TYPE_PALETTE */\r
+ {\r
+ double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1);\r
+ double g = 1.0;\r
+ double gs = 1.0;\r
+\r
+ switch (png_ptr->background_gamma_type)\r
+ {\r
+ case PNG_BACKGROUND_GAMMA_SCREEN:\r
+ g = (png_ptr->screen_gamma);\r
+ gs = 1.0;\r
+ break;\r
+ case PNG_BACKGROUND_GAMMA_FILE:\r
+ g = 1.0 / (png_ptr->gamma);\r
+ gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);\r
+ break;\r
+ case PNG_BACKGROUND_GAMMA_UNIQUE:\r
+ g = 1.0 / (png_ptr->background_gamma);\r
+ gs = 1.0 / (png_ptr->background_gamma *\r
+ png_ptr->screen_gamma);\r
+ break;\r
+ }\r
+\r
+ png_ptr->background_1.gray = (png_uint_16)(pow(\r
+ (double)png_ptr->background.gray / m, g) * m + .5);\r
+ png_ptr->background.gray = (png_uint_16)(pow(\r
+ (double)png_ptr->background.gray / m, gs) * m + .5);\r
+\r
+ if ((png_ptr->background.red != png_ptr->background.green) ||\r
+ (png_ptr->background.red != png_ptr->background.blue) ||\r
+ (png_ptr->background.red != png_ptr->background.gray))\r
+ {\r
+ /* RGB or RGBA with color background */\r
+ png_ptr->background_1.red = (png_uint_16)(pow(\r
+ (double)png_ptr->background.red / m, g) * m + .5);\r
+ png_ptr->background_1.green = (png_uint_16)(pow(\r
+ (double)png_ptr->background.green / m, g) * m + .5);\r
+ png_ptr->background_1.blue = (png_uint_16)(pow(\r
+ (double)png_ptr->background.blue / m, g) * m + .5);\r
+ png_ptr->background.red = (png_uint_16)(pow(\r
+ (double)png_ptr->background.red / m, gs) * m + .5);\r
+ png_ptr->background.green = (png_uint_16)(pow(\r
+ (double)png_ptr->background.green / m, gs) * m + .5);\r
+ png_ptr->background.blue = (png_uint_16)(pow(\r
+ (double)png_ptr->background.blue / m, gs) * m + .5);\r
+ }\r
+ else\r
+ {\r
+ /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */\r
+ png_ptr->background_1.red = png_ptr->background_1.green\r
+ = png_ptr->background_1.blue = png_ptr->background_1.gray;\r
+ png_ptr->background.red = png_ptr->background.green\r
+ = png_ptr->background.blue = png_ptr->background.gray;\r
+ }\r
+ }\r
+ }\r
+ else\r
+ /* transformation does not include PNG_BACKGROUND */\r
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */\r
+ if (color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_colorp palette = png_ptr->palette;\r
+ int num_palette = png_ptr->num_palette;\r
+ int i;\r
+\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ palette[i].red = png_ptr->gamma_table[palette[i].red];\r
+ palette[i].green = png_ptr->gamma_table[palette[i].green];\r
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];\r
+ }\r
+\r
+ /* Done the gamma correction. */\r
+ png_ptr->transformations &= ~PNG_GAMMA;\r
+ }\r
+ }\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ else\r
+#endif\r
+#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ /* No GAMMA transformation */\r
+ if ((png_ptr->transformations & PNG_BACKGROUND) &&\r
+ (color_type == PNG_COLOR_TYPE_PALETTE))\r
+ {\r
+ int i;\r
+ int istop = (int)png_ptr->num_trans;\r
+ png_color back;\r
+ png_colorp palette = png_ptr->palette;\r
+\r
+ back.red = (png_byte)png_ptr->background.red;\r
+ back.green = (png_byte)png_ptr->background.green;\r
+ back.blue = (png_byte)png_ptr->background.blue;\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ if (png_ptr->trans[i] == 0)\r
+ {\r
+ palette[i] = back;\r
+ }\r
+ else if (png_ptr->trans[i] != 0xff)\r
+ {\r
+ /* The png_composite() macro is defined in png.h */\r
+ png_composite(palette[i].red, palette[i].red,\r
+ png_ptr->trans[i], back.red);\r
+ png_composite(palette[i].green, palette[i].green,\r
+ png_ptr->trans[i], back.green);\r
+ png_composite(palette[i].blue, palette[i].blue,\r
+ png_ptr->trans[i], back.blue);\r
+ }\r
+ }\r
+\r
+ /* Handled alpha, still need to strip the channel. */\r
+ png_ptr->transformations &= ~PNG_BACKGROUND;\r
+ png_ptr->transformations |= PNG_STRIP_ALPHA;\r
+ }\r
+#endif /* PNG_READ_BACKGROUND_SUPPORTED */\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_SHIFT) &&\r
+ (color_type == PNG_COLOR_TYPE_PALETTE))\r
+ {\r
+ png_uint_16 i;\r
+ png_uint_16 istop = png_ptr->num_palette;\r
+ int sr = 8 - png_ptr->sig_bit.red;\r
+ int sg = 8 - png_ptr->sig_bit.green;\r
+ int sb = 8 - png_ptr->sig_bit.blue;\r
+\r
+ if (sr < 0 || sr > 8)\r
+ sr = 0;\r
+ if (sg < 0 || sg > 8)\r
+ sg = 0;\r
+ if (sb < 0 || sb > 8)\r
+ sb = 0;\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ png_ptr->palette[i].red >>= sr;\r
+ png_ptr->palette[i].green >>= sg;\r
+ png_ptr->palette[i].blue >>= sb;\r
+ }\r
+ }\r
+#endif /* PNG_READ_SHIFT_SUPPORTED */\r
+ }\r
+#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \\r
+ && !defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr)\r
+ return;\r
+#endif\r
+}\r
+\r
+/* Modify the info structure to reflect the transformations. The\r
+ * info should be updated so a PNG file could be written with it,\r
+ * assuming the transformations result in valid PNG data.\r
+ */\r
+void /* PRIVATE */\r
+png_read_transform_info(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_read_transform_info\n");\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_EXPAND)\r
+ {\r
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (png_ptr->num_trans &&\r
+ (png_ptr->transformations & PNG_EXPAND_tRNS))\r
+ info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;\r
+ else\r
+ info_ptr->color_type = PNG_COLOR_TYPE_RGB;\r
+ info_ptr->bit_depth = 8;\r
+ info_ptr->num_trans = 0;\r
+ }\r
+ else\r
+ {\r
+ if (png_ptr->num_trans)\r
+ {\r
+ if (png_ptr->transformations & PNG_EXPAND_tRNS)\r
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;\r
+#if 0 /* Removed from libpng-1.2.27 */\r
+ else\r
+ info_ptr->color_type |= PNG_COLOR_MASK_COLOR;\r
+#endif\r
+ }\r
+ if (info_ptr->bit_depth < 8)\r
+ info_ptr->bit_depth = 8;\r
+ info_ptr->num_trans = 0;\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BACKGROUND)\r
+ {\r
+ info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;\r
+ info_ptr->num_trans = 0;\r
+ info_ptr->background = png_ptr->background;\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_GAMMA)\r
+ {\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ info_ptr->gamma = png_ptr->gamma;\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ info_ptr->int_gamma = png_ptr->int_gamma;\r
+#endif\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16))\r
+ info_ptr->bit_depth = 8;\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_GRAY_TO_RGB)\r
+ info_ptr->color_type |= PNG_COLOR_MASK_COLOR;\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_RGB_TO_GRAY)\r
+ info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR;\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_DITHER)\r
+ {\r
+ if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||\r
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&\r
+ png_ptr->palette_lookup && info_ptr->bit_depth == 8)\r
+ {\r
+ info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8))\r
+ info_ptr->bit_depth = 8;\r
+#endif\r
+\r
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ info_ptr->channels = 1;\r
+ else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+ info_ptr->channels = 3;\r
+ else\r
+ info_ptr->channels = 1;\r
+\r
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+ if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)\r
+ info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA;\r
+#endif\r
+\r
+ if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)\r
+ info_ptr->channels++;\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+ /* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */\r
+ if ((png_ptr->transformations & PNG_FILLER) &&\r
+ ((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||\r
+ (info_ptr->color_type == PNG_COLOR_TYPE_GRAY)))\r
+ {\r
+ info_ptr->channels++;\r
+ /* if adding a true alpha channel not just filler */\r
+#if !defined(PNG_1_0_X)\r
+ if (png_ptr->transformations & PNG_ADD_ALPHA)\r
+ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;\r
+#endif\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \\r
+defined(PNG_READ_USER_TRANSFORM_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)\r
+ {\r
+ if (info_ptr->bit_depth < png_ptr->user_transform_depth)\r
+ info_ptr->bit_depth = png_ptr->user_transform_depth;\r
+ if (info_ptr->channels < png_ptr->user_transform_channels)\r
+ info_ptr->channels = png_ptr->user_transform_channels;\r
+ }\r
+#endif\r
+\r
+ info_ptr->pixel_depth = (png_byte)(info_ptr->channels *\r
+ info_ptr->bit_depth);\r
+\r
+ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);\r
+\r
+#if !defined(PNG_READ_EXPAND_SUPPORTED)\r
+ if (png_ptr)\r
+ return;\r
+#endif\r
+}\r
+\r
+/* Transform the row. The order of transformations is significant,\r
+ * and is very touchy. If you add a transformation, take care to\r
+ * decide how it fits in with the other transformations here.\r
+ */\r
+void /* PRIVATE */\r
+png_do_read_transformations(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_do_read_transformations\n");\r
+ if (png_ptr->row_buf == NULL)\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char msg[50];\r
+\r
+ png_snprintf2(msg, 50,\r
+ "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number,\r
+ png_ptr->pass);\r
+ png_error(png_ptr, msg);\r
+#else\r
+ png_error(png_ptr, "NULL row buffer");\r
+#endif\r
+ }\r
+#ifdef PNG_WARN_UNINITIALIZED_ROW\r
+ if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))\r
+ /* Application has failed to call either png_read_start_image()\r
+ * or png_read_update_info() after setting transforms that expand\r
+ * pixels. This check added to libpng-1.2.19 */\r
+#if (PNG_WARN_UNINITIALIZED_ROW==1)\r
+ png_error(png_ptr, "Uninitialized row");\r
+#else\r
+ png_warning(png_ptr, "Uninitialized row");\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_EXPAND)\r
+ {\r
+ if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ png_ptr->palette, png_ptr->trans, png_ptr->num_trans);\r
+ }\r
+ else\r
+ {\r
+ if (png_ptr->num_trans &&\r
+ (png_ptr->transformations & PNG_EXPAND_tRNS))\r
+ png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ &(png_ptr->trans_values));\r
+ else\r
+ png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ NULL);\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+ if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)\r
+ png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA));\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_RGB_TO_GRAY)\r
+ {\r
+ int rgb_error =\r
+ png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1);\r
+ if (rgb_error)\r
+ {\r
+ png_ptr->rgb_to_gray_status=1;\r
+ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == \r
+ PNG_RGB_TO_GRAY_WARN)\r
+ png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");\r
+ if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==\r
+ PNG_RGB_TO_GRAY_ERR)\r
+ png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");\r
+ }\r
+ }\r
+#endif\r
+\r
+/*\r
+From Andreas Dilger e-mail to png-implement, 26 March 1998:\r
+\r
+ In most cases, the "simple transparency" should be done prior to doing\r
+ gray-to-RGB, or you will have to test 3x as many bytes to check if a\r
+ pixel is transparent. You would also need to make sure that the\r
+ transparency information is upgraded to RGB.\r
+\r
+ To summarize, the current flow is:\r
+ - Gray + simple transparency -> compare 1 or 2 gray bytes and composite\r
+ with background "in place" if transparent,\r
+ convert to RGB if necessary\r
+ - Gray + alpha -> composite with gray background and remove alpha bytes,\r
+ convert to RGB if necessary\r
+\r
+ To support RGB backgrounds for gray images we need:\r
+ - Gray + simple transparency -> convert to RGB + simple transparency, compare\r
+ 3 or 6 bytes and composite with background\r
+ "in place" if transparent (3x compare/pixel\r
+ compared to doing composite with gray bkgrnd)\r
+ - Gray + alpha -> convert to RGB + alpha, composite with background and\r
+ remove alpha bytes (3x float operations/pixel\r
+ compared with composite on gray background)\r
+\r
+ Greg's change will do this. The reason it wasn't done before is for\r
+ performance, as this increases the per-pixel operations. If we would check\r
+ in advance if the background was gray or RGB, and position the gray-to-RGB\r
+ transform appropriately, then it would save a lot of work/time.\r
+ */\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+ /* if gray -> RGB, do so now only if background is non-gray; else do later\r
+ * for performance reasons */\r
+ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&\r
+ !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY))\r
+ png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_BACKGROUND) &&\r
+ ((png_ptr->num_trans != 0 ) ||\r
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA)))\r
+ png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ &(png_ptr->trans_values), &(png_ptr->background)\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ , &(png_ptr->background_1),\r
+ png_ptr->gamma_table, png_ptr->gamma_from_1,\r
+ png_ptr->gamma_to_1, png_ptr->gamma_16_table,\r
+ png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1,\r
+ png_ptr->gamma_shift\r
+#endif\r
+);\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_GAMMA) &&\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ !((png_ptr->transformations & PNG_BACKGROUND) &&\r
+ ((png_ptr->num_trans != 0) ||\r
+ (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) &&\r
+#endif\r
+ (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))\r
+ png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ png_ptr->gamma_table, png_ptr->gamma_16_table,\r
+ png_ptr->gamma_shift);\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_16_TO_8)\r
+ png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_DITHER)\r
+ {\r
+ png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ png_ptr->palette_lookup, png_ptr->dither_index);\r
+ if (png_ptr->row_info.rowbytes == (png_uint_32)0)\r
+ png_error(png_ptr, "png_do_dither returned rowbytes=0");\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_MONO)\r
+ png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SHIFT)\r
+ png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ &(png_ptr->shift));\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACK)\r
+ png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BGR)\r
+ png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+ /* if gray -> RGB, do so now only if we did not do so above */\r
+ if ((png_ptr->transformations & PNG_GRAY_TO_RGB) &&\r
+ (png_ptr->mode & PNG_BACKGROUND_IS_GRAY))\r
+ png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_FILLER)\r
+ png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ (png_uint_32)png_ptr->filler, png_ptr->flags);\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)\r
+ png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_ALPHA)\r
+ png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_BYTES)\r
+ png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)\r
+ {\r
+ if (png_ptr->read_user_transform_fn != NULL)\r
+ (*(png_ptr->read_user_transform_fn)) /* user read transform function */\r
+ (png_ptr, /* png_ptr */\r
+ &(png_ptr->row_info), /* row_info: */\r
+ /* png_uint_32 width; width of row */\r
+ /* png_uint_32 rowbytes; number of bytes in row */\r
+ /* png_byte color_type; color type of pixels */\r
+ /* png_byte bit_depth; bit depth of samples */\r
+ /* png_byte channels; number of channels (1-4) */\r
+ /* png_byte pixel_depth; bits per pixel (depth*channels) */\r
+ png_ptr->row_buf + 1); /* start of pixel data for row */\r
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)\r
+ if (png_ptr->user_transform_depth)\r
+ png_ptr->row_info.bit_depth = png_ptr->user_transform_depth;\r
+ if (png_ptr->user_transform_channels)\r
+ png_ptr->row_info.channels = png_ptr->user_transform_channels;\r
+#endif\r
+ png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *\r
+ png_ptr->row_info.channels);\r
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,\r
+ png_ptr->row_info.width);\r
+ }\r
+#endif\r
+\r
+}\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED)\r
+/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel,\r
+ * without changing the actual values. Thus, if you had a row with\r
+ * a bit depth of 1, you would end up with bytes that only contained\r
+ * the numbers 0 or 1. If you would rather they contain 0 and 255, use\r
+ * png_do_shift() after this.\r
+ */\r
+void /* PRIVATE */\r
+png_do_unpack(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_unpack\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL && row_info->bit_depth < 8)\r
+#else\r
+ if (row_info->bit_depth < 8)\r
+#endif\r
+ {\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 3);\r
+ png_bytep dp = row + (png_size_t)row_width - 1;\r
+ png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *dp = (png_byte)((*sp >> shift) & 0x01);\r
+ if (shift == 7)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift++;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+\r
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 2);\r
+ png_bytep dp = row + (png_size_t)row_width - 1;\r
+ png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *dp = (png_byte)((*sp >> shift) & 0x03);\r
+ if (shift == 6)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift += 2;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep sp = row + (png_size_t)((row_width - 1) >> 1);\r
+ png_bytep dp = row + (png_size_t)row_width - 1;\r
+ png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *dp = (png_byte)((*sp >> shift) & 0x0f);\r
+ if (shift == 4)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift = 4;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = (png_byte)(8 * row_info->channels);\r
+ row_info->rowbytes = row_width * row_info->channels;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED)\r
+/* Reverse the effects of png_do_shift. This routine merely shifts the\r
+ * pixels back to their significant bits values. Thus, if you have\r
+ * a row of bit depth 8, but only 5 are significant, this will shift\r
+ * the values back to 0 through 31.\r
+ */\r
+void /* PRIVATE */\r
+png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits)\r
+{\r
+ png_debug(1, "in png_do_unshift\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL && sig_bits != NULL &&\r
+#endif\r
+ row_info->color_type != PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ int shift[4];\r
+ int channels = 0;\r
+ int c;\r
+ png_uint_16 value = 0;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ if (row_info->color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ shift[channels++] = row_info->bit_depth - sig_bits->red;\r
+ shift[channels++] = row_info->bit_depth - sig_bits->green;\r
+ shift[channels++] = row_info->bit_depth - sig_bits->blue;\r
+ }\r
+ else\r
+ {\r
+ shift[channels++] = row_info->bit_depth - sig_bits->gray;\r
+ }\r
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)\r
+ {\r
+ shift[channels++] = row_info->bit_depth - sig_bits->alpha;\r
+ }\r
+\r
+ for (c = 0; c < channels; c++)\r
+ {\r
+ if (shift[c] <= 0)\r
+ shift[c] = 0;\r
+ else\r
+ value = 1;\r
+ }\r
+\r
+ if (!value)\r
+ return;\r
+\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 2:\r
+ {\r
+ png_bytep bp;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+\r
+ for (bp = row, i = 0; i < istop; i++)\r
+ {\r
+ *bp >>= 1;\r
+ *bp++ &= 0x55;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep bp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+ png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) |\r
+ (png_byte)((int)0xf >> shift[0]));\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ *bp >>= shift[0];\r
+ *bp++ &= mask;\r
+ }\r
+ break;\r
+ }\r
+ case 8:\r
+ {\r
+ png_bytep bp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_width * channels;\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ *bp++ >>= shift[i%channels];\r
+ }\r
+ break;\r
+ }\r
+ case 16:\r
+ {\r
+ png_bytep bp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = channels * row_width;\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ value = (png_uint_16)((*bp << 8) + *(bp + 1));\r
+ value >>= shift[i%channels];\r
+ *bp++ = (png_byte)(value >> 8);\r
+ *bp++ = (png_byte)(value & 0xff);\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_16_TO_8_SUPPORTED)\r
+/* chop rows of bit depth 16 down to 8 */\r
+void /* PRIVATE */\r
+png_do_chop(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_chop\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL && row_info->bit_depth == 16)\r
+#else\r
+ if (row_info->bit_depth == 16)\r
+#endif\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->width * row_info->channels;\r
+\r
+ for (i = 0; i<istop; i++, sp += 2, dp++)\r
+ {\r
+#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED)\r
+ /* This does a more accurate scaling of the 16-bit color\r
+ * value, rather than a simple low-byte truncation.\r
+ *\r
+ * What the ideal calculation should be:\r
+ * *dp = (((((png_uint_32)(*sp) << 8) |\r
+ * (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L;\r
+ *\r
+ * GRR: no, I think this is what it really should be:\r
+ * *dp = (((((png_uint_32)(*sp) << 8) |\r
+ * (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L;\r
+ *\r
+ * GRR: here's the exact calculation with shifts:\r
+ * temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L;\r
+ * *dp = (temp - (temp >> 8)) >> 8;\r
+ *\r
+ * Approximate calculation with shift/add instead of multiply/divide:\r
+ * *dp = ((((png_uint_32)(*sp) << 8) |\r
+ * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8;\r
+ *\r
+ * What we actually do to avoid extra shifting and conversion:\r
+ */\r
+\r
+ *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0);\r
+#else\r
+ /* Simply discard the low order byte */\r
+ *dp = *sp;\r
+#endif\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = (png_byte)(8 * row_info->channels);\r
+ row_info->rowbytes = row_info->width * row_info->channels;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)\r
+void /* PRIVATE */\r
+png_do_read_swap_alpha(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_read_swap_alpha\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ png_uint_32 row_width = row_info->width;\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ /* This converts from RGBA to ARGB */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_byte save;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ save = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = save;\r
+ }\r
+ }\r
+ /* This converts from RRGGBBAA to AARRGGBB */\r
+ else\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_byte save[2];\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ save[0] = *(--sp);\r
+ save[1] = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = save[0];\r
+ *(--dp) = save[1];\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ /* This converts from GA to AG */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_byte save;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ save = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = save;\r
+ }\r
+ }\r
+ /* This converts from GGAA to AAGG */\r
+ else\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_byte save[2];\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ save[0] = *(--sp);\r
+ save[1] = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = save[0];\r
+ *(--dp) = save[1];\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)\r
+void /* PRIVATE */\r
+png_do_read_invert_alpha(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_read_invert_alpha\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ png_uint_32 row_width = row_info->width;\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ /* This inverts the alpha channel in RGBA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+\r
+/* This does nothing:\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ We can replace it with:\r
+*/\r
+ sp-=3;\r
+ dp=sp;\r
+ }\r
+ }\r
+ /* This inverts the alpha channel in RRGGBBAA */\r
+ else\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+\r
+/* This does nothing:\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ We can replace it with:\r
+*/\r
+ sp-=6;\r
+ dp=sp;\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ /* This inverts the alpha channel in GA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+ *(--dp) = *(--sp);\r
+ }\r
+ }\r
+ /* This inverts the alpha channel in GGAA */\r
+ else\r
+ {\r
+ png_bytep sp = row + row_info->rowbytes;\r
+ png_bytep dp = sp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+ *(--dp) = (png_byte)(255 - *(--sp));\r
+/*\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+*/\r
+ sp-=2;\r
+ dp=sp;\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+/* Add filler channel if we have RGB color */\r
+void /* PRIVATE */\r
+png_do_read_filler(png_row_infop row_info, png_bytep row,\r
+ png_uint_32 filler, png_uint_32 flags)\r
+{\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ png_byte hi_filler = (png_byte)((filler>>8) & 0xff);\r
+ png_byte lo_filler = (png_byte)(filler & 0xff);\r
+\r
+ png_debug(1, "in png_do_read_filler\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ row_info->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ /* This changes the data from G to GX */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width;\r
+ png_bytep dp = sp + (png_size_t)row_width;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *(--dp) = lo_filler;\r
+ *(--dp) = *(--sp);\r
+ }\r
+ *(--dp) = lo_filler;\r
+ row_info->channels = 2;\r
+ row_info->pixel_depth = 16;\r
+ row_info->rowbytes = row_width * 2;\r
+ }\r
+ /* This changes the data from G to XG */\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width;\r
+ png_bytep dp = sp + (png_size_t)row_width;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = lo_filler;\r
+ }\r
+ row_info->channels = 2;\r
+ row_info->pixel_depth = 16;\r
+ row_info->rowbytes = row_width * 2;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ /* This changes the data from GG to GGXX */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 2;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ }\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ row_info->channels = 2;\r
+ row_info->pixel_depth = 32;\r
+ row_info->rowbytes = row_width * 4;\r
+ }\r
+ /* This changes the data from GG to XXGG */\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 2;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ }\r
+ row_info->channels = 2;\r
+ row_info->pixel_depth = 32;\r
+ row_info->rowbytes = row_width * 4;\r
+ }\r
+ }\r
+ } /* COLOR_TYPE == GRAY */\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ /* This changes the data from RGB to RGBX */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 3;\r
+ png_bytep dp = sp + (png_size_t)row_width;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *(--dp) = lo_filler;\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ }\r
+ *(--dp) = lo_filler;\r
+ row_info->channels = 4;\r
+ row_info->pixel_depth = 32;\r
+ row_info->rowbytes = row_width * 4;\r
+ }\r
+ /* This changes the data from RGB to XRGB */\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 3;\r
+ png_bytep dp = sp + (png_size_t)row_width;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = lo_filler;\r
+ }\r
+ row_info->channels = 4;\r
+ row_info->pixel_depth = 32;\r
+ row_info->rowbytes = row_width * 4;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ /* This changes the data from RRGGBB to RRGGBBXX */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 6;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ }\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ row_info->channels = 4;\r
+ row_info->pixel_depth = 64;\r
+ row_info->rowbytes = row_width * 8;\r
+ }\r
+ /* This changes the data from RRGGBB to XXRRGGBB */\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 6;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = *(--sp);\r
+ *(--dp) = hi_filler;\r
+ *(--dp) = lo_filler;\r
+ }\r
+ row_info->channels = 4;\r
+ row_info->pixel_depth = 64;\r
+ row_info->rowbytes = row_width * 8;\r
+ }\r
+ }\r
+ } /* COLOR_TYPE == RGB */\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+/* expand grayscale files to RGB, with or without alpha */\r
+void /* PRIVATE */\r
+png_do_gray_to_rgb(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ png_debug(1, "in png_do_gray_to_rgb\n");\r
+ if (row_info->bit_depth >= 8 &&\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ !(row_info->color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width - 1;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(dp--) = *sp;\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp--);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 2 - 1;\r
+ png_bytep dp = sp + (png_size_t)row_width * 4;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp - 1);\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp - 1);\r
+ *(dp--) = *(sp--);\r
+ *(dp--) = *(sp--);\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 2 - 1;\r
+ png_bytep dp = sp + (png_size_t)row_width * 2;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(dp--) = *(sp--);\r
+ *(dp--) = *sp;\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp--);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ png_bytep sp = row + (png_size_t)row_width * 4 - 1;\r
+ png_bytep dp = sp + (png_size_t)row_width * 4;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *(dp--) = *(sp--);\r
+ *(dp--) = *(sp--);\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp - 1);\r
+ *(dp--) = *sp;\r
+ *(dp--) = *(sp - 1);\r
+ *(dp--) = *(sp--);\r
+ *(dp--) = *(sp--);\r
+ }\r
+ }\r
+ }\r
+ row_info->channels += (png_byte)2;\r
+ row_info->color_type |= PNG_COLOR_MASK_COLOR;\r
+ row_info->pixel_depth = (png_byte)(row_info->channels *\r
+ row_info->bit_depth);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+/* reduce RGB files to grayscale, with or without alpha\r
+ * using the equation given in Poynton's ColorFAQ at\r
+ * <http://www.inforamp.net/~poynton/> (THIS LINK IS DEAD June 2008)\r
+ * New link:\r
+ * <http://www.poynton.com/notes/colour_and_gamma/>\r
+ * Charles Poynton poynton at poynton.com\r
+ *\r
+ * Y = 0.212671 * R + 0.715160 * G + 0.072169 * B\r
+ *\r
+ * We approximate this with\r
+ *\r
+ * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B\r
+ *\r
+ * which can be expressed with integers as\r
+ *\r
+ * Y = (6969 * R + 23434 * G + 2365 * B)/32768\r
+ *\r
+ * The calculation is to be done in a linear colorspace.\r
+ *\r
+ * Other integer coefficents can be used via png_set_rgb_to_gray().\r
+ */\r
+int /* PRIVATE */\r
+png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row)\r
+\r
+{\r
+ png_uint_32 i;\r
+\r
+ png_uint_32 row_width = row_info->width;\r
+ int rgb_error = 0;\r
+\r
+ png_debug(1, "in png_do_rgb_to_gray\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff;\r
+ png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff;\r
+ png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff;\r
+\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte red = png_ptr->gamma_to_1[*(sp++)];\r
+ png_byte green = png_ptr->gamma_to_1[*(sp++)];\r
+ png_byte blue = png_ptr->gamma_to_1[*(sp++)];\r
+ if (red != green || red != blue)\r
+ {\r
+ rgb_error |= 1;\r
+ *(dp++) = png_ptr->gamma_from_1[\r
+ (rc*red + gc*green + bc*blue)>>15];\r
+ }\r
+ else\r
+ *(dp++) = *(sp - 1);\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte red = *(sp++);\r
+ png_byte green = *(sp++);\r
+ png_byte blue = *(sp++);\r
+ if (red != green || red != blue)\r
+ {\r
+ rgb_error |= 1;\r
+ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);\r
+ }\r
+ else\r
+ *(dp++) = *(sp - 1);\r
+ }\r
+ }\r
+ }\r
+\r
+ else /* RGB bit_depth == 16 */\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->gamma_16_to_1 != NULL &&\r
+ png_ptr->gamma_16_from_1 != NULL)\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 red, green, blue, w;\r
+\r
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+\r
+ if (red == green && red == blue)\r
+ w = red;\r
+ else\r
+ {\r
+ png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>\r
+ png_ptr->gamma_shift][red>>8];\r
+ png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>\r
+ png_ptr->gamma_shift][green>>8];\r
+ png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>\r
+ png_ptr->gamma_shift][blue>>8];\r
+ png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1\r
+ + bc*blue_1)>>15);\r
+ w = png_ptr->gamma_16_from_1[(gray16&0xff) >>\r
+ png_ptr->gamma_shift][gray16 >> 8];\r
+ rgb_error |= 1;\r
+ }\r
+\r
+ *(dp++) = (png_byte)((w>>8) & 0xff);\r
+ *(dp++) = (png_byte)(w & 0xff);\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 red, green, blue, gray16;\r
+\r
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+\r
+ if (red != green || red != blue)\r
+ rgb_error |= 1;\r
+ gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);\r
+ *(dp++) = (png_byte)((gray16>>8) & 0xff);\r
+ *(dp++) = (png_byte)(gray16 & 0xff);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL)\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte red = png_ptr->gamma_to_1[*(sp++)];\r
+ png_byte green = png_ptr->gamma_to_1[*(sp++)];\r
+ png_byte blue = png_ptr->gamma_to_1[*(sp++)];\r
+ if (red != green || red != blue)\r
+ rgb_error |= 1;\r
+ *(dp++) = png_ptr->gamma_from_1\r
+ [(rc*red + gc*green + bc*blue)>>15];\r
+ *(dp++) = *(sp++); /* alpha */\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte red = *(sp++);\r
+ png_byte green = *(sp++);\r
+ png_byte blue = *(sp++);\r
+ if (red != green || red != blue)\r
+ rgb_error |= 1;\r
+ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15);\r
+ *(dp++) = *(sp++); /* alpha */\r
+ }\r
+ }\r
+ }\r
+ else /* RGBA bit_depth == 16 */\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->gamma_16_to_1 != NULL &&\r
+ png_ptr->gamma_16_from_1 != NULL)\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 red, green, blue, w;\r
+\r
+ red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+ blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2;\r
+\r
+ if (red == green && red == blue)\r
+ w = red;\r
+ else\r
+ {\r
+ png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >>\r
+ png_ptr->gamma_shift][red>>8];\r
+ png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >>\r
+ png_ptr->gamma_shift][green>>8];\r
+ png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >>\r
+ png_ptr->gamma_shift][blue>>8];\r
+ png_uint_16 gray16 = (png_uint_16)((rc * red_1\r
+ + gc * green_1 + bc * blue_1)>>15);\r
+ w = png_ptr->gamma_16_from_1[(gray16&0xff) >>\r
+ png_ptr->gamma_shift][gray16 >> 8];\r
+ rgb_error |= 1;\r
+ }\r
+\r
+ *(dp++) = (png_byte)((w>>8) & 0xff);\r
+ *(dp++) = (png_byte)(w & 0xff);\r
+ *(dp++) = *(sp++); /* alpha */\r
+ *(dp++) = *(sp++);\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_bytep sp = row;\r
+ png_bytep dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 red, green, blue, gray16;\r
+ red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;\r
+ green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;\r
+ blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2;\r
+ if (red != green || red != blue)\r
+ rgb_error |= 1;\r
+ gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15);\r
+ *(dp++) = (png_byte)((gray16>>8) & 0xff);\r
+ *(dp++) = (png_byte)(gray16 & 0xff);\r
+ *(dp++) = *(sp++); /* alpha */\r
+ *(dp++) = *(sp++);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ row_info->channels -= (png_byte)2;\r
+ row_info->color_type &= ~PNG_COLOR_MASK_COLOR;\r
+ row_info->pixel_depth = (png_byte)(row_info->channels *\r
+ row_info->bit_depth);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+ return rgb_error;\r
+}\r
+#endif\r
+\r
+/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth\r
+ * large of png_color. This lets grayscale images be treated as\r
+ * paletted. Most useful for gamma correction and simplification\r
+ * of code.\r
+ */\r
+void PNGAPI\r
+png_build_grayscale_palette(int bit_depth, png_colorp palette)\r
+{\r
+ int num_palette;\r
+ int color_inc;\r
+ int i;\r
+ int v;\r
+\r
+ png_debug(1, "in png_do_build_grayscale_palette\n");\r
+ if (palette == NULL)\r
+ return;\r
+\r
+ switch (bit_depth)\r
+ {\r
+ case 1:\r
+ num_palette = 2;\r
+ color_inc = 0xff;\r
+ break;\r
+ case 2:\r
+ num_palette = 4;\r
+ color_inc = 0x55;\r
+ break;\r
+ case 4:\r
+ num_palette = 16;\r
+ color_inc = 0x11;\r
+ break;\r
+ case 8:\r
+ num_palette = 256;\r
+ color_inc = 1;\r
+ break;\r
+ default:\r
+ num_palette = 0;\r
+ color_inc = 0;\r
+ break;\r
+ }\r
+\r
+ for (i = 0, v = 0; i < num_palette; i++, v += color_inc)\r
+ {\r
+ palette[i].red = (png_byte)v;\r
+ palette[i].green = (png_byte)v;\r
+ palette[i].blue = (png_byte)v;\r
+ }\r
+}\r
+\r
+/* This function is currently unused. Do we really need it? */\r
+#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED)\r
+void /* PRIVATE */\r
+png_correct_palette(png_structp png_ptr, png_colorp palette,\r
+ int num_palette)\r
+{\r
+ png_debug(1, "in png_correct_palette\n");\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \\r
+ defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND))\r
+ {\r
+ png_color back, back_1;\r
+\r
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)\r
+ {\r
+ back.red = png_ptr->gamma_table[png_ptr->background.red];\r
+ back.green = png_ptr->gamma_table[png_ptr->background.green];\r
+ back.blue = png_ptr->gamma_table[png_ptr->background.blue];\r
+\r
+ back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];\r
+ back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];\r
+ back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];\r
+ }\r
+ else\r
+ {\r
+ double g;\r
+\r
+ g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma);\r
+\r
+ if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN ||\r
+ fabs(g - 1.0) < PNG_GAMMA_THRESHOLD)\r
+ {\r
+ back.red = png_ptr->background.red;\r
+ back.green = png_ptr->background.green;\r
+ back.blue = png_ptr->background.blue;\r
+ }\r
+ else\r
+ {\r
+ back.red =\r
+ (png_byte)(pow((double)png_ptr->background.red/255, g) *\r
+ 255.0 + 0.5);\r
+ back.green =\r
+ (png_byte)(pow((double)png_ptr->background.green/255, g) *\r
+ 255.0 + 0.5);\r
+ back.blue =\r
+ (png_byte)(pow((double)png_ptr->background.blue/255, g) *\r
+ 255.0 + 0.5);\r
+ }\r
+\r
+ g = 1.0 / png_ptr->background_gamma;\r
+\r
+ back_1.red =\r
+ (png_byte)(pow((double)png_ptr->background.red/255, g) *\r
+ 255.0 + 0.5);\r
+ back_1.green =\r
+ (png_byte)(pow((double)png_ptr->background.green/255, g) *\r
+ 255.0 + 0.5);\r
+ back_1.blue =\r
+ (png_byte)(pow((double)png_ptr->background.blue/255, g) *\r
+ 255.0 + 0.5);\r
+ }\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < (png_uint_32)num_palette; i++)\r
+ {\r
+ if (i < png_ptr->num_trans && png_ptr->trans[i] == 0)\r
+ {\r
+ palette[i] = back;\r
+ }\r
+ else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff)\r
+ {\r
+ png_byte v, w;\r
+\r
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].red];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.red);\r
+ palette[i].red = png_ptr->gamma_from_1[w];\r
+\r
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].green];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.green);\r
+ palette[i].green = png_ptr->gamma_from_1[w];\r
+\r
+ v = png_ptr->gamma_to_1[png_ptr->palette[i].blue];\r
+ png_composite(w, v, png_ptr->trans[i], back_1.blue);\r
+ palette[i].blue = png_ptr->gamma_from_1[w];\r
+ }\r
+ else\r
+ {\r
+ palette[i].red = png_ptr->gamma_table[palette[i].red];\r
+ palette[i].green = png_ptr->gamma_table[palette[i].green];\r
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ int i;\r
+\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ if (palette[i].red == (png_byte)png_ptr->trans_values.gray)\r
+ {\r
+ palette[i] = back;\r
+ }\r
+ else\r
+ {\r
+ palette[i].red = png_ptr->gamma_table[palette[i].red];\r
+ palette[i].green = png_ptr->gamma_table[palette[i].green];\r
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];\r
+ }\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_GAMMA)\r
+ {\r
+ int i;\r
+\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ palette[i].red = png_ptr->gamma_table[palette[i].red];\r
+ palette[i].green = png_ptr->gamma_table[palette[i].green];\r
+ palette[i].blue = png_ptr->gamma_table[palette[i].blue];\r
+ }\r
+ }\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ else\r
+#endif\r
+#endif\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BACKGROUND)\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_color back;\r
+\r
+ back.red = (png_byte)png_ptr->background.red;\r
+ back.green = (png_byte)png_ptr->background.green;\r
+ back.blue = (png_byte)png_ptr->background.blue;\r
+\r
+ for (i = 0; i < (int)png_ptr->num_trans; i++)\r
+ {\r
+ if (png_ptr->trans[i] == 0)\r
+ {\r
+ palette[i].red = back.red;\r
+ palette[i].green = back.green;\r
+ palette[i].blue = back.blue;\r
+ }\r
+ else if (png_ptr->trans[i] != 0xff)\r
+ {\r
+ png_composite(palette[i].red, png_ptr->palette[i].red,\r
+ png_ptr->trans[i], back.red);\r
+ png_composite(palette[i].green, png_ptr->palette[i].green,\r
+ png_ptr->trans[i], back.green);\r
+ png_composite(palette[i].blue, png_ptr->palette[i].blue,\r
+ png_ptr->trans[i], back.blue);\r
+ }\r
+ }\r
+ }\r
+ else /* assume grayscale palette (what else could it be?) */\r
+ {\r
+ int i;\r
+\r
+ for (i = 0; i < num_palette; i++)\r
+ {\r
+ if (i == (png_byte)png_ptr->trans_values.gray)\r
+ {\r
+ palette[i].red = (png_byte)png_ptr->background.red;\r
+ palette[i].green = (png_byte)png_ptr->background.green;\r
+ palette[i].blue = (png_byte)png_ptr->background.blue;\r
+ }\r
+ }\r
+ }\r
+ }\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED)\r
+/* Replace any alpha or transparency with the supplied background color.\r
+ * "background" is already in the screen gamma, while "background_1" is\r
+ * at a gamma of 1.0. Paletted files have already been taken care of.\r
+ */\r
+void /* PRIVATE */\r
+png_do_background(png_row_infop row_info, png_bytep row,\r
+ png_color_16p trans_values, png_color_16p background\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ , png_color_16p background_1,\r
+ png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1,\r
+ png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1,\r
+ png_uint_16pp gamma_16_to_1, int gamma_shift\r
+#endif\r
+ )\r
+{\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+ int shift;\r
+\r
+ png_debug(1, "in png_do_background\n");\r
+ if (background != NULL &&\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) ||\r
+ (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values)))\r
+ {\r
+ switch (row_info->color_type)\r
+ {\r
+ case PNG_COLOR_TYPE_GRAY:\r
+ {\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ sp = row;\r
+ shift = 7;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((png_uint_16)((*sp >> shift) & 0x01)\r
+ == trans_values->gray)\r
+ {\r
+ *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);\r
+ *sp |= (png_byte)(background->gray << shift);\r
+ }\r
+ if (!shift)\r
+ {\r
+ shift = 7;\r
+ sp++;\r
+ }\r
+ else\r
+ shift--;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ shift = 6;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((png_uint_16)((*sp >> shift) & 0x03)\r
+ == trans_values->gray)\r
+ {\r
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);\r
+ *sp |= (png_byte)(background->gray << shift);\r
+ }\r
+ else\r
+ {\r
+ png_byte p = (png_byte)((*sp >> shift) & 0x03);\r
+ png_byte g = (png_byte)((gamma_table [p | (p << 2) |\r
+ (p << 4) | (p << 6)] >> 6) & 0x03);\r
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);\r
+ *sp |= (png_byte)(g << shift);\r
+ }\r
+ if (!shift)\r
+ {\r
+ shift = 6;\r
+ sp++;\r
+ }\r
+ else\r
+ shift -= 2;\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ shift = 6;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((png_uint_16)((*sp >> shift) & 0x03)\r
+ == trans_values->gray)\r
+ {\r
+ *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);\r
+ *sp |= (png_byte)(background->gray << shift);\r
+ }\r
+ if (!shift)\r
+ {\r
+ shift = 6;\r
+ sp++;\r
+ }\r
+ else\r
+ shift -= 2;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ shift = 4;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((png_uint_16)((*sp >> shift) & 0x0f)\r
+ == trans_values->gray)\r
+ {\r
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);\r
+ *sp |= (png_byte)(background->gray << shift);\r
+ }\r
+ else\r
+ {\r
+ png_byte p = (png_byte)((*sp >> shift) & 0x0f);\r
+ png_byte g = (png_byte)((gamma_table[p |\r
+ (p << 4)] >> 4) & 0x0f);\r
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);\r
+ *sp |= (png_byte)(g << shift);\r
+ }\r
+ if (!shift)\r
+ {\r
+ shift = 4;\r
+ sp++;\r
+ }\r
+ else\r
+ shift -= 4;\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ shift = 4;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((png_uint_16)((*sp >> shift) & 0x0f)\r
+ == trans_values->gray)\r
+ {\r
+ *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);\r
+ *sp |= (png_byte)(background->gray << shift);\r
+ }\r
+ if (!shift)\r
+ {\r
+ shift = 4;\r
+ sp++;\r
+ }\r
+ else\r
+ shift -= 4;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 8:\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp++)\r
+ {\r
+ if (*sp == trans_values->gray)\r
+ {\r
+ *sp = (png_byte)background->gray;\r
+ }\r
+ else\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp++)\r
+ {\r
+ if (*sp == trans_values->gray)\r
+ {\r
+ *sp = (png_byte)background->gray;\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case 16:\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_16 != NULL)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 2)\r
+ {\r
+ png_uint_16 v;\r
+\r
+ v = (png_uint_16)(((*sp) << 8) + *(sp + 1));\r
+ if (v == trans_values->gray)\r
+ {\r
+ /* background is already in screen gamma */\r
+ *sp = (png_byte)((background->gray >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(background->gray & 0xff);\r
+ }\r
+ else\r
+ {\r
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 2)\r
+ {\r
+ png_uint_16 v;\r
+\r
+ v = (png_uint_16)(((*sp) << 8) + *(sp + 1));\r
+ if (v == trans_values->gray)\r
+ {\r
+ *sp = (png_byte)((background->gray >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(background->gray & 0xff);\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_RGB:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 3)\r
+ {\r
+ if (*sp == trans_values->red &&\r
+ *(sp + 1) == trans_values->green &&\r
+ *(sp + 2) == trans_values->blue)\r
+ {\r
+ *sp = (png_byte)background->red;\r
+ *(sp + 1) = (png_byte)background->green;\r
+ *(sp + 2) = (png_byte)background->blue;\r
+ }\r
+ else\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ *(sp + 1) = gamma_table[*(sp + 1)];\r
+ *(sp + 2) = gamma_table[*(sp + 2)];\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 3)\r
+ {\r
+ if (*sp == trans_values->red &&\r
+ *(sp + 1) == trans_values->green &&\r
+ *(sp + 2) == trans_values->blue)\r
+ {\r
+ *sp = (png_byte)background->red;\r
+ *(sp + 1) = (png_byte)background->green;\r
+ *(sp + 2) = (png_byte)background->blue;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_16 != NULL)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 6)\r
+ {\r
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));\r
+ png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));\r
+ png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));\r
+ if (r == trans_values->red && g == trans_values->green &&\r
+ b == trans_values->blue)\r
+ {\r
+ /* background is already in screen gamma */\r
+ *sp = (png_byte)((background->red >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(background->red & 0xff);\r
+ *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);\r
+ *(sp + 3) = (png_byte)(background->green & 0xff);\r
+ *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);\r
+ *(sp + 5) = (png_byte)(background->blue & 0xff);\r
+ }\r
+ else\r
+ {\r
+ png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];\r
+ *(sp + 2) = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 3) = (png_byte)(v & 0xff);\r
+ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];\r
+ *(sp + 4) = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 5) = (png_byte)(v & 0xff);\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp += 6)\r
+ {\r
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1));\r
+ png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));\r
+ png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5));\r
+\r
+ if (r == trans_values->red && g == trans_values->green &&\r
+ b == trans_values->blue)\r
+ {\r
+ *sp = (png_byte)((background->red >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(background->red & 0xff);\r
+ *(sp + 2) = (png_byte)((background->green >> 8) & 0xff);\r
+ *(sp + 3) = (png_byte)(background->green & 0xff);\r
+ *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff);\r
+ *(sp + 5) = (png_byte)(background->blue & 0xff);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_GRAY_ALPHA:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_to_1 != NULL && gamma_from_1 != NULL &&\r
+ gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 2, dp++)\r
+ {\r
+ png_uint_16 a = *(sp + 1);\r
+\r
+ if (a == 0xff)\r
+ {\r
+ *dp = gamma_table[*sp];\r
+ }\r
+ else if (a == 0)\r
+ {\r
+ /* background is already in screen gamma */\r
+ *dp = (png_byte)background->gray;\r
+ }\r
+ else\r
+ {\r
+ png_byte v, w;\r
+\r
+ v = gamma_to_1[*sp];\r
+ png_composite(w, v, a, background_1->gray);\r
+ *dp = gamma_from_1[w];\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 2, dp++)\r
+ {\r
+ png_byte a = *(sp + 1);\r
+\r
+ if (a == 0xff)\r
+ {\r
+ *dp = *sp;\r
+ }\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ else if (a == 0)\r
+ {\r
+ *dp = (png_byte)background->gray;\r
+ }\r
+ else\r
+ {\r
+ png_composite(*dp, *sp, a, background_1->gray);\r
+ }\r
+#else\r
+ *dp = (png_byte)background->gray;\r
+#endif\r
+ }\r
+ }\r
+ }\r
+ else /* if (png_ptr->bit_depth == 16) */\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_16 != NULL && gamma_16_from_1 != NULL &&\r
+ gamma_16_to_1 != NULL)\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 4, dp += 2)\r
+ {\r
+ png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));\r
+\r
+ if (a == (png_uint_16)0xffff)\r
+ {\r
+ png_uint_16 v;\r
+\r
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];\r
+ *dp = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(v & 0xff);\r
+ }\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ else if (a == 0)\r
+#else\r
+ else\r
+#endif\r
+ {\r
+ /* background is already in screen gamma */\r
+ *dp = (png_byte)((background->gray >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(background->gray & 0xff);\r
+ }\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ else\r
+ {\r
+ png_uint_16 g, v, w;\r
+\r
+ g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];\r
+ png_composite_16(v, g, a, background_1->gray);\r
+ w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8];\r
+ *dp = (png_byte)((w >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(w & 0xff);\r
+ }\r
+#endif\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 4, dp += 2)\r
+ {\r
+ png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3));\r
+ if (a == (png_uint_16)0xffff)\r
+ {\r
+ png_memcpy(dp, sp, 2);\r
+ }\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ else if (a == 0)\r
+#else\r
+ else\r
+#endif\r
+ {\r
+ *dp = (png_byte)((background->gray >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(background->gray & 0xff);\r
+ }\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ else\r
+ {\r
+ png_uint_16 g, v;\r
+\r
+ g = (png_uint_16)(((*sp) << 8) + *(sp + 1));\r
+ png_composite_16(v, g, a, background_1->gray);\r
+ *dp = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(v & 0xff);\r
+ }\r
+#endif\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_RGB_ALPHA:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_to_1 != NULL && gamma_from_1 != NULL &&\r
+ gamma_table != NULL)\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 4, dp += 3)\r
+ {\r
+ png_byte a = *(sp + 3);\r
+\r
+ if (a == 0xff)\r
+ {\r
+ *dp = gamma_table[*sp];\r
+ *(dp + 1) = gamma_table[*(sp + 1)];\r
+ *(dp + 2) = gamma_table[*(sp + 2)];\r
+ }\r
+ else if (a == 0)\r
+ {\r
+ /* background is already in screen gamma */\r
+ *dp = (png_byte)background->red;\r
+ *(dp + 1) = (png_byte)background->green;\r
+ *(dp + 2) = (png_byte)background->blue;\r
+ }\r
+ else\r
+ {\r
+ png_byte v, w;\r
+\r
+ v = gamma_to_1[*sp];\r
+ png_composite(w, v, a, background_1->red);\r
+ *dp = gamma_from_1[w];\r
+ v = gamma_to_1[*(sp + 1)];\r
+ png_composite(w, v, a, background_1->green);\r
+ *(dp + 1) = gamma_from_1[w];\r
+ v = gamma_to_1[*(sp + 2)];\r
+ png_composite(w, v, a, background_1->blue);\r
+ *(dp + 2) = gamma_from_1[w];\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 4, dp += 3)\r
+ {\r
+ png_byte a = *(sp + 3);\r
+\r
+ if (a == 0xff)\r
+ {\r
+ *dp = *sp;\r
+ *(dp + 1) = *(sp + 1);\r
+ *(dp + 2) = *(sp + 2);\r
+ }\r
+ else if (a == 0)\r
+ {\r
+ *dp = (png_byte)background->red;\r
+ *(dp + 1) = (png_byte)background->green;\r
+ *(dp + 2) = (png_byte)background->blue;\r
+ }\r
+ else\r
+ {\r
+ png_composite(*dp, *sp, a, background->red);\r
+ png_composite(*(dp + 1), *(sp + 1), a,\r
+ background->green);\r
+ png_composite(*(dp + 2), *(sp + 2), a,\r
+ background->blue);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (gamma_16 != NULL && gamma_16_from_1 != NULL &&\r
+ gamma_16_to_1 != NULL)\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 8, dp += 6)\r
+ {\r
+ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))\r
+ << 8) + (png_uint_16)(*(sp + 7)));\r
+ if (a == (png_uint_16)0xffff)\r
+ {\r
+ png_uint_16 v;\r
+\r
+ v = gamma_16[*(sp + 1) >> gamma_shift][*sp];\r
+ *dp = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(v & 0xff);\r
+ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)];\r
+ *(dp + 2) = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 3) = (png_byte)(v & 0xff);\r
+ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)];\r
+ *(dp + 4) = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 5) = (png_byte)(v & 0xff);\r
+ }\r
+ else if (a == 0)\r
+ {\r
+ /* background is already in screen gamma */\r
+ *dp = (png_byte)((background->red >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(background->red & 0xff);\r
+ *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);\r
+ *(dp + 3) = (png_byte)(background->green & 0xff);\r
+ *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);\r
+ *(dp + 5) = (png_byte)(background->blue & 0xff);\r
+ }\r
+ else\r
+ {\r
+ png_uint_16 v, w, x;\r
+\r
+ v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp];\r
+ png_composite_16(w, v, a, background_1->red);\r
+ x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];\r
+ *dp = (png_byte)((x >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(x & 0xff);\r
+ v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)];\r
+ png_composite_16(w, v, a, background_1->green);\r
+ x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8];\r
+ *(dp + 2) = (png_byte)((x >> 8) & 0xff);\r
+ *(dp + 3) = (png_byte)(x & 0xff);\r
+ v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)];\r
+ png_composite_16(w, v, a, background_1->blue);\r
+ x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8];\r
+ *(dp + 4) = (png_byte)((x >> 8) & 0xff);\r
+ *(dp + 5) = (png_byte)(x & 0xff);\r
+ }\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++, sp += 8, dp += 6)\r
+ {\r
+ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6))\r
+ << 8) + (png_uint_16)(*(sp + 7)));\r
+ if (a == (png_uint_16)0xffff)\r
+ {\r
+ png_memcpy(dp, sp, 6);\r
+ }\r
+ else if (a == 0)\r
+ {\r
+ *dp = (png_byte)((background->red >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(background->red & 0xff);\r
+ *(dp + 2) = (png_byte)((background->green >> 8) & 0xff);\r
+ *(dp + 3) = (png_byte)(background->green & 0xff);\r
+ *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff);\r
+ *(dp + 5) = (png_byte)(background->blue & 0xff);\r
+ }\r
+ else\r
+ {\r
+ png_uint_16 v;\r
+\r
+ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1));\r
+ png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8)\r
+ + *(sp + 3));\r
+ png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8)\r
+ + *(sp + 5));\r
+\r
+ png_composite_16(v, r, a, background->red);\r
+ *dp = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 1) = (png_byte)(v & 0xff);\r
+ png_composite_16(v, g, a, background->green);\r
+ *(dp + 2) = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 3) = (png_byte)(v & 0xff);\r
+ png_composite_16(v, b, a, background->blue);\r
+ *(dp + 4) = (png_byte)((v >> 8) & 0xff);\r
+ *(dp + 5) = (png_byte)(v & 0xff);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ }\r
+\r
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)\r
+ {\r
+ row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;\r
+ row_info->channels--;\r
+ row_info->pixel_depth = (png_byte)(row_info->channels *\r
+ row_info->bit_depth);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+/* Gamma correct the image, avoiding the alpha channel. Make sure\r
+ * you do this after you deal with the transparency issue on grayscale\r
+ * or RGB images. If your bit depth is 8, use gamma_table, if it\r
+ * is 16, use gamma_16_table and gamma_shift. Build these with\r
+ * build_gamma_table().\r
+ */\r
+void /* PRIVATE */\r
+png_do_gamma(png_row_infop row_info, png_bytep row,\r
+ png_bytep gamma_table, png_uint_16pp gamma_16_table,\r
+ int gamma_shift)\r
+{\r
+ png_bytep sp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+\r
+ png_debug(1, "in png_do_gamma\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ ((row_info->bit_depth <= 8 && gamma_table != NULL) ||\r
+ (row_info->bit_depth == 16 && gamma_16_table != NULL)))\r
+ {\r
+ switch (row_info->color_type)\r
+ {\r
+ case PNG_COLOR_TYPE_RGB:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ }\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 v;\r
+\r
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_RGB_ALPHA:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ sp++;\r
+ }\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 4;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_GRAY_ALPHA:\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ sp += 2;\r
+ }\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 4;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case PNG_COLOR_TYPE_GRAY:\r
+ {\r
+ if (row_info->bit_depth == 2)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i += 4)\r
+ {\r
+ int a = *sp & 0xc0;\r
+ int b = *sp & 0x30;\r
+ int c = *sp & 0x0c;\r
+ int d = *sp & 0x03;\r
+\r
+ *sp = (png_byte)(\r
+ ((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)|\r
+ ((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)|\r
+ ((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)|\r
+ ((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) ));\r
+ sp++;\r
+ }\r
+ }\r
+ if (row_info->bit_depth == 4)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i += 2)\r
+ {\r
+ int msb = *sp & 0xf0;\r
+ int lsb = *sp & 0x0f;\r
+\r
+ *sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0)\r
+ | (((int)gamma_table[(lsb << 4) | lsb]) >> 4));\r
+ sp++;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 8)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *sp = gamma_table[*sp];\r
+ sp++;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp];\r
+ *sp = (png_byte)((v >> 8) & 0xff);\r
+ *(sp + 1) = (png_byte)(v & 0xff);\r
+ sp += 2;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+/* Expands a palette row to an RGB or RGBA row depending\r
+ * upon whether you supply trans and num_trans.\r
+ */\r
+void /* PRIVATE */\r
+png_do_expand_palette(png_row_infop row_info, png_bytep row,\r
+ png_colorp palette, png_bytep trans, int num_trans)\r
+{\r
+ int shift, value;\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+\r
+ png_debug(1, "in png_do_expand_palette\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ row_info->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (row_info->bit_depth < 8)\r
+ {\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ sp = row + (png_size_t)((row_width - 1) >> 3);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = 7 - (int)((row_width + 7) & 0x07);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((*sp >> shift) & 0x01)\r
+ *dp = 1;\r
+ else\r
+ *dp = 0;\r
+ if (shift == 7)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift++;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ sp = row + (png_size_t)((row_width - 1) >> 2);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ value = (*sp >> shift) & 0x03;\r
+ *dp = (png_byte)value;\r
+ if (shift == 6)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift += 2;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ sp = row + (png_size_t)((row_width - 1) >> 1);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = (int)((row_width & 0x01) << 2);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ value = (*sp >> shift) & 0x0f;\r
+ *dp = (png_byte)value;\r
+ if (shift == 4)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift += 4;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = 8;\r
+ row_info->rowbytes = row_width;\r
+ }\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 8:\r
+ {\r
+ if (trans != NULL)\r
+ {\r
+ sp = row + (png_size_t)row_width - 1;\r
+ dp = row + (png_size_t)(row_width << 2) - 1;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((int)(*sp) >= num_trans)\r
+ *dp-- = 0xff;\r
+ else\r
+ *dp-- = trans[*sp];\r
+ *dp-- = palette[*sp].blue;\r
+ *dp-- = palette[*sp].green;\r
+ *dp-- = palette[*sp].red;\r
+ sp--;\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = 32;\r
+ row_info->rowbytes = row_width * 4;\r
+ row_info->color_type = 6;\r
+ row_info->channels = 4;\r
+ }\r
+ else\r
+ {\r
+ sp = row + (png_size_t)row_width - 1;\r
+ dp = row + (png_size_t)(row_width * 3) - 1;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *dp-- = palette[*sp].blue;\r
+ *dp-- = palette[*sp].green;\r
+ *dp-- = palette[*sp].red;\r
+ sp--;\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = 24;\r
+ row_info->rowbytes = row_width * 3;\r
+ row_info->color_type = 2;\r
+ row_info->channels = 3;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+/* If the bit depth < 8, it is expanded to 8. Also, if the already\r
+ * expanded transparency value is supplied, an alpha channel is built.\r
+ */\r
+void /* PRIVATE */\r
+png_do_expand(png_row_infop row_info, png_bytep row,\r
+ png_color_16p trans_value)\r
+{\r
+ int shift, value;\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+\r
+ png_debug(1, "in png_do_expand\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0);\r
+\r
+ if (row_info->bit_depth < 8)\r
+ {\r
+ switch (row_info->bit_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ gray = (png_uint_16)((gray&0x01)*0xff);\r
+ sp = row + (png_size_t)((row_width - 1) >> 3);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = 7 - (int)((row_width + 7) & 0x07);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if ((*sp >> shift) & 0x01)\r
+ *dp = 0xff;\r
+ else\r
+ *dp = 0;\r
+ if (shift == 7)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift++;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ gray = (png_uint_16)((gray&0x03)*0x55);\r
+ sp = row + (png_size_t)((row_width - 1) >> 2);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ value = (*sp >> shift) & 0x03;\r
+ *dp = (png_byte)(value | (value << 2) | (value << 4) |\r
+ (value << 6));\r
+ if (shift == 6)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift += 2;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ gray = (png_uint_16)((gray&0x0f)*0x11);\r
+ sp = row + (png_size_t)((row_width - 1) >> 1);\r
+ dp = row + (png_size_t)row_width - 1;\r
+ shift = (int)((1 - ((row_width + 1) & 0x01)) << 2);\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ value = (*sp >> shift) & 0x0f;\r
+ *dp = (png_byte)(value | (value << 4));\r
+ if (shift == 4)\r
+ {\r
+ shift = 0;\r
+ sp--;\r
+ }\r
+ else\r
+ shift = 4;\r
+\r
+ dp--;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ row_info->bit_depth = 8;\r
+ row_info->pixel_depth = 8;\r
+ row_info->rowbytes = row_width;\r
+ }\r
+\r
+ if (trans_value != NULL)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ gray = gray & 0xff;\r
+ sp = row + (png_size_t)row_width - 1;\r
+ dp = row + (png_size_t)(row_width << 1) - 1;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (*sp == gray)\r
+ *dp-- = 0;\r
+ else\r
+ *dp-- = 0xff;\r
+ *dp-- = *sp--;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ png_byte gray_high = (gray >> 8) & 0xff;\r
+ png_byte gray_low = gray & 0xff;\r
+ sp = row + row_info->rowbytes - 1;\r
+ dp = row + (row_info->rowbytes << 1) - 1;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (*(sp - 1) == gray_high && *(sp) == gray_low) \r
+ {\r
+ *dp-- = 0;\r
+ *dp-- = 0;\r
+ }\r
+ else\r
+ {\r
+ *dp-- = 0xff;\r
+ *dp-- = 0xff;\r
+ }\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ }\r
+ }\r
+ row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA;\r
+ row_info->channels = 2;\r
+ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,\r
+ row_width);\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_byte red = trans_value->red & 0xff;\r
+ png_byte green = trans_value->green & 0xff;\r
+ png_byte blue = trans_value->blue & 0xff;\r
+ sp = row + (png_size_t)row_info->rowbytes - 1;\r
+ dp = row + (png_size_t)(row_width << 2) - 1;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue)\r
+ *dp-- = 0;\r
+ else\r
+ *dp-- = 0xff;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ png_byte red_high = (trans_value->red >> 8) & 0xff;\r
+ png_byte green_high = (trans_value->green >> 8) & 0xff;\r
+ png_byte blue_high = (trans_value->blue >> 8) & 0xff;\r
+ png_byte red_low = trans_value->red & 0xff;\r
+ png_byte green_low = trans_value->green & 0xff;\r
+ png_byte blue_low = trans_value->blue & 0xff;\r
+ sp = row + row_info->rowbytes - 1;\r
+ dp = row + (png_size_t)(row_width << 3) - 1;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (*(sp - 5) == red_high &&\r
+ *(sp - 4) == red_low &&\r
+ *(sp - 3) == green_high &&\r
+ *(sp - 2) == green_low &&\r
+ *(sp - 1) == blue_high &&\r
+ *(sp ) == blue_low)\r
+ {\r
+ *dp-- = 0;\r
+ *dp-- = 0;\r
+ }\r
+ else\r
+ {\r
+ *dp-- = 0xff;\r
+ *dp-- = 0xff;\r
+ }\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ *dp-- = *sp--;\r
+ }\r
+ }\r
+ row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA;\r
+ row_info->channels = 4;\r
+ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_DITHER_SUPPORTED)\r
+void /* PRIVATE */\r
+png_do_dither(png_row_infop row_info, png_bytep row,\r
+ png_bytep palette_lookup, png_bytep dither_lookup)\r
+{\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width=row_info->width;\r
+\r
+ png_debug(1, "in png_do_dither\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB &&\r
+ palette_lookup && row_info->bit_depth == 8)\r
+ {\r
+ int r, g, b, p;\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ r = *sp++;\r
+ g = *sp++;\r
+ b = *sp++;\r
+\r
+ /* this looks real messy, but the compiler will reduce\r
+ it down to a reasonable formula. For example, with\r
+ 5 bits per color, we get:\r
+ p = (((r >> 3) & 0x1f) << 10) |\r
+ (((g >> 3) & 0x1f) << 5) |\r
+ ((b >> 3) & 0x1f);\r
+ */\r
+ p = (((r >> (8 - PNG_DITHER_RED_BITS)) &\r
+ ((1 << PNG_DITHER_RED_BITS) - 1)) <<\r
+ (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |\r
+ (((g >> (8 - PNG_DITHER_GREEN_BITS)) &\r
+ ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<\r
+ (PNG_DITHER_BLUE_BITS)) |\r
+ ((b >> (8 - PNG_DITHER_BLUE_BITS)) &\r
+ ((1 << PNG_DITHER_BLUE_BITS) - 1));\r
+\r
+ *dp++ = palette_lookup[p];\r
+ }\r
+ row_info->color_type = PNG_COLOR_TYPE_PALETTE;\r
+ row_info->channels = 1;\r
+ row_info->pixel_depth = row_info->bit_depth;\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&\r
+ palette_lookup != NULL && row_info->bit_depth == 8)\r
+ {\r
+ int r, g, b, p;\r
+ sp = row;\r
+ dp = row;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ r = *sp++;\r
+ g = *sp++;\r
+ b = *sp++;\r
+ sp++;\r
+\r
+ p = (((r >> (8 - PNG_DITHER_RED_BITS)) &\r
+ ((1 << PNG_DITHER_RED_BITS) - 1)) <<\r
+ (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) |\r
+ (((g >> (8 - PNG_DITHER_GREEN_BITS)) &\r
+ ((1 << PNG_DITHER_GREEN_BITS) - 1)) <<\r
+ (PNG_DITHER_BLUE_BITS)) |\r
+ ((b >> (8 - PNG_DITHER_BLUE_BITS)) &\r
+ ((1 << PNG_DITHER_BLUE_BITS) - 1));\r
+\r
+ *dp++ = palette_lookup[p];\r
+ }\r
+ row_info->color_type = PNG_COLOR_TYPE_PALETTE;\r
+ row_info->channels = 1;\r
+ row_info->pixel_depth = row_info->bit_depth;\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width);\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ dither_lookup && row_info->bit_depth == 8)\r
+ {\r
+ sp = row;\r
+ for (i = 0; i < row_width; i++, sp++)\r
+ {\r
+ *sp = dither_lookup[*sp];\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+#if defined(PNG_READ_GAMMA_SUPPORTED)\r
+static PNG_CONST int png_gamma_shift[] =\r
+ {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00};\r
+\r
+/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit\r
+ * tables, we don't make a full table if we are reducing to 8-bit in\r
+ * the future. Note also how the gamma_16 tables are segmented so that\r
+ * we don't need to allocate > 64K chunks for a full 16-bit table.\r
+ */\r
+void /* PRIVATE */\r
+png_build_gamma_table(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_build_gamma_table\n");\r
+\r
+ if (png_ptr->bit_depth <= 8)\r
+ {\r
+ int i;\r
+ double g;\r
+\r
+ if (png_ptr->screen_gamma > .000001)\r
+ g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);\r
+ else\r
+ g = 1.0;\r
+\r
+ png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)256);\r
+\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0,\r
+ g) * 255.0 + .5);\r
+ }\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+ if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY))\r
+ {\r
+\r
+ g = 1.0 / (png_ptr->gamma);\r
+\r
+ png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)256);\r
+\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0,\r
+ g) * 255.0 + .5);\r
+ }\r
+\r
+\r
+ png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)256);\r
+\r
+ if (png_ptr->screen_gamma > 0.000001)\r
+ g = 1.0 / png_ptr->screen_gamma;\r
+ else\r
+ g = png_ptr->gamma; /* probably doing rgb_to_gray */\r
+\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0,\r
+ g) * 255.0 + .5);\r
+\r
+ }\r
+ }\r
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */\r
+ }\r
+ else\r
+ {\r
+ double g;\r
+ int i, j, shift, num;\r
+ int sig_bit;\r
+ png_uint_32 ig;\r
+\r
+ if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ sig_bit = (int)png_ptr->sig_bit.red;\r
+ if ((int)png_ptr->sig_bit.green > sig_bit)\r
+ sig_bit = png_ptr->sig_bit.green;\r
+ if ((int)png_ptr->sig_bit.blue > sig_bit)\r
+ sig_bit = png_ptr->sig_bit.blue;\r
+ }\r
+ else\r
+ {\r
+ sig_bit = (int)png_ptr->sig_bit.gray;\r
+ }\r
+\r
+ if (sig_bit > 0)\r
+ shift = 16 - sig_bit;\r
+ else\r
+ shift = 0;\r
+\r
+ if (png_ptr->transformations & PNG_16_TO_8)\r
+ {\r
+ if (shift < (16 - PNG_MAX_GAMMA_8))\r
+ shift = (16 - PNG_MAX_GAMMA_8);\r
+ }\r
+\r
+ if (shift > 8)\r
+ shift = 8;\r
+ if (shift < 0)\r
+ shift = 0;\r
+\r
+ png_ptr->gamma_shift = (png_byte)shift;\r
+\r
+ num = (1 << (8 - shift));\r
+\r
+ if (png_ptr->screen_gamma > .000001)\r
+ g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma);\r
+ else\r
+ g = 1.0;\r
+\r
+ png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr,\r
+ (png_uint_32)(num * png_sizeof(png_uint_16p)));\r
+\r
+ if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND))\r
+ {\r
+ double fin, fout;\r
+ png_uint_32 last, max;\r
+\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));\r
+ }\r
+\r
+ g = 1.0 / g;\r
+ last = 0;\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ fout = ((double)i + 0.5) / 256.0;\r
+ fin = pow(fout, g);\r
+ max = (png_uint_32)(fin * (double)((png_uint_32)num << 8));\r
+ while (last <= max)\r
+ {\r
+ png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]\r
+ [(int)(last >> (8 - shift))] = (png_uint_16)(\r
+ (png_uint_16)i | ((png_uint_16)i << 8));\r
+ last++;\r
+ }\r
+ }\r
+ while (last < ((png_uint_32)num << 8))\r
+ {\r
+ png_ptr->gamma_16_table[(int)(last & (0xff >> shift))]\r
+ [(int)(last >> (8 - shift))] = (png_uint_16)65535L;\r
+ last++;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));\r
+\r
+ ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4);\r
+ for (j = 0; j < 256; j++)\r
+ {\r
+ png_ptr->gamma_16_table[i][j] =\r
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /\r
+ 65535.0, g) * 65535.0 + .5);\r
+ }\r
+ }\r
+ }\r
+\r
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \\r
+ defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)\r
+ if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY))\r
+ {\r
+\r
+ g = 1.0 / (png_ptr->gamma);\r
+\r
+ png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr,\r
+ (png_uint_32)(num * png_sizeof(png_uint_16p )));\r
+\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));\r
+\r
+ ig = (((png_uint_32)i *\r
+ (png_uint_32)png_gamma_shift[shift]) >> 4);\r
+ for (j = 0; j < 256; j++)\r
+ {\r
+ png_ptr->gamma_16_to_1[i][j] =\r
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /\r
+ 65535.0, g) * 65535.0 + .5);\r
+ }\r
+ }\r
+\r
+ if (png_ptr->screen_gamma > 0.000001)\r
+ g = 1.0 / png_ptr->screen_gamma;\r
+ else\r
+ g = png_ptr->gamma; /* probably doing rgb_to_gray */\r
+\r
+ png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr,\r
+ (png_uint_32)(num * png_sizeof(png_uint_16p)));\r
+\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(256 * png_sizeof(png_uint_16)));\r
+\r
+ ig = (((png_uint_32)i *\r
+ (png_uint_32)png_gamma_shift[shift]) >> 4);\r
+ for (j = 0; j < 256; j++)\r
+ {\r
+ png_ptr->gamma_16_from_1[i][j] =\r
+ (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) /\r
+ 65535.0, g) * 65535.0 + .5);\r
+ }\r
+ }\r
+ }\r
+#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */\r
+ }\r
+}\r
+#endif\r
+/* To do: install integer version of png_build_gamma_table here */\r
+#endif\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+/* undoes intrapixel differencing */\r
+void /* PRIVATE */\r
+png_do_read_intrapixel(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_read_intrapixel\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ int bytes_per_pixel;\r
+ png_uint_32 row_width = row_info->width;\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ bytes_per_pixel = 3;\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ bytes_per_pixel = 4;\r
+ else\r
+ return;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)\r
+ {\r
+ *(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff);\r
+ *(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff);\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ bytes_per_pixel = 6;\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ bytes_per_pixel = 8;\r
+ else\r
+ return;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)\r
+ {\r
+ png_uint_32 s0 = (*(rp ) << 8) | *(rp + 1);\r
+ png_uint_32 s1 = (*(rp + 2) << 8) | *(rp + 3);\r
+ png_uint_32 s2 = (*(rp + 4) << 8) | *(rp + 5);\r
+ png_uint_32 red = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL);\r
+ png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL);\r
+ *(rp ) = (png_byte)((red >> 8) & 0xff);\r
+ *(rp+1) = (png_byte)(red & 0xff);\r
+ *(rp+4) = (png_byte)((blue >> 8) & 0xff);\r
+ *(rp+5) = (png_byte)(blue & 0xff);\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif /* PNG_MNG_FEATURES_SUPPORTED */\r
+#endif /* PNG_READ_SUPPORTED */\r
--- /dev/null
+\r
+/* pngrutil.c - utilities to read a PNG file\r
+ *\r
+ * Last changed in libpng 1.2.33 [October 31, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file contains routines that are only called from within\r
+ * libpng itself during the course of reading an image.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED)\r
+\r
+#if defined(_WIN32_WCE) && (_WIN32_WCE<0x500)\r
+# define WIN32_WCE_OLD\r
+#endif\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+# if defined(WIN32_WCE_OLD)\r
+/* strtod() function is not supported on WindowsCE */\r
+__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr)\r
+{\r
+ double result = 0;\r
+ int len;\r
+ wchar_t *str, *end;\r
+\r
+ len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0);\r
+ str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t));\r
+ if ( NULL != str )\r
+ {\r
+ MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len);\r
+ result = wcstod(str, &end);\r
+ len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL);\r
+ *endptr = (char *)nptr + (png_strlen(nptr) - len + 1);\r
+ png_free(png_ptr, str);\r
+ }\r
+ return result;\r
+}\r
+# else\r
+# define png_strtod(p,a,b) strtod(a,b)\r
+# endif\r
+#endif\r
+\r
+png_uint_32 PNGAPI\r
+png_get_uint_31(png_structp png_ptr, png_bytep buf)\r
+{\r
+#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED\r
+ png_uint_32 i = png_get_uint_32(buf);\r
+#else\r
+ /* Avoid an extra function call by inlining the result. */\r
+ png_uint_32 i = ((png_uint_32)(*buf) << 24) +\r
+ ((png_uint_32)(*(buf + 1)) << 16) +\r
+ ((png_uint_32)(*(buf + 2)) << 8) +\r
+ (png_uint_32)(*(buf + 3));\r
+#endif\r
+ if (i > PNG_UINT_31_MAX)\r
+ png_error(png_ptr, "PNG unsigned integer out of range.");\r
+ return (i);\r
+}\r
+#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED\r
+/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */\r
+png_uint_32 PNGAPI\r
+png_get_uint_32(png_bytep buf)\r
+{\r
+ png_uint_32 i = ((png_uint_32)(*buf) << 24) +\r
+ ((png_uint_32)(*(buf + 1)) << 16) +\r
+ ((png_uint_32)(*(buf + 2)) << 8) +\r
+ (png_uint_32)(*(buf + 3));\r
+\r
+ return (i);\r
+}\r
+\r
+/* Grab a signed 32-bit integer from a buffer in big-endian format. The\r
+ * data is stored in the PNG file in two's complement format, and it is\r
+ * assumed that the machine format for signed integers is the same. */\r
+png_int_32 PNGAPI\r
+png_get_int_32(png_bytep buf)\r
+{\r
+ png_int_32 i = ((png_int_32)(*buf) << 24) +\r
+ ((png_int_32)(*(buf + 1)) << 16) +\r
+ ((png_int_32)(*(buf + 2)) << 8) +\r
+ (png_int_32)(*(buf + 3));\r
+\r
+ return (i);\r
+}\r
+\r
+/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */\r
+png_uint_16 PNGAPI\r
+png_get_uint_16(png_bytep buf)\r
+{\r
+ png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) +\r
+ (png_uint_16)(*(buf + 1)));\r
+\r
+ return (i);\r
+}\r
+#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */\r
+\r
+/* Read the chunk header (length + type name).\r
+ * Put the type name into png_ptr->chunk_name, and return the length.\r
+ */\r
+png_uint_32 /* PRIVATE */\r
+png_read_chunk_header(png_structp png_ptr)\r
+{\r
+ png_byte buf[8];\r
+ png_uint_32 length;\r
+\r
+ /* read the length and the chunk name */\r
+ png_read_data(png_ptr, buf, 8);\r
+ length = png_get_uint_31(png_ptr, buf);\r
+\r
+ /* put the chunk name into png_ptr->chunk_name */\r
+ png_memcpy(png_ptr->chunk_name, buf + 4, 4);\r
+\r
+ png_debug2(0, "Reading %s chunk, length = %lu\n",\r
+ png_ptr->chunk_name, length);\r
+\r
+ /* reset the crc and run it over the chunk name */\r
+ png_reset_crc(png_ptr);\r
+ png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);\r
+\r
+ /* check to see if chunk name is valid */\r
+ png_check_chunk_name(png_ptr, png_ptr->chunk_name);\r
+\r
+ return length;\r
+}\r
+\r
+/* Read data, and (optionally) run it through the CRC. */\r
+void /* PRIVATE */\r
+png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_read_data(png_ptr, buf, length);\r
+ png_calculate_crc(png_ptr, buf, length);\r
+}\r
+\r
+/* Optionally skip data and then check the CRC. Depending on whether we\r
+ are reading a ancillary or critical chunk, and how the program has set\r
+ things up, we may calculate the CRC on the data and print a message.\r
+ Returns '1' if there was a CRC error, '0' otherwise. */\r
+int /* PRIVATE */\r
+png_crc_finish(png_structp png_ptr, png_uint_32 skip)\r
+{\r
+ png_size_t i;\r
+ png_size_t istop = png_ptr->zbuf_size;\r
+\r
+ for (i = (png_size_t)skip; i > istop; i -= istop)\r
+ {\r
+ png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);\r
+ }\r
+ if (i)\r
+ {\r
+ png_crc_read(png_ptr, png_ptr->zbuf, i);\r
+ }\r
+\r
+ if (png_crc_error(png_ptr))\r
+ {\r
+ if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */\r
+ !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||\r
+ (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */\r
+ (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))\r
+ {\r
+ png_chunk_warning(png_ptr, "CRC error");\r
+ }\r
+ else\r
+ {\r
+ png_chunk_error(png_ptr, "CRC error");\r
+ }\r
+ return (1);\r
+ }\r
+\r
+ return (0);\r
+}\r
+\r
+/* Compare the CRC stored in the PNG file with that calculated by libpng from\r
+ the data it has read thus far. */\r
+int /* PRIVATE */\r
+png_crc_error(png_structp png_ptr)\r
+{\r
+ png_byte crc_bytes[4];\r
+ png_uint_32 crc;\r
+ int need_crc = 1;\r
+\r
+ if (png_ptr->chunk_name[0] & 0x20) /* ancillary */\r
+ {\r
+ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==\r
+ (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))\r
+ need_crc = 0;\r
+ }\r
+ else /* critical */\r
+ {\r
+ if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)\r
+ need_crc = 0;\r
+ }\r
+\r
+ png_read_data(png_ptr, crc_bytes, 4);\r
+\r
+ if (need_crc)\r
+ {\r
+ crc = png_get_uint_32(crc_bytes);\r
+ return ((int)(crc != png_ptr->crc));\r
+ }\r
+ else\r
+ return (0);\r
+}\r
+\r
+#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \\r
+ defined(PNG_READ_iCCP_SUPPORTED)\r
+/*\r
+ * Decompress trailing data in a chunk. The assumption is that chunkdata\r
+ * points at an allocated area holding the contents of a chunk with a\r
+ * trailing compressed part. What we get back is an allocated area\r
+ * holding the original prefix part and an uncompressed version of the\r
+ * trailing part (the malloc area passed in is freed).\r
+ */\r
+void /* PRIVATE */\r
+png_decompress_chunk(png_structp png_ptr, int comp_type,\r
+ png_size_t chunklength,\r
+ png_size_t prefix_size, png_size_t *newlength)\r
+{\r
+ static PNG_CONST char msg[] = "Error decoding compressed text";\r
+ png_charp text;\r
+ png_size_t text_size;\r
+\r
+ if (comp_type == PNG_COMPRESSION_TYPE_BASE)\r
+ {\r
+ int ret = Z_OK;\r
+ png_ptr->zstream.next_in = (png_bytep)(png_ptr->chunkdata + prefix_size);\r
+ png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+\r
+ text_size = 0;\r
+ text = NULL;\r
+\r
+ while (png_ptr->zstream.avail_in)\r
+ {\r
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);\r
+ if (ret != Z_OK && ret != Z_STREAM_END)\r
+ {\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_warning(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_warning(png_ptr, msg);\r
+ inflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.avail_in = 0;\r
+\r
+ if (text == NULL)\r
+ {\r
+ text_size = prefix_size + png_sizeof(msg) + 1;\r
+ text = (png_charp)png_malloc_warn(png_ptr, text_size);\r
+ if (text == NULL)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_error(png_ptr, "Not enough memory to decompress chunk");\r
+ }\r
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);\r
+ }\r
+\r
+ text[text_size - 1] = 0x00;\r
+\r
+ /* Copy what we can of the error message into the text chunk */\r
+ text_size = (png_size_t)(chunklength -\r
+ (text - png_ptr->chunkdata) - 1);\r
+ if (text_size > png_sizeof(msg))\r
+ text_size = png_sizeof(msg);\r
+ png_memcpy(text + prefix_size, msg, text_size);\r
+ break;\r
+ }\r
+ if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END)\r
+ {\r
+ if (text == NULL)\r
+ {\r
+ text_size = prefix_size +\r
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out;\r
+ text = (png_charp)png_malloc_warn(png_ptr, text_size + 1);\r
+ if (text == NULL)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_error(png_ptr,\r
+ "Not enough memory to decompress chunk.");\r
+ }\r
+ png_memcpy(text + prefix_size, png_ptr->zbuf,\r
+ text_size - prefix_size);\r
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);\r
+ *(text + text_size) = 0x00;\r
+ }\r
+ else\r
+ {\r
+ png_charp tmp;\r
+\r
+ tmp = text;\r
+ text = (png_charp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(text_size +\r
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1));\r
+ if (text == NULL)\r
+ {\r
+ png_free(png_ptr, tmp);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_error(png_ptr,\r
+ "Not enough memory to decompress chunk..");\r
+ }\r
+ png_memcpy(text, tmp, text_size);\r
+ png_free(png_ptr, tmp);\r
+ png_memcpy(text + text_size, png_ptr->zbuf,\r
+ (png_ptr->zbuf_size - png_ptr->zstream.avail_out));\r
+ text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;\r
+ *(text + text_size) = 0x00;\r
+ }\r
+ if (ret == Z_STREAM_END)\r
+ break;\r
+ else\r
+ {\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ }\r
+ }\r
+ }\r
+ if (ret != Z_STREAM_END)\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char umsg[52];\r
+\r
+ if (ret == Z_BUF_ERROR)\r
+ png_snprintf(umsg, 52,\r
+ "Buffer error in compressed datastream in %s chunk",\r
+ png_ptr->chunk_name);\r
+ else if (ret == Z_DATA_ERROR)\r
+ png_snprintf(umsg, 52,\r
+ "Data error in compressed datastream in %s chunk",\r
+ png_ptr->chunk_name);\r
+ else\r
+ png_snprintf(umsg, 52,\r
+ "Incomplete compressed datastream in %s chunk",\r
+ png_ptr->chunk_name);\r
+ png_warning(png_ptr, umsg);\r
+#else\r
+ png_warning(png_ptr,\r
+ "Incomplete compressed datastream in chunk other than IDAT");\r
+#endif\r
+ text_size = prefix_size;\r
+ if (text == NULL)\r
+ {\r
+ text = (png_charp)png_malloc_warn(png_ptr, text_size+1);\r
+ if (text == NULL)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_error(png_ptr, "Not enough memory for text.");\r
+ }\r
+ png_memcpy(text, png_ptr->chunkdata, prefix_size);\r
+ }\r
+ *(text + text_size) = 0x00;\r
+ }\r
+\r
+ inflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.avail_in = 0;\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = text;\r
+ *newlength=text_size;\r
+ }\r
+ else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char umsg[50];\r
+\r
+ png_snprintf(umsg, 50, "Unknown zTXt compression type %d", comp_type);\r
+ png_warning(png_ptr, umsg);\r
+#else\r
+ png_warning(png_ptr, "Unknown zTXt compression type");\r
+#endif\r
+\r
+ *(png_ptr->chunkdata + prefix_size) = 0x00;\r
+ *newlength = prefix_size;\r
+ }\r
+}\r
+#endif\r
+\r
+/* read and check the IDHR chunk */\r
+void /* PRIVATE */\r
+png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte buf[13];\r
+ png_uint_32 width, height;\r
+ int bit_depth, color_type, compression_type, filter_type;\r
+ int interlace_type;\r
+\r
+ png_debug(1, "in png_handle_IHDR\n");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IHDR)\r
+ png_error(png_ptr, "Out of place IHDR");\r
+\r
+ /* check the length */\r
+ if (length != 13)\r
+ png_error(png_ptr, "Invalid IHDR chunk");\r
+\r
+ png_ptr->mode |= PNG_HAVE_IHDR;\r
+\r
+ png_crc_read(png_ptr, buf, 13);\r
+ png_crc_finish(png_ptr, 0);\r
+\r
+ width = png_get_uint_31(png_ptr, buf);\r
+ height = png_get_uint_31(png_ptr, buf + 4);\r
+ bit_depth = buf[8];\r
+ color_type = buf[9];\r
+ compression_type = buf[10];\r
+ filter_type = buf[11];\r
+ interlace_type = buf[12];\r
+\r
+ /* set internal variables */\r
+ png_ptr->width = width;\r
+ png_ptr->height = height;\r
+ png_ptr->bit_depth = (png_byte)bit_depth;\r
+ png_ptr->interlaced = (png_byte)interlace_type;\r
+ png_ptr->color_type = (png_byte)color_type;\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ png_ptr->filter_type = (png_byte)filter_type;\r
+#endif\r
+ png_ptr->compression_type = (png_byte)compression_type;\r
+\r
+ /* find number of channels */\r
+ switch (png_ptr->color_type)\r
+ {\r
+ case PNG_COLOR_TYPE_GRAY:\r
+ case PNG_COLOR_TYPE_PALETTE:\r
+ png_ptr->channels = 1;\r
+ break;\r
+ case PNG_COLOR_TYPE_RGB:\r
+ png_ptr->channels = 3;\r
+ break;\r
+ case PNG_COLOR_TYPE_GRAY_ALPHA:\r
+ png_ptr->channels = 2;\r
+ break;\r
+ case PNG_COLOR_TYPE_RGB_ALPHA:\r
+ png_ptr->channels = 4;\r
+ break;\r
+ }\r
+\r
+ /* set up other useful info */\r
+ png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *\r
+ png_ptr->channels);\r
+ png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);\r
+ png_debug1(3, "bit_depth = %d\n", png_ptr->bit_depth);\r
+ png_debug1(3, "channels = %d\n", png_ptr->channels);\r
+ png_debug1(3, "rowbytes = %lu\n", png_ptr->rowbytes);\r
+ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,\r
+ color_type, interlace_type, compression_type, filter_type);\r
+}\r
+\r
+/* read and check the palette */\r
+void /* PRIVATE */\r
+png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_color palette[PNG_MAX_PALETTE_LENGTH];\r
+ int num, i;\r
+#ifndef PNG_NO_POINTER_INDEXING\r
+ png_colorp pal_ptr;\r
+#endif\r
+\r
+ png_debug(1, "in png_handle_PLTE\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before PLTE");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid PLTE after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ png_error(png_ptr, "Duplicate PLTE chunk");\r
+\r
+ png_ptr->mode |= PNG_HAVE_PLTE;\r
+\r
+ if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring PLTE chunk in grayscale PNG");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)\r
+ if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+#endif\r
+\r
+ if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)\r
+ {\r
+ if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_warning(png_ptr, "Invalid palette chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else\r
+ {\r
+ png_error(png_ptr, "Invalid palette chunk");\r
+ }\r
+ }\r
+\r
+ num = (int)length / 3;\r
+\r
+#ifndef PNG_NO_POINTER_INDEXING\r
+ for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)\r
+ {\r
+ png_byte buf[3];\r
+\r
+ png_crc_read(png_ptr, buf, 3);\r
+ pal_ptr->red = buf[0];\r
+ pal_ptr->green = buf[1];\r
+ pal_ptr->blue = buf[2];\r
+ }\r
+#else\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_byte buf[3];\r
+\r
+ png_crc_read(png_ptr, buf, 3);\r
+ /* don't depend upon png_color being any order */\r
+ palette[i].red = buf[0];\r
+ palette[i].green = buf[1];\r
+ palette[i].blue = buf[2];\r
+ }\r
+#endif\r
+\r
+ /* If we actually NEED the PLTE chunk (ie for a paletted image), we do\r
+ whatever the normal CRC configuration tells us. However, if we\r
+ have an RGB image, the PLTE can be considered ancillary, so\r
+ we will act as though it is. */\r
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+#endif\r
+ {\r
+ png_crc_finish(png_ptr, 0);\r
+ }\r
+#if !defined(PNG_READ_OPT_PLTE_SUPPORTED)\r
+ else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */\r
+ {\r
+ /* If we don't want to use the data from an ancillary chunk,\r
+ we have two options: an error abort, or a warning and we\r
+ ignore the data in this chunk (which should be OK, since\r
+ it's considered ancillary for a RGB or RGBA image). */\r
+ if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE))\r
+ {\r
+ if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)\r
+ {\r
+ png_chunk_error(png_ptr, "CRC error");\r
+ }\r
+ else\r
+ {\r
+ png_chunk_warning(png_ptr, "CRC error");\r
+ return;\r
+ }\r
+ }\r
+ /* Otherwise, we (optionally) emit a warning and use the chunk. */\r
+ else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN))\r
+ {\r
+ png_chunk_warning(png_ptr, "CRC error");\r
+ }\r
+ }\r
+#endif\r
+\r
+ png_set_PLTE(png_ptr, info_ptr, palette, num);\r
+\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))\r
+ {\r
+ if (png_ptr->num_trans > (png_uint_16)num)\r
+ {\r
+ png_warning(png_ptr, "Truncating incorrect tRNS chunk length");\r
+ png_ptr->num_trans = (png_uint_16)num;\r
+ }\r
+ if (info_ptr->num_trans > (png_uint_16)num)\r
+ {\r
+ png_warning(png_ptr, "Truncating incorrect info tRNS chunk length");\r
+ info_ptr->num_trans = (png_uint_16)num;\r
+ }\r
+ }\r
+ }\r
+#endif\r
+\r
+}\r
+\r
+void /* PRIVATE */\r
+png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_debug(1, "in png_handle_IEND\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT))\r
+ {\r
+ png_error(png_ptr, "No image in file");\r
+ }\r
+\r
+ png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);\r
+\r
+ if (length != 0)\r
+ {\r
+ png_warning(png_ptr, "Incorrect IEND chunk length");\r
+ }\r
+ png_crc_finish(png_ptr, length);\r
+\r
+ info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */\r
+}\r
+\r
+#if defined(PNG_READ_gAMA_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_fixed_point igamma;\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float file_gamma;\r
+#endif\r
+ png_byte buf[4];\r
+\r
+ png_debug(1, "in png_handle_gAMA\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before gAMA");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid gAMA after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ /* Should be an error, but we can cope with it */\r
+ png_warning(png_ptr, "Out of place gAMA chunk");\r
+\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ && !(info_ptr->valid & PNG_INFO_sRGB)\r
+#endif\r
+ )\r
+ {\r
+ png_warning(png_ptr, "Duplicate gAMA chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (length != 4)\r
+ {\r
+ png_warning(png_ptr, "Incorrect gAMA chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 4);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ igamma = (png_fixed_point)png_get_uint_32(buf);\r
+ /* check for zero gamma */\r
+ if (igamma == 0)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring gAMA chunk with gamma=0");\r
+ return;\r
+ }\r
+\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))\r
+ if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring incorrect gAMA value when sRGB is also present");\r
+#ifndef PNG_NO_CONSOLE_IO\r
+ fprintf(stderr, "gamma = (%d/100000)\n", (int)igamma);\r
+#endif\r
+ return;\r
+ }\r
+#endif /* PNG_READ_sRGB_SUPPORTED */\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ file_gamma = (float)igamma / (float)100000.0;\r
+# ifdef PNG_READ_GAMMA_SUPPORTED\r
+ png_ptr->gamma = file_gamma;\r
+# endif\r
+ png_set_gAMA(png_ptr, info_ptr, file_gamma);\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_set_gAMA_fixed(png_ptr, info_ptr, igamma);\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_sBIT_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_size_t truelen;\r
+ png_byte buf[4];\r
+\r
+ png_debug(1, "in png_handle_sBIT\n");\r
+\r
+ buf[0] = buf[1] = buf[2] = buf[3] = 0;\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before sBIT");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid sBIT after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ {\r
+ /* Should be an error, but we can cope with it */\r
+ png_warning(png_ptr, "Out of place sBIT chunk");\r
+ }\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT))\r
+ {\r
+ png_warning(png_ptr, "Duplicate sBIT chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ truelen = 3;\r
+ else\r
+ truelen = (png_size_t)png_ptr->channels;\r
+\r
+ if (length != truelen || length > 4)\r
+ {\r
+ png_warning(png_ptr, "Incorrect sBIT chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, truelen);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ png_ptr->sig_bit.red = buf[0];\r
+ png_ptr->sig_bit.green = buf[1];\r
+ png_ptr->sig_bit.blue = buf[2];\r
+ png_ptr->sig_bit.alpha = buf[3];\r
+ }\r
+ else\r
+ {\r
+ png_ptr->sig_bit.gray = buf[0];\r
+ png_ptr->sig_bit.red = buf[0];\r
+ png_ptr->sig_bit.green = buf[0];\r
+ png_ptr->sig_bit.blue = buf[0];\r
+ png_ptr->sig_bit.alpha = buf[1];\r
+ }\r
+ png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_cHRM_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte buf[32];\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;\r
+#endif\r
+ png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,\r
+ int_y_green, int_x_blue, int_y_blue;\r
+\r
+ png_uint_32 uint_x, uint_y;\r
+\r
+ png_debug(1, "in png_handle_cHRM\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before cHRM");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ /* Should be an error, but we can cope with it */\r
+ png_warning(png_ptr, "Missing PLTE before cHRM");\r
+\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ && !(info_ptr->valid & PNG_INFO_sRGB)\r
+#endif\r
+ )\r
+ {\r
+ png_warning(png_ptr, "Duplicate cHRM chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (length != 32)\r
+ {\r
+ png_warning(png_ptr, "Incorrect cHRM chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 32);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ uint_x = png_get_uint_32(buf);\r
+ uint_y = png_get_uint_32(buf + 4);\r
+ if (uint_x > 80000L || uint_y > 80000L ||\r
+ uint_x + uint_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM white point");\r
+ return;\r
+ }\r
+ int_x_white = (png_fixed_point)uint_x;\r
+ int_y_white = (png_fixed_point)uint_y;\r
+\r
+ uint_x = png_get_uint_32(buf + 8);\r
+ uint_y = png_get_uint_32(buf + 12);\r
+ if (uint_x + uint_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM red point");\r
+ return;\r
+ }\r
+ int_x_red = (png_fixed_point)uint_x;\r
+ int_y_red = (png_fixed_point)uint_y;\r
+\r
+ uint_x = png_get_uint_32(buf + 16);\r
+ uint_y = png_get_uint_32(buf + 20);\r
+ if (uint_x + uint_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM green point");\r
+ return;\r
+ }\r
+ int_x_green = (png_fixed_point)uint_x;\r
+ int_y_green = (png_fixed_point)uint_y;\r
+\r
+ uint_x = png_get_uint_32(buf + 24);\r
+ uint_y = png_get_uint_32(buf + 28);\r
+ if (uint_x + uint_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM blue point");\r
+ return;\r
+ }\r
+ int_x_blue = (png_fixed_point)uint_x;\r
+ int_y_blue = (png_fixed_point)uint_y;\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ white_x = (float)int_x_white / (float)100000.0;\r
+ white_y = (float)int_y_white / (float)100000.0;\r
+ red_x = (float)int_x_red / (float)100000.0;\r
+ red_y = (float)int_y_red / (float)100000.0;\r
+ green_x = (float)int_x_green / (float)100000.0;\r
+ green_y = (float)int_y_green / (float)100000.0;\r
+ blue_x = (float)int_x_blue / (float)100000.0;\r
+ blue_y = (float)int_y_blue / (float)100000.0;\r
+#endif\r
+\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+ if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB))\r
+ {\r
+ if (PNG_OUT_OF_RANGE(int_x_white, 31270, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_y_white, 32900, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_x_red, 64000L, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_y_red, 33000, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_x_green, 30000, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_x_blue, 15000, 1000) ||\r
+ PNG_OUT_OF_RANGE(int_y_blue, 6000, 1000))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring incorrect cHRM value when sRGB is also present");\r
+#ifndef PNG_NO_CONSOLE_IO\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n",\r
+ white_x, white_y, red_x, red_y);\r
+ fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n",\r
+ green_x, green_y, blue_x, blue_y);\r
+#else\r
+ fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n",\r
+ int_x_white, int_y_white, int_x_red, int_y_red);\r
+ fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n",\r
+ int_x_green, int_y_green, int_x_blue, int_y_blue);\r
+#endif\r
+#endif /* PNG_NO_CONSOLE_IO */\r
+ }\r
+ return;\r
+ }\r
+#endif /* PNG_READ_sRGB_SUPPORTED */\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ png_set_cHRM(png_ptr, info_ptr,\r
+ white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_set_cHRM_fixed(png_ptr, info_ptr,\r
+ int_x_white, int_y_white, int_x_red, int_y_red, int_x_green,\r
+ int_y_green, int_x_blue, int_y_blue);\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_sRGB_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ int intent;\r
+ png_byte buf[1];\r
+\r
+ png_debug(1, "in png_handle_sRGB\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before sRGB");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid sRGB after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ /* Should be an error, but we can cope with it */\r
+ png_warning(png_ptr, "Out of place sRGB chunk");\r
+\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB))\r
+ {\r
+ png_warning(png_ptr, "Duplicate sRGB chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (length != 1)\r
+ {\r
+ png_warning(png_ptr, "Incorrect sRGB chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 1);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ intent = buf[0];\r
+ /* check for bad intent */\r
+ if (intent >= PNG_sRGB_INTENT_LAST)\r
+ {\r
+ png_warning(png_ptr, "Unknown sRGB intent");\r
+ return;\r
+ }\r
+\r
+#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA))\r
+ {\r
+ png_fixed_point igamma;\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ igamma=info_ptr->int_gamma;\r
+#else\r
+# ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ igamma=(png_fixed_point)(info_ptr->gamma * 100000.);\r
+# endif\r
+#endif\r
+ if (PNG_OUT_OF_RANGE(igamma, 45500L, 500))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring incorrect gAMA value when sRGB is also present");\r
+#ifndef PNG_NO_CONSOLE_IO\r
+# ifdef PNG_FIXED_POINT_SUPPORTED\r
+ fprintf(stderr, "incorrect gamma=(%d/100000)\n",\r
+ (int)png_ptr->int_gamma);\r
+# else\r
+# ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma);\r
+# endif\r
+# endif\r
+#endif\r
+ }\r
+ }\r
+#endif /* PNG_READ_gAMA_SUPPORTED */\r
+\r
+#ifdef PNG_READ_cHRM_SUPPORTED\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))\r
+ if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_x_red, 64000L, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_y_red, 33000, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_x_blue, 15000, 1000) ||\r
+ PNG_OUT_OF_RANGE(info_ptr->int_y_blue, 6000, 1000))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring incorrect cHRM value when sRGB is also present");\r
+ }\r
+#endif /* PNG_FIXED_POINT_SUPPORTED */\r
+#endif /* PNG_READ_cHRM_SUPPORTED */\r
+\r
+ png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent);\r
+}\r
+#endif /* PNG_READ_sRGB_SUPPORTED */\r
+\r
+#if defined(PNG_READ_iCCP_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+/* Note: this does not properly handle chunks that are > 64K under DOS */\r
+{\r
+ png_byte compression_type;\r
+ png_bytep pC;\r
+ png_charp profile;\r
+ png_uint_32 skip = 0;\r
+ png_uint_32 profile_size, profile_length;\r
+ png_size_t slength, prefix_length, data_length;\r
+\r
+ png_debug(1, "in png_handle_iCCP\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before iCCP");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid iCCP after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->mode & PNG_HAVE_PLTE)\r
+ /* Should be an error, but we can cope with it */\r
+ png_warning(png_ptr, "Out of place iCCP chunk");\r
+\r
+ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP))\r
+ {\r
+ png_warning(png_ptr, "Duplicate iCCP chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "iCCP chunk too large to fit in memory");\r
+ skip = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+\r
+ if (png_crc_finish(png_ptr, skip))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00;\r
+\r
+ for (profile = png_ptr->chunkdata; *profile; profile++)\r
+ /* empty loop to find end of name */ ;\r
+\r
+ ++profile;\r
+\r
+ /* there should be at least one zero (the compression type byte)\r
+ following the separator, and we should be on it */\r
+ if ( profile >= png_ptr->chunkdata + slength - 1)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "Malformed iCCP chunk");\r
+ return;\r
+ }\r
+\r
+ /* compression_type should always be zero */\r
+ compression_type = *profile++;\r
+ if (compression_type)\r
+ {\r
+ png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk");\r
+ compression_type = 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8\r
+ wrote nonzero) */\r
+ }\r
+\r
+ prefix_length = profile - png_ptr->chunkdata;\r
+ png_decompress_chunk(png_ptr, compression_type,\r
+ slength, prefix_length, &data_length);\r
+\r
+ profile_length = data_length - prefix_length;\r
+\r
+ if ( prefix_length > data_length || profile_length < 4)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "Profile size field missing from iCCP chunk");\r
+ return;\r
+ }\r
+\r
+ /* Check the profile_size recorded in the first 32 bits of the ICC profile */\r
+ pC = (png_bytep)(png_ptr->chunkdata + prefix_length);\r
+ profile_size = ((*(pC ))<<24) |\r
+ ((*(pC + 1))<<16) |\r
+ ((*(pC + 2))<< 8) |\r
+ ((*(pC + 3)) );\r
+\r
+ if (profile_size < profile_length)\r
+ profile_length = profile_size;\r
+\r
+ if (profile_size > profile_length)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "Ignoring truncated iCCP profile.");\r
+ return;\r
+ }\r
+\r
+ png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata,\r
+ compression_type, png_ptr->chunkdata + prefix_length, profile_length);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+}\r
+#endif /* PNG_READ_iCCP_SUPPORTED */\r
+\r
+#if defined(PNG_READ_sPLT_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+/* Note: this does not properly handle chunks that are > 64K under DOS */\r
+{\r
+ png_bytep entry_start;\r
+ png_sPLT_t new_palette;\r
+#ifdef PNG_NO_POINTER_INDEXING\r
+ png_sPLT_entryp pp;\r
+#endif\r
+ int data_length, entry_size, i;\r
+ png_uint_32 skip = 0;\r
+ png_size_t slength;\r
+\r
+ png_debug(1, "in png_handle_sPLT\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before sPLT");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid sPLT after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "sPLT chunk too large to fit in memory");\r
+ skip = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1);\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+\r
+ if (png_crc_finish(png_ptr, skip))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00;\r
+\r
+ for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)\r
+ /* empty loop to find end of name */ ;\r
+ ++entry_start;\r
+\r
+ /* a sample depth should follow the separator, and we should be on it */\r
+ if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "malformed sPLT chunk");\r
+ return;\r
+ }\r
+\r
+ new_palette.depth = *entry_start++;\r
+ entry_size = (new_palette.depth == 8 ? 6 : 10);\r
+ data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));\r
+\r
+ /* integrity-check the data length */\r
+ if (data_length % entry_size)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "sPLT chunk has bad length");\r
+ return;\r
+ }\r
+\r
+ new_palette.nentries = (png_int_32) ( data_length / entry_size);\r
+ if ((png_uint_32) new_palette.nentries >\r
+ (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry)))\r
+ {\r
+ png_warning(png_ptr, "sPLT chunk too long");\r
+ return;\r
+ }\r
+ new_palette.entries = (png_sPLT_entryp)png_malloc_warn(\r
+ png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry));\r
+ if (new_palette.entries == NULL)\r
+ {\r
+ png_warning(png_ptr, "sPLT chunk requires too much memory");\r
+ return;\r
+ }\r
+\r
+#ifndef PNG_NO_POINTER_INDEXING\r
+ for (i = 0; i < new_palette.nentries; i++)\r
+ {\r
+ png_sPLT_entryp pp = new_palette.entries + i;\r
+\r
+ if (new_palette.depth == 8)\r
+ {\r
+ pp->red = *entry_start++;\r
+ pp->green = *entry_start++;\r
+ pp->blue = *entry_start++;\r
+ pp->alpha = *entry_start++;\r
+ }\r
+ else\r
+ {\r
+ pp->red = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp->green = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp->blue = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp->alpha = png_get_uint_16(entry_start); entry_start += 2;\r
+ }\r
+ pp->frequency = png_get_uint_16(entry_start); entry_start += 2;\r
+ }\r
+#else\r
+ pp = new_palette.entries;\r
+ for (i = 0; i < new_palette.nentries; i++)\r
+ {\r
+\r
+ if (new_palette.depth == 8)\r
+ {\r
+ pp[i].red = *entry_start++;\r
+ pp[i].green = *entry_start++;\r
+ pp[i].blue = *entry_start++;\r
+ pp[i].alpha = *entry_start++;\r
+ }\r
+ else\r
+ {\r
+ pp[i].red = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp[i].green = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp[i].blue = png_get_uint_16(entry_start); entry_start += 2;\r
+ pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;\r
+ }\r
+ pp->frequency = png_get_uint_16(entry_start); entry_start += 2;\r
+ }\r
+#endif\r
+\r
+ /* discard all chunk data except the name and stash that */\r
+ new_palette.name = png_ptr->chunkdata;\r
+\r
+ png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_free(png_ptr, new_palette.entries);\r
+}\r
+#endif /* PNG_READ_sPLT_SUPPORTED */\r
+\r
+#if defined(PNG_READ_tRNS_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte readbuf[PNG_MAX_PALETTE_LENGTH];\r
+\r
+ png_debug(1, "in png_handle_tRNS\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before tRNS");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid tRNS after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))\r
+ {\r
+ png_warning(png_ptr, "Duplicate tRNS chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ png_byte buf[2];\r
+\r
+ if (length != 2)\r
+ {\r
+ png_warning(png_ptr, "Incorrect tRNS chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 2);\r
+ png_ptr->num_trans = 1;\r
+ png_ptr->trans_values.gray = png_get_uint_16(buf);\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ png_byte buf[6];\r
+\r
+ if (length != 6)\r
+ {\r
+ png_warning(png_ptr, "Incorrect tRNS chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ png_crc_read(png_ptr, buf, (png_size_t)length);\r
+ png_ptr->num_trans = 1;\r
+ png_ptr->trans_values.red = png_get_uint_16(buf);\r
+ png_ptr->trans_values.green = png_get_uint_16(buf + 2);\r
+ png_ptr->trans_values.blue = png_get_uint_16(buf + 4);\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (!(png_ptr->mode & PNG_HAVE_PLTE))\r
+ {\r
+ /* Should be an error, but we can cope with it. */\r
+ png_warning(png_ptr, "Missing PLTE before tRNS");\r
+ }\r
+ if (length > (png_uint_32)png_ptr->num_palette ||\r
+ length > PNG_MAX_PALETTE_LENGTH)\r
+ {\r
+ png_warning(png_ptr, "Incorrect tRNS chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ if (length == 0)\r
+ {\r
+ png_warning(png_ptr, "Zero length tRNS chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ png_crc_read(png_ptr, readbuf, (png_size_t)length);\r
+ png_ptr->num_trans = (png_uint_16)length;\r
+ }\r
+ else\r
+ {\r
+ png_warning(png_ptr, "tRNS chunk not allowed with alpha channel");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (png_crc_finish(png_ptr, 0))\r
+ {\r
+ png_ptr->num_trans = 0;\r
+ return;\r
+ }\r
+\r
+ png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,\r
+ &(png_ptr->trans_values));\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_bKGD_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_size_t truelen;\r
+ png_byte buf[6];\r
+\r
+ png_debug(1, "in png_handle_bKGD\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before bKGD");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid bKGD after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&\r
+ !(png_ptr->mode & PNG_HAVE_PLTE))\r
+ {\r
+ png_warning(png_ptr, "Missing PLTE before bKGD");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))\r
+ {\r
+ png_warning(png_ptr, "Duplicate bKGD chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ truelen = 1;\r
+ else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+ truelen = 6;\r
+ else\r
+ truelen = 2;\r
+\r
+ if (length != truelen)\r
+ {\r
+ png_warning(png_ptr, "Incorrect bKGD chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, truelen);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ /* We convert the index value into RGB components so that we can allow\r
+ * arbitrary RGB values for background when we have transparency, and\r
+ * so it is easy to determine the RGB values of the background color\r
+ * from the info_ptr struct. */\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_ptr->background.index = buf[0];\r
+ if (info_ptr && info_ptr->num_palette)\r
+ {\r
+ if (buf[0] > info_ptr->num_palette)\r
+ {\r
+ png_warning(png_ptr, "Incorrect bKGD chunk index value");\r
+ return;\r
+ }\r
+ png_ptr->background.red =\r
+ (png_uint_16)png_ptr->palette[buf[0]].red;\r
+ png_ptr->background.green =\r
+ (png_uint_16)png_ptr->palette[buf[0]].green;\r
+ png_ptr->background.blue =\r
+ (png_uint_16)png_ptr->palette[buf[0]].blue;\r
+ }\r
+ }\r
+ else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */\r
+ {\r
+ png_ptr->background.red =\r
+ png_ptr->background.green =\r
+ png_ptr->background.blue =\r
+ png_ptr->background.gray = png_get_uint_16(buf);\r
+ }\r
+ else\r
+ {\r
+ png_ptr->background.red = png_get_uint_16(buf);\r
+ png_ptr->background.green = png_get_uint_16(buf + 2);\r
+ png_ptr->background.blue = png_get_uint_16(buf + 4);\r
+ }\r
+\r
+ png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_hIST_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ unsigned int num, i;\r
+ png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];\r
+\r
+ png_debug(1, "in png_handle_hIST\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before hIST");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid hIST after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (!(png_ptr->mode & PNG_HAVE_PLTE))\r
+ {\r
+ png_warning(png_ptr, "Missing PLTE before hIST");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST))\r
+ {\r
+ png_warning(png_ptr, "Duplicate hIST chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ num = length / 2 ;\r
+ if (num != (unsigned int) png_ptr->num_palette || num >\r
+ (unsigned int) PNG_MAX_PALETTE_LENGTH)\r
+ {\r
+ png_warning(png_ptr, "Incorrect hIST chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ for (i = 0; i < num; i++)\r
+ {\r
+ png_byte buf[2];\r
+\r
+ png_crc_read(png_ptr, buf, 2);\r
+ readbuf[i] = png_get_uint_16(buf);\r
+ }\r
+\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ png_set_hIST(png_ptr, info_ptr, readbuf);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_pHYs_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte buf[9];\r
+ png_uint_32 res_x, res_y;\r
+ int unit_type;\r
+\r
+ png_debug(1, "in png_handle_pHYs\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before pHYs");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid pHYs after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs))\r
+ {\r
+ png_warning(png_ptr, "Duplicate pHYs chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (length != 9)\r
+ {\r
+ png_warning(png_ptr, "Incorrect pHYs chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 9);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ res_x = png_get_uint_32(buf);\r
+ res_y = png_get_uint_32(buf + 4);\r
+ unit_type = buf[8];\r
+ png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_oFFs_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte buf[9];\r
+ png_int_32 offset_x, offset_y;\r
+ int unit_type;\r
+\r
+ png_debug(1, "in png_handle_oFFs\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before oFFs");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid oFFs after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs))\r
+ {\r
+ png_warning(png_ptr, "Duplicate oFFs chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (length != 9)\r
+ {\r
+ png_warning(png_ptr, "Incorrect oFFs chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 9);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ offset_x = png_get_int_32(buf);\r
+ offset_y = png_get_int_32(buf + 4);\r
+ unit_type = buf[8];\r
+ png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_pCAL_SUPPORTED)\r
+/* read the pCAL chunk (described in the PNG Extensions document) */\r
+void /* PRIVATE */\r
+png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_int_32 X0, X1;\r
+ png_byte type, nparams;\r
+ png_charp buf, units, endptr;\r
+ png_charpp params;\r
+ png_size_t slength;\r
+ int i;\r
+\r
+ png_debug(1, "in png_handle_pCAL\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before pCAL");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid pCAL after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL))\r
+ {\r
+ png_warning(png_ptr, "Duplicate pCAL chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n",\r
+ length + 1);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);\r
+ if (png_ptr->chunkdata == NULL)\r
+ {\r
+ png_warning(png_ptr, "No memory for pCAL purpose.");\r
+ return;\r
+ }\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+\r
+ if (png_crc_finish(png_ptr, 0))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */\r
+\r
+ png_debug(3, "Finding end of pCAL purpose string\n");\r
+ for (buf = png_ptr->chunkdata; *buf; buf++)\r
+ /* empty loop */ ;\r
+\r
+ endptr = png_ptr->chunkdata + slength;\r
+\r
+ /* We need to have at least 12 bytes after the purpose string\r
+ in order to get the parameter information. */\r
+ if (endptr <= buf + 12)\r
+ {\r
+ png_warning(png_ptr, "Invalid pCAL data");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n");\r
+ X0 = png_get_int_32((png_bytep)buf+1);\r
+ X1 = png_get_int_32((png_bytep)buf+5);\r
+ type = buf[9];\r
+ nparams = buf[10];\r
+ units = buf + 11;\r
+\r
+ png_debug(3, "Checking pCAL equation type and number of parameters\n");\r
+ /* Check that we have the right number of parameters for known\r
+ equation types. */\r
+ if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||\r
+ (type == PNG_EQUATION_BASE_E && nparams != 3) ||\r
+ (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||\r
+ (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))\r
+ {\r
+ png_warning(png_ptr, "Invalid pCAL parameters for equation type");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ else if (type >= PNG_EQUATION_LAST)\r
+ {\r
+ png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");\r
+ }\r
+\r
+ for (buf = units; *buf; buf++)\r
+ /* Empty loop to move past the units string. */ ;\r
+\r
+ png_debug(3, "Allocating pCAL parameters array\n");\r
+ params = (png_charpp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(nparams * png_sizeof(png_charp))) ;\r
+ if (params == NULL)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_warning(png_ptr, "No memory for pCAL params.");\r
+ return;\r
+ }\r
+\r
+ /* Get pointers to the start of each parameter string. */\r
+ for (i = 0; i < (int)nparams; i++)\r
+ {\r
+ buf++; /* Skip the null string terminator from previous parameter. */\r
+\r
+ png_debug1(3, "Reading pCAL parameter %d\n", i);\r
+ for (params[i] = buf; buf <= endptr && *buf != 0x00; buf++)\r
+ /* Empty loop to move past each parameter string */ ;\r
+\r
+ /* Make sure we haven't run out of data yet */\r
+ if (buf > endptr)\r
+ {\r
+ png_warning(png_ptr, "Invalid pCAL data");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_free(png_ptr, params);\r
+ return;\r
+ }\r
+ }\r
+\r
+ png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams,\r
+ units, params);\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_free(png_ptr, params);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_sCAL_SUPPORTED)\r
+/* read the sCAL chunk */\r
+void /* PRIVATE */\r
+png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_charp ep;\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ double width, height;\r
+ png_charp vp;\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_charp swidth, sheight;\r
+#endif\r
+#endif\r
+ png_size_t slength;\r
+\r
+ png_debug(1, "in png_handle_sCAL\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before sCAL");\r
+ else if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+ png_warning(png_ptr, "Invalid sCAL after IDAT");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL))\r
+ {\r
+ png_warning(png_ptr, "Duplicate sCAL chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n",\r
+ length + 1);\r
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);\r
+ if (png_ptr->chunkdata == NULL)\r
+ {\r
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk");\r
+ return;\r
+ }\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+\r
+ if (png_crc_finish(png_ptr, 0))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */\r
+\r
+ ep = png_ptr->chunkdata + 1; /* skip unit byte */\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ width = png_strtod(png_ptr, ep, &vp);\r
+ if (*vp)\r
+ {\r
+ png_warning(png_ptr, "malformed width string in sCAL chunk");\r
+ return;\r
+ }\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);\r
+ if (swidth == NULL)\r
+ {\r
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk width");\r
+ return;\r
+ }\r
+ png_memcpy(swidth, ep, (png_size_t)png_strlen(ep));\r
+#endif\r
+#endif\r
+\r
+ for (ep = png_ptr->chunkdata; *ep; ep++)\r
+ /* empty loop */ ;\r
+ ep++;\r
+\r
+ if (png_ptr->chunkdata + slength < ep)\r
+ {\r
+ png_warning(png_ptr, "Truncated sCAL chunk");\r
+#if defined(PNG_FIXED_POINT_SUPPORTED) && \\r
+ !defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ png_free(png_ptr, swidth);\r
+#endif\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ height = png_strtod(png_ptr, ep, &vp);\r
+ if (*vp)\r
+ {\r
+ png_warning(png_ptr, "malformed height string in sCAL chunk");\r
+ return;\r
+ }\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1);\r
+ if (sheight == NULL)\r
+ {\r
+ png_warning(png_ptr, "Out of memory while processing sCAL chunk height");\r
+ return;\r
+ }\r
+ png_memcpy(sheight, ep, (png_size_t)png_strlen(ep));\r
+#endif\r
+#endif\r
+\r
+ if (png_ptr->chunkdata + slength < ep\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ || width <= 0. || height <= 0.\r
+#endif\r
+ )\r
+ {\r
+ png_warning(png_ptr, "Invalid sCAL data");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ png_free(png_ptr, swidth);\r
+ png_free(png_ptr, sheight);\r
+#endif\r
+ return;\r
+ }\r
+\r
+\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height);\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight);\r
+#endif\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)\r
+ png_free(png_ptr, swidth);\r
+ png_free(png_ptr, sheight);\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_tIME_SUPPORTED)\r
+void /* PRIVATE */\r
+png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_byte buf[7];\r
+ png_time mod_time;\r
+\r
+ png_debug(1, "in png_handle_tIME\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Out of place tIME chunk");\r
+ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME))\r
+ {\r
+ png_warning(png_ptr, "Duplicate tIME chunk");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+\r
+ if (length != 7)\r
+ {\r
+ png_warning(png_ptr, "Incorrect tIME chunk length");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+\r
+ png_crc_read(png_ptr, buf, 7);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ return;\r
+\r
+ mod_time.second = buf[6];\r
+ mod_time.minute = buf[5];\r
+ mod_time.hour = buf[4];\r
+ mod_time.day = buf[3];\r
+ mod_time.month = buf[2];\r
+ mod_time.year = png_get_uint_16(buf);\r
+\r
+ png_set_tIME(png_ptr, info_ptr, &mod_time);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_tEXt_SUPPORTED)\r
+/* Note: this does not properly handle chunks that are > 64K under DOS */\r
+void /* PRIVATE */\r
+png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_textp text_ptr;\r
+ png_charp key;\r
+ png_charp text;\r
+ png_uint_32 skip = 0;\r
+ png_size_t slength;\r
+ int ret;\r
+\r
+ png_debug(1, "in png_handle_tEXt\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before tEXt");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "tEXt chunk too large to fit in memory");\r
+ skip = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);\r
+ if (png_ptr->chunkdata == NULL)\r
+ {\r
+ png_warning(png_ptr, "No memory to process text chunk.");\r
+ return;\r
+ }\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+\r
+ if (png_crc_finish(png_ptr, skip))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ key = png_ptr->chunkdata;\r
+ key[slength] = 0x00;\r
+\r
+ for (text = key; *text; text++)\r
+ /* empty loop to find end of key */ ;\r
+\r
+ if (text != key + slength)\r
+ text++;\r
+\r
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ if (text_ptr == NULL)\r
+ {\r
+ png_warning(png_ptr, "Not enough memory to process text chunk.");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;\r
+ text_ptr->key = key;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ text_ptr->lang = NULL;\r
+ text_ptr->lang_key = NULL;\r
+ text_ptr->itxt_length = 0;\r
+#endif\r
+ text_ptr->text = text;\r
+ text_ptr->text_length = png_strlen(text);\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ png_free(png_ptr, text_ptr);\r
+ if (ret)\r
+ png_warning(png_ptr, "Insufficient memory to process text chunk.");\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_zTXt_SUPPORTED)\r
+/* note: this does not correctly handle chunks that are > 64K under DOS */\r
+void /* PRIVATE */\r
+png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_textp text_ptr;\r
+ png_charp text;\r
+ int comp_type;\r
+ int ret;\r
+ png_size_t slength, prefix_len, data_len;\r
+\r
+ png_debug(1, "in png_handle_zTXt\n");\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before zTXt");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ /* We will no doubt have problems with chunks even half this size, but\r
+ there is no hard and fast rule to tell us where to stop. */\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "zTXt chunk too large to fit in memory");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);\r
+ if (png_ptr->chunkdata == NULL)\r
+ {\r
+ png_warning(png_ptr, "Out of memory processing zTXt chunk.");\r
+ return;\r
+ }\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00;\r
+\r
+ for (text = png_ptr->chunkdata; *text; text++)\r
+ /* empty loop */ ;\r
+\r
+ /* zTXt must have some text after the chunkdataword */\r
+ if (text >= png_ptr->chunkdata + slength - 2)\r
+ {\r
+ png_warning(png_ptr, "Truncated zTXt chunk");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ else\r
+ {\r
+ comp_type = *(++text);\r
+ if (comp_type != PNG_TEXT_COMPRESSION_zTXt)\r
+ {\r
+ png_warning(png_ptr, "Unknown compression type in zTXt chunk");\r
+ comp_type = PNG_TEXT_COMPRESSION_zTXt;\r
+ }\r
+ text++; /* skip the compression_method byte */\r
+ }\r
+ prefix_len = text - png_ptr->chunkdata;\r
+\r
+ png_decompress_chunk(png_ptr, comp_type,\r
+ (png_size_t)length, prefix_len, &data_len);\r
+\r
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ if (text_ptr == NULL)\r
+ {\r
+ png_warning(png_ptr, "Not enough memory to process zTXt chunk.");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ text_ptr->compression = comp_type;\r
+ text_ptr->key = png_ptr->chunkdata;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ text_ptr->lang = NULL;\r
+ text_ptr->lang_key = NULL;\r
+ text_ptr->itxt_length = 0;\r
+#endif\r
+ text_ptr->text = png_ptr->chunkdata + prefix_len;\r
+ text_ptr->text_length = data_len;\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_free(png_ptr, text_ptr);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ if (ret)\r
+ png_error(png_ptr, "Insufficient memory to store zTXt chunk.");\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_iTXt_SUPPORTED)\r
+/* note: this does not correctly handle chunks that are > 64K under DOS */\r
+void /* PRIVATE */\r
+png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_textp text_ptr;\r
+ png_charp key, lang, text, lang_key;\r
+ int comp_flag;\r
+ int comp_type = 0;\r
+ int ret;\r
+ png_size_t slength, prefix_len, data_len;\r
+\r
+ png_debug(1, "in png_handle_iTXt\n");\r
+\r
+ if (!(png_ptr->mode & PNG_HAVE_IHDR))\r
+ png_error(png_ptr, "Missing IHDR before iTXt");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ /* We will no doubt have problems with chunks even half this size, but\r
+ there is no hard and fast rule to tell us where to stop. */\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "iTXt chunk too large to fit in memory");\r
+ png_crc_finish(png_ptr, length);\r
+ return;\r
+ }\r
+#endif\r
+\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1);\r
+ if (png_ptr->chunkdata == NULL)\r
+ {\r
+ png_warning(png_ptr, "No memory to process iTXt chunk.");\r
+ return;\r
+ }\r
+ slength = (png_size_t)length;\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength);\r
+ if (png_crc_finish(png_ptr, 0))\r
+ {\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ png_ptr->chunkdata[slength] = 0x00;\r
+\r
+ for (lang = png_ptr->chunkdata; *lang; lang++)\r
+ /* empty loop */ ;\r
+ lang++; /* skip NUL separator */\r
+\r
+ /* iTXt must have a language tag (possibly empty), two compression bytes,\r
+ translated keyword (possibly empty), and possibly some text after the\r
+ keyword */\r
+\r
+ if (lang >= png_ptr->chunkdata + slength - 3)\r
+ {\r
+ png_warning(png_ptr, "Truncated iTXt chunk");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ else\r
+ {\r
+ comp_flag = *lang++;\r
+ comp_type = *lang++;\r
+ }\r
+\r
+ for (lang_key = lang; *lang_key; lang_key++)\r
+ /* empty loop */ ;\r
+ lang_key++; /* skip NUL separator */\r
+\r
+ if (lang_key >= png_ptr->chunkdata + slength)\r
+ {\r
+ png_warning(png_ptr, "Truncated iTXt chunk");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ for (text = lang_key; *text; text++)\r
+ /* empty loop */ ;\r
+ text++; /* skip NUL separator */\r
+ if (text >= png_ptr->chunkdata + slength)\r
+ {\r
+ png_warning(png_ptr, "Malformed iTXt chunk");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+\r
+ prefix_len = text - png_ptr->chunkdata;\r
+\r
+ key=png_ptr->chunkdata;\r
+ if (comp_flag)\r
+ png_decompress_chunk(png_ptr, comp_type,\r
+ (size_t)length, prefix_len, &data_len);\r
+ else\r
+ data_len = png_strlen(png_ptr->chunkdata + prefix_len);\r
+ text_ptr = (png_textp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)png_sizeof(png_text));\r
+ if (text_ptr == NULL)\r
+ {\r
+ png_warning(png_ptr, "Not enough memory to process iTXt chunk.");\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ return;\r
+ }\r
+ text_ptr->compression = (int)comp_flag + 1;\r
+ text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key);\r
+ text_ptr->lang = png_ptr->chunkdata + (lang - key);\r
+ text_ptr->itxt_length = data_len;\r
+ text_ptr->text_length = 0;\r
+ text_ptr->key = png_ptr->chunkdata;\r
+ text_ptr->text = png_ptr->chunkdata + prefix_len;\r
+\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1);\r
+\r
+ png_free(png_ptr, text_ptr);\r
+ png_free(png_ptr, png_ptr->chunkdata);\r
+ png_ptr->chunkdata = NULL;\r
+ if (ret)\r
+ png_error(png_ptr, "Insufficient memory to store iTXt chunk.");\r
+}\r
+#endif\r
+\r
+/* This function is called when we haven't found a handler for a\r
+ chunk. If there isn't a problem with the chunk itself (ie bad\r
+ chunk name, CRC, or a critical chunk), the chunk is silently ignored\r
+ -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which\r
+ case it will be saved away to be written out later. */\r
+void /* PRIVATE */\r
+png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)\r
+{\r
+ png_uint_32 skip = 0;\r
+\r
+ png_debug(1, "in png_handle_unknown\n");\r
+\r
+ if (png_ptr->mode & PNG_HAVE_IDAT)\r
+ {\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IDAT;\r
+#endif\r
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ }\r
+\r
+ if (!(png_ptr->chunk_name[0] & 0x20))\r
+ {\r
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=\r
+ PNG_HANDLE_CHUNK_ALWAYS\r
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+ && png_ptr->read_user_chunk_fn == NULL\r
+#endif\r
+ )\r
+#endif\r
+ png_chunk_error(png_ptr, "unknown critical chunk");\r
+ }\r
+\r
+#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) ||\r
+ (png_ptr->read_user_chunk_fn != NULL))\r
+ {\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (length > (png_uint_32)65535L)\r
+ {\r
+ png_warning(png_ptr, "unknown chunk too large to fit in memory");\r
+ skip = length - (png_uint_32)65535L;\r
+ length = (png_uint_32)65535L;\r
+ }\r
+#endif\r
+ png_memcpy((png_charp)png_ptr->unknown_chunk.name,\r
+ (png_charp)png_ptr->chunk_name, \r
+ png_sizeof(png_ptr->unknown_chunk.name));\r
+ png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] = '\0';\r
+ png_ptr->unknown_chunk.size = (png_size_t)length;\r
+ if (length == 0)\r
+ png_ptr->unknown_chunk.data = NULL;\r
+ else\r
+ {\r
+ png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length);\r
+ png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);\r
+ }\r
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+ if (png_ptr->read_user_chunk_fn != NULL)\r
+ {\r
+ /* callback to user unknown chunk handler */\r
+ int ret;\r
+ ret = (*(png_ptr->read_user_chunk_fn))\r
+ (png_ptr, &png_ptr->unknown_chunk);\r
+ if (ret < 0)\r
+ png_chunk_error(png_ptr, "error in user chunk");\r
+ if (ret == 0)\r
+ {\r
+ if (!(png_ptr->chunk_name[0] & 0x20))\r
+ if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=\r
+ PNG_HANDLE_CHUNK_ALWAYS)\r
+ png_chunk_error(png_ptr, "unknown critical chunk");\r
+ png_set_unknown_chunks(png_ptr, info_ptr,\r
+ &png_ptr->unknown_chunk, 1);\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);\r
+ png_free(png_ptr, png_ptr->unknown_chunk.data);\r
+ png_ptr->unknown_chunk.data = NULL;\r
+ }\r
+ else\r
+#endif\r
+ skip = length;\r
+\r
+ png_crc_finish(png_ptr, skip);\r
+\r
+#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+ info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */\r
+#endif\r
+}\r
+\r
+/* This function is called to verify that a chunk name is valid.\r
+ This function can't have the "critical chunk check" incorporated\r
+ into it, since in the future we will need to be able to call user\r
+ functions to handle unknown critical chunks after we check that\r
+ the chunk name itself is valid. */\r
+\r
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))\r
+\r
+void /* PRIVATE */\r
+png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name)\r
+{\r
+ png_debug(1, "in png_check_chunk_name\n");\r
+ if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) ||\r
+ isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3]))\r
+ {\r
+ png_chunk_error(png_ptr, "invalid chunk type");\r
+ }\r
+}\r
+\r
+/* Combines the row recently read in with the existing pixels in the\r
+ row. This routine takes care of alpha and transparency if requested.\r
+ This routine also handles the two methods of progressive display\r
+ of interlaced images, depending on the mask value.\r
+ The mask value describes which pixels are to be combined with\r
+ the row. The pattern always repeats every 8 pixels, so just 8\r
+ bits are needed. A one indicates the pixel is to be combined,\r
+ a zero indicates the pixel is to be skipped. This is in addition\r
+ to any alpha or transparency value associated with the pixel. If\r
+ you want all pixels to be combined, pass 0xff (255) in mask. */\r
+\r
+void /* PRIVATE */\r
+png_combine_row(png_structp png_ptr, png_bytep row, int mask)\r
+{\r
+ png_debug(1, "in png_combine_row\n");\r
+ if (mask == 0xff)\r
+ {\r
+ png_memcpy(row, png_ptr->row_buf + 1,\r
+ PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width));\r
+ }\r
+ else\r
+ {\r
+ switch (png_ptr->row_info.pixel_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ png_bytep sp = png_ptr->row_buf + 1;\r
+ png_bytep dp = row;\r
+ int s_inc, s_start, s_end;\r
+ int m = 0x80;\r
+ int shift;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = png_ptr->width;\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ {\r
+ s_start = 0;\r
+ s_end = 7;\r
+ s_inc = 1;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ s_start = 7;\r
+ s_end = 0;\r
+ s_inc = -1;\r
+ }\r
+\r
+ shift = s_start;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (m & mask)\r
+ {\r
+ int value;\r
+\r
+ value = (*sp >> shift) & 0x01;\r
+ *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff);\r
+ *dp |= (png_byte)(value << shift);\r
+ }\r
+\r
+ if (shift == s_end)\r
+ {\r
+ shift = s_start;\r
+ sp++;\r
+ dp++;\r
+ }\r
+ else\r
+ shift += s_inc;\r
+\r
+ if (m == 1)\r
+ m = 0x80;\r
+ else\r
+ m >>= 1;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ png_bytep sp = png_ptr->row_buf + 1;\r
+ png_bytep dp = row;\r
+ int s_start, s_end, s_inc;\r
+ int m = 0x80;\r
+ int shift;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = png_ptr->width;\r
+ int value;\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ {\r
+ s_start = 0;\r
+ s_end = 6;\r
+ s_inc = 2;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ s_start = 6;\r
+ s_end = 0;\r
+ s_inc = -2;\r
+ }\r
+\r
+ shift = s_start;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (m & mask)\r
+ {\r
+ value = (*sp >> shift) & 0x03;\r
+ *dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff);\r
+ *dp |= (png_byte)(value << shift);\r
+ }\r
+\r
+ if (shift == s_end)\r
+ {\r
+ shift = s_start;\r
+ sp++;\r
+ dp++;\r
+ }\r
+ else\r
+ shift += s_inc;\r
+ if (m == 1)\r
+ m = 0x80;\r
+ else\r
+ m >>= 1;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep sp = png_ptr->row_buf + 1;\r
+ png_bytep dp = row;\r
+ int s_start, s_end, s_inc;\r
+ int m = 0x80;\r
+ int shift;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = png_ptr->width;\r
+ int value;\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ {\r
+ s_start = 0;\r
+ s_end = 4;\r
+ s_inc = 4;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ s_start = 4;\r
+ s_end = 0;\r
+ s_inc = -4;\r
+ }\r
+ shift = s_start;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (m & mask)\r
+ {\r
+ value = (*sp >> shift) & 0xf;\r
+ *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff);\r
+ *dp |= (png_byte)(value << shift);\r
+ }\r
+\r
+ if (shift == s_end)\r
+ {\r
+ shift = s_start;\r
+ sp++;\r
+ dp++;\r
+ }\r
+ else\r
+ shift += s_inc;\r
+ if (m == 1)\r
+ m = 0x80;\r
+ else\r
+ m >>= 1;\r
+ }\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ png_bytep sp = png_ptr->row_buf + 1;\r
+ png_bytep dp = row;\r
+ png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3);\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = png_ptr->width;\r
+ png_byte m = 0x80;\r
+\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (m & mask)\r
+ {\r
+ png_memcpy(dp, sp, pixel_bytes);\r
+ }\r
+\r
+ sp += pixel_bytes;\r
+ dp += pixel_bytes;\r
+\r
+ if (m == 1)\r
+ m = 0x80;\r
+ else\r
+ m >>= 1;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+/* OLD pre-1.0.9 interface:\r
+void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,\r
+ png_uint_32 transformations)\r
+ */\r
+void /* PRIVATE */\r
+png_do_read_interlace(png_structp png_ptr)\r
+{\r
+ png_row_infop row_info = &(png_ptr->row_info);\r
+ png_bytep row = png_ptr->row_buf + 1;\r
+ int pass = png_ptr->pass;\r
+ png_uint_32 transformations = png_ptr->transformations;\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+ /* offset to next interlace block */\r
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+#endif\r
+\r
+ png_debug(1, "in png_do_read_interlace\n");\r
+ if (row != NULL && row_info != NULL)\r
+ {\r
+ png_uint_32 final_width;\r
+\r
+ final_width = row_info->width * png_pass_inc[pass];\r
+\r
+ switch (row_info->pixel_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);\r
+ png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);\r
+ int sshift, dshift;\r
+ int s_start, s_end, s_inc;\r
+ int jstop = png_pass_inc[pass];\r
+ png_byte v;\r
+ png_uint_32 i;\r
+ int j;\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (transformations & PNG_PACKSWAP)\r
+ {\r
+ sshift = (int)((row_info->width + 7) & 0x07);\r
+ dshift = (int)((final_width + 7) & 0x07);\r
+ s_start = 7;\r
+ s_end = 0;\r
+ s_inc = -1;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sshift = 7 - (int)((row_info->width + 7) & 0x07);\r
+ dshift = 7 - (int)((final_width + 7) & 0x07);\r
+ s_start = 0;\r
+ s_end = 7;\r
+ s_inc = 1;\r
+ }\r
+\r
+ for (i = 0; i < row_info->width; i++)\r
+ {\r
+ v = (png_byte)((*sp >> sshift) & 0x01);\r
+ for (j = 0; j < jstop; j++)\r
+ {\r
+ *dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff);\r
+ *dp |= (png_byte)(v << dshift);\r
+ if (dshift == s_end)\r
+ {\r
+ dshift = s_start;\r
+ dp--;\r
+ }\r
+ else\r
+ dshift += s_inc;\r
+ }\r
+ if (sshift == s_end)\r
+ {\r
+ sshift = s_start;\r
+ sp--;\r
+ }\r
+ else\r
+ sshift += s_inc;\r
+ }\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);\r
+ png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);\r
+ int sshift, dshift;\r
+ int s_start, s_end, s_inc;\r
+ int jstop = png_pass_inc[pass];\r
+ png_uint_32 i;\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (transformations & PNG_PACKSWAP)\r
+ {\r
+ sshift = (int)(((row_info->width + 3) & 0x03) << 1);\r
+ dshift = (int)(((final_width + 3) & 0x03) << 1);\r
+ s_start = 6;\r
+ s_end = 0;\r
+ s_inc = -2;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);\r
+ dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);\r
+ s_start = 0;\r
+ s_end = 6;\r
+ s_inc = 2;\r
+ }\r
+\r
+ for (i = 0; i < row_info->width; i++)\r
+ {\r
+ png_byte v;\r
+ int j;\r
+\r
+ v = (png_byte)((*sp >> sshift) & 0x03);\r
+ for (j = 0; j < jstop; j++)\r
+ {\r
+ *dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff);\r
+ *dp |= (png_byte)(v << dshift);\r
+ if (dshift == s_end)\r
+ {\r
+ dshift = s_start;\r
+ dp--;\r
+ }\r
+ else\r
+ dshift += s_inc;\r
+ }\r
+ if (sshift == s_end)\r
+ {\r
+ sshift = s_start;\r
+ sp--;\r
+ }\r
+ else\r
+ sshift += s_inc;\r
+ }\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);\r
+ png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);\r
+ int sshift, dshift;\r
+ int s_start, s_end, s_inc;\r
+ png_uint_32 i;\r
+ int jstop = png_pass_inc[pass];\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (transformations & PNG_PACKSWAP)\r
+ {\r
+ sshift = (int)(((row_info->width + 1) & 0x01) << 2);\r
+ dshift = (int)(((final_width + 1) & 0x01) << 2);\r
+ s_start = 4;\r
+ s_end = 0;\r
+ s_inc = -4;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);\r
+ dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);\r
+ s_start = 0;\r
+ s_end = 4;\r
+ s_inc = 4;\r
+ }\r
+\r
+ for (i = 0; i < row_info->width; i++)\r
+ {\r
+ png_byte v = (png_byte)((*sp >> sshift) & 0xf);\r
+ int j;\r
+\r
+ for (j = 0; j < jstop; j++)\r
+ {\r
+ *dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff);\r
+ *dp |= (png_byte)(v << dshift);\r
+ if (dshift == s_end)\r
+ {\r
+ dshift = s_start;\r
+ dp--;\r
+ }\r
+ else\r
+ dshift += s_inc;\r
+ }\r
+ if (sshift == s_end)\r
+ {\r
+ sshift = s_start;\r
+ sp--;\r
+ }\r
+ else\r
+ sshift += s_inc;\r
+ }\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ png_size_t pixel_bytes = (row_info->pixel_depth >> 3);\r
+ png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes;\r
+ png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;\r
+\r
+ int jstop = png_pass_inc[pass];\r
+ png_uint_32 i;\r
+\r
+ for (i = 0; i < row_info->width; i++)\r
+ {\r
+ png_byte v[8];\r
+ int j;\r
+\r
+ png_memcpy(v, sp, pixel_bytes);\r
+ for (j = 0; j < jstop; j++)\r
+ {\r
+ png_memcpy(dp, v, pixel_bytes);\r
+ dp -= pixel_bytes;\r
+ }\r
+ sp -= pixel_bytes;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ row_info->width = final_width;\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);\r
+ }\r
+#if !defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ transformations = transformations; /* silence compiler warning */\r
+#endif\r
+}\r
+#endif /* PNG_READ_INTERLACING_SUPPORTED */\r
+\r
+void /* PRIVATE */\r
+png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,\r
+ png_bytep prev_row, int filter)\r
+{\r
+ png_debug(1, "in png_read_filter_row\n");\r
+ png_debug2(2, "row = %lu, filter = %d\n", png_ptr->row_number, filter);\r
+ switch (filter)\r
+ {\r
+ case PNG_FILTER_VALUE_NONE:\r
+ break;\r
+ case PNG_FILTER_VALUE_SUB:\r
+ {\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;\r
+ png_bytep rp = row + bpp;\r
+ png_bytep lp = row;\r
+\r
+ for (i = bpp; i < istop; i++)\r
+ {\r
+ *rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff);\r
+ rp++;\r
+ }\r
+ break;\r
+ }\r
+ case PNG_FILTER_VALUE_UP:\r
+ {\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+ png_bytep rp = row;\r
+ png_bytep pp = prev_row;\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);\r
+ rp++;\r
+ }\r
+ break;\r
+ }\r
+ case PNG_FILTER_VALUE_AVG:\r
+ {\r
+ png_uint_32 i;\r
+ png_bytep rp = row;\r
+ png_bytep pp = prev_row;\r
+ png_bytep lp = row;\r
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;\r
+ png_uint_32 istop = row_info->rowbytes - bpp;\r
+\r
+ for (i = 0; i < bpp; i++)\r
+ {\r
+ *rp = (png_byte)(((int)(*rp) +\r
+ ((int)(*pp++) / 2 )) & 0xff);\r
+ rp++;\r
+ }\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ *rp = (png_byte)(((int)(*rp) +\r
+ (int)(*pp++ + *lp++) / 2 ) & 0xff);\r
+ rp++;\r
+ }\r
+ break;\r
+ }\r
+ case PNG_FILTER_VALUE_PAETH:\r
+ {\r
+ png_uint_32 i;\r
+ png_bytep rp = row;\r
+ png_bytep pp = prev_row;\r
+ png_bytep lp = row;\r
+ png_bytep cp = prev_row;\r
+ png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3;\r
+ png_uint_32 istop=row_info->rowbytes - bpp;\r
+\r
+ for (i = 0; i < bpp; i++)\r
+ {\r
+ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);\r
+ rp++;\r
+ }\r
+\r
+ for (i = 0; i < istop; i++) /* use leftover rp,pp */\r
+ {\r
+ int a, b, c, pa, pb, pc, p;\r
+\r
+ a = *lp++;\r
+ b = *pp++;\r
+ c = *cp++;\r
+\r
+ p = b - c;\r
+ pc = a - c;\r
+\r
+#ifdef PNG_USE_ABS\r
+ pa = abs(p);\r
+ pb = abs(pc);\r
+ pc = abs(p + pc);\r
+#else\r
+ pa = p < 0 ? -p : p;\r
+ pb = pc < 0 ? -pc : pc;\r
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;\r
+#endif\r
+\r
+ /*\r
+ if (pa <= pb && pa <= pc)\r
+ p = a;\r
+ else if (pb <= pc)\r
+ p = b;\r
+ else\r
+ p = c;\r
+ */\r
+\r
+ p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;\r
+\r
+ *rp = (png_byte)(((int)(*rp) + p) & 0xff);\r
+ rp++;\r
+ }\r
+ break;\r
+ }\r
+ default:\r
+ png_warning(png_ptr, "Ignoring bad adaptive filter type");\r
+ *row = 0;\r
+ break;\r
+ }\r
+}\r
+\r
+void /* PRIVATE */\r
+png_read_finish_row(png_structp png_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+ /* start of interlace block in the y direction */\r
+ PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+ /* offset to next interlace block in the y direction */\r
+ PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};\r
+#endif /* PNG_READ_INTERLACING_SUPPORTED */\r
+#endif\r
+\r
+ png_debug(1, "in png_read_finish_row\n");\r
+ png_ptr->row_number++;\r
+ if (png_ptr->row_number < png_ptr->num_rows)\r
+ return;\r
+\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+ if (png_ptr->interlaced)\r
+ {\r
+ png_ptr->row_number = 0;\r
+ png_memset_check(png_ptr, png_ptr->prev_row, 0,\r
+ png_ptr->rowbytes + 1);\r
+ do\r
+ {\r
+ png_ptr->pass++;\r
+ if (png_ptr->pass >= 7)\r
+ break;\r
+ png_ptr->iwidth = (png_ptr->width +\r
+ png_pass_inc[png_ptr->pass] - 1 -\r
+ png_pass_start[png_ptr->pass]) /\r
+ png_pass_inc[png_ptr->pass];\r
+\r
+ png_ptr->irowbytes = PNG_ROWBYTES(png_ptr->pixel_depth,\r
+ png_ptr->iwidth) + 1;\r
+\r
+ if (!(png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ png_ptr->num_rows = (png_ptr->height +\r
+ png_pass_yinc[png_ptr->pass] - 1 -\r
+ png_pass_ystart[png_ptr->pass]) /\r
+ png_pass_yinc[png_ptr->pass];\r
+ if (!(png_ptr->num_rows))\r
+ continue;\r
+ }\r
+ else /* if (png_ptr->transformations & PNG_INTERLACE) */\r
+ break;\r
+ } while (png_ptr->iwidth == 0);\r
+\r
+ if (png_ptr->pass < 7)\r
+ return;\r
+ }\r
+#endif /* PNG_READ_INTERLACING_SUPPORTED */\r
+\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))\r
+ {\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_CONST PNG_IDAT;\r
+#endif\r
+ char extra;\r
+ int ret;\r
+\r
+ png_ptr->zstream.next_out = (Byte *)&extra;\r
+ png_ptr->zstream.avail_out = (uInt)1;\r
+ for (;;)\r
+ {\r
+ if (!(png_ptr->zstream.avail_in))\r
+ {\r
+ while (!png_ptr->idat_size)\r
+ {\r
+ png_byte chunk_length[4];\r
+\r
+ png_crc_finish(png_ptr, 0);\r
+\r
+ png_read_data(png_ptr, chunk_length, 4);\r
+ png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length);\r
+ png_reset_crc(png_ptr);\r
+ png_crc_read(png_ptr, png_ptr->chunk_name, 4);\r
+ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4))\r
+ png_error(png_ptr, "Not enough image data");\r
+\r
+ }\r
+ png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_in = png_ptr->zbuf;\r
+ if (png_ptr->zbuf_size > png_ptr->idat_size)\r
+ png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;\r
+ png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in);\r
+ png_ptr->idat_size -= png_ptr->zstream.avail_in;\r
+ }\r
+ ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);\r
+ if (ret == Z_STREAM_END)\r
+ {\r
+ if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in ||\r
+ png_ptr->idat_size)\r
+ png_warning(png_ptr, "Extra compressed data");\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;\r
+ break;\r
+ }\r
+ if (ret != Z_OK)\r
+ png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :\r
+ "Decompression Error");\r
+\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ png_warning(png_ptr, "Extra compressed data.");\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;\r
+ break;\r
+ }\r
+\r
+ }\r
+ png_ptr->zstream.avail_out = 0;\r
+ }\r
+\r
+ if (png_ptr->idat_size || png_ptr->zstream.avail_in)\r
+ png_warning(png_ptr, "Extra compression data");\r
+\r
+ inflateReset(&png_ptr->zstream);\r
+\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+}\r
+\r
+void /* PRIVATE */\r
+png_read_start_row(png_structp png_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+ /* start of interlace block in the y direction */\r
+ PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+ /* offset to next interlace block in the y direction */\r
+ PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};\r
+#endif\r
+#endif\r
+\r
+ int max_pixel_depth;\r
+ png_size_t row_bytes;\r
+\r
+ png_debug(1, "in png_read_start_row\n");\r
+ png_ptr->zstream.avail_in = 0;\r
+ png_init_read_transformations(png_ptr);\r
+#ifdef PNG_READ_INTERLACING_SUPPORTED\r
+ if (png_ptr->interlaced)\r
+ {\r
+ if (!(png_ptr->transformations & PNG_INTERLACE))\r
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -\r
+ png_pass_ystart[0]) / png_pass_yinc[0];\r
+ else\r
+ png_ptr->num_rows = png_ptr->height;\r
+\r
+ png_ptr->iwidth = (png_ptr->width +\r
+ png_pass_inc[png_ptr->pass] - 1 -\r
+ png_pass_start[png_ptr->pass]) /\r
+ png_pass_inc[png_ptr->pass];\r
+\r
+ png_ptr->irowbytes =\r
+ PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1;\r
+ }\r
+ else\r
+#endif /* PNG_READ_INTERLACING_SUPPORTED */\r
+ {\r
+ png_ptr->num_rows = png_ptr->height;\r
+ png_ptr->iwidth = png_ptr->width;\r
+ png_ptr->irowbytes = png_ptr->rowbytes + 1;\r
+ }\r
+ max_pixel_depth = png_ptr->pixel_depth;\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED)\r
+ if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8)\r
+ max_pixel_depth = 8;\r
+#endif\r
+\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_EXPAND)\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (png_ptr->num_trans)\r
+ max_pixel_depth = 32;\r
+ else\r
+ max_pixel_depth = 24;\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ if (max_pixel_depth < 8)\r
+ max_pixel_depth = 8;\r
+ if (png_ptr->num_trans)\r
+ max_pixel_depth *= 2;\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ if (png_ptr->num_trans)\r
+ {\r
+ max_pixel_depth *= 4;\r
+ max_pixel_depth /= 3;\r
+ }\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+ if (png_ptr->transformations & (PNG_FILLER))\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ max_pixel_depth = 32;\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ if (max_pixel_depth <= 8)\r
+ max_pixel_depth = 16;\r
+ else\r
+ max_pixel_depth = 32;\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ if (max_pixel_depth <= 32)\r
+ max_pixel_depth = 32;\r
+ else\r
+ max_pixel_depth = 64;\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_GRAY_TO_RGB)\r
+ {\r
+ if (\r
+#if defined(PNG_READ_EXPAND_SUPPORTED)\r
+ (png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) ||\r
+#endif\r
+#if defined(PNG_READ_FILLER_SUPPORTED)\r
+ (png_ptr->transformations & (PNG_FILLER)) ||\r
+#endif\r
+ png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ if (max_pixel_depth <= 16)\r
+ max_pixel_depth = 32;\r
+ else\r
+ max_pixel_depth = 64;\r
+ }\r
+ else\r
+ {\r
+ if (max_pixel_depth <= 8)\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ max_pixel_depth = 32;\r
+ else\r
+ max_pixel_depth = 24;\r
+ }\r
+ else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ max_pixel_depth = 64;\r
+ else\r
+ max_pixel_depth = 48;\r
+ }\r
+ }\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \\r
+defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)\r
+ {\r
+ int user_pixel_depth = png_ptr->user_transform_depth*\r
+ png_ptr->user_transform_channels;\r
+ if (user_pixel_depth > max_pixel_depth)\r
+ max_pixel_depth=user_pixel_depth;\r
+ }\r
+#endif\r
+\r
+ /* align the width on the next larger 8 pixels. Mainly used\r
+ for interlacing */\r
+ row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));\r
+ /* calculate the maximum bytes needed, adding a byte and a pixel\r
+ for safety's sake */\r
+ row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +\r
+ 1 + ((max_pixel_depth + 7) >> 3);\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if (row_bytes > (png_uint_32)65536L)\r
+ png_error(png_ptr, "This image requires a row greater than 64KB");\r
+#endif\r
+\r
+ if (row_bytes + 64 > png_ptr->old_big_row_buf_size)\r
+ {\r
+ png_free(png_ptr, png_ptr->big_row_buf);\r
+ png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64);\r
+ png_ptr->row_buf = png_ptr->big_row_buf+32;\r
+ png_ptr->old_big_row_buf_size = row_bytes+64;\r
+ }\r
+\r
+#ifdef PNG_MAX_MALLOC_64K\r
+ if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L)\r
+ png_error(png_ptr, "This image requires a row greater than 64KB");\r
+#endif\r
+ if ((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1))\r
+ png_error(png_ptr, "Row has too many bytes to allocate in memory.");\r
+\r
+ if (png_ptr->rowbytes+1 > png_ptr->old_prev_row_size)\r
+ {\r
+ png_free(png_ptr, png_ptr->prev_row);\r
+ png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(\r
+ png_ptr->rowbytes + 1));\r
+ png_ptr->old_prev_row_size = png_ptr->rowbytes+1;\r
+ }\r
+\r
+ png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1);\r
+\r
+ png_debug1(3, "width = %lu,\n", png_ptr->width);\r
+ png_debug1(3, "height = %lu,\n", png_ptr->height);\r
+ png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth);\r
+ png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows);\r
+ png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes);\r
+ png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes);\r
+\r
+ png_ptr->flags |= PNG_FLAG_ROW_INIT;\r
+}\r
+#endif /* PNG_READ_SUPPORTED */\r
--- /dev/null
+\r
+/* pngset.c - storage of image information into info struct\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * The functions here are used during reads to store data from the file\r
+ * into the info struct, and during writes to store application data\r
+ * into the info struct for writing into the file. This abstracts the\r
+ * info struct and allows us to change the structure in the future.\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+#if defined(PNG_bKGD_SUPPORTED)\r
+void PNGAPI\r
+png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "bKGD");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));\r
+ info_ptr->valid |= PNG_INFO_bKGD;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+void PNGAPI\r
+png_set_cHRM(png_structp png_ptr, png_infop info_ptr,\r
+ double white_x, double white_y, double red_x, double red_y,\r
+ double green_x, double green_y, double blue_x, double blue_y)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "cHRM");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||\r
+ blue_x || blue_y))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set all-zero chromaticity values");\r
+ return;\r
+ }\r
+ if (white_x < 0.0 || white_y < 0.0 ||\r
+ red_x < 0.0 || red_y < 0.0 ||\r
+ green_x < 0.0 || green_y < 0.0 ||\r
+ blue_x < 0.0 || blue_y < 0.0)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set negative chromaticity value");\r
+ return;\r
+ }\r
+ if (white_x > 21474.83 || white_y > 21474.83 ||\r
+ red_x > 21474.83 || red_y > 21474.83 ||\r
+ green_x > 21474.83 || green_y > 21474.83 ||\r
+ blue_x > 21474.83 || blue_y > 21474.83)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set chromaticity value exceeding 21474.83");\r
+ return;\r
+ }\r
+\r
+ info_ptr->x_white = (float)white_x;\r
+ info_ptr->y_white = (float)white_y;\r
+ info_ptr->x_red = (float)red_x;\r
+ info_ptr->y_red = (float)red_y;\r
+ info_ptr->x_green = (float)green_x;\r
+ info_ptr->y_green = (float)green_y;\r
+ info_ptr->x_blue = (float)blue_x;\r
+ info_ptr->y_blue = (float)blue_y;\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5);\r
+ info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5);\r
+ info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5);\r
+ info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5);\r
+ info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5);\r
+ info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5);\r
+ info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5);\r
+ info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5);\r
+#endif\r
+ info_ptr->valid |= PNG_INFO_cHRM;\r
+}\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+void PNGAPI\r
+png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,\r
+ png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x,\r
+ png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y,\r
+ png_fixed_point blue_x, png_fixed_point blue_y)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "cHRM");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ if (!(white_x || white_y || red_x || red_y || green_x || green_y ||\r
+ blue_x || blue_y))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set all-zero chromaticity values");\r
+ return;\r
+ }\r
+ if (white_x < 0 || white_y < 0 ||\r
+ red_x < 0 || red_y < 0 ||\r
+ green_x < 0 || green_y < 0 ||\r
+ blue_x < 0 || blue_y < 0)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set negative chromaticity value");\r
+ return;\r
+ }\r
+ if (white_x > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ white_y > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ red_x > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ red_y > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ green_x > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ green_y > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ blue_x > (png_fixed_point) PNG_UINT_31_MAX ||\r
+ blue_y > (png_fixed_point) PNG_UINT_31_MAX )\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to set chromaticity value exceeding 21474.83");\r
+ return;\r
+ }\r
+ info_ptr->int_x_white = white_x;\r
+ info_ptr->int_y_white = white_y;\r
+ info_ptr->int_x_red = red_x;\r
+ info_ptr->int_y_red = red_y;\r
+ info_ptr->int_x_green = green_x;\r
+ info_ptr->int_y_green = green_y;\r
+ info_ptr->int_x_blue = blue_x;\r
+ info_ptr->int_y_blue = blue_y;\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ info_ptr->x_white = (float)(white_x/100000.);\r
+ info_ptr->y_white = (float)(white_y/100000.);\r
+ info_ptr->x_red = (float)( red_x/100000.);\r
+ info_ptr->y_red = (float)( red_y/100000.);\r
+ info_ptr->x_green = (float)(green_x/100000.);\r
+ info_ptr->y_green = (float)(green_y/100000.);\r
+ info_ptr->x_blue = (float)( blue_x/100000.);\r
+ info_ptr->y_blue = (float)( blue_y/100000.);\r
+#endif\r
+ info_ptr->valid |= PNG_INFO_cHRM;\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+void PNGAPI\r
+png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)\r
+{\r
+ double gamma;\r
+ png_debug1(1, "in %s storage function\n", "gAMA");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ /* Check for overflow */\r
+ if (file_gamma > 21474.83)\r
+ {\r
+ png_warning(png_ptr, "Limiting gamma to 21474.83");\r
+ gamma=21474.83;\r
+ }\r
+ else\r
+ gamma = file_gamma;\r
+ info_ptr->gamma = (float)gamma;\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ info_ptr->int_gamma = (int)(gamma*100000.+.5);\r
+#endif\r
+ info_ptr->valid |= PNG_INFO_gAMA;\r
+ if (gamma == 0.0)\r
+ png_warning(png_ptr, "Setting gamma=0");\r
+}\r
+#endif\r
+void PNGAPI\r
+png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point\r
+ int_gamma)\r
+{\r
+ png_fixed_point gamma;\r
+\r
+ png_debug1(1, "in %s storage function\n", "gAMA");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX)\r
+ {\r
+ png_warning(png_ptr, "Limiting gamma to 21474.83");\r
+ gamma=PNG_UINT_31_MAX;\r
+ }\r
+ else\r
+ {\r
+ if (int_gamma < 0)\r
+ {\r
+ png_warning(png_ptr, "Setting negative gamma to zero");\r
+ gamma = 0;\r
+ }\r
+ else\r
+ gamma = int_gamma;\r
+ }\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ info_ptr->gamma = (float)(gamma/100000.);\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ info_ptr->int_gamma = gamma;\r
+#endif\r
+ info_ptr->valid |= PNG_INFO_gAMA;\r
+ if (gamma == 0)\r
+ png_warning(png_ptr, "Setting gamma=0");\r
+}\r
+#endif\r
+\r
+#if defined(PNG_hIST_SUPPORTED)\r
+void PNGAPI\r
+png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)\r
+{\r
+ int i;\r
+\r
+ png_debug1(1, "in %s storage function\n", "hIST");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+ if (info_ptr->num_palette == 0 || info_ptr->num_palette\r
+ > PNG_MAX_PALETTE_LENGTH)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Invalid palette size, hIST allocation skipped.");\r
+ return;\r
+ }\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);\r
+#endif\r
+ /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version\r
+ 1.2.1 */\r
+ png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));\r
+ if (png_ptr->hist == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory for hIST chunk data.");\r
+ return;\r
+ }\r
+\r
+ for (i = 0; i < info_ptr->num_palette; i++)\r
+ png_ptr->hist[i] = hist[i];\r
+ info_ptr->hist = png_ptr->hist;\r
+ info_ptr->valid |= PNG_INFO_hIST;\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_HIST;\r
+#else\r
+ png_ptr->flags |= PNG_FLAG_FREE_HIST;\r
+#endif\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_set_IHDR(png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 width, png_uint_32 height, int bit_depth,\r
+ int color_type, int interlace_type, int compression_type,\r
+ int filter_type)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "IHDR");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ /* check for width and height valid values */\r
+ if (width == 0 || height == 0)\r
+ png_error(png_ptr, "Image width or height is zero in IHDR");\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ if (width > png_ptr->user_width_max || height > png_ptr->user_height_max)\r
+ png_error(png_ptr, "image size exceeds user limits in IHDR");\r
+#else\r
+ if (width > PNG_USER_WIDTH_MAX || height > PNG_USER_HEIGHT_MAX)\r
+ png_error(png_ptr, "image size exceeds user limits in IHDR");\r
+#endif\r
+ if (width > PNG_UINT_31_MAX || height > PNG_UINT_31_MAX)\r
+ png_error(png_ptr, "Invalid image size in IHDR");\r
+ if ( width > (PNG_UINT_32_MAX\r
+ >> 3) /* 8-byte RGBA pixels */\r
+ - 64 /* bigrowbuf hack */\r
+ - 1 /* filter byte */\r
+ - 7*8 /* rounding of width to multiple of 8 pixels */\r
+ - 8) /* extra max_pixel_depth pad */\r
+ png_warning(png_ptr, "Width is too large for libpng to process pixels");\r
+\r
+ /* check other values */\r
+ if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&\r
+ bit_depth != 8 && bit_depth != 16)\r
+ png_error(png_ptr, "Invalid bit depth in IHDR");\r
+\r
+ if (color_type < 0 || color_type == 1 ||\r
+ color_type == 5 || color_type > 6)\r
+ png_error(png_ptr, "Invalid color type in IHDR");\r
+\r
+ if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||\r
+ ((color_type == PNG_COLOR_TYPE_RGB ||\r
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||\r
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))\r
+ png_error(png_ptr, "Invalid color type/bit depth combination in IHDR");\r
+\r
+ if (interlace_type >= PNG_INTERLACE_LAST)\r
+ png_error(png_ptr, "Unknown interlace method in IHDR");\r
+\r
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)\r
+ png_error(png_ptr, "Unknown compression method in IHDR");\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ /* Accept filter_method 64 (intrapixel differencing) only if\r
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and\r
+ * 2. Libpng did not read a PNG signature (this filter_method is only\r
+ * used in PNG datastreams that are embedded in MNG datastreams) and\r
+ * 3. The application called png_permit_mng_features with a mask that\r
+ * included PNG_FLAG_MNG_FILTER_64 and\r
+ * 4. The filter_method is 64 and\r
+ * 5. The color_type is RGB or RGBA\r
+ */\r
+ if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted)\r
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");\r
+ if (filter_type != PNG_FILTER_TYPE_BASE)\r
+ {\r
+ if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&\r
+ ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&\r
+ (color_type == PNG_COLOR_TYPE_RGB ||\r
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA)))\r
+ png_error(png_ptr, "Unknown filter method in IHDR");\r
+ if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)\r
+ png_warning(png_ptr, "Invalid filter method in IHDR");\r
+ }\r
+#else\r
+ if (filter_type != PNG_FILTER_TYPE_BASE)\r
+ png_error(png_ptr, "Unknown filter method in IHDR");\r
+#endif\r
+\r
+ info_ptr->width = width;\r
+ info_ptr->height = height;\r
+ info_ptr->bit_depth = (png_byte)bit_depth;\r
+ info_ptr->color_type =(png_byte) color_type;\r
+ info_ptr->compression_type = (png_byte)compression_type;\r
+ info_ptr->filter_type = (png_byte)filter_type;\r
+ info_ptr->interlace_type = (png_byte)interlace_type;\r
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ info_ptr->channels = 1;\r
+ else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR)\r
+ info_ptr->channels = 3;\r
+ else\r
+ info_ptr->channels = 1;\r
+ if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)\r
+ info_ptr->channels++;\r
+ info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);\r
+\r
+ /* check for potential overflow */\r
+ if (width > (PNG_UINT_32_MAX\r
+ >> 3) /* 8-byte RGBA pixels */\r
+ - 64 /* bigrowbuf hack */\r
+ - 1 /* filter byte */\r
+ - 7*8 /* rounding of width to multiple of 8 pixels */\r
+ - 8) /* extra max_pixel_depth pad */\r
+ info_ptr->rowbytes = (png_size_t)0;\r
+ else\r
+ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);\r
+}\r
+\r
+#if defined(PNG_oFFs_SUPPORTED)\r
+void PNGAPI\r
+png_set_oFFs(png_structp png_ptr, png_infop info_ptr,\r
+ png_int_32 offset_x, png_int_32 offset_y, int unit_type)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "oFFs");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ info_ptr->x_offset = offset_x;\r
+ info_ptr->y_offset = offset_y;\r
+ info_ptr->offset_unit_type = (png_byte)unit_type;\r
+ info_ptr->valid |= PNG_INFO_oFFs;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_pCAL_SUPPORTED)\r
+void PNGAPI\r
+png_set_pCAL(png_structp png_ptr, png_infop info_ptr,\r
+ png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,\r
+ png_charp units, png_charpp params)\r
+{\r
+ png_uint_32 length;\r
+ int i;\r
+\r
+ png_debug1(1, "in %s storage function\n", "pCAL");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ length = png_strlen(purpose) + 1;\r
+ png_debug1(3, "allocating purpose for info (%lu bytes)\n",\r
+ (unsigned long)length);\r
+ info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (info_ptr->pcal_purpose == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory for pCAL purpose.");\r
+ return;\r
+ }\r
+ png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length);\r
+\r
+ png_debug(3, "storing X0, X1, type, and nparams in info\n");\r
+ info_ptr->pcal_X0 = X0;\r
+ info_ptr->pcal_X1 = X1;\r
+ info_ptr->pcal_type = (png_byte)type;\r
+ info_ptr->pcal_nparams = (png_byte)nparams;\r
+\r
+ length = png_strlen(units) + 1;\r
+ png_debug1(3, "allocating units for info (%lu bytes)\n",\r
+ (unsigned long)length);\r
+ info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (info_ptr->pcal_units == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory for pCAL units.");\r
+ return;\r
+ }\r
+ png_memcpy(info_ptr->pcal_units, units, (png_size_t)length);\r
+\r
+ info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)((nparams + 1) * png_sizeof(png_charp)));\r
+ if (info_ptr->pcal_params == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory for pCAL params.");\r
+ return;\r
+ }\r
+\r
+ info_ptr->pcal_params[nparams] = NULL;\r
+\r
+ for (i = 0; i < nparams; i++)\r
+ {\r
+ length = png_strlen(params[i]) + 1;\r
+ png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i,\r
+ (unsigned long)length);\r
+ info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (info_ptr->pcal_params[i] == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory for pCAL parameter.");\r
+ return;\r
+ }\r
+ png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length);\r
+ }\r
+\r
+ info_ptr->valid |= PNG_INFO_pCAL;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_PCAL;\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+void PNGAPI\r
+png_set_sCAL(png_structp png_ptr, png_infop info_ptr,\r
+ int unit, double width, double height)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "sCAL");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ info_ptr->scal_unit = (png_byte)unit;\r
+ info_ptr->scal_pixel_width = width;\r
+ info_ptr->scal_pixel_height = height;\r
+\r
+ info_ptr->valid |= PNG_INFO_sCAL;\r
+}\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+void PNGAPI\r
+png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr,\r
+ int unit, png_charp swidth, png_charp sheight)\r
+{\r
+ png_uint_32 length;\r
+\r
+ png_debug1(1, "in %s storage function\n", "sCAL");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ info_ptr->scal_unit = (png_byte)unit;\r
+\r
+ length = png_strlen(swidth) + 1;\r
+ png_debug1(3, "allocating unit for info (%u bytes)\n",\r
+ (unsigned int)length);\r
+ info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (info_ptr->scal_s_width == NULL)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Memory allocation failed while processing sCAL.");\r
+ return;\r
+ }\r
+ png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length);\r
+\r
+ length = png_strlen(sheight) + 1;\r
+ png_debug1(3, "allocating unit for info (%u bytes)\n",\r
+ (unsigned int)length);\r
+ info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (info_ptr->scal_s_height == NULL)\r
+ {\r
+ png_free (png_ptr, info_ptr->scal_s_width);\r
+ info_ptr->scal_s_width = NULL;\r
+ png_warning(png_ptr,\r
+ "Memory allocation failed while processing sCAL.");\r
+ return;\r
+ }\r
+ png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length);\r
+ info_ptr->valid |= PNG_INFO_sCAL;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_SCAL;\r
+#endif\r
+}\r
+#endif\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_pHYs_SUPPORTED)\r
+void PNGAPI\r
+png_set_pHYs(png_structp png_ptr, png_infop info_ptr,\r
+ png_uint_32 res_x, png_uint_32 res_y, int unit_type)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "pHYs");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ info_ptr->x_pixels_per_unit = res_x;\r
+ info_ptr->y_pixels_per_unit = res_y;\r
+ info_ptr->phys_unit_type = (png_byte)unit_type;\r
+ info_ptr->valid |= PNG_INFO_pHYs;\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_set_PLTE(png_structp png_ptr, png_infop info_ptr,\r
+ png_colorp palette, int num_palette)\r
+{\r
+\r
+ png_debug1(1, "in %s storage function\n", "PLTE");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)\r
+ {\r
+ if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ png_error(png_ptr, "Invalid palette length");\r
+ else\r
+ {\r
+ png_warning(png_ptr, "Invalid palette length");\r
+ return;\r
+ }\r
+ }\r
+\r
+ /*\r
+ * It may not actually be necessary to set png_ptr->palette here;\r
+ * we do it for backward compatibility with the way the png_handle_tRNS\r
+ * function used to do the allocation.\r
+ */\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);\r
+#endif\r
+\r
+ /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead\r
+ of num_palette entries,\r
+ in case of an invalid PNG file that has too-large sample values. */\r
+ png_ptr->palette = (png_colorp)png_malloc(png_ptr,\r
+ PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));\r
+ png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *\r
+ png_sizeof(png_color));\r
+ png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));\r
+ info_ptr->palette = png_ptr->palette;\r
+ info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_PLTE;\r
+#else\r
+ png_ptr->flags |= PNG_FLAG_FREE_PLTE;\r
+#endif\r
+\r
+ info_ptr->valid |= PNG_INFO_PLTE;\r
+}\r
+\r
+#if defined(PNG_sBIT_SUPPORTED)\r
+void PNGAPI\r
+png_set_sBIT(png_structp png_ptr, png_infop info_ptr,\r
+ png_color_8p sig_bit)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "sBIT");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));\r
+ info_ptr->valid |= PNG_INFO_sBIT;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sRGB_SUPPORTED)\r
+void PNGAPI\r
+png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "sRGB");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ info_ptr->srgb_intent = (png_byte)intent;\r
+ info_ptr->valid |= PNG_INFO_sRGB;\r
+}\r
+\r
+void PNGAPI\r
+png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,\r
+ int intent)\r
+{\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float file_gamma;\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_fixed_point int_file_gamma;\r
+#endif\r
+#endif\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y;\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,\r
+ int_green_y, int_blue_x, int_blue_y;\r
+#endif\r
+#endif\r
+ png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ png_set_sRGB(png_ptr, info_ptr, intent);\r
+\r
+#if defined(PNG_gAMA_SUPPORTED)\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ file_gamma = (float).45455;\r
+ png_set_gAMA(png_ptr, info_ptr, file_gamma);\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ int_file_gamma = 45455L;\r
+ png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_cHRM_SUPPORTED)\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ int_white_x = 31270L;\r
+ int_white_y = 32900L;\r
+ int_red_x = 64000L;\r
+ int_red_y = 33000L;\r
+ int_green_x = 30000L;\r
+ int_green_y = 60000L;\r
+ int_blue_x = 15000L;\r
+ int_blue_y = 6000L;\r
+\r
+ png_set_cHRM_fixed(png_ptr, info_ptr,\r
+ int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y,\r
+ int_blue_x, int_blue_y);\r
+#endif\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ white_x = (float).3127;\r
+ white_y = (float).3290;\r
+ red_x = (float).64;\r
+ red_y = (float).33;\r
+ green_x = (float).30;\r
+ green_y = (float).60;\r
+ blue_x = (float).15;\r
+ blue_y = (float).06;\r
+\r
+ png_set_cHRM(png_ptr, info_ptr,\r
+ white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);\r
+#endif\r
+#endif\r
+}\r
+#endif\r
+\r
+\r
+#if defined(PNG_iCCP_SUPPORTED)\r
+void PNGAPI\r
+png_set_iCCP(png_structp png_ptr, png_infop info_ptr,\r
+ png_charp name, int compression_type,\r
+ png_charp profile, png_uint_32 proflen)\r
+{\r
+ png_charp new_iccp_name;\r
+ png_charp new_iccp_profile;\r
+ png_uint_32 length;\r
+\r
+ png_debug1(1, "in %s storage function\n", "iCCP");\r
+ if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)\r
+ return;\r
+\r
+ length = png_strlen(name)+1;\r
+ new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (new_iccp_name == NULL)\r
+ {\r
+ png_warning(png_ptr, "Insufficient memory to process iCCP chunk.");\r
+ return;\r
+ }\r
+ png_memcpy(new_iccp_name, name, length);\r
+ new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);\r
+ if (new_iccp_profile == NULL)\r
+ {\r
+ png_free (png_ptr, new_iccp_name);\r
+ png_warning(png_ptr,\r
+ "Insufficient memory to process iCCP profile.");\r
+ return;\r
+ }\r
+ png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);\r
+\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);\r
+\r
+ info_ptr->iccp_proflen = proflen;\r
+ info_ptr->iccp_name = new_iccp_name;\r
+ info_ptr->iccp_profile = new_iccp_profile;\r
+ /* Compression is always zero but is here so the API and info structure\r
+ * does not have to change if we introduce multiple compression types */\r
+ info_ptr->iccp_compression = (png_byte)compression_type;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_ICCP;\r
+#endif\r
+ info_ptr->valid |= PNG_INFO_iCCP;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_TEXT_SUPPORTED)\r
+void PNGAPI\r
+png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,\r
+ int num_text)\r
+{\r
+ int ret;\r
+ ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);\r
+ if (ret)\r
+ png_error(png_ptr, "Insufficient memory to store text");\r
+}\r
+\r
+int /* PRIVATE */\r
+png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,\r
+ int num_text)\r
+{\r
+ int i;\r
+\r
+ png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ?\r
+ "text" : (png_const_charp)png_ptr->chunk_name));\r
+\r
+ if (png_ptr == NULL || info_ptr == NULL || num_text == 0)\r
+ return(0);\r
+\r
+ /* Make sure we have enough space in the "text" array in info_struct\r
+ * to hold all of the incoming text_ptr objects.\r
+ */\r
+ if (info_ptr->num_text + num_text > info_ptr->max_text)\r
+ {\r
+ if (info_ptr->text != NULL)\r
+ {\r
+ png_textp old_text;\r
+ int old_max;\r
+\r
+ old_max = info_ptr->max_text;\r
+ info_ptr->max_text = info_ptr->num_text + num_text + 8;\r
+ old_text = info_ptr->text;\r
+ info_ptr->text = (png_textp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));\r
+ if (info_ptr->text == NULL)\r
+ {\r
+ png_free(png_ptr, old_text);\r
+ return(1);\r
+ }\r
+ png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *\r
+ png_sizeof(png_text)));\r
+ png_free(png_ptr, old_text);\r
+ }\r
+ else\r
+ {\r
+ info_ptr->max_text = num_text + 8;\r
+ info_ptr->num_text = 0;\r
+ info_ptr->text = (png_textp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));\r
+ if (info_ptr->text == NULL)\r
+ return(1);\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_TEXT;\r
+#endif\r
+ }\r
+ png_debug1(3, "allocated %d entries for info_ptr->text\n",\r
+ info_ptr->max_text);\r
+ }\r
+ for (i = 0; i < num_text; i++)\r
+ {\r
+ png_size_t text_length, key_len;\r
+ png_size_t lang_len, lang_key_len;\r
+ png_textp textp = &(info_ptr->text[info_ptr->num_text]);\r
+\r
+ if (text_ptr[i].key == NULL)\r
+ continue;\r
+\r
+ key_len = png_strlen(text_ptr[i].key);\r
+\r
+ if (text_ptr[i].compression <= 0)\r
+ {\r
+ lang_len = 0;\r
+ lang_key_len = 0;\r
+ }\r
+ else\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ {\r
+ /* set iTXt data */\r
+ if (text_ptr[i].lang != NULL)\r
+ lang_len = png_strlen(text_ptr[i].lang);\r
+ else\r
+ lang_len = 0;\r
+ if (text_ptr[i].lang_key != NULL)\r
+ lang_key_len = png_strlen(text_ptr[i].lang_key);\r
+ else\r
+ lang_key_len = 0;\r
+ }\r
+#else\r
+ {\r
+ png_warning(png_ptr, "iTXt chunk not supported.");\r
+ continue;\r
+ }\r
+#endif\r
+\r
+ if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')\r
+ {\r
+ text_length = 0;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ if (text_ptr[i].compression > 0)\r
+ textp->compression = PNG_ITXT_COMPRESSION_NONE;\r
+ else\r
+#endif\r
+ textp->compression = PNG_TEXT_COMPRESSION_NONE;\r
+ }\r
+ else\r
+ {\r
+ text_length = png_strlen(text_ptr[i].text);\r
+ textp->compression = text_ptr[i].compression;\r
+ }\r
+\r
+ textp->key = (png_charp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)\r
+ (key_len + text_length + lang_len + lang_key_len + 4));\r
+ if (textp->key == NULL)\r
+ return(1);\r
+ png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n",\r
+ (png_uint_32)\r
+ (key_len + lang_len + lang_key_len + text_length + 4),\r
+ (int)textp->key);\r
+\r
+ png_memcpy(textp->key, text_ptr[i].key,\r
+ (png_size_t)(key_len));\r
+ *(textp->key + key_len) = '\0';\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ if (text_ptr[i].compression > 0)\r
+ {\r
+ textp->lang = textp->key + key_len + 1;\r
+ png_memcpy(textp->lang, text_ptr[i].lang, lang_len);\r
+ *(textp->lang + lang_len) = '\0';\r
+ textp->lang_key = textp->lang + lang_len + 1;\r
+ png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);\r
+ *(textp->lang_key + lang_key_len) = '\0';\r
+ textp->text = textp->lang_key + lang_key_len + 1;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ textp->lang=NULL;\r
+ textp->lang_key=NULL;\r
+#endif\r
+ textp->text = textp->key + key_len + 1;\r
+ }\r
+ if (text_length)\r
+ png_memcpy(textp->text, text_ptr[i].text,\r
+ (png_size_t)(text_length));\r
+ *(textp->text + text_length) = '\0';\r
+\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ if (textp->compression > 0)\r
+ {\r
+ textp->text_length = 0;\r
+ textp->itxt_length = text_length;\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ textp->text_length = text_length;\r
+#ifdef PNG_iTXt_SUPPORTED\r
+ textp->itxt_length = 0;\r
+#endif\r
+ }\r
+ info_ptr->num_text++;\r
+ png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text);\r
+ }\r
+ return(0);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_tIME_SUPPORTED)\r
+void PNGAPI\r
+png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "tIME");\r
+ if (png_ptr == NULL || info_ptr == NULL ||\r
+ (png_ptr->mode & PNG_WROTE_tIME))\r
+ return;\r
+\r
+ png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));\r
+ info_ptr->valid |= PNG_INFO_tIME;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_tRNS_SUPPORTED)\r
+void PNGAPI\r
+png_set_tRNS(png_structp png_ptr, png_infop info_ptr,\r
+ png_bytep trans, int num_trans, png_color_16p trans_values)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "tRNS");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ if (trans != NULL)\r
+ {\r
+ /*\r
+ * It may not actually be necessary to set png_ptr->trans here;\r
+ * we do it for backward compatibility with the way the png_handle_tRNS\r
+ * function used to do the allocation.\r
+ */\r
+\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);\r
+#endif\r
+\r
+ /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */\r
+ png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)PNG_MAX_PALETTE_LENGTH);\r
+ if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)\r
+ png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);\r
+ }\r
+\r
+ if (trans_values != NULL)\r
+ {\r
+ int sample_max = (1 << info_ptr->bit_depth);\r
+ if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&\r
+ (int)trans_values->gray > sample_max) ||\r
+ (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&\r
+ ((int)trans_values->red > sample_max ||\r
+ (int)trans_values->green > sample_max ||\r
+ (int)trans_values->blue > sample_max)))\r
+ png_warning(png_ptr,\r
+ "tRNS chunk has out-of-range samples for bit_depth");\r
+ png_memcpy(&(info_ptr->trans_values), trans_values,\r
+ png_sizeof(png_color_16));\r
+ if (num_trans == 0)\r
+ num_trans = 1;\r
+ }\r
+\r
+ info_ptr->num_trans = (png_uint_16)num_trans;\r
+ if (num_trans != 0)\r
+ {\r
+ info_ptr->valid |= PNG_INFO_tRNS;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_TRNS;\r
+#else\r
+ png_ptr->flags |= PNG_FLAG_FREE_TRNS;\r
+#endif\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_sPLT_SUPPORTED)\r
+void PNGAPI\r
+png_set_sPLT(png_structp png_ptr,\r
+ png_infop info_ptr, png_sPLT_tp entries, int nentries)\r
+/*\r
+ * entries - array of png_sPLT_t structures\r
+ * to be added to the list of palettes\r
+ * in the info structure.\r
+ * nentries - number of palette structures to be\r
+ * added.\r
+ */\r
+{\r
+ png_sPLT_tp np;\r
+ int i;\r
+\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ np = (png_sPLT_tp)png_malloc_warn(png_ptr,\r
+ (info_ptr->splt_palettes_num + nentries) *\r
+ (png_uint_32)png_sizeof(png_sPLT_t));\r
+ if (np == NULL)\r
+ {\r
+ png_warning(png_ptr, "No memory for sPLT palettes.");\r
+ return;\r
+ }\r
+\r
+ png_memcpy(np, info_ptr->splt_palettes,\r
+ info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));\r
+ png_free(png_ptr, info_ptr->splt_palettes);\r
+ info_ptr->splt_palettes=NULL;\r
+\r
+ for (i = 0; i < nentries; i++)\r
+ {\r
+ png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;\r
+ png_sPLT_tp from = entries + i;\r
+ png_uint_32 length;\r
+\r
+ length = png_strlen(from->name) + 1;\r
+ to->name = (png_charp)png_malloc_warn(png_ptr, length);\r
+ if (to->name == NULL)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Out of memory while processing sPLT chunk");\r
+ continue;\r
+ }\r
+ png_memcpy(to->name, from->name, length);\r
+ to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));\r
+ if (to->entries == NULL)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Out of memory while processing sPLT chunk");\r
+ png_free(png_ptr, to->name);\r
+ to->name = NULL;\r
+ continue;\r
+ }\r
+ png_memcpy(to->entries, from->entries,\r
+ from->nentries * png_sizeof(png_sPLT_entry));\r
+ to->nentries = from->nentries;\r
+ to->depth = from->depth;\r
+ }\r
+\r
+ info_ptr->splt_palettes = np;\r
+ info_ptr->splt_palettes_num += nentries;\r
+ info_ptr->valid |= PNG_INFO_sPLT;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_SPLT;\r
+#endif\r
+}\r
+#endif /* PNG_sPLT_SUPPORTED */\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+void PNGAPI\r
+png_set_unknown_chunks(png_structp png_ptr,\r
+ png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)\r
+{\r
+ png_unknown_chunkp np;\r
+ int i;\r
+\r
+ if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)\r
+ return;\r
+\r
+ np = (png_unknown_chunkp)png_malloc_warn(png_ptr,\r
+ (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *\r
+ png_sizeof(png_unknown_chunk)));\r
+ if (np == NULL)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Out of memory while processing unknown chunk.");\r
+ return;\r
+ }\r
+\r
+ png_memcpy(np, info_ptr->unknown_chunks,\r
+ info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));\r
+ png_free(png_ptr, info_ptr->unknown_chunks);\r
+ info_ptr->unknown_chunks=NULL;\r
+\r
+ for (i = 0; i < num_unknowns; i++)\r
+ {\r
+ png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;\r
+ png_unknown_chunkp from = unknowns + i;\r
+\r
+ png_memcpy((png_charp)to->name, \r
+ (png_charp)from->name, \r
+ png_sizeof(from->name));\r
+ to->name[png_sizeof(to->name)-1] = '\0';\r
+ to->size = from->size;\r
+ /* note our location in the read or write sequence */\r
+ to->location = (png_byte)(png_ptr->mode & 0xff);\r
+\r
+ if (from->size == 0)\r
+ to->data=NULL;\r
+ else\r
+ {\r
+ to->data = (png_bytep)png_malloc_warn(png_ptr,\r
+ (png_uint_32)from->size);\r
+ if (to->data == NULL)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Out of memory while processing unknown chunk.");\r
+ to->size = 0;\r
+ }\r
+ else\r
+ png_memcpy(to->data, from->data, from->size);\r
+ }\r
+ }\r
+\r
+ info_ptr->unknown_chunks = np;\r
+ info_ptr->unknown_chunks_num += num_unknowns;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ info_ptr->free_me |= PNG_FREE_UNKN;\r
+#endif\r
+}\r
+void PNGAPI\r
+png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr,\r
+ int chunk, int location)\r
+{\r
+ if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk <\r
+ (int)info_ptr->unknown_chunks_num)\r
+ info_ptr->unknown_chunks[chunk].location = (png_byte)location;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \\r
+ defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED)\r
+void PNGAPI\r
+png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted)\r
+{\r
+ /* This function is deprecated in favor of png_permit_mng_features()\r
+ and will be removed from libpng-1.3.0 */\r
+ png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->mng_features_permitted = (png_byte)\r
+ ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) |\r
+ ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE)));\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+png_uint_32 PNGAPI\r
+png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)\r
+{\r
+ png_debug(1, "in png_permit_mng_features\n");\r
+ if (png_ptr == NULL)\r
+ return (png_uint_32)0;\r
+ png_ptr->mng_features_permitted =\r
+ (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);\r
+ return (png_uint_32)png_ptr->mng_features_permitted;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+void PNGAPI\r
+png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep\r
+ chunk_list, int num_chunks)\r
+{\r
+ png_bytep new_list, p;\r
+ int i, old_num_chunks;\r
+ if (png_ptr == NULL)\r
+ return;\r
+ if (num_chunks == 0)\r
+ {\r
+ if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)\r
+ png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;\r
+ else\r
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;\r
+\r
+ if (keep == PNG_HANDLE_CHUNK_ALWAYS)\r
+ png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;\r
+ else\r
+ png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;\r
+ return;\r
+ }\r
+ if (chunk_list == NULL)\r
+ return;\r
+ old_num_chunks = png_ptr->num_chunk_list;\r
+ new_list=(png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)\r
+ (5*(num_chunks + old_num_chunks)));\r
+ if (png_ptr->chunk_list != NULL)\r
+ {\r
+ png_memcpy(new_list, png_ptr->chunk_list,\r
+ (png_size_t)(5*old_num_chunks));\r
+ png_free(png_ptr, png_ptr->chunk_list);\r
+ png_ptr->chunk_list=NULL;\r
+ }\r
+ png_memcpy(new_list + 5*old_num_chunks, chunk_list,\r
+ (png_size_t)(5*num_chunks));\r
+ for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)\r
+ *p=(png_byte)keep;\r
+ png_ptr->num_chunk_list = old_num_chunks + num_chunks;\r
+ png_ptr->chunk_list = new_list;\r
+#ifdef PNG_FREE_ME_SUPPORTED\r
+ png_ptr->free_me |= PNG_FREE_LIST;\r
+#endif\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_USER_CHUNKS_SUPPORTED)\r
+void PNGAPI\r
+png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,\r
+ png_user_chunk_ptr read_user_chunk_fn)\r
+{\r
+ png_debug(1, "in png_set_read_user_chunk_fn\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->read_user_chunk_fn = read_user_chunk_fn;\r
+ png_ptr->user_chunk_ptr = user_chunk_ptr;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+void PNGAPI\r
+png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)\r
+{\r
+ png_debug1(1, "in %s storage function\n", "rows");\r
+\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);\r
+ info_ptr->row_pointers = row_pointers;\r
+ if (row_pointers)\r
+ info_ptr->valid |= PNG_INFO_IDAT;\r
+}\r
+#endif\r
+\r
+#ifdef PNG_WRITE_SUPPORTED\r
+void PNGAPI\r
+png_set_compression_buffer_size(png_structp png_ptr,\r
+ png_uint_32 size)\r
+{\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_free(png_ptr, png_ptr->zbuf);\r
+ png_ptr->zbuf_size = (png_size_t)size;\r
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+}\r
+#endif\r
+\r
+void PNGAPI\r
+png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)\r
+{\r
+ if (png_ptr && info_ptr)\r
+ info_ptr->valid &= ~mask;\r
+}\r
+\r
+\r
+#ifndef PNG_1_0_X\r
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED\r
+/* function was added to libpng 1.2.0 and should always exist by default */\r
+void PNGAPI\r
+png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)\r
+{\r
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */\r
+ if (png_ptr != NULL)\r
+ png_ptr->asm_flags = 0;\r
+ asm_flags = asm_flags; /* Quiet the compiler */\r
+}\r
+\r
+/* this function was added to libpng 1.2.0 */\r
+void PNGAPI\r
+png_set_mmx_thresholds (png_structp png_ptr,\r
+ png_byte mmx_bitdepth_threshold,\r
+ png_uint_32 mmx_rowbytes_threshold)\r
+{\r
+/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */\r
+ if (png_ptr == NULL)\r
+ return;\r
+ /* Quiet the compiler */\r
+ mmx_bitdepth_threshold = mmx_bitdepth_threshold;\r
+ mmx_rowbytes_threshold = mmx_rowbytes_threshold;\r
+}\r
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */\r
+\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+/* this function was added to libpng 1.2.6 */\r
+void PNGAPI\r
+png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,\r
+ png_uint_32 user_height_max)\r
+{\r
+ /* Images with dimensions larger than these limits will be\r
+ * rejected by png_set_IHDR(). To accept any PNG datastream\r
+ * regardless of dimensions, set both limits to 0x7ffffffL.\r
+ */\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->user_width_max = user_width_max;\r
+ png_ptr->user_height_max = user_height_max;\r
+}\r
+#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */\r
+\r
+#endif /* ?PNG_1_0_X */\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngtrans.c - transforms the data in a row (used by both readers and writers)\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
+/* turn on BGR-to-RGB mapping */\r
+void PNGAPI\r
+png_set_bgr(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_bgr\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_BGR;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
+/* turn on 16 bit byte swapping */\r
+void PNGAPI\r
+png_set_swap(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_swap\n");\r
+ if (png_ptr == NULL) return;\r
+ if (png_ptr->bit_depth == 16)\r
+ png_ptr->transformations |= PNG_SWAP_BYTES;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)\r
+/* turn on pixel packing */\r
+void PNGAPI\r
+png_set_packing(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_packing\n");\r
+ if (png_ptr == NULL) return;\r
+ if (png_ptr->bit_depth < 8)\r
+ {\r
+ png_ptr->transformations |= PNG_PACK;\r
+ png_ptr->usr_bit_depth = 8;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+/* turn on packed pixel swapping */\r
+void PNGAPI\r
+png_set_packswap(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_packswap\n");\r
+ if (png_ptr == NULL) return;\r
+ if (png_ptr->bit_depth < 8)\r
+ png_ptr->transformations |= PNG_PACKSWAP;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+void PNGAPI\r
+png_set_shift(png_structp png_ptr, png_color_8p true_bits)\r
+{\r
+ png_debug(1, "in png_set_shift\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_SHIFT;\r
+ png_ptr->shift = *true_bits;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_INTERLACING_SUPPORTED) || \\r
+ defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+int PNGAPI\r
+png_set_interlace_handling(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_interlace handling\n");\r
+ if (png_ptr && png_ptr->interlaced)\r
+ {\r
+ png_ptr->transformations |= PNG_INTERLACE;\r
+ return (7);\r
+ }\r
+\r
+ return (1);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)\r
+/* Add a filler byte on read, or remove a filler or alpha byte on write.\r
+ * The filler type has changed in v0.95 to allow future 2-byte fillers\r
+ * for 48-bit input data, as well as to avoid problems with some compilers\r
+ * that don't like bytes as parameters.\r
+ */\r
+void PNGAPI\r
+png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)\r
+{\r
+ png_debug(1, "in png_set_filler\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_FILLER;\r
+ png_ptr->filler = (png_byte)filler;\r
+ if (filler_loc == PNG_FILLER_AFTER)\r
+ png_ptr->flags |= PNG_FLAG_FILLER_AFTER;\r
+ else\r
+ png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;\r
+\r
+ /* This should probably go in the "do_read_filler" routine.\r
+ * I attempted to do that in libpng-1.0.1a but that caused problems\r
+ * so I restored it in libpng-1.0.2a\r
+ */\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ png_ptr->usr_channels = 4;\r
+ }\r
+\r
+ /* Also I added this in libpng-1.0.2a (what happens when we expand\r
+ * a less-than-8-bit grayscale to GA? */\r
+\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8)\r
+ {\r
+ png_ptr->usr_channels = 2;\r
+ }\r
+}\r
+\r
+#if !defined(PNG_1_0_X)\r
+/* Added to libpng-1.2.7 */\r
+void PNGAPI\r
+png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)\r
+{\r
+ png_debug(1, "in png_set_add_alpha\n");\r
+ if (png_ptr == NULL) return;\r
+ png_set_filler(png_ptr, filler, filler_loc);\r
+ png_ptr->transformations |= PNG_ADD_ALPHA;\r
+}\r
+#endif\r
+\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \\r
+ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+void PNGAPI\r
+png_set_swap_alpha(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_swap_alpha\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_SWAP_ALPHA;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \\r
+ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+void PNGAPI\r
+png_set_invert_alpha(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_invert_alpha\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_INVERT_ALPHA;\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)\r
+void PNGAPI\r
+png_set_invert_mono(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_set_invert_mono\n");\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->transformations |= PNG_INVERT_MONO;\r
+}\r
+\r
+/* invert monochrome grayscale data */\r
+void /* PRIVATE */\r
+png_do_invert(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_invert\n");\r
+ /* This test removed from libpng version 1.0.13 and 1.2.0:\r
+ * if (row_info->bit_depth == 1 &&\r
+ */\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row == NULL || row_info == NULL)\r
+ return;\r
+#endif\r
+ if (row_info->color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ png_bytep rp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+\r
+ for (i = 0; i < istop; i++)\r
+ {\r
+ *rp = (png_byte)(~(*rp));\r
+ rp++;\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
+ row_info->bit_depth == 8)\r
+ {\r
+ png_bytep rp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+\r
+ for (i = 0; i < istop; i+=2)\r
+ {\r
+ *rp = (png_byte)(~(*rp));\r
+ rp+=2;\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
+ row_info->bit_depth == 16)\r
+ {\r
+ png_bytep rp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = row_info->rowbytes;\r
+\r
+ for (i = 0; i < istop; i+=4)\r
+ {\r
+ *rp = (png_byte)(~(*rp));\r
+ *(rp+1) = (png_byte)(~(*(rp+1)));\r
+ rp+=4;\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)\r
+/* swaps byte order on 16 bit depth images */\r
+void /* PRIVATE */\r
+png_do_swap(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_swap\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ row_info->bit_depth == 16)\r
+ {\r
+ png_bytep rp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop= row_info->width * row_info->channels;\r
+\r
+ for (i = 0; i < istop; i++, rp += 2)\r
+ {\r
+ png_byte t = *rp;\r
+ *rp = *(rp + 1);\r
+ *(rp + 1) = t;\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+static PNG_CONST png_byte onebppswaptable[256] = {\r
+ 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,\r
+ 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,\r
+ 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,\r
+ 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,\r
+ 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,\r
+ 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,\r
+ 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,\r
+ 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,\r
+ 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,\r
+ 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,\r
+ 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,\r
+ 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,\r
+ 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,\r
+ 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,\r
+ 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,\r
+ 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,\r
+ 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,\r
+ 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,\r
+ 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,\r
+ 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,\r
+ 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,\r
+ 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,\r
+ 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,\r
+ 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,\r
+ 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,\r
+ 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,\r
+ 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,\r
+ 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,\r
+ 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,\r
+ 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,\r
+ 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,\r
+ 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF\r
+};\r
+\r
+static PNG_CONST png_byte twobppswaptable[256] = {\r
+ 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,\r
+ 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,\r
+ 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,\r
+ 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,\r
+ 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,\r
+ 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,\r
+ 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,\r
+ 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,\r
+ 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,\r
+ 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,\r
+ 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,\r
+ 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,\r
+ 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,\r
+ 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,\r
+ 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,\r
+ 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,\r
+ 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,\r
+ 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,\r
+ 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,\r
+ 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,\r
+ 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,\r
+ 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,\r
+ 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,\r
+ 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,\r
+ 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,\r
+ 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,\r
+ 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,\r
+ 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,\r
+ 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,\r
+ 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,\r
+ 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,\r
+ 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF\r
+};\r
+\r
+static PNG_CONST png_byte fourbppswaptable[256] = {\r
+ 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,\r
+ 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,\r
+ 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,\r
+ 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,\r
+ 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,\r
+ 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,\r
+ 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,\r
+ 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,\r
+ 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,\r
+ 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,\r
+ 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,\r
+ 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,\r
+ 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,\r
+ 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,\r
+ 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,\r
+ 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,\r
+ 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,\r
+ 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,\r
+ 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,\r
+ 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,\r
+ 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,\r
+ 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,\r
+ 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,\r
+ 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,\r
+ 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,\r
+ 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,\r
+ 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,\r
+ 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,\r
+ 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,\r
+ 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,\r
+ 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,\r
+ 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF\r
+};\r
+\r
+/* swaps pixel packing order within bytes */\r
+void /* PRIVATE */\r
+png_do_packswap(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_packswap\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ row_info->bit_depth < 8)\r
+ {\r
+ png_bytep rp, end, table;\r
+\r
+ end = row + row_info->rowbytes;\r
+\r
+ if (row_info->bit_depth == 1)\r
+ table = (png_bytep)onebppswaptable;\r
+ else if (row_info->bit_depth == 2)\r
+ table = (png_bytep)twobppswaptable;\r
+ else if (row_info->bit_depth == 4)\r
+ table = (png_bytep)fourbppswaptable;\r
+ else\r
+ return;\r
+\r
+ for (rp = row; rp < end; rp++)\r
+ *rp = table[*rp];\r
+ }\r
+}\r
+#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */\r
+\r
+#if defined(PNG_WRITE_FILLER_SUPPORTED) || \\r
+ defined(PNG_READ_STRIP_ALPHA_SUPPORTED)\r
+/* remove filler or alpha byte(s) */\r
+void /* PRIVATE */\r
+png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)\r
+{\r
+ png_debug(1, "in png_do_strip_filler\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ png_bytep sp=row;\r
+ png_bytep dp=row;\r
+ png_uint_32 row_width=row_info->width;\r
+ png_uint_32 i;\r
+\r
+ if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||\r
+ (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&\r
+ (flags & PNG_FLAG_STRIP_ALPHA))) &&\r
+ row_info->channels == 4)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ /* This converts from RGBX or RGBA to RGB */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ dp+=3; sp+=4;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ sp++;\r
+ }\r
+ }\r
+ /* This converts from XRGB or ARGB to RGB */\r
+ else\r
+ {\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ }\r
+ }\r
+ row_info->pixel_depth = 24;\r
+ row_info->rowbytes = row_width * 3;\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */\r
+ sp += 8; dp += 6;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ /* This could be (although png_memcpy is probably slower):\r
+ png_memcpy(dp, sp, 6);\r
+ sp += 8;\r
+ dp += 6;\r
+ */\r
+\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ sp += 2;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ /* This could be (although png_memcpy is probably slower):\r
+ png_memcpy(dp, sp, 6);\r
+ sp += 8;\r
+ dp += 6;\r
+ */\r
+\r
+ sp+=2;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ }\r
+ }\r
+ row_info->pixel_depth = 48;\r
+ row_info->rowbytes = row_width * 6;\r
+ }\r
+ row_info->channels = 3;\r
+ }\r
+ else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY ||\r
+ (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&\r
+ (flags & PNG_FLAG_STRIP_ALPHA))) &&\r
+ row_info->channels == 2)\r
+ {\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ /* This converts from GX or GA to G */\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ *dp++ = *sp++;\r
+ sp++;\r
+ }\r
+ }\r
+ /* This converts from XG or AG to G */\r
+ else\r
+ {\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ sp++;\r
+ *dp++ = *sp++;\r
+ }\r
+ }\r
+ row_info->pixel_depth = 8;\r
+ row_info->rowbytes = row_width;\r
+ }\r
+ else /* if (row_info->bit_depth == 16) */\r
+ {\r
+ if (flags & PNG_FLAG_FILLER_AFTER)\r
+ {\r
+ /* This converts from GGXX or GGAA to GG */\r
+ sp += 4; dp += 2;\r
+ for (i = 1; i < row_width; i++)\r
+ {\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ sp += 2;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* This converts from XXGG or AAGG to GG */\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ sp += 2;\r
+ *dp++ = *sp++;\r
+ *dp++ = *sp++;\r
+ }\r
+ }\r
+ row_info->pixel_depth = 16;\r
+ row_info->rowbytes = row_width * 2;\r
+ }\r
+ row_info->channels = 1;\r
+ }\r
+ if (flags & PNG_FLAG_STRIP_ALPHA)\r
+ row_info->color_type &= ~PNG_COLOR_MASK_ALPHA;\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)\r
+/* swaps red and blue bytes within a pixel */\r
+void /* PRIVATE */\r
+png_do_bgr(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_bgr\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ png_uint_32 row_width = row_info->width;\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += 3)\r
+ {\r
+ png_byte save = *rp;\r
+ *rp = *(rp + 2);\r
+ *(rp + 2) = save;\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += 4)\r
+ {\r
+ png_byte save = *rp;\r
+ *rp = *(rp + 2);\r
+ *(rp + 2) = save;\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += 6)\r
+ {\r
+ png_byte save = *rp;\r
+ *rp = *(rp + 4);\r
+ *(rp + 4) = save;\r
+ save = *(rp + 1);\r
+ *(rp + 1) = *(rp + 5);\r
+ *(rp + 5) = save;\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += 8)\r
+ {\r
+ png_byte save = *rp;\r
+ *rp = *(rp + 4);\r
+ *(rp + 4) = save;\r
+ save = *(rp + 1);\r
+ *(rp + 1) = *(rp + 5);\r
+ *(rp + 5) = save;\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */\r
+\r
+#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \\r
+ defined(PNG_LEGACY_SUPPORTED)\r
+void PNGAPI\r
+png_set_user_transform_info(png_structp png_ptr, png_voidp\r
+ user_transform_ptr, int user_transform_depth, int user_transform_channels)\r
+{\r
+ png_debug(1, "in png_set_user_transform_info\n");\r
+ if (png_ptr == NULL) return;\r
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)\r
+ png_ptr->user_transform_ptr = user_transform_ptr;\r
+ png_ptr->user_transform_depth = (png_byte)user_transform_depth;\r
+ png_ptr->user_transform_channels = (png_byte)user_transform_channels;\r
+#else\r
+ if (user_transform_ptr || user_transform_depth || user_transform_channels)\r
+ png_warning(png_ptr,\r
+ "This version of libpng does not support user transform info");\r
+#endif\r
+}\r
+#endif\r
+\r
+/* This function returns a pointer to the user_transform_ptr associated with\r
+ * the user transform functions. The application should free any memory\r
+ * associated with this pointer before png_write_destroy and png_read_destroy\r
+ * are called.\r
+ */\r
+png_voidp PNGAPI\r
+png_get_user_transform_ptr(png_structp png_ptr)\r
+{\r
+ if (png_ptr == NULL) return (NULL);\r
+#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)\r
+ return ((png_voidp)png_ptr->user_transform_ptr);\r
+#else\r
+ return (NULL);\r
+#endif\r
+}\r
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngwio.c - functions for data output\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ *\r
+ * This file provides a location for all output. Users who need\r
+ * special handling are expected to write functions that have the same\r
+ * arguments as these and perform similar functions, but that possibly\r
+ * use different output methods. Note that you shouldn't change these\r
+ * functions, but rather write replacement functions and then change\r
+ * them at run time with png_set_write_fn(...).\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#ifdef PNG_WRITE_SUPPORTED\r
+\r
+/* Write the data to whatever output you are using. The default routine\r
+ writes to a file pointer. Note that this routine sometimes gets called\r
+ with very small lengths, so you should implement some kind of simple\r
+ buffering if you are using unbuffered writes. This should never be asked\r
+ to write more than 64K on a 16 bit machine. */\r
+\r
+void /* PRIVATE */\r
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ if (png_ptr->write_data_fn != NULL )\r
+ (*(png_ptr->write_data_fn))(png_ptr, data, length);\r
+ else\r
+ png_error(png_ptr, "Call to NULL write function");\r
+}\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+/* This is the function that does the actual writing of data. If you are\r
+ not writing to a standard C stream, you should create a replacement\r
+ write_data function and use it at run time with png_set_write_fn(), rather\r
+ than changing the library. */\r
+#ifndef USE_FAR_KEYWORD\r
+void PNGAPI\r
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ png_uint_32 check;\r
+\r
+ if (png_ptr == NULL) return;\r
+#if defined(_WIN32_WCE)\r
+ if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )\r
+ check = 0;\r
+#else\r
+ check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));\r
+#endif\r
+ if (check != length)\r
+ png_error(png_ptr, "Write Error");\r
+}\r
+#else\r
+/* this is the model-independent version. Since the standard I/O library\r
+ can't handle far buffers in the medium and small models, we have to copy\r
+ the data.\r
+*/\r
+\r
+#define NEAR_BUF_SIZE 1024\r
+#define MIN(a,b) (a <= b ? a : b)\r
+\r
+void PNGAPI\r
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ png_uint_32 check;\r
+ png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */\r
+ png_FILE_p io_ptr;\r
+\r
+ if (png_ptr == NULL) return;\r
+ /* Check if data really is near. If so, use usual code. */\r
+ near_data = (png_byte *)CVT_PTR_NOCHECK(data);\r
+ io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);\r
+ if ((png_bytep)near_data == data)\r
+ {\r
+#if defined(_WIN32_WCE)\r
+ if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )\r
+ check = 0;\r
+#else\r
+ check = fwrite(near_data, 1, length, io_ptr);\r
+#endif\r
+ }\r
+ else\r
+ {\r
+ png_byte buf[NEAR_BUF_SIZE];\r
+ png_size_t written, remaining, err;\r
+ check = 0;\r
+ remaining = length;\r
+ do\r
+ {\r
+ written = MIN(NEAR_BUF_SIZE, remaining);\r
+ png_memcpy(buf, data, written); /* copy far buffer to near buffer */\r
+#if defined(_WIN32_WCE)\r
+ if ( !WriteFile(io_ptr, buf, written, &err, NULL) )\r
+ err = 0;\r
+#else\r
+ err = fwrite(buf, 1, written, io_ptr);\r
+#endif\r
+ if (err != written)\r
+ break;\r
+ else\r
+ check += err;\r
+ data += written;\r
+ remaining -= written;\r
+ }\r
+ while (remaining != 0);\r
+ }\r
+ if (check != length)\r
+ png_error(png_ptr, "Write Error");\r
+}\r
+\r
+#endif\r
+#endif\r
+\r
+/* This function is called to output any data pending writing (normally\r
+ to disk). After png_flush is called, there should be no data pending\r
+ writing in any buffers. */\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+void /* PRIVATE */\r
+png_flush(png_structp png_ptr)\r
+{\r
+ if (png_ptr->output_flush_fn != NULL)\r
+ (*(png_ptr->output_flush_fn))(png_ptr);\r
+}\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+void PNGAPI\r
+png_default_flush(png_structp png_ptr)\r
+{\r
+#if !defined(_WIN32_WCE)\r
+ png_FILE_p io_ptr;\r
+#endif\r
+ if (png_ptr == NULL) return;\r
+#if !defined(_WIN32_WCE)\r
+ io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));\r
+ if (io_ptr != NULL)\r
+ fflush(io_ptr);\r
+#endif\r
+}\r
+#endif\r
+#endif\r
+\r
+/* This function allows the application to supply new output functions for\r
+ libpng if standard C streams aren't being used.\r
+\r
+ This function takes as its arguments:\r
+ png_ptr - pointer to a png output data structure\r
+ io_ptr - pointer to user supplied structure containing info about\r
+ the output functions. May be NULL.\r
+ write_data_fn - pointer to a new output function that takes as its\r
+ arguments a pointer to a png_struct, a pointer to\r
+ data to be written, and a 32-bit unsigned int that is\r
+ the number of bytes to be written. The new write\r
+ function should call png_error(png_ptr, "Error msg")\r
+ to exit and output any fatal error messages.\r
+ flush_data_fn - pointer to a new flush function that takes as its\r
+ arguments a pointer to a png_struct. After a call to\r
+ the flush function, there should be no data in any buffers\r
+ or pending transmission. If the output method doesn't do\r
+ any buffering of ouput, a function prototype must still be\r
+ supplied although it doesn't have to do anything. If\r
+ PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile\r
+ time, output_flush_fn will be ignored, although it must be\r
+ supplied for compatibility. */\r
+void PNGAPI\r
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,\r
+ png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_ptr->io_ptr = io_ptr;\r
+\r
+#if !defined(PNG_NO_STDIO)\r
+ if (write_data_fn != NULL)\r
+ png_ptr->write_data_fn = write_data_fn;\r
+ else\r
+ png_ptr->write_data_fn = png_default_write_data;\r
+#else\r
+ png_ptr->write_data_fn = write_data_fn;\r
+#endif\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+#if !defined(PNG_NO_STDIO)\r
+ if (output_flush_fn != NULL)\r
+ png_ptr->output_flush_fn = output_flush_fn;\r
+ else\r
+ png_ptr->output_flush_fn = png_default_flush;\r
+#else\r
+ png_ptr->output_flush_fn = output_flush_fn;\r
+#endif\r
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */\r
+\r
+ /* It is an error to read while writing a png file */\r
+ if (png_ptr->read_data_fn != NULL)\r
+ {\r
+ png_ptr->read_data_fn = NULL;\r
+ png_warning(png_ptr,\r
+ "Attempted to set both read_data_fn and write_data_fn in");\r
+ png_warning(png_ptr,\r
+ "the same structure. Resetting read_data_fn to NULL.");\r
+ }\r
+}\r
+\r
+#if defined(USE_FAR_KEYWORD)\r
+#if defined(_MSC_VER)\r
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)\r
+{\r
+ void *near_ptr;\r
+ void FAR *far_ptr;\r
+ FP_OFF(near_ptr) = FP_OFF(ptr);\r
+ far_ptr = (void FAR *)near_ptr;\r
+ if (check != 0)\r
+ if (FP_SEG(ptr) != FP_SEG(far_ptr))\r
+ png_error(png_ptr, "segment lost in conversion");\r
+ return(near_ptr);\r
+}\r
+# else\r
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)\r
+{\r
+ void *near_ptr;\r
+ void FAR *far_ptr;\r
+ near_ptr = (void FAR *)ptr;\r
+ far_ptr = (void FAR *)near_ptr;\r
+ if (check != 0)\r
+ if (far_ptr != ptr)\r
+ png_error(png_ptr, "segment lost in conversion");\r
+ return(near_ptr);\r
+}\r
+# endif\r
+# endif\r
+#endif /* PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngwrite.c - general routines to write a PNG file\r
+ *\r
+ * Last changed in libpng 1.2.31 [August 19, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+/* get internal access to png.h */\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#ifdef PNG_WRITE_SUPPORTED\r
+\r
+/* Writes all the PNG information. This is the suggested way to use the\r
+ * library. If you have a new chunk to add, make a function to write it,\r
+ * and put it in the correct location here. If you want the chunk written\r
+ * after the image data, put it in png_write_end(). I strongly encourage\r
+ * you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing\r
+ * the chunk, as that will keep the code from breaking if you want to just\r
+ * write a plain PNG file. If you have long comments, I suggest writing\r
+ * them in png_write_end(), and compressing them.\r
+ */\r
+void PNGAPI\r
+png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_write_info_before_PLTE\n");\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+ if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))\r
+ {\r
+ png_write_sig(png_ptr); /* write PNG signature */\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))\r
+ {\r
+ png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");\r
+ png_ptr->mng_features_permitted=0;\r
+ }\r
+#endif\r
+ /* write IHDR information. */\r
+ png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,\r
+ info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,\r
+ info_ptr->filter_type,\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+ info_ptr->interlace_type);\r
+#else\r
+ 0);\r
+#endif\r
+ /* the rest of these check to see if the valid field has the appropriate\r
+ flag set, and if it does, writes the chunk. */\r
+#if defined(PNG_WRITE_gAMA_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_gAMA)\r
+ {\r
+# ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ png_write_gAMA(png_ptr, info_ptr->gamma);\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);\r
+# endif\r
+#endif\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_sRGB_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_sRGB)\r
+ png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);\r
+#endif\r
+#if defined(PNG_WRITE_iCCP_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_iCCP)\r
+ png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,\r
+ info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);\r
+#endif\r
+#if defined(PNG_WRITE_sBIT_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_sBIT)\r
+ png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);\r
+#endif\r
+#if defined(PNG_WRITE_cHRM_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_cHRM)\r
+ {\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+ png_write_cHRM(png_ptr,\r
+ info_ptr->x_white, info_ptr->y_white,\r
+ info_ptr->x_red, info_ptr->y_red,\r
+ info_ptr->x_green, info_ptr->y_green,\r
+ info_ptr->x_blue, info_ptr->y_blue);\r
+#else\r
+# ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_write_cHRM_fixed(png_ptr,\r
+ info_ptr->int_x_white, info_ptr->int_y_white,\r
+ info_ptr->int_x_red, info_ptr->int_y_red,\r
+ info_ptr->int_x_green, info_ptr->int_y_green,\r
+ info_ptr->int_x_blue, info_ptr->int_y_blue);\r
+# endif\r
+#endif\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (info_ptr->unknown_chunks_num)\r
+ {\r
+ png_unknown_chunk *up;\r
+\r
+ png_debug(5, "writing extra chunks\n");\r
+\r
+ for (up = info_ptr->unknown_chunks;\r
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;\r
+ up++)\r
+ {\r
+ int keep=png_handle_as_unknown(png_ptr, up->name);\r
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&\r
+ up->location && !(up->location & PNG_HAVE_PLTE) &&\r
+ !(up->location & PNG_HAVE_IDAT) &&\r
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||\r
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))\r
+ {\r
+ if (up->size == 0)\r
+ png_warning(png_ptr, "Writing zero-length unknown chunk");\r
+ png_write_chunk(png_ptr, up->name, up->data, up->size);\r
+ }\r
+ }\r
+ }\r
+#endif\r
+ png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;\r
+ }\r
+}\r
+\r
+void PNGAPI\r
+png_write_info(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)\r
+ int i;\r
+#endif\r
+\r
+ png_debug(1, "in png_write_info\n");\r
+\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+\r
+ png_write_info_before_PLTE(png_ptr, info_ptr);\r
+\r
+ if (info_ptr->valid & PNG_INFO_PLTE)\r
+ png_write_PLTE(png_ptr, info_ptr->palette,\r
+ (png_uint_32)info_ptr->num_palette);\r
+ else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ png_error(png_ptr, "Valid palette required for paletted images");\r
+\r
+#if defined(PNG_WRITE_tRNS_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_tRNS)\r
+ {\r
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+ /* invert the alpha channel (in tRNS) */\r
+ if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&\r
+ info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ int j;\r
+ for (j=0; j<(int)info_ptr->num_trans; j++)\r
+ info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);\r
+ }\r
+#endif\r
+ png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),\r
+ info_ptr->num_trans, info_ptr->color_type);\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_bKGD_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_bKGD)\r
+ png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);\r
+#endif\r
+#if defined(PNG_WRITE_hIST_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_hIST)\r
+ png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);\r
+#endif\r
+#if defined(PNG_WRITE_oFFs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_oFFs)\r
+ png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,\r
+ info_ptr->offset_unit_type);\r
+#endif\r
+#if defined(PNG_WRITE_pCAL_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pCAL)\r
+ png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,\r
+ info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,\r
+ info_ptr->pcal_units, info_ptr->pcal_params);\r
+#endif\r
+#if defined(PNG_WRITE_sCAL_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_sCAL)\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)\r
+ png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,\r
+ info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+ png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,\r
+ info_ptr->scal_s_width, info_ptr->scal_s_height);\r
+#else\r
+ png_warning(png_ptr,\r
+ "png_write_sCAL not supported; sCAL chunk not written.");\r
+#endif\r
+#endif\r
+#endif\r
+#if defined(PNG_WRITE_pHYs_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_pHYs)\r
+ png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,\r
+ info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);\r
+#endif\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_tIME)\r
+ {\r
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));\r
+ png_ptr->mode |= PNG_WROTE_tIME;\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_sPLT_SUPPORTED)\r
+ if (info_ptr->valid & PNG_INFO_sPLT)\r
+ for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)\r
+ png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);\r
+#endif\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED)\r
+ /* Check to see if we need to write text chunks */\r
+ for (i = 0; i < info_ptr->num_text; i++)\r
+ {\r
+ png_debug2(2, "Writing header text chunk %d, type %d\n", i,\r
+ info_ptr->text[i].compression);\r
+ /* an internationalized chunk? */\r
+ if (info_ptr->text[i].compression > 0)\r
+ {\r
+#if defined(PNG_WRITE_iTXt_SUPPORTED)\r
+ /* write international chunk */\r
+ png_write_iTXt(png_ptr,\r
+ info_ptr->text[i].compression,\r
+ info_ptr->text[i].key,\r
+ info_ptr->text[i].lang,\r
+ info_ptr->text[i].lang_key,\r
+ info_ptr->text[i].text);\r
+#else\r
+ png_warning(png_ptr, "Unable to write international text");\r
+#endif\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;\r
+ }\r
+ /* If we want a compressed text chunk */\r
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)\r
+ {\r
+#if defined(PNG_WRITE_zTXt_SUPPORTED)\r
+ /* write compressed chunk */\r
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,\r
+ info_ptr->text[i].text, 0,\r
+ info_ptr->text[i].compression);\r
+#else\r
+ png_warning(png_ptr, "Unable to write compressed text");\r
+#endif\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;\r
+ }\r
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)\r
+ {\r
+#if defined(PNG_WRITE_tEXt_SUPPORTED)\r
+ /* write uncompressed chunk */\r
+ png_write_tEXt(png_ptr, info_ptr->text[i].key,\r
+ info_ptr->text[i].text,\r
+ 0);\r
+#else\r
+ png_warning(png_ptr, "Unable to write uncompressed text");\r
+#endif\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;\r
+ }\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (info_ptr->unknown_chunks_num)\r
+ {\r
+ png_unknown_chunk *up;\r
+\r
+ png_debug(5, "writing extra chunks\n");\r
+\r
+ for (up = info_ptr->unknown_chunks;\r
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;\r
+ up++)\r
+ {\r
+ int keep=png_handle_as_unknown(png_ptr, up->name);\r
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&\r
+ up->location && (up->location & PNG_HAVE_PLTE) &&\r
+ !(up->location & PNG_HAVE_IDAT) &&\r
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||\r
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))\r
+ {\r
+ png_write_chunk(png_ptr, up->name, up->data, up->size);\r
+ }\r
+ }\r
+ }\r
+#endif\r
+}\r
+\r
+/* Writes the end of the PNG file. If you don't want to write comments or\r
+ * time information, you can pass NULL for info. If you already wrote these\r
+ * in png_write_info(), do not write them again here. If you have long\r
+ * comments, I suggest writing them here, and compressing them.\r
+ */\r
+void PNGAPI\r
+png_write_end(png_structp png_ptr, png_infop info_ptr)\r
+{\r
+ png_debug(1, "in png_write_end\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ if (!(png_ptr->mode & PNG_HAVE_IDAT))\r
+ png_error(png_ptr, "No IDATs written into file");\r
+\r
+ /* see if user wants us to write information chunks */\r
+ if (info_ptr != NULL)\r
+ {\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED)\r
+ int i; /* local index variable */\r
+#endif\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+ /* check to see if user has supplied a time chunk */\r
+ if ((info_ptr->valid & PNG_INFO_tIME) &&\r
+ !(png_ptr->mode & PNG_WROTE_tIME))\r
+ png_write_tIME(png_ptr, &(info_ptr->mod_time));\r
+#endif\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED)\r
+ /* loop through comment chunks */\r
+ for (i = 0; i < info_ptr->num_text; i++)\r
+ {\r
+ png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,\r
+ info_ptr->text[i].compression);\r
+ /* an internationalized chunk? */\r
+ if (info_ptr->text[i].compression > 0)\r
+ {\r
+#if defined(PNG_WRITE_iTXt_SUPPORTED)\r
+ /* write international chunk */\r
+ png_write_iTXt(png_ptr,\r
+ info_ptr->text[i].compression,\r
+ info_ptr->text[i].key,\r
+ info_ptr->text[i].lang,\r
+ info_ptr->text[i].lang_key,\r
+ info_ptr->text[i].text);\r
+#else\r
+ png_warning(png_ptr, "Unable to write international text");\r
+#endif\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;\r
+ }\r
+ else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)\r
+ {\r
+#if defined(PNG_WRITE_zTXt_SUPPORTED)\r
+ /* write compressed chunk */\r
+ png_write_zTXt(png_ptr, info_ptr->text[i].key,\r
+ info_ptr->text[i].text, 0,\r
+ info_ptr->text[i].compression);\r
+#else\r
+ png_warning(png_ptr, "Unable to write compressed text");\r
+#endif\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;\r
+ }\r
+ else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)\r
+ {\r
+#if defined(PNG_WRITE_tEXt_SUPPORTED)\r
+ /* write uncompressed chunk */\r
+ png_write_tEXt(png_ptr, info_ptr->text[i].key,\r
+ info_ptr->text[i].text, 0);\r
+#else\r
+ png_warning(png_ptr, "Unable to write uncompressed text");\r
+#endif\r
+\r
+ /* Mark this chunk as written */\r
+ info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;\r
+ }\r
+ }\r
+#endif\r
+#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (info_ptr->unknown_chunks_num)\r
+ {\r
+ png_unknown_chunk *up;\r
+\r
+ png_debug(5, "writing extra chunks\n");\r
+\r
+ for (up = info_ptr->unknown_chunks;\r
+ up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;\r
+ up++)\r
+ {\r
+ int keep=png_handle_as_unknown(png_ptr, up->name);\r
+ if (keep != PNG_HANDLE_CHUNK_NEVER &&\r
+ up->location && (up->location & PNG_AFTER_IDAT) &&\r
+ ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||\r
+ (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))\r
+ {\r
+ png_write_chunk(png_ptr, up->name, up->data, up->size);\r
+ }\r
+ }\r
+ }\r
+#endif\r
+ }\r
+\r
+ png_ptr->mode |= PNG_AFTER_IDAT;\r
+\r
+ /* write end of PNG file */\r
+ png_write_IEND(png_ptr);\r
+ /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,\r
+ * and restored again in libpng-1.2.30, may cause some applications that\r
+ * do not set png_ptr->output_flush_fn to crash. If your application\r
+ * experiences a problem, please try building libpng with\r
+ * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to\r
+ * png-mng-implement at lists.sf.net . This kludge will be removed\r
+ * from libpng-1.4.0.\r
+ */\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED) && \\r
+ defined(PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED)\r
+ png_flush(png_ptr);\r
+#endif\r
+}\r
+\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+#if !defined(_WIN32_WCE)\r
+/* "time.h" functions are not supported on WindowsCE */\r
+void PNGAPI\r
+png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)\r
+{\r
+ png_debug(1, "in png_convert_from_struct_tm\n");\r
+ ptime->year = (png_uint_16)(1900 + ttime->tm_year);\r
+ ptime->month = (png_byte)(ttime->tm_mon + 1);\r
+ ptime->day = (png_byte)ttime->tm_mday;\r
+ ptime->hour = (png_byte)ttime->tm_hour;\r
+ ptime->minute = (png_byte)ttime->tm_min;\r
+ ptime->second = (png_byte)ttime->tm_sec;\r
+}\r
+\r
+void PNGAPI\r
+png_convert_from_time_t(png_timep ptime, time_t ttime)\r
+{\r
+ struct tm *tbuf;\r
+\r
+ png_debug(1, "in png_convert_from_time_t\n");\r
+ tbuf = gmtime(&ttime);\r
+ png_convert_from_struct_tm(ptime, tbuf);\r
+}\r
+#endif\r
+#endif\r
+\r
+/* Initialize png_ptr structure, and allocate any memory needed */\r
+png_structp PNGAPI\r
+png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn)\r
+{\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,\r
+ warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));\r
+}\r
+\r
+/* Alternate initialize png_ptr structure, and allocate any memory needed */\r
+png_structp PNGAPI\r
+png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,\r
+ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,\r
+ png_malloc_ptr malloc_fn, png_free_ptr free_fn)\r
+{\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ volatile\r
+#endif\r
+ png_structp png_ptr;\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+#ifdef USE_FAR_KEYWORD\r
+ jmp_buf jmpbuf;\r
+#endif\r
+#endif\r
+ int i;\r
+ png_debug(1, "in png_create_write_struct\n");\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,\r
+ (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);\r
+#else\r
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ if (png_ptr == NULL)\r
+ return (NULL);\r
+\r
+ /* added at libpng-1.2.6 */\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;\r
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+#ifdef USE_FAR_KEYWORD\r
+ if (setjmp(jmpbuf))\r
+#else\r
+ if (setjmp(png_ptr->jmpbuf))\r
+#endif\r
+ {\r
+ png_free(png_ptr, png_ptr->zbuf);\r
+ png_ptr->zbuf=NULL;\r
+ png_destroy_struct(png_ptr);\r
+ return (NULL);\r
+ }\r
+#ifdef USE_FAR_KEYWORD\r
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+#endif\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);\r
+#endif /* PNG_USER_MEM_SUPPORTED */\r
+ png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);\r
+\r
+ if (user_png_ver)\r
+ {\r
+ i=0;\r
+ do\r
+ {\r
+ if (user_png_ver[i] != png_libpng_ver[i])\r
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+ } while (png_libpng_ver[i++]);\r
+ }\r
+\r
+ if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)\r
+ {\r
+ /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so\r
+ * we must recompile any applications that use any older library version.\r
+ * For versions after libpng 1.0, we will be compatible, so we need\r
+ * only check the first digit.\r
+ */\r
+ if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] ||\r
+ (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) ||\r
+ (user_png_ver[0] == '0' && user_png_ver[2] < '9'))\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char msg[80];\r
+ if (user_png_ver)\r
+ {\r
+ png_snprintf(msg, 80,\r
+ "Application was compiled with png.h from libpng-%.20s",\r
+ user_png_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+ png_snprintf(msg, 80,\r
+ "Application is running with png.c from libpng-%.20s",\r
+ png_libpng_ver);\r
+ png_warning(png_ptr, msg);\r
+#endif\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags=0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "Incompatible libpng version in application and library");\r
+ }\r
+ }\r
+\r
+ /* initialize zbuf - compression buffer */\r
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;\r
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+\r
+ png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,\r
+ png_flush_ptr_NULL);\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,\r
+ 1, png_doublep_NULL, png_doublep_NULL);\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+/* Applications that neglect to set up their own setjmp() and then encounter\r
+ a png_error() will longjmp here. Since the jmpbuf is then meaningless we\r
+ abort instead of returning. */\r
+#ifdef USE_FAR_KEYWORD\r
+ if (setjmp(jmpbuf))\r
+ PNG_ABORT();\r
+ png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf));\r
+#else\r
+ if (setjmp(png_ptr->jmpbuf))\r
+ PNG_ABORT();\r
+#endif\r
+#endif\r
+ return (png_ptr);\r
+}\r
+\r
+/* Initialize png_ptr structure, and allocate any memory needed */\r
+#if defined(PNG_1_0_X) || defined(PNG_1_2_X)\r
+/* Deprecated. */\r
+#undef png_write_init\r
+void PNGAPI\r
+png_write_init(png_structp png_ptr)\r
+{\r
+ /* We only come here via pre-1.0.7-compiled applications */\r
+ png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);\r
+}\r
+\r
+void PNGAPI\r
+png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,\r
+ png_size_t png_struct_size, png_size_t png_info_size)\r
+{\r
+ /* We only come here via pre-1.0.12-compiled applications */\r
+ if (png_ptr == NULL) return;\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ if (png_sizeof(png_struct) > png_struct_size ||\r
+ png_sizeof(png_info) > png_info_size)\r
+ {\r
+ char msg[80];\r
+ png_ptr->warning_fn=NULL;\r
+ if (user_png_ver)\r
+ {\r
+ png_snprintf(msg, 80,\r
+ "Application was compiled with png.h from libpng-%.20s",\r
+ user_png_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+ png_snprintf(msg, 80,\r
+ "Application is running with png.c from libpng-%.20s",\r
+ png_libpng_ver);\r
+ png_warning(png_ptr, msg);\r
+ }\r
+#endif\r
+ if (png_sizeof(png_struct) > png_struct_size)\r
+ {\r
+ png_ptr->error_fn=NULL;\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags=0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "The png struct allocated by the application for writing is too small.");\r
+ }\r
+ if (png_sizeof(png_info) > png_info_size)\r
+ {\r
+ png_ptr->error_fn=NULL;\r
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED\r
+ png_ptr->flags=0;\r
+#endif\r
+ png_error(png_ptr,\r
+ "The info struct allocated by the application for writing is too small.");\r
+ }\r
+ png_write_init_3(&png_ptr, user_png_ver, png_struct_size);\r
+}\r
+#endif /* PNG_1_0_X || PNG_1_2_X */\r
+\r
+\r
+void PNGAPI\r
+png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,\r
+ png_size_t png_struct_size)\r
+{\r
+ png_structp png_ptr=*ptr_ptr;\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ jmp_buf tmp_jmp; /* to save current jump buffer */\r
+#endif\r
+\r
+ int i = 0;\r
+\r
+ if (png_ptr == NULL)\r
+ return;\r
+\r
+ do\r
+ {\r
+ if (user_png_ver[i] != png_libpng_ver[i])\r
+ {\r
+#ifdef PNG_LEGACY_SUPPORTED\r
+ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;\r
+#else\r
+ png_ptr->warning_fn=NULL;\r
+ png_warning(png_ptr,\r
+ "Application uses deprecated png_write_init() and should be recompiled.");\r
+ break;\r
+#endif\r
+ }\r
+ } while (png_libpng_ver[i++]);\r
+\r
+ png_debug(1, "in png_write_init_3\n");\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ /* save jump buffer and error functions */\r
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ if (png_sizeof(png_struct) > png_struct_size)\r
+ {\r
+ png_destroy_struct(png_ptr);\r
+ png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);\r
+ *ptr_ptr = png_ptr;\r
+ }\r
+\r
+ /* reset all variables to 0 */\r
+ png_memset(png_ptr, 0, png_sizeof(png_struct));\r
+\r
+ /* added at libpng-1.2.6 */\r
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED\r
+ png_ptr->user_width_max=PNG_USER_WIDTH_MAX;\r
+ png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ /* restore jump buffer */\r
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,\r
+ png_flush_ptr_NULL);\r
+\r
+ /* initialize zbuf - compression buffer */\r
+ png_ptr->zbuf_size = PNG_ZBUF_SIZE;\r
+ png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,\r
+ 1, png_doublep_NULL, png_doublep_NULL);\r
+#endif\r
+}\r
+\r
+/* Write a few rows of image data. If the image is interlaced,\r
+ * either you will have to write the 7 sub images, or, if you\r
+ * have called png_set_interlace_handling(), you will have to\r
+ * "write" the image seven times.\r
+ */\r
+void PNGAPI\r
+png_write_rows(png_structp png_ptr, png_bytepp row,\r
+ png_uint_32 num_rows)\r
+{\r
+ png_uint_32 i; /* row counter */\r
+ png_bytepp rp; /* row pointer */\r
+\r
+ png_debug(1, "in png_write_rows\n");\r
+\r
+ if (png_ptr == NULL)\r
+ return;\r
+\r
+ /* loop through the rows */\r
+ for (i = 0, rp = row; i < num_rows; i++, rp++)\r
+ {\r
+ png_write_row(png_ptr, *rp);\r
+ }\r
+}\r
+\r
+/* Write the image. You only need to call this function once, even\r
+ * if you are writing an interlaced image.\r
+ */\r
+void PNGAPI\r
+png_write_image(png_structp png_ptr, png_bytepp image)\r
+{\r
+ png_uint_32 i; /* row index */\r
+ int pass, num_pass; /* pass variables */\r
+ png_bytepp rp; /* points to current row */\r
+\r
+ if (png_ptr == NULL)\r
+ return;\r
+\r
+ png_debug(1, "in png_write_image\n");\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+ /* intialize interlace handling. If image is not interlaced,\r
+ this will set pass to 1 */\r
+ num_pass = png_set_interlace_handling(png_ptr);\r
+#else\r
+ num_pass = 1;\r
+#endif\r
+ /* loop through passes */\r
+ for (pass = 0; pass < num_pass; pass++)\r
+ {\r
+ /* loop through image */\r
+ for (i = 0, rp = image; i < png_ptr->height; i++, rp++)\r
+ {\r
+ png_write_row(png_ptr, *rp);\r
+ }\r
+ }\r
+}\r
+\r
+/* called by user to write a row of image data */\r
+void PNGAPI\r
+png_write_row(png_structp png_ptr, png_bytep row)\r
+{\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_debug2(1, "in png_write_row (row %ld, pass %d)\n",\r
+ png_ptr->row_number, png_ptr->pass);\r
+\r
+ /* initialize transformations and other stuff if first time */\r
+ if (png_ptr->row_number == 0 && png_ptr->pass == 0)\r
+ {\r
+ /* make sure we wrote the header info */\r
+ if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))\r
+ png_error(png_ptr,\r
+ "png_write_info was never called before png_write_row.");\r
+\r
+ /* check for transforms that have been set but were defined out */\r
+#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_MONO)\r
+ png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_FILLER)\r
+ png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACK)\r
+ png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SHIFT)\r
+ png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BGR)\r
+ png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");\r
+#endif\r
+#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_BYTES)\r
+ png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");\r
+#endif\r
+\r
+ png_write_start_row(png_ptr);\r
+ }\r
+\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+ /* if interlaced and not interested in row, return */\r
+ if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ switch (png_ptr->pass)\r
+ {\r
+ case 0:\r
+ if (png_ptr->row_number & 0x07)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 1:\r
+ if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 2:\r
+ if ((png_ptr->row_number & 0x07) != 4)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 3:\r
+ if ((png_ptr->row_number & 0x03) || png_ptr->width < 3)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 4:\r
+ if ((png_ptr->row_number & 0x03) != 2)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 5:\r
+ if ((png_ptr->row_number & 0x01) || png_ptr->width < 2)\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ case 6:\r
+ if (!(png_ptr->row_number & 0x01))\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+#endif\r
+\r
+ /* set up row info for transformations */\r
+ png_ptr->row_info.color_type = png_ptr->color_type;\r
+ png_ptr->row_info.width = png_ptr->usr_width;\r
+ png_ptr->row_info.channels = png_ptr->usr_channels;\r
+ png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;\r
+ png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *\r
+ png_ptr->row_info.channels);\r
+\r
+ png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth,\r
+ png_ptr->row_info.width);\r
+\r
+ png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);\r
+ png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);\r
+ png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);\r
+ png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);\r
+ png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);\r
+ png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);\r
+\r
+ /* Copy user's row into buffer, leaving room for filter byte. */\r
+ png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,\r
+ png_ptr->row_info.rowbytes);\r
+\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+ /* handle interlacing */\r
+ if (png_ptr->interlaced && png_ptr->pass < 6 &&\r
+ (png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ png_do_write_interlace(&(png_ptr->row_info),\r
+ png_ptr->row_buf + 1, png_ptr->pass);\r
+ /* this should always get caught above, but still ... */\r
+ if (!(png_ptr->row_info.width))\r
+ {\r
+ png_write_finish_row(png_ptr);\r
+ return;\r
+ }\r
+ }\r
+#endif\r
+\r
+ /* handle other transformations */\r
+ if (png_ptr->transformations)\r
+ png_do_write_transformations(png_ptr);\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ /* Write filter_method 64 (intrapixel differencing) only if\r
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and\r
+ * 2. Libpng did not write a PNG signature (this filter_method is only\r
+ * used in PNG datastreams that are embedded in MNG datastreams) and\r
+ * 3. The application called png_permit_mng_features with a mask that\r
+ * included PNG_FLAG_MNG_FILTER_64 and\r
+ * 4. The filter_method is 64 and\r
+ * 5. The color_type is RGB or RGBA\r
+ */\r
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+ (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))\r
+ {\r
+ /* Intrapixel differencing */\r
+ png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+ }\r
+#endif\r
+\r
+ /* Find a filter if necessary, filter the row and write it out. */\r
+ png_write_find_filter(png_ptr, &(png_ptr->row_info));\r
+\r
+ if (png_ptr->write_row_fn != NULL)\r
+ (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);\r
+}\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+/* Set the automatic flush interval or 0 to turn flushing off */\r
+void PNGAPI\r
+png_set_flush(png_structp png_ptr, int nrows)\r
+{\r
+ png_debug(1, "in png_set_flush\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);\r
+}\r
+\r
+/* flush the current output buffers now */\r
+void PNGAPI\r
+png_write_flush(png_structp png_ptr)\r
+{\r
+ int wrote_IDAT;\r
+\r
+ png_debug(1, "in png_write_flush\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ /* We have already written out all of the data */\r
+ if (png_ptr->row_number >= png_ptr->num_rows)\r
+ return;\r
+\r
+ do\r
+ {\r
+ int ret;\r
+\r
+ /* compress the data */\r
+ ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);\r
+ wrote_IDAT = 0;\r
+\r
+ /* check for compression errors */\r
+ if (ret != Z_OK)\r
+ {\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_error(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_error(png_ptr, "zlib error");\r
+ }\r
+\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ /* write the IDAT and reset the zlib output buffer */\r
+ png_write_IDAT(png_ptr, png_ptr->zbuf,\r
+ png_ptr->zbuf_size);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ wrote_IDAT = 1;\r
+ }\r
+ } while(wrote_IDAT == 1);\r
+\r
+ /* If there is any data left to be output, write it into a new IDAT */\r
+ if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)\r
+ {\r
+ /* write the IDAT and reset the zlib output buffer */\r
+ png_write_IDAT(png_ptr, png_ptr->zbuf,\r
+ png_ptr->zbuf_size - png_ptr->zstream.avail_out);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ }\r
+ png_ptr->flush_rows = 0;\r
+ png_flush(png_ptr);\r
+}\r
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */\r
+\r
+/* free all memory used by the write */\r
+void PNGAPI\r
+png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)\r
+{\r
+ png_structp png_ptr = NULL;\r
+ png_infop info_ptr = NULL;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_free_ptr free_fn = NULL;\r
+ png_voidp mem_ptr = NULL;\r
+#endif\r
+\r
+ png_debug(1, "in png_destroy_write_struct\n");\r
+ if (png_ptr_ptr != NULL)\r
+ {\r
+ png_ptr = *png_ptr_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ free_fn = png_ptr->free_fn;\r
+ mem_ptr = png_ptr->mem_ptr;\r
+#endif\r
+ }\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ if (png_ptr != NULL)\r
+ {\r
+ free_fn = png_ptr->free_fn;\r
+ mem_ptr = png_ptr->mem_ptr;\r
+ }\r
+#endif\r
+\r
+ if (info_ptr_ptr != NULL)\r
+ info_ptr = *info_ptr_ptr;\r
+\r
+ if (info_ptr != NULL)\r
+ {\r
+ if (png_ptr != NULL)\r
+ {\r
+ png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);\r
+\r
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)\r
+ if (png_ptr->num_chunk_list)\r
+ {\r
+ png_free(png_ptr, png_ptr->chunk_list);\r
+ png_ptr->chunk_list=NULL;\r
+ png_ptr->num_chunk_list = 0;\r
+ }\r
+#endif\r
+ }\r
+\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,\r
+ (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)info_ptr);\r
+#endif\r
+ *info_ptr_ptr = NULL;\r
+ }\r
+\r
+ if (png_ptr != NULL)\r
+ {\r
+ png_write_destroy(png_ptr);\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,\r
+ (png_voidp)mem_ptr);\r
+#else\r
+ png_destroy_struct((png_voidp)png_ptr);\r
+#endif\r
+ *png_ptr_ptr = NULL;\r
+ }\r
+}\r
+\r
+\r
+/* Free any memory used in png_ptr struct (old method) */\r
+void /* PRIVATE */\r
+png_write_destroy(png_structp png_ptr)\r
+{\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ jmp_buf tmp_jmp; /* save jump buffer */\r
+#endif\r
+ png_error_ptr error_fn;\r
+ png_error_ptr warning_fn;\r
+ png_voidp error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_free_ptr free_fn;\r
+#endif\r
+\r
+ png_debug(1, "in png_write_destroy\n");\r
+ /* free any memory zlib uses */\r
+ deflateEnd(&png_ptr->zstream);\r
+\r
+ /* free our memory. png_free checks NULL for us. */\r
+ png_free(png_ptr, png_ptr->zbuf);\r
+ png_free(png_ptr, png_ptr->row_buf);\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ png_free(png_ptr, png_ptr->prev_row);\r
+ png_free(png_ptr, png_ptr->sub_row);\r
+ png_free(png_ptr, png_ptr->up_row);\r
+ png_free(png_ptr, png_ptr->avg_row);\r
+ png_free(png_ptr, png_ptr->paeth_row);\r
+#endif\r
+\r
+#if defined(PNG_TIME_RFC1123_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->time_buffer);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ png_free(png_ptr, png_ptr->prev_filters);\r
+ png_free(png_ptr, png_ptr->filter_weights);\r
+ png_free(png_ptr, png_ptr->inv_filter_weights);\r
+ png_free(png_ptr, png_ptr->filter_costs);\r
+ png_free(png_ptr, png_ptr->inv_filter_costs);\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ /* reset structure */\r
+ png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));\r
+#endif\r
+\r
+ error_fn = png_ptr->error_fn;\r
+ warning_fn = png_ptr->warning_fn;\r
+ error_ptr = png_ptr->error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ free_fn = png_ptr->free_fn;\r
+#endif\r
+\r
+ png_memset(png_ptr, 0, png_sizeof(png_struct));\r
+\r
+ png_ptr->error_fn = error_fn;\r
+ png_ptr->warning_fn = warning_fn;\r
+ png_ptr->error_ptr = error_ptr;\r
+#ifdef PNG_USER_MEM_SUPPORTED\r
+ png_ptr->free_fn = free_fn;\r
+#endif\r
+\r
+#ifdef PNG_SETJMP_SUPPORTED\r
+ png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));\r
+#endif\r
+}\r
+\r
+/* Allow the application to select one or more row filters to use. */\r
+void PNGAPI\r
+png_set_filter(png_structp png_ptr, int method, int filters)\r
+{\r
+ png_debug(1, "in png_set_filter\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+ (method == PNG_INTRAPIXEL_DIFFERENCING))\r
+ method = PNG_FILTER_TYPE_BASE;\r
+#endif\r
+ if (method == PNG_FILTER_TYPE_BASE)\r
+ {\r
+ switch (filters & (PNG_ALL_FILTERS | 0x07))\r
+ {\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ case 5:\r
+ case 6:\r
+ case 7: png_warning(png_ptr, "Unknown row filter for method 0");\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+ case PNG_FILTER_VALUE_NONE:\r
+ png_ptr->do_filter=PNG_FILTER_NONE; break;\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ case PNG_FILTER_VALUE_SUB:\r
+ png_ptr->do_filter=PNG_FILTER_SUB; break;\r
+ case PNG_FILTER_VALUE_UP:\r
+ png_ptr->do_filter=PNG_FILTER_UP; break;\r
+ case PNG_FILTER_VALUE_AVG:\r
+ png_ptr->do_filter=PNG_FILTER_AVG; break;\r
+ case PNG_FILTER_VALUE_PAETH:\r
+ png_ptr->do_filter=PNG_FILTER_PAETH; break;\r
+ default: png_ptr->do_filter = (png_byte)filters; break;\r
+#else\r
+ default: png_warning(png_ptr, "Unknown row filter for method 0");\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+ }\r
+\r
+ /* If we have allocated the row_buf, this means we have already started\r
+ * with the image and we should have allocated all of the filter buffers\r
+ * that have been selected. If prev_row isn't already allocated, then\r
+ * it is too late to start using the filters that need it, since we\r
+ * will be missing the data in the previous row. If an application\r
+ * wants to start and stop using particular filters during compression,\r
+ * it should start out with all of the filters, and then add and\r
+ * remove them after the start of compression.\r
+ */\r
+ if (png_ptr->row_buf != NULL)\r
+ {\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)\r
+ {\r
+ png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_ptr->rowbytes + 1));\r
+ png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;\r
+ }\r
+\r
+ if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)\r
+ {\r
+ if (png_ptr->prev_row == NULL)\r
+ {\r
+ png_warning(png_ptr, "Can't add Up filter after starting");\r
+ png_ptr->do_filter &= ~PNG_FILTER_UP;\r
+ }\r
+ else\r
+ {\r
+ png_ptr->up_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_ptr->rowbytes + 1));\r
+ png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;\r
+ }\r
+ }\r
+\r
+ if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)\r
+ {\r
+ if (png_ptr->prev_row == NULL)\r
+ {\r
+ png_warning(png_ptr, "Can't add Average filter after starting");\r
+ png_ptr->do_filter &= ~PNG_FILTER_AVG;\r
+ }\r
+ else\r
+ {\r
+ png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_ptr->rowbytes + 1));\r
+ png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;\r
+ }\r
+ }\r
+\r
+ if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&\r
+ png_ptr->paeth_row == NULL)\r
+ {\r
+ if (png_ptr->prev_row == NULL)\r
+ {\r
+ png_warning(png_ptr, "Can't add Paeth filter after starting");\r
+ png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);\r
+ }\r
+ else\r
+ {\r
+ png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_ptr->rowbytes + 1));\r
+ png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;\r
+ }\r
+ }\r
+\r
+ if (png_ptr->do_filter == PNG_NO_FILTERS)\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+ png_ptr->do_filter = PNG_FILTER_NONE;\r
+ }\r
+ }\r
+ else\r
+ png_error(png_ptr, "Unknown custom filter method");\r
+}\r
+\r
+/* This allows us to influence the way in which libpng chooses the "best"\r
+ * filter for the current scanline. While the "minimum-sum-of-absolute-\r
+ * differences metric is relatively fast and effective, there is some\r
+ * question as to whether it can be improved upon by trying to keep the\r
+ * filtered data going to zlib more consistent, hopefully resulting in\r
+ * better compression.\r
+ */\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */\r
+void PNGAPI\r
+png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,\r
+ int num_weights, png_doublep filter_weights,\r
+ png_doublep filter_costs)\r
+{\r
+ int i;\r
+\r
+ png_debug(1, "in png_set_filter_heuristics\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)\r
+ {\r
+ png_warning(png_ptr, "Unknown filter heuristic method");\r
+ return;\r
+ }\r
+\r
+ if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)\r
+ {\r
+ heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;\r
+ }\r
+\r
+ if (num_weights < 0 || filter_weights == NULL ||\r
+ heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)\r
+ {\r
+ num_weights = 0;\r
+ }\r
+\r
+ png_ptr->num_prev_filters = (png_byte)num_weights;\r
+ png_ptr->heuristic_method = (png_byte)heuristic_method;\r
+\r
+ if (num_weights > 0)\r
+ {\r
+ if (png_ptr->prev_filters == NULL)\r
+ {\r
+ png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_byte) * num_weights));\r
+\r
+ /* To make sure that the weighting starts out fairly */\r
+ for (i = 0; i < num_weights; i++)\r
+ {\r
+ png_ptr->prev_filters[i] = 255;\r
+ }\r
+ }\r
+\r
+ if (png_ptr->filter_weights == NULL)\r
+ {\r
+ png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_uint_16) * num_weights));\r
+\r
+ png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_uint_16) * num_weights));\r
+ for (i = 0; i < num_weights; i++)\r
+ {\r
+ png_ptr->inv_filter_weights[i] =\r
+ png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;\r
+ }\r
+ }\r
+\r
+ for (i = 0; i < num_weights; i++)\r
+ {\r
+ if (filter_weights[i] < 0.0)\r
+ {\r
+ png_ptr->inv_filter_weights[i] =\r
+ png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;\r
+ }\r
+ else\r
+ {\r
+ png_ptr->inv_filter_weights[i] =\r
+ (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);\r
+ png_ptr->filter_weights[i] =\r
+ (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);\r
+ }\r
+ }\r
+ }\r
+\r
+ /* If, in the future, there are other filter methods, this would\r
+ * need to be based on png_ptr->filter.\r
+ */\r
+ if (png_ptr->filter_costs == NULL)\r
+ {\r
+ png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));\r
+\r
+ png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,\r
+ (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));\r
+\r
+ for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)\r
+ {\r
+ png_ptr->inv_filter_costs[i] =\r
+ png_ptr->filter_costs[i] = PNG_COST_FACTOR;\r
+ }\r
+ }\r
+\r
+ /* Here is where we set the relative costs of the different filters. We\r
+ * should take the desired compression level into account when setting\r
+ * the costs, so that Paeth, for instance, has a high relative cost at low\r
+ * compression levels, while it has a lower relative cost at higher\r
+ * compression settings. The filter types are in order of increasing\r
+ * relative cost, so it would be possible to do this with an algorithm.\r
+ */\r
+ for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)\r
+ {\r
+ if (filter_costs == NULL || filter_costs[i] < 0.0)\r
+ {\r
+ png_ptr->inv_filter_costs[i] =\r
+ png_ptr->filter_costs[i] = PNG_COST_FACTOR;\r
+ }\r
+ else if (filter_costs[i] >= 1.0)\r
+ {\r
+ png_ptr->inv_filter_costs[i] =\r
+ (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);\r
+ png_ptr->filter_costs[i] =\r
+ (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);\r
+ }\r
+ }\r
+}\r
+#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */\r
+\r
+void PNGAPI\r
+png_set_compression_level(png_structp png_ptr, int level)\r
+{\r
+ png_debug(1, "in png_set_compression_level\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL;\r
+ png_ptr->zlib_level = level;\r
+}\r
+\r
+void PNGAPI\r
+png_set_compression_mem_level(png_structp png_ptr, int mem_level)\r
+{\r
+ png_debug(1, "in png_set_compression_mem_level\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;\r
+ png_ptr->zlib_mem_level = mem_level;\r
+}\r
+\r
+void PNGAPI\r
+png_set_compression_strategy(png_structp png_ptr, int strategy)\r
+{\r
+ png_debug(1, "in png_set_compression_strategy\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;\r
+ png_ptr->zlib_strategy = strategy;\r
+}\r
+\r
+void PNGAPI\r
+png_set_compression_window_bits(png_structp png_ptr, int window_bits)\r
+{\r
+ if (png_ptr == NULL)\r
+ return;\r
+ if (window_bits > 15)\r
+ png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");\r
+ else if (window_bits < 8)\r
+ png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");\r
+#ifndef WBITS_8_OK\r
+ /* avoid libpng bug with 256-byte windows */\r
+ if (window_bits == 8)\r
+ {\r
+ png_warning(png_ptr, "Compression window is being reset to 512");\r
+ window_bits=9;\r
+ }\r
+#endif\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;\r
+ png_ptr->zlib_window_bits = window_bits;\r
+}\r
+\r
+void PNGAPI\r
+png_set_compression_method(png_structp png_ptr, int method)\r
+{\r
+ png_debug(1, "in png_set_compression_method\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ if (method != 8)\r
+ png_warning(png_ptr, "Only compression method 8 is supported by PNG");\r
+ png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD;\r
+ png_ptr->zlib_method = method;\r
+}\r
+\r
+void PNGAPI\r
+png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)\r
+{\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->write_row_fn = write_row_fn;\r
+}\r
+\r
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
+void PNGAPI\r
+png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr\r
+ write_user_transform_fn)\r
+{\r
+ png_debug(1, "in png_set_write_user_transform_fn\n");\r
+ if (png_ptr == NULL)\r
+ return;\r
+ png_ptr->transformations |= PNG_USER_TRANSFORM;\r
+ png_ptr->write_user_transform_fn = write_user_transform_fn;\r
+}\r
+#endif\r
+\r
+\r
+#if defined(PNG_INFO_IMAGE_SUPPORTED)\r
+void PNGAPI\r
+png_write_png(png_structp png_ptr, png_infop info_ptr,\r
+ int transforms, voidp params)\r
+{\r
+ if (png_ptr == NULL || info_ptr == NULL)\r
+ return;\r
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+ /* invert the alpha channel from opacity to transparency */\r
+ if (transforms & PNG_TRANSFORM_INVERT_ALPHA)\r
+ png_set_invert_alpha(png_ptr);\r
+#endif\r
+\r
+ /* Write the file header information. */\r
+ png_write_info(png_ptr, info_ptr);\r
+\r
+ /* ------ these transformations don't touch the info structure ------- */\r
+\r
+#if defined(PNG_WRITE_INVERT_SUPPORTED)\r
+ /* invert monochrome pixels */\r
+ if (transforms & PNG_TRANSFORM_INVERT_MONO)\r
+ png_set_invert_mono(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+ /* Shift the pixels up to a legal bit depth and fill in\r
+ * as appropriate to correctly scale the image.\r
+ */\r
+ if ((transforms & PNG_TRANSFORM_SHIFT)\r
+ && (info_ptr->valid & PNG_INFO_sBIT))\r
+ png_set_shift(png_ptr, &info_ptr->sig_bit);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_PACK_SUPPORTED)\r
+ /* pack pixels into bytes */\r
+ if (transforms & PNG_TRANSFORM_PACKING)\r
+ png_set_packing(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+ /* swap location of alpha bytes from ARGB to RGBA */\r
+ if (transforms & PNG_TRANSFORM_SWAP_ALPHA)\r
+ png_set_swap_alpha(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_FILLER_SUPPORTED)\r
+ /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into\r
+ * RGB (4 channels -> 3 channels). The second parameter is not used.\r
+ */\r
+ if (transforms & PNG_TRANSFORM_STRIP_FILLER)\r
+ png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_BGR_SUPPORTED)\r
+ /* flip BGR pixels to RGB */\r
+ if (transforms & PNG_TRANSFORM_BGR)\r
+ png_set_bgr(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SWAP_SUPPORTED)\r
+ /* swap bytes of 16-bit files to most significant byte first */\r
+ if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)\r
+ png_set_swap(png_ptr);\r
+#endif\r
+\r
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+ /* swap bits of 1, 2, 4 bit packed pixel formats */\r
+ if (transforms & PNG_TRANSFORM_PACKSWAP)\r
+ png_set_packswap(png_ptr);\r
+#endif\r
+\r
+ /* ----------------------- end of transformations ------------------- */\r
+\r
+ /* write the bits */\r
+ if (info_ptr->valid & PNG_INFO_IDAT)\r
+ png_write_image(png_ptr, info_ptr->row_pointers);\r
+\r
+ /* It is REQUIRED to call this to finish writing the rest of the file */\r
+ png_write_end(png_ptr, info_ptr);\r
+\r
+ transforms = transforms; /* quiet compiler warnings */\r
+ params = params;\r
+}\r
+#endif\r
+#endif /* PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngwtran.c - transforms the data in a row for PNG writers\r
+ *\r
+ * Last changed in libpng 1.2.9 April 14, 2006\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2006 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#ifdef PNG_WRITE_SUPPORTED\r
+\r
+/* Transform the data according to the user's wishes. The order of\r
+ * transformations is significant.\r
+ */\r
+void /* PRIVATE */\r
+png_do_write_transformations(png_structp png_ptr)\r
+{\r
+ png_debug(1, "in png_do_write_transformations\n");\r
+\r
+ if (png_ptr == NULL)\r
+ return;\r
+\r
+#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_USER_TRANSFORM)\r
+ if (png_ptr->write_user_transform_fn != NULL)\r
+ (*(png_ptr->write_user_transform_fn)) /* user write transform function */\r
+ (png_ptr, /* png_ptr */\r
+ &(png_ptr->row_info), /* row_info: */\r
+ /* png_uint_32 width; width of row */\r
+ /* png_uint_32 rowbytes; number of bytes in row */\r
+ /* png_byte color_type; color type of pixels */\r
+ /* png_byte bit_depth; bit depth of samples */\r
+ /* png_byte channels; number of channels (1-4) */\r
+ /* png_byte pixel_depth; bits per pixel (depth*channels) */\r
+ png_ptr->row_buf + 1); /* start of pixel data for row */\r
+#endif\r
+#if defined(PNG_WRITE_FILLER_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_FILLER)\r
+ png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ png_ptr->flags);\r
+#endif\r
+#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACKSWAP)\r
+ png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+#if defined(PNG_WRITE_PACK_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_PACK)\r
+ png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ (png_uint_32)png_ptr->bit_depth);\r
+#endif\r
+#if defined(PNG_WRITE_SWAP_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_BYTES)\r
+ png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SHIFT)\r
+ png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1,\r
+ &(png_ptr->shift));\r
+#endif\r
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_SWAP_ALPHA)\r
+ png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_ALPHA)\r
+ png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+#if defined(PNG_WRITE_BGR_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_BGR)\r
+ png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+#if defined(PNG_WRITE_INVERT_SUPPORTED)\r
+ if (png_ptr->transformations & PNG_INVERT_MONO)\r
+ png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1);\r
+#endif\r
+}\r
+\r
+#if defined(PNG_WRITE_PACK_SUPPORTED)\r
+/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The\r
+ * row_info bit depth should be 8 (one pixel per byte). The channels\r
+ * should be 1 (this only happens on grayscale and paletted images).\r
+ */\r
+void /* PRIVATE */\r
+png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)\r
+{\r
+ png_debug(1, "in png_do_pack\n");\r
+ if (row_info->bit_depth == 8 &&\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ row_info->channels == 1)\r
+ {\r
+ switch ((int)bit_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ png_bytep sp, dp;\r
+ int mask, v;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ sp = row;\r
+ dp = row;\r
+ mask = 0x80;\r
+ v = 0;\r
+\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ if (*sp != 0)\r
+ v |= mask;\r
+ sp++;\r
+ if (mask > 1)\r
+ mask >>= 1;\r
+ else\r
+ {\r
+ mask = 0x80;\r
+ *dp = (png_byte)v;\r
+ dp++;\r
+ v = 0;\r
+ }\r
+ }\r
+ if (mask != 0x80)\r
+ *dp = (png_byte)v;\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ png_bytep sp, dp;\r
+ int shift, v;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ sp = row;\r
+ dp = row;\r
+ shift = 6;\r
+ v = 0;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte value;\r
+\r
+ value = (png_byte)(*sp & 0x03);\r
+ v |= (value << shift);\r
+ if (shift == 0)\r
+ {\r
+ shift = 6;\r
+ *dp = (png_byte)v;\r
+ dp++;\r
+ v = 0;\r
+ }\r
+ else\r
+ shift -= 2;\r
+ sp++;\r
+ }\r
+ if (shift != 6)\r
+ *dp = (png_byte)v;\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep sp, dp;\r
+ int shift, v;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ sp = row;\r
+ dp = row;\r
+ shift = 4;\r
+ v = 0;\r
+ for (i = 0; i < row_width; i++)\r
+ {\r
+ png_byte value;\r
+\r
+ value = (png_byte)(*sp & 0x0f);\r
+ v |= (value << shift);\r
+\r
+ if (shift == 0)\r
+ {\r
+ shift = 4;\r
+ *dp = (png_byte)v;\r
+ dp++;\r
+ v = 0;\r
+ }\r
+ else\r
+ shift -= 4;\r
+\r
+ sp++;\r
+ }\r
+ if (shift != 4)\r
+ *dp = (png_byte)v;\r
+ break;\r
+ }\r
+ }\r
+ row_info->bit_depth = (png_byte)bit_depth;\r
+ row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,\r
+ row_info->width);\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SHIFT_SUPPORTED)\r
+/* Shift pixel values to take advantage of whole range. Pass the\r
+ * true number of bits in bit_depth. The row should be packed\r
+ * according to row_info->bit_depth. Thus, if you had a row of\r
+ * bit depth 4, but the pixels only had values from 0 to 7, you\r
+ * would pass 3 as bit_depth, and this routine would translate the\r
+ * data to 0 to 15.\r
+ */\r
+void /* PRIVATE */\r
+png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)\r
+{\r
+ png_debug(1, "in png_do_shift\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL &&\r
+#else\r
+ if (\r
+#endif\r
+ row_info->color_type != PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ int shift_start[4], shift_dec[4];\r
+ int channels = 0;\r
+\r
+ if (row_info->color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ shift_start[channels] = row_info->bit_depth - bit_depth->red;\r
+ shift_dec[channels] = bit_depth->red;\r
+ channels++;\r
+ shift_start[channels] = row_info->bit_depth - bit_depth->green;\r
+ shift_dec[channels] = bit_depth->green;\r
+ channels++;\r
+ shift_start[channels] = row_info->bit_depth - bit_depth->blue;\r
+ shift_dec[channels] = bit_depth->blue;\r
+ channels++;\r
+ }\r
+ else\r
+ {\r
+ shift_start[channels] = row_info->bit_depth - bit_depth->gray;\r
+ shift_dec[channels] = bit_depth->gray;\r
+ channels++;\r
+ }\r
+ if (row_info->color_type & PNG_COLOR_MASK_ALPHA)\r
+ {\r
+ shift_start[channels] = row_info->bit_depth - bit_depth->alpha;\r
+ shift_dec[channels] = bit_depth->alpha;\r
+ channels++;\r
+ }\r
+\r
+ /* with low row depths, could only be grayscale, so one channel */\r
+ if (row_info->bit_depth < 8)\r
+ {\r
+ png_bytep bp = row;\r
+ png_uint_32 i;\r
+ png_byte mask;\r
+ png_uint_32 row_bytes = row_info->rowbytes;\r
+\r
+ if (bit_depth->gray == 1 && row_info->bit_depth == 2)\r
+ mask = 0x55;\r
+ else if (row_info->bit_depth == 4 && bit_depth->gray == 3)\r
+ mask = 0x11;\r
+ else\r
+ mask = 0xff;\r
+\r
+ for (i = 0; i < row_bytes; i++, bp++)\r
+ {\r
+ png_uint_16 v;\r
+ int j;\r
+\r
+ v = *bp;\r
+ *bp = 0;\r
+ for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0])\r
+ {\r
+ if (j > 0)\r
+ *bp |= (png_byte)((v << j) & 0xff);\r
+ else\r
+ *bp |= (png_byte)((v >> (-j)) & mask);\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep bp = row;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = channels * row_info->width;\r
+\r
+ for (i = 0; i < istop; i++, bp++)\r
+ {\r
+\r
+ png_uint_16 v;\r
+ int j;\r
+ int c = (int)(i%channels);\r
+\r
+ v = *bp;\r
+ *bp = 0;\r
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])\r
+ {\r
+ if (j > 0)\r
+ *bp |= (png_byte)((v << j) & 0xff);\r
+ else\r
+ *bp |= (png_byte)((v >> (-j)) & 0xff);\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ png_bytep bp;\r
+ png_uint_32 i;\r
+ png_uint_32 istop = channels * row_info->width;\r
+\r
+ for (bp = row, i = 0; i < istop; i++)\r
+ {\r
+ int c = (int)(i%channels);\r
+ png_uint_16 value, v;\r
+ int j;\r
+\r
+ v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1));\r
+ value = 0;\r
+ for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c])\r
+ {\r
+ if (j > 0)\r
+ value |= (png_uint_16)((v << j) & (png_uint_16)0xffff);\r
+ else\r
+ value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff);\r
+ }\r
+ *bp++ = (png_byte)(value >> 8);\r
+ *bp++ = (png_byte)(value & 0xff);\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)\r
+void /* PRIVATE */\r
+png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_write_swap_alpha\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ /* This converts from ARGB to RGBA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ png_byte save = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = save;\r
+ }\r
+ }\r
+ /* This converts from AARRGGBB to RRGGBBAA */\r
+ else\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ png_byte save[2];\r
+ save[0] = *(sp++);\r
+ save[1] = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = save[0];\r
+ *(dp++) = save[1];\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ /* This converts from AG to GA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ png_byte save = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = save;\r
+ }\r
+ }\r
+ /* This converts from AAGG to GGAA */\r
+ else\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ png_byte save[2];\r
+ save[0] = *(sp++);\r
+ save[1] = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = save[0];\r
+ *(dp++) = save[1];\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)\r
+void /* PRIVATE */\r
+png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_write_invert_alpha\n");\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL)\r
+#endif\r
+ {\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ {\r
+ /* This inverts the alpha channel in RGBA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ /* does nothing\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ */\r
+ sp+=3; dp = sp;\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ }\r
+ }\r
+ /* This inverts the alpha channel in RRGGBBAA */\r
+ else\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ /* does nothing\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ */\r
+ sp+=6; dp = sp;\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ }\r
+ }\r
+ }\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)\r
+ {\r
+ /* This inverts the alpha channel in GA */\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ }\r
+ }\r
+ /* This inverts the alpha channel in GGAA */\r
+ else\r
+ {\r
+ png_bytep sp, dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ for (i = 0, sp = dp = row; i < row_width; i++)\r
+ {\r
+ /* does nothing\r
+ *(dp++) = *(sp++);\r
+ *(dp++) = *(sp++);\r
+ */\r
+ sp+=2; dp = sp;\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ *(dp++) = (png_byte)(255 - *(sp++));\r
+ }\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+/* undoes intrapixel differencing */\r
+void /* PRIVATE */\r
+png_do_write_intrapixel(png_row_infop row_info, png_bytep row)\r
+{\r
+ png_debug(1, "in png_do_write_intrapixel\n");\r
+ if (\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ row != NULL && row_info != NULL &&\r
+#endif\r
+ (row_info->color_type & PNG_COLOR_MASK_COLOR))\r
+ {\r
+ int bytes_per_pixel;\r
+ png_uint_32 row_width = row_info->width;\r
+ if (row_info->bit_depth == 8)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ bytes_per_pixel = 3;\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ bytes_per_pixel = 4;\r
+ else\r
+ return;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)\r
+ {\r
+ *(rp) = (png_byte)((*rp - *(rp+1))&0xff);\r
+ *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff);\r
+ }\r
+ }\r
+ else if (row_info->bit_depth == 16)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 i;\r
+\r
+ if (row_info->color_type == PNG_COLOR_TYPE_RGB)\r
+ bytes_per_pixel = 6;\r
+ else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)\r
+ bytes_per_pixel = 8;\r
+ else\r
+ return;\r
+\r
+ for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)\r
+ {\r
+ png_uint_32 s0 = (*(rp ) << 8) | *(rp+1);\r
+ png_uint_32 s1 = (*(rp+2) << 8) | *(rp+3);\r
+ png_uint_32 s2 = (*(rp+4) << 8) | *(rp+5);\r
+ png_uint_32 red = (png_uint_32)((s0 - s1) & 0xffffL);\r
+ png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);\r
+ *(rp ) = (png_byte)((red >> 8) & 0xff);\r
+ *(rp+1) = (png_byte)(red & 0xff);\r
+ *(rp+4) = (png_byte)((blue >> 8) & 0xff);\r
+ *(rp+5) = (png_byte)(blue & 0xff);\r
+ }\r
+ }\r
+ }\r
+}\r
+#endif /* PNG_MNG_FEATURES_SUPPORTED */\r
+#endif /* PNG_WRITE_SUPPORTED */\r
--- /dev/null
+\r
+/* pngwutil.c - utilities to write a PNG file\r
+ *\r
+ * Last changed in libpng 1.2.30 [August 15, 2008]\r
+ * For conditions of distribution and use, see copyright notice in png.h\r
+ * Copyright (c) 1998-2008 Glenn Randers-Pehrson\r
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
+ */\r
+\r
+#define PNG_INTERNAL\r
+#include "png.h"\r
+#ifdef PNG_WRITE_SUPPORTED\r
+\r
+/* Place a 32-bit number into a buffer in PNG byte order. We work\r
+ * with unsigned numbers for convenience, although one supported\r
+ * ancillary chunk uses signed (two's complement) numbers.\r
+ */\r
+void PNGAPI\r
+png_save_uint_32(png_bytep buf, png_uint_32 i)\r
+{\r
+ buf[0] = (png_byte)((i >> 24) & 0xff);\r
+ buf[1] = (png_byte)((i >> 16) & 0xff);\r
+ buf[2] = (png_byte)((i >> 8) & 0xff);\r
+ buf[3] = (png_byte)(i & 0xff);\r
+}\r
+\r
+/* The png_save_int_32 function assumes integers are stored in two's\r
+ * complement format. If this isn't the case, then this routine needs to\r
+ * be modified to write data in two's complement format.\r
+ */\r
+void PNGAPI\r
+png_save_int_32(png_bytep buf, png_int_32 i)\r
+{\r
+ buf[0] = (png_byte)((i >> 24) & 0xff);\r
+ buf[1] = (png_byte)((i >> 16) & 0xff);\r
+ buf[2] = (png_byte)((i >> 8) & 0xff);\r
+ buf[3] = (png_byte)(i & 0xff);\r
+}\r
+\r
+/* Place a 16-bit number into a buffer in PNG byte order.\r
+ * The parameter is declared unsigned int, not png_uint_16,\r
+ * just to avoid potential problems on pre-ANSI C compilers.\r
+ */\r
+void PNGAPI\r
+png_save_uint_16(png_bytep buf, unsigned int i)\r
+{\r
+ buf[0] = (png_byte)((i >> 8) & 0xff);\r
+ buf[1] = (png_byte)(i & 0xff);\r
+}\r
+\r
+/* Simple function to write the signature. If we have already written\r
+ * the magic bytes of the signature, or more likely, the PNG stream is\r
+ * being embedded into another stream and doesn't need its own signature,\r
+ * we should call png_set_sig_bytes() to tell libpng how many of the\r
+ * bytes have already been written.\r
+ */\r
+void /* PRIVATE */\r
+png_write_sig(png_structp png_ptr)\r
+{\r
+ png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};\r
+\r
+ /* write the rest of the 8 byte signature */\r
+ png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],\r
+ (png_size_t)(8 - png_ptr->sig_bytes));\r
+ if (png_ptr->sig_bytes < 3)\r
+ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;\r
+}\r
+\r
+/* Write a PNG chunk all at once. The type is an array of ASCII characters\r
+ * representing the chunk name. The array must be at least 4 bytes in\r
+ * length, and does not need to be null terminated. To be safe, pass the\r
+ * pre-defined chunk names here, and if you need a new one, define it\r
+ * where the others are defined. The length is the length of the data.\r
+ * All the data must be present. If that is not possible, use the\r
+ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()\r
+ * functions instead.\r
+ */\r
+void PNGAPI\r
+png_write_chunk(png_structp png_ptr, png_bytep chunk_name,\r
+ png_bytep data, png_size_t length)\r
+{\r
+ if (png_ptr == NULL) return;\r
+ png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);\r
+ png_write_chunk_data(png_ptr, data, (png_size_t)length);\r
+ png_write_chunk_end(png_ptr);\r
+}\r
+\r
+/* Write the start of a PNG chunk. The type is the chunk type.\r
+ * The total_length is the sum of the lengths of all the data you will be\r
+ * passing in png_write_chunk_data().\r
+ */\r
+void PNGAPI\r
+png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,\r
+ png_uint_32 length)\r
+{\r
+ png_byte buf[8];\r
+\r
+ png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,\r
+ (unsigned long)length);\r
+ if (png_ptr == NULL) return;\r
+\r
+ /* write the length and the chunk name */\r
+ png_save_uint_32(buf, length);\r
+ png_memcpy(buf + 4, chunk_name, 4);\r
+ png_write_data(png_ptr, buf, (png_size_t)8);\r
+ /* put the chunk name into png_ptr->chunk_name */\r
+ png_memcpy(png_ptr->chunk_name, chunk_name, 4);\r
+ /* reset the crc and run it over the chunk name */\r
+ png_reset_crc(png_ptr);\r
+ png_calculate_crc(png_ptr, chunk_name, (png_size_t)4);\r
+}\r
+\r
+/* Write the data of a PNG chunk started with png_write_chunk_start().\r
+ * Note that multiple calls to this function are allowed, and that the\r
+ * sum of the lengths from these calls *must* add up to the total_length\r
+ * given to png_write_chunk_start().\r
+ */\r
+void PNGAPI\r
+png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+ /* write the data, and run the CRC over it */\r
+ if (png_ptr == NULL) return;\r
+ if (data != NULL && length > 0)\r
+ {\r
+ png_write_data(png_ptr, data, length);\r
+ /* update the CRC after writing the data,\r
+ * in case that the user I/O routine alters it.\r
+ */\r
+ png_calculate_crc(png_ptr, data, length);\r
+ }\r
+}\r
+\r
+/* Finish a chunk started with png_write_chunk_start(). */\r
+void PNGAPI\r
+png_write_chunk_end(png_structp png_ptr)\r
+{\r
+ png_byte buf[4];\r
+\r
+ if (png_ptr == NULL) return;\r
+\r
+ /* write the crc in a single operation */\r
+ png_save_uint_32(buf, png_ptr->crc);\r
+\r
+ png_write_data(png_ptr, buf, (png_size_t)4);\r
+}\r
+\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)\r
+/*\r
+ * This pair of functions encapsulates the operation of (a) compressing a\r
+ * text string, and (b) issuing it later as a series of chunk data writes.\r
+ * The compression_state structure is shared context for these functions\r
+ * set up by the caller in order to make the whole mess thread-safe.\r
+ */\r
+\r
+typedef struct\r
+{\r
+ char *input; /* the uncompressed input data */\r
+ int input_len; /* its length */\r
+ int num_output_ptr; /* number of output pointers used */\r
+ int max_output_ptr; /* size of output_ptr */\r
+ png_charpp output_ptr; /* array of pointers to output */\r
+} compression_state;\r
+\r
+/* compress given text into storage in the png_ptr structure */\r
+static int /* PRIVATE */\r
+png_text_compress(png_structp png_ptr,\r
+ png_charp text, png_size_t text_len, int compression,\r
+ compression_state *comp)\r
+{\r
+ int ret;\r
+\r
+ comp->num_output_ptr = 0;\r
+ comp->max_output_ptr = 0;\r
+ comp->output_ptr = NULL;\r
+ comp->input = NULL;\r
+ comp->input_len = 0;\r
+\r
+ /* we may just want to pass the text right through */\r
+ if (compression == PNG_TEXT_COMPRESSION_NONE)\r
+ {\r
+ comp->input = text;\r
+ comp->input_len = text_len;\r
+ return((int)text_len);\r
+ }\r
+\r
+ if (compression >= PNG_TEXT_COMPRESSION_LAST)\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char msg[50];\r
+ png_snprintf(msg, 50, "Unknown compression type %d", compression);\r
+ png_warning(png_ptr, msg);\r
+#else\r
+ png_warning(png_ptr, "Unknown compression type");\r
+#endif\r
+ }\r
+\r
+ /* We can't write the chunk until we find out how much data we have,\r
+ * which means we need to run the compressor first and save the\r
+ * output. This shouldn't be a problem, as the vast majority of\r
+ * comments should be reasonable, but we will set up an array of\r
+ * malloc'd pointers to be sure.\r
+ *\r
+ * If we knew the application was well behaved, we could simplify this\r
+ * greatly by assuming we can always malloc an output buffer large\r
+ * enough to hold the compressed text ((1001 * text_len / 1000) + 12)\r
+ * and malloc this directly. The only time this would be a bad idea is\r
+ * if we can't malloc more than 64K and we have 64K of random input\r
+ * data, or if the input string is incredibly large (although this\r
+ * wouldn't cause a failure, just a slowdown due to swapping).\r
+ */\r
+\r
+ /* set up the compression buffers */\r
+ png_ptr->zstream.avail_in = (uInt)text_len;\r
+ png_ptr->zstream.next_in = (Bytef *)text;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf;\r
+\r
+ /* this is the same compression loop as in png_write_row() */\r
+ do\r
+ {\r
+ /* compress the data */\r
+ ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);\r
+ if (ret != Z_OK)\r
+ {\r
+ /* error */\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_error(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_error(png_ptr, "zlib error");\r
+ }\r
+ /* check to see if we need more room */\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ /* make sure the output array has room */\r
+ if (comp->num_output_ptr >= comp->max_output_ptr)\r
+ {\r
+ int old_max;\r
+\r
+ old_max = comp->max_output_ptr;\r
+ comp->max_output_ptr = comp->num_output_ptr + 4;\r
+ if (comp->output_ptr != NULL)\r
+ {\r
+ png_charpp old_ptr;\r
+\r
+ old_ptr = comp->output_ptr;\r
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,\r
+ (png_uint_32)\r
+ (comp->max_output_ptr * png_sizeof(png_charpp)));\r
+ png_memcpy(comp->output_ptr, old_ptr, old_max\r
+ * png_sizeof(png_charp));\r
+ png_free(png_ptr, old_ptr);\r
+ }\r
+ else\r
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,\r
+ (png_uint_32)\r
+ (comp->max_output_ptr * png_sizeof(png_charp)));\r
+ }\r
+\r
+ /* save the data */\r
+ comp->output_ptr[comp->num_output_ptr] =\r
+ (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+ png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,\r
+ png_ptr->zbuf_size);\r
+ comp->num_output_ptr++;\r
+\r
+ /* and reset the buffer */\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ }\r
+ /* continue until we don't have any more to compress */\r
+ } while (png_ptr->zstream.avail_in);\r
+\r
+ /* finish the compression */\r
+ do\r
+ {\r
+ /* tell zlib we are finished */\r
+ ret = deflate(&png_ptr->zstream, Z_FINISH);\r
+\r
+ if (ret == Z_OK)\r
+ {\r
+ /* check to see if we need more room */\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ /* check to make sure our output array has room */\r
+ if (comp->num_output_ptr >= comp->max_output_ptr)\r
+ {\r
+ int old_max;\r
+\r
+ old_max = comp->max_output_ptr;\r
+ comp->max_output_ptr = comp->num_output_ptr + 4;\r
+ if (comp->output_ptr != NULL)\r
+ {\r
+ png_charpp old_ptr;\r
+\r
+ old_ptr = comp->output_ptr;\r
+ /* This could be optimized to realloc() */\r
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,\r
+ (png_uint_32)(comp->max_output_ptr *\r
+ png_sizeof(png_charp)));\r
+ png_memcpy(comp->output_ptr, old_ptr,\r
+ old_max * png_sizeof(png_charp));\r
+ png_free(png_ptr, old_ptr);\r
+ }\r
+ else\r
+ comp->output_ptr = (png_charpp)png_malloc(png_ptr,\r
+ (png_uint_32)(comp->max_output_ptr *\r
+ png_sizeof(png_charp)));\r
+ }\r
+\r
+ /* save off the data */\r
+ comp->output_ptr[comp->num_output_ptr] =\r
+ (png_charp)png_malloc(png_ptr,\r
+ (png_uint_32)png_ptr->zbuf_size);\r
+ png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,\r
+ png_ptr->zbuf_size);\r
+ comp->num_output_ptr++;\r
+\r
+ /* and reset the buffer pointers */\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ }\r
+ }\r
+ else if (ret != Z_STREAM_END)\r
+ {\r
+ /* we got an error */\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_error(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_error(png_ptr, "zlib error");\r
+ }\r
+ } while (ret != Z_STREAM_END);\r
+\r
+ /* text length is number of buffers plus last buffer */\r
+ text_len = png_ptr->zbuf_size * comp->num_output_ptr;\r
+ if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)\r
+ text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out;\r
+\r
+ return((int)text_len);\r
+}\r
+\r
+/* ship the compressed text out via chunk writes */\r
+static void /* PRIVATE */\r
+png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)\r
+{\r
+ int i;\r
+\r
+ /* handle the no-compression case */\r
+ if (comp->input)\r
+ {\r
+ png_write_chunk_data(png_ptr, (png_bytep)comp->input,\r
+ (png_size_t)comp->input_len);\r
+ return;\r
+ }\r
+\r
+ /* write saved output buffers, if any */\r
+ for (i = 0; i < comp->num_output_ptr; i++)\r
+ {\r
+ png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],\r
+ (png_size_t)png_ptr->zbuf_size);\r
+ png_free(png_ptr, comp->output_ptr[i]);\r
+ comp->output_ptr[i]=NULL;\r
+ }\r
+ if (comp->max_output_ptr != 0)\r
+ png_free(png_ptr, comp->output_ptr);\r
+ comp->output_ptr=NULL;\r
+ /* write anything left in zbuf */\r
+ if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)\r
+ png_write_chunk_data(png_ptr, png_ptr->zbuf,\r
+ (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));\r
+\r
+ /* reset zlib for another zTXt/iTXt or image data */\r
+ deflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.data_type = Z_BINARY;\r
+}\r
+#endif\r
+\r
+/* Write the IHDR chunk, and update the png_struct with the necessary\r
+ * information. Note that the rest of this code depends upon this\r
+ * information being correct.\r
+ */\r
+void /* PRIVATE */\r
+png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,\r
+ int bit_depth, int color_type, int compression_type, int filter_type,\r
+ int interlace_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_IHDR;\r
+#endif\r
+ int ret;\r
+\r
+ png_byte buf[13]; /* buffer to store the IHDR info */\r
+\r
+ png_debug(1, "in png_write_IHDR\n");\r
+ /* Check that we have valid input data from the application info */\r
+ switch (color_type)\r
+ {\r
+ case PNG_COLOR_TYPE_GRAY:\r
+ switch (bit_depth)\r
+ {\r
+ case 1:\r
+ case 2:\r
+ case 4:\r
+ case 8:\r
+ case 16: png_ptr->channels = 1; break;\r
+ default: png_error(png_ptr, "Invalid bit depth for grayscale image");\r
+ }\r
+ break;\r
+ case PNG_COLOR_TYPE_RGB:\r
+ if (bit_depth != 8 && bit_depth != 16)\r
+ png_error(png_ptr, "Invalid bit depth for RGB image");\r
+ png_ptr->channels = 3;\r
+ break;\r
+ case PNG_COLOR_TYPE_PALETTE:\r
+ switch (bit_depth)\r
+ {\r
+ case 1:\r
+ case 2:\r
+ case 4:\r
+ case 8: png_ptr->channels = 1; break;\r
+ default: png_error(png_ptr, "Invalid bit depth for paletted image");\r
+ }\r
+ break;\r
+ case PNG_COLOR_TYPE_GRAY_ALPHA:\r
+ if (bit_depth != 8 && bit_depth != 16)\r
+ png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");\r
+ png_ptr->channels = 2;\r
+ break;\r
+ case PNG_COLOR_TYPE_RGB_ALPHA:\r
+ if (bit_depth != 8 && bit_depth != 16)\r
+ png_error(png_ptr, "Invalid bit depth for RGBA image");\r
+ png_ptr->channels = 4;\r
+ break;\r
+ default:\r
+ png_error(png_ptr, "Invalid image color type specified");\r
+ }\r
+\r
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)\r
+ {\r
+ png_warning(png_ptr, "Invalid compression type specified");\r
+ compression_type = PNG_COMPRESSION_TYPE_BASE;\r
+ }\r
+\r
+ /* Write filter_method 64 (intrapixel differencing) only if\r
+ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and\r
+ * 2. Libpng did not write a PNG signature (this filter_method is only\r
+ * used in PNG datastreams that are embedded in MNG datastreams) and\r
+ * 3. The application called png_permit_mng_features with a mask that\r
+ * included PNG_FLAG_MNG_FILTER_64 and\r
+ * 4. The filter_method is 64 and\r
+ * 5. The color_type is RGB or RGBA\r
+ */\r
+ if (\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&\r
+ ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&\r
+ (color_type == PNG_COLOR_TYPE_RGB ||\r
+ color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&\r
+ (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&\r
+#endif\r
+ filter_type != PNG_FILTER_TYPE_BASE)\r
+ {\r
+ png_warning(png_ptr, "Invalid filter type specified");\r
+ filter_type = PNG_FILTER_TYPE_BASE;\r
+ }\r
+\r
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED\r
+ if (interlace_type != PNG_INTERLACE_NONE &&\r
+ interlace_type != PNG_INTERLACE_ADAM7)\r
+ {\r
+ png_warning(png_ptr, "Invalid interlace type specified");\r
+ interlace_type = PNG_INTERLACE_ADAM7;\r
+ }\r
+#else\r
+ interlace_type=PNG_INTERLACE_NONE;\r
+#endif\r
+\r
+ /* save off the relevent information */\r
+ png_ptr->bit_depth = (png_byte)bit_depth;\r
+ png_ptr->color_type = (png_byte)color_type;\r
+ png_ptr->interlaced = (png_byte)interlace_type;\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ png_ptr->filter_type = (png_byte)filter_type;\r
+#endif\r
+ png_ptr->compression_type = (png_byte)compression_type;\r
+ png_ptr->width = width;\r
+ png_ptr->height = height;\r
+\r
+ png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);\r
+ png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);\r
+ /* set the usr info, so any transformations can modify it */\r
+ png_ptr->usr_width = png_ptr->width;\r
+ png_ptr->usr_bit_depth = png_ptr->bit_depth;\r
+ png_ptr->usr_channels = png_ptr->channels;\r
+\r
+ /* pack the header information into the buffer */\r
+ png_save_uint_32(buf, width);\r
+ png_save_uint_32(buf + 4, height);\r
+ buf[8] = (png_byte)bit_depth;\r
+ buf[9] = (png_byte)color_type;\r
+ buf[10] = (png_byte)compression_type;\r
+ buf[11] = (png_byte)filter_type;\r
+ buf[12] = (png_byte)interlace_type;\r
+\r
+ /* write the chunk */\r
+ png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);\r
+\r
+ /* initialize zlib with PNG info */\r
+ png_ptr->zstream.zalloc = png_zalloc;\r
+ png_ptr->zstream.zfree = png_zfree;\r
+ png_ptr->zstream.opaque = (voidpf)png_ptr;\r
+ if (!(png_ptr->do_filter))\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||\r
+ png_ptr->bit_depth < 8)\r
+ png_ptr->do_filter = PNG_FILTER_NONE;\r
+ else\r
+ png_ptr->do_filter = PNG_ALL_FILTERS;\r
+ }\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY))\r
+ {\r
+ if (png_ptr->do_filter != PNG_FILTER_NONE)\r
+ png_ptr->zlib_strategy = Z_FILTERED;\r
+ else\r
+ png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;\r
+ }\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL))\r
+ png_ptr->zlib_level = Z_DEFAULT_COMPRESSION;\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL))\r
+ png_ptr->zlib_mem_level = 8;\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS))\r
+ png_ptr->zlib_window_bits = 15;\r
+ if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))\r
+ png_ptr->zlib_method = 8;\r
+ ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level,\r
+ png_ptr->zlib_method, png_ptr->zlib_window_bits,\r
+ png_ptr->zlib_mem_level, png_ptr->zlib_strategy);\r
+ if (ret != Z_OK)\r
+ {\r
+ if (ret == Z_VERSION_ERROR) png_error(png_ptr,\r
+ "zlib failed to initialize compressor -- version error");\r
+ if (ret == Z_STREAM_ERROR) png_error(png_ptr,\r
+ "zlib failed to initialize compressor -- stream error");\r
+ if (ret == Z_MEM_ERROR) png_error(png_ptr,\r
+ "zlib failed to initialize compressor -- mem error");\r
+ png_error(png_ptr, "zlib failed to initialize compressor");\r
+ }\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ /* libpng is not interested in zstream.data_type */\r
+ /* set it to a predefined value, to avoid its evaluation inside zlib */\r
+ png_ptr->zstream.data_type = Z_BINARY;\r
+\r
+ png_ptr->mode = PNG_HAVE_IHDR;\r
+}\r
+\r
+/* write the palette. We are careful not to trust png_color to be in the\r
+ * correct order for PNG, so people can redefine it to any convenient\r
+ * structure.\r
+ */\r
+void /* PRIVATE */\r
+png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_PLTE;\r
+#endif\r
+ png_uint_32 i;\r
+ png_colorp pal_ptr;\r
+ png_byte buf[3];\r
+\r
+ png_debug(1, "in png_write_PLTE\n");\r
+ if ((\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ !(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) &&\r
+#endif\r
+ num_pal == 0) || num_pal > 256)\r
+ {\r
+ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ png_error(png_ptr, "Invalid number of colors in palette");\r
+ }\r
+ else\r
+ {\r
+ png_warning(png_ptr, "Invalid number of colors in palette");\r
+ return;\r
+ }\r
+ }\r
+\r
+ if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring request to write a PLTE chunk in grayscale PNG");\r
+ return;\r
+ }\r
+\r
+ png_ptr->num_palette = (png_uint_16)num_pal;\r
+ png_debug1(3, "num_palette = %d\n", png_ptr->num_palette);\r
+\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_PLTE,\r
+ (png_uint_32)(num_pal * 3));\r
+#ifndef PNG_NO_POINTER_INDEXING\r
+ for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)\r
+ {\r
+ buf[0] = pal_ptr->red;\r
+ buf[1] = pal_ptr->green;\r
+ buf[2] = pal_ptr->blue;\r
+ png_write_chunk_data(png_ptr, buf, (png_size_t)3);\r
+ }\r
+#else\r
+ /* This is a little slower but some buggy compilers need to do this instead */\r
+ pal_ptr=palette;\r
+ for (i = 0; i < num_pal; i++)\r
+ {\r
+ buf[0] = pal_ptr[i].red;\r
+ buf[1] = pal_ptr[i].green;\r
+ buf[2] = pal_ptr[i].blue;\r
+ png_write_chunk_data(png_ptr, buf, (png_size_t)3);\r
+ }\r
+#endif\r
+ png_write_chunk_end(png_ptr);\r
+ png_ptr->mode |= PNG_HAVE_PLTE;\r
+}\r
+\r
+/* write an IDAT chunk */\r
+void /* PRIVATE */\r
+png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_IDAT;\r
+#endif\r
+ png_debug(1, "in png_write_IDAT\n");\r
+\r
+ /* Optimize the CMF field in the zlib stream. */\r
+ /* This hack of the zlib stream is compliant to the stream specification. */\r
+ if (!(png_ptr->mode & PNG_HAVE_IDAT) &&\r
+ png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)\r
+ {\r
+ unsigned int z_cmf = data[0]; /* zlib compression method and flags */\r
+ if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)\r
+ {\r
+ /* Avoid memory underflows and multiplication overflows. */\r
+ /* The conditions below are practically always satisfied;\r
+ however, they still must be checked. */\r
+ if (length >= 2 &&\r
+ png_ptr->height < 16384 && png_ptr->width < 16384)\r
+ {\r
+ png_uint_32 uncompressed_idat_size = png_ptr->height *\r
+ ((png_ptr->width *\r
+ png_ptr->channels * png_ptr->bit_depth + 15) >> 3);\r
+ unsigned int z_cinfo = z_cmf >> 4;\r
+ unsigned int half_z_window_size = 1 << (z_cinfo + 7);\r
+ while (uncompressed_idat_size <= half_z_window_size &&\r
+ half_z_window_size >= 256)\r
+ {\r
+ z_cinfo--;\r
+ half_z_window_size >>= 1;\r
+ }\r
+ z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);\r
+ if (data[0] != (png_byte)z_cmf)\r
+ {\r
+ data[0] = (png_byte)z_cmf;\r
+ data[1] &= 0xe0;\r
+ data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f);\r
+ }\r
+ }\r
+ }\r
+ else\r
+ png_error(png_ptr,\r
+ "Invalid zlib compression method or flags in IDAT");\r
+ }\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length);\r
+ png_ptr->mode |= PNG_HAVE_IDAT;\r
+}\r
+\r
+/* write an IEND chunk */\r
+void /* PRIVATE */\r
+png_write_IEND(png_structp png_ptr)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_IEND;\r
+#endif\r
+ png_debug(1, "in png_write_IEND\n");\r
+ png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL,\r
+ (png_size_t)0);\r
+ png_ptr->mode |= PNG_HAVE_IEND;\r
+}\r
+\r
+#if defined(PNG_WRITE_gAMA_SUPPORTED)\r
+/* write a gAMA chunk */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+void /* PRIVATE */\r
+png_write_gAMA(png_structp png_ptr, double file_gamma)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_gAMA;\r
+#endif\r
+ png_uint_32 igamma;\r
+ png_byte buf[4];\r
+\r
+ png_debug(1, "in png_write_gAMA\n");\r
+ /* file_gamma is saved in 1/100,000ths */\r
+ igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);\r
+ png_save_uint_32(buf, igamma);\r
+ png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);\r
+}\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+void /* PRIVATE */\r
+png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_gAMA;\r
+#endif\r
+ png_byte buf[4];\r
+\r
+ png_debug(1, "in png_write_gAMA\n");\r
+ /* file_gamma is saved in 1/100,000ths */\r
+ png_save_uint_32(buf, (png_uint_32)file_gamma);\r
+ png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sRGB_SUPPORTED)\r
+/* write a sRGB chunk */\r
+void /* PRIVATE */\r
+png_write_sRGB(png_structp png_ptr, int srgb_intent)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_sRGB;\r
+#endif\r
+ png_byte buf[1];\r
+\r
+ png_debug(1, "in png_write_sRGB\n");\r
+ if (srgb_intent >= PNG_sRGB_INTENT_LAST)\r
+ png_warning(png_ptr,\r
+ "Invalid sRGB rendering intent specified");\r
+ buf[0]=(png_byte)srgb_intent;\r
+ png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_iCCP_SUPPORTED)\r
+/* write an iCCP chunk */\r
+void /* PRIVATE */\r
+png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,\r
+ png_charp profile, int profile_len)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_iCCP;\r
+#endif\r
+ png_size_t name_len;\r
+ png_charp new_name;\r
+ compression_state comp;\r
+ int embedded_profile_len = 0;\r
+\r
+ png_debug(1, "in png_write_iCCP\n");\r
+\r
+ comp.num_output_ptr = 0;\r
+ comp.max_output_ptr = 0;\r
+ comp.output_ptr = NULL;\r
+ comp.input = NULL;\r
+ comp.input_len = 0;\r
+\r
+ if (name == NULL || (name_len = png_check_keyword(png_ptr, name,\r
+ &new_name)) == 0)\r
+ {\r
+ png_warning(png_ptr, "Empty keyword in iCCP chunk");\r
+ return;\r
+ }\r
+\r
+ if (compression_type != PNG_COMPRESSION_TYPE_BASE)\r
+ png_warning(png_ptr, "Unknown compression type in iCCP chunk");\r
+\r
+ if (profile == NULL)\r
+ profile_len = 0;\r
+\r
+ if (profile_len > 3)\r
+ embedded_profile_len =\r
+ ((*( (png_bytep)profile ))<<24) |\r
+ ((*( (png_bytep)profile + 1))<<16) |\r
+ ((*( (png_bytep)profile + 2))<< 8) |\r
+ ((*( (png_bytep)profile + 3)) );\r
+\r
+ if (profile_len < embedded_profile_len)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Embedded profile length too large in iCCP chunk");\r
+ return;\r
+ }\r
+\r
+ if (profile_len > embedded_profile_len)\r
+ {\r
+ png_warning(png_ptr,\r
+ "Truncating profile to actual length in iCCP chunk");\r
+ profile_len = embedded_profile_len;\r
+ }\r
+\r
+ if (profile_len)\r
+ profile_len = png_text_compress(png_ptr, profile,\r
+ (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);\r
+\r
+ /* make sure we include the NULL after the name and the compression type */\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_iCCP,\r
+ (png_uint_32)(name_len + profile_len + 2));\r
+ new_name[name_len + 1] = 0x00;\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_name,\r
+ (png_size_t)(name_len + 2));\r
+\r
+ if (profile_len)\r
+ png_write_compressed_data_out(png_ptr, &comp);\r
+\r
+ png_write_chunk_end(png_ptr);\r
+ png_free(png_ptr, new_name);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sPLT_SUPPORTED)\r
+/* write a sPLT chunk */\r
+void /* PRIVATE */\r
+png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_sPLT;\r
+#endif\r
+ png_size_t name_len;\r
+ png_charp new_name;\r
+ png_byte entrybuf[10];\r
+ int entry_size = (spalette->depth == 8 ? 6 : 10);\r
+ int palette_size = entry_size * spalette->nentries;\r
+ png_sPLT_entryp ep;\r
+#ifdef PNG_NO_POINTER_INDEXING\r
+ int i;\r
+#endif\r
+\r
+ png_debug(1, "in png_write_sPLT\n");\r
+ if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr,\r
+ spalette->name, &new_name))==0)\r
+ {\r
+ png_warning(png_ptr, "Empty keyword in sPLT chunk");\r
+ return;\r
+ }\r
+\r
+ /* make sure we include the NULL after the name */\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_sPLT,\r
+ (png_uint_32)(name_len + 2 + palette_size));\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_name,\r
+ (png_size_t)(name_len + 1));\r
+ png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);\r
+\r
+ /* loop through each palette entry, writing appropriately */\r
+#ifndef PNG_NO_POINTER_INDEXING\r
+ for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)\r
+ {\r
+ if (spalette->depth == 8)\r
+ {\r
+ entrybuf[0] = (png_byte)ep->red;\r
+ entrybuf[1] = (png_byte)ep->green;\r
+ entrybuf[2] = (png_byte)ep->blue;\r
+ entrybuf[3] = (png_byte)ep->alpha;\r
+ png_save_uint_16(entrybuf + 4, ep->frequency);\r
+ }\r
+ else\r
+ {\r
+ png_save_uint_16(entrybuf + 0, ep->red);\r
+ png_save_uint_16(entrybuf + 2, ep->green);\r
+ png_save_uint_16(entrybuf + 4, ep->blue);\r
+ png_save_uint_16(entrybuf + 6, ep->alpha);\r
+ png_save_uint_16(entrybuf + 8, ep->frequency);\r
+ }\r
+ png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);\r
+ }\r
+#else\r
+ ep=spalette->entries;\r
+ for (i=0; i>spalette->nentries; i++)\r
+ {\r
+ if (spalette->depth == 8)\r
+ {\r
+ entrybuf[0] = (png_byte)ep[i].red;\r
+ entrybuf[1] = (png_byte)ep[i].green;\r
+ entrybuf[2] = (png_byte)ep[i].blue;\r
+ entrybuf[3] = (png_byte)ep[i].alpha;\r
+ png_save_uint_16(entrybuf + 4, ep[i].frequency);\r
+ }\r
+ else\r
+ {\r
+ png_save_uint_16(entrybuf + 0, ep[i].red);\r
+ png_save_uint_16(entrybuf + 2, ep[i].green);\r
+ png_save_uint_16(entrybuf + 4, ep[i].blue);\r
+ png_save_uint_16(entrybuf + 6, ep[i].alpha);\r
+ png_save_uint_16(entrybuf + 8, ep[i].frequency);\r
+ }\r
+ png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);\r
+ }\r
+#endif\r
+\r
+ png_write_chunk_end(png_ptr);\r
+ png_free(png_ptr, new_name);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sBIT_SUPPORTED)\r
+/* write the sBIT chunk */\r
+void /* PRIVATE */\r
+png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_sBIT;\r
+#endif\r
+ png_byte buf[4];\r
+ png_size_t size;\r
+\r
+ png_debug(1, "in png_write_sBIT\n");\r
+ /* make sure we don't depend upon the order of PNG_COLOR_8 */\r
+ if (color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ png_byte maxbits;\r
+\r
+ maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :\r
+ png_ptr->usr_bit_depth);\r
+ if (sbit->red == 0 || sbit->red > maxbits ||\r
+ sbit->green == 0 || sbit->green > maxbits ||\r
+ sbit->blue == 0 || sbit->blue > maxbits)\r
+ {\r
+ png_warning(png_ptr, "Invalid sBIT depth specified");\r
+ return;\r
+ }\r
+ buf[0] = sbit->red;\r
+ buf[1] = sbit->green;\r
+ buf[2] = sbit->blue;\r
+ size = 3;\r
+ }\r
+ else\r
+ {\r
+ if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)\r
+ {\r
+ png_warning(png_ptr, "Invalid sBIT depth specified");\r
+ return;\r
+ }\r
+ buf[0] = sbit->gray;\r
+ size = 1;\r
+ }\r
+\r
+ if (color_type & PNG_COLOR_MASK_ALPHA)\r
+ {\r
+ if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)\r
+ {\r
+ png_warning(png_ptr, "Invalid sBIT depth specified");\r
+ return;\r
+ }\r
+ buf[size++] = sbit->alpha;\r
+ }\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_cHRM_SUPPORTED)\r
+/* write the cHRM chunk */\r
+#ifdef PNG_FLOATING_POINT_SUPPORTED\r
+void /* PRIVATE */\r
+png_write_cHRM(png_structp png_ptr, double white_x, double white_y,\r
+ double red_x, double red_y, double green_x, double green_y,\r
+ double blue_x, double blue_y)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_cHRM;\r
+#endif\r
+ png_byte buf[32];\r
+ png_uint_32 itemp;\r
+\r
+ png_debug(1, "in png_write_cHRM\n");\r
+ /* each value is saved in 1/100,000ths */\r
+ if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 ||\r
+ white_x + white_y > 1.0)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM white point specified");\r
+#if !defined(PNG_NO_CONSOLE_IO)\r
+ fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);\r
+#endif\r
+ return;\r
+ }\r
+ itemp = (png_uint_32)(white_x * 100000.0 + 0.5);\r
+ png_save_uint_32(buf, itemp);\r
+ itemp = (png_uint_32)(white_y * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 4, itemp);\r
+\r
+ if (red_x < 0 || red_y < 0 || red_x + red_y > 1.0)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM red point specified");\r
+ return;\r
+ }\r
+ itemp = (png_uint_32)(red_x * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 8, itemp);\r
+ itemp = (png_uint_32)(red_y * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 12, itemp);\r
+\r
+ if (green_x < 0 || green_y < 0 || green_x + green_y > 1.0)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM green point specified");\r
+ return;\r
+ }\r
+ itemp = (png_uint_32)(green_x * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 16, itemp);\r
+ itemp = (png_uint_32)(green_y * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 20, itemp);\r
+\r
+ if (blue_x < 0 || blue_y < 0 || blue_x + blue_y > 1.0)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM blue point specified");\r
+ return;\r
+ }\r
+ itemp = (png_uint_32)(blue_x * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 24, itemp);\r
+ itemp = (png_uint_32)(blue_y * 100000.0 + 0.5);\r
+ png_save_uint_32(buf + 28, itemp);\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);\r
+}\r
+#endif\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+void /* PRIVATE */\r
+png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,\r
+ png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y,\r
+ png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x,\r
+ png_fixed_point blue_y)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_cHRM;\r
+#endif\r
+ png_byte buf[32];\r
+\r
+ png_debug(1, "in png_write_cHRM\n");\r
+ /* each value is saved in 1/100,000ths */\r
+ if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid fixed cHRM white point specified");\r
+#if !defined(PNG_NO_CONSOLE_IO)\r
+ fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,\r
+ (unsigned long)white_y);\r
+#endif\r
+ return;\r
+ }\r
+ png_save_uint_32(buf, (png_uint_32)white_x);\r
+ png_save_uint_32(buf + 4, (png_uint_32)white_y);\r
+\r
+ if (red_x + red_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid cHRM fixed red point specified");\r
+ return;\r
+ }\r
+ png_save_uint_32(buf + 8, (png_uint_32)red_x);\r
+ png_save_uint_32(buf + 12, (png_uint_32)red_y);\r
+\r
+ if (green_x + green_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid fixed cHRM green point specified");\r
+ return;\r
+ }\r
+ png_save_uint_32(buf + 16, (png_uint_32)green_x);\r
+ png_save_uint_32(buf + 20, (png_uint_32)green_y);\r
+\r
+ if (blue_x + blue_y > 100000L)\r
+ {\r
+ png_warning(png_ptr, "Invalid fixed cHRM blue point specified");\r
+ return;\r
+ }\r
+ png_save_uint_32(buf + 24, (png_uint_32)blue_x);\r
+ png_save_uint_32(buf + 28, (png_uint_32)blue_y);\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);\r
+}\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tRNS_SUPPORTED)\r
+/* write the tRNS chunk */\r
+void /* PRIVATE */\r
+png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,\r
+ int num_trans, int color_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_tRNS;\r
+#endif\r
+ png_byte buf[6];\r
+\r
+ png_debug(1, "in png_write_tRNS\n");\r
+ if (color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)\r
+ {\r
+ png_warning(png_ptr, "Invalid number of transparent colors specified");\r
+ return;\r
+ }\r
+ /* write the chunk out as it is */\r
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans,\r
+ (png_size_t)num_trans);\r
+ }\r
+ else if (color_type == PNG_COLOR_TYPE_GRAY)\r
+ {\r
+ /* one 16 bit value */\r
+ if (tran->gray >= (1 << png_ptr->bit_depth))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");\r
+ return;\r
+ }\r
+ png_save_uint_16(buf, tran->gray);\r
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);\r
+ }\r
+ else if (color_type == PNG_COLOR_TYPE_RGB)\r
+ {\r
+ /* three 16 bit values */\r
+ png_save_uint_16(buf, tran->red);\r
+ png_save_uint_16(buf + 2, tran->green);\r
+ png_save_uint_16(buf + 4, tran->blue);\r
+ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");\r
+ return;\r
+ }\r
+ png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);\r
+ }\r
+ else\r
+ {\r
+ png_warning(png_ptr, "Can't write tRNS with an alpha channel");\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_bKGD_SUPPORTED)\r
+/* write the background chunk */\r
+void /* PRIVATE */\r
+png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_bKGD;\r
+#endif\r
+ png_byte buf[6];\r
+\r
+ png_debug(1, "in png_write_bKGD\n");\r
+ if (color_type == PNG_COLOR_TYPE_PALETTE)\r
+ {\r
+ if (\r
+#if defined(PNG_MNG_FEATURES_SUPPORTED)\r
+ (png_ptr->num_palette ||\r
+ (!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) &&\r
+#endif\r
+ back->index > png_ptr->num_palette)\r
+ {\r
+ png_warning(png_ptr, "Invalid background palette index");\r
+ return;\r
+ }\r
+ buf[0] = back->index;\r
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);\r
+ }\r
+ else if (color_type & PNG_COLOR_MASK_COLOR)\r
+ {\r
+ png_save_uint_16(buf, back->red);\r
+ png_save_uint_16(buf + 2, back->green);\r
+ png_save_uint_16(buf + 4, back->blue);\r
+ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");\r
+ return;\r
+ }\r
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);\r
+ }\r
+ else\r
+ {\r
+ if (back->gray >= (1 << png_ptr->bit_depth))\r
+ {\r
+ png_warning(png_ptr,\r
+ "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");\r
+ return;\r
+ }\r
+ png_save_uint_16(buf, back->gray);\r
+ png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);\r
+ }\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_hIST_SUPPORTED)\r
+/* write the histogram */\r
+void /* PRIVATE */\r
+png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_hIST;\r
+#endif\r
+ int i;\r
+ png_byte buf[3];\r
+\r
+ png_debug(1, "in png_write_hIST\n");\r
+ if (num_hist > (int)png_ptr->num_palette)\r
+ {\r
+ png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist,\r
+ png_ptr->num_palette);\r
+ png_warning(png_ptr, "Invalid number of histogram entries specified");\r
+ return;\r
+ }\r
+\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_hIST,\r
+ (png_uint_32)(num_hist * 2));\r
+ for (i = 0; i < num_hist; i++)\r
+ {\r
+ png_save_uint_16(buf, hist[i]);\r
+ png_write_chunk_data(png_ptr, buf, (png_size_t)2);\r
+ }\r
+ png_write_chunk_end(png_ptr);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \\r
+ defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)\r
+/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification,\r
+ * and if invalid, correct the keyword rather than discarding the entire\r
+ * chunk. The PNG 1.0 specification requires keywords 1-79 characters in\r
+ * length, forbids leading or trailing whitespace, multiple internal spaces,\r
+ * and the non-break space (0x80) from ISO 8859-1. Returns keyword length.\r
+ *\r
+ * The new_key is allocated to hold the corrected keyword and must be freed\r
+ * by the calling routine. This avoids problems with trying to write to\r
+ * static keywords without having to have duplicate copies of the strings.\r
+ */\r
+png_size_t /* PRIVATE */\r
+png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)\r
+{\r
+ png_size_t key_len;\r
+ png_charp kp, dp;\r
+ int kflag;\r
+ int kwarn=0;\r
+\r
+ png_debug(1, "in png_check_keyword\n");\r
+ *new_key = NULL;\r
+\r
+ if (key == NULL || (key_len = png_strlen(key)) == 0)\r
+ {\r
+ png_warning(png_ptr, "zero length keyword");\r
+ return ((png_size_t)0);\r
+ }\r
+\r
+ png_debug1(2, "Keyword to be checked is '%s'\n", key);\r
+\r
+ *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));\r
+ if (*new_key == NULL)\r
+ {\r
+ png_warning(png_ptr, "Out of memory while procesing keyword");\r
+ return ((png_size_t)0);\r
+ }\r
+\r
+ /* Replace non-printing characters with a blank and print a warning */\r
+ for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++)\r
+ {\r
+ if ((png_byte)*kp < 0x20 ||\r
+ ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1))\r
+ {\r
+#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)\r
+ char msg[40];\r
+\r
+ png_snprintf(msg, 40,\r
+ "invalid keyword character 0x%02X", (png_byte)*kp);\r
+ png_warning(png_ptr, msg);\r
+#else\r
+ png_warning(png_ptr, "invalid character in keyword");\r
+#endif\r
+ *dp = ' ';\r
+ }\r
+ else\r
+ {\r
+ *dp = *kp;\r
+ }\r
+ }\r
+ *dp = '\0';\r
+\r
+ /* Remove any trailing white space. */\r
+ kp = *new_key + key_len - 1;\r
+ if (*kp == ' ')\r
+ {\r
+ png_warning(png_ptr, "trailing spaces removed from keyword");\r
+\r
+ while (*kp == ' ')\r
+ {\r
+ *(kp--) = '\0';\r
+ key_len--;\r
+ }\r
+ }\r
+\r
+ /* Remove any leading white space. */\r
+ kp = *new_key;\r
+ if (*kp == ' ')\r
+ {\r
+ png_warning(png_ptr, "leading spaces removed from keyword");\r
+\r
+ while (*kp == ' ')\r
+ {\r
+ kp++;\r
+ key_len--;\r
+ }\r
+ }\r
+\r
+ png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp);\r
+\r
+ /* Remove multiple internal spaces. */\r
+ for (kflag = 0, dp = *new_key; *kp != '\0'; kp++)\r
+ {\r
+ if (*kp == ' ' && kflag == 0)\r
+ {\r
+ *(dp++) = *kp;\r
+ kflag = 1;\r
+ }\r
+ else if (*kp == ' ')\r
+ {\r
+ key_len--;\r
+ kwarn=1;\r
+ }\r
+ else\r
+ {\r
+ *(dp++) = *kp;\r
+ kflag = 0;\r
+ }\r
+ }\r
+ *dp = '\0';\r
+ if (kwarn)\r
+ png_warning(png_ptr, "extra interior spaces removed from keyword");\r
+\r
+ if (key_len == 0)\r
+ {\r
+ png_free(png_ptr, *new_key);\r
+ *new_key=NULL;\r
+ png_warning(png_ptr, "Zero length keyword");\r
+ }\r
+\r
+ if (key_len > 79)\r
+ {\r
+ png_warning(png_ptr, "keyword length must be 1 - 79 characters");\r
+ new_key[79] = '\0';\r
+ key_len = 79;\r
+ }\r
+\r
+ return (key_len);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tEXt_SUPPORTED)\r
+/* write a tEXt chunk */\r
+void /* PRIVATE */\r
+png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text,\r
+ png_size_t text_len)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_tEXt;\r
+#endif\r
+ png_size_t key_len;\r
+ png_charp new_key;\r
+\r
+ png_debug(1, "in png_write_tEXt\n");\r
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)\r
+ {\r
+ png_warning(png_ptr, "Empty keyword in tEXt chunk");\r
+ return;\r
+ }\r
+\r
+ if (text == NULL || *text == '\0')\r
+ text_len = 0;\r
+ else\r
+ text_len = png_strlen(text);\r
+\r
+ /* make sure we include the 0 after the key */\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_tEXt,\r
+ (png_uint_32)(key_len + text_len + 1));\r
+ /*\r
+ * We leave it to the application to meet PNG-1.0 requirements on the\r
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of\r
+ * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.\r
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.\r
+ */\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,\r
+ (png_size_t)(key_len + 1));\r
+ if (text_len)\r
+ png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);\r
+\r
+ png_write_chunk_end(png_ptr);\r
+ png_free(png_ptr, new_key);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_zTXt_SUPPORTED)\r
+/* write a compressed text chunk */\r
+void /* PRIVATE */\r
+png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,\r
+ png_size_t text_len, int compression)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_zTXt;\r
+#endif\r
+ png_size_t key_len;\r
+ char buf[1];\r
+ png_charp new_key;\r
+ compression_state comp;\r
+\r
+ png_debug(1, "in png_write_zTXt\n");\r
+\r
+ comp.num_output_ptr = 0;\r
+ comp.max_output_ptr = 0;\r
+ comp.output_ptr = NULL;\r
+ comp.input = NULL;\r
+ comp.input_len = 0;\r
+\r
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)\r
+ {\r
+ png_warning(png_ptr, "Empty keyword in zTXt chunk");\r
+ png_free(png_ptr, new_key);\r
+ return;\r
+ }\r
+\r
+ if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)\r
+ {\r
+ png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);\r
+ png_free(png_ptr, new_key);\r
+ return;\r
+ }\r
+\r
+ text_len = png_strlen(text);\r
+\r
+ /* compute the compressed data; do it now for the length */\r
+ text_len = png_text_compress(png_ptr, text, text_len, compression,\r
+ &comp);\r
+\r
+ /* write start of chunk */\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_zTXt,\r
+ (png_uint_32)(key_len+text_len + 2));\r
+ /* write key */\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,\r
+ (png_size_t)(key_len + 1));\r
+ png_free(png_ptr, new_key);\r
+\r
+ buf[0] = (png_byte)compression;\r
+ /* write compression */\r
+ png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);\r
+ /* write the compressed data */\r
+ png_write_compressed_data_out(png_ptr, &comp);\r
+\r
+ /* close the chunk */\r
+ png_write_chunk_end(png_ptr);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_iTXt_SUPPORTED)\r
+/* write an iTXt chunk */\r
+void /* PRIVATE */\r
+png_write_iTXt(png_structp png_ptr, int compression, png_charp key,\r
+ png_charp lang, png_charp lang_key, png_charp text)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_iTXt;\r
+#endif\r
+ png_size_t lang_len, key_len, lang_key_len, text_len;\r
+ png_charp new_lang, new_key;\r
+ png_byte cbuf[2];\r
+ compression_state comp;\r
+\r
+ png_debug(1, "in png_write_iTXt\n");\r
+\r
+ comp.num_output_ptr = 0;\r
+ comp.max_output_ptr = 0;\r
+ comp.output_ptr = NULL;\r
+ comp.input = NULL;\r
+\r
+ if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)\r
+ {\r
+ png_warning(png_ptr, "Empty keyword in iTXt chunk");\r
+ return;\r
+ }\r
+ if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0)\r
+ {\r
+ png_warning(png_ptr, "Empty language field in iTXt chunk");\r
+ new_lang = NULL;\r
+ lang_len = 0;\r
+ }\r
+\r
+ if (lang_key == NULL)\r
+ lang_key_len = 0;\r
+ else\r
+ lang_key_len = png_strlen(lang_key);\r
+\r
+ if (text == NULL)\r
+ text_len = 0;\r
+ else\r
+ text_len = png_strlen(text);\r
+\r
+ /* compute the compressed data; do it now for the length */\r
+ text_len = png_text_compress(png_ptr, text, text_len, compression-2,\r
+ &comp);\r
+\r
+\r
+ /* make sure we include the compression flag, the compression byte,\r
+ * and the NULs after the key, lang, and lang_key parts */\r
+\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_iTXt,\r
+ (png_uint_32)(\r
+ 5 /* comp byte, comp flag, terminators for key, lang and lang_key */\r
+ + key_len\r
+ + lang_len\r
+ + lang_key_len\r
+ + text_len));\r
+\r
+ /*\r
+ * We leave it to the application to meet PNG-1.0 requirements on the\r
+ * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of\r
+ * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.\r
+ * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.\r
+ */\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_key,\r
+ (png_size_t)(key_len + 1));\r
+\r
+ /* set the compression flag */\r
+ if (compression == PNG_ITXT_COMPRESSION_NONE || \\r
+ compression == PNG_TEXT_COMPRESSION_NONE)\r
+ cbuf[0] = 0;\r
+ else /* compression == PNG_ITXT_COMPRESSION_zTXt */\r
+ cbuf[0] = 1;\r
+ /* set the compression method */\r
+ cbuf[1] = 0;\r
+ png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);\r
+\r
+ cbuf[0] = 0;\r
+ png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),\r
+ (png_size_t)(lang_len + 1));\r
+ png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),\r
+ (png_size_t)(lang_key_len + 1));\r
+ png_write_compressed_data_out(png_ptr, &comp);\r
+\r
+ png_write_chunk_end(png_ptr);\r
+ png_free(png_ptr, new_key);\r
+ png_free(png_ptr, new_lang);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_oFFs_SUPPORTED)\r
+/* write the oFFs chunk */\r
+void /* PRIVATE */\r
+png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset,\r
+ int unit_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_oFFs;\r
+#endif\r
+ png_byte buf[9];\r
+\r
+ png_debug(1, "in png_write_oFFs\n");\r
+ if (unit_type >= PNG_OFFSET_LAST)\r
+ png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");\r
+\r
+ png_save_int_32(buf, x_offset);\r
+ png_save_int_32(buf + 4, y_offset);\r
+ buf[8] = (png_byte)unit_type;\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9);\r
+}\r
+#endif\r
+#if defined(PNG_WRITE_pCAL_SUPPORTED)\r
+/* write the pCAL chunk (described in the PNG extensions document) */\r
+void /* PRIVATE */\r
+png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,\r
+ png_int_32 X1, int type, int nparams, png_charp units, png_charpp params)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_pCAL;\r
+#endif\r
+ png_size_t purpose_len, units_len, total_len;\r
+ png_uint_32p params_len;\r
+ png_byte buf[10];\r
+ png_charp new_purpose;\r
+ int i;\r
+\r
+ png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams);\r
+ if (type >= PNG_EQUATION_LAST)\r
+ png_warning(png_ptr, "Unrecognized equation type for pCAL chunk");\r
+\r
+ purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1;\r
+ png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len);\r
+ units_len = png_strlen(units) + (nparams == 0 ? 0 : 1);\r
+ png_debug1(3, "pCAL units length = %d\n", (int)units_len);\r
+ total_len = purpose_len + units_len + 10;\r
+\r
+ params_len = (png_uint_32p)png_malloc(png_ptr,\r
+ (png_uint_32)(nparams * png_sizeof(png_uint_32)));\r
+\r
+ /* Find the length of each parameter, making sure we don't count the\r
+ null terminator for the last parameter. */\r
+ for (i = 0; i < nparams; i++)\r
+ {\r
+ params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1);\r
+ png_debug2(3, "pCAL parameter %d length = %lu\n", i,\r
+ (unsigned long) params_len[i]);\r
+ total_len += (png_size_t)params_len[i];\r
+ }\r
+\r
+ png_debug1(3, "pCAL total length = %d\n", (int)total_len);\r
+ png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len);\r
+ png_write_chunk_data(png_ptr, (png_bytep)new_purpose,\r
+ (png_size_t)purpose_len);\r
+ png_save_int_32(buf, X0);\r
+ png_save_int_32(buf + 4, X1);\r
+ buf[8] = (png_byte)type;\r
+ buf[9] = (png_byte)nparams;\r
+ png_write_chunk_data(png_ptr, buf, (png_size_t)10);\r
+ png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);\r
+\r
+ png_free(png_ptr, new_purpose);\r
+\r
+ for (i = 0; i < nparams; i++)\r
+ {\r
+ png_write_chunk_data(png_ptr, (png_bytep)params[i],\r
+ (png_size_t)params_len[i]);\r
+ }\r
+\r
+ png_free(png_ptr, params_len);\r
+ png_write_chunk_end(png_ptr);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_sCAL_SUPPORTED)\r
+/* write the sCAL chunk */\r
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)\r
+void /* PRIVATE */\r
+png_write_sCAL(png_structp png_ptr, int unit, double width, double height)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_sCAL;\r
+#endif\r
+ char buf[64];\r
+ png_size_t total_len;\r
+\r
+ png_debug(1, "in png_write_sCAL\n");\r
+\r
+ buf[0] = (char)unit;\r
+#if defined(_WIN32_WCE)\r
+/* sprintf() function is not supported on WindowsCE */\r
+ {\r
+ wchar_t wc_buf[32];\r
+ size_t wc_len;\r
+ swprintf(wc_buf, TEXT("%12.12e"), width);\r
+ wc_len = wcslen(wc_buf);\r
+ WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + 1, wc_len, NULL, NULL);\r
+ total_len = wc_len + 2;\r
+ swprintf(wc_buf, TEXT("%12.12e"), height);\r
+ wc_len = wcslen(wc_buf);\r
+ WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + total_len, wc_len,\r
+ NULL, NULL);\r
+ total_len += wc_len;\r
+ }\r
+#else\r
+ png_snprintf(buf + 1, 63, "%12.12e", width);\r
+ total_len = 1 + png_strlen(buf + 1) + 1;\r
+ png_snprintf(buf + total_len, 64-total_len, "%12.12e", height);\r
+ total_len += png_strlen(buf + total_len);\r
+#endif\r
+\r
+ png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);\r
+ png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len);\r
+}\r
+#else\r
+#ifdef PNG_FIXED_POINT_SUPPORTED\r
+void /* PRIVATE */\r
+png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width,\r
+ png_charp height)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_sCAL;\r
+#endif\r
+ png_byte buf[64];\r
+ png_size_t wlen, hlen, total_len;\r
+\r
+ png_debug(1, "in png_write_sCAL_s\n");\r
+\r
+ wlen = png_strlen(width);\r
+ hlen = png_strlen(height);\r
+ total_len = wlen + hlen + 2;\r
+ if (total_len > 64)\r
+ {\r
+ png_warning(png_ptr, "Can't write sCAL (buffer too small)");\r
+ return;\r
+ }\r
+\r
+ buf[0] = (png_byte)unit;\r
+ png_memcpy(buf + 1, width, wlen + 1); /* append the '\0' here */\r
+ png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */\r
+\r
+ png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len);\r
+ png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len);\r
+}\r
+#endif\r
+#endif\r
+#endif\r
+\r
+#if defined(PNG_WRITE_pHYs_SUPPORTED)\r
+/* write the pHYs chunk */\r
+void /* PRIVATE */\r
+png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit,\r
+ png_uint_32 y_pixels_per_unit,\r
+ int unit_type)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_pHYs;\r
+#endif\r
+ png_byte buf[9];\r
+\r
+ png_debug(1, "in png_write_pHYs\n");\r
+ if (unit_type >= PNG_RESOLUTION_LAST)\r
+ png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");\r
+\r
+ png_save_uint_32(buf, x_pixels_per_unit);\r
+ png_save_uint_32(buf + 4, y_pixels_per_unit);\r
+ buf[8] = (png_byte)unit_type;\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);\r
+}\r
+#endif\r
+\r
+#if defined(PNG_WRITE_tIME_SUPPORTED)\r
+/* Write the tIME chunk. Use either png_convert_from_struct_tm()\r
+ * or png_convert_from_time_t(), or fill in the structure yourself.\r
+ */\r
+void /* PRIVATE */\r
+png_write_tIME(png_structp png_ptr, png_timep mod_time)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ PNG_tIME;\r
+#endif\r
+ png_byte buf[7];\r
+\r
+ png_debug(1, "in png_write_tIME\n");\r
+ if (mod_time->month > 12 || mod_time->month < 1 ||\r
+ mod_time->day > 31 || mod_time->day < 1 ||\r
+ mod_time->hour > 23 || mod_time->second > 60)\r
+ {\r
+ png_warning(png_ptr, "Invalid time specified for tIME chunk");\r
+ return;\r
+ }\r
+\r
+ png_save_uint_16(buf, mod_time->year);\r
+ buf[2] = mod_time->month;\r
+ buf[3] = mod_time->day;\r
+ buf[4] = mod_time->hour;\r
+ buf[5] = mod_time->minute;\r
+ buf[6] = mod_time->second;\r
+\r
+ png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);\r
+}\r
+#endif\r
+\r
+/* initializes the row writing capability of libpng */\r
+void /* PRIVATE */\r
+png_write_start_row(png_structp png_ptr)\r
+{\r
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+ /* start of interlace block in the y direction */\r
+ int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+ /* offset to next interlace block in the y direction */\r
+ int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};\r
+#endif\r
+#endif\r
+\r
+ png_size_t buf_size;\r
+\r
+ png_debug(1, "in png_write_start_row\n");\r
+ buf_size = (png_size_t)(PNG_ROWBYTES(\r
+ png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);\r
+\r
+ /* set up row buffer */\r
+ png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)buf_size);\r
+ png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;\r
+\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ /* set up filtering buffer, if using this filter */\r
+ if (png_ptr->do_filter & PNG_FILTER_SUB)\r
+ {\r
+ png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(png_ptr->rowbytes + 1));\r
+ png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;\r
+ }\r
+\r
+ /* We only need to keep the previous row if we are using one of these. */\r
+ if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))\r
+ {\r
+ /* set up previous row buffer */\r
+ png_ptr->prev_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)buf_size);\r
+ png_memset(png_ptr->prev_row, 0, buf_size);\r
+\r
+ if (png_ptr->do_filter & PNG_FILTER_UP)\r
+ {\r
+ png_ptr->up_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(png_ptr->rowbytes + 1));\r
+ png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;\r
+ }\r
+\r
+ if (png_ptr->do_filter & PNG_FILTER_AVG)\r
+ {\r
+ png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(png_ptr->rowbytes + 1));\r
+ png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;\r
+ }\r
+\r
+ if (png_ptr->do_filter & PNG_FILTER_PAETH)\r
+ {\r
+ png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,\r
+ (png_uint_32)(png_ptr->rowbytes + 1));\r
+ png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;\r
+ }\r
+ }\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+\r
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED\r
+ /* if interlaced, we need to set up width and height of pass */\r
+ if (png_ptr->interlaced)\r
+ {\r
+ if (!(png_ptr->transformations & PNG_INTERLACE))\r
+ {\r
+ png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -\r
+ png_pass_ystart[0]) / png_pass_yinc[0];\r
+ png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -\r
+ png_pass_start[0]) / png_pass_inc[0];\r
+ }\r
+ else\r
+ {\r
+ png_ptr->num_rows = png_ptr->height;\r
+ png_ptr->usr_width = png_ptr->width;\r
+ }\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ png_ptr->num_rows = png_ptr->height;\r
+ png_ptr->usr_width = png_ptr->width;\r
+ }\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+}\r
+\r
+/* Internal use only. Called when finished processing a row of data. */\r
+void /* PRIVATE */\r
+png_write_finish_row(png_structp png_ptr)\r
+{\r
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+\r
+ /* start of interlace block in the y direction */\r
+ int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};\r
+\r
+ /* offset to next interlace block in the y direction */\r
+ int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};\r
+#endif\r
+#endif\r
+\r
+ int ret;\r
+\r
+ png_debug(1, "in png_write_finish_row\n");\r
+ /* next row */\r
+ png_ptr->row_number++;\r
+\r
+ /* see if we are done */\r
+ if (png_ptr->row_number < png_ptr->num_rows)\r
+ return;\r
+\r
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED\r
+ /* if interlaced, go to next pass */\r
+ if (png_ptr->interlaced)\r
+ {\r
+ png_ptr->row_number = 0;\r
+ if (png_ptr->transformations & PNG_INTERLACE)\r
+ {\r
+ png_ptr->pass++;\r
+ }\r
+ else\r
+ {\r
+ /* loop until we find a non-zero width or height pass */\r
+ do\r
+ {\r
+ png_ptr->pass++;\r
+ if (png_ptr->pass >= 7)\r
+ break;\r
+ png_ptr->usr_width = (png_ptr->width +\r
+ png_pass_inc[png_ptr->pass] - 1 -\r
+ png_pass_start[png_ptr->pass]) /\r
+ png_pass_inc[png_ptr->pass];\r
+ png_ptr->num_rows = (png_ptr->height +\r
+ png_pass_yinc[png_ptr->pass] - 1 -\r
+ png_pass_ystart[png_ptr->pass]) /\r
+ png_pass_yinc[png_ptr->pass];\r
+ if (png_ptr->transformations & PNG_INTERLACE)\r
+ break;\r
+ } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);\r
+\r
+ }\r
+\r
+ /* reset the row above the image for the next pass */\r
+ if (png_ptr->pass < 7)\r
+ {\r
+ if (png_ptr->prev_row != NULL)\r
+ png_memset(png_ptr->prev_row, 0,\r
+ (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*\r
+ png_ptr->usr_bit_depth, png_ptr->width)) + 1);\r
+ return;\r
+ }\r
+ }\r
+#endif\r
+\r
+ /* if we get here, we've just written the last row, so we need\r
+ to flush the compressor */\r
+ do\r
+ {\r
+ /* tell the compressor we are done */\r
+ ret = deflate(&png_ptr->zstream, Z_FINISH);\r
+ /* check for an error */\r
+ if (ret == Z_OK)\r
+ {\r
+ /* check to see if we need more room */\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ }\r
+ }\r
+ else if (ret != Z_STREAM_END)\r
+ {\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_error(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_error(png_ptr, "zlib error");\r
+ }\r
+ } while (ret != Z_STREAM_END);\r
+\r
+ /* write any extra space */\r
+ if (png_ptr->zstream.avail_out < png_ptr->zbuf_size)\r
+ {\r
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size -\r
+ png_ptr->zstream.avail_out);\r
+ }\r
+\r
+ deflateReset(&png_ptr->zstream);\r
+ png_ptr->zstream.data_type = Z_BINARY;\r
+}\r
+\r
+#if defined(PNG_WRITE_INTERLACING_SUPPORTED)\r
+/* Pick out the correct pixels for the interlace pass.\r
+ * The basic idea here is to go through the row with a source\r
+ * pointer and a destination pointer (sp and dp), and copy the\r
+ * correct pixels for the pass. As the row gets compacted,\r
+ * sp will always be >= dp, so we should never overwrite anything.\r
+ * See the default: case for the easiest code to understand.\r
+ */\r
+void /* PRIVATE */\r
+png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)\r
+{\r
+#ifdef PNG_USE_LOCAL_ARRAYS\r
+ /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */\r
+\r
+ /* start of interlace block */\r
+ int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};\r
+\r
+ /* offset to next interlace block */\r
+ int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};\r
+#endif\r
+\r
+ png_debug(1, "in png_do_write_interlace\n");\r
+ /* we don't have to do anything on the last pass (6) */\r
+#if defined(PNG_USELESS_TESTS_SUPPORTED)\r
+ if (row != NULL && row_info != NULL && pass < 6)\r
+#else\r
+ if (pass < 6)\r
+#endif\r
+ {\r
+ /* each pixel depth is handled separately */\r
+ switch (row_info->pixel_depth)\r
+ {\r
+ case 1:\r
+ {\r
+ png_bytep sp;\r
+ png_bytep dp;\r
+ int shift;\r
+ int d;\r
+ int value;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ dp = row;\r
+ d = 0;\r
+ shift = 7;\r
+ for (i = png_pass_start[pass]; i < row_width;\r
+ i += png_pass_inc[pass])\r
+ {\r
+ sp = row + (png_size_t)(i >> 3);\r
+ value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;\r
+ d |= (value << shift);\r
+\r
+ if (shift == 0)\r
+ {\r
+ shift = 7;\r
+ *dp++ = (png_byte)d;\r
+ d = 0;\r
+ }\r
+ else\r
+ shift--;\r
+\r
+ }\r
+ if (shift != 7)\r
+ *dp = (png_byte)d;\r
+ break;\r
+ }\r
+ case 2:\r
+ {\r
+ png_bytep sp;\r
+ png_bytep dp;\r
+ int shift;\r
+ int d;\r
+ int value;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ dp = row;\r
+ shift = 6;\r
+ d = 0;\r
+ for (i = png_pass_start[pass]; i < row_width;\r
+ i += png_pass_inc[pass])\r
+ {\r
+ sp = row + (png_size_t)(i >> 2);\r
+ value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;\r
+ d |= (value << shift);\r
+\r
+ if (shift == 0)\r
+ {\r
+ shift = 6;\r
+ *dp++ = (png_byte)d;\r
+ d = 0;\r
+ }\r
+ else\r
+ shift -= 2;\r
+ }\r
+ if (shift != 6)\r
+ *dp = (png_byte)d;\r
+ break;\r
+ }\r
+ case 4:\r
+ {\r
+ png_bytep sp;\r
+ png_bytep dp;\r
+ int shift;\r
+ int d;\r
+ int value;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+\r
+ dp = row;\r
+ shift = 4;\r
+ d = 0;\r
+ for (i = png_pass_start[pass]; i < row_width;\r
+ i += png_pass_inc[pass])\r
+ {\r
+ sp = row + (png_size_t)(i >> 1);\r
+ value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;\r
+ d |= (value << shift);\r
+\r
+ if (shift == 0)\r
+ {\r
+ shift = 4;\r
+ *dp++ = (png_byte)d;\r
+ d = 0;\r
+ }\r
+ else\r
+ shift -= 4;\r
+ }\r
+ if (shift != 4)\r
+ *dp = (png_byte)d;\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ png_bytep sp;\r
+ png_bytep dp;\r
+ png_uint_32 i;\r
+ png_uint_32 row_width = row_info->width;\r
+ png_size_t pixel_bytes;\r
+\r
+ /* start at the beginning */\r
+ dp = row;\r
+ /* find out how many bytes each pixel takes up */\r
+ pixel_bytes = (row_info->pixel_depth >> 3);\r
+ /* loop through the row, only looking at the pixels that\r
+ matter */\r
+ for (i = png_pass_start[pass]; i < row_width;\r
+ i += png_pass_inc[pass])\r
+ {\r
+ /* find out where the original pixel is */\r
+ sp = row + (png_size_t)i * pixel_bytes;\r
+ /* move the pixel */\r
+ if (dp != sp)\r
+ png_memcpy(dp, sp, pixel_bytes);\r
+ /* next pixel */\r
+ dp += pixel_bytes;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ /* set new row width */\r
+ row_info->width = (row_info->width +\r
+ png_pass_inc[pass] - 1 -\r
+ png_pass_start[pass]) /\r
+ png_pass_inc[pass];\r
+ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,\r
+ row_info->width);\r
+ }\r
+}\r
+#endif\r
+\r
+/* This filters the row, chooses which filter to use, if it has not already\r
+ * been specified by the application, and then writes the row out with the\r
+ * chosen filter.\r
+ */\r
+#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1)\r
+#define PNG_HISHIFT 10\r
+#define PNG_LOMASK ((png_uint_32)0xffffL)\r
+#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT))\r
+void /* PRIVATE */\r
+png_write_find_filter(png_structp png_ptr, png_row_infop row_info)\r
+{\r
+ png_bytep best_row;\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ png_bytep prev_row, row_buf;\r
+ png_uint_32 mins, bpp;\r
+ png_byte filter_to_do = png_ptr->do_filter;\r
+ png_uint_32 row_bytes = row_info->rowbytes;\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ int num_p_filters = (int)png_ptr->num_prev_filters;\r
+#endif\r
+\r
+ png_debug(1, "in png_write_find_filter\n");\r
+ /* find out how many bytes offset each pixel is */\r
+ bpp = (row_info->pixel_depth + 7) >> 3;\r
+\r
+ prev_row = png_ptr->prev_row;\r
+#endif\r
+ best_row = png_ptr->row_buf;\r
+#ifndef PNG_NO_WRITE_FILTER\r
+ row_buf = best_row;\r
+ mins = PNG_MAXSUM;\r
+\r
+ /* The prediction method we use is to find which method provides the\r
+ * smallest value when summing the absolute values of the distances\r
+ * from zero, using anything >= 128 as negative numbers. This is known\r
+ * as the "minimum sum of absolute differences" heuristic. Other\r
+ * heuristics are the "weighted minimum sum of absolute differences"\r
+ * (experimental and can in theory improve compression), and the "zlib\r
+ * predictive" method (not implemented yet), which does test compressions\r
+ * of lines using different filter methods, and then chooses the\r
+ * (series of) filter(s) that give minimum compressed data size (VERY\r
+ * computationally expensive).\r
+ *\r
+ * GRR 980525: consider also\r
+ * (1) minimum sum of absolute differences from running average (i.e.,\r
+ * keep running sum of non-absolute differences & count of bytes)\r
+ * [track dispersion, too? restart average if dispersion too large?]\r
+ * (1b) minimum sum of absolute differences from sliding average, probably\r
+ * with window size <= deflate window (usually 32K)\r
+ * (2) minimum sum of squared differences from zero or running average\r
+ * (i.e., ~ root-mean-square approach)\r
+ */\r
+\r
+\r
+ /* We don't need to test the 'no filter' case if this is the only filter\r
+ * that has been chosen, as it doesn't actually do anything to the data.\r
+ */\r
+ if ((filter_to_do & PNG_FILTER_NONE) &&\r
+ filter_to_do != PNG_FILTER_NONE)\r
+ {\r
+ png_bytep rp;\r
+ png_uint_32 sum = 0;\r
+ png_uint_32 i;\r
+ int v;\r
+\r
+ for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)\r
+ {\r
+ v = *rp;\r
+ sum += (v < 128) ? v : 256 - v;\r
+ }\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ png_uint_32 sumhi, sumlo;\r
+ int j;\r
+ sumlo = sum & PNG_LOMASK;\r
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */\r
+\r
+ /* Reduce the sum if we match any of the previous rows */\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)\r
+ {\r
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ /* Factor in the cost of this filter (this is here for completeness,\r
+ * but it makes no sense to have a "cost" for the NONE filter, as\r
+ * it has the minimum possible computational cost - none).\r
+ */\r
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>\r
+ PNG_COST_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (sumhi > PNG_HIMASK)\r
+ sum = PNG_MAXSUM;\r
+ else\r
+ sum = (sumhi << PNG_HISHIFT) + sumlo;\r
+ }\r
+#endif\r
+ mins = sum;\r
+ }\r
+\r
+ /* sub filter */\r
+ if (filter_to_do == PNG_FILTER_SUB)\r
+ /* it's the only filter so no testing is needed */\r
+ {\r
+ png_bytep rp, lp, dp;\r
+ png_uint_32 i;\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;\r
+ i++, rp++, dp++)\r
+ {\r
+ *dp = *rp;\r
+ }\r
+ for (lp = row_buf + 1; i < row_bytes;\r
+ i++, rp++, lp++, dp++)\r
+ {\r
+ *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);\r
+ }\r
+ best_row = png_ptr->sub_row;\r
+ }\r
+\r
+ else if (filter_to_do & PNG_FILTER_SUB)\r
+ {\r
+ png_bytep rp, dp, lp;\r
+ png_uint_32 sum = 0, lmins = mins;\r
+ png_uint_32 i;\r
+ int v;\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ /* We temporarily increase the "minimum sum" by the factor we\r
+ * would reduce the sum of this filter, so that we can do the\r
+ * early exit comparison without scaling the sum each time.\r
+ */\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 lmhi, lmlo;\r
+ lmlo = lmins & PNG_LOMASK;\r
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)\r
+ {\r
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>\r
+ PNG_COST_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (lmhi > PNG_HIMASK)\r
+ lmins = PNG_MAXSUM;\r
+ else\r
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;\r
+ }\r
+#endif\r
+\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;\r
+ i++, rp++, dp++)\r
+ {\r
+ v = *dp = *rp;\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+ }\r
+ for (lp = row_buf + 1; i < row_bytes;\r
+ i++, rp++, lp++, dp++)\r
+ {\r
+ v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+\r
+ if (sum > lmins) /* We are already worse, don't continue. */\r
+ break;\r
+ }\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 sumhi, sumlo;\r
+ sumlo = sum & PNG_LOMASK;\r
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)\r
+ {\r
+ sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>\r
+ PNG_COST_SHIFT;\r
+ sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (sumhi > PNG_HIMASK)\r
+ sum = PNG_MAXSUM;\r
+ else\r
+ sum = (sumhi << PNG_HISHIFT) + sumlo;\r
+ }\r
+#endif\r
+\r
+ if (sum < mins)\r
+ {\r
+ mins = sum;\r
+ best_row = png_ptr->sub_row;\r
+ }\r
+ }\r
+\r
+ /* up filter */\r
+ if (filter_to_do == PNG_FILTER_UP)\r
+ {\r
+ png_bytep rp, dp, pp;\r
+ png_uint_32 i;\r
+\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,\r
+ pp = prev_row + 1; i < row_bytes;\r
+ i++, rp++, pp++, dp++)\r
+ {\r
+ *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);\r
+ }\r
+ best_row = png_ptr->up_row;\r
+ }\r
+\r
+ else if (filter_to_do & PNG_FILTER_UP)\r
+ {\r
+ png_bytep rp, dp, pp;\r
+ png_uint_32 sum = 0, lmins = mins;\r
+ png_uint_32 i;\r
+ int v;\r
+\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 lmhi, lmlo;\r
+ lmlo = lmins & PNG_LOMASK;\r
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)\r
+ {\r
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>\r
+ PNG_COST_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (lmhi > PNG_HIMASK)\r
+ lmins = PNG_MAXSUM;\r
+ else\r
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;\r
+ }\r
+#endif\r
+\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,\r
+ pp = prev_row + 1; i < row_bytes; i++)\r
+ {\r
+ v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+\r
+ if (sum > lmins) /* We are already worse, don't continue. */\r
+ break;\r
+ }\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 sumhi, sumlo;\r
+ sumlo = sum & PNG_LOMASK;\r
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)\r
+ {\r
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>\r
+ PNG_COST_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (sumhi > PNG_HIMASK)\r
+ sum = PNG_MAXSUM;\r
+ else\r
+ sum = (sumhi << PNG_HISHIFT) + sumlo;\r
+ }\r
+#endif\r
+\r
+ if (sum < mins)\r
+ {\r
+ mins = sum;\r
+ best_row = png_ptr->up_row;\r
+ }\r
+ }\r
+\r
+ /* avg filter */\r
+ if (filter_to_do == PNG_FILTER_AVG)\r
+ {\r
+ png_bytep rp, dp, pp, lp;\r
+ png_uint_32 i;\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,\r
+ pp = prev_row + 1; i < bpp; i++)\r
+ {\r
+ *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);\r
+ }\r
+ for (lp = row_buf + 1; i < row_bytes; i++)\r
+ {\r
+ *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))\r
+ & 0xff);\r
+ }\r
+ best_row = png_ptr->avg_row;\r
+ }\r
+\r
+ else if (filter_to_do & PNG_FILTER_AVG)\r
+ {\r
+ png_bytep rp, dp, pp, lp;\r
+ png_uint_32 sum = 0, lmins = mins;\r
+ png_uint_32 i;\r
+ int v;\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 lmhi, lmlo;\r
+ lmlo = lmins & PNG_LOMASK;\r
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)\r
+ {\r
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>\r
+ PNG_COST_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (lmhi > PNG_HIMASK)\r
+ lmins = PNG_MAXSUM;\r
+ else\r
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;\r
+ }\r
+#endif\r
+\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,\r
+ pp = prev_row + 1; i < bpp; i++)\r
+ {\r
+ v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+ }\r
+ for (lp = row_buf + 1; i < row_bytes; i++)\r
+ {\r
+ v = *dp++ =\r
+ (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+\r
+ if (sum > lmins) /* We are already worse, don't continue. */\r
+ break;\r
+ }\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 sumhi, sumlo;\r
+ sumlo = sum & PNG_LOMASK;\r
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)\r
+ {\r
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>\r
+ PNG_COST_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (sumhi > PNG_HIMASK)\r
+ sum = PNG_MAXSUM;\r
+ else\r
+ sum = (sumhi << PNG_HISHIFT) + sumlo;\r
+ }\r
+#endif\r
+\r
+ if (sum < mins)\r
+ {\r
+ mins = sum;\r
+ best_row = png_ptr->avg_row;\r
+ }\r
+ }\r
+\r
+ /* Paeth filter */\r
+ if (filter_to_do == PNG_FILTER_PAETH)\r
+ {\r
+ png_bytep rp, dp, pp, cp, lp;\r
+ png_uint_32 i;\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,\r
+ pp = prev_row + 1; i < bpp; i++)\r
+ {\r
+ *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);\r
+ }\r
+\r
+ for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)\r
+ {\r
+ int a, b, c, pa, pb, pc, p;\r
+\r
+ b = *pp++;\r
+ c = *cp++;\r
+ a = *lp++;\r
+\r
+ p = b - c;\r
+ pc = a - c;\r
+\r
+#ifdef PNG_USE_ABS\r
+ pa = abs(p);\r
+ pb = abs(pc);\r
+ pc = abs(p + pc);\r
+#else\r
+ pa = p < 0 ? -p : p;\r
+ pb = pc < 0 ? -pc : pc;\r
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;\r
+#endif\r
+\r
+ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;\r
+\r
+ *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);\r
+ }\r
+ best_row = png_ptr->paeth_row;\r
+ }\r
+\r
+ else if (filter_to_do & PNG_FILTER_PAETH)\r
+ {\r
+ png_bytep rp, dp, pp, cp, lp;\r
+ png_uint_32 sum = 0, lmins = mins;\r
+ png_uint_32 i;\r
+ int v;\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 lmhi, lmlo;\r
+ lmlo = lmins & PNG_LOMASK;\r
+ lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)\r
+ {\r
+ lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>\r
+ PNG_COST_SHIFT;\r
+ lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (lmhi > PNG_HIMASK)\r
+ lmins = PNG_MAXSUM;\r
+ else\r
+ lmins = (lmhi << PNG_HISHIFT) + lmlo;\r
+ }\r
+#endif\r
+\r
+ for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,\r
+ pp = prev_row + 1; i < bpp; i++)\r
+ {\r
+ v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+ }\r
+\r
+ for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)\r
+ {\r
+ int a, b, c, pa, pb, pc, p;\r
+\r
+ b = *pp++;\r
+ c = *cp++;\r
+ a = *lp++;\r
+\r
+#ifndef PNG_SLOW_PAETH\r
+ p = b - c;\r
+ pc = a - c;\r
+#ifdef PNG_USE_ABS\r
+ pa = abs(p);\r
+ pb = abs(pc);\r
+ pc = abs(p + pc);\r
+#else\r
+ pa = p < 0 ? -p : p;\r
+ pb = pc < 0 ? -pc : pc;\r
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;\r
+#endif\r
+ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;\r
+#else /* PNG_SLOW_PAETH */\r
+ p = a + b - c;\r
+ pa = abs(p - a);\r
+ pb = abs(p - b);\r
+ pc = abs(p - c);\r
+ if (pa <= pb && pa <= pc)\r
+ p = a;\r
+ else if (pb <= pc)\r
+ p = b;\r
+ else\r
+ p = c;\r
+#endif /* PNG_SLOW_PAETH */\r
+\r
+ v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);\r
+\r
+ sum += (v < 128) ? v : 256 - v;\r
+\r
+ if (sum > lmins) /* We are already worse, don't continue. */\r
+ break;\r
+ }\r
+\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)\r
+ {\r
+ int j;\r
+ png_uint_32 sumhi, sumlo;\r
+ sumlo = sum & PNG_LOMASK;\r
+ sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;\r
+\r
+ for (j = 0; j < num_p_filters; j++)\r
+ {\r
+ if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)\r
+ {\r
+ sumlo = (sumlo * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_weights[j]) >>\r
+ PNG_WEIGHT_SHIFT;\r
+ }\r
+ }\r
+\r
+ sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>\r
+ PNG_COST_SHIFT;\r
+ sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>\r
+ PNG_COST_SHIFT;\r
+\r
+ if (sumhi > PNG_HIMASK)\r
+ sum = PNG_MAXSUM;\r
+ else\r
+ sum = (sumhi << PNG_HISHIFT) + sumlo;\r
+ }\r
+#endif\r
+\r
+ if (sum < mins)\r
+ {\r
+ best_row = png_ptr->paeth_row;\r
+ }\r
+ }\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+ /* Do the actual writing of the filtered row data from the chosen filter. */\r
+\r
+ png_write_filtered_row(png_ptr, best_row);\r
+\r
+#ifndef PNG_NO_WRITE_FILTER\r
+#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)\r
+ /* Save the type of filter we picked this time for future calculations */\r
+ if (png_ptr->num_prev_filters > 0)\r
+ {\r
+ int j;\r
+ for (j = 1; j < num_p_filters; j++)\r
+ {\r
+ png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];\r
+ }\r
+ png_ptr->prev_filters[j] = best_row[0];\r
+ }\r
+#endif\r
+#endif /* PNG_NO_WRITE_FILTER */\r
+}\r
+\r
+\r
+/* Do the actual writing of a previously filtered row. */\r
+void /* PRIVATE */\r
+png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row)\r
+{\r
+ png_debug(1, "in png_write_filtered_row\n");\r
+ png_debug1(2, "filter = %d\n", filtered_row[0]);\r
+ /* set up the zlib input buffer */\r
+\r
+ png_ptr->zstream.next_in = filtered_row;\r
+ png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1;\r
+ /* repeat until we have compressed all the data */\r
+ do\r
+ {\r
+ int ret; /* return of zlib */\r
+\r
+ /* compress the data */\r
+ ret = deflate(&png_ptr->zstream, Z_NO_FLUSH);\r
+ /* check for compression errors */\r
+ if (ret != Z_OK)\r
+ {\r
+ if (png_ptr->zstream.msg != NULL)\r
+ png_error(png_ptr, png_ptr->zstream.msg);\r
+ else\r
+ png_error(png_ptr, "zlib error");\r
+ }\r
+\r
+ /* see if it is time to write another IDAT */\r
+ if (!(png_ptr->zstream.avail_out))\r
+ {\r
+ /* write the IDAT and reset the zlib output buffer */\r
+ png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size);\r
+ png_ptr->zstream.next_out = png_ptr->zbuf;\r
+ png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;\r
+ }\r
+ /* repeat until all data has been compressed */\r
+ } while (png_ptr->zstream.avail_in);\r
+\r
+ /* swap the current and previous rows */\r
+ if (png_ptr->prev_row != NULL)\r
+ {\r
+ png_bytep tptr;\r
+\r
+ tptr = png_ptr->prev_row;\r
+ png_ptr->prev_row = png_ptr->row_buf;\r
+ png_ptr->row_buf = tptr;\r
+ }\r
+\r
+ /* finish row - updates counters and flushes zlib if last row */\r
+ png_write_finish_row(png_ptr);\r
+\r
+#if defined(PNG_WRITE_FLUSH_SUPPORTED)\r
+ png_ptr->flush_rows++;\r
+\r
+ if (png_ptr->flush_dist > 0 &&\r
+ png_ptr->flush_rows >= png_ptr->flush_dist)\r
+ {\r
+ png_write_flush(png_ptr);\r
+ }\r
+#endif\r
+}\r
+#endif /* PNG_WRITE_SUPPORTED */\r
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <string.h>
+#include "imago2.h"
+
+/* pixel-format conversions are sub-optimal at the moment to avoid
+ * writing a lot of code. optimize at some point ?
+ */
+
+#define CLAMP(x, a, b) ((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
+
+struct pixel {
+ float r, g, b, a;
+};
+
+static void unpack_grey8(struct pixel *unp, void *pptr, int count);
+static void unpack_rgb24(struct pixel *unp, void *pptr, int count);
+static void unpack_rgba32(struct pixel *unp, void *pptr, int count);
+static void unpack_greyf(struct pixel *unp, void *pptr, int count);
+static void unpack_rgbf(struct pixel *unp, void *pptr, int count);
+static void unpack_rgbaf(struct pixel *unp, void *pptr, int count);
+
+static void pack_grey8(void *pptr, struct pixel *unp, int count);
+static void pack_rgb24(void *pptr, struct pixel *unp, int count);
+static void pack_rgba32(void *pptr, struct pixel *unp, int count);
+static void pack_greyf(void *pptr, struct pixel *unp, int count);
+static void pack_rgbf(void *pptr, struct pixel *unp, int count);
+static void pack_rgbaf(void *pptr, struct pixel *unp, int count);
+
+/* XXX keep in sync with enum img_fmt at imago2.h */
+static void (*unpack[])(struct pixel*, void*, int) = {
+ unpack_grey8,
+ unpack_rgb24,
+ unpack_rgba32,
+ unpack_greyf,
+ unpack_rgbf,
+ unpack_rgbaf
+};
+
+/* XXX keep in sync with enum img_fmt at imago2.h */
+static void (*pack[])(void*, struct pixel*, int) = {
+ pack_grey8,
+ pack_rgb24,
+ pack_rgba32,
+ pack_greyf,
+ pack_rgbf,
+ pack_rgbaf
+};
+
+
+int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
+{
+ struct pixel pbuf[8];
+ int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
+ int i, num_pix = img->width * img->height;
+ int num_iter = num_pix / bufsz;
+ char *sptr, *dptr;
+ struct img_pixmap nimg;
+
+ if(img->fmt == tofmt) {
+ return 0; /* nothing to do */
+ }
+
+ img_init(&nimg);
+ if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
+ img_destroy(&nimg);
+ return -1;
+ }
+
+ sptr = img->pixels;
+ dptr = nimg.pixels;
+
+ for(i=0; i<num_iter; i++) {
+ unpack[img->fmt](pbuf, sptr, bufsz);
+ pack[tofmt](dptr, pbuf, bufsz);
+
+ sptr += bufsz * img->pixelsz;
+ dptr += bufsz * nimg.pixelsz;
+ }
+
+ img_copy(img, &nimg);
+ img_destroy(&nimg);
+ return 0;
+}
+
+/* the following functions *could* benefit from SIMD */
+
+static void unpack_grey8(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = unp->g = unp->b = (float)*pix++ / 255.0;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgb24(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = (float)*pix++ / 255.0;
+ unp->g = (float)*pix++ / 255.0;
+ unp->b = (float)*pix++ / 255.0;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgba32(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = (float)*pix++ / 255.0;
+ unp->g = (float)*pix++ / 255.0;
+ unp->b = (float)*pix++ / 255.0;
+ unp->a = (float)*pix++ / 255.0;
+ unp++;
+ }
+}
+
+static void unpack_greyf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = unp->g = unp->b = *pix++;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = *pix++;
+ unp->g = *pix++;
+ unp->b = *pix++;
+ unp->a = 1.0;
+ unp++;
+ }
+}
+
+static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ unp->r = *pix++;
+ unp->g = *pix++;
+ unp->b = *pix++;
+ unp->a = *pix++;
+ unp++;
+ }
+}
+
+
+static void pack_grey8(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
+ *pix++ = CLAMP(lum, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_rgb24(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int r = (int)(unp->r * 255.0);
+ int g = (int)(unp->g * 255.0);
+ int b = (int)(unp->b * 255.0);
+
+ *pix++ = CLAMP(r, 0, 255);
+ *pix++ = CLAMP(g, 0, 255);
+ *pix++ = CLAMP(b, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_rgba32(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ unsigned char *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ int r = (int)(unp->r * 255.0);
+ int g = (int)(unp->g * 255.0);
+ int b = (int)(unp->b * 255.0);
+ int a = (int)(unp->a * 255.0);
+
+ *pix++ = CLAMP(r, 0, 255);
+ *pix++ = CLAMP(g, 0, 255);
+ *pix++ = CLAMP(b, 0, 255);
+ *pix++ = CLAMP(a, 0, 255);
+ unp++;
+ }
+}
+
+static void pack_greyf(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ *pix++ = (unp->r + unp->g + unp->b) / 3.0;
+ unp++;
+ }
+}
+
+static void pack_rgbf(void *pptr, struct pixel *unp, int count)
+{
+ int i;
+ float *pix = pptr;
+
+ for(i=0; i<count; i++) {
+ *pix++ = unp->r;
+ *pix++ = unp->g;
+ *pix++ = unp->b;
+ unp++;
+ }
+}
+
+static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
+{
+ memcpy(pptr, unp, count * sizeof *unp);
+}
+
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- JPEG module -- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef WIN32
+#include <windows.h>
+#define HAVE_BOOLEAN
+#endif
+
+#include <jpeglib.h>
+#include "imago2.h"
+#include "ftmodule.h"
+
+#define INPUT_BUF_SIZE 512
+#define OUTPUT_BUF_SIZE 512
+
+/* data source manager: adapted from jdatasrc.c */
+struct src_mgr {
+ struct jpeg_source_mgr pub;
+
+ struct img_io *io;
+ unsigned char buffer[INPUT_BUF_SIZE];
+ int start_of_file;
+};
+
+/* data destination manager: adapted from jdatadst.c */
+struct dst_mgr {
+ struct jpeg_destination_mgr pub;
+
+ struct img_io *io;
+ unsigned char buffer[OUTPUT_BUF_SIZE];
+};
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+/* read source functions */
+static void init_source(j_decompress_ptr jd);
+static boolean fill_input_buffer(j_decompress_ptr jd);
+static void skip_input_data(j_decompress_ptr jd, long num_bytes);
+static void term_source(j_decompress_ptr jd);
+
+/* write destination functions */
+static void init_destination(j_compress_ptr jc);
+static boolean empty_output_buffer(j_compress_ptr jc);
+static void term_destination(j_compress_ptr jc);
+
+int img_register_jpeg(void)
+{
+ static struct ftype_module mod = {".jpg", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ unsigned char sig[10];
+
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(sig, 10, io->uptr) < 10) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(memcmp(sig, "\xff\xd8\xff\xe0", 4) != 0 && memcmp(sig, "\xff\xd8\xff\xe1", 4) != 0
+ && memcmp(sig, "\xff\xd8\xff\xdb", 4) != 0 && memcmp(sig + 6, "JFIF", 4) != 0) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return 0;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ int i, nlines = 0;
+ struct jpeg_decompress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ struct src_mgr src;
+ unsigned char **scanlines;
+
+ io->seek(0, SEEK_CUR, io->uptr);
+
+ cinfo.err = jpeg_std_error(&jerr); /* XXX change... */
+ jpeg_create_decompress(&cinfo);
+
+ src.pub.init_source = init_source;
+ src.pub.fill_input_buffer = fill_input_buffer;
+ src.pub.skip_input_data = skip_input_data;
+ src.pub.resync_to_restart = jpeg_resync_to_restart;
+ src.pub.term_source = term_source;
+ src.pub.next_input_byte = 0;
+ src.pub.bytes_in_buffer = 0;
+ src.io = io;
+ cinfo.src = (struct jpeg_source_mgr*)&src;
+
+ jpeg_read_header(&cinfo, 1);
+ cinfo.out_color_space = JCS_RGB;
+
+ if(img_set_pixels(img, cinfo.image_width, cinfo.image_height, IMG_FMT_RGB24, 0) == -1) {
+ jpeg_destroy_decompress(&cinfo);
+ return -1;
+ }
+
+ if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
+ jpeg_destroy_decompress(&cinfo);
+ return -1;
+ }
+ scanlines[0] = img->pixels;
+ for(i=1; i<img->height; i++) {
+ scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
+ }
+
+ jpeg_start_decompress(&cinfo);
+ while(nlines < img->height) {
+ int res = jpeg_read_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
+ nlines += res;
+ }
+ jpeg_finish_decompress(&cinfo);
+ jpeg_destroy_decompress(&cinfo);
+
+ free(scanlines);
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ int i, nlines = 0;
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ struct dst_mgr dest;
+ struct img_pixmap tmpimg;
+ unsigned char **scanlines;
+
+ img_init(&tmpimg);
+
+ if(img->fmt != IMG_FMT_RGB24) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ if(!(scanlines = malloc(img->height * sizeof *scanlines))) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ scanlines[0] = img->pixels;
+ for(i=1; i<img->height; i++) {
+ scanlines[i] = scanlines[i - 1] + img->width * img->pixelsz;
+ }
+
+ cinfo.err = jpeg_std_error(&jerr); /* XXX */
+ jpeg_create_compress(&cinfo);
+
+ dest.pub.init_destination = init_destination;
+ dest.pub.empty_output_buffer = empty_output_buffer;
+ dest.pub.term_destination = term_destination;
+ dest.io = io;
+ cinfo.dest = (struct jpeg_destination_mgr*)&dest;
+
+ cinfo.image_width = img->width;
+ cinfo.image_height = img->height;
+ cinfo.input_components = 3;
+ cinfo.in_color_space = JCS_RGB;
+
+ jpeg_set_defaults(&cinfo);
+
+ jpeg_start_compress(&cinfo, 1);
+ while(nlines < img->height) {
+ int res = jpeg_write_scanlines(&cinfo, scanlines + nlines, img->height - nlines);
+ nlines += res;
+ }
+ jpeg_finish_compress(&cinfo);
+ jpeg_destroy_compress(&cinfo);
+
+ free(scanlines);
+ img_destroy(&tmpimg);
+ return 0;
+}
+
+/* -- read source functions --
+ * the following functions are adapted from jdatasrc.c in jpeglib
+ */
+static void init_source(j_decompress_ptr jd)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+ src->start_of_file = 1;
+}
+
+static boolean fill_input_buffer(j_decompress_ptr jd)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+ size_t nbytes;
+
+ nbytes = src->io->read(src->buffer, INPUT_BUF_SIZE, src->io->uptr);
+
+ if(nbytes <= 0) {
+ if(src->start_of_file) {
+ return 0;
+ }
+ /* insert a fake EOI marker */
+ src->buffer[0] = 0xff;
+ src->buffer[1] = JPEG_EOI;
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = 0;
+ return 1;
+}
+
+static void skip_input_data(j_decompress_ptr jd, long num_bytes)
+{
+ struct src_mgr *src = (struct src_mgr*)jd->src;
+
+ if(num_bytes > 0) {
+ while(num_bytes > (long)src->pub.bytes_in_buffer) {
+ num_bytes -= (long)src->pub.bytes_in_buffer;
+ fill_input_buffer(jd);
+ }
+ src->pub.next_input_byte += (size_t)num_bytes;
+ src->pub.bytes_in_buffer -= (size_t)num_bytes;
+ }
+}
+
+static void term_source(j_decompress_ptr jd)
+{
+ /* nothing to see here, move along */
+}
+
+
+/* -- write destination functions --
+ * the following functions are adapted from jdatadst.c in jpeglib
+ */
+static void init_destination(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+static boolean empty_output_buffer(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+
+ if(dest->io->write(dest->buffer, OUTPUT_BUF_SIZE, dest->io->uptr) != OUTPUT_BUF_SIZE) {
+ return 0;
+ }
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+ return 1;
+}
+
+static void term_destination(j_compress_ptr jc)
+{
+ struct dst_mgr *dest = (struct dst_mgr*)jc->dest;
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* write any remaining data in the buffer */
+ if(datacount > 0) {
+ dest->io->write(dest->buffer, datacount, dest->io->uptr);
+ }
+ /* XXX flush? ... */
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- PNG module -- */
+
+#include <stdlib.h>
+#include <string.h>
+#include <png.h>
+#include "imago2.h"
+#include "ftmodule.h"
+
+static int check_file(struct img_io *io);
+static int read_file(struct img_pixmap *img, struct img_io *io);
+static int write_file(struct img_pixmap *img, struct img_io *io);
+
+static void read_func(png_struct *png, unsigned char *data, size_t len);
+static void write_func(png_struct *png, unsigned char *data, size_t len);
+static void flush_func(png_struct *png);
+
+static int png_type_to_fmt(int color_type, int channel_bits);
+static int fmt_to_png_type(enum img_fmt fmt);
+
+
+int img_register_png(void)
+{
+ static struct ftype_module mod = {".png", check_file, read_file, write_file};
+ return img_register_module(&mod);
+}
+
+static int check_file(struct img_io *io)
+{
+ unsigned char sig[8];
+ int res;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(sig, 8, io->uptr) < 8) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ res = png_sig_cmp(sig, 0, 8) == 0 ? 0 : -1;
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int read_file(struct img_pixmap *img, struct img_io *io)
+{
+ png_struct *png;
+ png_info *info;
+ int channel_bits, color_type, ilace_type, compression, filtering, fmt;
+ png_uint_32 xsz, ysz;
+
+ if(!(png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+ return -1;
+ }
+
+ if(!(info = png_create_info_struct(png))) {
+ png_destroy_read_struct(&png, 0, 0);
+ return -1;
+ }
+
+ if(setjmp(png_jmpbuf(png))) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+ png_set_read_fn(png, io, read_func);
+ png_set_sig_bytes(png, 0);
+ png_read_png(png, info, 0, 0);
+
+ png_get_IHDR(png, info, &xsz, &ysz, &channel_bits, &color_type, &ilace_type,
+ &compression, &filtering);
+ if((fmt = png_type_to_fmt(color_type, channel_bits)) == -1) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, fmt, 0) == -1) {
+ png_destroy_read_struct(&png, &info, 0);
+ return -1;
+ }
+
+
+ if(channel_bits == 8) {
+ unsigned int i;
+ unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
+ unsigned char *dest = img->pixels;
+
+ for(i=0; i<ysz; i++) {
+ memcpy(dest, lineptr[i], xsz * img->pixelsz);
+ dest += xsz * img->pixelsz;
+ }
+ } else {
+ unsigned int i, j, num_elem;
+ unsigned char **lineptr = (unsigned char**)png_get_rows(png, info);
+ float *dest = img->pixels;
+
+ num_elem = img->pixelsz / sizeof(float);
+ for(i=0; i<ysz; i++) {
+ for(j=0; j<xsz * num_elem; j++) {
+ unsigned short val = (lineptr[i][j * 2] << 8) | lineptr[i][j * 2 + 1];
+ *dest++ = (float)val / 65535.0;
+ }
+ }
+ }
+
+
+ png_destroy_read_struct(&png, &info, 0);
+ return 0;
+}
+
+
+static int write_file(struct img_pixmap *img, struct img_io *io)
+{
+ png_struct *png;
+ png_info *info;
+ png_text txt;
+ struct img_pixmap tmpimg;
+ unsigned char **rows;
+ unsigned char *pixptr;
+ int i, coltype;
+
+ img_init(&tmpimg);
+
+ if(!(png = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) {
+ return -1;
+ }
+ if(!(info = png_create_info_struct(png))) {
+ png_destroy_write_struct(&png, 0);
+ return -1;
+ }
+
+ /* if the input image is floating-point, we need to convert it to integer */
+ if(img_is_float(img)) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_to_integer(&tmpimg) == -1) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ txt.compression = PNG_TEXT_COMPRESSION_NONE;
+ txt.key = "Software";
+ txt.text = "libimago2";
+ txt.text_length = 0;
+
+ if(setjmp(png_jmpbuf(png))) {
+ png_destroy_write_struct(&png, &info);
+ img_destroy(&tmpimg);
+ return -1;
+ }
+ png_set_write_fn(png, io, write_func, flush_func);
+
+ coltype = fmt_to_png_type(img->fmt);
+ png_set_IHDR(png, info, img->width, img->height, 8, coltype, PNG_INTERLACE_NONE,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ png_set_text(png, info, &txt, 1);
+
+ if(!(rows = malloc(img->height * sizeof *rows))) {
+ png_destroy_write_struct(&png, &info);
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ pixptr = img->pixels;
+ for(i=0; i<img->height; i++) {
+ rows[i] = pixptr;
+ pixptr += img->width * img->pixelsz;
+ }
+ png_set_rows(png, info, rows);
+
+ png_write_png(png, info, 0, 0);
+ png_write_end(png, info);
+ png_destroy_write_struct(&png, &info);
+
+ free(rows);
+
+ img_destroy(&tmpimg);
+ return 0;
+}
+
+static void read_func(png_struct *png, unsigned char *data, size_t len)
+{
+ struct img_io *io = (struct img_io*)png_get_io_ptr(png);
+
+ if(io->read(data, len, io->uptr) == -1) {
+ longjmp(png_jmpbuf(png), 1);
+ }
+}
+
+static void write_func(png_struct *png, unsigned char *data, size_t len)
+{
+ struct img_io *io = (struct img_io*)png_get_io_ptr(png);
+
+ if(io->write(data, len, io->uptr) == -1) {
+ longjmp(png_jmpbuf(png), 1);
+ }
+}
+
+static void flush_func(png_struct *png)
+{
+ /* XXX does it matter that we can't flush? */
+}
+
+static int png_type_to_fmt(int color_type, int channel_bits)
+{
+ /* only 8 and 16 bits per channel ar supported at the moment */
+ if(channel_bits != 8 && channel_bits != 16) {
+ return -1;
+ }
+
+ switch(color_type) {
+ case PNG_COLOR_TYPE_RGB:
+ return channel_bits == 16 ? IMG_FMT_RGBF : IMG_FMT_RGB24;
+
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ return channel_bits == 16 ? IMG_FMT_RGBAF : IMG_FMT_RGBA32;
+
+ case PNG_COLOR_TYPE_GRAY:
+ return channel_bits == 16 ? IMG_FMT_GREYF : IMG_FMT_GREY8;
+
+ default:
+ break;
+ }
+ return -1;
+}
+
+static int fmt_to_png_type(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return PNG_COLOR_TYPE_GRAY;
+
+ case IMG_FMT_RGB24:
+ return PNG_COLOR_TYPE_RGB;
+
+ case IMG_FMT_RGBA32:
+ return PNG_COLOR_TYPE_RGBA;
+
+ default:
+ break;
+ }
+ return -1;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- Portable Pixmap (PPM) module -- */
+
+#include <string.h>
+#include "imago2.h"
+#include "ftmodule.h"
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+int img_register_ppm(void)
+{
+ static struct ftype_module mod = {".ppm", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ char id[2];
+ int res = -1;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ if(io->read(id, 2, io->uptr) < 2) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(id[0] == 'P' && (id[1] == '6' || id[1] == '3')) {
+ res = 0;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static char *iofgets(char *buf, int size, struct img_io *io)
+{
+ int c;
+ char *ptr = buf;
+
+ while(--size > 0 && (c = iofgetc(io)) != -1) {
+ *ptr++ = c;
+ if(c == '\n') break;
+ }
+ *ptr = 0;
+
+ return ptr == buf ? 0 : buf;
+}
+
+/* TODO: implement P3 reading */
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ char buf[256];
+ int xsz, ysz, maxval, got_hdrlines = 1;
+
+ if(!iofgets(buf, sizeof buf, io)) {
+ return -1;
+ }
+ if(!(buf[0] == 'P' && (buf[1] == '6' || buf[1] == '3'))) {
+ return -1;
+ }
+
+ while(got_hdrlines < 3 && iofgets(buf, sizeof buf, io)) {
+ if(buf[0] == '#') continue;
+
+ switch(got_hdrlines) {
+ case 1:
+ if(sscanf(buf, "%d %d\n", &xsz, &ysz) < 2) {
+ return -1;
+ }
+ break;
+
+ case 2:
+ if(sscanf(buf, "%d\n", &maxval) < 1) {
+ return -1;
+ }
+ default:
+ break;
+ }
+ got_hdrlines++;
+ }
+
+ if(xsz < 1 || ysz < 1 || maxval != 255) {
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGB24, 0) == -1) {
+ return -1;
+ }
+
+ if(io->read(img->pixels, xsz * ysz * 3, io->uptr) < (unsigned int)(xsz * ysz * 3)) {
+ return -1;
+ }
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ int sz;
+ char buf[256];
+ struct img_pixmap tmpimg;
+
+ img_init(&tmpimg);
+
+ if(img->fmt != IMG_FMT_RGB24) {
+ if(img_copy(&tmpimg, img) == -1) {
+ return -1;
+ }
+ if(img_convert(&tmpimg, IMG_FMT_RGB24) == -1) {
+ return -1;
+ }
+ img = &tmpimg;
+ }
+
+ sprintf(buf, "P6\n#written by libimago2\n%d %d\n255\n", img->width, img->height);
+ if(io->write(buf, strlen(buf), io->uptr) < strlen(buf)) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ sz = img->width * img->height * 3;
+ if(io->write(img->pixels, sz, io->uptr) < (unsigned int)sz) {
+ img_destroy(&tmpimg);
+ return -1;
+ }
+
+ img_destroy(&tmpimg);
+ return 0;
+}
--- /dev/null
+/* This file contains code to read and write four byte rgbe file format
+ * developed by Greg Ward. It handles the conversions between rgbe and
+ * pixels consisting of floats. The data is assumed to be an array of floats.
+ * By default there are three floats per pixel in the order red, green, blue.
+ * (RGBE_DATA_??? values control this.)
+ *
+ * written by Bruce Walter (bjw@graphics.cornell.edu) 5/26/95
+ * based on code written by Greg Ward
+ * minor modifications by John Tsiombikas (nuclear@member.fsf.org) apr.9 2007
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#include <errno.h>
+#include "imago2.h"
+#include "ftmodule.h"
+
+
+typedef struct {
+ int valid; /* indicate which fields are valid */
+ char programtype[16]; /* listed at beginning of file to identify it
+ * after "#?". defaults to "RGBE" */
+ float gamma; /* image has already been gamma corrected with
+ * given gamma. defaults to 1.0 (no correction) */
+ float exposure; /* a value of 1.0 in an image corresponds to
+ * <exposure> watts/steradian/m^2.
+ * defaults to 1.0 */
+} rgbe_header_info;
+
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+
+static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info);
+static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines);
+
+
+int img_register_rgbe(void)
+{
+ static struct ftype_module mod = {".rgbe", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ int xsz, ysz, res;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+
+ rgbe_header_info hdr;
+ res = rgbe_read_header(io, &xsz, &ysz, &hdr);
+
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ int xsz, ysz;
+ rgbe_header_info hdr;
+
+ if(rgbe_read_header(io, &xsz, &ysz, &hdr) == -1) {
+ return -1;
+ }
+
+ if(img_set_pixels(img, xsz, ysz, IMG_FMT_RGBF, 0) == -1) {
+ return -1;
+ }
+ if(rgbe_read_pixels_rle(io, img->pixels, xsz, ysz) == -1) {
+ return -1;
+ }
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ return -1; /* TODO */
+}
+
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static char *iofgets(char *buf, int size, struct img_io *io)
+{
+ int c;
+ char *ptr = buf;
+
+ while(--size > 0 && (c = iofgetc(io)) != -1) {
+ *ptr++ = c;
+ if(c == '\n') break;
+ }
+ *ptr = 0;
+
+ return ptr == buf ? 0 : buf;
+}
+
+
+/* flags indicating which fields in an rgbe_header_info are valid */
+#define RGBE_VALID_PROGRAMTYPE 0x01
+#define RGBE_VALID_GAMMA 0x02
+#define RGBE_VALID_EXPOSURE 0x04
+
+/* return codes for rgbe routines */
+#define RGBE_RETURN_SUCCESS 0
+#define RGBE_RETURN_FAILURE -1
+
+
+#if defined(__cplusplus) || defined(GNUC) || __STDC_VERSION >= 199901L
+#define INLINE inline
+#else
+#define INLINE
+#endif
+
+/* offsets to red, green, and blue components in a data (float) pixel */
+#define RGBE_DATA_RED 0
+#define RGBE_DATA_GREEN 1
+#define RGBE_DATA_BLUE 2
+
+/* number of floats per pixel */
+#define RGBE_DATA_SIZE 3
+
+enum rgbe_error_codes {
+ rgbe_read_error,
+ rgbe_write_error,
+ rgbe_format_error,
+ rgbe_memory_error
+};
+
+
+/* default error routine. change this to change error handling */
+static int rgbe_error(int rgbe_error_code, char *msg)
+{
+ switch (rgbe_error_code) {
+ case rgbe_read_error:
+ fprintf(stderr, "RGBE read error: %s\n", strerror(errno));
+ break;
+
+ case rgbe_write_error:
+ fprintf(stderr, "RGBE write error: %s\n", strerror(errno));
+ break;
+
+ case rgbe_format_error:
+ fprintf(stderr, "RGBE bad file format: %s\n", msg);
+ break;
+
+ default:
+ case rgbe_memory_error:
+ fprintf(stderr, "RGBE error: %s\n", msg);
+ }
+ return RGBE_RETURN_FAILURE;
+}
+
+/* standard conversion from float pixels to rgbe pixels */
+/*static INLINE void float2rgbe(unsigned char rgbe[4], float red, float green, float blue)
+{
+ float v;
+ int e;
+
+ v = red;
+ if(green > v)
+ v = green;
+ if(blue > v)
+ v = blue;
+ if(v < 1e-32) {
+ rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
+ } else {
+ v = frexp(v, &e) * 256.0 / v;
+ rgbe[0] = (unsigned char)(red * v);
+ rgbe[1] = (unsigned char)(green * v);
+ rgbe[2] = (unsigned char)(blue * v);
+ rgbe[3] = (unsigned char)(e + 128);
+ }
+}*/
+
+/* standard conversion from rgbe to float pixels */
+/* note: Ward uses ldexp(col+0.5,exp-(128+8)). However we wanted pixels */
+/* in the range [0,1] to map back into the range [0,1]. */
+static INLINE void rgbe2float(float *red, float *green, float *blue, unsigned char rgbe[4])
+{
+ float f;
+
+ if(rgbe[3]) { /*nonzero pixel */
+ f = ldexp(1.0, rgbe[3] - (int)(128 + 8));
+ *red = rgbe[0] * f;
+ *green = rgbe[1] * f;
+ *blue = rgbe[2] * f;
+ } else
+ *red = *green = *blue = 0.0;
+}
+
+#if 0
+/* default minimal header. modify if you want more information in header */
+static int rgbe_write_header(FILE * fp, int width, int height, rgbe_header_info * info)
+{
+ char *programtype = "RGBE";
+
+ if(info && (info->valid & RGBE_VALID_PROGRAMTYPE))
+ programtype = info->programtype;
+ if(fprintf(fp, "#?%s\n", programtype) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ /* The #? is to identify file type, the programtype is optional. */
+ if(info && (info->valid & RGBE_VALID_GAMMA)) {
+ if(fprintf(fp, "GAMMA=%g\n", info->gamma) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ if(info && (info->valid & RGBE_VALID_EXPOSURE)) {
+ if(fprintf(fp, "EXPOSURE=%g\n", info->exposure) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ if(fprintf(fp, "FORMAT=32-bit_rle_rgbe\n\n") < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ if(fprintf(fp, "-Y %d +X %d\n", height, width) < 0)
+ return rgbe_error(rgbe_write_error, NULL);
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+/* minimal header reading. modify if you want to parse more information */
+static int rgbe_read_header(struct img_io *io, int *width, int *height, rgbe_header_info * info)
+{
+ char buf[128];
+ float tempf;
+ int i;
+
+ if(info) {
+ info->valid = 0;
+ info->programtype[0] = 0;
+ info->gamma = info->exposure = 1.0;
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == NULL)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if((buf[0] != '#') || (buf[1] != '?')) {
+ /* if you want to require the magic token then uncomment the next line */
+ /*return rgbe_error(rgbe_format_error,"bad initial token"); */
+ } else if(info) {
+ info->valid |= RGBE_VALID_PROGRAMTYPE;
+ for(i = 0; i < sizeof(info->programtype) - 1; i++) {
+ if((buf[i + 2] == 0) || isspace(buf[i + 2]))
+ break;
+ info->programtype[i] = buf[i + 2];
+ }
+ info->programtype[i] = 0;
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ for(;;) {
+ if((buf[0] == 0) || (buf[0] == '\n'))
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "no FORMAT specifier found");*/
+ else if(strcmp(buf, "FORMAT=32-bit_rle_rgbe\n") == 0)
+ break; /* format found so break out of loop */
+ else if(info && (sscanf(buf, "GAMMA=%g", &tempf) == 1)) {
+ info->gamma = tempf;
+ info->valid |= RGBE_VALID_GAMMA;
+ } else if(info && (sscanf(buf, "EXPOSURE=%g", &tempf) == 1)) {
+ info->exposure = tempf;
+ info->valid |= RGBE_VALID_EXPOSURE;
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ }
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if(strcmp(buf, "\n") != 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing blank line after FORMAT specifier");*/
+ if(iofgets(buf, sizeof(buf) / sizeof(buf[0]), io) == 0)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_read_error, NULL);*/
+ if(sscanf(buf, "-Y %d +X %d", height, width) < 2)
+ return RGBE_RETURN_FAILURE;/*rgbe_error(rgbe_format_error, "missing image size specifier");*/
+ return RGBE_RETURN_SUCCESS;
+}
+
+#if 0
+/* simple write routine that does not use run length encoding */
+
+/* These routines can be made faster by allocating a larger buffer and
+ fread-ing and fwrite-ing the data in larger chunks */
+static int rgbe_write_pixels(FILE * fp, float *data, int numpixels)
+{
+ unsigned char rgbe[4];
+
+ while(numpixels-- > 0) {
+ float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
+ data += RGBE_DATA_SIZE;
+ if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+/* simple read routine. will not correctly handle run length encoding */
+static int rgbe_read_pixels(struct img_io *io, float *data, int numpixels)
+{
+ unsigned char rgbe[4];
+
+ while(numpixels-- > 0) {
+ if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1)
+ return rgbe_error(rgbe_read_error, NULL);
+ rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
+ data += RGBE_DATA_SIZE;
+ }
+ return RGBE_RETURN_SUCCESS;
+}
+
+#if 0
+/* The code below is only needed for the run-length encoded files. */
+
+/* Run length encoding adds considerable complexity but does */
+
+/* save some space. For each scanline, each channel (r,g,b,e) is */
+
+/* encoded separately for better compression. */
+
+static int rgbe_write_bytes_rle(struct img_io *io, unsigned char *data, int numbytes)
+{
+#define MINRUNLENGTH 4
+ int cur, beg_run, run_count, old_run_count, nonrun_count;
+ unsigned char buf[2];
+
+ cur = 0;
+ while(cur < numbytes) {
+ beg_run = cur;
+ /* find next run of length at least 4 if one exists */
+ run_count = old_run_count = 0;
+ while((run_count < MINRUNLENGTH) && (beg_run < numbytes)) {
+ beg_run += run_count;
+ old_run_count = run_count;
+ run_count = 1;
+ while((beg_run + run_count < numbytes) && (run_count < 127)
+ && (data[beg_run] == data[beg_run + run_count]))
+ run_count++;
+ }
+ /* if data before next big run is a short run then write it as such */
+ if((old_run_count > 1) && (old_run_count == beg_run - cur)) {
+ buf[0] = 128 + old_run_count; /*write short run */
+ buf[1] = data[cur];
+ if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur = beg_run;
+ }
+ /* write out bytes until we reach the start of the next run */
+ while(cur < beg_run) {
+ nonrun_count = beg_run - cur;
+ if(nonrun_count > 128)
+ nonrun_count = 128;
+ buf[0] = nonrun_count;
+ if(fwrite(buf, sizeof(buf[0]), 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ if(fwrite(&data[cur], sizeof(data[0]) * nonrun_count, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur += nonrun_count;
+ }
+ /* write out next run if one was found */
+ if(run_count >= MINRUNLENGTH) {
+ buf[0] = 128 + run_count;
+ buf[1] = data[beg_run];
+ if(fwrite(buf, sizeof(buf[0]) * 2, 1, fp) < 1)
+ return rgbe_error(rgbe_write_error, NULL);
+ cur += run_count;
+ }
+ }
+ return RGBE_RETURN_SUCCESS;
+#undef MINRUNLENGTH
+}
+
+static int rgbe_write_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
+{
+ unsigned char rgbe[4];
+ unsigned char *buffer;
+ int i, err;
+
+ if((scanline_width < 8) || (scanline_width > 0x7fff))
+ /* run length encoding is not allowed so write flat */
+ return rgbe_write_pixels(io, data, scanline_width * num_scanlines);
+ buffer = (unsigned char *)malloc(sizeof(unsigned char) * 4 * scanline_width);
+ if(buffer == NULL)
+ /* no buffer space so write flat */
+ return rgbe_write_pixels(fp, data, scanline_width * num_scanlines);
+ while(num_scanlines-- > 0) {
+ rgbe[0] = 2;
+ rgbe[1] = 2;
+ rgbe[2] = scanline_width >> 8;
+ rgbe[3] = scanline_width & 0xFF;
+ if(fwrite(rgbe, sizeof(rgbe), 1, fp) < 1) {
+ free(buffer);
+ return rgbe_error(rgbe_write_error, NULL);
+ }
+ for(i = 0; i < scanline_width; i++) {
+ float2rgbe(rgbe, data[RGBE_DATA_RED], data[RGBE_DATA_GREEN], data[RGBE_DATA_BLUE]);
+ buffer[i] = rgbe[0];
+ buffer[i + scanline_width] = rgbe[1];
+ buffer[i + 2 * scanline_width] = rgbe[2];
+ buffer[i + 3 * scanline_width] = rgbe[3];
+ data += RGBE_DATA_SIZE;
+ }
+ /* write out each of the four channels separately run length encoded */
+ /* first red, then green, then blue, then exponent */
+ for(i = 0; i < 4; i++) {
+ if((err = rgbe_write_bytes_rle(fp, &buffer[i * scanline_width],
+ scanline_width)) != RGBE_RETURN_SUCCESS) {
+ free(buffer);
+ return err;
+ }
+ }
+ }
+ free(buffer);
+ return RGBE_RETURN_SUCCESS;
+}
+#endif
+
+static int rgbe_read_pixels_rle(struct img_io *io, float *data, int scanline_width, int num_scanlines)
+{
+ unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
+ int i, count;
+ unsigned char buf[2];
+
+ if((scanline_width < 8) || (scanline_width > 0x7fff))
+ /* run length encoding is not allowed so read flat */
+ return rgbe_read_pixels(io, data, scanline_width * num_scanlines);
+ scanline_buffer = NULL;
+ /* read in each successive scanline */
+ while(num_scanlines > 0) {
+ if(io->read(rgbe, sizeof(rgbe), io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ if((rgbe[0] != 2) || (rgbe[1] != 2) || (rgbe[2] & 0x80)) {
+ /* this file is not run length encoded */
+ rgbe2float(&data[0], &data[1], &data[2], rgbe);
+ data += RGBE_DATA_SIZE;
+ free(scanline_buffer);
+ return rgbe_read_pixels(io, data, scanline_width * num_scanlines - 1);
+ }
+ if((((int)rgbe[2]) << 8 | rgbe[3]) != scanline_width) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "wrong scanline width");
+ }
+ if(scanline_buffer == NULL)
+ scanline_buffer = (unsigned char *)
+ malloc(sizeof(unsigned char) * 4 * scanline_width);
+ if(scanline_buffer == NULL)
+ return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
+
+ ptr = &scanline_buffer[0];
+ /* read each of the four channels for the scanline into the buffer */
+ for(i = 0; i < 4; i++) {
+ ptr_end = &scanline_buffer[(i + 1) * scanline_width];
+ while(ptr < ptr_end) {
+ if(io->read(buf, sizeof(buf[0]) * 2, io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ if(buf[0] > 128) {
+ /* a run of the same value */
+ count = buf[0] - 128;
+ if((count == 0) || (count > ptr_end - ptr)) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "bad scanline data");
+ }
+ while(count-- > 0)
+ *ptr++ = buf[1];
+ } else {
+ /* a non-run */
+ count = buf[0];
+ if((count == 0) || (count > ptr_end - ptr)) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_format_error, "bad scanline data");
+ }
+ *ptr++ = buf[1];
+ if(--count > 0) {
+ if(io->read(ptr, sizeof(*ptr) * count, io->uptr) < 1) {
+ free(scanline_buffer);
+ return rgbe_error(rgbe_read_error, NULL);
+ }
+ ptr += count;
+ }
+ }
+ }
+ }
+ /* now convert data from buffer into floats */
+ for(i = 0; i < scanline_width; i++) {
+ rgbe[0] = scanline_buffer[i];
+ rgbe[1] = scanline_buffer[i + scanline_width];
+ rgbe[2] = scanline_buffer[i + 2 * scanline_width];
+ rgbe[3] = scanline_buffer[i + 3 * scanline_width];
+ rgbe2float(&data[RGBE_DATA_RED], &data[RGBE_DATA_GREEN], &data[RGBE_DATA_BLUE], rgbe);
+ data += RGBE_DATA_SIZE;
+ }
+ num_scanlines--;
+ }
+ free(scanline_buffer);
+ return RGBE_RETURN_SUCCESS;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010-2015 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* -- Targa (tga) module -- */
+
+#include <string.h>
+#include <stdlib.h>
+#include "inttypes.h"
+#include "imago2.h"
+#include "ftmodule.h"
+
+
+#if defined(__i386__) || defined(__ia64__) || defined(WIN32) || \
+ (defined(__alpha__) || defined(__alpha)) || \
+ defined(__arm__) || \
+ (defined(__mips__) && defined(__MIPSEL__)) || \
+ defined(__SYMBIAN32__) || \
+ defined(__x86_64__) || \
+ defined(__LITTLE_ENDIAN__)
+/* little endian */
+#define read_int16_le(f) read_int16(f)
+#else
+/* big endian */
+#define read_int16_le(f) read_int16_inv(f)
+#endif /* endian check */
+
+
+enum {
+ IMG_NONE,
+ IMG_CMAP,
+ IMG_RGBA,
+ IMG_BW,
+
+ IMG_RLE_CMAP = 9,
+ IMG_RLE_RGBA,
+ IMG_RLE_BW
+};
+
+#define IS_RLE(x) ((x) >= IMG_RLE_CMAP)
+#define IS_RGBA(x) ((x) == IMG_RGBA || (x) == IMG_RLE_RGBA)
+
+
+struct tga_header {
+ uint8_t idlen; /* id field length */
+ uint8_t cmap_type; /* color map type (0:no color map, 1:color map present) */
+ uint8_t img_type; /* image type:
+ * 0: no image data
+ * 1: uncomp. color-mapped 9: RLE color-mapped
+ * 2: uncomp. true color 10: RLE true color
+ * 3: uncomp. black/white 11: RLE black/white */
+ uint16_t cmap_first; /* color map first entry index */
+ uint16_t cmap_len; /* color map length */
+ uint8_t cmap_entry_sz; /* color map entry size */
+ uint16_t img_x; /* X-origin of the image */
+ uint16_t img_y; /* Y-origin of the image */
+ uint16_t img_width; /* image width */
+ uint16_t img_height; /* image height */
+ uint8_t img_bpp; /* bits per pixel */
+ uint8_t img_desc; /* descriptor:
+ * bits 0 - 3: alpha or overlay bits
+ * bits 5 & 4: origin (0 = bottom/left, 1 = top/right)
+ * bits 7 & 6: data interleaving */
+};
+
+struct tga_footer {
+ uint32_t ext_off; /* extension area offset */
+ uint32_t devdir_off; /* developer directory offset */
+ char sig[18]; /* signature with . and \0 */
+};
+
+
+static int check(struct img_io *io);
+static int read(struct img_pixmap *img, struct img_io *io);
+static int write(struct img_pixmap *img, struct img_io *io);
+static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix);
+static int16_t read_int16(struct img_io *io);
+static int16_t read_int16_inv(struct img_io *io);
+
+int img_register_tga(void)
+{
+ static struct ftype_module mod = {".tga", check, read, write};
+ return img_register_module(&mod);
+}
+
+
+static int check(struct img_io *io)
+{
+ struct tga_footer foot;
+ int res = -1;
+ long pos = io->seek(0, SEEK_CUR, io->uptr);
+ io->seek(-18, SEEK_END, io->uptr);
+
+ if(io->read(foot.sig, 17, io->uptr) < 17) {
+ io->seek(pos, SEEK_SET, io->uptr);
+ return -1;
+ }
+
+ if(memcmp(foot.sig, "TRUEVISION-XFILE.", 17) == 0) {
+ res = 0;
+ }
+ io->seek(pos, SEEK_SET, io->uptr);
+ return res;
+}
+
+static int iofgetc(struct img_io *io)
+{
+ char c;
+ return io->read(&c, 1, io->uptr) < 1 ? -1 : c;
+}
+
+static int read(struct img_pixmap *img, struct img_io *io)
+{
+ struct tga_header hdr;
+ int x, y;
+ int i, c;
+ uint32_t ppixel = 0;
+ int rle_mode = 0, rle_pix_left = 0;
+ int rdalpha;
+
+ /* read header */
+ hdr.idlen = iofgetc(io);
+ hdr.cmap_type = iofgetc(io);
+ hdr.img_type = iofgetc(io);
+ hdr.cmap_first = read_int16_le(io);
+ hdr.cmap_len = read_int16_le(io);
+ hdr.cmap_entry_sz = iofgetc(io);
+ hdr.img_x = read_int16_le(io);
+ hdr.img_y = read_int16_le(io);
+ hdr.img_width = read_int16_le(io);
+ hdr.img_height = read_int16_le(io);
+ hdr.img_bpp = iofgetc(io);
+ if((c = iofgetc(io)) == -1) {
+ return -1;
+ }
+ hdr.img_desc = c;
+
+ if(!IS_RGBA(hdr.img_type)) {
+ fprintf(stderr, "only true color tga images supported\n");
+ return -1;
+ }
+
+ io->seek(hdr.idlen, SEEK_CUR, io); /* skip the image ID */
+
+ /* skip the color map if it exists */
+ if(hdr.cmap_type == 1) {
+ io->seek(hdr.cmap_len * hdr.cmap_entry_sz / 8, SEEK_CUR, io);
+ }
+
+ x = hdr.img_width;
+ y = hdr.img_height;
+ rdalpha = hdr.img_desc & 0xf;
+
+ /* TODO make this IMG_FMT_RGB24 if there's no alpha channel */
+ if(img_set_pixels(img, x, y, IMG_FMT_RGBA32, 0) == -1) {
+ return -1;
+ }
+
+ for(i=0; i<y; i++) {
+ uint32_t *ptr;
+ int j;
+
+ ptr = (uint32_t*)img->pixels + ((hdr.img_desc & 0x20) ? i : y - (i + 1)) * x;
+
+ for(j=0; j<x; j++) {
+ /* if the image is raw, then just read the next pixel */
+ if(!IS_RLE(hdr.img_type)) {
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ } else {
+ /* otherwise, for RLE... */
+
+ /* if we have pixels left in the packet ... */
+ if(rle_pix_left) {
+ /* if it's a raw packet, read the next pixel, otherwise keep the same */
+ if(!rle_mode) {
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ }
+ --rle_pix_left;
+ } else {
+ /* read RLE packet header */
+ unsigned char phdr = iofgetc(io);
+ rle_mode = (phdr & 128); /* last bit shows the mode for this packet (1: rle, 0: raw) */
+ rle_pix_left = (phdr & ~128); /* the rest gives the count of pixels minus one (we also read one here, so no +1) */
+ /* and read the first pixel of the packet */
+ if(read_pixel(io, rdalpha, &ppixel) == -1) {
+ return -1;
+ }
+ }
+ }
+
+ *ptr++ = ppixel;
+ }
+ }
+
+ return 0;
+}
+
+static int write(struct img_pixmap *img, struct img_io *io)
+{
+ return -1; /* TODO */
+}
+
+#define PACK_COLOR32(r,g,b,a) \
+ ((((a) & 0xff) << 24) | \
+ (((r) & 0xff) << 0) | \
+ (((g) & 0xff) << 8) | \
+ (((b) & 0xff) << 16))
+
+static int read_pixel(struct img_io *io, int rdalpha, uint32_t *pix)
+{
+ int r, g, b, a;
+ b = iofgetc(io);
+ g = iofgetc(io);
+ r = iofgetc(io);
+ a = rdalpha ? iofgetc(io) : 0xff;
+ *pix = PACK_COLOR32(r, g, b, a);
+ return a == -1 || r == -1 ? -1 : 0;
+}
+
+static int16_t read_int16(struct img_io *io)
+{
+ int16_t v;
+ io->read(&v, 2, io);
+ return v;
+}
+
+static int16_t read_int16_inv(struct img_io *io)
+{
+ int16_t v;
+ io->read(&v, 2, io);
+ return ((v >> 8) & 0xff) | (v << 8);
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include "ftmodule.h"
+
+static struct list_node {
+ struct ftype_module *module;
+ struct list_node *next;
+} *modules;
+
+/* defined in modules.c which is generated by configure */
+void img_modules_init();
+
+static int done_init;
+
+int img_register_module(struct ftype_module *mod)
+{
+ struct list_node *node;
+
+ if(!(node = malloc(sizeof *node))) {
+ return -1;
+ }
+
+ node->module = mod;
+ node->next = modules;
+ modules = node;
+ return 0;
+}
+
+struct ftype_module *img_find_format_module(struct img_io *io)
+{
+ struct list_node *node;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ node = modules;
+ while(node) {
+ if(node->module->check(io) != -1) {
+ return node->module;
+ }
+ node = node->next;
+ }
+ return 0;
+}
+
+struct ftype_module *img_guess_format(const char *fname)
+{
+ struct list_node *node;
+ char *suffix;
+ int suffix_len;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ if(!(suffix = strrchr(fname, '.'))) {
+ return 0; /* no suffix, can't guess ... */
+ }
+ suffix_len = (int)strlen(suffix);
+
+ node = modules;
+ while(node) {
+ char *suflist = node->module->suffix;
+ char *start, *end;
+
+ while(*suflist) {
+ if(!(start = strstr(suflist, suffix))) {
+ break;
+ }
+ end = start + suffix_len;
+
+ if(*end == ':' || *end == 0) {
+ return node->module; /* found it */
+ }
+ suflist = end;
+ }
+
+ node = node->next;
+ }
+ return 0;
+}
+
+struct ftype_module *img_get_module(int idx)
+{
+ struct list_node *node;
+
+ if(!done_init) {
+ img_modules_init();
+ done_init = 1;
+ }
+
+ node = modules;
+ while(node && idx--) {
+ node = node->next;
+ }
+ return node->module;
+}
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef FTYPE_MODULE_H_
+#define FTYPE_MODULE_H_
+
+#include "imago2.h"
+
+struct ftype_module {
+ char *suffix; /* used for format autodetection during saving only */
+
+ int (*check)(struct img_io *io);
+ int (*read)(struct img_pixmap *img, struct img_io *io);
+ int (*write)(struct img_pixmap *img, struct img_io *io);
+};
+
+int img_register_module(struct ftype_module *mod);
+
+struct ftype_module *img_find_format_module(struct img_io *io);
+struct ftype_module *img_guess_format(const char *fname);
+struct ftype_module *img_get_module(int idx);
+
+
+#endif /* FTYPE_MODULE_H_ */
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "imago2.h"
+#include "ftmodule.h"
+
+static int pixel_size(enum img_fmt fmt);
+static size_t def_read(void *buf, size_t bytes, void *uptr);
+static size_t def_write(void *buf, size_t bytes, void *uptr);
+static long def_seek(long offset, int whence, void *uptr);
+
+
+void img_init(struct img_pixmap *img)
+{
+ img->pixels = 0;
+ img->width = img->height = 0;
+ img->fmt = IMG_FMT_RGBA32;
+ img->pixelsz = pixel_size(img->fmt);
+ img->name = 0;
+}
+
+
+void img_destroy(struct img_pixmap *img)
+{
+ free(img->pixels);
+ img->pixels = 0; /* just in case... */
+ img->width = img->height = 0xbadbeef;
+ free(img->name);
+}
+
+struct img_pixmap *img_create(void)
+{
+ struct img_pixmap *p;
+
+ if(!(p = malloc(sizeof *p))) {
+ return 0;
+ }
+ img_init(p);
+ return p;
+}
+
+void img_free(struct img_pixmap *img)
+{
+ img_destroy(img);
+ free(img);
+}
+
+int img_set_name(struct img_pixmap *img, const char *name)
+{
+ char *tmp;
+
+ if(!(tmp = malloc(strlen(name) + 1))) {
+ return -1;
+ }
+ strcpy(tmp, name);
+ img->name = tmp;
+ return 0;
+}
+
+int img_set_format(struct img_pixmap *img, enum img_fmt fmt)
+{
+ if(img->pixels) {
+ return img_convert(img, fmt);
+ }
+ img->fmt = fmt;
+ return 0;
+}
+
+int img_copy(struct img_pixmap *dest, struct img_pixmap *src)
+{
+ return img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels);
+}
+
+int img_set_pixels(struct img_pixmap *img, int w, int h, enum img_fmt fmt, void *pix)
+{
+ void *newpix;
+ int pixsz = pixel_size(fmt);
+
+ if(!(newpix = malloc(w * h * pixsz))) {
+ return -1;
+ }
+
+ if(pix) {
+ memcpy(newpix, pix, w * h * pixsz);
+ } else {
+ memset(newpix, 0, w * h * pixsz);
+ }
+
+ free(img->pixels);
+ img->pixels = newpix;
+ img->width = w;
+ img->height = h;
+ img->pixelsz = pixsz;
+ img->fmt = fmt;
+ return 0;
+}
+
+void *img_load_pixels(const char *fname, int *xsz, int *ysz, enum img_fmt fmt)
+{
+ struct img_pixmap img;
+
+ img_init(&img);
+
+ if(img_load(&img, fname) == -1) {
+ return 0;
+ }
+ if(img.fmt != fmt) {
+ if(img_convert(&img, fmt) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+ }
+
+ *xsz = img.width;
+ *ysz = img.height;
+ return img.pixels;
+}
+
+int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, enum img_fmt fmt)
+{
+ int res;
+ struct img_pixmap img;
+
+ img_init(&img);
+ img.fmt = fmt;
+ img.width = xsz;
+ img.height = ysz;
+ img.pixels = pix;
+
+ res = img_save(&img, fname);
+ img.pixels = 0;
+ img_destroy(&img);
+ return res;
+}
+
+void img_free_pixels(void *pix)
+{
+ free(pix);
+}
+
+int img_load(struct img_pixmap *img, const char *fname)
+{
+ int res;
+ FILE *fp;
+
+ if(!(fp = fopen(fname, "rb"))) {
+ return -1;
+ }
+ res = img_read_file(img, fp);
+ fclose(fp);
+ return res;
+}
+
+/* TODO implement filetype selection */
+int img_save(struct img_pixmap *img, const char *fname)
+{
+ int res;
+ FILE *fp;
+
+ img_set_name(img, fname);
+
+ if(!(fp = fopen(fname, "wb"))) {
+ return -1;
+ }
+ res = img_write_file(img, fp);
+ fclose(fp);
+ return res;
+}
+
+int img_read_file(struct img_pixmap *img, FILE *fp)
+{
+ struct img_io io = {0, def_read, def_write, def_seek};
+
+ io.uptr = fp;
+ return img_read(img, &io);
+}
+
+int img_write_file(struct img_pixmap *img, FILE *fp)
+{
+ struct img_io io = {0, def_read, def_write, def_seek};
+
+ io.uptr = fp;
+ return img_write(img, &io);
+}
+
+int img_read(struct img_pixmap *img, struct img_io *io)
+{
+ struct ftype_module *mod;
+
+ if((mod = img_find_format_module(io))) {
+ return mod->read(img, io);
+ }
+ return -1;
+}
+
+int img_write(struct img_pixmap *img, struct img_io *io)
+{
+ struct ftype_module *mod;
+
+ if(!img->name || !(mod = img_guess_format(img->name))) {
+ /* TODO throw some sort of warning? */
+ /* TODO implement some sort of module priority or let the user specify? */
+ if(!(mod = img_get_module(0))) {
+ return -1;
+ }
+ }
+
+ return mod->write(img, io);
+}
+
+int img_to_float(struct img_pixmap *img)
+{
+ enum img_fmt targ_fmt;
+
+ switch(img->fmt) {
+ case IMG_FMT_GREY8:
+ targ_fmt = IMG_FMT_GREYF;
+ break;
+
+ case IMG_FMT_RGB24:
+ targ_fmt = IMG_FMT_RGBF;
+ break;
+
+ case IMG_FMT_RGBA32:
+ targ_fmt = IMG_FMT_RGBAF;
+ break;
+
+ default:
+ return 0; /* already float */
+ }
+
+ return img_convert(img, targ_fmt);
+}
+
+int img_to_integer(struct img_pixmap *img)
+{
+ enum img_fmt targ_fmt;
+
+ switch(img->fmt) {
+ case IMG_FMT_GREYF:
+ targ_fmt = IMG_FMT_GREY8;
+ break;
+
+ case IMG_FMT_RGBF:
+ targ_fmt = IMG_FMT_RGB24;
+ break;
+
+ case IMG_FMT_RGBAF:
+ targ_fmt = IMG_FMT_RGBA32;
+ break;
+
+ default:
+ return 0; /* already integer */
+ }
+
+ return img_convert(img, targ_fmt);
+}
+
+int img_is_float(struct img_pixmap *img)
+{
+ return img->fmt >= IMG_FMT_GREYF && img->fmt <= IMG_FMT_RGBAF;
+}
+
+int img_has_alpha(struct img_pixmap *img)
+{
+ if(img->fmt == IMG_FMT_RGBA32 || img->fmt == IMG_FMT_RGBAF) {
+ return 1;
+ }
+ return 0;
+}
+
+
+void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel)
+{
+ char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
+ memcpy(dest, pixel, img->pixelsz);
+}
+
+void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel)
+{
+ char *dest = (char*)img->pixels + (y * img->width + x) * img->pixelsz;
+ memcpy(pixel, dest, img->pixelsz);
+}
+
+void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix)
+{
+ img_setpixel4i(img, x, y, pix, pix, pix, pix);
+}
+
+void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix)
+{
+ img_setpixel4f(img, x, y, pix, pix, pix, pix);
+}
+
+void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a)
+{
+ if(img_is_float(img)) {
+ img_setpixel4f(img, x, y, r / 255.0, g / 255.0, b / 255.0, a / 255.0);
+ } else {
+ unsigned char pixel[4];
+ pixel[0] = r;
+ pixel[1] = g;
+ pixel[2] = b;
+ pixel[3] = a;
+
+ img_setpixel(img, x, y, pixel);
+ }
+}
+
+void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a)
+{
+ if(img_is_float(img)) {
+ float pixel[4];
+ pixel[0] = r;
+ pixel[1] = g;
+ pixel[2] = b;
+ pixel[3] = a;
+
+ img_setpixel(img, x, y, pixel);
+ } else {
+ img_setpixel4i(img, x, y, (int)(r * 255.0), (int)(g * 255.0), (int)(b * 255.0), (int)(a * 255.0));
+ }
+}
+
+void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix)
+{
+ int junk[3];
+ img_getpixel4i(img, x, y, pix, junk, junk + 1, junk + 2);
+}
+
+void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix)
+{
+ float junk[3];
+ img_getpixel4f(img, x, y, pix, junk, junk + 1, junk + 2);
+}
+
+void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a)
+{
+ if(img_is_float(img)) {
+ float pixel[4] = {0, 0, 0, 0};
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0] * 255.0;
+ *g = pixel[1] * 255.0;
+ *b = pixel[2] * 255.0;
+ *a = pixel[3] * 255.0;
+ } else {
+ unsigned char pixel[4];
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0];
+ *g = pixel[1];
+ *b = pixel[2];
+ *a = pixel[3];
+ }
+}
+
+void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a)
+{
+ if(img_is_float(img)) {
+ float pixel[4] = {0, 0, 0, 0};
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0];
+ *g = pixel[1];
+ *b = pixel[2];
+ *a = pixel[3];
+ } else {
+ unsigned char pixel[4];
+ img_getpixel(img, x, y, pixel);
+ *r = pixel[0] / 255.0;
+ *g = pixel[1] / 255.0;
+ *b = pixel[2] / 255.0;
+ *a = pixel[3] / 255.0;
+ }
+}
+
+void img_io_set_user_data(struct img_io *io, void *uptr)
+{
+ io->uptr = uptr;
+}
+
+void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*))
+{
+ io->read = read;
+}
+
+void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*))
+{
+ io->write = write;
+}
+
+void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*))
+{
+ io->seek = seek;
+}
+
+
+static int pixel_size(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return 1;
+ case IMG_FMT_RGB24:
+ return 3;
+ case IMG_FMT_RGBA32:
+ return 4;
+ case IMG_FMT_GREYF:
+ return sizeof(float);
+ case IMG_FMT_RGBF:
+ return 3 * sizeof(float);
+ case IMG_FMT_RGBAF:
+ return 4 * sizeof(float);
+ default:
+ break;
+ }
+ return 0;
+}
+
+static size_t def_read(void *buf, size_t bytes, void *uptr)
+{
+ return uptr ? fread(buf, 1, bytes, uptr) : 0;
+}
+
+static size_t def_write(void *buf, size_t bytes, void *uptr)
+{
+ return uptr ? fwrite(buf, 1, bytes, uptr) : 0;
+}
+
+static long def_seek(long offset, int whence, void *uptr)
+{
+ if(!uptr || fseek(uptr, offset, whence) == -1) {
+ return -1;
+ }
+ return ftell(uptr);
+}
+
--- /dev/null
+/*
+libimago - a multi-format image file input/output library.
+Copyright (C) 2010-2012 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef IMAGO2_H_
+#define IMAGO2_H_
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+#define IMG_OPTARG(arg, val) arg = val
+#else
+#define IMG_OPTARG(arg, val) arg
+#endif
+
+/* XXX if you change this make sure to also change pack/unpack arrays in conv.c */
+enum img_fmt {
+ IMG_FMT_GREY8,
+ IMG_FMT_RGB24,
+ IMG_FMT_RGBA32,
+ IMG_FMT_GREYF,
+ IMG_FMT_RGBF,
+ IMG_FMT_RGBAF,
+
+ NUM_IMG_FMT
+};
+
+struct img_pixmap {
+ void *pixels;
+ int width, height;
+ enum img_fmt fmt;
+ int pixelsz;
+ char *name;
+};
+
+struct img_io {
+ void *uptr; /* user-data */
+
+ size_t (*read)(void *buf, size_t bytes, void *uptr);
+ size_t (*write)(void *buf, size_t bytes, void *uptr);
+ long (*seek)(long offs, int whence, void *uptr);
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* initialize the img_pixmap structure */
+void img_init(struct img_pixmap *img);
+/* destroys the img_pixmap structure, freeing the pixel buffer (if available)
+ * and any other memory held by the pixmap.
+ */
+void img_destroy(struct img_pixmap *img);
+
+/* convenience function that allocates an img_pixmap struct and then initializes it.
+ * returns null if the malloc fails.
+ */
+struct img_pixmap *img_create(void);
+/* frees a pixmap previously allocated with img_create (free followed by img_destroy) */
+void img_free(struct img_pixmap *img);
+
+int img_set_name(struct img_pixmap *img, const char *name);
+
+/* set the image pixel format */
+int img_set_format(struct img_pixmap *img, enum img_fmt fmt);
+
+/* copies one pixmap to another.
+ * equivalent to: img_set_pixels(dest, src->width, src->height, src->fmt, src->pixels)
+ */
+int img_copy(struct img_pixmap *dest, struct img_pixmap *src);
+
+/* allocates a pixel buffer of the specified dimensions and format, and copies the
+ * pixels given through the pix pointer into it.
+ * the pix pointer can be null, in which case there's no copy, just allocation.
+ *
+ * C++: fmt and pix have default parameters IMG_FMT_RGBA32 and null respectively.
+ */
+int img_set_pixels(struct img_pixmap *img, int w, int h, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32), IMG_OPTARG(void *pix, 0));
+
+/* Simplified image loading
+ * Loads the specified file, and returns a pointer to an array of pixels of the
+ * requested pixel format. The width and height of the image are returned through
+ * the xsz and ysz pointers.
+ * If the image cannot be loaded, the function returns null.
+ *
+ * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
+ */
+void *img_load_pixels(const char *fname, int *xsz, int *ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
+
+/* Simplified image saving
+ * Reads an array of pixels supplied through the pix pointer, of dimensions xsz
+ * and ysz, and pixel-format fmt, and saves it to a file.
+ * The output filetype is guessed by the filename suffix.
+ *
+ * C++: the format argument is optional and defaults to IMG_FMT_RGBA32
+ */
+int img_save_pixels(const char *fname, void *pix, int xsz, int ysz, IMG_OPTARG(enum img_fmt fmt, IMG_FMT_RGBA32));
+
+/* Frees the memory allocated by img_load_pixels */
+void img_free_pixels(void *pix);
+
+/* Loads an image file into the supplied pixmap */
+int img_load(struct img_pixmap *img, const char *fname);
+/* Saves the supplied pixmap to a file. The output filetype is guessed by the filename suffix */
+int img_save(struct img_pixmap *img, const char *fname);
+
+/* Reads an image from an open FILE* into the supplied pixmap */
+int img_read_file(struct img_pixmap *img, FILE *fp);
+/* Writes the supplied pixmap to an open FILE* */
+int img_write_file(struct img_pixmap *img, FILE *fp);
+
+/* Reads an image using user-defined file-i/o functions (see img_io_set_*) */
+int img_read(struct img_pixmap *img, struct img_io *io);
+/* Writes an image using user-defined file-i/o functions (see img_io_set_*) */
+int img_write(struct img_pixmap *img, struct img_io *io);
+
+/* Converts an image to the specified pixel format */
+int img_convert(struct img_pixmap *img, enum img_fmt tofmt);
+
+/* Converts an image from an integer pixel format to the corresponding floating point one */
+int img_to_float(struct img_pixmap *img);
+/* Converts an image from a floating point pixel format to the corresponding integer one */
+int img_to_integer(struct img_pixmap *img);
+
+/* Returns non-zero (true) if the supplied image is in a floating point pixel format */
+int img_is_float(struct img_pixmap *img);
+/* Returns non-zero (true) if the supplied image has an alpha channel */
+int img_has_alpha(struct img_pixmap *img);
+
+
+/* don't use these for anything performance-critical */
+void img_setpixel(struct img_pixmap *img, int x, int y, void *pixel);
+void img_getpixel(struct img_pixmap *img, int x, int y, void *pixel);
+
+void img_setpixel1i(struct img_pixmap *img, int x, int y, int pix);
+void img_setpixel1f(struct img_pixmap *img, int x, int y, float pix);
+void img_setpixel4i(struct img_pixmap *img, int x, int y, int r, int g, int b, int a);
+void img_setpixel4f(struct img_pixmap *img, int x, int y, float r, float g, float b, float a);
+
+void img_getpixel1i(struct img_pixmap *img, int x, int y, int *pix);
+void img_getpixel1f(struct img_pixmap *img, int x, int y, float *pix);
+void img_getpixel4i(struct img_pixmap *img, int x, int y, int *r, int *g, int *b, int *a);
+void img_getpixel4f(struct img_pixmap *img, int x, int y, float *r, float *g, float *b, float *a);
+
+
+/* OpenGL helper functions */
+
+/* Returns the equivalent OpenGL "format" as expected by the 7th argument of glTexImage2D */
+unsigned int img_fmt_glfmt(enum img_fmt fmt);
+/* Returns the equivalent OpenGL "type" as expected by the 8th argument of glTexImage2D */
+unsigned int img_fmt_gltype(enum img_fmt fmt);
+/* Returns the equivalent OpenGL "internal format" as expected by the 3rd argument of glTexImage2D */
+unsigned int img_fmt_glintfmt(enum img_fmt fmt);
+
+/* Same as above, based on the pixel format of the supplied image */
+unsigned int img_glfmt(struct img_pixmap *img);
+unsigned int img_gltype(struct img_pixmap *img);
+unsigned int img_glintfmt(struct img_pixmap *img);
+
+/* Creates an OpenGL texture from the image, and returns the texture id, or 0 for failure */
+unsigned int img_gltexture(struct img_pixmap *img);
+
+/* Load an image and create an OpenGL texture out of it */
+unsigned int img_gltexture_load(const char *fname);
+unsigned int img_gltexture_read_file(FILE *fp);
+unsigned int img_gltexture_read(struct img_io *io);
+
+/* These functions can be used to fill an img_io struct before it's passed to
+ * one of the user-defined i/o image reading/writing functions (img_read/img_write).
+ *
+ * User-defined i/o functions:
+ *
+ * - size_t read_func(void *buffer, size_t bytes, void *user_ptr)
+ * Must try to fill the buffer with the specified number of bytes, and return
+ * the number of bytes actually read.
+ *
+ * - size_t write_func(void *buffer, size_t bytes, void *user_ptr)
+ * Must write the specified number of bytes from the supplied buffer and return
+ * the number of bytes actually written.
+ *
+ * - long seek_func(long offset, int whence, void *user_ptr)
+ * Must seek offset bytes from: the beginning of the file if whence is SEEK_SET,
+ * the current position if whence is SEEK_CUR, or the end of the file if whence is
+ * SEEK_END, and return the resulting file offset from the beginning of the file.
+ * (i.e. seek_func(0, SEEK_CUR, user_ptr); must be equivalent to an ftell).
+ *
+ * All three functions get the user-data pointer set through img_io_set_user_data
+ * as their last argument.
+ *
+ * Note: obviously you don't need to set a write function if you're only going
+ * to call img_read, or the read and seek function if you're only going to call
+ * img_write.
+ *
+ * Note: if the user-supplied write function is buffered, make sure to flush
+ * (or close the file) after img_write returns.
+ */
+void img_io_set_user_data(struct img_io *io, void *uptr);
+void img_io_set_read_func(struct img_io *io, size_t (*read)(void*, size_t, void*));
+void img_io_set_write_func(struct img_io *io, size_t (*write)(void*, size_t, void*));
+void img_io_set_seek_func(struct img_io *io, long (*seek)(long, int, void*));
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* IMAGO_H_ */
--- /dev/null
+#include "imago2.h"
+
+/* to avoid dependency to OpenGL, I'll define all the relevant GL macros manually */
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_FLOAT 0x1406
+
+#define GL_LUMINANCE 0x1909
+#define GL_RGB 0x1907
+#define GL_RGBA 0x1908
+
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_LUMINANCE32F 0x8818
+
+#define GL_TEXTURE_2D 0x0de1
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_LINEAR 0x2601
+#define GL_REPEAT 0x2901
+
+
+typedef unsigned int GLenum;
+typedef unsigned int GLuint;
+typedef int GLint;
+typedef int GLsizei;
+typedef void GLvoid;
+
+/* for the same reason I'll load GL functions dynamically */
+#ifndef WIN32
+typedef void (*gl_gen_textures_func)(GLsizei, GLuint*);
+typedef void (*gl_bind_texture_func)(GLenum, GLuint);
+typedef void (*gl_tex_parameteri_func)(GLenum, GLenum, GLint);
+typedef void (*gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
+#else
+typedef void (__stdcall *gl_gen_textures_func)(GLsizei, GLuint*);
+typedef void (__stdcall *gl_bind_texture_func)(GLenum, GLuint);
+typedef void (__stdcall *gl_tex_parameteri_func)(GLenum, GLenum, GLint);
+typedef void (__stdcall *gl_tex_image2d_func)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*);
+#endif
+
+static gl_gen_textures_func gl_gen_textures;
+static gl_bind_texture_func gl_bind_texture;
+static gl_tex_parameteri_func gl_tex_parameteri;
+static gl_tex_image2d_func gl_tex_image2d;
+
+static int load_glfunc(void);
+
+unsigned int img_fmt_glfmt(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ case IMG_FMT_GREYF:
+ return GL_LUMINANCE;
+
+ case IMG_FMT_RGB24:
+ case IMG_FMT_RGBF:
+ return GL_RGB;
+
+ case IMG_FMT_RGBA32:
+ case IMG_FMT_RGBAF:
+ return GL_RGBA;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_fmt_gltype(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ case IMG_FMT_RGB24:
+ case IMG_FMT_RGBA32:
+ return GL_UNSIGNED_BYTE;
+
+ case IMG_FMT_GREYF:
+ case IMG_FMT_RGBF:
+ case IMG_FMT_RGBAF:
+ return GL_FLOAT;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_fmt_glintfmt(enum img_fmt fmt)
+{
+ switch(fmt) {
+ case IMG_FMT_GREY8:
+ return GL_LUMINANCE;
+ case IMG_FMT_RGB24:
+ return GL_RGB;
+ case IMG_FMT_RGBA32:
+ return GL_RGBA;
+ case IMG_FMT_GREYF:
+ return GL_LUMINANCE32F;
+ case IMG_FMT_RGBF:
+ return GL_RGB32F;
+ case IMG_FMT_RGBAF:
+ return GL_RGBA32F;
+ default:
+ break;
+ }
+ return 0;
+}
+
+unsigned int img_glfmt(struct img_pixmap *img)
+{
+ return img_fmt_glfmt(img->fmt);
+}
+
+unsigned int img_gltype(struct img_pixmap *img)
+{
+ return img_fmt_gltype(img->fmt);
+}
+
+unsigned int img_glintfmt(struct img_pixmap *img)
+{
+ return img_fmt_glintfmt(img->fmt);
+}
+
+unsigned int img_gltexture(struct img_pixmap *img)
+{
+ unsigned int tex;
+ unsigned int intfmt, fmt, type;
+
+ if(!gl_gen_textures) {
+ if(load_glfunc() == -1) {
+ fprintf(stderr, "imago: failed to initialize the OpenGL helpers\n");
+ return 0;
+ }
+ }
+
+ intfmt = img_glintfmt(img);
+ fmt = img_glfmt(img);
+ type = img_gltype(img);
+
+ gl_gen_textures(1, &tex);
+ gl_bind_texture(GL_TEXTURE_2D, tex);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ gl_tex_parameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ gl_tex_image2d(GL_TEXTURE_2D, 0, intfmt, img->width, img->height, 0, fmt, type, img->pixels);
+ return tex;
+}
+
+unsigned int img_gltexture_load(const char *fname)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_load(&img, fname) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+unsigned int img_gltexture_read_file(FILE *fp)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_read_file(&img, fp) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+unsigned int img_gltexture_read(struct img_io *io)
+{
+ struct img_pixmap img;
+ unsigned int tex;
+
+ img_init(&img);
+ if(img_read(&img, io) == -1) {
+ img_destroy(&img);
+ return 0;
+ }
+
+ tex = img_gltexture(&img);
+ img_destroy(&img);
+ return tex;
+}
+
+#if (defined(__DOS__) || defined(__MSDOS__)) && defined(__unix__)
+#undef __unix__
+#endif
+
+#if defined(__unix__) || defined(__APPLE__)
+#ifndef __USE_GNU
+#define __USE_GNU
+#endif
+
+#include <dlfcn.h>
+#endif
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+static int load_glfunc(void)
+{
+#if defined(__unix__) || defined(__APPLE__)
+ gl_gen_textures = (gl_gen_textures_func)dlsym(RTLD_DEFAULT, "glGenTextures");
+ gl_bind_texture = (gl_bind_texture_func)dlsym(RTLD_DEFAULT, "glBindTexture");
+ gl_tex_parameteri = (gl_tex_parameteri_func)dlsym(RTLD_DEFAULT, "glTexParameteri");
+ gl_tex_image2d = (gl_tex_image2d_func)dlsym(RTLD_DEFAULT, "glTexImage2D");
+#endif
+
+#ifdef WIN32
+ HANDLE dll = LoadLibrary("opengl32.dll");
+ if(dll) {
+ gl_gen_textures = (gl_gen_textures_func)GetProcAddress(dll, "glGenTextures");
+ gl_bind_texture = (gl_bind_texture_func)GetProcAddress(dll, "glBindTexture");
+ gl_tex_parameteri = (gl_tex_parameteri_func)GetProcAddress(dll, "glTexParameteri");
+ gl_tex_image2d = (gl_tex_image2d_func)GetProcAddress(dll, "glTexImage2D");
+ }
+#endif
+
+ return (gl_gen_textures && gl_bind_texture && gl_tex_parameteri && gl_tex_image2d) ? 0 : -1;
+}
--- /dev/null
+/*
+colcycle - color cycling image viewer
+Copyright (C) 2016 John Tsiombikas <nuclear@member.fsf.org>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef INT_TYPES_H_
+#define INT_TYPES_H_
+
+#if defined(__DOS__) || defined(__MSDOS__) || defined(WIN32)
+typedef char int8_t;
+typedef short int16_t;
+typedef long int32_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned long uint32_t;
+
+typedef unsigned long intptr_t;
+#else
+#include <stdint.h>
+#endif
+
+#endif /* INT_TYPES_H_ */
--- /dev/null
+/* this file is generated by ./configure, do not edit */
+int img_register_jpeg();
+int img_register_png();
+int img_register_ppm();
+int img_register_rgbe();
+int img_register_tga();
+
+void img_modules_init(void)
+{
+ img_register_jpeg();
+ img_register_png();
+ img_register_ppm();
+ img_register_rgbe();
+ img_register_tga();
+}
--- /dev/null
+ (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
--- /dev/null
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#define BASE 65521UL /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf) DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware */
+#ifdef NO_DIVIDE
+# define MOD(a) \
+ do { \
+ if (a >= (BASE << 16)) a -= (BASE << 16); \
+ if (a >= (BASE << 15)) a -= (BASE << 15); \
+ if (a >= (BASE << 14)) a -= (BASE << 14); \
+ if (a >= (BASE << 13)) a -= (BASE << 13); \
+ if (a >= (BASE << 12)) a -= (BASE << 12); \
+ if (a >= (BASE << 11)) a -= (BASE << 11); \
+ if (a >= (BASE << 10)) a -= (BASE << 10); \
+ if (a >= (BASE << 9)) a -= (BASE << 9); \
+ if (a >= (BASE << 8)) a -= (BASE << 8); \
+ if (a >= (BASE << 7)) a -= (BASE << 7); \
+ if (a >= (BASE << 6)) a -= (BASE << 6); \
+ if (a >= (BASE << 5)) a -= (BASE << 5); \
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
+ if (a >= BASE) a -= BASE; \
+ } while (0)
+# define MOD4(a) \
+ do { \
+ if (a >= (BASE << 4)) a -= (BASE << 4); \
+ if (a >= (BASE << 3)) a -= (BASE << 3); \
+ if (a >= (BASE << 2)) a -= (BASE << 2); \
+ if (a >= (BASE << 1)) a -= (BASE << 1); \
+ if (a >= BASE) a -= BASE; \
+ } while (0)
+#else
+# define MOD(a) a %= BASE
+# define MOD4(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ uInt len;
+{
+ unsigned long sum2;
+ unsigned n;
+
+ /* split Adler-32 into component sums */
+ sum2 = (adler >> 16) & 0xffff;
+ adler &= 0xffff;
+
+ /* in case user likes doing a byte at a time, keep it fast */
+ if (len == 1) {
+ adler += buf[0];
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 += adler;
+ if (sum2 >= BASE)
+ sum2 -= BASE;
+ return adler | (sum2 << 16);
+ }
+
+ /* initial Adler-32 value (deferred check for len == 1 speed) */
+ if (buf == Z_NULL)
+ return 1L;
+
+ /* in case short lengths are provided, keep it somewhat fast */
+ if (len < 16) {
+ while (len--) {
+ adler += *buf++;
+ sum2 += adler;
+ }
+ if (adler >= BASE)
+ adler -= BASE;
+ MOD4(sum2); /* only added so many BASE's */
+ return adler | (sum2 << 16);
+ }
+
+ /* do length NMAX blocks -- requires just one modulo operation */
+ while (len >= NMAX) {
+ len -= NMAX;
+ n = NMAX / 16; /* NMAX is divisible by 16 */
+ do {
+ DO16(buf); /* 16 sums unrolled */
+ buf += 16;
+ } while (--n);
+ MOD(adler);
+ MOD(sum2);
+ }
+
+ /* do remaining bytes (less than NMAX, still just one modulo) */
+ if (len) { /* avoid modulos if none remaining */
+ while (len >= 16) {
+ len -= 16;
+ DO16(buf);
+ buf += 16;
+ }
+ while (len--) {
+ adler += *buf++;
+ sum2 += adler;
+ }
+ MOD(adler);
+ MOD(sum2);
+ }
+
+ /* return recombined sums */
+ return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+ uLong adler1;
+ uLong adler2;
+ z_off_t len2;
+{
+ unsigned long sum1;
+ unsigned long sum2;
+ unsigned rem;
+
+ /* the derivation of this formula is left as an exercise for the reader */
+ rem = (unsigned)(len2 % BASE);
+ sum1 = adler1 & 0xffff;
+ sum2 = rem * sum1;
+ MOD(sum2);
+ sum1 += (adler2 & 0xffff) + BASE - 1;
+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+ if (sum1 > BASE) sum1 -= BASE;
+ if (sum1 > BASE) sum1 -= BASE;
+ if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
+ if (sum2 > BASE) sum2 -= BASE;
+ return sum1 | (sum2 << 16);
+}
--- /dev/null
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+ Compresses the source buffer into the destination buffer. The level
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
+ length of the source buffer. Upon entry, destLen is the total size of the
+ destination buffer, which must be at least 0.1% larger than sourceLen plus
+ 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+ Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+ int level;
+{
+ z_stream stream;
+ int err;
+
+ stream.next_in = (Bytef*)source;
+ stream.avail_in = (uInt)sourceLen;
+#ifdef MAXSEG_64K
+ /* Check for source > 64K on 16-bit machine: */
+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+#endif
+ stream.next_out = dest;
+ stream.avail_out = (uInt)*destLen;
+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
+
+ err = deflateInit(&stream, level);
+ if (err != Z_OK) return err;
+
+ err = deflate(&stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ deflateEnd(&stream);
+ return err == Z_OK ? Z_BUF_ERROR : err;
+ }
+ *destLen = stream.total_out;
+
+ err = deflateEnd(&stream);
+ return err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+ If the default memLevel or windowBits for deflateInit() is changed, then
+ this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+ uLong sourceLen;
+{
+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
+}
--- /dev/null
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors. This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+ Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+ protection on the static variables used to control the first-use generation
+ of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+ first call get_crc_table() to initialize the tables before allowing more than
+ one thread to use crc32().
+ */
+
+#ifdef MAKECRCH
+# include <stdio.h>
+# ifndef DYNAMIC_CRC_TABLE
+# define DYNAMIC_CRC_TABLE
+# endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h" /* for STDC and FAR definitions */
+
+#define local static
+
+/* Find a four-byte integer type for crc32_little() and crc32_big(). */
+#ifndef NOBYFOUR
+# ifdef STDC /* need ANSI C limits.h to determine sizes */
+# include <limits.h>
+# define BYFOUR
+# if (UINT_MAX == 0xffffffffUL)
+ typedef unsigned int u4;
+# else
+# if (ULONG_MAX == 0xffffffffUL)
+ typedef unsigned long u4;
+# else
+# if (USHRT_MAX == 0xffffffffUL)
+ typedef unsigned short u4;
+# else
+# undef BYFOUR /* can't find a four-byte integer type! */
+# endif
+# endif
+# endif
+# endif /* STDC */
+#endif /* !NOBYFOUR */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#ifdef BYFOUR
+# define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
+ (((w)&0xff00)<<8)+(((w)&0xff)<<24))
+ local unsigned long crc32_little OF((unsigned long,
+ const unsigned char FAR *, unsigned));
+ local unsigned long crc32_big OF((unsigned long,
+ const unsigned char FAR *, unsigned));
+# define TBLS 8
+#else
+# define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+ unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local unsigned long FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+ local void write_table OF((FILE *, const unsigned long FAR *));
+#endif /* MAKECRCH */
+/*
+ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+ x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+ Polynomials over GF(2) are represented in binary, one bit per coefficient,
+ with the lowest powers in the most significant bit. Then adding polynomials
+ is just exclusive-or, and multiplying a polynomial by x is a right shift by
+ one. If we call the above polynomial p, and represent a byte as the
+ polynomial q, also with the lowest power in the most significant bit (so the
+ byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+ where a mod b means the remainder after dividing a by b.
+
+ This calculation is done using the shift-register method of multiplying and
+ taking the remainder. The register is initialized to zero, and for each
+ incoming bit, x^32 is added mod p to the register if the bit is a one (where
+ x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+ x (which is shifting right by one and adding x^32 mod p if the bit shifted
+ out is a one). We start with the highest power (least significant bit) of
+ q and repeat for all eight bits of q.
+
+ The first table is simply the CRC of all possible eight bit values. This is
+ all the information needed to generate CRCs on data a byte at a time for all
+ combinations of CRC register values and incoming bytes. The remaining tables
+ allow for word-at-a-time CRC calculation for both big-endian and little-
+ endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+ unsigned long c;
+ int n, k;
+ unsigned long poly; /* polynomial exclusive-or pattern */
+ /* terms of polynomial defining this crc (except x^32): */
+ static volatile int first = 1; /* flag to limit concurrent making */
+ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+ /* See if another task is already doing this (not thread-safe, but better
+ than nothing -- significantly reduces duration of vulnerability in
+ case the advice about DYNAMIC_CRC_TABLE is ignored) */
+ if (first) {
+ first = 0;
+
+ /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+ poly = 0UL;
+ for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
+ poly |= 1UL << (31 - p[n]);
+
+ /* generate a crc for every 8-bit value */
+ for (n = 0; n < 256; n++) {
+ c = (unsigned long)n;
+ for (k = 0; k < 8; k++)
+ c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+ crc_table[0][n] = c;
+ }
+
+#ifdef BYFOUR
+ /* generate crc for each value followed by one, two, and three zeros,
+ and then the byte reversal of those as well as the first table */
+ for (n = 0; n < 256; n++) {
+ c = crc_table[0][n];
+ crc_table[4][n] = REV(c);
+ for (k = 1; k < 4; k++) {
+ c = crc_table[0][c & 0xff] ^ (c >> 8);
+ crc_table[k][n] = c;
+ crc_table[k + 4][n] = REV(c);
+ }
+ }
+#endif /* BYFOUR */
+
+ crc_table_empty = 0;
+ }
+ else { /* not first */
+ /* wait for the other guy to finish (not efficient, but rare) */
+ while (crc_table_empty)
+ ;
+ }
+
+#ifdef MAKECRCH
+ /* write out CRC tables to crc32.h */
+ {
+ FILE *out;
+
+ out = fopen("crc32.h", "w");
+ if (out == NULL) return;
+ fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+ fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+ fprintf(out, "local const unsigned long FAR ");
+ fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
+ write_table(out, crc_table[0]);
+# ifdef BYFOUR
+ fprintf(out, "#ifdef BYFOUR\n");
+ for (k = 1; k < 8; k++) {
+ fprintf(out, " },\n {\n");
+ write_table(out, crc_table[k]);
+ }
+ fprintf(out, "#endif\n");
+# endif /* BYFOUR */
+ fprintf(out, " }\n};\n");
+ fclose(out);
+ }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+ FILE *out;
+ const unsigned long FAR *table;
+{
+ int n;
+
+ for (n = 0; n < 256; n++)
+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n],
+ n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const unsigned long FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+ if (crc_table_empty)
+ make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+ return (const unsigned long FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+ if (crc_table_empty)
+ make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+ if (sizeof(void *) == sizeof(ptrdiff_t)) {
+ u4 endian;
+
+ endian = 1;
+ if (*((unsigned char *)(&endian)))
+ return crc32_little(crc, buf, len);
+ else
+ return crc32_big(crc, buf, len);
+ }
+#endif /* BYFOUR */
+ crc = crc ^ 0xffffffffUL;
+ while (len >= 8) {
+ DO8;
+ len -= 8;
+ }
+ if (len) do {
+ DO1;
+ } while (--len);
+ return crc ^ 0xffffffffUL;
+}
+
+#ifdef BYFOUR
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ register u4 c;
+ register const u4 FAR *buf4;
+
+ c = (u4)crc;
+ c = ~c;
+ while (len && ((ptrdiff_t)buf & 3)) {
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+ len--;
+ }
+
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
+ while (len >= 32) {
+ DOLIT32;
+ len -= 32;
+ }
+ while (len >= 4) {
+ DOLIT4;
+ len -= 4;
+ }
+ buf = (const unsigned char FAR *)buf4;
+
+ if (len) do {
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+ } while (--len);
+ c = ~c;
+ return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *++buf4; \
+ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ unsigned len;
+{
+ register u4 c;
+ register const u4 FAR *buf4;
+
+ c = REV((u4)crc);
+ c = ~c;
+ while (len && ((ptrdiff_t)buf & 3)) {
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+ len--;
+ }
+
+ buf4 = (const u4 FAR *)(const void FAR *)buf;
+ buf4--;
+ while (len >= 32) {
+ DOBIG32;
+ len -= 32;
+ }
+ while (len >= 4) {
+ DOBIG4;
+ len -= 4;
+ }
+ buf4++;
+ buf = (const unsigned char FAR *)buf4;
+
+ if (len) do {
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+ } while (--len);
+ c = ~c;
+ return (unsigned long)(REV(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+ unsigned long *mat;
+ unsigned long vec;
+{
+ unsigned long sum;
+
+ sum = 0;
+ while (vec) {
+ if (vec & 1)
+ sum ^= *mat;
+ vec >>= 1;
+ mat++;
+ }
+ return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+ unsigned long *square;
+ unsigned long *mat;
+{
+ int n;
+
+ for (n = 0; n < GF2_DIM; n++)
+ square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+ uLong crc1;
+ uLong crc2;
+ z_off_t len2;
+{
+ int n;
+ unsigned long row;
+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
+ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
+
+ /* degenerate case */
+ if (len2 == 0)
+ return crc1;
+
+ /* put operator for one zero bit in odd */
+ odd[0] = 0xedb88320L; /* CRC-32 polynomial */
+ row = 1;
+ for (n = 1; n < GF2_DIM; n++) {
+ odd[n] = row;
+ row <<= 1;
+ }
+
+ /* put operator for two zero bits in even */
+ gf2_matrix_square(even, odd);
+
+ /* put operator for four zero bits in odd */
+ gf2_matrix_square(odd, even);
+
+ /* apply len2 zeros to crc1 (first square will put the operator for one
+ zero byte, eight zero bits, in even) */
+ do {
+ /* apply zeros operator for this bit of len2 */
+ gf2_matrix_square(even, odd);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(even, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ if (len2 == 0)
+ break;
+
+ /* another iteration of the loop with odd and even swapped */
+ gf2_matrix_square(odd, even);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(odd, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ } while (len2 != 0);
+
+ /* return combined crc */
+ crc1 ^= crc2;
+ return crc1;
+}
--- /dev/null
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const unsigned long FAR crc_table[TBLS][256] =
+{
+ {
+ 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+ 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+ 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+ 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+ 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+ 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+ 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+ 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+ 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+ 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+ 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+ 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+ 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+ 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+ 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+ 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+ 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+ 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+ 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+ 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+ 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+ 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+ 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+ 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+ 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+ 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+ 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+ 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+ 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+ 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+ 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+ 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+ 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+ 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+ 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+ 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+ 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+ 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+ 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+ 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+ 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+ 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+ 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+ 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+ 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+ 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+ 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+ 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+ 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+ 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+ 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+ 0x2d02ef8dUL
+#ifdef BYFOUR
+ },
+ {
+ 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+ 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+ 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+ 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+ 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+ 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+ 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+ 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+ 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+ 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+ 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+ 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+ 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+ 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+ 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+ 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+ 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+ 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+ 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+ 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+ 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+ 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+ 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+ 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+ 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+ 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+ 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+ 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+ 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+ 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+ 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+ 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+ 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+ 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+ 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+ 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+ 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+ 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+ 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+ 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+ 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+ 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+ 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+ 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+ 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+ 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+ 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+ 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+ 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+ 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+ 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+ 0x9324fd72UL
+ },
+ {
+ 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+ 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+ 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+ 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+ 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+ 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+ 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+ 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+ 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+ 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+ 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+ 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+ 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+ 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+ 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+ 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+ 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+ 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+ 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+ 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+ 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+ 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+ 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+ 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+ 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+ 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+ 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+ 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+ 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+ 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+ 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+ 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+ 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+ 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+ 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+ 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+ 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+ 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+ 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+ 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+ 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+ 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+ 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+ 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+ 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+ 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+ 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+ 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+ 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+ 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+ 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+ 0xbe9834edUL
+ },
+ {
+ 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+ 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+ 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+ 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+ 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+ 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+ 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+ 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+ 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+ 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+ 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+ 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+ 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+ 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+ 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+ 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+ 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+ 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+ 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+ 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+ 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+ 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+ 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+ 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+ 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+ 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+ 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+ 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+ 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+ 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+ 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+ 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+ 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+ 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+ 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+ 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+ 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+ 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+ 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+ 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+ 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+ 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+ 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+ 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+ 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+ 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+ 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+ 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+ 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+ 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+ 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+ 0xde0506f1UL
+ },
+ {
+ 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+ 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+ 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+ 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+ 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+ 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+ 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+ 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+ 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+ 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+ 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+ 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+ 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+ 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+ 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+ 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+ 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+ 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+ 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+ 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+ 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+ 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+ 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+ 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+ 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+ 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+ 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+ 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+ 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+ 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+ 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+ 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+ 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+ 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+ 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+ 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+ 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+ 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+ 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+ 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+ 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+ 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+ 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+ 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+ 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+ 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+ 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+ 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+ 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+ 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+ 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+ 0x8def022dUL
+ },
+ {
+ 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+ 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+ 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+ 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+ 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+ 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+ 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+ 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+ 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+ 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+ 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+ 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+ 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+ 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+ 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+ 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+ 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+ 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+ 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+ 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+ 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+ 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+ 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+ 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+ 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+ 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+ 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+ 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+ 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+ 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+ 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+ 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+ 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+ 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+ 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+ 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+ 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+ 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+ 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+ 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+ 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+ 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+ 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+ 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+ 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+ 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+ 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+ 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+ 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+ 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+ 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+ 0x72fd2493UL
+ },
+ {
+ 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+ 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+ 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+ 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+ 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+ 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+ 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+ 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+ 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+ 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+ 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+ 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+ 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+ 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+ 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+ 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+ 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+ 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+ 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+ 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+ 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+ 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+ 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+ 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+ 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+ 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+ 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+ 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+ 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+ 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+ 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+ 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+ 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+ 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+ 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+ 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+ 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+ 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+ 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+ 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+ 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+ 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+ 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+ 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+ 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+ 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+ 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+ 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+ 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+ 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+ 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+ 0xed3498beUL
+ },
+ {
+ 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+ 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+ 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+ 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+ 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+ 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+ 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+ 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+ 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+ 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+ 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+ 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+ 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+ 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+ 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+ 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+ 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+ 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+ 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+ 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+ 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+ 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+ 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+ 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+ 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+ 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+ 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+ 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+ 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+ 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+ 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+ 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+ 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+ 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+ 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+ 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+ 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+ 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+ 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+ 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+ 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+ 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+ 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+ 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+ 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+ 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+ 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+ 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+ 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+ 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+ 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+ 0xf10605deUL
+#endif
+ }
+};
--- /dev/null
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * ALGORITHM
+ *
+ * The "deflation" process depends on being able to identify portions
+ * of the input text which are identical to earlier input (within a
+ * sliding window trailing behind the input currently being processed).
+ *
+ * The most straightforward technique turns out to be the fastest for
+ * most input files: try all possible matches and select the longest.
+ * The key feature of this algorithm is that insertions into the string
+ * dictionary are very simple and thus fast, and deletions are avoided
+ * completely. Insertions are performed at each input character, whereas
+ * string matches are performed only when the previous match ends. So it
+ * is preferable to spend more time in matches to allow very fast string
+ * insertions and avoid deletions. The matching algorithm for small
+ * strings is inspired from that of Rabin & Karp. A brute force approach
+ * is used to find longer strings when a small match has been found.
+ * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ * (by Leonid Broukhis).
+ * A previous version of this file used a more sophisticated algorithm
+ * (by Fiala and Greene) which is guaranteed to run in linear amortized
+ * time, but has a larger average cost, uses more memory and is patented.
+ * However the F&G algorithm may be faster for some highly redundant
+ * files if the parameter max_chain_length (described below) is too large.
+ *
+ * ACKNOWLEDGEMENTS
+ *
+ * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ * I found it in 'freeze' written by Leonid Broukhis.
+ * Thanks to many people for bug reports and testing.
+ *
+ * REFERENCES
+ *
+ * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ * Available in http://www.ietf.org/rfc/rfc1951.txt
+ *
+ * A description of the Rabin and Karp algorithm is given in the book
+ * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ * Fiala,E.R., and Greene,D.H.
+ * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id$ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+ " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
+/*
+ If you use the zlib library in a product, an acknowledgment is welcome
+ in the documentation of your product. If for some reason you cannot
+ include such an acknowledgment, I would appreciate that you keep this
+ copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ * Function prototypes.
+ */
+typedef enum {
+ need_more, /* block not completed, need more input or more output */
+ block_done, /* block flush performed */
+ finish_started, /* finish started, need only more output at next deflate */
+ finish_done /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local void fill_window OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast OF((deflate_state *s, int flush));
+#ifndef FASTEST
+local block_state deflate_slow OF((deflate_state *s, int flush));
+#endif
+local void lm_init OF((deflate_state *s));
+local void putShortMSB OF((deflate_state *s, uInt b));
+local void flush_pending OF((z_streamp strm));
+local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifndef FASTEST
+#ifdef ASMV
+ void match_init OF((void)); /* asm code initialization */
+ uInt longest_match OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match OF((deflate_state *s, IPos cur_match));
+#endif
+#endif
+local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));
+
+#ifdef DEBUG
+local void check_match OF((deflate_state *s, IPos start, IPos match,
+ int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+# define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+ ush good_length; /* reduce lazy search above this match length */
+ ush max_lazy; /* do not perform lazy search above this match length */
+ ush nice_length; /* quit search above this match length */
+ ush max_chain;
+ compress_func func;
+} config;
+
+#ifdef FASTEST
+local const config configuration_table[2] = {
+/* good lazy nice chain */
+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
+/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */
+#else
+local const config configuration_table[10] = {
+/* good lazy nice chain */
+/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
+/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */
+/* 2 */ {4, 5, 16, 8, deflate_fast},
+/* 3 */ {4, 6, 32, 32, deflate_fast},
+
+/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */
+/* 5 */ {8, 16, 32, 32, deflate_slow},
+/* 6 */ {8, 16, 128, 128, deflate_slow},
+/* 7 */ {8, 32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
+#endif
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+#ifndef NO_DUMMY_DECL
+struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
+#endif
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN assertion: all calls to to UPDATE_HASH are made with consecutive
+ * input characters, so that a running hash key can be computed from the
+ * previous key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN assertion: all calls to to INSERT_STRING are made with consecutive
+ * input characters and the first MIN_MATCH bytes of str are valid
+ * (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+ match_head = s->head[s->ins_h], \
+ s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+ (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+ match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
+ s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+ s->head[s->hash_size-1] = NIL; \
+ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+ z_streamp strm;
+ int level;
+ const char *version;
+ int stream_size;
+{
+ return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+ Z_DEFAULT_STRATEGY, version, stream_size);
+ /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+ version, stream_size)
+ z_streamp strm;
+ int level;
+ int method;
+ int windowBits;
+ int memLevel;
+ int strategy;
+ const char *version;
+ int stream_size;
+{
+ deflate_state *s;
+ int wrap = 1;
+ static const char my_version[] = ZLIB_VERSION;
+
+ ushf *overlay;
+ /* We overlay pending_buf and d_buf+l_buf. This works since the average
+ * output size for (length,distance) codes is <= 24 bits.
+ */
+
+ if (version == Z_NULL || version[0] != my_version[0] ||
+ stream_size != sizeof(z_stream)) {
+ return Z_VERSION_ERROR;
+ }
+ if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+ strm->msg = Z_NULL;
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+
+#ifdef FASTEST
+ if (level != 0) level = 1;
+#else
+ if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+
+ if (windowBits < 0) { /* suppress zlib wrapper */
+ wrap = 0;
+ windowBits = -windowBits;
+ }
+#ifdef GZIP
+ else if (windowBits > 15) {
+ wrap = 2; /* write gzip wrapper instead */
+ windowBits -= 16;
+ }
+#endif
+ if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+ windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+ strategy < 0 || strategy > Z_FIXED) {
+ return Z_STREAM_ERROR;
+ }
+ if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
+ s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+ if (s == Z_NULL) return Z_MEM_ERROR;
+ strm->state = (struct internal_state FAR *)s;
+ s->strm = strm;
+
+ s->wrap = wrap;
+ s->gzhead = Z_NULL;
+ s->w_bits = windowBits;
+ s->w_size = 1 << s->w_bits;
+ s->w_mask = s->w_size - 1;
+
+ s->hash_bits = memLevel + 7;
+ s->hash_size = 1 << s->hash_bits;
+ s->hash_mask = s->hash_size - 1;
+ s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+ s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+ s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
+ s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+ overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+ s->pending_buf = (uchf *) overlay;
+ s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+ if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+ s->pending_buf == Z_NULL) {
+ s->status = FINISH_STATE;
+ strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
+ deflateEnd (strm);
+ return Z_MEM_ERROR;
+ }
+ s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+ s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+ s->level = level;
+ s->strategy = strategy;
+ s->method = (Byte)method;
+
+ return deflateReset(strm);
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ const Bytef *dictionary;
+ uInt dictLength;
+{
+ deflate_state *s;
+ uInt length = dictLength;
+ uInt n;
+ IPos hash_head = 0;
+
+ if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
+ strm->state->wrap == 2 ||
+ (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
+ return Z_STREAM_ERROR;
+
+ s = strm->state;
+ if (s->wrap)
+ strm->adler = adler32(strm->adler, dictionary, dictLength);
+
+ if (length < MIN_MATCH) return Z_OK;
+ if (length > MAX_DIST(s)) {
+ length = MAX_DIST(s);
+ dictionary += dictLength - length; /* use the tail of the dictionary */
+ }
+ zmemcpy(s->window, dictionary, length);
+ s->strstart = length;
+ s->block_start = (long)length;
+
+ /* Insert all strings in the hash table (except for the last two bytes).
+ * s->lookahead stays null, so s->ins_h will be recomputed at the next
+ * call of fill_window.
+ */
+ s->ins_h = s->window[0];
+ UPDATE_HASH(s, s->ins_h, s->window[1]);
+ for (n = 0; n <= length - MIN_MATCH; n++) {
+ INSERT_STRING(s, n, hash_head);
+ }
+ if (hash_head) hash_head = 0; /* to make compiler happy */
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
+ return Z_STREAM_ERROR;
+ }
+
+ strm->total_in = strm->total_out = 0;
+ strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+ strm->data_type = Z_UNKNOWN;
+
+ s = (deflate_state *)strm->state;
+ s->pending = 0;
+ s->pending_out = s->pending_buf;
+
+ if (s->wrap < 0) {
+ s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
+ }
+ s->status = s->wrap ? INIT_STATE : BUSY_STATE;
+ strm->adler =
+#ifdef GZIP
+ s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+#endif
+ adler32(0L, Z_NULL, 0);
+ s->last_flush = Z_NO_FLUSH;
+
+ _tr_init(s);
+ lm_init(s);
+
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetHeader (strm, head)
+ z_streamp strm;
+ gz_headerp head;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ if (strm->state->wrap != 2) return Z_STREAM_ERROR;
+ strm->state->gzhead = head;
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePrime (strm, bits, value)
+ z_streamp strm;
+ int bits;
+ int value;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ strm->state->bi_valid = bits;
+ strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+ z_streamp strm;
+ int level;
+ int strategy;
+{
+ deflate_state *s;
+ compress_func func;
+ int err = Z_OK;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ s = strm->state;
+
+#ifdef FASTEST
+ if (level != 0) level = 1;
+#else
+ if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+ if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+ return Z_STREAM_ERROR;
+ }
+ func = configuration_table[s->level].func;
+
+ if (func != configuration_table[level].func && strm->total_in != 0) {
+ /* Flush the last buffer: */
+ err = deflate(strm, Z_PARTIAL_FLUSH);
+ }
+ if (s->level != level) {
+ s->level = level;
+ s->max_lazy_match = configuration_table[level].max_lazy;
+ s->good_match = configuration_table[level].good_length;
+ s->nice_match = configuration_table[level].nice_length;
+ s->max_chain_length = configuration_table[level].max_chain;
+ }
+ s->strategy = strategy;
+ return err;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
+ z_streamp strm;
+ int good_length;
+ int max_lazy;
+ int nice_length;
+ int max_chain;
+{
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ s = strm->state;
+ s->good_match = good_length;
+ s->max_lazy_match = max_lazy;
+ s->nice_match = nice_length;
+ s->max_chain_length = max_chain;
+ return Z_OK;
+}
+
+/* =========================================================================
+ * For the default windowBits of 15 and memLevel of 8, this function returns
+ * a close to exact, as well as small, upper bound on the compressed size.
+ * They are coded as constants here for a reason--if the #define's are
+ * changed, then this function needs to be changed as well. The return
+ * value for 15 and 8 only works for those exact settings.
+ *
+ * For any setting other than those defaults for windowBits and memLevel,
+ * the value returned is a conservative worst case for the maximum expansion
+ * resulting from using fixed blocks instead of stored blocks, which deflate
+ * can emit on compressed data for some combinations of the parameters.
+ *
+ * This function could be more sophisticated to provide closer upper bounds
+ * for every combination of windowBits and memLevel, as well as wrap.
+ * But even the conservative upper bound of about 14% expansion does not
+ * seem onerous for output buffer allocation.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+ z_streamp strm;
+ uLong sourceLen;
+{
+ deflate_state *s;
+ uLong destLen;
+
+ /* conservative upper bound */
+ destLen = sourceLen +
+ ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;
+
+ /* if can't get parameters, return conservative bound */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return destLen;
+
+ /* if not default parameters, return conservative bound */
+ s = strm->state;
+ if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+ return destLen;
+
+ /* default settings: return tight bound for that case */
+ return compressBound(sourceLen);
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+ deflate_state *s;
+ uInt b;
+{
+ put_byte(s, (Byte)(b >> 8));
+ put_byte(s, (Byte)(b & 0xff));
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output goes
+ * through this function so some applications may wish to modify it
+ * to avoid allocating a large strm->next_out buffer and copying into it.
+ * (See also read_buf()).
+ */
+local void flush_pending(strm)
+ z_streamp strm;
+{
+ unsigned len = strm->state->pending;
+
+ if (len > strm->avail_out) len = strm->avail_out;
+ if (len == 0) return;
+
+ zmemcpy(strm->next_out, strm->state->pending_out, len);
+ strm->next_out += len;
+ strm->state->pending_out += len;
+ strm->total_out += len;
+ strm->avail_out -= len;
+ strm->state->pending -= len;
+ if (strm->state->pending == 0) {
+ strm->state->pending_out = strm->state->pending_buf;
+ }
+}
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+ z_streamp strm;
+ int flush;
+{
+ int old_flush; /* value of flush param for previous deflate call */
+ deflate_state *s;
+
+ if (strm == Z_NULL || strm->state == Z_NULL ||
+ flush > Z_FINISH || flush < 0) {
+ return Z_STREAM_ERROR;
+ }
+ s = strm->state;
+
+ if (strm->next_out == Z_NULL ||
+ (strm->next_in == Z_NULL && strm->avail_in != 0) ||
+ (s->status == FINISH_STATE && flush != Z_FINISH)) {
+ ERR_RETURN(strm, Z_STREAM_ERROR);
+ }
+ if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+ s->strm = strm; /* just in case */
+ old_flush = s->last_flush;
+ s->last_flush = flush;
+
+ /* Write the header */
+ if (s->status == INIT_STATE) {
+#ifdef GZIP
+ if (s->wrap == 2) {
+ strm->adler = crc32(0L, Z_NULL, 0);
+ put_byte(s, 31);
+ put_byte(s, 139);
+ put_byte(s, 8);
+ if (s->gzhead == NULL) {
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, 0);
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, OS_CODE);
+ s->status = BUSY_STATE;
+ }
+ else {
+ put_byte(s, (s->gzhead->text ? 1 : 0) +
+ (s->gzhead->hcrc ? 2 : 0) +
+ (s->gzhead->extra == Z_NULL ? 0 : 4) +
+ (s->gzhead->name == Z_NULL ? 0 : 8) +
+ (s->gzhead->comment == Z_NULL ? 0 : 16)
+ );
+ put_byte(s, (Byte)(s->gzhead->time & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+ put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+ put_byte(s, s->level == 9 ? 2 :
+ (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+ 4 : 0));
+ put_byte(s, s->gzhead->os & 0xff);
+ if (s->gzhead->extra != NULL) {
+ put_byte(s, s->gzhead->extra_len & 0xff);
+ put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
+ }
+ if (s->gzhead->hcrc)
+ strm->adler = crc32(strm->adler, s->pending_buf,
+ s->pending);
+ s->gzindex = 0;
+ s->status = EXTRA_STATE;
+ }
+ }
+ else
+#endif
+ {
+ uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+ uInt level_flags;
+
+ if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+ level_flags = 0;
+ else if (s->level < 6)
+ level_flags = 1;
+ else if (s->level == 6)
+ level_flags = 2;
+ else
+ level_flags = 3;
+ header |= (level_flags << 6);
+ if (s->strstart != 0) header |= PRESET_DICT;
+ header += 31 - (header % 31);
+
+ s->status = BUSY_STATE;
+ putShortMSB(s, header);
+
+ /* Save the adler32 of the preset dictionary: */
+ if (s->strstart != 0) {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ strm->adler = adler32(0L, Z_NULL, 0);
+ }
+ }
+#ifdef GZIP
+ if (s->status == EXTRA_STATE) {
+ if (s->gzhead->extra != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+
+ while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size)
+ break;
+ }
+ put_byte(s, s->gzhead->extra[s->gzindex]);
+ s->gzindex++;
+ }
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (s->gzindex == s->gzhead->extra_len) {
+ s->gzindex = 0;
+ s->status = NAME_STATE;
+ }
+ }
+ else
+ s->status = NAME_STATE;
+ }
+ if (s->status == NAME_STATE) {
+ if (s->gzhead->name != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+ int val;
+
+ do {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size) {
+ val = 1;
+ break;
+ }
+ }
+ val = s->gzhead->name[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (val == 0) {
+ s->gzindex = 0;
+ s->status = COMMENT_STATE;
+ }
+ }
+ else
+ s->status = COMMENT_STATE;
+ }
+ if (s->status == COMMENT_STATE) {
+ if (s->gzhead->comment != NULL) {
+ uInt beg = s->pending; /* start of bytes to update crc */
+ int val;
+
+ do {
+ if (s->pending == s->pending_buf_size) {
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ flush_pending(strm);
+ beg = s->pending;
+ if (s->pending == s->pending_buf_size) {
+ val = 1;
+ break;
+ }
+ }
+ val = s->gzhead->comment[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ if (s->gzhead->hcrc && s->pending > beg)
+ strm->adler = crc32(strm->adler, s->pending_buf + beg,
+ s->pending - beg);
+ if (val == 0)
+ s->status = HCRC_STATE;
+ }
+ else
+ s->status = HCRC_STATE;
+ }
+ if (s->status == HCRC_STATE) {
+ if (s->gzhead->hcrc) {
+ if (s->pending + 2 > s->pending_buf_size)
+ flush_pending(strm);
+ if (s->pending + 2 <= s->pending_buf_size) {
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ strm->adler = crc32(0L, Z_NULL, 0);
+ s->status = BUSY_STATE;
+ }
+ }
+ else
+ s->status = BUSY_STATE;
+ }
+#endif
+
+ /* Flush as much pending output as possible */
+ if (s->pending != 0) {
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ /* Since avail_out is 0, deflate will be called again with
+ * more output space, but possibly with both pending and
+ * avail_in equal to zero. There won't be anything to do,
+ * but this is not an error situation so make sure we
+ * return OK instead of BUF_ERROR at next call of deflate:
+ */
+ s->last_flush = -1;
+ return Z_OK;
+ }
+
+ /* Make sure there is something to do and avoid duplicate consecutive
+ * flushes. For repeated and useless calls with Z_FINISH, we keep
+ * returning Z_STREAM_END instead of Z_BUF_ERROR.
+ */
+ } else if (strm->avail_in == 0 && flush <= old_flush &&
+ flush != Z_FINISH) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* User must not provide more input after the first FINISH: */
+ if (s->status == FINISH_STATE && strm->avail_in != 0) {
+ ERR_RETURN(strm, Z_BUF_ERROR);
+ }
+
+ /* Start a new block or continue the current one.
+ */
+ if (strm->avail_in != 0 || s->lookahead != 0 ||
+ (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+ block_state bstate;
+
+ bstate = (*(configuration_table[s->level].func))(s, flush);
+
+ if (bstate == finish_started || bstate == finish_done) {
+ s->status = FINISH_STATE;
+ }
+ if (bstate == need_more || bstate == finish_started) {
+ if (strm->avail_out == 0) {
+ s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+ }
+ return Z_OK;
+ /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+ * of deflate should use the same flush parameter to make sure
+ * that the flush is complete. So we don't have to output an
+ * empty block here, this will be done at next call. This also
+ * ensures that for a very small output buffer, we emit at most
+ * one empty block.
+ */
+ }
+ if (bstate == block_done) {
+ if (flush == Z_PARTIAL_FLUSH) {
+ _tr_align(s);
+ } else { /* FULL_FLUSH or SYNC_FLUSH */
+ _tr_stored_block(s, (char*)0, 0L, 0);
+ /* For a full flush, this empty block will be recognized
+ * as a special marker by inflate_sync().
+ */
+ if (flush == Z_FULL_FLUSH) {
+ CLEAR_HASH(s); /* forget history */
+ }
+ }
+ flush_pending(strm);
+ if (strm->avail_out == 0) {
+ s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+ return Z_OK;
+ }
+ }
+ }
+ Assert(strm->avail_out > 0, "bug2");
+
+ if (flush != Z_FINISH) return Z_OK;
+ if (s->wrap <= 0) return Z_STREAM_END;
+
+ /* Write the trailer */
+#ifdef GZIP
+ if (s->wrap == 2) {
+ put_byte(s, (Byte)(strm->adler & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
+ put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
+ put_byte(s, (Byte)(strm->total_in & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
+ put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
+ }
+ else
+#endif
+ {
+ putShortMSB(s, (uInt)(strm->adler >> 16));
+ putShortMSB(s, (uInt)(strm->adler & 0xffff));
+ }
+ flush_pending(strm);
+ /* If avail_out is zero, the application will call deflate again
+ * to flush the rest.
+ */
+ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+ return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+ z_streamp strm;
+{
+ int status;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+
+ status = strm->state->status;
+ if (status != INIT_STATE &&
+ status != EXTRA_STATE &&
+ status != NAME_STATE &&
+ status != COMMENT_STATE &&
+ status != HCRC_STATE &&
+ status != BUSY_STATE &&
+ status != FINISH_STATE) {
+ return Z_STREAM_ERROR;
+ }
+
+ /* Deallocate in reverse order of allocations: */
+ TRY_FREE(strm, strm->state->pending_buf);
+ TRY_FREE(strm, strm->state->head);
+ TRY_FREE(strm, strm->state->prev);
+ TRY_FREE(strm, strm->state->window);
+
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+
+ return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+ z_streamp dest;
+ z_streamp source;
+{
+#ifdef MAXSEG_64K
+ return Z_STREAM_ERROR;
+#else
+ deflate_state *ds;
+ deflate_state *ss;
+ ushf *overlay;
+
+
+ if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
+ return Z_STREAM_ERROR;
+ }
+
+ ss = source->state;
+
+ zmemcpy(dest, source, sizeof(z_stream));
+
+ ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+ if (ds == Z_NULL) return Z_MEM_ERROR;
+ dest->state = (struct internal_state FAR *) ds;
+ zmemcpy(ds, ss, sizeof(deflate_state));
+ ds->strm = dest;
+
+ ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+ ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
+ ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
+ overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+ ds->pending_buf = (uchf *) overlay;
+
+ if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+ ds->pending_buf == Z_NULL) {
+ deflateEnd (dest);
+ return Z_MEM_ERROR;
+ }
+ /* following zmemcpy do not work for 16-bit MSDOS */
+ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+ zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
+ zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
+ zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+ ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+ ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+ ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+ ds->l_desc.dyn_tree = ds->dyn_ltree;
+ ds->d_desc.dyn_tree = ds->dyn_dtree;
+ ds->bl_desc.dyn_tree = ds->bl_tree;
+
+ return Z_OK;
+#endif /* MAXSEG_64K */
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read. All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local int read_buf(strm, buf, size)
+ z_streamp strm;
+ Bytef *buf;
+ unsigned size;
+{
+ unsigned len = strm->avail_in;
+
+ if (len > size) len = size;
+ if (len == 0) return 0;
+
+ strm->avail_in -= len;
+
+ if (strm->state->wrap == 1) {
+ strm->adler = adler32(strm->adler, strm->next_in, len);
+ }
+#ifdef GZIP
+ else if (strm->state->wrap == 2) {
+ strm->adler = crc32(strm->adler, strm->next_in, len);
+ }
+#endif
+ zmemcpy(buf, strm->next_in, len);
+ strm->next_in += len;
+ strm->total_in += len;
+
+ return (int)len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+ deflate_state *s;
+{
+ s->window_size = (ulg)2L*s->w_size;
+
+ CLEAR_HASH(s);
+
+ /* Set the default configuration parameters:
+ */
+ s->max_lazy_match = configuration_table[s->level].max_lazy;
+ s->good_match = configuration_table[s->level].good_length;
+ s->nice_match = configuration_table[s->level].nice_length;
+ s->max_chain_length = configuration_table[s->level].max_chain;
+
+ s->strstart = 0;
+ s->block_start = 0L;
+ s->lookahead = 0;
+ s->match_length = s->prev_length = MIN_MATCH-1;
+ s->match_available = 0;
+ s->ins_h = 0;
+#ifndef FASTEST
+#ifdef ASMV
+ match_init(); /* initialize the asm code */
+#endif
+#endif
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+local uInt longest_match(s, cur_match)
+ deflate_state *s;
+ IPos cur_match; /* current match */
+{
+ unsigned chain_length = s->max_chain_length;/* max hash chain length */
+ register Bytef *scan = s->window + s->strstart; /* current string */
+ register Bytef *match; /* matched string */
+ register int len; /* length of current match */
+ int best_len = s->prev_length; /* best match length so far */
+ int nice_match = s->nice_match; /* stop if match long enough */
+ IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+ s->strstart - (IPos)MAX_DIST(s) : NIL;
+ /* Stop when cur_match becomes <= limit. To simplify the code,
+ * we prevent matches with the string of window index 0.
+ */
+ Posf *prev = s->prev;
+ uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+ /* Compare two bytes at a time. Note: this is not always beneficial.
+ * Try with and without -DUNALIGNED_OK to check.
+ */
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+ register ush scan_start = *(ushf*)scan;
+ register ush scan_end = *(ushf*)(scan+best_len-1);
+#else
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+ register Byte scan_end1 = scan[best_len-1];
+ register Byte scan_end = scan[best_len];
+#endif
+
+ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+ * It is easy to get rid of this optimization if necessary.
+ */
+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+ /* Do not waste too much time if we already have a good match: */
+ if (s->prev_length >= s->good_match) {
+ chain_length >>= 2;
+ }
+ /* Do not look for matches beyond the end of the input. This is necessary
+ * to make deflate deterministic.
+ */
+ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+ do {
+ Assert(cur_match < s->strstart, "no future");
+ match = s->window + cur_match;
+
+ /* Skip to next match if the match length cannot increase
+ * or if the match length is less than 2. Note that the checks below
+ * for insufficient lookahead only occur occasionally for performance
+ * reasons. Therefore uninitialized memory will be accessed, and
+ * conditional jumps will be made that depend on those values.
+ * However the length of the match is limited to the lookahead, so
+ * the output of deflate is not affected by the uninitialized values.
+ */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+ /* This code assumes sizeof(unsigned short) == 2. Do not use
+ * UNALIGNED_OK if your compiler uses a different size.
+ */
+ if (*(ushf*)(match+best_len-1) != scan_end ||
+ *(ushf*)match != scan_start) continue;
+
+ /* It is not necessary to compare scan[2] and match[2] since they are
+ * always equal when the other bytes match, given that the hash keys
+ * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+ * strstart+3, +5, ... up to strstart+257. We check for insufficient
+ * lookahead only every 4th comparison; the 128th check will be made
+ * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+ * necessary to put more guard bytes at the end of the window, or
+ * to check more often for insufficient lookahead.
+ */
+ Assert(scan[2] == match[2], "scan[2]?");
+ scan++, match++;
+ do {
+ } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ scan < strend);
+ /* The funny "do {}" generates better code on most compilers */
+
+ /* Here, scan <= window+strstart+257 */
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+ if (*scan == *match) scan++;
+
+ len = (MAX_MATCH - 1) - (int)(strend-scan);
+ scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+ if (match[best_len] != scan_end ||
+ match[best_len-1] != scan_end1 ||
+ *match != *scan ||
+ *++match != scan[1]) continue;
+
+ /* The check at best_len-1 can be removed because it will be made
+ * again later. (This heuristic is not always a win.)
+ * It is not necessary to compare scan[2] and match[2] since they
+ * are always equal when the other bytes match, given that
+ * the hash keys are equal and that HASH_BITS >= 8.
+ */
+ scan += 2, match++;
+ Assert(*scan == *match, "match[2]?");
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {
+ } while (*++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ scan < strend);
+
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+ len = MAX_MATCH - (int)(strend - scan);
+ scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+ if (len > best_len) {
+ s->match_start = cur_match;
+ best_len = len;
+ if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+ scan_end = *(ushf*)(scan+best_len-1);
+#else
+ scan_end1 = scan[best_len-1];
+ scan_end = scan[best_len];
+#endif
+ }
+ } while ((cur_match = prev[cur_match & wmask]) > limit
+ && --chain_length != 0);
+
+ if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+ return s->lookahead;
+}
+#endif /* ASMV */
+#endif /* FASTEST */
+
+/* ---------------------------------------------------------------------------
+ * Optimized version for level == 1 or strategy == Z_RLE only
+ */
+local uInt longest_match_fast(s, cur_match)
+ deflate_state *s;
+ IPos cur_match; /* current match */
+{
+ register Bytef *scan = s->window + s->strstart; /* current string */
+ register Bytef *match; /* matched string */
+ register int len; /* length of current match */
+ register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+ /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+ * It is easy to get rid of this optimization if necessary.
+ */
+ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+ Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+ Assert(cur_match < s->strstart, "no future");
+
+ match = s->window + cur_match;
+
+ /* Return failure if the match length is less than 2:
+ */
+ if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+ /* The check at best_len-1 can be removed because it will be made
+ * again later. (This heuristic is not always a win.)
+ * It is not necessary to compare scan[2] and match[2] since they
+ * are always equal when the other bytes match, given that
+ * the hash keys are equal and that HASH_BITS >= 8.
+ */
+ scan += 2, match += 2;
+ Assert(*scan == *match, "match[2]?");
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {
+ } while (*++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ *++scan == *++match && *++scan == *++match &&
+ scan < strend);
+
+ Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+ len = MAX_MATCH - (int)(strend - scan);
+
+ if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+ s->match_start = cur_match;
+ return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
+}
+
+#ifdef DEBUG
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+ deflate_state *s;
+ IPos start, match;
+ int length;
+{
+ /* check that the match is indeed a match */
+ if (zmemcmp(s->window + match,
+ s->window + start, length) != EQUAL) {
+ fprintf(stderr, " start %u, match %u, length %d\n",
+ start, match, length);
+ do {
+ fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+ } while (--length != 0);
+ z_error("invalid match");
+ }
+ if (z_verbose > 1) {
+ fprintf(stderr,"\\[%d,%d]", start-match, length);
+ do { putc(s->window[start++], stderr); } while (--length != 0);
+ }
+}
+#else
+# define check_match(s, start, match, length)
+#endif /* DEBUG */
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ * At least one byte has been read, or avail_in == 0; reads are
+ * performed for at least two bytes (required for the zip translate_eol
+ * option -- not supported here).
+ */
+local void fill_window(s)
+ deflate_state *s;
+{
+ register unsigned n, m;
+ register Posf *p;
+ unsigned more; /* Amount of free space at the end of the window. */
+ uInt wsize = s->w_size;
+
+ do {
+ more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+ /* Deal with !@#$% 64K limit: */
+ if (sizeof(int) <= 2) {
+ if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+ more = wsize;
+
+ } else if (more == (unsigned)(-1)) {
+ /* Very unlikely, but possible on 16 bit machine if
+ * strstart == 0 && lookahead == 1 (input done a byte at time)
+ */
+ more--;
+ }
+ }
+
+ /* If the window is almost full and there is insufficient lookahead,
+ * move the upper half to the lower one to make room in the upper half.
+ */
+ if (s->strstart >= wsize+MAX_DIST(s)) {
+
+ zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
+ s->match_start -= wsize;
+ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
+ s->block_start -= (long) wsize;
+
+ /* Slide the hash table (could be avoided with 32 bit values
+ at the expense of memory usage). We slide even when level == 0
+ to keep the hash table consistent if we switch back to level > 0
+ later. (Using level 0 permanently is not an optimal usage of
+ zlib, so we don't care about this pathological case.)
+ */
+ /* %%% avoid this when Z_RLE */
+ n = s->hash_size;
+ p = &s->head[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m-wsize : NIL);
+ } while (--n);
+
+ n = wsize;
+#ifndef FASTEST
+ p = &s->prev[n];
+ do {
+ m = *--p;
+ *p = (Pos)(m >= wsize ? m-wsize : NIL);
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
+ */
+ } while (--n);
+#endif
+ more += wsize;
+ }
+ if (s->strm->avail_in == 0) return;
+
+ /* If there was no sliding:
+ * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+ * more == window_size - lookahead - strstart
+ * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+ * => more >= window_size - 2*WSIZE + 2
+ * In the BIG_MEM or MMAP case (not yet supported),
+ * window_size == input_size + MIN_LOOKAHEAD &&
+ * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+ * Otherwise, window_size == 2*WSIZE so more >= 2.
+ * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+ */
+ Assert(more >= 2, "more < 2");
+
+ n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+ s->lookahead += n;
+
+ /* Initialize the hash value now that we have some input: */
+ if (s->lookahead >= MIN_MATCH) {
+ s->ins_h = s->window[s->strstart];
+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+ Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+ }
+ /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+ * but this is not important since only literal bytes will be emitted.
+ */
+
+ } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, eof) { \
+ _tr_flush_block(s, (s->block_start >= 0L ? \
+ (charf *)&s->window[(unsigned)s->block_start] : \
+ (charf *)Z_NULL), \
+ (ulg)((long)s->strstart - s->block_start), \
+ (eof)); \
+ s->block_start = s->strstart; \
+ flush_pending(s->strm); \
+ Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, eof) { \
+ FLUSH_BLOCK_ONLY(s, eof); \
+ if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
+}
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ * This function does not insert new strings in the dictionary since
+ * uncompressible data is probably not useful. This function is used
+ * only for the level=0 compression option.
+ * NOTE: this function should be optimized to avoid extra copying from
+ * window to pending_buf.
+ */
+local block_state deflate_stored(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
+ * to pending_buf_size, and each stored block has a 5 byte header:
+ */
+ ulg max_block_size = 0xffff;
+ ulg max_start;
+
+ if (max_block_size > s->pending_buf_size - 5) {
+ max_block_size = s->pending_buf_size - 5;
+ }
+
+ /* Copy as much as possible from input to output: */
+ for (;;) {
+ /* Fill the window as much as possible: */
+ if (s->lookahead <= 1) {
+
+ Assert(s->strstart < s->w_size+MAX_DIST(s) ||
+ s->block_start >= (long)s->w_size, "slide too late");
+
+ fill_window(s);
+ if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
+
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+ Assert(s->block_start >= 0L, "block gone");
+
+ s->strstart += s->lookahead;
+ s->lookahead = 0;
+
+ /* Emit a stored block if pending_buf will be full: */
+ max_start = s->block_start + max_block_size;
+ if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
+ /* strstart == 0 is possible when wraparound on 16-bit machine */
+ s->lookahead = (uInt)(s->strstart - max_start);
+ s->strstart = (uInt)max_start;
+ FLUSH_BLOCK(s, 0);
+ }
+ /* Flush if we may have to slide, otherwise block_start may become
+ * negative and the data will be gone:
+ */
+ if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
+ FLUSH_BLOCK(s, 0);
+ }
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ IPos hash_head = NIL; /* head of the hash chain */
+ int bflush; /* set if current block must be flushed */
+
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ if (s->lookahead < MIN_LOOKAHEAD) {
+ fill_window(s);
+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ if (s->lookahead >= MIN_MATCH) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+
+ /* Find the longest match, discarding those <= prev_length.
+ * At this point we have always match_length < MIN_MATCH
+ */
+ if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+ /* To simplify the code, we prevent matches with the string
+ * of window index 0 (in particular we have to avoid a match
+ * of the string with itself at the start of the input file).
+ */
+#ifdef FASTEST
+ if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
+ (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+#else
+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+ s->match_length = longest_match (s, hash_head);
+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+#endif
+ /* longest_match() or longest_match_fast() sets match_start */
+ }
+ if (s->match_length >= MIN_MATCH) {
+ check_match(s, s->strstart, s->match_start, s->match_length);
+
+ _tr_tally_dist(s, s->strstart - s->match_start,
+ s->match_length - MIN_MATCH, bflush);
+
+ s->lookahead -= s->match_length;
+
+ /* Insert new strings in the hash table only if the match length
+ * is not too large. This saves time but degrades compression.
+ */
+#ifndef FASTEST
+ if (s->match_length <= s->max_insert_length &&
+ s->lookahead >= MIN_MATCH) {
+ s->match_length--; /* string at strstart already in table */
+ do {
+ s->strstart++;
+ INSERT_STRING(s, s->strstart, hash_head);
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead.
+ */
+ } while (--s->match_length != 0);
+ s->strstart++;
+ } else
+#endif
+ {
+ s->strstart += s->match_length;
+ s->match_length = 0;
+ s->ins_h = s->window[s->strstart];
+ UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+ Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+ /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+ * matter since it will be recomputed at next deflate call.
+ */
+ }
+ } else {
+ /* No match, output a literal byte */
+ Tracevv((stderr,"%c", s->window[s->strstart]));
+ _tr_tally_lit (s, s->window[s->strstart], bflush);
+ s->lookahead--;
+ s->strstart++;
+ }
+ if (bflush) FLUSH_BLOCK(s, 0);
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ IPos hash_head = NIL; /* head of hash chain */
+ int bflush; /* set if current block must be flushed */
+
+ /* Process the input block. */
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the next match, plus MIN_MATCH bytes to insert the
+ * string following the next match.
+ */
+ if (s->lookahead < MIN_LOOKAHEAD) {
+ fill_window(s);
+ if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ if (s->lookahead >= MIN_MATCH) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+
+ /* Find the longest match, discarding those <= prev_length.
+ */
+ s->prev_length = s->match_length, s->prev_match = s->match_start;
+ s->match_length = MIN_MATCH-1;
+
+ if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+ s->strstart - hash_head <= MAX_DIST(s)) {
+ /* To simplify the code, we prevent matches with the string
+ * of window index 0 (in particular we have to avoid a match
+ * of the string with itself at the start of the input file).
+ */
+ if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
+ s->match_length = longest_match (s, hash_head);
+ } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
+ s->match_length = longest_match_fast (s, hash_head);
+ }
+ /* longest_match() or longest_match_fast() sets match_start */
+
+ if (s->match_length <= 5 && (s->strategy == Z_FILTERED
+#if TOO_FAR <= 32767
+ || (s->match_length == MIN_MATCH &&
+ s->strstart - s->match_start > TOO_FAR)
+#endif
+ )) {
+
+ /* If prev_match is also MIN_MATCH, match_start is garbage
+ * but we will ignore the current match anyway.
+ */
+ s->match_length = MIN_MATCH-1;
+ }
+ }
+ /* If there was a match at the previous step and the current
+ * match is not better, output the previous match:
+ */
+ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+ uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+ /* Do not insert strings in hash table beyond this. */
+
+ check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+ _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+ s->prev_length - MIN_MATCH, bflush);
+
+ /* Insert in hash table all strings up to the end of the match.
+ * strstart-1 and strstart are already inserted. If there is not
+ * enough lookahead, the last two strings are not inserted in
+ * the hash table.
+ */
+ s->lookahead -= s->prev_length-1;
+ s->prev_length -= 2;
+ do {
+ if (++s->strstart <= max_insert) {
+ INSERT_STRING(s, s->strstart, hash_head);
+ }
+ } while (--s->prev_length != 0);
+ s->match_available = 0;
+ s->match_length = MIN_MATCH-1;
+ s->strstart++;
+
+ if (bflush) FLUSH_BLOCK(s, 0);
+
+ } else if (s->match_available) {
+ /* If there was no match at the previous position, output a
+ * single literal. If there was a match but the current match
+ * is longer, truncate the previous match to a single literal.
+ */
+ Tracevv((stderr,"%c", s->window[s->strstart-1]));
+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+ if (bflush) {
+ FLUSH_BLOCK_ONLY(s, 0);
+ }
+ s->strstart++;
+ s->lookahead--;
+ if (s->strm->avail_out == 0) return need_more;
+ } else {
+ /* There is no previous match to compare with, wait for
+ * the next step to decide.
+ */
+ s->match_available = 1;
+ s->strstart++;
+ s->lookahead--;
+ }
+ }
+ Assert (flush != Z_NO_FLUSH, "no flush?");
+ if (s->match_available) {
+ Tracevv((stderr,"%c", s->window[s->strstart-1]));
+ _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+ s->match_available = 0;
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif /* FASTEST */
+
+#if 0
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one. Do not maintain a hash table. (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+local block_state deflate_rle(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ int bflush; /* set if current block must be flushed */
+ uInt run; /* length of run */
+ uInt max; /* maximum length of run */
+ uInt prev; /* byte at distance one to match */
+ Bytef *scan; /* scan for end of run */
+
+ for (;;) {
+ /* Make sure that we always have enough lookahead, except
+ * at the end of the input file. We need MAX_MATCH bytes
+ * for the longest encodable run.
+ */
+ if (s->lookahead < MAX_MATCH) {
+ fill_window(s);
+ if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
+ return need_more;
+ }
+ if (s->lookahead == 0) break; /* flush the current block */
+ }
+
+ /* See how many times the previous byte repeats */
+ run = 0;
+ if (s->strstart > 0) { /* if there is a previous byte, that is */
+ max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
+ scan = s->window + s->strstart - 1;
+ prev = *scan++;
+ do {
+ if (*scan++ != prev)
+ break;
+ } while (++run < max);
+ }
+
+ /* Emit match if have run of MIN_MATCH or longer, else emit literal */
+ if (run >= MIN_MATCH) {
+ check_match(s, s->strstart, s->strstart - 1, run);
+ _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
+ s->lookahead -= run;
+ s->strstart += run;
+ } else {
+ /* No match, output a literal byte */
+ Tracevv((stderr,"%c", s->window[s->strstart]));
+ _tr_tally_lit (s, s->window[s->strstart], bflush);
+ s->lookahead--;
+ s->strstart++;
+ }
+ if (bflush) FLUSH_BLOCK(s, 0);
+ }
+ FLUSH_BLOCK(s, flush == Z_FINISH);
+ return flush == Z_FINISH ? finish_done : block_done;
+}
+#endif
--- /dev/null
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2004 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+ trailer creation by deflate(). NO_GZIP would be used to avoid linking in
+ the crc code when it is not needed. For shared libraries, gzip encoding
+ should be left enabled. */
+#ifndef NO_GZIP
+# define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS 256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES 30
+/* number of distance codes */
+
+#define BL_CODES 19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define INIT_STATE 42
+#define EXTRA_STATE 69
+#define NAME_STATE 73
+#define COMMENT_STATE 91
+#define HCRC_STATE 103
+#define BUSY_STATE 113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+ union {
+ ush freq; /* frequency count */
+ ush code; /* bit string */
+ } fc;
+ union {
+ ush dad; /* father node in Huffman tree */
+ ush len; /* length of bit string */
+ } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad dl.dad
+#define Len dl.len
+
+typedef struct static_tree_desc_s static_tree_desc;
+
+typedef struct tree_desc_s {
+ ct_data *dyn_tree; /* the dynamic tree */
+ int max_code; /* largest code with non zero frequency */
+ static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+ z_streamp strm; /* pointer back to this zlib stream */
+ int status; /* as the name implies */
+ Bytef *pending_buf; /* output still pending */
+ ulg pending_buf_size; /* size of pending_buf */
+ Bytef *pending_out; /* next pending byte to output to the stream */
+ uInt pending; /* nb of bytes in the pending buffer */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ gz_headerp gzhead; /* gzip header information to write */
+ uInt gzindex; /* where in extra, name, or comment */
+ Byte method; /* STORED (for zip only) or DEFLATED */
+ int last_flush; /* value of flush param for previous deflate call */
+
+ /* used by deflate.c: */
+
+ uInt w_size; /* LZ77 window size (32K by default) */
+ uInt w_bits; /* log2(w_size) (8..16) */
+ uInt w_mask; /* w_size - 1 */
+
+ Bytef *window;
+ /* Sliding window. Input bytes are read into the second half of the window,
+ * and move to the first half later to keep a dictionary of at least wSize
+ * bytes. With this organization, matches are limited to a distance of
+ * wSize-MAX_MATCH bytes, but this ensures that IO is always
+ * performed with a length multiple of the block size. Also, it limits
+ * the window size to 64K, which is quite useful on MSDOS.
+ * To do: use the user input buffer as sliding window.
+ */
+
+ ulg window_size;
+ /* Actual size of window: 2*wSize, except when the user input buffer
+ * is directly used as sliding window.
+ */
+
+ Posf *prev;
+ /* Link to older string with same hash index. To limit the size of this
+ * array to 64K, this link is maintained only for the last 32K strings.
+ * An index in this array is thus a window index modulo 32K.
+ */
+
+ Posf *head; /* Heads of the hash chains or NIL. */
+
+ uInt ins_h; /* hash index of string to be inserted */
+ uInt hash_size; /* number of elements in hash table */
+ uInt hash_bits; /* log2(hash_size) */
+ uInt hash_mask; /* hash_size-1 */
+
+ uInt hash_shift;
+ /* Number of bits by which ins_h must be shifted at each input
+ * step. It must be such that after MIN_MATCH steps, the oldest
+ * byte no longer takes part in the hash key, that is:
+ * hash_shift * MIN_MATCH >= hash_bits
+ */
+
+ long block_start;
+ /* Window position at the beginning of the current output block. Gets
+ * negative when the window is moved backwards.
+ */
+
+ uInt match_length; /* length of best match */
+ IPos prev_match; /* previous match */
+ int match_available; /* set if previous match exists */
+ uInt strstart; /* start of string to insert */
+ uInt match_start; /* start of matching string */
+ uInt lookahead; /* number of valid bytes ahead in window */
+
+ uInt prev_length;
+ /* Length of the best match at previous step. Matches not greater than this
+ * are discarded. This is used in the lazy match evaluation.
+ */
+
+ uInt max_chain_length;
+ /* To speed up deflation, hash chains are never searched beyond this
+ * length. A higher limit improves compression ratio but degrades the
+ * speed.
+ */
+
+ uInt max_lazy_match;
+ /* Attempt to find a better match only when the current match is strictly
+ * smaller than this value. This mechanism is used only for compression
+ * levels >= 4.
+ */
+# define max_insert_length max_lazy_match
+ /* Insert new strings in the hash table only if the match length is not
+ * greater than this length. This saves time but degrades compression.
+ * max_insert_length is used only for compression levels <= 3.
+ */
+
+ int level; /* compression level (1..9) */
+ int strategy; /* favor or force Huffman coding*/
+
+ uInt good_match;
+ /* Use a faster search when the previous match is longer than this */
+
+ int nice_match; /* Stop searching when current match exceeds this */
+
+ /* used by trees.c: */
+ /* Didn't use ct_data typedef below to supress compiler warning */
+ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
+ struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+ struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
+
+ struct tree_desc_s l_desc; /* desc. for literal tree */
+ struct tree_desc_s d_desc; /* desc. for distance tree */
+ struct tree_desc_s bl_desc; /* desc. for bit length tree */
+
+ ush bl_count[MAX_BITS+1];
+ /* number of codes at each bit length for an optimal tree */
+
+ int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
+ int heap_len; /* number of elements in the heap */
+ int heap_max; /* element of largest frequency */
+ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+ * The same heap array is used to build all trees.
+ */
+
+ uch depth[2*L_CODES+1];
+ /* Depth of each subtree used as tie breaker for trees of equal frequency
+ */
+
+ uchf *l_buf; /* buffer for literals or lengths */
+
+ uInt lit_bufsize;
+ /* Size of match buffer for literals/lengths. There are 4 reasons for
+ * limiting lit_bufsize to 64K:
+ * - frequencies can be kept in 16 bit counters
+ * - if compression is not successful for the first block, all input
+ * data is still in the window so we can still emit a stored block even
+ * when input comes from standard input. (This can also be done for
+ * all blocks if lit_bufsize is not greater than 32K.)
+ * - if compression is not successful for a file smaller than 64K, we can
+ * even emit a stored file instead of a stored block (saving 5 bytes).
+ * This is applicable only for zip (not gzip or zlib).
+ * - creating new Huffman trees less frequently may not provide fast
+ * adaptation to changes in the input data statistics. (Take for
+ * example a binary file with poorly compressible code followed by
+ * a highly compressible string table.) Smaller buffer sizes give
+ * fast adaptation but have of course the overhead of transmitting
+ * trees more frequently.
+ * - I can't count above 4
+ */
+
+ uInt last_lit; /* running index in l_buf */
+
+ ushf *d_buf;
+ /* Buffer for distances. To simplify the code, d_buf and l_buf have
+ * the same number of elements. To use different lengths, an extra flag
+ * array would be necessary.
+ */
+
+ ulg opt_len; /* bit length of current block with optimal trees */
+ ulg static_len; /* bit length of current block with static trees */
+ uInt matches; /* number of string matches in current block */
+ int last_eob_len; /* bit length of EOB code for last block */
+
+#ifdef DEBUG
+ ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+ ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
+#endif
+
+ ush bi_buf;
+ /* Output buffer. bits are inserted starting at the bottom (least
+ * significant bits).
+ */
+ int bi_valid;
+ /* Number of valid bits in bi_buf. All bits above the last valid bit
+ * are always zero.
+ */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+ /* in trees.c */
+void _tr_init OF((deflate_state *s));
+int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len,
+ int eof));
+void _tr_align OF((deflate_state *s));
+void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len,
+ int eof));
+
+#define d_code(dist) \
+ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+ extern uch _length_code[];
+ extern uch _dist_code[];
+#else
+ extern const uch _length_code[];
+ extern const uch _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+ { uch cc = (c); \
+ s->d_buf[s->last_lit] = 0; \
+ s->l_buf[s->last_lit++] = cc; \
+ s->dyn_ltree[cc].Freq++; \
+ flush = (s->last_lit == s->lit_bufsize-1); \
+ }
+# define _tr_tally_dist(s, distance, length, flush) \
+ { uch len = (length); \
+ ush dist = (distance); \
+ s->d_buf[s->last_lit] = dist; \
+ s->l_buf[s->last_lit++] = len; \
+ dist--; \
+ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+ s->dyn_dtree[d_code(dist)].Freq++; \
+ flush = (s->last_lit == s->lit_bufsize-1); \
+ }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+ flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
--- /dev/null
+/* gzio.c -- IO on .gz files
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Compile this file with -DNO_GZCOMPRESS to avoid the compression code.
+ */
+
+/* @(#) $Id$ */
+
+#include <stdio.h>
+
+#include "zutil.h"
+
+#ifdef NO_DEFLATE /* for compatibility with old definition */
+# define NO_GZCOMPRESS
+#endif
+
+#ifndef NO_DUMMY_DECL
+struct internal_state {int dummy;}; /* for buggy compilers */
+#endif
+
+#ifndef Z_BUFSIZE
+# ifdef MAXSEG_64K
+# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */
+# else
+# define Z_BUFSIZE 16384
+# endif
+#endif
+#ifndef Z_PRINTF_BUFSIZE
+# define Z_PRINTF_BUFSIZE 4096
+#endif
+
+#ifdef __MVS__
+# pragma map (fdopen , "\174\174FDOPEN")
+ FILE *fdopen(int, const char *);
+#endif
+
+#ifndef STDC
+extern voidp malloc OF((uInt size));
+extern void free OF((voidpf ptr));
+#endif
+
+#define ALLOC(size) malloc(size)
+#define TRYFREE(p) {if (p) free(p);}
+
+static int const gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
+
+/* gzip flag byte */
+#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
+#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
+#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
+#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
+#define COMMENT 0x10 /* bit 4 set: file comment present */
+#define RESERVED 0xE0 /* bits 5..7: reserved */
+
+typedef struct gz_stream {
+ z_stream stream;
+ int z_err; /* error code for last stream operation */
+ int z_eof; /* set if end of input file */
+ FILE *file; /* .gz file */
+ Byte *inbuf; /* input buffer */
+ Byte *outbuf; /* output buffer */
+ uLong crc; /* crc32 of uncompressed data */
+ char *msg; /* error message */
+ char *path; /* path name for debugging only */
+ int transparent; /* 1 if input file is not a .gz file */
+ char mode; /* 'w' or 'r' */
+ z_off_t start; /* start of compressed data in file (header skipped) */
+ z_off_t in; /* bytes into deflate or inflate */
+ z_off_t out; /* bytes out of deflate or inflate */
+ int back; /* one character push-back */
+ int last; /* true if push-back is last character */
+} gz_stream;
+
+
+local gzFile gz_open OF((const char *path, const char *mode, int fd));
+local int do_flush OF((gzFile file, int flush));
+local int get_byte OF((gz_stream *s));
+local void check_header OF((gz_stream *s));
+local int destroy OF((gz_stream *s));
+local void putLong OF((FILE *file, uLong x));
+local uLong getLong OF((gz_stream *s));
+
+/* ===========================================================================
+ Opens a gzip (.gz) file for reading or writing. The mode parameter
+ is as in fopen ("rb" or "wb"). The file is given either by file descriptor
+ or path name (if fd == -1).
+ gz_open returns NULL if the file could not be opened or if there was
+ insufficient memory to allocate the (de)compression state; errno
+ can be checked to distinguish the two cases (if errno is zero, the
+ zlib error is Z_MEM_ERROR).
+*/
+local gzFile gz_open (path, mode, fd)
+ const char *path;
+ const char *mode;
+ int fd;
+{
+ int err;
+ int level = Z_DEFAULT_COMPRESSION; /* compression level */
+ int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
+ char *p = (char*)mode;
+ gz_stream *s;
+ char fmode[80]; /* copy of mode, without the compression level */
+ char *m = fmode;
+
+ if (!path || !mode) return Z_NULL;
+
+ s = (gz_stream *)ALLOC(sizeof(gz_stream));
+ if (!s) return Z_NULL;
+
+ s->stream.zalloc = (alloc_func)0;
+ s->stream.zfree = (free_func)0;
+ s->stream.opaque = (voidpf)0;
+ s->stream.next_in = s->inbuf = Z_NULL;
+ s->stream.next_out = s->outbuf = Z_NULL;
+ s->stream.avail_in = s->stream.avail_out = 0;
+ s->file = NULL;
+ s->z_err = Z_OK;
+ s->z_eof = 0;
+ s->in = 0;
+ s->out = 0;
+ s->back = EOF;
+ s->crc = crc32(0L, Z_NULL, 0);
+ s->msg = NULL;
+ s->transparent = 0;
+
+ s->path = (char*)ALLOC(strlen(path)+1);
+ if (s->path == NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ strcpy(s->path, path); /* do this early for debugging */
+
+ s->mode = '\0';
+ do {
+ if (*p == 'r') s->mode = 'r';
+ if (*p == 'w' || *p == 'a') s->mode = 'w';
+ if (*p >= '0' && *p <= '9') {
+ level = *p - '0';
+ } else if (*p == 'f') {
+ strategy = Z_FILTERED;
+ } else if (*p == 'h') {
+ strategy = Z_HUFFMAN_ONLY;
+ } else if (*p == 'R') {
+ strategy = Z_RLE;
+ } else {
+ *m++ = *p; /* copy the mode */
+ }
+ } while (*p++ && m != fmode + sizeof(fmode));
+ if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ err = Z_STREAM_ERROR;
+#else
+ err = deflateInit2(&(s->stream), level,
+ Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
+ /* windowBits is passed < 0 to suppress zlib header */
+
+ s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+#endif
+ if (err != Z_OK || s->outbuf == Z_NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ } else {
+ s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
+
+ err = inflateInit2(&(s->stream), -MAX_WBITS);
+ /* windowBits is passed < 0 to tell that there is no zlib header.
+ * Note that in this case inflate *requires* an extra "dummy" byte
+ * after the compressed stream in order to complete decompression and
+ * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
+ * present after the compressed stream.
+ */
+ if (err != Z_OK || s->inbuf == Z_NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+
+ errno = 0;
+ s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode);
+
+ if (s->file == NULL) {
+ return destroy(s), (gzFile)Z_NULL;
+ }
+ if (s->mode == 'w') {
+ /* Write a very simple .gz header:
+ */
+ fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
+ Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE);
+ s->start = 10L;
+ /* We use 10L instead of ftell(s->file) to because ftell causes an
+ * fflush on some systems. This version of the library doesn't use
+ * start anyway in write mode, so this initialization is not
+ * necessary.
+ */
+ } else {
+ check_header(s); /* skip the .gz header */
+ s->start = ftell(s->file) - s->stream.avail_in;
+ }
+
+ return (gzFile)s;
+}
+
+/* ===========================================================================
+ Opens a gzip (.gz) file for reading or writing.
+*/
+gzFile ZEXPORT gzopen (path, mode)
+ const char *path;
+ const char *mode;
+{
+ return gz_open (path, mode, -1);
+}
+
+/* ===========================================================================
+ Associate a gzFile with the file descriptor fd. fd is not dup'ed here
+ to mimic the behavio(u)r of fdopen.
+*/
+gzFile ZEXPORT gzdopen (fd, mode)
+ int fd;
+ const char *mode;
+{
+ char name[46]; /* allow for up to 128-bit integers */
+
+ if (fd < 0) return (gzFile)Z_NULL;
+ sprintf(name, "<fd:%d>", fd); /* for debugging */
+
+ return gz_open (name, mode, fd);
+}
+
+/* ===========================================================================
+ * Update the compression level and strategy
+ */
+int ZEXPORT gzsetparams (file, level, strategy)
+ gzFile file;
+ int level;
+ int strategy;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ /* Make room to allow flushing */
+ if (s->stream.avail_out == 0) {
+
+ s->stream.next_out = s->outbuf;
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+ s->z_err = Z_ERRNO;
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+
+ return deflateParams (&(s->stream), level, strategy);
+}
+
+/* ===========================================================================
+ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+ for end of file.
+ IN assertion: the stream s has been sucessfully opened for reading.
+*/
+local int get_byte(s)
+ gz_stream *s;
+{
+ if (s->z_eof) return EOF;
+ if (s->stream.avail_in == 0) {
+ errno = 0;
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+ if (s->stream.avail_in == 0) {
+ s->z_eof = 1;
+ if (ferror(s->file)) s->z_err = Z_ERRNO;
+ return EOF;
+ }
+ s->stream.next_in = s->inbuf;
+ }
+ s->stream.avail_in--;
+ return *(s->stream.next_in)++;
+}
+
+/* ===========================================================================
+ Check the gzip header of a gz_stream opened for reading. Set the stream
+ mode to transparent if the gzip magic header is not present; set s->err
+ to Z_DATA_ERROR if the magic header is present but the rest of the header
+ is incorrect.
+ IN assertion: the stream s has already been created sucessfully;
+ s->stream.avail_in is zero for the first time, but may be non-zero
+ for concatenated .gz files.
+*/
+local void check_header(s)
+ gz_stream *s;
+{
+ int method; /* method byte */
+ int flags; /* flags byte */
+ uInt len;
+ int c;
+
+ /* Assure two bytes in the buffer so we can peek ahead -- handle case
+ where first byte of header is at the end of the buffer after the last
+ gzip segment */
+ len = s->stream.avail_in;
+ if (len < 2) {
+ if (len) s->inbuf[0] = s->stream.next_in[0];
+ errno = 0;
+ len = (uInt)fread(s->inbuf + len, 1, Z_BUFSIZE >> len, s->file);
+ if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
+ s->stream.avail_in += len;
+ s->stream.next_in = s->inbuf;
+ if (s->stream.avail_in < 2) {
+ s->transparent = s->stream.avail_in;
+ return;
+ }
+ }
+
+ /* Peek ahead to check the gzip magic header */
+ if (s->stream.next_in[0] != gz_magic[0] ||
+ s->stream.next_in[1] != gz_magic[1]) {
+ s->transparent = 1;
+ return;
+ }
+ s->stream.avail_in -= 2;
+ s->stream.next_in += 2;
+
+ /* Check the rest of the gzip header */
+ method = get_byte(s);
+ flags = get_byte(s);
+ if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
+ s->z_err = Z_DATA_ERROR;
+ return;
+ }
+
+ /* Discard time, xflags and OS code: */
+ for (len = 0; len < 6; len++) (void)get_byte(s);
+
+ if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
+ len = (uInt)get_byte(s);
+ len += ((uInt)get_byte(s))<<8;
+ /* len is garbage if EOF but the loop below will quit anyway */
+ while (len-- != 0 && get_byte(s) != EOF) ;
+ }
+ if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
+ }
+ if ((flags & COMMENT) != 0) { /* skip the .gz file comment */
+ while ((c = get_byte(s)) != 0 && c != EOF) ;
+ }
+ if ((flags & HEAD_CRC) != 0) { /* skip the header crc */
+ for (len = 0; len < 2; len++) (void)get_byte(s);
+ }
+ s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
+}
+
+ /* ===========================================================================
+ * Cleanup then free the given gz_stream. Return a zlib error code.
+ Try freeing in the reverse order of allocations.
+ */
+local int destroy (s)
+ gz_stream *s;
+{
+ int err = Z_OK;
+
+ if (!s) return Z_STREAM_ERROR;
+
+ TRYFREE(s->msg);
+
+ if (s->stream.state != NULL) {
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ err = Z_STREAM_ERROR;
+#else
+ err = deflateEnd(&(s->stream));
+#endif
+ } else if (s->mode == 'r') {
+ err = inflateEnd(&(s->stream));
+ }
+ }
+ if (s->file != NULL && fclose(s->file)) {
+#ifdef ESPIPE
+ if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
+#endif
+ err = Z_ERRNO;
+ }
+ if (s->z_err < 0) err = s->z_err;
+
+ TRYFREE(s->inbuf);
+ TRYFREE(s->outbuf);
+ TRYFREE(s->path);
+ TRYFREE(s);
+ return err;
+}
+
+/* ===========================================================================
+ Reads the given number of uncompressed bytes from the compressed file.
+ gzread returns the number of bytes actually read (0 for end of file).
+*/
+int ZEXPORT gzread (file, buf, len)
+ gzFile file;
+ voidp buf;
+ unsigned len;
+{
+ gz_stream *s = (gz_stream*)file;
+ Bytef *start = (Bytef*)buf; /* starting point for crc computation */
+ Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
+
+ if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
+
+ if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
+ if (s->z_err == Z_STREAM_END) return 0; /* EOF */
+
+ next_out = (Byte*)buf;
+ s->stream.next_out = (Bytef*)buf;
+ s->stream.avail_out = len;
+
+ if (s->stream.avail_out && s->back != EOF) {
+ *next_out++ = s->back;
+ s->stream.next_out++;
+ s->stream.avail_out--;
+ s->back = EOF;
+ s->out++;
+ start++;
+ if (s->last) {
+ s->z_err = Z_STREAM_END;
+ return 1;
+ }
+ }
+
+ while (s->stream.avail_out != 0) {
+
+ if (s->transparent) {
+ /* Copy first the lookahead bytes: */
+ uInt n = s->stream.avail_in;
+ if (n > s->stream.avail_out) n = s->stream.avail_out;
+ if (n > 0) {
+ zmemcpy(s->stream.next_out, s->stream.next_in, n);
+ next_out += n;
+ s->stream.next_out = next_out;
+ s->stream.next_in += n;
+ s->stream.avail_out -= n;
+ s->stream.avail_in -= n;
+ }
+ if (s->stream.avail_out > 0) {
+ s->stream.avail_out -=
+ (uInt)fread(next_out, 1, s->stream.avail_out, s->file);
+ }
+ len -= s->stream.avail_out;
+ s->in += len;
+ s->out += len;
+ if (len == 0) s->z_eof = 1;
+ return (int)len;
+ }
+ if (s->stream.avail_in == 0 && !s->z_eof) {
+
+ errno = 0;
+ s->stream.avail_in = (uInt)fread(s->inbuf, 1, Z_BUFSIZE, s->file);
+ if (s->stream.avail_in == 0) {
+ s->z_eof = 1;
+ if (ferror(s->file)) {
+ s->z_err = Z_ERRNO;
+ break;
+ }
+ }
+ s->stream.next_in = s->inbuf;
+ }
+ s->in += s->stream.avail_in;
+ s->out += s->stream.avail_out;
+ s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
+ s->in -= s->stream.avail_in;
+ s->out -= s->stream.avail_out;
+
+ if (s->z_err == Z_STREAM_END) {
+ /* Check CRC and original size */
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+ start = s->stream.next_out;
+
+ if (getLong(s) != s->crc) {
+ s->z_err = Z_DATA_ERROR;
+ } else {
+ (void)getLong(s);
+ /* The uncompressed length returned by above getlong() may be
+ * different from s->out in case of concatenated .gz files.
+ * Check for such files:
+ */
+ check_header(s);
+ if (s->z_err == Z_OK) {
+ inflateReset(&(s->stream));
+ s->crc = crc32(0L, Z_NULL, 0);
+ }
+ }
+ }
+ if (s->z_err != Z_OK || s->z_eof) break;
+ }
+ s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
+
+ if (len == s->stream.avail_out &&
+ (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
+ return -1;
+ return (int)(len - s->stream.avail_out);
+}
+
+
+/* ===========================================================================
+ Reads one byte from the compressed file. gzgetc returns this byte
+ or -1 in case of end of file or error.
+*/
+int ZEXPORT gzgetc(file)
+ gzFile file;
+{
+ unsigned char c;
+
+ return gzread(file, &c, 1) == 1 ? c : -1;
+}
+
+
+/* ===========================================================================
+ Push one byte back onto the stream.
+*/
+int ZEXPORT gzungetc(c, file)
+ int c;
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r' || c == EOF || s->back != EOF) return EOF;
+ s->back = c;
+ s->out--;
+ s->last = (s->z_err == Z_STREAM_END);
+ if (s->last) s->z_err = Z_OK;
+ s->z_eof = 0;
+ return c;
+}
+
+
+/* ===========================================================================
+ Reads bytes from the compressed file until len-1 characters are
+ read, or a newline character is read and transferred to buf, or an
+ end-of-file condition is encountered. The string is then terminated
+ with a null character.
+ gzgets returns buf, or Z_NULL in case of error.
+
+ The current implementation is not optimized at all.
+*/
+char * ZEXPORT gzgets(file, buf, len)
+ gzFile file;
+ char *buf;
+ int len;
+{
+ char *b = buf;
+ if (buf == Z_NULL || len <= 0) return Z_NULL;
+
+ while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ;
+ *buf = '\0';
+ return b == buf && len > 0 ? Z_NULL : b;
+}
+
+
+#ifndef NO_GZCOMPRESS
+/* ===========================================================================
+ Writes the given number of uncompressed bytes into the compressed file.
+ gzwrite returns the number of bytes actually written (0 in case of error).
+*/
+int ZEXPORT gzwrite (file, buf, len)
+ gzFile file;
+ voidpc buf;
+ unsigned len;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ s->stream.next_in = (Bytef*)buf;
+ s->stream.avail_in = len;
+
+ while (s->stream.avail_in != 0) {
+
+ if (s->stream.avail_out == 0) {
+
+ s->stream.next_out = s->outbuf;
+ if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
+ s->z_err = Z_ERRNO;
+ break;
+ }
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+ s->in += s->stream.avail_in;
+ s->out += s->stream.avail_out;
+ s->z_err = deflate(&(s->stream), Z_NO_FLUSH);
+ s->in -= s->stream.avail_in;
+ s->out -= s->stream.avail_out;
+ if (s->z_err != Z_OK) break;
+ }
+ s->crc = crc32(s->crc, (const Bytef *)buf, len);
+
+ return (int)(len - s->stream.avail_in);
+}
+
+
+/* ===========================================================================
+ Converts, formats, and writes the args to the compressed file under
+ control of the format string, as in fprintf. gzprintf returns the number of
+ uncompressed bytes actually written (0 in case of error).
+*/
+#ifdef STDC
+#include <stdarg.h>
+
+int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
+{
+ char buf[Z_PRINTF_BUFSIZE];
+ va_list va;
+ int len;
+
+ buf[sizeof(buf) - 1] = 0;
+ va_start(va, format);
+#ifdef NO_vsnprintf
+# ifdef HAS_vsprintf_void
+ (void)vsprintf(buf, format, va);
+ va_end(va);
+ for (len = 0; len < sizeof(buf); len++)
+ if (buf[len] == 0) break;
+# else
+ len = vsprintf(buf, format, va);
+ va_end(va);
+# endif
+#else
+# ifdef HAS_vsnprintf_void
+ (void)vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+ len = strlen(buf);
+# else
+ len = vsnprintf(buf, sizeof(buf), format, va);
+ va_end(va);
+# endif
+#endif
+ if (len <= 0 || len >= (int)sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+ return 0;
+ return gzwrite(file, buf, (unsigned)len);
+}
+#else /* not ANSI C */
+
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+ gzFile file;
+ const char *format;
+ int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+ char buf[Z_PRINTF_BUFSIZE];
+ int len;
+
+ buf[sizeof(buf) - 1] = 0;
+#ifdef NO_snprintf
+# ifdef HAS_sprintf_void
+ sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ for (len = 0; len < sizeof(buf); len++)
+ if (buf[len] == 0) break;
+# else
+ len = sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#else
+# ifdef HAS_snprintf_void
+ snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = strlen(buf);
+# else
+ len = snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#endif
+ if (len <= 0 || len >= sizeof(buf) || buf[sizeof(buf) - 1] != 0)
+ return 0;
+ return gzwrite(file, buf, len);
+}
+#endif
+
+/* ===========================================================================
+ Writes c, converted to an unsigned char, into the compressed file.
+ gzputc returns the value that was written, or -1 in case of error.
+*/
+int ZEXPORT gzputc(file, c)
+ gzFile file;
+ int c;
+{
+ unsigned char cc = (unsigned char) c; /* required for big endian systems */
+
+ return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1;
+}
+
+
+/* ===========================================================================
+ Writes the given null-terminated string to the compressed file, excluding
+ the terminating null character.
+ gzputs returns the number of characters written, or -1 in case of error.
+*/
+int ZEXPORT gzputs(file, s)
+ gzFile file;
+ const char *s;
+{
+ return gzwrite(file, (char*)s, (unsigned)strlen(s));
+}
+
+
+/* ===========================================================================
+ Flushes all pending output into the compressed file. The parameter
+ flush is as in the deflate() function.
+*/
+local int do_flush (file, flush)
+ gzFile file;
+ int flush;
+{
+ uInt len;
+ int done = 0;
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
+
+ s->stream.avail_in = 0; /* should be zero already anyway */
+
+ for (;;) {
+ len = Z_BUFSIZE - s->stream.avail_out;
+
+ if (len != 0) {
+ if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) {
+ s->z_err = Z_ERRNO;
+ return Z_ERRNO;
+ }
+ s->stream.next_out = s->outbuf;
+ s->stream.avail_out = Z_BUFSIZE;
+ }
+ if (done) break;
+ s->out += s->stream.avail_out;
+ s->z_err = deflate(&(s->stream), flush);
+ s->out -= s->stream.avail_out;
+
+ /* Ignore the second of two consecutive flushes: */
+ if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK;
+
+ /* deflate has finished flushing only when it hasn't used up
+ * all the available space in the output buffer:
+ */
+ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
+
+ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
+ }
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+
+int ZEXPORT gzflush (file, flush)
+ gzFile file;
+ int flush;
+{
+ gz_stream *s = (gz_stream*)file;
+ int err = do_flush (file, flush);
+
+ if (err) return err;
+ fflush(s->file);
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
+}
+#endif /* NO_GZCOMPRESS */
+
+/* ===========================================================================
+ Sets the starting position for the next gzread or gzwrite on the given
+ compressed file. The offset represents a number of bytes in the
+ gzseek returns the resulting offset location as measured in bytes from
+ the beginning of the uncompressed stream, or -1 in case of error.
+ SEEK_END is not implemented, returns error.
+ In this version of the library, gzseek can be extremely slow.
+*/
+z_off_t ZEXPORT gzseek (file, offset, whence)
+ gzFile file;
+ z_off_t offset;
+ int whence;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || whence == SEEK_END ||
+ s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) {
+ return -1L;
+ }
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ return -1L;
+#else
+ if (whence == SEEK_SET) {
+ offset -= s->in;
+ }
+ if (offset < 0) return -1L;
+
+ /* At this point, offset is the number of zero bytes to write. */
+ if (s->inbuf == Z_NULL) {
+ s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */
+ if (s->inbuf == Z_NULL) return -1L;
+ zmemzero(s->inbuf, Z_BUFSIZE);
+ }
+ while (offset > 0) {
+ uInt size = Z_BUFSIZE;
+ if (offset < Z_BUFSIZE) size = (uInt)offset;
+
+ size = gzwrite(file, s->inbuf, size);
+ if (size == 0) return -1L;
+
+ offset -= size;
+ }
+ return s->in;
+#endif
+ }
+ /* Rest of function is for reading only */
+
+ /* compute absolute position */
+ if (whence == SEEK_CUR) {
+ offset += s->out;
+ }
+ if (offset < 0) return -1L;
+
+ if (s->transparent) {
+ /* map to fseek */
+ s->back = EOF;
+ s->stream.avail_in = 0;
+ s->stream.next_in = s->inbuf;
+ if (fseek(s->file, offset, SEEK_SET) < 0) return -1L;
+
+ s->in = s->out = offset;
+ return offset;
+ }
+
+ /* For a negative seek, rewind and use positive seek */
+ if (offset >= s->out) {
+ offset -= s->out;
+ } else if (gzrewind(file) < 0) {
+ return -1L;
+ }
+ /* offset is now the number of bytes to skip. */
+
+ if (offset != 0 && s->outbuf == Z_NULL) {
+ s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
+ if (s->outbuf == Z_NULL) return -1L;
+ }
+ if (offset && s->back != EOF) {
+ s->back = EOF;
+ s->out++;
+ offset--;
+ if (s->last) s->z_err = Z_STREAM_END;
+ }
+ while (offset > 0) {
+ int size = Z_BUFSIZE;
+ if (offset < Z_BUFSIZE) size = (int)offset;
+
+ size = gzread(file, s->outbuf, (uInt)size);
+ if (size <= 0) return -1L;
+ offset -= size;
+ }
+ return s->out;
+}
+
+/* ===========================================================================
+ Rewinds input file.
+*/
+int ZEXPORT gzrewind (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r') return -1;
+
+ s->z_err = Z_OK;
+ s->z_eof = 0;
+ s->back = EOF;
+ s->stream.avail_in = 0;
+ s->stream.next_in = s->inbuf;
+ s->crc = crc32(0L, Z_NULL, 0);
+ if (!s->transparent) (void)inflateReset(&s->stream);
+ s->in = 0;
+ s->out = 0;
+ return fseek(s->file, s->start, SEEK_SET);
+}
+
+/* ===========================================================================
+ Returns the starting position for the next gzread or gzwrite on the
+ given compressed file. This position represents a number of bytes in the
+ uncompressed data stream.
+*/
+z_off_t ZEXPORT gztell (file)
+ gzFile file;
+{
+ return gzseek(file, 0L, SEEK_CUR);
+}
+
+/* ===========================================================================
+ Returns 1 when EOF has previously been detected reading the given
+ input stream, otherwise zero.
+*/
+int ZEXPORT gzeof (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ /* With concatenated compressed files that can have embedded
+ * crc trailers, z_eof is no longer the only/best indicator of EOF
+ * on a gz_stream. Handle end-of-stream error explicitly here.
+ */
+ if (s == NULL || s->mode != 'r') return 0;
+ if (s->z_eof) return 1;
+ return s->z_err == Z_STREAM_END;
+}
+
+/* ===========================================================================
+ Returns 1 if reading and doing so transparently, otherwise zero.
+*/
+int ZEXPORT gzdirect (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL || s->mode != 'r') return 0;
+ return s->transparent;
+}
+
+/* ===========================================================================
+ Outputs a long in LSB order to the given file
+*/
+local void putLong (file, x)
+ FILE *file;
+ uLong x;
+{
+ int n;
+ for (n = 0; n < 4; n++) {
+ fputc((int)(x & 0xff), file);
+ x >>= 8;
+ }
+}
+
+/* ===========================================================================
+ Reads a long in LSB order from the given gz_stream. Sets z_err in case
+ of error.
+*/
+local uLong getLong (s)
+ gz_stream *s;
+{
+ uLong x = (uLong)get_byte(s);
+ int c;
+
+ x += ((uLong)get_byte(s))<<8;
+ x += ((uLong)get_byte(s))<<16;
+ c = get_byte(s);
+ if (c == EOF) s->z_err = Z_DATA_ERROR;
+ x += ((uLong)c)<<24;
+ return x;
+}
+
+/* ===========================================================================
+ Flushes all pending output if necessary, closes the compressed file
+ and deallocates all the (de)compression state.
+*/
+int ZEXPORT gzclose (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) return Z_STREAM_ERROR;
+
+ if (s->mode == 'w') {
+#ifdef NO_GZCOMPRESS
+ return Z_STREAM_ERROR;
+#else
+ if (do_flush (file, Z_FINISH) != Z_OK)
+ return destroy((gz_stream*)file);
+
+ putLong (s->file, s->crc);
+ putLong (s->file, (uLong)(s->in & 0xffffffff));
+#endif
+ }
+ return destroy((gz_stream*)file);
+}
+
+#ifdef STDC
+# define zstrerror(errnum) strerror(errnum)
+#else
+# define zstrerror(errnum) ""
+#endif
+
+/* ===========================================================================
+ Returns the error message for the last error which occurred on the
+ given compressed file. errnum is set to zlib error number. If an
+ error occurred in the file system and not in the compression library,
+ errnum is set to Z_ERRNO and the application may consult errno
+ to get the exact error code.
+*/
+const char * ZEXPORT gzerror (file, errnum)
+ gzFile file;
+ int *errnum;
+{
+ char *m;
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) {
+ *errnum = Z_STREAM_ERROR;
+ return (const char*)ERR_MSG(Z_STREAM_ERROR);
+ }
+ *errnum = s->z_err;
+ if (*errnum == Z_OK) return (const char*)"";
+
+ m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg);
+
+ if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err);
+
+ TRYFREE(s->msg);
+ s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3);
+ if (s->msg == Z_NULL) return (const char*)ERR_MSG(Z_MEM_ERROR);
+ strcpy(s->msg, s->path);
+ strcat(s->msg, ": ");
+ strcat(s->msg, m);
+ return (const char*)s->msg;
+}
+
+/* ===========================================================================
+ Clear the error and end-of-file flags, and do the same for the real file.
+*/
+void ZEXPORT gzclearerr (file)
+ gzFile file;
+{
+ gz_stream *s = (gz_stream*)file;
+
+ if (s == NULL) return;
+ if (s->z_err != Z_STREAM_END) s->z_err = Z_OK;
+ s->z_eof = 0;
+ clearerr(s->file);
+}
--- /dev/null
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ This code is largely copied from inflate.c. Normally either infback.o or
+ inflate.o would be linked into an application--not both. The interface
+ with inffast.c is retained so that optimized assembler-coded versions of
+ inflate_fast() can be used with either inflate.c or infback.c.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+
+/*
+ strm provides memory allocation functions in zalloc and zfree, or
+ Z_NULL to use the library memory allocation functions.
+
+ windowBits is in the range 8..15, and window is a user-supplied
+ window and output buffer that is 2**windowBits bytes.
+ */
+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
+z_streamp strm;
+int windowBits;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+ struct inflate_state FAR *state;
+
+ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+ stream_size != (int)(sizeof(z_stream)))
+ return Z_VERSION_ERROR;
+ if (strm == Z_NULL || window == Z_NULL ||
+ windowBits < 8 || windowBits > 15)
+ return Z_STREAM_ERROR;
+ strm->msg = Z_NULL; /* in case we return an error */
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+ state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+ sizeof(struct inflate_state));
+ if (state == Z_NULL) return Z_MEM_ERROR;
+ Tracev((stderr, "inflate: allocated\n"));
+ strm->state = (struct internal_state FAR *)state;
+ state->dmax = 32768U;
+ state->wbits = windowBits;
+ state->wsize = 1U << windowBits;
+ state->window = window;
+ state->write = 0;
+ state->whave = 0;
+ return Z_OK;
+}
+
+/*
+ Return state with length and distance decoding tables and index sizes set to
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
+ If BUILDFIXED is defined, then instead this routine builds the tables the
+ first time it's called, and returns those tables the first time and
+ thereafter. This reduces the size of the code by about 2K bytes, in
+ exchange for a little execution time. However, BUILDFIXED should not be
+ used for threaded applications, since the rewriting of the tables and virgin
+ may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+ static int virgin = 1;
+ static code *lenfix, *distfix;
+ static code fixed[544];
+
+ /* build fixed huffman tables if first call (may not be thread safe) */
+ if (virgin) {
+ unsigned sym, bits;
+ static code *next;
+
+ /* literal/length table */
+ sym = 0;
+ while (sym < 144) state->lens[sym++] = 8;
+ while (sym < 256) state->lens[sym++] = 9;
+ while (sym < 280) state->lens[sym++] = 7;
+ while (sym < 288) state->lens[sym++] = 8;
+ next = fixed;
+ lenfix = next;
+ bits = 9;
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+ /* distance table */
+ sym = 0;
+ while (sym < 32) state->lens[sym++] = 5;
+ distfix = next;
+ bits = 5;
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+ /* do this just once */
+ virgin = 0;
+ }
+#else /* !BUILDFIXED */
+# include "inffixed.h"
+#endif /* BUILDFIXED */
+ state->lencode = lenfix;
+ state->lenbits = 9;
+ state->distcode = distfix;
+ state->distbits = 5;
+}
+
+/* Macros for inflateBack(): */
+
+/* Load returned state from inflate_fast() */
+#define LOAD() \
+ do { \
+ put = strm->next_out; \
+ left = strm->avail_out; \
+ next = strm->next_in; \
+ have = strm->avail_in; \
+ hold = state->hold; \
+ bits = state->bits; \
+ } while (0)
+
+/* Set state from registers for inflate_fast() */
+#define RESTORE() \
+ do { \
+ strm->next_out = put; \
+ strm->avail_out = left; \
+ strm->next_in = next; \
+ strm->avail_in = have; \
+ state->hold = hold; \
+ state->bits = bits; \
+ } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+ do { \
+ hold = 0; \
+ bits = 0; \
+ } while (0)
+
+/* Assure that some input is available. If input is requested, but denied,
+ then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+ do { \
+ if (have == 0) { \
+ have = in(in_desc, &next); \
+ if (have == 0) { \
+ next = Z_NULL; \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+ with an error if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ PULL(); \
+ have--; \
+ hold += (unsigned long)(*next++) << bits; \
+ bits += 8; \
+ } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator. If there is
+ not enough available input to do that, then return from inflateBack() with
+ an error. */
+#define NEEDBITS(n) \
+ do { \
+ while (bits < (unsigned)(n)) \
+ PULLBYTE(); \
+ } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+ ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+ do { \
+ hold >>= (n); \
+ bits -= (unsigned)(n); \
+ } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+ do { \
+ hold >>= bits & 7; \
+ bits -= bits & 7; \
+ } while (0)
+
+/* Assure that some output space is available, by writing out the window
+ if it's full. If the write fails, return from inflateBack() with a
+ Z_BUF_ERROR. */
+#define ROOM() \
+ do { \
+ if (left == 0) { \
+ put = state->window; \
+ left = state->wsize; \
+ state->whave = left; \
+ if (out(out_desc, put, left)) { \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/*
+ strm provides the memory allocation functions and window buffer on input,
+ and provides information on the unused input on return. For Z_DATA_ERROR
+ returns, strm will also provide an error message.
+
+ in() and out() are the call-back input and output functions. When
+ inflateBack() needs more input, it calls in(). When inflateBack() has
+ filled the window with output, or when it completes with data in the
+ window, it calls out() to write out the data. The application must not
+ change the provided input until in() is called again or inflateBack()
+ returns. The application must not change the window/output buffer until
+ inflateBack() returns.
+
+ in() and out() are called with a descriptor parameter provided in the
+ inflateBack() call. This parameter can be a structure that provides the
+ information required to do the read or write, as well as accumulated
+ information on the input and output such as totals and check values.
+
+ in() should return zero on failure. out() should return non-zero on
+ failure. If either in() or out() fails, than inflateBack() returns a
+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
+ was in() or out() that caused in the error. Otherwise, inflateBack()
+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+ error, or Z_MEM_ERROR if it could not allocate memory for the state.
+ inflateBack() can also return Z_STREAM_ERROR if the input parameters
+ are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
+z_streamp strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ unsigned copy; /* number of stored or match bytes to copy */
+ unsigned char FAR *from; /* where to copy match bytes from */
+ code this; /* current decoding table entry */
+ code last; /* parent table entry */
+ unsigned len; /* length to copy for repeats, bits to drop */
+ int ret; /* return code */
+ static const unsigned short order[19] = /* permutation of code lengths */
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+ /* Check that the strm exists and that the state was initialized */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* Reset the state */
+ strm->msg = Z_NULL;
+ state->mode = TYPE;
+ state->last = 0;
+ state->whave = 0;
+ next = strm->next_in;
+ have = next != Z_NULL ? strm->avail_in : 0;
+ hold = 0;
+ bits = 0;
+ put = state->window;
+ left = state->wsize;
+
+ /* Inflate until end of block marked as last */
+ for (;;)
+ switch (state->mode) {
+ case TYPE:
+ /* determine and dispatch block type */
+ if (state->last) {
+ BYTEBITS();
+ state->mode = DONE;
+ break;
+ }
+ NEEDBITS(3);
+ state->last = BITS(1);
+ DROPBITS(1);
+ switch (BITS(2)) {
+ case 0: /* stored block */
+ Tracev((stderr, "inflate: stored block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = STORED;
+ break;
+ case 1: /* fixed block */
+ fixedtables(state);
+ Tracev((stderr, "inflate: fixed codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = LEN; /* decode codes */
+ break;
+ case 2: /* dynamic block */
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = TABLE;
+ break;
+ case 3:
+ strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ DROPBITS(2);
+ break;
+
+ case STORED:
+ /* get and verify stored block length */
+ BYTEBITS(); /* go to byte boundary */
+ NEEDBITS(32);
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned)hold & 0xffff;
+ Tracev((stderr, "inflate: stored length %u\n",
+ state->length));
+ INITBITS();
+
+ /* copy stored block from input to output */
+ while (state->length != 0) {
+ copy = state->length;
+ PULL();
+ ROOM();
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ state->mode = TYPE;
+ break;
+
+ case TABLE:
+ /* get dynamic table entries descriptor */
+ NEEDBITS(14);
+ state->nlen = BITS(5) + 257;
+ DROPBITS(5);
+ state->ndist = BITS(5) + 1;
+ DROPBITS(5);
+ state->ncode = BITS(4) + 4;
+ DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+ if (state->nlen > 286 || state->ndist > 30) {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ Tracev((stderr, "inflate: table sizes ok\n"));
+
+ /* get code length code lengths (not a typo) */
+ state->have = 0;
+ while (state->have < state->ncode) {
+ NEEDBITS(3);
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
+ DROPBITS(3);
+ }
+ while (state->have < 19)
+ state->lens[order[state->have++]] = 0;
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 7;
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: code lengths ok\n"));
+
+ /* get length and distance code code lengths */
+ state->have = 0;
+ while (state->have < state->nlen + state->ndist) {
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.val < 16) {
+ NEEDBITS(this.bits);
+ DROPBITS(this.bits);
+ state->lens[state->have++] = this.val;
+ }
+ else {
+ if (this.val == 16) {
+ NEEDBITS(this.bits + 2);
+ DROPBITS(this.bits);
+ if (state->have == 0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = (unsigned)(state->lens[state->have - 1]);
+ copy = 3 + BITS(2);
+ DROPBITS(2);
+ }
+ else if (this.val == 17) {
+ NEEDBITS(this.bits + 3);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 3 + BITS(3);
+ DROPBITS(3);
+ }
+ else {
+ NEEDBITS(this.bits + 7);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 11 + BITS(7);
+ DROPBITS(7);
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (copy--)
+ state->lens[state->have++] = (unsigned short)len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (state->mode == BAD) break;
+
+ /* build code tables */
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 9;
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid literal/lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->distcode = (code const FAR *)(state->next);
+ state->distbits = 6;
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+ &(state->next), &(state->distbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid distances set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: codes ok\n"));
+ state->mode = LEN;
+
+ case LEN:
+ /* use inflate_fast() if we have enough input and output */
+ if (have >= 6 && left >= 258) {
+ RESTORE();
+ if (state->whave < state->wsize)
+ state->whave = state->wsize - left;
+ inflate_fast(strm, state->wsize);
+ LOAD();
+ break;
+ }
+
+ /* get a literal, length, or end-of-block code */
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.op && (this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->lencode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ state->length = (unsigned)this.val;
+
+ /* process literal */
+ if (this.op == 0) {
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ ROOM();
+ *put++ = (unsigned char)(state->length);
+ left--;
+ state->mode = LEN;
+ break;
+ }
+
+ /* process end of block */
+ if (this.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+
+ /* invalid code */
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+
+ /* length code -- get extra bits, if any */
+ state->extra = (unsigned)(this.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->length += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ Tracevv((stderr, "inflate: length %u\n", state->length));
+
+ /* get distance code */
+ for (;;) {
+ this = state->distcode[BITS(state->distbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if ((this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->distcode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned)this.val;
+
+ /* get distance extra bits, if any */
+ state->extra = (unsigned)(this.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->offset += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ if (state->offset > state->wsize - (state->whave < state->wsize ?
+ left : 0)) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
+
+ /* copy match from window to output */
+ do {
+ ROOM();
+ copy = state->wsize - state->offset;
+ if (copy < left) {
+ from = put + copy;
+ copy = left - copy;
+ }
+ else {
+ from = put - state->offset;
+ copy = left;
+ }
+ if (copy > state->length) copy = state->length;
+ state->length -= copy;
+ left -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ } while (state->length != 0);
+ break;
+
+ case DONE:
+ /* inflate stream terminated properly -- write leftover output */
+ ret = Z_STREAM_END;
+ if (left < state->wsize) {
+ if (out(out_desc, state->window, state->wsize - left))
+ ret = Z_BUF_ERROR;
+ }
+ goto inf_leave;
+
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+
+ default: /* can't happen, but makes compilers happy */
+ ret = Z_STREAM_ERROR;
+ goto inf_leave;
+ }
+
+ /* Return unused input */
+ inf_leave:
+ strm->next_in = next;
+ strm->avail_in = have;
+ return ret;
+}
+
+int ZEXPORT inflateBackEnd(strm)
+z_streamp strm;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
--- /dev/null
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifndef ASMINF
+
+/* Allow machine dependent optimization for post-increment or pre-increment.
+ Based on testing to date,
+ Pre-increment preferred for:
+ - PowerPC G3 (Adler)
+ - MIPS R5000 (Randers-Pehrson)
+ Post-increment preferred for:
+ - none
+ No measurable difference:
+ - Pentium III (Anderson)
+ - M68060 (Nikl)
+ */
+#ifdef POSTINC
+# define OFF 0
+# define PUP(a) *(a)++
+#else
+# define OFF 1
+# define PUP(a) *++(a)
+#endif
+
+/*
+ Decode literal, length, and distance codes and write out the resulting
+ literal and match bytes until either not enough input or output is
+ available, an end-of-block is encountered, or a data error is encountered.
+ When large enough input and output buffers are supplied to inflate(), for
+ example, a 16K input buffer and a 64K output buffer, more than 95% of the
+ inflate execution time is spent in this routine.
+
+ Entry assumptions:
+
+ state->mode == LEN
+ strm->avail_in >= 6
+ strm->avail_out >= 258
+ start >= strm->avail_out
+ state->bits < 8
+
+ On return, state->mode is one of:
+
+ LEN -- ran out of enough output space or enough available input
+ TYPE -- reached end of block code, inflate() to interpret next block
+ BAD -- error in block data
+
+ Notes:
+
+ - The maximum input bits used by a length/distance pair is 15 bits for the
+ length code, 5 bits for the length extra, 15 bits for the distance code,
+ and 13 bits for the distance extra. This totals 48 bits, or six bytes.
+ Therefore if strm->avail_in >= 6, then there is enough input to avoid
+ checking for available input while decoding.
+
+ - The maximum bytes that a single length/distance pair can output is 258
+ bytes, which is the maximum length that can be coded. inflate_fast()
+ requires strm->avail_out >= 258 for each loop to avoid checking for
+ output space.
+ */
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start; /* inflate()'s starting value for strm->avail_out */
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *in; /* local strm->next_in */
+ unsigned char FAR *last; /* while in < last, enough input available */
+ unsigned char FAR *out; /* local strm->next_out */
+ unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
+ unsigned char FAR *end; /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+ unsigned dmax; /* maximum distance from zlib header */
+#endif
+ unsigned wsize; /* window size or zero if not using window */
+ unsigned whave; /* valid bytes in the window */
+ unsigned write; /* window write index */
+ unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
+ unsigned long hold; /* local strm->hold */
+ unsigned bits; /* local strm->bits */
+ code const FAR *lcode; /* local strm->lencode */
+ code const FAR *dcode; /* local strm->distcode */
+ unsigned lmask; /* mask for first level of length codes */
+ unsigned dmask; /* mask for first level of distance codes */
+ code this; /* retrieved table entry */
+ unsigned op; /* code bits, operation, extra bits, or */
+ /* window position, window bytes to copy */
+ unsigned len; /* match length, unused bytes */
+ unsigned dist; /* match distance */
+ unsigned char FAR *from; /* where to copy match from */
+
+ /* copy state to local variables */
+ state = (struct inflate_state FAR *)strm->state;
+ in = strm->next_in - OFF;
+ last = in + (strm->avail_in - 5);
+ out = strm->next_out - OFF;
+ beg = out - (start - strm->avail_out);
+ end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+ dmax = state->dmax;
+#endif
+ wsize = state->wsize;
+ whave = state->whave;
+ write = state->write;
+ window = state->window;
+ hold = state->hold;
+ bits = state->bits;
+ lcode = state->lencode;
+ dcode = state->distcode;
+ lmask = (1U << state->lenbits) - 1;
+ dmask = (1U << state->distbits) - 1;
+
+ /* decode literals and length/distances until end-of-block or not enough
+ input data or output space */
+ do {
+ if (bits < 15) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ this = lcode[hold & lmask];
+ dolen:
+ op = (unsigned)(this.bits);
+ hold >>= op;
+ bits -= op;
+ op = (unsigned)(this.op);
+ if (op == 0) { /* literal */
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ PUP(out) = (unsigned char)(this.val);
+ }
+ else if (op & 16) { /* length base */
+ len = (unsigned)(this.val);
+ op &= 15; /* number of extra bits */
+ if (op) {
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ len += (unsigned)hold & ((1U << op) - 1);
+ hold >>= op;
+ bits -= op;
+ }
+ Tracevv((stderr, "inflate: length %u\n", len));
+ if (bits < 15) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ this = dcode[hold & dmask];
+ dodist:
+ op = (unsigned)(this.bits);
+ hold >>= op;
+ bits -= op;
+ op = (unsigned)(this.op);
+ if (op & 16) { /* distance base */
+ dist = (unsigned)(this.val);
+ op &= 15; /* number of extra bits */
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ if (bits < op) {
+ hold += (unsigned long)(PUP(in)) << bits;
+ bits += 8;
+ }
+ }
+ dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+ if (dist > dmax) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ hold >>= op;
+ bits -= op;
+ Tracevv((stderr, "inflate: distance %u\n", dist));
+ op = (unsigned)(out - beg); /* max distance in output */
+ if (dist > op) { /* see if copy from window */
+ op = dist - op; /* distance back in window */
+ if (op > whave) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ from = window - OFF;
+ if (write == 0) { /* very common case */
+ from += wsize - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ else if (write < op) { /* wrap around window */
+ from += wsize + write - op;
+ op -= write;
+ if (op < len) { /* some from end of window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = window - OFF;
+ if (write < len) { /* some from start of window */
+ op = write;
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ }
+ else { /* contiguous in window */
+ from += write - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ do {
+ PUP(out) = PUP(from);
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ while (len > 2) {
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ len -= 3;
+ }
+ if (len) {
+ PUP(out) = PUP(from);
+ if (len > 1)
+ PUP(out) = PUP(from);
+ }
+ }
+ else {
+ from = out - dist; /* copy direct from output */
+ do { /* minimum length is three */
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ PUP(out) = PUP(from);
+ len -= 3;
+ } while (len > 2);
+ if (len) {
+ PUP(out) = PUP(from);
+ if (len > 1)
+ PUP(out) = PUP(from);
+ }
+ }
+ }
+ else if ((op & 64) == 0) { /* 2nd level distance code */
+ this = dcode[this.val + (hold & ((1U << op) - 1))];
+ goto dodist;
+ }
+ else {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ }
+ else if ((op & 64) == 0) { /* 2nd level length code */
+ this = lcode[this.val + (hold & ((1U << op) - 1))];
+ goto dolen;
+ }
+ else if (op & 32) { /* end-of-block */
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+ else {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ } while (in < last && out < end);
+
+ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+ len = bits >> 3;
+ in -= len;
+ bits -= len << 3;
+ hold &= (1U << bits) - 1;
+
+ /* update state and return */
+ strm->next_in = in + OFF;
+ strm->next_out = out + OFF;
+ strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+ strm->avail_out = (unsigned)(out < end ?
+ 257 + (end - out) : 257 - (out - end));
+ state->hold = hold;
+ state->bits = bits;
+ return;
+}
+
+/*
+ inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+ - Using bit fields for code structure
+ - Different op definition to avoid & for extra bits (do & for table bits)
+ - Three separate decoding do-loops for direct, window, and write == 0
+ - Special case for distance > 1 copies to do overlapped load and store copy
+ - Explicit branch predictions (based on measured branch probabilities)
+ - Deferring match copy and interspersed it with decoding subsequent codes
+ - Swapping literal/length else
+ - Swapping window/direct else
+ - Larger unrolled copy loops (three is about right)
+ - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !ASMINF */
--- /dev/null
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+void inflate_fast OF((z_streamp strm, unsigned start));
--- /dev/null
+ /* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by makefixed().
+ */
+
+ /* WARNING: this file should *not* be used by applications. It
+ is part of the implementation of the compression library and
+ is subject to change. Applications should only use zlib.h.
+ */
+
+ static const code lenfix[512] = {
+ {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+ {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+ {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+ {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+ {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+ {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+ {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+ {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+ {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+ {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+ {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+ {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+ {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+ {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+ {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+ {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+ {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+ {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+ {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+ {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+ {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+ {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+ {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+ {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+ {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+ {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+ {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+ {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+ {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+ {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+ {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+ {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+ {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+ {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+ {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+ {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+ {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+ {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+ {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+ {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+ {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+ {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+ {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+ {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+ {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+ {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+ {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+ {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+ {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+ {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+ {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+ {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+ {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+ {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+ {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+ {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+ {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+ {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+ {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+ {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+ {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+ {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+ {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+ {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+ {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+ {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+ {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+ {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+ {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+ {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+ {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+ {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+ {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+ {0,9,255}
+ };
+
+ static const code distfix[32] = {
+ {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+ {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+ {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+ {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+ {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+ {22,5,193},{64,5,0}
+ };
--- /dev/null
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0 24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ * creation of window when not needed, minimize use of window when it is
+ * needed, make inffast.c even faster, implement gzip decoding, and to
+ * improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1 25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2 4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ * to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3 22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ * buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4 1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common write == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ * source file infback.c to provide a call-back interface to inflate for
+ * programs like gzip and unzip -- uses window as output buffer to avoid
+ * window copying
+ *
+ * 1.2.beta5 1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ * input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6 4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ * make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7 27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0 9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ * for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ * and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+# ifndef BUILDFIXED
+# define BUILDFIXED
+# endif
+#endif
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, unsigned out));
+#ifdef BUILDFIXED
+ void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
+ unsigned len));
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ strm->total_in = strm->total_out = state->total = 0;
+ strm->msg = Z_NULL;
+ strm->adler = 1; /* to support ill-conceived Java test suite */
+ state->mode = HEAD;
+ state->last = 0;
+ state->havedict = 0;
+ state->dmax = 32768U;
+ state->head = Z_NULL;
+ state->wsize = 0;
+ state->whave = 0;
+ state->write = 0;
+ state->hold = 0;
+ state->bits = 0;
+ state->lencode = state->distcode = state->next = state->codes;
+ Tracev((stderr, "inflate: reset\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+ value &= (1L << bits) - 1;
+ state->hold += value << state->bits;
+ state->bits += bits;
+ return Z_OK;
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+ struct inflate_state FAR *state;
+
+ if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+ stream_size != (int)(sizeof(z_stream)))
+ return Z_VERSION_ERROR;
+ if (strm == Z_NULL) return Z_STREAM_ERROR;
+ strm->msg = Z_NULL; /* in case we return an error */
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+ state = (struct inflate_state FAR *)
+ ZALLOC(strm, 1, sizeof(struct inflate_state));
+ if (state == Z_NULL) return Z_MEM_ERROR;
+ Tracev((stderr, "inflate: allocated\n"));
+ strm->state = (struct internal_state FAR *)state;
+ if (windowBits < 0) {
+ state->wrap = 0;
+ windowBits = -windowBits;
+ }
+ else {
+ state->wrap = (windowBits >> 4) + 1;
+#ifdef GUNZIP
+ if (windowBits < 48) windowBits &= 15;
+#endif
+ }
+ if (windowBits < 8 || windowBits > 15) {
+ ZFREE(strm, state);
+ strm->state = Z_NULL;
+ return Z_STREAM_ERROR;
+ }
+ state->wbits = (unsigned)windowBits;
+ state->window = Z_NULL;
+ return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+ return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+/*
+ Return state with length and distance decoding tables and index sizes set to
+ fixed code decoding. Normally this returns fixed tables from inffixed.h.
+ If BUILDFIXED is defined, then instead this routine builds the tables the
+ first time it's called, and returns those tables the first time and
+ thereafter. This reduces the size of the code by about 2K bytes, in
+ exchange for a little execution time. However, BUILDFIXED should not be
+ used for threaded applications, since the rewriting of the tables and virgin
+ may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+ static int virgin = 1;
+ static code *lenfix, *distfix;
+ static code fixed[544];
+
+ /* build fixed huffman tables if first call (may not be thread safe) */
+ if (virgin) {
+ unsigned sym, bits;
+ static code *next;
+
+ /* literal/length table */
+ sym = 0;
+ while (sym < 144) state->lens[sym++] = 8;
+ while (sym < 256) state->lens[sym++] = 9;
+ while (sym < 280) state->lens[sym++] = 7;
+ while (sym < 288) state->lens[sym++] = 8;
+ next = fixed;
+ lenfix = next;
+ bits = 9;
+ inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+ /* distance table */
+ sym = 0;
+ while (sym < 32) state->lens[sym++] = 5;
+ distfix = next;
+ bits = 5;
+ inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+ /* do this just once */
+ virgin = 0;
+ }
+#else /* !BUILDFIXED */
+# include "inffixed.h"
+#endif /* BUILDFIXED */
+ state->lencode = lenfix;
+ state->lenbits = 9;
+ state->distcode = distfix;
+ state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+ Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also
+ defines BUILDFIXED, so the tables are built on the fly. makefixed() writes
+ those tables to stdout, which would be piped to inffixed.h. A small program
+ can simply call makefixed to do this:
+
+ void makefixed(void);
+
+ int main(void)
+ {
+ makefixed();
+ return 0;
+ }
+
+ Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+ a.out > inffixed.h
+ */
+void makefixed()
+{
+ unsigned low, size;
+ struct inflate_state state;
+
+ fixedtables(&state);
+ puts(" /* inffixed.h -- table for decoding fixed codes");
+ puts(" * Generated automatically by makefixed().");
+ puts(" */");
+ puts("");
+ puts(" /* WARNING: this file should *not* be used by applications.");
+ puts(" It is part of the implementation of this library and is");
+ puts(" subject to change. Applications should only use zlib.h.");
+ puts(" */");
+ puts("");
+ size = 1U << 9;
+ printf(" static const code lenfix[%u] = {", size);
+ low = 0;
+ for (;;) {
+ if ((low % 7) == 0) printf("\n ");
+ printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
+ state.lencode[low].val);
+ if (++low == size) break;
+ putchar(',');
+ }
+ puts("\n };");
+ size = 1U << 5;
+ printf("\n static const code distfix[%u] = {", size);
+ low = 0;
+ for (;;) {
+ if ((low % 6) == 0) printf("\n ");
+ printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+ state.distcode[low].val);
+ if (++low == size) break;
+ putchar(',');
+ }
+ puts("\n };");
+}
+#endif /* MAKEFIXED */
+
+/*
+ Update the window with the last wsize (normally 32K) bytes written before
+ returning. If window does not exist yet, create it. This is only called
+ when a window is already in use, or when output has been written during this
+ inflate call, but the end of the deflate stream has not been reached yet.
+ It is also called to create a window for dictionary data when a dictionary
+ is loaded.
+
+ Providing output buffers larger than 32K to inflate() should provide a speed
+ advantage, since only the last 32K of output is copied to the sliding window
+ upon return from inflate(), and since all distances after the first 32K of
+ output will fall in the output data, making match copies simpler and faster.
+ The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, out)
+z_streamp strm;
+unsigned out;
+{
+ struct inflate_state FAR *state;
+ unsigned copy, dist;
+
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* if it hasn't been done already, allocate space for the window */
+ if (state->window == Z_NULL) {
+ state->window = (unsigned char FAR *)
+ ZALLOC(strm, 1U << state->wbits,
+ sizeof(unsigned char));
+ if (state->window == Z_NULL) return 1;
+ }
+
+ /* if window not in use yet, initialize */
+ if (state->wsize == 0) {
+ state->wsize = 1U << state->wbits;
+ state->write = 0;
+ state->whave = 0;
+ }
+
+ /* copy state->wsize or less output bytes into the circular window */
+ copy = out - strm->avail_out;
+ if (copy >= state->wsize) {
+ zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+ state->write = 0;
+ state->whave = state->wsize;
+ }
+ else {
+ dist = state->wsize - state->write;
+ if (dist > copy) dist = copy;
+ zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+ copy -= dist;
+ if (copy) {
+ zmemcpy(state->window, strm->next_out - copy, copy);
+ state->write = copy;
+ state->whave = state->wsize;
+ }
+ else {
+ state->write += dist;
+ if (state->write == state->wsize) state->write = 0;
+ if (state->whave < state->wsize) state->whave += dist;
+ }
+ }
+ return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+# define UPDATE(check, buf, len) \
+ (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+# define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+# define CRC2(check, word) \
+ do { \
+ hbuf[0] = (unsigned char)(word); \
+ hbuf[1] = (unsigned char)((word) >> 8); \
+ check = crc32(check, hbuf, 2); \
+ } while (0)
+
+# define CRC4(check, word) \
+ do { \
+ hbuf[0] = (unsigned char)(word); \
+ hbuf[1] = (unsigned char)((word) >> 8); \
+ hbuf[2] = (unsigned char)((word) >> 16); \
+ hbuf[3] = (unsigned char)((word) >> 24); \
+ check = crc32(check, hbuf, 4); \
+ } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+ do { \
+ put = strm->next_out; \
+ left = strm->avail_out; \
+ next = strm->next_in; \
+ have = strm->avail_in; \
+ hold = state->hold; \
+ bits = state->bits; \
+ } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+ do { \
+ strm->next_out = put; \
+ strm->avail_out = left; \
+ strm->next_in = next; \
+ strm->avail_in = have; \
+ state->hold = hold; \
+ state->bits = bits; \
+ } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+ do { \
+ hold = 0; \
+ bits = 0; \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+ if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ if (have == 0) goto inf_leave; \
+ have--; \
+ hold += (unsigned long)(*next++) << bits; \
+ bits += 8; \
+ } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator. If there is
+ not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+ do { \
+ while (bits < (unsigned)(n)) \
+ PULLBYTE(); \
+ } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+ ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+ do { \
+ hold >>= (n); \
+ bits -= (unsigned)(n); \
+ } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+ do { \
+ hold >>= bits & 7; \
+ bits -= bits & 7; \
+ } while (0)
+
+/* Reverse the bytes in a 32-bit value */
+#define REVERSE(q) \
+ ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+ (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+/*
+ inflate() uses a state machine to process as much input data and generate as
+ much output data as possible before returning. The state machine is
+ structured roughly as follows:
+
+ for (;;) switch (state) {
+ ...
+ case STATEn:
+ if (not enough input data or output space to make progress)
+ return;
+ ... make progress ...
+ state = STATEm;
+ break;
+ ...
+ }
+
+ so when inflate() is called again, the same case is attempted again, and
+ if the appropriate resources are provided, the machine proceeds to the
+ next state. The NEEDBITS() macro is usually the way the state evaluates
+ whether it can proceed or should return. NEEDBITS() does the return if
+ the requested bits are not available. The typical use of the BITS macros
+ is:
+
+ NEEDBITS(n);
+ ... do something with BITS(n) ...
+ DROPBITS(n);
+
+ where NEEDBITS(n) either returns from inflate() if there isn't enough
+ input left to load n bits into the accumulator, or it continues. BITS(n)
+ gives the low n bits in the accumulator. When done, DROPBITS(n) drops
+ the low n bits off the accumulator. INITBITS() clears the accumulator
+ and sets the number of available bits to zero. BYTEBITS() discards just
+ enough bits to put the accumulator on a byte boundary. After BYTEBITS()
+ and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+ NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+ if there is no input available. The decoding of variable length codes uses
+ PULLBYTE() directly in order to pull just enough bytes to decode the next
+ code, and no more.
+
+ Some states loop until they get enough input, making sure that enough
+ state information is maintained to continue the loop where it left off
+ if NEEDBITS() returns in the loop. For example, want, need, and keep
+ would all have to actually be part of the saved state in case NEEDBITS()
+ returns:
+
+ case STATEw:
+ while (want < need) {
+ NEEDBITS(n);
+ keep[want++] = BITS(n);
+ DROPBITS(n);
+ }
+ state = STATEx;
+ case STATEx:
+
+ As shown above, if the next state is also the next case, then the break
+ is omitted.
+
+ A state may also return if there is not enough output space available to
+ complete that state. Those states are copying stored data, writing a
+ literal byte, and copying a matching string.
+
+ When returning, a "goto inf_leave" is used to update the total counters,
+ update the check value, and determine whether any progress has been made
+ during that inflate() call in order to return the proper return code.
+ Progress is defined as a change in either strm->avail_in or strm->avail_out.
+ When there is a window, goto inf_leave will update the window with the last
+ output written. If a goto inf_leave occurs in the middle of decompression
+ and there is no window currently, goto inf_leave will create one and copy
+ output to the window for the next call of inflate().
+
+ In this implementation, the flush parameter of inflate() only affects the
+ return code (per zlib.h). inflate() always writes as much as possible to
+ strm->next_out, given the space available and the provided input--the effect
+ documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
+ the allocation of and copying into a sliding window until necessary, which
+ provides the effect documented in zlib.h for Z_FINISH when the entire input
+ stream available. So the only thing the flush parameter actually does is:
+ when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
+ will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+ struct inflate_state FAR *state;
+ unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ unsigned in, out; /* save starting available input and output */
+ unsigned copy; /* number of stored or match bytes to copy */
+ unsigned char FAR *from; /* where to copy match bytes from */
+ code this; /* current decoding table entry */
+ code last; /* parent table entry */
+ unsigned len; /* length to copy for repeats, bits to drop */
+ int ret; /* return code */
+#ifdef GUNZIP
+ unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
+#endif
+ static const unsigned short order[19] = /* permutation of code lengths */
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+ (strm->next_in == Z_NULL && strm->avail_in != 0))
+ return Z_STREAM_ERROR;
+
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
+ LOAD();
+ in = have;
+ out = left;
+ ret = Z_OK;
+ for (;;)
+ switch (state->mode) {
+ case HEAD:
+ if (state->wrap == 0) {
+ state->mode = TYPEDO;
+ break;
+ }
+ NEEDBITS(16);
+#ifdef GUNZIP
+ if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
+ state->check = crc32(0L, Z_NULL, 0);
+ CRC2(state->check, hold);
+ INITBITS();
+ state->mode = FLAGS;
+ break;
+ }
+ state->flags = 0; /* expect zlib header */
+ if (state->head != Z_NULL)
+ state->head->done = -1;
+ if (!(state->wrap & 1) || /* check if zlib header allowed */
+#else
+ if (
+#endif
+ ((BITS(8) << 8) + (hold >> 8)) % 31) {
+ strm->msg = (char *)"incorrect header check";
+ state->mode = BAD;
+ break;
+ }
+ if (BITS(4) != Z_DEFLATED) {
+ strm->msg = (char *)"unknown compression method";
+ state->mode = BAD;
+ break;
+ }
+ DROPBITS(4);
+ len = BITS(4) + 8;
+ if (len > state->wbits) {
+ strm->msg = (char *)"invalid window size";
+ state->mode = BAD;
+ break;
+ }
+ state->dmax = 1U << len;
+ Tracev((stderr, "inflate: zlib header ok\n"));
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
+ state->mode = hold & 0x200 ? DICTID : TYPE;
+ INITBITS();
+ break;
+#ifdef GUNZIP
+ case FLAGS:
+ NEEDBITS(16);
+ state->flags = (int)(hold);
+ if ((state->flags & 0xff) != Z_DEFLATED) {
+ strm->msg = (char *)"unknown compression method";
+ state->mode = BAD;
+ break;
+ }
+ if (state->flags & 0xe000) {
+ strm->msg = (char *)"unknown header flags set";
+ state->mode = BAD;
+ break;
+ }
+ if (state->head != Z_NULL)
+ state->head->text = (int)((hold >> 8) & 1);
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ state->mode = TIME;
+ case TIME:
+ NEEDBITS(32);
+ if (state->head != Z_NULL)
+ state->head->time = hold;
+ if (state->flags & 0x0200) CRC4(state->check, hold);
+ INITBITS();
+ state->mode = OS;
+ case OS:
+ NEEDBITS(16);
+ if (state->head != Z_NULL) {
+ state->head->xflags = (int)(hold & 0xff);
+ state->head->os = (int)(hold >> 8);
+ }
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ state->mode = EXLEN;
+ case EXLEN:
+ if (state->flags & 0x0400) {
+ NEEDBITS(16);
+ state->length = (unsigned)(hold);
+ if (state->head != Z_NULL)
+ state->head->extra_len = (unsigned)hold;
+ if (state->flags & 0x0200) CRC2(state->check, hold);
+ INITBITS();
+ }
+ else if (state->head != Z_NULL)
+ state->head->extra = Z_NULL;
+ state->mode = EXTRA;
+ case EXTRA:
+ if (state->flags & 0x0400) {
+ copy = state->length;
+ if (copy > have) copy = have;
+ if (copy) {
+ if (state->head != Z_NULL &&
+ state->head->extra != Z_NULL) {
+ len = state->head->extra_len - state->length;
+ zmemcpy(state->head->extra + len, next,
+ len + copy > state->head->extra_max ?
+ state->head->extra_max - len : copy);
+ }
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ state->length -= copy;
+ }
+ if (state->length) goto inf_leave;
+ }
+ state->length = 0;
+ state->mode = NAME;
+ case NAME:
+ if (state->flags & 0x0800) {
+ if (have == 0) goto inf_leave;
+ copy = 0;
+ do {
+ len = (unsigned)(next[copy++]);
+ if (state->head != Z_NULL &&
+ state->head->name != Z_NULL &&
+ state->length < state->head->name_max)
+ state->head->name[state->length++] = len;
+ } while (len && copy < have);
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else if (state->head != Z_NULL)
+ state->head->name = Z_NULL;
+ state->length = 0;
+ state->mode = COMMENT;
+ case COMMENT:
+ if (state->flags & 0x1000) {
+ if (have == 0) goto inf_leave;
+ copy = 0;
+ do {
+ len = (unsigned)(next[copy++]);
+ if (state->head != Z_NULL &&
+ state->head->comment != Z_NULL &&
+ state->length < state->head->comm_max)
+ state->head->comment[state->length++] = len;
+ } while (len && copy < have);
+ if (state->flags & 0x0200)
+ state->check = crc32(state->check, next, copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else if (state->head != Z_NULL)
+ state->head->comment = Z_NULL;
+ state->mode = HCRC;
+ case HCRC:
+ if (state->flags & 0x0200) {
+ NEEDBITS(16);
+ if (hold != (state->check & 0xffff)) {
+ strm->msg = (char *)"header crc mismatch";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ }
+ if (state->head != Z_NULL) {
+ state->head->hcrc = (int)((state->flags >> 9) & 1);
+ state->head->done = 1;
+ }
+ strm->adler = state->check = crc32(0L, Z_NULL, 0);
+ state->mode = TYPE;
+ break;
+#endif
+ case DICTID:
+ NEEDBITS(32);
+ strm->adler = state->check = REVERSE(hold);
+ INITBITS();
+ state->mode = DICT;
+ case DICT:
+ if (state->havedict == 0) {
+ RESTORE();
+ return Z_NEED_DICT;
+ }
+ strm->adler = state->check = adler32(0L, Z_NULL, 0);
+ state->mode = TYPE;
+ case TYPE:
+ if (flush == Z_BLOCK) goto inf_leave;
+ case TYPEDO:
+ if (state->last) {
+ BYTEBITS();
+ state->mode = CHECK;
+ break;
+ }
+ NEEDBITS(3);
+ state->last = BITS(1);
+ DROPBITS(1);
+ switch (BITS(2)) {
+ case 0: /* stored block */
+ Tracev((stderr, "inflate: stored block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = STORED;
+ break;
+ case 1: /* fixed block */
+ fixedtables(state);
+ Tracev((stderr, "inflate: fixed codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = LEN; /* decode codes */
+ break;
+ case 2: /* dynamic block */
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
+ state->last ? " (last)" : ""));
+ state->mode = TABLE;
+ break;
+ case 3:
+ strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ DROPBITS(2);
+ break;
+ case STORED:
+ BYTEBITS(); /* go to byte boundary */
+ NEEDBITS(32);
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned)hold & 0xffff;
+ Tracev((stderr, "inflate: stored length %u\n",
+ state->length));
+ INITBITS();
+ state->mode = COPY;
+ case COPY:
+ copy = state->length;
+ if (copy) {
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ if (copy == 0) goto inf_leave;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ break;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ state->mode = TYPE;
+ break;
+ case TABLE:
+ NEEDBITS(14);
+ state->nlen = BITS(5) + 257;
+ DROPBITS(5);
+ state->ndist = BITS(5) + 1;
+ DROPBITS(5);
+ state->ncode = BITS(4) + 4;
+ DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+ if (state->nlen > 286 || state->ndist > 30) {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ Tracev((stderr, "inflate: table sizes ok\n"));
+ state->have = 0;
+ state->mode = LENLENS;
+ case LENLENS:
+ while (state->have < state->ncode) {
+ NEEDBITS(3);
+ state->lens[order[state->have++]] = (unsigned short)BITS(3);
+ DROPBITS(3);
+ }
+ while (state->have < 19)
+ state->lens[order[state->have++]] = 0;
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 7;
+ ret = inflate_table(CODES, state->lens, 19, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: code lengths ok\n"));
+ state->have = 0;
+ state->mode = CODELENS;
+ case CODELENS:
+ while (state->have < state->nlen + state->ndist) {
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.val < 16) {
+ NEEDBITS(this.bits);
+ DROPBITS(this.bits);
+ state->lens[state->have++] = this.val;
+ }
+ else {
+ if (this.val == 16) {
+ NEEDBITS(this.bits + 2);
+ DROPBITS(this.bits);
+ if (state->have == 0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = state->lens[state->have - 1];
+ copy = 3 + BITS(2);
+ DROPBITS(2);
+ }
+ else if (this.val == 17) {
+ NEEDBITS(this.bits + 3);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 3 + BITS(3);
+ DROPBITS(3);
+ }
+ else {
+ NEEDBITS(this.bits + 7);
+ DROPBITS(this.bits);
+ len = 0;
+ copy = 11 + BITS(7);
+ DROPBITS(7);
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (copy--)
+ state->lens[state->have++] = (unsigned short)len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (state->mode == BAD) break;
+
+ /* build code tables */
+ state->next = state->codes;
+ state->lencode = (code const FAR *)(state->next);
+ state->lenbits = 9;
+ ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+ &(state->lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid literal/lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->distcode = (code const FAR *)(state->next);
+ state->distbits = 6;
+ ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+ &(state->next), &(state->distbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid distances set";
+ state->mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: codes ok\n"));
+ state->mode = LEN;
+ case LEN:
+ if (have >= 6 && left >= 258) {
+ RESTORE();
+ inflate_fast(strm, out);
+ LOAD();
+ break;
+ }
+ for (;;) {
+ this = state->lencode[BITS(state->lenbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (this.op && (this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->lencode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ state->length = (unsigned)this.val;
+ if ((int)(this.op) == 0) {
+ Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", this.val));
+ state->mode = LIT;
+ break;
+ }
+ if (this.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ state->extra = (unsigned)(this.op) & 15;
+ state->mode = LENEXT;
+ case LENEXT:
+ if (state->extra) {
+ NEEDBITS(state->extra);
+ state->length += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ Tracevv((stderr, "inflate: length %u\n", state->length));
+ state->mode = DIST;
+ case DIST:
+ for (;;) {
+ this = state->distcode[BITS(state->distbits)];
+ if ((unsigned)(this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if ((this.op & 0xf0) == 0) {
+ last = this;
+ for (;;) {
+ this = state->distcode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + this.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(this.bits);
+ if (this.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned)this.val;
+ state->extra = (unsigned)(this.op) & 15;
+ state->mode = DISTEXT;
+ case DISTEXT:
+ if (state->extra) {
+ NEEDBITS(state->extra);
+ state->offset += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+#ifdef INFLATE_STRICT
+ if (state->offset > state->dmax) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+#endif
+ if (state->offset > state->whave + out - left) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
+ state->mode = MATCH;
+ case MATCH:
+ if (left == 0) goto inf_leave;
+ copy = out - left;
+ if (state->offset > copy) { /* copy from window */
+ copy = state->offset - copy;
+ if (copy > state->write) {
+ copy -= state->write;
+ from = state->window + (state->wsize - copy);
+ }
+ else
+ from = state->window + (state->write - copy);
+ if (copy > state->length) copy = state->length;
+ }
+ else { /* copy from output */
+ from = put - state->offset;
+ copy = state->length;
+ }
+ if (copy > left) copy = left;
+ left -= copy;
+ state->length -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ if (state->length == 0) state->mode = LEN;
+ break;
+ case LIT:
+ if (left == 0) goto inf_leave;
+ *put++ = (unsigned char)(state->length);
+ left--;
+ state->mode = LEN;
+ break;
+ case CHECK:
+ if (state->wrap) {
+ NEEDBITS(32);
+ out -= left;
+ strm->total_out += out;
+ state->total += out;
+ if (out)
+ strm->adler = state->check =
+ UPDATE(state->check, put - out, out);
+ out = left;
+ if ((
+#ifdef GUNZIP
+ state->flags ? hold :
+#endif
+ REVERSE(hold)) != state->check) {
+ strm->msg = (char *)"incorrect data check";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ Tracev((stderr, "inflate: check matches trailer\n"));
+ }
+#ifdef GUNZIP
+ state->mode = LENGTH;
+ case LENGTH:
+ if (state->wrap && state->flags) {
+ NEEDBITS(32);
+ if (hold != (state->total & 0xffffffffUL)) {
+ strm->msg = (char *)"incorrect length check";
+ state->mode = BAD;
+ break;
+ }
+ INITBITS();
+ Tracev((stderr, "inflate: length matches trailer\n"));
+ }
+#endif
+ state->mode = DONE;
+ case DONE:
+ ret = Z_STREAM_END;
+ goto inf_leave;
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+ case MEM:
+ return Z_MEM_ERROR;
+ case SYNC:
+ default:
+ return Z_STREAM_ERROR;
+ }
+
+ /*
+ Return from inflate(), updating the total counts and the check value.
+ If there was no progress during the inflate() call, return a buffer
+ error. Call updatewindow() to create and/or update the window state.
+ Note: a memory error from inflate() is non-recoverable.
+ */
+ inf_leave:
+ RESTORE();
+ if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+ if (updatewindow(strm, out)) {
+ state->mode = MEM;
+ return Z_MEM_ERROR;
+ }
+ in -= strm->avail_in;
+ out -= strm->avail_out;
+ strm->total_in += in;
+ strm->total_out += out;
+ state->total += out;
+ if (state->wrap && out)
+ strm->adler = state->check =
+ UPDATE(state->check, strm->next_out - out, out);
+ strm->data_type = state->bits + (state->last ? 64 : 0) +
+ (state->mode == TYPE ? 128 : 0);
+ if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+ ret = Z_BUF_ERROR;
+ return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->window != Z_NULL) ZFREE(strm, state->window);
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+ struct inflate_state FAR *state;
+ unsigned long id;
+
+ /* check state */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state->wrap != 0 && state->mode != DICT)
+ return Z_STREAM_ERROR;
+
+ /* check for correct dictionary id */
+ if (state->mode == DICT) {
+ id = adler32(0L, Z_NULL, 0);
+ id = adler32(id, dictionary, dictLength);
+ if (id != state->check)
+ return Z_DATA_ERROR;
+ }
+
+ /* copy dictionary to window */
+ if (updatewindow(strm, strm->avail_out)) {
+ state->mode = MEM;
+ return Z_MEM_ERROR;
+ }
+ if (dictLength > state->wsize) {
+ zmemcpy(state->window, dictionary + dictLength - state->wsize,
+ state->wsize);
+ state->whave = state->wsize;
+ }
+ else {
+ zmemcpy(state->window + state->wsize - dictLength, dictionary,
+ dictLength);
+ state->whave = dictLength;
+ }
+ state->havedict = 1;
+ Tracev((stderr, "inflate: dictionary set\n"));
+ return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+ struct inflate_state FAR *state;
+
+ /* check state */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+ /* save header structure */
+ state->head = head;
+ head->done = 0;
+ return Z_OK;
+}
+
+/*
+ Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found
+ or when out of input. When called, *have is the number of pattern bytes
+ found in order so far, in 0..3. On return *have is updated to the new
+ state. If on return *have equals four, then the pattern was found and the
+ return value is how many bytes were read including the last byte of the
+ pattern. If *have is less than four, then the pattern has not been found
+ yet and the return value is len. In the latter case, syncsearch() can be
+ called again with more data and the *have state. *have is initialized to
+ zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+unsigned char FAR *buf;
+unsigned len;
+{
+ unsigned got;
+ unsigned next;
+
+ got = *have;
+ next = 0;
+ while (next < len && got < 4) {
+ if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+ got++;
+ else if (buf[next])
+ got = 0;
+ else
+ got = 4 - got;
+ next++;
+ }
+ *have = got;
+ return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+ unsigned len; /* number of bytes to look at or looked at */
+ unsigned long in, out; /* temporary to save total_in and total_out */
+ unsigned char buf[4]; /* to restore bit buffer to byte string */
+ struct inflate_state FAR *state;
+
+ /* check parameters */
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+ /* if first time, start search in bit buffer */
+ if (state->mode != SYNC) {
+ state->mode = SYNC;
+ state->hold <<= state->bits & 7;
+ state->bits -= state->bits & 7;
+ len = 0;
+ while (state->bits >= 8) {
+ buf[len++] = (unsigned char)(state->hold);
+ state->hold >>= 8;
+ state->bits -= 8;
+ }
+ state->have = 0;
+ syncsearch(&(state->have), buf, len);
+ }
+
+ /* search available input */
+ len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+ strm->avail_in -= len;
+ strm->next_in += len;
+ strm->total_in += len;
+
+ /* return no joy or set up to restart inflate() on a new block */
+ if (state->have != 4) return Z_DATA_ERROR;
+ in = strm->total_in; out = strm->total_out;
+ inflateReset(strm);
+ strm->total_in = in; strm->total_out = out;
+ state->mode = TYPE;
+ return Z_OK;
+}
+
+/*
+ Returns true if inflate is currently at the end of a block generated by
+ Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+ implementation to provide an additional safety check. PPP uses
+ Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+ block. When decompressing, PPP checks that at the end of input packet,
+ inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+ struct inflate_state FAR *state;
+ struct inflate_state FAR *copy;
+ unsigned char FAR *window;
+ unsigned wsize;
+
+ /* check input */
+ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
+ source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)source->state;
+
+ /* allocate space */
+ copy = (struct inflate_state FAR *)
+ ZALLOC(source, 1, sizeof(struct inflate_state));
+ if (copy == Z_NULL) return Z_MEM_ERROR;
+ window = Z_NULL;
+ if (state->window != Z_NULL) {
+ window = (unsigned char FAR *)
+ ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+ if (window == Z_NULL) {
+ ZFREE(source, copy);
+ return Z_MEM_ERROR;
+ }
+ }
+
+ /* copy state */
+ zmemcpy(dest, source, sizeof(z_stream));
+ zmemcpy(copy, state, sizeof(struct inflate_state));
+ if (state->lencode >= state->codes &&
+ state->lencode <= state->codes + ENOUGH - 1) {
+ copy->lencode = copy->codes + (state->lencode - state->codes);
+ copy->distcode = copy->codes + (state->distcode - state->codes);
+ }
+ copy->next = copy->codes + (state->next - state->codes);
+ if (window != Z_NULL) {
+ wsize = 1U << state->wbits;
+ zmemcpy(window, state->window, wsize);
+ }
+ copy->window = window;
+ dest->state = (struct internal_state FAR *)copy;
+ return Z_OK;
+}
--- /dev/null
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+ trailer decoding by inflate(). NO_GZIP would be used to avoid linking in
+ the crc code when it is not needed. For shared libraries, gzip decoding
+ should be left enabled. */
+#ifndef NO_GZIP
+# define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+ HEAD, /* i: waiting for magic header */
+ FLAGS, /* i: waiting for method and flags (gzip) */
+ TIME, /* i: waiting for modification time (gzip) */
+ OS, /* i: waiting for extra flags and operating system (gzip) */
+ EXLEN, /* i: waiting for extra length (gzip) */
+ EXTRA, /* i: waiting for extra bytes (gzip) */
+ NAME, /* i: waiting for end of file name (gzip) */
+ COMMENT, /* i: waiting for end of comment (gzip) */
+ HCRC, /* i: waiting for header crc (gzip) */
+ DICTID, /* i: waiting for dictionary check value */
+ DICT, /* waiting for inflateSetDictionary() call */
+ TYPE, /* i: waiting for type bits, including last-flag bit */
+ TYPEDO, /* i: same, but skip check to exit inflate on new block */
+ STORED, /* i: waiting for stored size (length and complement) */
+ COPY, /* i/o: waiting for input or output to copy stored block */
+ TABLE, /* i: waiting for dynamic block table lengths */
+ LENLENS, /* i: waiting for code length code lengths */
+ CODELENS, /* i: waiting for length/lit and distance code lengths */
+ LEN, /* i: waiting for length/lit code */
+ LENEXT, /* i: waiting for length extra bits */
+ DIST, /* i: waiting for distance code */
+ DISTEXT, /* i: waiting for distance extra bits */
+ MATCH, /* o: waiting for output space to copy string */
+ LIT, /* o: waiting for output space to write literal */
+ CHECK, /* i: waiting for 32-bit check value */
+ LENGTH, /* i: waiting for 32-bit length (gzip) */
+ DONE, /* finished check, done -- remain here until reset */
+ BAD, /* got a data error -- remain here until reset */
+ MEM, /* got an inflate() memory error -- remain here until reset */
+ SYNC /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+ State transitions between above modes -
+
+ (most modes can go to the BAD or MEM mode -- not shown for clarity)
+
+ Process header:
+ HEAD -> (gzip) or (zlib)
+ (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+ NAME -> COMMENT -> HCRC -> TYPE
+ (zlib) -> DICTID or TYPE
+ DICTID -> DICT -> TYPE
+ Read deflate blocks:
+ TYPE -> STORED or TABLE or LEN or CHECK
+ STORED -> COPY -> TYPE
+ TABLE -> LENLENS -> CODELENS -> LEN
+ Read deflate codes:
+ LEN -> LENEXT or LIT or TYPE
+ LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+ LIT -> LEN
+ Process trailer:
+ CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls. Approximately 7K bytes. */
+struct inflate_state {
+ inflate_mode mode; /* current inflate mode */
+ int last; /* true if processing last block */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ int havedict; /* true if dictionary provided */
+ int flags; /* gzip header method and flags (0 if zlib) */
+ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
+ unsigned long check; /* protected copy of check value */
+ unsigned long total; /* protected copy of output count */
+ gz_headerp head; /* where to save gzip header information */
+ /* sliding window */
+ unsigned wbits; /* log base 2 of requested window size */
+ unsigned wsize; /* window size or zero if not using window */
+ unsigned whave; /* valid bytes in the window */
+ unsigned write; /* window write index */
+ unsigned char FAR *window; /* allocated sliding window, if needed */
+ /* bit accumulator */
+ unsigned long hold; /* input bit accumulator */
+ unsigned bits; /* number of bits in "in" */
+ /* for string and stored block copying */
+ unsigned length; /* literal or length of data to copy */
+ unsigned offset; /* distance back to copy string from */
+ /* for table and code decoding */
+ unsigned extra; /* extra bits needed */
+ /* fixed and dynamic code tables */
+ code const FAR *lencode; /* starting table for length/literal codes */
+ code const FAR *distcode; /* starting table for distance codes */
+ unsigned lenbits; /* index bits for lencode */
+ unsigned distbits; /* index bits for distcode */
+ /* dynamic table building */
+ unsigned ncode; /* number of code length code lengths */
+ unsigned nlen; /* number of length code lengths */
+ unsigned ndist; /* number of distance code lengths */
+ unsigned have; /* number of code lengths in lens[] */
+ code FAR *next; /* next available space in codes[] */
+ unsigned short lens[320]; /* temporary storage for code lengths */
+ unsigned short work[288]; /* work area for code table building */
+ code codes[ENOUGH]; /* space for code tables */
+};
--- /dev/null
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+ " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
+/*
+ If you use the zlib library in a product, an acknowledgment is welcome
+ in the documentation of your product. If for some reason you cannot
+ include such an acknowledgment, I would appreciate that you keep this
+ copyright string in the executable of your product.
+ */
+
+/*
+ Build a set of tables to decode the provided canonical Huffman code.
+ The code lengths are lens[0..codes-1]. The result starts at *table,
+ whose indices are 0..2^bits-1. work is a writable array of at least
+ lens shorts, which is used as a work area. type is the type of code
+ to be generated, CODES, LENS, or DISTS. On return, zero is success,
+ -1 is an invalid code, and +1 means that ENOUGH isn't enough. table
+ on return points to the next available entry's address. bits is the
+ requested root table index bits, and on return it is the actual root
+ table index bits. It will differ if the request is greater than the
+ longest code or if it is less than the shortest code.
+ */
+int inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+ unsigned len; /* a code's length in bits */
+ unsigned sym; /* index of code symbols */
+ unsigned min, max; /* minimum and maximum code lengths */
+ unsigned root; /* number of index bits for root table */
+ unsigned curr; /* number of index bits for current table */
+ unsigned drop; /* code bits to drop for sub-table */
+ int left; /* number of prefix codes available */
+ unsigned used; /* code entries in table used */
+ unsigned huff; /* Huffman code */
+ unsigned incr; /* for incrementing code, index */
+ unsigned fill; /* index for replicating entries */
+ unsigned low; /* low bits for current root entry */
+ unsigned mask; /* mask for low root bits */
+ code this; /* table entry for duplication */
+ code FAR *next; /* next available space in table */
+ const unsigned short FAR *base; /* base value table to use */
+ const unsigned short FAR *extra; /* extra bits table to use */
+ int end; /* use base and extra for symbol > end */
+ unsigned short count[MAXBITS+1]; /* number of codes of each length */
+ unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
+ static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+ 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+ static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+ 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+ 8193, 12289, 16385, 24577, 0, 0};
+ static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+ 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+ 28, 28, 29, 29, 64, 64};
+
+ /*
+ Process a set of code lengths to create a canonical Huffman code. The
+ code lengths are lens[0..codes-1]. Each length corresponds to the
+ symbols 0..codes-1. The Huffman code is generated by first sorting the
+ symbols by length from short to long, and retaining the symbol order
+ for codes with equal lengths. Then the code starts with all zero bits
+ for the first code of the shortest length, and the codes are integer
+ increments for the same length, and zeros are appended as the length
+ increases. For the deflate format, these bits are stored backwards
+ from their more natural integer increment ordering, and so when the
+ decoding tables are built in the large loop below, the integer codes
+ are incremented backwards.
+
+ This routine assumes, but does not check, that all of the entries in
+ lens[] are in the range 0..MAXBITS. The caller must assure this.
+ 1..MAXBITS is interpreted as that code length. zero means that that
+ symbol does not occur in this code.
+
+ The codes are sorted by computing a count of codes for each length,
+ creating from that a table of starting indices for each length in the
+ sorted table, and then entering the symbols in order in the sorted
+ table. The sorted table is work[], with that space being provided by
+ the caller.
+
+ The length counts are used for other purposes as well, i.e. finding
+ the minimum and maximum length codes, determining if there are any
+ codes at all, checking for a valid set of lengths, and looking ahead
+ at length counts to determine sub-table sizes when building the
+ decoding tables.
+ */
+
+ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+ for (len = 0; len <= MAXBITS; len++)
+ count[len] = 0;
+ for (sym = 0; sym < codes; sym++)
+ count[lens[sym]]++;
+
+ /* bound code lengths, force root to be within code lengths */
+ root = *bits;
+ for (max = MAXBITS; max >= 1; max--)
+ if (count[max] != 0) break;
+ if (root > max) root = max;
+ if (max == 0) { /* no symbols to code at all */
+ this.op = (unsigned char)64; /* invalid code marker */
+ this.bits = (unsigned char)1;
+ this.val = (unsigned short)0;
+ *(*table)++ = this; /* make a table to force an error */
+ *(*table)++ = this;
+ *bits = 1;
+ return 0; /* no symbols, but wait for decoding to report error */
+ }
+ for (min = 1; min <= MAXBITS; min++)
+ if (count[min] != 0) break;
+ if (root < min) root = min;
+
+ /* check for an over-subscribed or incomplete set of lengths */
+ left = 1;
+ for (len = 1; len <= MAXBITS; len++) {
+ left <<= 1;
+ left -= count[len];
+ if (left < 0) return -1; /* over-subscribed */
+ }
+ if (left > 0 && (type == CODES || max != 1))
+ return -1; /* incomplete set */
+
+ /* generate offsets into symbol table for each length for sorting */
+ offs[1] = 0;
+ for (len = 1; len < MAXBITS; len++)
+ offs[len + 1] = offs[len] + count[len];
+
+ /* sort symbols by length, by symbol order within each length */
+ for (sym = 0; sym < codes; sym++)
+ if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+ /*
+ Create and fill in decoding tables. In this loop, the table being
+ filled is at next and has curr index bits. The code being used is huff
+ with length len. That code is converted to an index by dropping drop
+ bits off of the bottom. For codes where len is less than drop + curr,
+ those top drop + curr - len bits are incremented through all values to
+ fill the table with replicated entries.
+
+ root is the number of index bits for the root table. When len exceeds
+ root, sub-tables are created pointed to by the root entry with an index
+ of the low root bits of huff. This is saved in low to check for when a
+ new sub-table should be started. drop is zero when the root table is
+ being filled, and drop is root when sub-tables are being filled.
+
+ When a new sub-table is needed, it is necessary to look ahead in the
+ code lengths to determine what size sub-table is needed. The length
+ counts are used for this, and so count[] is decremented as codes are
+ entered in the tables.
+
+ used keeps track of how many table entries have been allocated from the
+ provided *table space. It is checked when a LENS table is being made
+ against the space in *table, ENOUGH, minus the maximum space needed by
+ the worst case distance code, MAXD. This should never happen, but the
+ sufficiency of ENOUGH has not been proven exhaustively, hence the check.
+ This assumes that when type == LENS, bits == 9.
+
+ sym increments through all symbols, and the loop terminates when
+ all codes of length max, i.e. all codes, have been processed. This
+ routine permits incomplete codes, so another loop after this one fills
+ in the rest of the decoding tables with invalid code markers.
+ */
+
+ /* set up for code type */
+ switch (type) {
+ case CODES:
+ base = extra = work; /* dummy value--not used */
+ end = 19;
+ break;
+ case LENS:
+ base = lbase;
+ base -= 257;
+ extra = lext;
+ extra -= 257;
+ end = 256;
+ break;
+ default: /* DISTS */
+ base = dbase;
+ extra = dext;
+ end = -1;
+ }
+
+ /* initialize state for loop */
+ huff = 0; /* starting code */
+ sym = 0; /* starting code symbol */
+ len = min; /* starting code length */
+ next = *table; /* current table to fill in */
+ curr = root; /* current table index bits */
+ drop = 0; /* current bits to drop from code for index */
+ low = (unsigned)(-1); /* trigger new sub-table when len > root */
+ used = 1U << root; /* use root table entries */
+ mask = used - 1; /* mask for comparing low */
+
+ /* check available table space */
+ if (type == LENS && used >= ENOUGH - MAXD)
+ return 1;
+
+ /* process all codes and make table entries */
+ for (;;) {
+ /* create table entry */
+ this.bits = (unsigned char)(len - drop);
+ if ((int)(work[sym]) < end) {
+ this.op = (unsigned char)0;
+ this.val = work[sym];
+ }
+ else if ((int)(work[sym]) > end) {
+ this.op = (unsigned char)(extra[work[sym]]);
+ this.val = base[work[sym]];
+ }
+ else {
+ this.op = (unsigned char)(32 + 64); /* end of block */
+ this.val = 0;
+ }
+
+ /* replicate for those indices with low len bits equal to huff */
+ incr = 1U << (len - drop);
+ fill = 1U << curr;
+ min = fill; /* save offset to next table */
+ do {
+ fill -= incr;
+ next[(huff >> drop) + fill] = this;
+ } while (fill != 0);
+
+ /* backwards increment the len-bit code huff */
+ incr = 1U << (len - 1);
+ while (huff & incr)
+ incr >>= 1;
+ if (incr != 0) {
+ huff &= incr - 1;
+ huff += incr;
+ }
+ else
+ huff = 0;
+
+ /* go to next symbol, update count, len */
+ sym++;
+ if (--(count[len]) == 0) {
+ if (len == max) break;
+ len = lens[work[sym]];
+ }
+
+ /* create new sub-table if needed */
+ if (len > root && (huff & mask) != low) {
+ /* if first time, transition to sub-tables */
+ if (drop == 0)
+ drop = root;
+
+ /* increment past last table */
+ next += min; /* here min is 1 << curr */
+
+ /* determine length of next table */
+ curr = len - drop;
+ left = (int)(1 << curr);
+ while (curr + drop < max) {
+ left -= count[curr + drop];
+ if (left <= 0) break;
+ curr++;
+ left <<= 1;
+ }
+
+ /* check for enough space */
+ used += 1U << curr;
+ if (type == LENS && used >= ENOUGH - MAXD)
+ return 1;
+
+ /* point entry in root table to sub-table */
+ low = huff & mask;
+ (*table)[low].op = (unsigned char)curr;
+ (*table)[low].bits = (unsigned char)root;
+ (*table)[low].val = (unsigned short)(next - *table);
+ }
+ }
+
+ /*
+ Fill in rest of table for incomplete codes. This loop is similar to the
+ loop above in incrementing huff for table indices. It is assumed that
+ len is equal to curr + drop, so there is no loop needed to increment
+ through high index bits. When the current sub-table is filled, the loop
+ drops back to the root table to fill in any remaining entries there.
+ */
+ this.op = (unsigned char)64; /* invalid code marker */
+ this.bits = (unsigned char)(len - drop);
+ this.val = (unsigned short)0;
+ while (huff != 0) {
+ /* when done with sub-table, drop back to root table */
+ if (drop != 0 && (huff & mask) != low) {
+ drop = 0;
+ len = root;
+ next = *table;
+ this.bits = (unsigned char)len;
+ }
+
+ /* put invalid code marker in table */
+ next[huff >> drop] = this;
+
+ /* backwards increment the len-bit code huff */
+ incr = 1U << (len - 1);
+ while (huff & incr)
+ incr >>= 1;
+ if (incr != 0) {
+ huff &= incr - 1;
+ huff += incr;
+ }
+ else
+ huff = 0;
+ }
+
+ /* set return parameters */
+ *table += used;
+ *bits = root;
+ return 0;
+}
--- /dev/null
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables. Each entry provides either the
+ information needed to do the operation requested by the code that
+ indexed that table entry, or it provides a pointer to another
+ table that indexes more bits of the code. op indicates whether
+ the entry is a pointer to another table, a literal, a length or
+ distance, an end-of-block, or an invalid code. For a table
+ pointer, the low four bits of op is the number of index bits of
+ that table. For a length or distance, the low four bits of op
+ is the number of extra bits to get after the code. bits is
+ the number of bits in this code or part of the code to drop off
+ of the bit buffer. val is the actual byte to output in the case
+ of a literal, the base length or distance, or the offset from
+ the current table to the next table. Each entry is four bytes. */
+typedef struct {
+ unsigned char op; /* operation, extra bits, table bits */
+ unsigned char bits; /* bits in this part of the code */
+ unsigned short val; /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+ 00000000 - literal
+ 0000tttt - table link, tttt != 0 is the number of table index bits
+ 0001eeee - length or distance, eeee is the number of extra bits
+ 01100000 - end of block
+ 01000000 - invalid code
+ */
+
+/* Maximum size of dynamic tree. The maximum found in a long but non-
+ exhaustive search was 1444 code structures (852 for length/literals
+ and 592 for distances, the latter actually the result of an
+ exhaustive search). The true maximum is not known, but the value
+ below is more than safe. */
+#define ENOUGH 2048
+#define MAXD 592
+
+/* Type of code to build for inftable() */
+typedef enum {
+ CODES,
+ LENS,
+ DISTS
+} codetype;
+
+extern int inflate_table OF((codetype type, unsigned short FAR *lens,
+ unsigned codes, code FAR * FAR *table,
+ unsigned FAR *bits, unsigned short FAR *work));
--- /dev/null
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2005 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * ALGORITHM
+ *
+ * The "deflation" process uses several Huffman trees. The more
+ * common source values are represented by shorter bit sequences.
+ *
+ * Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values). The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ * REFERENCES
+ *
+ * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ * Storer, James A.
+ * Data Compression: Methods and Theory, pp. 49-50.
+ * Computer Science Press, 1988. ISBN 0-7167-8156-5.
+ *
+ * Sedgewick, R.
+ * Algorithms, p290.
+ * Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id$ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef DEBUG
+# include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6 16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10 17
+/* repeat a zero length 3-10 times (3 bits of repeat count) */
+
+#define REPZ_11_138 18
+/* repeat a zero length 11-138 times (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+ = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+ = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+ = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+ = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+#define Buf_size (8 * 2*sizeof(char))
+/* Number of bits used within bi_buf. (bi_buf might be implemented on
+ * more than 16 bits on some systems.)
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+# include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+ const ct_data *static_tree; /* static tree or NULL */
+ const intf *extra_bits; /* extra bits for each code or NULL */
+ int extra_base; /* base index for extra_bits */
+ int elems; /* max number of elements in the tree */
+ int max_length; /* max bit length for the codes */
+};
+
+local static_tree_desc static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local static_tree_desc static_d_desc =
+{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
+
+local static_tree_desc static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block OF((deflate_state *s));
+local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
+local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree OF((deflate_state *s, tree_desc *desc));
+local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
+local int build_bl_tree OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+ int blcodes));
+local void compress_block OF((deflate_state *s, ct_data *ltree,
+ ct_data *dtree));
+local void set_data_type OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup OF((deflate_state *s));
+local void bi_flush OF((deflate_state *s));
+local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
+ int header));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef DEBUG
+# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+ /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* DEBUG */
+# define send_code(s, c, tree) \
+ { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+ send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+ put_byte(s, (uch)((w) & 0xff)); \
+ put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef DEBUG
+local void send_bits OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+ deflate_state *s;
+ int value; /* value to send */
+ int length; /* number of bits */
+{
+ Tracevv((stderr," l %2d v %4x ", length, value));
+ Assert(length > 0 && length <= 15, "invalid length");
+ s->bits_sent += (ulg)length;
+
+ /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+ * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+ * unused bits in value.
+ */
+ if (s->bi_valid > (int)Buf_size - length) {
+ s->bi_buf |= (value << s->bi_valid);
+ put_short(s, s->bi_buf);
+ s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+ s->bi_valid += length - Buf_size;
+ } else {
+ s->bi_buf |= value << s->bi_valid;
+ s->bi_valid += length;
+ }
+}
+#else /* !DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+ if (s->bi_valid > (int)Buf_size - len) {\
+ int val = value;\
+ s->bi_buf |= (val << s->bi_valid);\
+ put_short(s, s->bi_buf);\
+ s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+ s->bi_valid += len - Buf_size;\
+ } else {\
+ s->bi_buf |= (value) << s->bi_valid;\
+ s->bi_valid += len;\
+ }\
+}
+#endif /* DEBUG */
+
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+ static int static_init_done = 0;
+ int n; /* iterates over tree elements */
+ int bits; /* bit counter */
+ int length; /* length value */
+ int code; /* code value */
+ int dist; /* distance index */
+ ush bl_count[MAX_BITS+1];
+ /* number of codes at each bit length for an optimal tree */
+
+ if (static_init_done) return;
+
+ /* For some embedded targets, global variables are not initialized: */
+ static_l_desc.static_tree = static_ltree;
+ static_l_desc.extra_bits = extra_lbits;
+ static_d_desc.static_tree = static_dtree;
+ static_d_desc.extra_bits = extra_dbits;
+ static_bl_desc.extra_bits = extra_blbits;
+
+ /* Initialize the mapping length (0..255) -> length code (0..28) */
+ length = 0;
+ for (code = 0; code < LENGTH_CODES-1; code++) {
+ base_length[code] = length;
+ for (n = 0; n < (1<<extra_lbits[code]); n++) {
+ _length_code[length++] = (uch)code;
+ }
+ }
+ Assert (length == 256, "tr_static_init: length != 256");
+ /* Note that the length 255 (match length 258) can be represented
+ * in two different ways: code 284 + 5 bits or code 285, so we
+ * overwrite length_code[255] to use the best encoding:
+ */
+ _length_code[length-1] = (uch)code;
+
+ /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+ dist = 0;
+ for (code = 0 ; code < 16; code++) {
+ base_dist[code] = dist;
+ for (n = 0; n < (1<<extra_dbits[code]); n++) {
+ _dist_code[dist++] = (uch)code;
+ }
+ }
+ Assert (dist == 256, "tr_static_init: dist != 256");
+ dist >>= 7; /* from now on, all distances are divided by 128 */
+ for ( ; code < D_CODES; code++) {
+ base_dist[code] = dist << 7;
+ for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+ _dist_code[256 + dist++] = (uch)code;
+ }
+ }
+ Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+ /* Construct the codes of the static literal tree */
+ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+ n = 0;
+ while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+ while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+ while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+ while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+ /* Codes 286 and 287 do not exist, but we must include them in the
+ * tree construction to get a canonical Huffman tree (longest code
+ * all ones)
+ */
+ gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+ /* The static distance tree is trivial: */
+ for (n = 0; n < D_CODES; n++) {
+ static_dtree[n].Len = 5;
+ static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+ }
+ static_init_done = 1;
+
+# ifdef GEN_TREES_H
+ gen_trees_header();
+# endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+# ifndef DEBUG
+# include <stdio.h>
+# endif
+
+# define SEPARATOR(i, last, width) \
+ ((i) == (last)? "\n};\n\n" : \
+ ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+ FILE *header = fopen("trees.h", "w");
+ int i;
+
+ Assert (header != NULL, "Can't open trees.h");
+ fprintf(header,
+ "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+ fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+ for (i = 0; i < L_CODES+2; i++) {
+ fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+ static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+ }
+
+ fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+ for (i = 0; i < D_CODES; i++) {
+ fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+ static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+ }
+
+ fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n");
+ for (i = 0; i < DIST_CODE_LEN; i++) {
+ fprintf(header, "%2u%s", _dist_code[i],
+ SEPARATOR(i, DIST_CODE_LEN-1, 20));
+ }
+
+ fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+ for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+ fprintf(header, "%2u%s", _length_code[i],
+ SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+ }
+
+ fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+ for (i = 0; i < LENGTH_CODES; i++) {
+ fprintf(header, "%1u%s", base_length[i],
+ SEPARATOR(i, LENGTH_CODES-1, 20));
+ }
+
+ fprintf(header, "local const int base_dist[D_CODES] = {\n");
+ for (i = 0; i < D_CODES; i++) {
+ fprintf(header, "%5u%s", base_dist[i],
+ SEPARATOR(i, D_CODES-1, 10));
+ }
+
+ fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void _tr_init(s)
+ deflate_state *s;
+{
+ tr_static_init();
+
+ s->l_desc.dyn_tree = s->dyn_ltree;
+ s->l_desc.stat_desc = &static_l_desc;
+
+ s->d_desc.dyn_tree = s->dyn_dtree;
+ s->d_desc.stat_desc = &static_d_desc;
+
+ s->bl_desc.dyn_tree = s->bl_tree;
+ s->bl_desc.stat_desc = &static_bl_desc;
+
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+ s->last_eob_len = 8; /* enough lookahead for inflate */
+#ifdef DEBUG
+ s->compressed_len = 0L;
+ s->bits_sent = 0L;
+#endif
+
+ /* Initialize the first block of the first file: */
+ init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+ deflate_state *s;
+{
+ int n; /* iterates over tree elements */
+
+ /* Initialize the trees. */
+ for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
+ for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
+ for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+ s->dyn_ltree[END_BLOCK].Freq = 1;
+ s->opt_len = s->static_len = 0L;
+ s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+ top = s->heap[SMALLEST]; \
+ s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+ pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+ (tree[n].Freq < tree[m].Freq || \
+ (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+ deflate_state *s;
+ ct_data *tree; /* the tree to restore */
+ int k; /* node to move down */
+{
+ int v = s->heap[k];
+ int j = k << 1; /* left son of k */
+ while (j <= s->heap_len) {
+ /* Set j to the smallest of the two sons: */
+ if (j < s->heap_len &&
+ smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+ j++;
+ }
+ /* Exit if v is smaller than both sons */
+ if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+ /* Exchange v with the smallest son */
+ s->heap[k] = s->heap[j]; k = j;
+
+ /* And continue down the tree, setting j to the left son of k */
+ j <<= 1;
+ }
+ s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ * above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ * array bl_count contains the frequencies for each bit length.
+ * The length opt_len is updated; static_len is also updated if stree is
+ * not null.
+ */
+local void gen_bitlen(s, desc)
+ deflate_state *s;
+ tree_desc *desc; /* the tree descriptor */
+{
+ ct_data *tree = desc->dyn_tree;
+ int max_code = desc->max_code;
+ const ct_data *stree = desc->stat_desc->static_tree;
+ const intf *extra = desc->stat_desc->extra_bits;
+ int base = desc->stat_desc->extra_base;
+ int max_length = desc->stat_desc->max_length;
+ int h; /* heap index */
+ int n, m; /* iterate over the tree elements */
+ int bits; /* bit length */
+ int xbits; /* extra bits */
+ ush f; /* frequency */
+ int overflow = 0; /* number of elements with bit length too large */
+
+ for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+ /* In a first pass, compute the optimal bit lengths (which may
+ * overflow in the case of the bit length tree).
+ */
+ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+ for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+ n = s->heap[h];
+ bits = tree[tree[n].Dad].Len + 1;
+ if (bits > max_length) bits = max_length, overflow++;
+ tree[n].Len = (ush)bits;
+ /* We overwrite tree[n].Dad which is no longer needed */
+
+ if (n > max_code) continue; /* not a leaf node */
+
+ s->bl_count[bits]++;
+ xbits = 0;
+ if (n >= base) xbits = extra[n-base];
+ f = tree[n].Freq;
+ s->opt_len += (ulg)f * (bits + xbits);
+ if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
+ }
+ if (overflow == 0) return;
+
+ Trace((stderr,"\nbit length overflow\n"));
+ /* This happens for example on obj2 and pic of the Calgary corpus */
+
+ /* Find the first bit length which could increase: */
+ do {
+ bits = max_length-1;
+ while (s->bl_count[bits] == 0) bits--;
+ s->bl_count[bits]--; /* move one leaf down the tree */
+ s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+ s->bl_count[max_length]--;
+ /* The brother of the overflow item also moves one step up,
+ * but this does not affect bl_count[max_length]
+ */
+ overflow -= 2;
+ } while (overflow > 0);
+
+ /* Now recompute all bit lengths, scanning in increasing frequency.
+ * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+ * lengths instead of fixing only the wrong ones. This idea is taken
+ * from 'ar' written by Haruhiko Okumura.)
+ */
+ for (bits = max_length; bits != 0; bits--) {
+ n = s->bl_count[bits];
+ while (n != 0) {
+ m = s->heap[--h];
+ if (m > max_code) continue;
+ if ((unsigned) tree[m].Len != (unsigned) bits) {
+ Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+ s->opt_len += ((long)bits - (long)tree[m].Len)
+ *(long)tree[m].Freq;
+ tree[m].Len = (ush)bits;
+ }
+ n--;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ * zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+ ct_data *tree; /* the tree to decorate */
+ int max_code; /* largest code with non zero frequency */
+ ushf *bl_count; /* number of codes at each bit length */
+{
+ ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+ ush code = 0; /* running code value */
+ int bits; /* bit index */
+ int n; /* code index */
+
+ /* The distribution counts are first used to generate the code values
+ * without bit reversal.
+ */
+ for (bits = 1; bits <= MAX_BITS; bits++) {
+ next_code[bits] = code = (code + bl_count[bits-1]) << 1;
+ }
+ /* Check that the bit counts in bl_count are consistent. The last code
+ * must be all ones.
+ */
+ Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+ "inconsistent bit counts");
+ Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+ for (n = 0; n <= max_code; n++) {
+ int len = tree[n].Len;
+ if (len == 0) continue;
+ /* Now reverse the bits */
+ tree[n].Code = bi_reverse(next_code[len]++, len);
+
+ Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+ n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+ }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ * and corresponding code. The length opt_len is updated; static_len is
+ * also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+ deflate_state *s;
+ tree_desc *desc; /* the tree descriptor */
+{
+ ct_data *tree = desc->dyn_tree;
+ const ct_data *stree = desc->stat_desc->static_tree;
+ int elems = desc->stat_desc->elems;
+ int n, m; /* iterate over heap elements */
+ int max_code = -1; /* largest code with non zero frequency */
+ int node; /* new node being created */
+
+ /* Construct the initial heap, with least frequent element in
+ * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+ * heap[0] is not used.
+ */
+ s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+ for (n = 0; n < elems; n++) {
+ if (tree[n].Freq != 0) {
+ s->heap[++(s->heap_len)] = max_code = n;
+ s->depth[n] = 0;
+ } else {
+ tree[n].Len = 0;
+ }
+ }
+
+ /* The pkzip format requires that at least one distance code exists,
+ * and that at least one bit should be sent even if there is only one
+ * possible code. So to avoid special checks later on we force at least
+ * two codes of non zero frequency.
+ */
+ while (s->heap_len < 2) {
+ node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+ tree[node].Freq = 1;
+ s->depth[node] = 0;
+ s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+ /* node is 0 or 1 so it does not have extra bits */
+ }
+ desc->max_code = max_code;
+
+ /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+ * establish sub-heaps of increasing lengths:
+ */
+ for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+ /* Construct the Huffman tree by repeatedly combining the least two
+ * frequent nodes.
+ */
+ node = elems; /* next internal node of the tree */
+ do {
+ pqremove(s, tree, n); /* n = node of least frequency */
+ m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+ s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+ s->heap[--(s->heap_max)] = m;
+
+ /* Create a new node father of n and m */
+ tree[node].Freq = tree[n].Freq + tree[m].Freq;
+ s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+ s->depth[n] : s->depth[m]) + 1);
+ tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+ if (tree == s->bl_tree) {
+ fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+ node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+ }
+#endif
+ /* and insert the new node in the heap */
+ s->heap[SMALLEST] = node++;
+ pqdownheap(s, tree, SMALLEST);
+
+ } while (s->heap_len >= 2);
+
+ s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+ /* At this point, the fields freq and dad are set. We can now
+ * generate the bit lengths.
+ */
+ gen_bitlen(s, (tree_desc *)desc);
+
+ /* The field len is now set, we can generate the bit codes */
+ gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+ deflate_state *s;
+ ct_data *tree; /* the tree to be scanned */
+ int max_code; /* and its largest code of non zero frequency */
+{
+ int n; /* iterates over all tree elements */
+ int prevlen = -1; /* last emitted length */
+ int curlen; /* length of current code */
+ int nextlen = tree[0].Len; /* length of next code */
+ int count = 0; /* repeat count of the current code */
+ int max_count = 7; /* max repeat count */
+ int min_count = 4; /* min repeat count */
+
+ if (nextlen == 0) max_count = 138, min_count = 3;
+ tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen; nextlen = tree[n+1].Len;
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ s->bl_tree[curlen].Freq += count;
+ } else if (curlen != 0) {
+ if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+ s->bl_tree[REP_3_6].Freq++;
+ } else if (count <= 10) {
+ s->bl_tree[REPZ_3_10].Freq++;
+ } else {
+ s->bl_tree[REPZ_11_138].Freq++;
+ }
+ count = 0; prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138, min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6, min_count = 3;
+ } else {
+ max_count = 7, min_count = 4;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+ deflate_state *s;
+ ct_data *tree; /* the tree to be scanned */
+ int max_code; /* and its largest code of non zero frequency */
+{
+ int n; /* iterates over all tree elements */
+ int prevlen = -1; /* last emitted length */
+ int curlen; /* length of current code */
+ int nextlen = tree[0].Len; /* length of next code */
+ int count = 0; /* repeat count of the current code */
+ int max_count = 7; /* max repeat count */
+ int min_count = 4; /* min repeat count */
+
+ /* tree[max_code+1].Len = -1; */ /* guard already set */
+ if (nextlen == 0) max_count = 138, min_count = 3;
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen; nextlen = tree[n+1].Len;
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+ } else if (curlen != 0) {
+ if (curlen != prevlen) {
+ send_code(s, curlen, s->bl_tree); count--;
+ }
+ Assert(count >= 3 && count <= 6, " 3_6?");
+ send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+ } else if (count <= 10) {
+ send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+ } else {
+ send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+ }
+ count = 0; prevlen = curlen;
+ if (nextlen == 0) {
+ max_count = 138, min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6, min_count = 3;
+ } else {
+ max_count = 7, min_count = 4;
+ }
+ }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+ deflate_state *s;
+{
+ int max_blindex; /* index of last bit length code of non zero freq */
+
+ /* Determine the bit length frequencies for literal and distance trees */
+ scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+ scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+ /* Build the bit length tree: */
+ build_tree(s, (tree_desc *)(&(s->bl_desc)));
+ /* opt_len now includes the length of the tree representations, except
+ * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+ */
+
+ /* Determine the number of bit length codes to send. The pkzip format
+ * requires that at least 4 bit length codes be sent. (appnote.txt says
+ * 3 but the actual value used is 4.)
+ */
+ for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+ if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+ }
+ /* Update opt_len to include the bit length tree and counts */
+ s->opt_len += 3*(max_blindex+1) + 5+5+4;
+ Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+ s->opt_len, s->static_len));
+
+ return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+ deflate_state *s;
+ int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+ int rank; /* index in bl_order */
+
+ Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+ Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+ "too many codes");
+ Tracev((stderr, "\nbl counts: "));
+ send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+ send_bits(s, dcodes-1, 5);
+ send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
+ for (rank = 0; rank < blcodes; rank++) {
+ Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+ send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+ }
+ Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+ send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+ send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void _tr_stored_block(s, buf, stored_len, eof)
+ deflate_state *s;
+ charf *buf; /* input block */
+ ulg stored_len; /* length of input block */
+ int eof; /* true if this is the last block for a file */
+{
+ send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */
+#ifdef DEBUG
+ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+ s->compressed_len += (stored_len + 4) << 3;
+#endif
+ copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ * The current inflate code requires 9 bits of lookahead. If the
+ * last two codes for the previous block (real code plus EOB) were coded
+ * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+ * the last real code. In this case we send two empty static blocks instead
+ * of one. (There are no problems if the previous block is stored or fixed.)
+ * To simplify the code, we assume the worst case of last real code encoded
+ * on one bit only.
+ */
+void _tr_align(s)
+ deflate_state *s;
+{
+ send_bits(s, STATIC_TREES<<1, 3);
+ send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+ s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+ bi_flush(s);
+ /* Of the 10 bits for the empty block, we have already sent
+ * (10 - bi_valid) bits. The lookahead for the last real code (before
+ * the EOB of the previous block) was thus at least one plus the length
+ * of the EOB plus what we have just sent of the empty static block.
+ */
+ if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
+ send_bits(s, STATIC_TREES<<1, 3);
+ send_code(s, END_BLOCK, static_ltree);
+#ifdef DEBUG
+ s->compressed_len += 10L;
+#endif
+ bi_flush(s);
+ }
+ s->last_eob_len = 7;
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+void _tr_flush_block(s, buf, stored_len, eof)
+ deflate_state *s;
+ charf *buf; /* input block, or NULL if too old */
+ ulg stored_len; /* length of input block */
+ int eof; /* true if this is the last block for a file */
+{
+ ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+ int max_blindex = 0; /* index of last bit length code of non zero freq */
+
+ /* Build the Huffman trees unless a stored block is forced */
+ if (s->level > 0) {
+
+ /* Check if the file is binary or text */
+ if (stored_len > 0 && s->strm->data_type == Z_UNKNOWN)
+ set_data_type(s);
+
+ /* Construct the literal and distance trees */
+ build_tree(s, (tree_desc *)(&(s->l_desc)));
+ Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+ s->static_len));
+
+ build_tree(s, (tree_desc *)(&(s->d_desc)));
+ Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+ s->static_len));
+ /* At this point, opt_len and static_len are the total bit lengths of
+ * the compressed block data, excluding the tree representations.
+ */
+
+ /* Build the bit length tree for the above two trees, and get the index
+ * in bl_order of the last bit length code to send.
+ */
+ max_blindex = build_bl_tree(s);
+
+ /* Determine the best encoding. Compute the block lengths in bytes. */
+ opt_lenb = (s->opt_len+3+7)>>3;
+ static_lenb = (s->static_len+3+7)>>3;
+
+ Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+ opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+ s->last_lit));
+
+ if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+ } else {
+ Assert(buf != (char*)0, "lost buf");
+ opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+ }
+
+#ifdef FORCE_STORED
+ if (buf != (char*)0) { /* force stored block */
+#else
+ if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+ /* 4: two words for the lengths */
+#endif
+ /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+ * Otherwise we can't have processed more than WSIZE input bytes since
+ * the last block flush, because compression would have been
+ * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+ * transform a block into a stored block.
+ */
+ _tr_stored_block(s, buf, stored_len, eof);
+
+#ifdef FORCE_STATIC
+ } else if (static_lenb >= 0) { /* force static trees */
+#else
+ } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
+#endif
+ send_bits(s, (STATIC_TREES<<1)+eof, 3);
+ compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
+#ifdef DEBUG
+ s->compressed_len += 3 + s->static_len;
+#endif
+ } else {
+ send_bits(s, (DYN_TREES<<1)+eof, 3);
+ send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+ max_blindex+1);
+ compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
+#ifdef DEBUG
+ s->compressed_len += 3 + s->opt_len;
+#endif
+ }
+ Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+ /* The above check is made mod 2^32, for files larger than 512 MB
+ * and uLong implemented on 32 bits.
+ */
+ init_block(s);
+
+ if (eof) {
+ bi_windup(s);
+#ifdef DEBUG
+ s->compressed_len += 7; /* align on byte boundary */
+#endif
+ }
+ Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+ s->compressed_len-7*eof));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int _tr_tally (s, dist, lc)
+ deflate_state *s;
+ unsigned dist; /* distance of matched string */
+ unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+ s->d_buf[s->last_lit] = (ush)dist;
+ s->l_buf[s->last_lit++] = (uch)lc;
+ if (dist == 0) {
+ /* lc is the unmatched char */
+ s->dyn_ltree[lc].Freq++;
+ } else {
+ s->matches++;
+ /* Here, lc is the match length - MIN_MATCH */
+ dist--; /* dist = match distance - 1 */
+ Assert((ush)dist < (ush)MAX_DIST(s) &&
+ (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+ (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
+
+ s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+ s->dyn_dtree[d_code(dist)].Freq++;
+ }
+
+#ifdef TRUNCATE_BLOCK
+ /* Try to guess if it is profitable to stop the current block here */
+ if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+ /* Compute an upper bound for the compressed length */
+ ulg out_length = (ulg)s->last_lit*8L;
+ ulg in_length = (ulg)((long)s->strstart - s->block_start);
+ int dcode;
+ for (dcode = 0; dcode < D_CODES; dcode++) {
+ out_length += (ulg)s->dyn_dtree[dcode].Freq *
+ (5L+extra_dbits[dcode]);
+ }
+ out_length >>= 3;
+ Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+ s->last_lit, in_length, out_length,
+ 100L - out_length*100L/in_length));
+ if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+ }
+#endif
+ return (s->last_lit == s->lit_bufsize-1);
+ /* We avoid equality with lit_bufsize because of wraparound at 64K
+ * on 16 bit machines and because stored blocks are restricted to
+ * 64K-1 bytes.
+ */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+ deflate_state *s;
+ ct_data *ltree; /* literal tree */
+ ct_data *dtree; /* distance tree */
+{
+ unsigned dist; /* distance of matched string */
+ int lc; /* match length or unmatched char (if dist == 0) */
+ unsigned lx = 0; /* running index in l_buf */
+ unsigned code; /* the code to send */
+ int extra; /* number of extra bits to send */
+
+ if (s->last_lit != 0) do {
+ dist = s->d_buf[lx];
+ lc = s->l_buf[lx++];
+ if (dist == 0) {
+ send_code(s, lc, ltree); /* send a literal byte */
+ Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+ } else {
+ /* Here, lc is the match length - MIN_MATCH */
+ code = _length_code[lc];
+ send_code(s, code+LITERALS+1, ltree); /* send the length code */
+ extra = extra_lbits[code];
+ if (extra != 0) {
+ lc -= base_length[code];
+ send_bits(s, lc, extra); /* send the extra length bits */
+ }
+ dist--; /* dist is now the match distance - 1 */
+ code = d_code(dist);
+ Assert (code < D_CODES, "bad d_code");
+
+ send_code(s, code, dtree); /* send the distance code */
+ extra = extra_dbits[code];
+ if (extra != 0) {
+ dist -= base_dist[code];
+ send_bits(s, dist, extra); /* send the extra distance bits */
+ }
+ } /* literal or match pair ? */
+
+ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+ Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+ "pendingBuf overflow");
+
+ } while (lx < s->last_lit);
+
+ send_code(s, END_BLOCK, ltree);
+ s->last_eob_len = ltree[END_BLOCK].Len;
+}
+
+/* ===========================================================================
+ * Set the data type to BINARY or TEXT, using a crude approximation:
+ * set it to Z_TEXT if all symbols are either printable characters (33 to 255)
+ * or white spaces (9 to 13, or 32); or set it to Z_BINARY otherwise.
+ * IN assertion: the fields Freq of dyn_ltree are set.
+ */
+local void set_data_type(s)
+ deflate_state *s;
+{
+ int n;
+
+ for (n = 0; n < 9; n++)
+ if (s->dyn_ltree[n].Freq != 0)
+ break;
+ if (n == 9)
+ for (n = 14; n < 32; n++)
+ if (s->dyn_ltree[n].Freq != 0)
+ break;
+ s->strm->data_type = (n == 32) ? Z_TEXT : Z_BINARY;
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+ unsigned code; /* the value to invert */
+ int len; /* its bit length */
+{
+ register unsigned res = 0;
+ do {
+ res |= code & 1;
+ code >>= 1, res <<= 1;
+ } while (--len > 0);
+ return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+ deflate_state *s;
+{
+ if (s->bi_valid == 16) {
+ put_short(s, s->bi_buf);
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+ } else if (s->bi_valid >= 8) {
+ put_byte(s, (Byte)s->bi_buf);
+ s->bi_buf >>= 8;
+ s->bi_valid -= 8;
+ }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+ deflate_state *s;
+{
+ if (s->bi_valid > 8) {
+ put_short(s, s->bi_buf);
+ } else if (s->bi_valid > 0) {
+ put_byte(s, (Byte)s->bi_buf);
+ }
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+#ifdef DEBUG
+ s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
+
+/* ===========================================================================
+ * Copy a stored block, storing first the length and its
+ * one's complement if requested.
+ */
+local void copy_block(s, buf, len, header)
+ deflate_state *s;
+ charf *buf; /* the input data */
+ unsigned len; /* its length */
+ int header; /* true if block header must be written */
+{
+ bi_windup(s); /* align on byte boundary */
+ s->last_eob_len = 8; /* enough lookahead for inflate */
+
+ if (header) {
+ put_short(s, (ush)len);
+ put_short(s, (ush)~len);
+#ifdef DEBUG
+ s->bits_sent += 2*16;
+#endif
+ }
+#ifdef DEBUG
+ s->bits_sent += (ulg)len<<3;
+#endif
+ while (len--) {
+ put_byte(s, *buf++);
+ }
+}
--- /dev/null
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
+{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
+{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
+{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
+{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
+{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
+{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
+{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
+{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
+{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
+{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
+{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
+{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
+{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
+{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
+{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
+{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
+{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
+{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
+{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
+{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
+{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
+{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
+{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
+{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
+{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
+{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
+{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
+{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
+{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
+{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
+{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
+{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
+{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
+{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
+{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
+{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
+{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
+{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
+{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
+{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
+{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
+{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
+{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
+{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
+{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
+{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
+{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
+{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
+{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
+{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
+{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
+{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
+{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
+{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
+{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
+{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
+{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch _dist_code[DIST_CODE_LEN] = {
+ 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
+ 32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
+ 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
+};
+
--- /dev/null
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2003 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+ Decompresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be large enough to hold the
+ entire uncompressed data. (The size of the uncompressed data must have
+ been saved previously by the compressor and transmitted to the decompressor
+ by some mechanism outside the scope of this compression library.)
+ Upon exit, destLen is the actual size of the compressed buffer.
+ This function can be used to decompress a whole file at once if the
+ input file is mmap'ed.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer, or Z_DATA_ERROR if the input data was corrupted.
+*/
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ z_stream stream;
+ int err;
+
+ stream.next_in = (Bytef*)source;
+ stream.avail_in = (uInt)sourceLen;
+ /* Check for source > 64K on 16-bit machine: */
+ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+
+ stream.next_out = dest;
+ stream.avail_out = (uInt)*destLen;
+ if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+
+ err = inflateInit(&stream);
+ if (err != Z_OK) return err;
+
+ err = inflate(&stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ inflateEnd(&stream);
+ if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
+ return Z_DATA_ERROR;
+ return err;
+ }
+ *destLen = stream.total_out;
+
+ err = inflateEnd(&stream);
+ return err;
+}
--- /dev/null
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+# define deflateInit_ z_deflateInit_
+# define deflate z_deflate
+# define deflateEnd z_deflateEnd
+# define inflateInit_ z_inflateInit_
+# define inflate z_inflate
+# define inflateEnd z_inflateEnd
+# define deflateInit2_ z_deflateInit2_
+# define deflateSetDictionary z_deflateSetDictionary
+# define deflateCopy z_deflateCopy
+# define deflateReset z_deflateReset
+# define deflateParams z_deflateParams
+# define deflateBound z_deflateBound
+# define deflatePrime z_deflatePrime
+# define inflateInit2_ z_inflateInit2_
+# define inflateSetDictionary z_inflateSetDictionary
+# define inflateSync z_inflateSync
+# define inflateSyncPoint z_inflateSyncPoint
+# define inflateCopy z_inflateCopy
+# define inflateReset z_inflateReset
+# define inflateBack z_inflateBack
+# define inflateBackEnd z_inflateBackEnd
+# define compress z_compress
+# define compress2 z_compress2
+# define compressBound z_compressBound
+# define uncompress z_uncompress
+# define adler32 z_adler32
+# define crc32 z_crc32
+# define get_crc_table z_get_crc_table
+# define zError z_zError
+
+# define alloc_func z_alloc_func
+# define free_func z_free_func
+# define in_func z_in_func
+# define out_func z_out_func
+# define Byte z_Byte
+# define uInt z_uInt
+# define uLong z_uLong
+# define Bytef z_Bytef
+# define charf z_charf
+# define intf z_intf
+# define uIntf z_uIntf
+# define uLongf z_uLongf
+# define voidpf z_voidpf
+# define voidp z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+# define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+# define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+# define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+# ifndef WIN32
+# define WIN32
+# endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+# ifndef SYS16BIT
+# define SYS16BIT
+# endif
+# endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+# define MAXSEG_64K
+#endif
+#ifdef MSDOS
+# define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+# ifndef STDC
+# define STDC
+# endif
+# if __STDC_VERSION__ >= 199901L
+# ifndef STDC99
+# define STDC99
+# endif
+# endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+# define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+# define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
+# define STDC
+#endif
+
+#ifndef STDC
+# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+# define const /* note: need a more gentle solution here */
+# endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+# define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+# ifdef MAXSEG_64K
+# define MAX_MEM_LEVEL 8
+# else
+# define MAX_MEM_LEVEL 9
+# endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+# define MAX_WBITS 15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+ (1 << (windowBits+2)) + (1 << (memLevel+9))
+ that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+ make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+ The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+ /* Type declarations */
+
+#ifndef OF /* function prototypes */
+# ifdef STDC
+# define OF(args) args
+# else
+# define OF(args) ()
+# endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+# if defined(M_I86SM) || defined(M_I86MM)
+ /* MSC small or medium model */
+# define SMALL_MEDIUM
+# ifdef _MSC_VER
+# define FAR _far
+# else
+# define FAR far
+# endif
+# endif
+# if (defined(__SMALL__) || defined(__MEDIUM__))
+ /* Turbo C small or medium model */
+# define SMALL_MEDIUM
+# ifdef __BORLANDC__
+# define FAR _far
+# else
+# define FAR far
+# endif
+# endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+ /* If building or using zlib as a DLL, define ZLIB_DLL.
+ * This is not mandatory, but it offers a little performance increase.
+ */
+# ifdef ZLIB_DLL
+# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+# ifdef ZLIB_INTERNAL
+# define ZEXTERN extern __declspec(dllexport)
+# else
+# define ZEXTERN extern __declspec(dllimport)
+# endif
+# endif
+# endif /* ZLIB_DLL */
+ /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+ * define ZLIB_WINAPI.
+ * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+ */
+# ifdef ZLIB_WINAPI
+# ifdef FAR
+# undef FAR
+# endif
+# include <windows.h>
+ /* No need for _export, use ZLIB.DEF instead. */
+ /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+# define ZEXPORT WINAPI
+# ifdef WIN32
+# define ZEXPORTVA WINAPIV
+# else
+# define ZEXPORTVA FAR CDECL
+# endif
+# endif
+#endif
+
+#if defined (__BEOS__)
+# ifdef ZLIB_DLL
+# ifdef ZLIB_INTERNAL
+# define ZEXPORT __declspec(dllexport)
+# define ZEXPORTVA __declspec(dllexport)
+# else
+# define ZEXPORT __declspec(dllimport)
+# define ZEXPORTVA __declspec(dllimport)
+# endif
+# endif
+#endif
+
+#ifndef ZEXTERN
+# define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+# define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+# define ZEXPORTVA
+#endif
+
+#ifndef FAR
+# define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char Byte; /* 8 bits */
+#endif
+typedef unsigned int uInt; /* 16 bits or more */
+typedef unsigned long uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+ /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+# define Bytef Byte FAR
+#else
+ typedef Byte FAR Bytef;
+#endif
+typedef char FAR charf;
+typedef int FAR intf;
+typedef uInt FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+ typedef void const *voidpc;
+ typedef void FAR *voidpf;
+ typedef void *voidp;
+#else
+ typedef Byte const *voidpc;
+ typedef Byte FAR *voidpf;
+ typedef Byte *voidp;
+#endif
+
+#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */
+# include <sys/types.h> /* for off_t */
+# include <unistd.h> /* for SEEK_* and off_t */
+# ifdef VMS
+# include <unixio.h> /* for off_t */
+# endif
+# define z_off_t off_t
+#endif
+#ifndef SEEK_SET
+# define SEEK_SET 0 /* Seek from beginning of file. */
+# define SEEK_CUR 1 /* Seek from current position. */
+# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+# define z_off_t long
+#endif
+
+#if defined(__OS400__)
+# define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+# define NO_vsnprintf
+# ifdef FAR
+# undef FAR
+# endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+# pragma map(deflateInit_,"DEIN")
+# pragma map(deflateInit2_,"DEIN2")
+# pragma map(deflateEnd,"DEEND")
+# pragma map(deflateBound,"DEBND")
+# pragma map(inflateInit_,"ININ")
+# pragma map(inflateInit2_,"ININ2")
+# pragma map(inflateEnd,"INEND")
+# pragma map(inflateSync,"INSY")
+# pragma map(inflateSetDictionary,"INSEDI")
+# pragma map(compressBound,"CMBND")
+# pragma map(inflate_table,"INTABL")
+# pragma map(inflate_fast,"INFA")
+# pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
--- /dev/null
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.3, July 18th, 2005
+
+ Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
+
+
+ The data format used by the zlib library is described by RFCs (Request for
+ Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+ (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.3"
+#define ZLIB_VERNUM 0x1230
+
+/*
+ The 'zlib' compression library provides in-memory compression and
+ decompression functions, including integrity checks of the uncompressed
+ data. This version of the library supports only one compression method
+ (deflation) but other algorithms will be added later and will have the same
+ stream interface.
+
+ Compression can be done in a single step if the buffers are large
+ enough (for example if an input file is mmap'ed), or can be done by
+ repeated calls of the compression function. In the latter case, the
+ application must provide more input and/or consume the output
+ (providing more output space) before each call.
+
+ The compressed data format used by default by the in-memory functions is
+ the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+ around a deflate stream, which is itself documented in RFC 1951.
+
+ The library also supports reading and writing files in gzip (.gz) format
+ with an interface similar to that of stdio using the functions that start
+ with "gz". The gzip format is different from the zlib format. gzip is a
+ gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+ This library can optionally read and write gzip streams in memory as well.
+
+ The zlib format was designed to be compact and fast for use in memory
+ and on communications channels. The gzip format was designed for single-
+ file compression on file systems, has a larger header than zlib to maintain
+ directory information, and uses a different, slower check method than zlib.
+
+ The library does not install any signal handler. The decoder checks
+ the consistency of the compressed data, so the library should never
+ crash even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void (*free_func) OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+ Bytef *next_in; /* next input byte */
+ uInt avail_in; /* number of bytes available at next_in */
+ uLong total_in; /* total nb of input bytes read so far */
+
+ Bytef *next_out; /* next output byte should be put there */
+ uInt avail_out; /* remaining free space at next_out */
+ uLong total_out; /* total nb of bytes output so far */
+
+ char *msg; /* last error message, NULL if no error */
+ struct internal_state FAR *state; /* not visible by applications */
+
+ alloc_func zalloc; /* used to allocate the internal state */
+ free_func zfree; /* used to free the internal state */
+ voidpf opaque; /* private data object passed to zalloc and zfree */
+
+ int data_type; /* best guess about the data type: binary or text */
+ uLong adler; /* adler32 value of the uncompressed data */
+ uLong reserved; /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+ gzip header information passed to and from zlib routines. See RFC 1952
+ for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+ int text; /* true if compressed data believed to be text */
+ uLong time; /* modification time */
+ int xflags; /* extra flags (not used when writing a gzip file) */
+ int os; /* operating system */
+ Bytef *extra; /* pointer to extra field or Z_NULL if none */
+ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */
+ uInt extra_max; /* space at extra (only when reading header) */
+ Bytef *name; /* pointer to zero-terminated file name or Z_NULL */
+ uInt name_max; /* space at name (only when reading header) */
+ Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */
+ uInt comm_max; /* space at comment (only when reading header) */
+ int hcrc; /* true if there was or will be a header crc */
+ int done; /* true when done reading gzip header (not used
+ when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+ The application must update next_in and avail_in when avail_in has
+ dropped to zero. It must update next_out and avail_out when avail_out
+ has dropped to zero. The application must initialize zalloc, zfree and
+ opaque before calling the init function. All other fields are set by the
+ compression library and must not be updated by the application.
+
+ The opaque value provided by the application will be passed as the first
+ parameter for calls of zalloc and zfree. This can be useful for custom
+ memory management. The compression library attaches no meaning to the
+ opaque value.
+
+ zalloc must return Z_NULL if there is not enough memory for the object.
+ If zlib is used in a multi-threaded application, zalloc and zfree must be
+ thread safe.
+
+ On 16-bit systems, the functions zalloc and zfree must be able to allocate
+ exactly 65536 bytes, but will not be required to allocate more than this
+ if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+ pointers returned by zalloc for objects of exactly 65536 bytes *must*
+ have their offset normalized to zero. The default allocation function
+ provided by this library ensures this (see zutil.c). To reduce memory
+ requirements and avoid any allocation of 64K objects, at the expense of
+ compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+ The fields total_in and total_out can be used for statistics or
+ progress reports. After compression, total_in holds the total size of
+ the uncompressed data and may be saved for use in the decompressor
+ (particularly if the decompressor wants to decompress everything in
+ a single step).
+*/
+
+ /* constants */
+
+#define Z_NO_FLUSH 0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH 2
+#define Z_FULL_FLUSH 3
+#define Z_FINISH 4
+#define Z_BLOCK 5
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK 0
+#define Z_STREAM_END 1
+#define Z_NEED_DICT 2
+#define Z_ERRNO (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR (-3)
+#define Z_MEM_ERROR (-4)
+#define Z_BUF_ERROR (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION 0
+#define Z_BEST_SPEED 1
+#define Z_BEST_COMPRESSION 9
+#define Z_DEFAULT_COMPRESSION (-1)
+/* compression levels */
+
+#define Z_FILTERED 1
+#define Z_HUFFMAN_ONLY 2
+#define Z_RLE 3
+#define Z_FIXED 4
+#define Z_DEFAULT_STRATEGY 0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY 0
+#define Z_TEXT 1
+#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN 2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED 8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+ /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+ If the first character differs, the library code actually used is
+ not compatible with the zlib.h header file used by the application.
+ This check is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+ Initializes the internal stream state for compression. The fields
+ zalloc, zfree and opaque must be initialized before by the caller.
+ If zalloc and zfree are set to Z_NULL, deflateInit updates them to
+ use default allocation functions.
+
+ The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+ 1 gives best speed, 9 gives best compression, 0 gives no compression at
+ all (the input data is simply copied a block at a time).
+ Z_DEFAULT_COMPRESSION requests a default compromise between speed and
+ compression (currently equivalent to level 6).
+
+ deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if level is not a valid compression level,
+ Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+ with the version assumed by the caller (ZLIB_VERSION).
+ msg is set to null if there is no error message. deflateInit does not
+ perform any compression: this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+ deflate compresses as much data as possible, and stops when the input
+ buffer becomes empty or the output buffer becomes full. It may introduce some
+ output latency (reading input without producing any output) except when
+ forced to flush.
+
+ The detailed semantics are as follows. deflate performs one or both of the
+ following actions:
+
+ - Compress more input starting at next_in and update next_in and avail_in
+ accordingly. If not all input can be processed (because there is not
+ enough room in the output buffer), next_in and avail_in are updated and
+ processing will resume at this point for the next call of deflate().
+
+ - Provide more output starting at next_out and update next_out and avail_out
+ accordingly. This action is forced if the parameter flush is non zero.
+ Forcing flush frequently degrades the compression ratio, so this parameter
+ should be set only when necessary (in interactive applications).
+ Some output may be provided even if flush is not set.
+
+ Before the call of deflate(), the application should ensure that at least
+ one of the actions is possible, by providing more input and/or consuming
+ more output, and updating avail_in or avail_out accordingly; avail_out
+ should never be zero before the call. The application can consume the
+ compressed output when it wants, for example when the output buffer is full
+ (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
+ and with zero avail_out, it must be called again after making room in the
+ output buffer because there might be more output pending.
+
+ Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+ decide how much data to accumualte before producing output, in order to
+ maximize compression.
+
+ If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+ flushed to the output buffer and the output is aligned on a byte boundary, so
+ that the decompressor can get all input data available so far. (In particular
+ avail_in is zero after the call if enough output space has been provided
+ before the call.) Flushing may degrade compression for some compression
+ algorithms and so it should be used only when necessary.
+
+ If flush is set to Z_FULL_FLUSH, all output is flushed as with
+ Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+ restart from this point if previous compressed data has been damaged or if
+ random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
+ compression.
+
+ If deflate returns with avail_out == 0, this function must be called again
+ with the same value of the flush parameter and more output space (updated
+ avail_out), until the flush is complete (deflate returns with non-zero
+ avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+ avail_out is greater than six to avoid repeated flush markers due to
+ avail_out == 0 on return.
+
+ If the parameter flush is set to Z_FINISH, pending input is processed,
+ pending output is flushed and deflate returns with Z_STREAM_END if there
+ was enough output space; if deflate returns with Z_OK, this function must be
+ called again with Z_FINISH and more output space (updated avail_out) but no
+ more input data, until it returns with Z_STREAM_END or an error. After
+ deflate has returned Z_STREAM_END, the only possible operations on the
+ stream are deflateReset or deflateEnd.
+
+ Z_FINISH can be used immediately after deflateInit if all the compression
+ is to be done in a single step. In this case, avail_out must be at least
+ the value returned by deflateBound (see below). If deflate does not return
+ Z_STREAM_END, then it must be called again as described above.
+
+ deflate() sets strm->adler to the adler32 checksum of all input read
+ so far (that is, total_in bytes).
+
+ deflate() may update strm->data_type if it can make a good guess about
+ the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
+ binary. This field is only for information purposes and does not affect
+ the compression algorithm in any manner.
+
+ deflate() returns Z_OK if some progress has been made (more input
+ processed or more output produced), Z_STREAM_END if all input has been
+ consumed and all output has been produced (only when flush is set to
+ Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+ if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
+ (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
+ fatal, and deflate() can be called again with more input and more output
+ space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+ All dynamically allocated data structures for this stream are freed.
+ This function discards any unprocessed input and does not flush any
+ pending output.
+
+ deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+ stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+ prematurely (some input or output was discarded). In the error case,
+ msg may be set but then points to a static string (which must not be
+ deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+ Initializes the internal stream state for decompression. The fields
+ next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+ the caller. If next_in is not Z_NULL and avail_in is large enough (the exact
+ value depends on the compression method), inflateInit determines the
+ compression method from the zlib header and allocates all data structures
+ accordingly; otherwise the allocation will be deferred to the first call of
+ inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+ use default allocation functions.
+
+ inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+ version assumed by the caller. msg is set to null if there is no error
+ message. inflateInit does not perform any decompression apart from reading
+ the zlib header if present: this will be done by inflate(). (So next_in and
+ avail_in may be modified, but next_out and avail_out are unchanged.)
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+ inflate decompresses as much data as possible, and stops when the input
+ buffer becomes empty or the output buffer becomes full. It may introduce
+ some output latency (reading input without producing any output) except when
+ forced to flush.
+
+ The detailed semantics are as follows. inflate performs one or both of the
+ following actions:
+
+ - Decompress more input starting at next_in and update next_in and avail_in
+ accordingly. If not all input can be processed (because there is not
+ enough room in the output buffer), next_in is updated and processing
+ will resume at this point for the next call of inflate().
+
+ - Provide more output starting at next_out and update next_out and avail_out
+ accordingly. inflate() provides as much output as possible, until there
+ is no more input data or no more space in the output buffer (see below
+ about the flush parameter).
+
+ Before the call of inflate(), the application should ensure that at least
+ one of the actions is possible, by providing more input and/or consuming
+ more output, and updating the next_* and avail_* values accordingly.
+ The application can consume the uncompressed output when it wants, for
+ example when the output buffer is full (avail_out == 0), or after each
+ call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+ must be called again after making room in the output buffer because there
+ might be more output pending.
+
+ The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
+ Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
+ output as possible to the output buffer. Z_BLOCK requests that inflate() stop
+ if and when it gets to the next deflate block boundary. When decoding the
+ zlib or gzip format, this will cause inflate() to return immediately after
+ the header and before the first block. When doing a raw inflate, inflate()
+ will go ahead and process the first block, and will return when it gets to
+ the end of that block, or when it runs out of data.
+
+ The Z_BLOCK option assists in appending to or combining deflate streams.
+ Also to assist in this, on return inflate() will set strm->data_type to the
+ number of unused bits in the last byte taken from strm->next_in, plus 64
+ if inflate() is currently decoding the last block in the deflate stream,
+ plus 128 if inflate() returned immediately after decoding an end-of-block
+ code or decoding the complete header up to just before the first byte of the
+ deflate stream. The end-of-block will not be indicated until all of the
+ uncompressed data from that block has been written to strm->next_out. The
+ number of unused bits may in general be greater than seven, except when
+ bit 7 of data_type is set, in which case the number of unused bits will be
+ less than eight.
+
+ inflate() should normally be called until it returns Z_STREAM_END or an
+ error. However if all decompression is to be performed in a single step
+ (a single call of inflate), the parameter flush should be set to
+ Z_FINISH. In this case all pending input is processed and all pending
+ output is flushed; avail_out must be large enough to hold all the
+ uncompressed data. (The size of the uncompressed data may have been saved
+ by the compressor for this purpose.) The next operation on this stream must
+ be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+ is never required, but can be used to inform inflate that a faster approach
+ may be used for the single inflate() call.
+
+ In this implementation, inflate() always flushes as much output as
+ possible to the output buffer, and always uses the faster approach on the
+ first call. So the only effect of the flush parameter in this implementation
+ is on the return value of inflate(), as noted below, or when it returns early
+ because Z_BLOCK is used.
+
+ If a preset dictionary is needed after this call (see inflateSetDictionary
+ below), inflate sets strm->adler to the adler32 checksum of the dictionary
+ chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+ strm->adler to the adler32 checksum of all output produced so far (that is,
+ total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+ below. At the end of the stream, inflate() checks that its computed adler32
+ checksum is equal to that saved by the compressor and returns Z_STREAM_END
+ only if the checksum is correct.
+
+ inflate() will decompress and check either zlib-wrapped or gzip-wrapped
+ deflate data. The header type is detected automatically. Any information
+ contained in the gzip header is not retained, so applications that need that
+ information should instead use raw inflate, see inflateInit2() below, or
+ inflateBack() and perform their own processing of the gzip header and
+ trailer.
+
+ inflate() returns Z_OK if some progress has been made (more input processed
+ or more output produced), Z_STREAM_END if the end of the compressed data has
+ been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+ preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+ corrupted (input stream not conforming to the zlib format or incorrect check
+ value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+ if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
+ Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+ output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+ inflate() can be called again with more input and more output space to
+ continue decompressing. If Z_DATA_ERROR is returned, the application may then
+ call inflateSync() to look for a good compression block if a partial recovery
+ of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+ All dynamically allocated data structures for this stream are freed.
+ This function discards any unprocessed input and does not flush any
+ pending output.
+
+ inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+ was inconsistent. In the error case, msg may be set but then points to a
+ static string (which must not be deallocated).
+*/
+
+ /* Advanced functions */
+
+/*
+ The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+ int level,
+ int method,
+ int windowBits,
+ int memLevel,
+ int strategy));
+
+ This is another version of deflateInit with more compression options. The
+ fields next_in, zalloc, zfree and opaque must be initialized before by
+ the caller.
+
+ The method parameter is the compression method. It must be Z_DEFLATED in
+ this version of the library.
+
+ The windowBits parameter is the base two logarithm of the window size
+ (the size of the history buffer). It should be in the range 8..15 for this
+ version of the library. Larger values of this parameter result in better
+ compression at the expense of memory usage. The default value is 15 if
+ deflateInit is used instead.
+
+ windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
+ determines the window size. deflate() will then generate raw deflate data
+ with no zlib header or trailer, and will not compute an adler32 check value.
+
+ windowBits can also be greater than 15 for optional gzip encoding. Add
+ 16 to windowBits to write a simple gzip header and trailer around the
+ compressed data instead of a zlib wrapper. The gzip header will have no
+ file name, no extra data, no comment, no modification time (set to zero),
+ no header crc, and the operating system will be set to 255 (unknown). If a
+ gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+ The memLevel parameter specifies how much memory should be allocated
+ for the internal compression state. memLevel=1 uses minimum memory but
+ is slow and reduces compression ratio; memLevel=9 uses maximum memory
+ for optimal speed. The default value is 8. See zconf.h for total memory
+ usage as a function of windowBits and memLevel.
+
+ The strategy parameter is used to tune the compression algorithm. Use the
+ value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+ filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+ string match), or Z_RLE to limit match distances to one (run-length
+ encoding). Filtered data consists mostly of small values with a somewhat
+ random distribution. In this case, the compression algorithm is tuned to
+ compress them better. The effect of Z_FILTERED is to force more Huffman
+ coding and less string matching; it is somewhat intermediate between
+ Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
+ Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
+ parameter only affects the compression ratio but not the correctness of the
+ compressed output even if it is not set appropriately. Z_FIXED prevents the
+ use of dynamic Huffman codes, allowing for a simpler decoder for special
+ applications.
+
+ deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
+ method). msg is set to null if there is no error message. deflateInit2 does
+ not perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength));
+/*
+ Initializes the compression dictionary from the given byte sequence
+ without producing any compressed output. This function must be called
+ immediately after deflateInit, deflateInit2 or deflateReset, before any
+ call of deflate. The compressor and decompressor must use exactly the same
+ dictionary (see inflateSetDictionary).
+
+ The dictionary should consist of strings (byte sequences) that are likely
+ to be encountered later in the data to be compressed, with the most commonly
+ used strings preferably put towards the end of the dictionary. Using a
+ dictionary is most useful when the data to be compressed is short and can be
+ predicted with good accuracy; the data can then be compressed better than
+ with the default empty dictionary.
+
+ Depending on the size of the compression data structures selected by
+ deflateInit or deflateInit2, a part of the dictionary may in effect be
+ discarded, for example if the dictionary is larger than the window size in
+ deflate or deflate2. Thus the strings most likely to be useful should be
+ put at the end of the dictionary, not at the front. In addition, the
+ current implementation of deflate will use at most the window size minus
+ 262 bytes of the provided dictionary.
+
+ Upon return of this function, strm->adler is set to the adler32 value
+ of the dictionary; the decompressor may later use this value to determine
+ which dictionary has been used by the compressor. (The adler32 value
+ applies to the whole dictionary even if only a subset of the dictionary is
+ actually used by the compressor.) If a raw deflate was requested, then the
+ adler32 value is not computed and strm->adler is not set.
+
+ deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+ parameter is invalid (such as NULL dictionary) or the stream state is
+ inconsistent (for example if deflate has already been called for this stream
+ or if the compression method is bsort). deflateSetDictionary does not
+ perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+ z_streamp source));
+/*
+ Sets the destination stream as a complete copy of the source stream.
+
+ This function can be useful when several compression strategies will be
+ tried, for example when there are several ways of pre-processing the input
+ data with a filter. The streams that will be discarded should then be freed
+ by calling deflateEnd. Note that deflateCopy duplicates the internal
+ compression state which can be quite large, so this strategy is slow and
+ can consume lots of memory.
+
+ deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+ (such as zalloc being NULL). msg is left unchanged in both source and
+ destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+ This function is equivalent to deflateEnd followed by deflateInit,
+ but does not free and reallocate all the internal compression state.
+ The stream will keep the same compression level and any other attributes
+ that may have been set by deflateInit2.
+
+ deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+ int level,
+ int strategy));
+/*
+ Dynamically update the compression level and compression strategy. The
+ interpretation of level and strategy is as in deflateInit2. This can be
+ used to switch between compression and straight copy of the input data, or
+ to switch to a different kind of input data requiring a different
+ strategy. If the compression level is changed, the input available so far
+ is compressed with the old level (and may be flushed); the new level will
+ take effect only at the next call of deflate().
+
+ Before the call of deflateParams, the stream state must be set as for
+ a call of deflate(), since the currently available input may have to
+ be compressed and flushed. In particular, strm->avail_out must be non-zero.
+
+ deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+ stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
+ if strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+ int good_length,
+ int max_lazy,
+ int nice_length,
+ int max_chain));
+/*
+ Fine tune deflate's internal compression parameters. This should only be
+ used by someone who understands the algorithm used by zlib's deflate for
+ searching for the best matching string, and even then only by the most
+ fanatic optimizer trying to squeeze out the last compressed bit for their
+ specific input data. Read the deflate.c source code for the meaning of the
+ max_lazy, good_length, nice_length, and max_chain parameters.
+
+ deflateTune() can be called after deflateInit() or deflateInit2(), and
+ returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+ uLong sourceLen));
+/*
+ deflateBound() returns an upper bound on the compressed size after
+ deflation of sourceLen bytes. It must be called after deflateInit()
+ or deflateInit2(). This would be used to allocate an output buffer
+ for deflation in a single pass, and so would be called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+ int bits,
+ int value));
+/*
+ deflatePrime() inserts bits in the deflate output stream. The intent
+ is that this function is used to start off the deflate output with the
+ bits leftover from a previous deflate stream when appending to it. As such,
+ this function can only be used for raw deflate, and must be used before the
+ first deflate() call after a deflateInit2() or deflateReset(). bits must be
+ less than or equal to 16, and that many of the least significant bits of
+ value will be inserted in the output.
+
+ deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+ gz_headerp head));
+/*
+ deflateSetHeader() provides gzip header information for when a gzip
+ stream is requested by deflateInit2(). deflateSetHeader() may be called
+ after deflateInit2() or deflateReset() and before the first call of
+ deflate(). The text, time, os, extra field, name, and comment information
+ in the provided gz_header structure are written to the gzip header (xflag is
+ ignored -- the extra flags are set according to the compression level). The
+ caller must assure that, if not Z_NULL, name and comment are terminated with
+ a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+ available there. If hcrc is true, a gzip header crc is included. Note that
+ the current versions of the command-line version of gzip (up through version
+ 1.3.x) do not support header crc's, and will report that it is a "multi-part
+ gzip file" and give up.
+
+ If deflateSetHeader is not used, the default gzip header has text false,
+ the time set to zero, and os set to 255, with no extra, name, or comment
+ fields. The gzip header is returned to the default state by deflateReset().
+
+ deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+ int windowBits));
+
+ This is another version of inflateInit with an extra parameter. The
+ fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+ before by the caller.
+
+ The windowBits parameter is the base two logarithm of the maximum window
+ size (the size of the history buffer). It should be in the range 8..15 for
+ this version of the library. The default value is 15 if inflateInit is used
+ instead. windowBits must be greater than or equal to the windowBits value
+ provided to deflateInit2() while compressing, or it must be equal to 15 if
+ deflateInit2() was not used. If a compressed stream with a larger window
+ size is given as input, inflate() will return with the error code
+ Z_DATA_ERROR instead of trying to allocate a larger window.
+
+ windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
+ determines the window size. inflate() will then process raw deflate data,
+ not looking for a zlib or gzip header, not generating a check value, and not
+ looking for any check values for comparison at the end of the stream. This
+ is for use with other formats that use the deflate compressed data format
+ such as zip. Those formats provide their own check values. If a custom
+ format is developed using the raw deflate format for compressed data, it is
+ recommended that a check value such as an adler32 or a crc32 be applied to
+ the uncompressed data as is done in the zlib, gzip, and zip formats. For
+ most applications, the zlib format should be used as is. Note that comments
+ above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+ windowBits can also be greater than 15 for optional gzip decoding. Add
+ 32 to windowBits to enable zlib and gzip decoding with automatic header
+ detection, or add 16 to decode only the gzip format (the zlib format will
+ return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is
+ a crc32 instead of an adler32.
+
+ inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
+ is set to null if there is no error message. inflateInit2 does not perform
+ any decompression apart from reading the zlib header if present: this will
+ be done by inflate(). (So next_in and avail_in may be modified, but next_out
+ and avail_out are unchanged.)
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+ const Bytef *dictionary,
+ uInt dictLength));
+/*
+ Initializes the decompression dictionary from the given uncompressed byte
+ sequence. This function must be called immediately after a call of inflate,
+ if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
+ can be determined from the adler32 value returned by that call of inflate.
+ The compressor and decompressor must use exactly the same dictionary (see
+ deflateSetDictionary). For raw inflate, this function can be called
+ immediately after inflateInit2() or inflateReset() and before any call of
+ inflate() to set the dictionary. The application must insure that the
+ dictionary that was used for compression is provided.
+
+ inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+ parameter is invalid (such as NULL dictionary) or the stream state is
+ inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+ expected one (incorrect adler32 value). inflateSetDictionary does not
+ perform any decompression: this will be done by subsequent calls of
+ inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+ Skips invalid compressed data until a full flush point (see above the
+ description of deflate with Z_FULL_FLUSH) can be found, or until all
+ available input is skipped. No output is provided.
+
+ inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+ if no more input was provided, Z_DATA_ERROR if no flush point has been found,
+ or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+ case, the application may save the current current value of total_in which
+ indicates where valid compressed data was found. In the error case, the
+ application may repeatedly call inflateSync, providing more input each time,
+ until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+ z_streamp source));
+/*
+ Sets the destination stream as a complete copy of the source stream.
+
+ This function can be useful when randomly accessing a large stream. The
+ first pass through the stream can periodically record the inflate state,
+ allowing restarting inflate at those points when randomly accessing the
+ stream.
+
+ inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+ (such as zalloc being NULL). msg is left unchanged in both source and
+ destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+ This function is equivalent to inflateEnd followed by inflateInit,
+ but does not free and reallocate all the internal decompression state.
+ The stream will keep attributes that may have been set by inflateInit2.
+
+ inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+ int bits,
+ int value));
+/*
+ This function inserts bits in the inflate input stream. The intent is
+ that this function is used to start inflating at a bit position in the
+ middle of a byte. The provided bits will be used before any bytes are used
+ from next_in. This function should only be used with raw inflate, and
+ should be used before the first inflate() call after inflateInit2() or
+ inflateReset(). bits must be less than or equal to 16, and that many of the
+ least significant bits of value will be inserted in the input.
+
+ inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+ gz_headerp head));
+/*
+ inflateGetHeader() requests that gzip header information be stored in the
+ provided gz_header structure. inflateGetHeader() may be called after
+ inflateInit2() or inflateReset(), and before the first call of inflate().
+ As inflate() processes the gzip stream, head->done is zero until the header
+ is completed, at which time head->done is set to one. If a zlib stream is
+ being decoded, then head->done is set to -1 to indicate that there will be
+ no gzip header information forthcoming. Note that Z_BLOCK can be used to
+ force inflate() to return immediately after header processing is complete
+ and before any actual data is decompressed.
+
+ The text, time, xflags, and os fields are filled in with the gzip header
+ contents. hcrc is set to true if there is a header CRC. (The header CRC
+ was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+ contains the maximum number of bytes to write to extra. Once done is true,
+ extra_len contains the actual extra field length, and extra contains the
+ extra field, or that field truncated if extra_max is less than extra_len.
+ If name is not Z_NULL, then up to name_max characters are written there,
+ terminated with a zero unless the length is greater than name_max. If
+ comment is not Z_NULL, then up to comm_max characters are written there,
+ terminated with a zero unless the length is greater than comm_max. When
+ any of extra, name, or comment are not Z_NULL and the respective field is
+ not present in the header, then that field is set to Z_NULL to signal its
+ absence. This allows the use of deflateSetHeader() with the returned
+ structure to duplicate the header. However if those fields are set to
+ allocated memory, then the application will need to save those pointers
+ elsewhere so that they can be eventually freed.
+
+ If inflateGetHeader is not used, then the header information is simply
+ discarded. The header is always checked for validity, including the header
+ CRC if present. inflateReset() will reset the process to discard the header
+ information. The application would need to call inflateGetHeader() again to
+ retrieve the header from the next gzip stream.
+
+ inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+ stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+ unsigned char FAR *window));
+
+ Initialize the internal stream state for decompression using inflateBack()
+ calls. The fields zalloc, zfree and opaque in strm must be initialized
+ before the call. If zalloc and zfree are Z_NULL, then the default library-
+ derived memory allocation routines are used. windowBits is the base two
+ logarithm of the window size, in the range 8..15. window is a caller
+ supplied buffer of that size. Except for special applications where it is
+ assured that deflate was used with small window sizes, windowBits must be 15
+ and a 32K byte window must be supplied to be able to decompress general
+ deflate streams.
+
+ See inflateBack() for the usage of these routines.
+
+ inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+ the paramaters are invalid, Z_MEM_ERROR if the internal state could not
+ be allocated, or Z_VERSION_ERROR if the version of the library does not
+ match the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+ in_func in, void FAR *in_desc,
+ out_func out, void FAR *out_desc));
+/*
+ inflateBack() does a raw inflate with a single call using a call-back
+ interface for input and output. This is more efficient than inflate() for
+ file i/o applications in that it avoids copying between the output and the
+ sliding window by simply making the window itself the output buffer. This
+ function trusts the application to not change the output buffer passed by
+ the output function, at least until inflateBack() returns.
+
+ inflateBackInit() must be called first to allocate the internal state
+ and to initialize the state with the user-provided window buffer.
+ inflateBack() may then be used multiple times to inflate a complete, raw
+ deflate stream with each call. inflateBackEnd() is then called to free
+ the allocated state.
+
+ A raw deflate stream is one with no zlib or gzip header or trailer.
+ This routine would normally be used in a utility that reads zip or gzip
+ files and writes out uncompressed files. The utility would decode the
+ header and process the trailer on its own, hence this routine expects
+ only the raw deflate stream to decompress. This is different from the
+ normal behavior of inflate(), which expects either a zlib or gzip header and
+ trailer around the deflate stream.
+
+ inflateBack() uses two subroutines supplied by the caller that are then
+ called by inflateBack() for input and output. inflateBack() calls those
+ routines until it reads a complete deflate stream and writes out all of the
+ uncompressed data, or until it encounters an error. The function's
+ parameters and return types are defined above in the in_func and out_func
+ typedefs. inflateBack() will call in(in_desc, &buf) which should return the
+ number of bytes of provided input, and a pointer to that input in buf. If
+ there is no input available, in() must return zero--buf is ignored in that
+ case--and inflateBack() will return a buffer error. inflateBack() will call
+ out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
+ should return zero on success, or non-zero on failure. If out() returns
+ non-zero, inflateBack() will return with an error. Neither in() nor out()
+ are permitted to change the contents of the window provided to
+ inflateBackInit(), which is also the buffer that out() uses to write from.
+ The length written by out() will be at most the window size. Any non-zero
+ amount of input may be provided by in().
+
+ For convenience, inflateBack() can be provided input on the first call by
+ setting strm->next_in and strm->avail_in. If that input is exhausted, then
+ in() will be called. Therefore strm->next_in must be initialized before
+ calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
+ immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in
+ must also be initialized, and then if strm->avail_in is not zero, input will
+ initially be taken from strm->next_in[0 .. strm->avail_in - 1].
+
+ The in_desc and out_desc parameters of inflateBack() is passed as the
+ first parameter of in() and out() respectively when they are called. These
+ descriptors can be optionally used to pass any information that the caller-
+ supplied in() and out() functions need to do their job.
+
+ On return, inflateBack() will set strm->next_in and strm->avail_in to
+ pass back any unused input that was provided by the last in() call. The
+ return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+ if in() or out() returned an error, Z_DATA_ERROR if there was a format
+ error in the deflate stream (in which case strm->msg is set to indicate the
+ nature of the error), or Z_STREAM_ERROR if the stream was not properly
+ initialized. In the case of Z_BUF_ERROR, an input or output error can be
+ distinguished using strm->next_in which will be Z_NULL only if in() returned
+ an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
+ out() returning non-zero. (in() will always be called before out(), so
+ strm->next_in is assured to be defined if out() returns non-zero.) Note
+ that inflateBack() cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+ All memory allocated by inflateBackInit() is freed.
+
+ inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+ state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+ Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+ 1.0: size of uInt
+ 3.2: size of uLong
+ 5.4: size of voidpf (pointer)
+ 7.6: size of z_off_t
+
+ Compiler, assembler, and debug options:
+ 8: DEBUG
+ 9: ASMV or ASMINF -- use ASM code
+ 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+ 11: 0 (reserved)
+
+ One-time table building (smaller code, but not thread-safe if true):
+ 12: BUILDFIXED -- build static block decoding tables when needed
+ 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+ 14,15: 0 (reserved)
+
+ Library content (indicates missing functionality):
+ 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+ deflate code when not needed)
+ 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+ and decode gzip streams (to avoid linking crc code)
+ 18-19: 0 (reserved)
+
+ Operation variations (changes in library functionality):
+ 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+ 21: FASTEST -- deflate algorithm with only one, lowest compression level
+ 22,23: 0 (reserved)
+
+ The sprintf variant used by gzprintf (zero is best):
+ 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+ 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+ 26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+ Remainder:
+ 27-31: 0 (reserved)
+ */
+
+
+ /* utility functions */
+
+/*
+ The following utility functions are implemented on top of the
+ basic stream-oriented functions. To simplify the interface, some
+ default options are assumed (compression level and memory usage,
+ standard memory allocation functions). The source code of these
+ utility functions can easily be modified if you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen));
+/*
+ Compresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be at least the value returned
+ by compressBound(sourceLen). Upon exit, destLen is the actual size of the
+ compressed buffer.
+ This function can be used to compress a whole file at once if the
+ input file is mmap'ed.
+ compress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen,
+ int level));
+/*
+ Compresses the source buffer into the destination buffer. The level
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
+ length of the source buffer. Upon entry, destLen is the total size of the
+ destination buffer, which must be at least the value returned by
+ compressBound(sourceLen). Upon exit, destLen is the actual size of the
+ compressed buffer.
+
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+ Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+ compressBound() returns an upper bound on the compressed size after
+ compress() or compress2() on sourceLen bytes. It would be used before
+ a compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen));
+/*
+ Decompresses the source buffer into the destination buffer. sourceLen is
+ the byte length of the source buffer. Upon entry, destLen is the total
+ size of the destination buffer, which must be large enough to hold the
+ entire uncompressed data. (The size of the uncompressed data must have
+ been saved previously by the compressor and transmitted to the decompressor
+ by some mechanism outside the scope of this compression library.)
+ Upon exit, destLen is the actual size of the compressed buffer.
+ This function can be used to decompress a whole file at once if the
+ input file is mmap'ed.
+
+ uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+ enough memory, Z_BUF_ERROR if there was not enough room in the output
+ buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+/*
+ Opens a gzip (.gz) file for reading or writing. The mode parameter
+ is as in fopen ("rb" or "wb") but can also include a compression level
+ ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+ Huffman only compression as in "wb1h", or 'R' for run-length encoding
+ as in "wb1R". (See the description of deflateInit2 for more information
+ about the strategy parameter.)
+
+ gzopen can be used to read a file which is not in gzip format; in this
+ case gzread will directly read from the file without decompression.
+
+ gzopen returns NULL if the file could not be opened or if there was
+ insufficient memory to allocate the (de)compression state; errno
+ can be checked to distinguish the two cases (if errno is zero, the
+ zlib error is Z_MEM_ERROR). */
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+ gzdopen() associates a gzFile with the file descriptor fd. File
+ descriptors are obtained from calls like open, dup, creat, pipe or
+ fileno (in the file has been previously opened with fopen).
+ The mode parameter is as in gzopen.
+ The next call of gzclose on the returned gzFile will also close the
+ file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+ descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+ gzdopen returns NULL if there was insufficient memory to allocate
+ the (de)compression state.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+ Dynamically update the compression level or strategy. See the description
+ of deflateInit2 for the meaning of these parameters.
+ gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+ opened for writing.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+ Reads the given number of uncompressed bytes from the compressed file.
+ If the input file was not in gzip format, gzread copies the given number
+ of bytes into the buffer.
+ gzread returns the number of uncompressed bytes actually read (0 for
+ end of file, -1 for error). */
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+ voidpc buf, unsigned len));
+/*
+ Writes the given number of uncompressed bytes into the compressed file.
+ gzwrite returns the number of uncompressed bytes actually written
+ (0 in case of error).
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+/*
+ Converts, formats, and writes the args to the compressed file under
+ control of the format string, as in fprintf. gzprintf returns the number of
+ uncompressed bytes actually written (0 in case of error). The number of
+ uncompressed bytes written is limited to 4095. The caller should assure that
+ this limit is not exceeded. If it is exceeded, then gzprintf() will return
+ return an error (0) with nothing written. In this case, there may also be a
+ buffer overflow with unpredictable consequences, which is possible only if
+ zlib was compiled with the insecure functions sprintf() or vsprintf()
+ because the secure snprintf() or vsnprintf() functions were not available.
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+ Writes the given null-terminated string to the compressed file, excluding
+ the terminating null character.
+ gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+ Reads bytes from the compressed file until len-1 characters are read, or
+ a newline character is read and transferred to buf, or an end-of-file
+ condition is encountered. The string is then terminated with a null
+ character.
+ gzgets returns buf, or Z_NULL in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+ Writes c, converted to an unsigned char, into the compressed file.
+ gzputc returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+ Reads one byte from the compressed file. gzgetc returns this byte
+ or -1 in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+ Push one character back onto the stream to be read again later.
+ Only one character of push-back is allowed. gzungetc() returns the
+ character pushed, or -1 on failure. gzungetc() will fail if a
+ character has been pushed but not read yet, or if c is -1. The pushed
+ character will be discarded if the stream is repositioned with gzseek()
+ or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+ Flushes all pending output into the compressed file. The parameter
+ flush is as in the deflate() function. The return value is the zlib
+ error number (see function gzerror below). gzflush returns Z_OK if
+ the flush parameter is Z_FINISH and all output could be flushed.
+ gzflush should be called only when strictly necessary because it can
+ degrade compression.
+*/
+
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+ z_off_t offset, int whence));
+/*
+ Sets the starting position for the next gzread or gzwrite on the
+ given compressed file. The offset represents a number of bytes in the
+ uncompressed data stream. The whence parameter is defined as in lseek(2);
+ the value SEEK_END is not supported.
+ If the file is opened for reading, this function is emulated but can be
+ extremely slow. If the file is opened for writing, only forward seeks are
+ supported; gzseek then compresses a sequence of zeroes up to the new
+ starting position.
+
+ gzseek returns the resulting offset location as measured in bytes from
+ the beginning of the uncompressed stream, or -1 in case of error, in
+ particular if the file is opened for writing and the new starting position
+ would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
+/*
+ Rewinds the given file. This function is supported only for reading.
+
+ gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
+/*
+ Returns the starting position for the next gzread or gzwrite on the
+ given compressed file. This position represents a number of bytes in the
+ uncompressed data stream.
+
+ gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+ Returns 1 when EOF has previously been detected reading the given
+ input stream, otherwise zero.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+ Returns 1 if file is being read directly without decompression, otherwise
+ zero.
+*/
+
+ZEXTERN int ZEXPORT gzclose OF((gzFile file));
+/*
+ Flushes all pending output if necessary, closes the compressed file
+ and deallocates all the (de)compression state. The return value is the zlib
+ error number (see function gzerror below).
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+ Returns the error message for the last error which occurred on the
+ given compressed file. errnum is set to zlib error number. If an
+ error occurred in the file system and not in the compression library,
+ errnum is set to Z_ERRNO and the application may consult errno
+ to get the exact error code.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+ Clears the error and end-of-file flags for file. This is analogous to the
+ clearerr() function in stdio. This is useful for continuing to read a gzip
+ file that is being written concurrently.
+*/
+
+ /* checksum functions */
+
+/*
+ These functions are not related to compression but are exported
+ anyway because they might be useful in applications using the
+ compression library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+ Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+ return the updated checksum. If buf is NULL, this function returns
+ the required initial value for the checksum.
+ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+ much faster. Usage example:
+
+ uLong adler = adler32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ adler = adler32(adler, buffer, length);
+ }
+ if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+ z_off_t len2));
+/*
+ Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
+ and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+ each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
+ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
+/*
+ Update a running CRC-32 with the bytes buf[0..len-1] and return the
+ updated CRC-32. If buf is NULL, this function returns the required initial
+ value for the for the crc. Pre- and post-conditioning (one's complement) is
+ performed within this function so it shouldn't be done by the application.
+ Usage example:
+
+ uLong crc = crc32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ crc = crc32(crc, buffer, length);
+ }
+ if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+/*
+ Combine two CRC-32 check values into one. For two sequences of bytes,
+ seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+ calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32
+ check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+ len2.
+*/
+
+
+ /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
+ int windowBits, int memLevel,
+ int strategy, const char *version,
+ int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
+ const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+ unsigned char FAR *window,
+ const char *version,
+ int stream_size));
+#define deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+ struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char * ZEXPORT zError OF((int));
+ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
--- /dev/null
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+#ifndef NO_DUMMY_DECL
+struct internal_state {int dummy;}; /* for buggy compilers */
+#endif
+
+const char * const z_errmsg[10] = {
+"need dictionary", /* Z_NEED_DICT 2 */
+"stream end", /* Z_STREAM_END 1 */
+"", /* Z_OK 0 */
+"file error", /* Z_ERRNO (-1) */
+"stream error", /* Z_STREAM_ERROR (-2) */
+"data error", /* Z_DATA_ERROR (-3) */
+"insufficient memory", /* Z_MEM_ERROR (-4) */
+"buffer error", /* Z_BUF_ERROR (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+ return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+ uLong flags;
+
+ flags = 0;
+ switch (sizeof(uInt)) {
+ case 2: break;
+ case 4: flags += 1; break;
+ case 8: flags += 2; break;
+ default: flags += 3;
+ }
+ switch (sizeof(uLong)) {
+ case 2: break;
+ case 4: flags += 1 << 2; break;
+ case 8: flags += 2 << 2; break;
+ default: flags += 3 << 2;
+ }
+ switch (sizeof(voidpf)) {
+ case 2: break;
+ case 4: flags += 1 << 4; break;
+ case 8: flags += 2 << 4; break;
+ default: flags += 3 << 4;
+ }
+ switch (sizeof(z_off_t)) {
+ case 2: break;
+ case 4: flags += 1 << 6; break;
+ case 8: flags += 2 << 6; break;
+ default: flags += 3 << 6;
+ }
+#ifdef DEBUG
+ flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+ flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+ flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+ flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+ flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+ flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+ flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+ flags += 1L << 20;
+#endif
+#ifdef FASTEST
+ flags += 1L << 21;
+#endif
+#ifdef STDC
+# ifdef NO_vsnprintf
+ flags += 1L << 25;
+# ifdef HAS_vsprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_vsnprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#else
+ flags += 1L << 24;
+# ifdef NO_snprintf
+ flags += 1L << 25;
+# ifdef HAS_sprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_snprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#endif
+ return flags;
+}
+
+#ifdef DEBUG
+
+# ifndef verbose
+# define verbose 0
+# endif
+int z_verbose = verbose;
+
+void z_error (m)
+ char *m;
+{
+ fprintf(stderr, "%s\n", m);
+ exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+ int err;
+{
+ return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE)
+ /* The Microsoft C Run-Time Library for Windows CE doesn't have
+ * errno. We define it as a global variable to simplify porting.
+ * Its value is always 0 and should not be used.
+ */
+ int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+ Bytef* dest;
+ const Bytef* source;
+ uInt len;
+{
+ if (len == 0) return;
+ do {
+ *dest++ = *source++; /* ??? to be unrolled */
+ } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+ const Bytef* s1;
+ const Bytef* s2;
+ uInt len;
+{
+ uInt j;
+
+ for (j = 0; j < len; j++) {
+ if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+ }
+ return 0;
+}
+
+void zmemzero(dest, len)
+ Bytef* dest;
+ uInt len;
+{
+ if (len == 0) return;
+ do {
+ *dest++ = 0; /* ??? to be unrolled */
+ } while (--len != 0);
+}
+#endif
+
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+# define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+ voidpf org_ptr;
+ voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+ voidpf buf = opaque; /* just to make some compilers happy */
+ ulg bsize = (ulg)items*size;
+
+ /* If we allocate less than 65520 bytes, we assume that farmalloc
+ * will return a usable pointer which doesn't have to be normalized.
+ */
+ if (bsize < 65520L) {
+ buf = farmalloc(bsize);
+ if (*(ush*)&buf != 0) return buf;
+ } else {
+ buf = farmalloc(bsize + 16L);
+ }
+ if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+ table[next_ptr].org_ptr = buf;
+
+ /* Normalize the pointer to seg:0 */
+ *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+ *(ush*)&buf = 0;
+ table[next_ptr++].new_ptr = buf;
+ return buf;
+}
+
+void zcfree (voidpf opaque, voidpf ptr)
+{
+ int n;
+ if (*(ush*)&ptr != 0) { /* object < 64K */
+ farfree(ptr);
+ return;
+ }
+ /* Find the original pointer */
+ for (n = 0; n < next_ptr; n++) {
+ if (ptr != table[n].new_ptr) continue;
+
+ farfree(table[n].org_ptr);
+ while (++n < next_ptr) {
+ table[n-1] = table[n];
+ }
+ next_ptr--;
+ return;
+ }
+ ptr = opaque; /* just to make some compilers happy */
+ Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+# define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+# define _halloc halloc
+# define _hfree hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+ if (opaque) opaque = 0; /* to make compiler happy */
+ return _halloc((long)items, size);
+}
+
+void zcfree (voidpf opaque, voidpf ptr)
+{
+ if (opaque) opaque = 0; /* to make compiler happy */
+ _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp malloc OF((uInt size));
+extern voidp calloc OF((uInt items, uInt size));
+extern void free OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+ voidpf opaque;
+ unsigned items;
+ unsigned size;
+{
+ if (opaque) items += size - size; /* make compiler happy */
+ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+ (voidpf)calloc(items, size);
+}
+
+void zcfree (opaque, ptr)
+ voidpf opaque;
+ voidpf ptr;
+{
+ free(ptr);
+ if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
--- /dev/null
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#ifdef STDC
+# ifndef _WIN32_WCE
+# include <stddef.h>
+# endif
+# include <string.h>
+# include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+# ifdef _WIN32_WCE
+ /* The Microsoft C Run-Time Library for Windows CE doesn't have
+ * errno. We define it as a global variable to simplify porting.
+ * Its value is always 0 and should not be used. We rename it to
+ * avoid conflict with other libraries that use the same workaround.
+ */
+# define errno z_errno
+# endif
+ extern int errno;
+#else
+# ifndef _WIN32_WCE
+# include <errno.h>
+# endif
+#endif
+
+#ifndef local
+# define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long ulg;
+
+extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+ return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+ /* common constants */
+
+#ifndef DEF_WBITS
+# define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+# define DEF_MEM_LEVEL 8
+#else
+# define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES 2
+/* The three kinds of block type */
+
+#define MIN_MATCH 3
+#define MAX_MATCH 258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+ /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+# define OS_CODE 0x00
+# if defined(__TURBOC__) || defined(__BORLANDC__)
+# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+ /* Allow compilation with ANSI keywords only enabled */
+ void _Cdecl farfree( void *block );
+ void *_Cdecl farmalloc( unsigned long nbytes );
+# else
+# include <alloc.h>
+# endif
+# else /* MSC or DJGPP */
+# include <malloc.h>
+# endif
+#endif
+
+#ifdef AMIGA
+# define OS_CODE 0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+# define OS_CODE 0x02
+# define F_OPEN(name, mode) \
+ fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+# define OS_CODE 0x05
+#endif
+
+#ifdef OS2
+# define OS_CODE 0x06
+# ifdef M_I86
+ #include <malloc.h>
+# endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+# define OS_CODE 0x07
+# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+# include <unix.h> /* for fdopen */
+# else
+# ifndef fdopen
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# endif
+# endif
+#endif
+
+#ifdef TOPS20
+# define OS_CODE 0x0a
+#endif
+
+#ifdef WIN32
+# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
+# define OS_CODE 0x0b
+# endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+# define OS_CODE 0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+# if defined(_WIN32_WCE)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+# else
+# define fdopen(fd,type) _fdopen(fd,type)
+# endif
+#endif
+
+ /* common defaults */
+
+#ifndef OS_CODE
+# define OS_CODE 0x03 /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+# define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+ /* functions */
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+# ifndef HAVE_VSNPRINTF
+# define HAVE_VSNPRINTF
+# endif
+#endif
+#if defined(__CYGWIN__)
+# ifndef HAVE_VSNPRINTF
+# define HAVE_VSNPRINTF
+# endif
+#endif
+#ifndef HAVE_VSNPRINTF
+# ifdef MSDOS
+ /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+ but for now we just assume it doesn't. */
+# define NO_vsnprintf
+# endif
+# ifdef __TURBOC__
+# define NO_vsnprintf
+# endif
+# ifdef WIN32
+ /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+# if !defined(vsnprintf) && !defined(NO_vsnprintf)
+# define vsnprintf _vsnprintf
+# endif
+# endif
+# ifdef __SASC
+# define NO_vsnprintf
+# endif
+#endif
+#ifdef VMS
+# define NO_vsnprintf
+#endif
+
+#if defined(pyr)
+# define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+ * You may have to use the same strategy for Borland C (untested).
+ * The __SC__ check is for Symantec.
+ */
+# define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+# define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+# ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+# define zmemcpy _fmemcpy
+# define zmemcmp _fmemcmp
+# define zmemzero(dest, len) _fmemset(dest, 0, len)
+# else
+# define zmemcpy memcpy
+# define zmemcmp memcmp
+# define zmemzero(dest, len) memset(dest, 0, len)
+# endif
+#else
+ extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+ extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+ extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+# include <stdio.h>
+ extern int z_verbose;
+ extern void z_error OF((char *m));
+# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+# define Trace(x) {if (z_verbose>=0) fprintf x ;}
+# define Tracev(x) {if (z_verbose>0) fprintf x ;}
+# define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+# define Assert(cond,msg)
+# define Trace(x)
+# define Tracev(x)
+# define Tracevv(x)
+# define Tracec(c,x)
+# define Tracecv(c,x)
+#endif
+
+
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void zcfree OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+ (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* ZUTIL_H */
#include "logger.h"
#include "cdpmi.h"
-static void draw(void);
-
static struct video_mode *vmode;
-
+static int quit;
int main(int argc, char **argv)
{
if(key == 27) goto break_evloop;
}
+ if(quit) goto break_evloop;
+
time_msec = get_msec();
draw();
}
return status;
}
-static void draw(void)
+void game_quit(void)
{
- int i, j;
- uint16_t *pptr = fb_pixels;
-
- for(i=0; i<fb_height; i++) {
- for(j=0; j<fb_width; j++) {
- int chess = ((i >> 4) & 1) == ((j >> 4) & 1);
- *pptr++ = chess ? 0xff00 : 0x00ff;
- }
- }
-
- blit_frame(fb_pixels, 1);
+ quit = 1;
}
#include "game.h"
+#include "menuscr.h"
int fb_width, fb_height;
long fb_size;
long time_msec;
-void (*swap_buffers)(void*);
+void (*draw)(void);
+void (*key_event)(int key, int pressed);
-int game_init(int argc, char **argv)
+int init(int argc, char **argv)
{
- return 0;
-}
+ if(menu_init() == -1) {
+ return -1;
+ }
-void game_cleanup(void)
-{
-}
-
-void game_draw(void)
-{
+ draw = menu_draw;
+ key_event = menu_keyb;
+ return 0;
}
-void game_keyboard(int key, int press)
+void cleanup(void)
{
+ menu_cleanup();
}
int game_init(int argc, char **argv);
void game_cleanup(void);
-void game_draw(void);
+extern void (*draw)(void);
+extern void (*key_event)(int key, int pressed);
-void game_keyboard(int key, int press);
+void game_quit(void);
#endif /* GAME_H_ */
--- /dev/null
+#include <string.h>
+#include "game.h"
+#include "gfxutil.h"
+
+enum {
+ IN = 0,
+ LEFT = 1,
+ RIGHT = 2,
+ TOP = 4,
+ BOTTOM = 8
+};
+
+static int outcode(int x, int y, int xmin, int ymin, int xmax, int ymax)
+{
+ int code = 0;
+
+ if(x < xmin) {
+ code |= LEFT;
+ } else if(x > xmax) {
+ code |= RIGHT;
+ }
+ if(y < ymin) {
+ code |= TOP;
+ } else if(y > ymax) {
+ code |= BOTTOM;
+ }
+ return code;
+}
+
+#define FIXMUL(a, b) (((a) * (b)) >> 8)
+#define FIXDIV(a, b) (((a) << 8) / (b))
+
+#define LERP(a, b, t) ((a) + FIXMUL((b) - (a), (t)))
+
+int clip_line(int *x0, int *y0, int *x1, int *y1, int xmin, int ymin, int xmax, int ymax)
+{
+ int oc_out;
+
+ int oc0 = outcode(*x0, *y0, xmin, ymin, xmax, ymax);
+ int oc1 = outcode(*x1, *y1, xmin, ymin, xmax, ymax);
+
+ long fx0, fy0, fx1, fy1, fxmin, fymin, fxmax, fymax;
+
+ if(!(oc0 | oc1)) return 1; /* both points are inside */
+
+ fx0 = *x0 << 8;
+ fy0 = *y0 << 8;
+ fx1 = *x1 << 8;
+ fy1 = *y1 << 8;
+ fxmin = xmin << 8;
+ fymin = ymin << 8;
+ fxmax = xmax << 8;
+ fymax = ymax << 8;
+
+ for(;;) {
+ long x, y, t;
+
+ if(oc0 & oc1) return 0; /* both have points with the same outbit, not visible */
+ if(!(oc0 | oc1)) break; /* both points are inside */
+
+ oc_out = oc0 ? oc0 : oc1;
+
+ if(oc_out & TOP) {
+ t = FIXDIV(fymin - fy0, fy1 - fy0);
+ x = LERP(fx0, fx1, t);
+ y = fymin;
+ } else if(oc_out & BOTTOM) {
+ t = FIXDIV(fymax - fy0, fy1 - fy0);
+ x = LERP(fx0, fx1, t);
+ y = fymax;
+ } else if(oc_out & LEFT) {
+ t = FIXDIV(fxmin - fx0, fx1 - fx0);
+ x = fxmin;
+ y = LERP(fy0, fy1, t);
+ } else if(oc_out & RIGHT) {
+ t = FIXDIV(fxmax - fx0, fx1 - fx0);
+ x = fxmax;
+ y = LERP(fy0, fy1, t);
+ }
+
+ if(oc_out == oc0) {
+ fx0 = x;
+ fy0 = y;
+ oc0 = outcode(fx0 >> 8, fy0 >> 8, xmin, ymin, xmax, ymax);
+ } else {
+ fx1 = x;
+ fy1 = y;
+ oc1 = outcode(fx1 >> 8, fy1 >> 8, xmin, ymin, xmax, ymax);
+ }
+ }
+
+ *x0 = fx0 >> 8;
+ *y0 = fy0 >> 8;
+ *x1 = fx1 >> 8;
+ *y1 = fy1 >> 8;
+ return 1;
+}
+
+void draw_line(int x0, int y0, int x1, int y1, unsigned short color)
+{
+ int i, dx, dy, x_inc, y_inc, error;
+ unsigned short *fb = fb_pixels;
+
+ fb += y0 * fb_width + x0;
+
+ dx = x1 - x0;
+ dy = y1 - y0;
+
+ if(dx >= 0) {
+ x_inc = 1;
+ } else {
+ x_inc = -1;
+ dx = -dx;
+ }
+ if(dy >= 0) {
+ y_inc = fb_width;
+ } else {
+ y_inc = -fb_width;
+ dy = -dy;
+ }
+
+ if(dx > dy) {
+ error = dy * 2 - dx;
+ for(i=0; i<=dx; i++) {
+ *fb = color;
+ if(error >= 0) {
+ error -= dx * 2;
+ fb += y_inc;
+ }
+ error += dy * 2;
+ fb += x_inc;
+ }
+ } else {
+ error = dx * 2 - dy;
+ for(i=0; i<=dy; i++) {
+ *fb = color;
+ if(error >= 0) {
+ error -= dy * 2;
+ fb += x_inc;
+ }
+ error += dx * 2;
+ fb += y_inc;
+ }
+ }
+}
+
+
+#define BLUR(w, h, pstep, sstep) \
+ for(i=0; i<h; i++) { \
+ int sum = sptr[0] * (rad + 1); \
+ int count = (rad * 2 + 1) << 8; \
+ int midsize = w - rad * 2; \
+ int firstpix = sptr[0]; \
+ int lastpix = sptr[pstep * (w - 1)]; \
+ /* add up the contributions for the -1 pixel */ \
+ for(j=0; j<rad; j++) { \
+ sum += sptr[pstep * j]; \
+ } \
+ /* first part adding sptr[rad] and subtracting sptr[0] */ \
+ for(j=0; j<=rad; j++) { \
+ sum += (int)sptr[pstep * rad] - firstpix; \
+ sptr += pstep; \
+ *dptr = scale * sum / count; \
+ dptr += pstep; \
+ } \
+ /* middle part adding sptr[rad] and subtracting sptr[-(rad+1)] */ \
+ for(j=1; j<midsize; j++) { \
+ sum += (int)sptr[pstep * rad] - (int)sptr[-(rad + 1) * pstep]; \
+ sptr += pstep; \
+ *dptr = scale * sum / count; \
+ dptr += pstep; \
+ } \
+ /* last part adding lastpix and subtracting sptr[-(rad+1)] */ \
+ for(j=0; j<rad; j++) { \
+ sum += lastpix - (int)sptr[-(rad + 1) * pstep]; \
+ sptr += pstep; \
+ *dptr = scale * sum / count; \
+ dptr += pstep; \
+ } \
+ sptr += sstep; \
+ dptr += sstep; \
+ }
+
+/* TODO bound blur rad to image size to avoid inner loop conditionals */
+/* TODO make version with pow2 (rad*2+1) to avoid div with count everywhere */
+void blur_grey_horiz(uint16_t *dest, uint16_t *src, int xsz, int ysz, int rad, int scale)
+{
+ int i, j;
+ unsigned char *dptr = (unsigned char*)dest;
+ unsigned char *sptr = (unsigned char*)src;
+
+ BLUR(xsz, ysz, 2, 0);
+}
+
+
+void blur_grey_vert(uint16_t *dest, uint16_t *src, int xsz, int ysz, int rad, int scale)
+{
+ int i, j;
+ unsigned char *dptr = (unsigned char*)dest;
+ unsigned char *sptr = (unsigned char*)src;
+ int pixel_step = xsz * 2;
+ int scanline_step = 2 - ysz * pixel_step;
+
+ BLUR(ysz, xsz, pixel_step, scanline_step);
+}
+
+void convimg_rgb24_rgb16(uint16_t *dest, unsigned char *src, int xsz, int ysz)
+{
+ int i;
+ int npixels = xsz * ysz;
+
+ for(i=0; i<npixels; i++) {
+ int r = *src++;
+ int g = *src++;
+ int b = *src++;
+ *dest++ = PACK_RGB16(r, g, b);
+ }
+}
+
+void blitfb(uint16_t *dest, uint16_t *src, int width, int height, int pitch_pix)
+{
+ int i;
+ for(i=0; i<height; i++) {
+ memcpy(dest, src, width * 2);
+ dest += 320;
+ src += pitch_pix;
+ }
+}
+
+void blitfb_key(uint16_t *dest, uint16_t *src, int width, int height, int pitch_pix, uint16_t key)
+{
+ int i, j, dadv = 320 - width;
+
+ for(i=0; i<height; i++) {
+ for(j=0; j<width; j++) {
+ uint16_t scol = *src++;
+ if(scol != key) *dest = scol;
+ dest++;
+ }
+ dest += dadv;
+ }
+
+}
--- /dev/null
+#ifndef GFXUTIL_H_
+#define GFXUTIL_H_
+
+#include "inttypes.h"
+
+#define PACK_RGB16(r, g, b) \
+ ((((uint16_t)(r) << 8) & 0xf800) | \
+ (((uint16_t)(g) << 3) & 0x7e0) | \
+ (((uint16_t)(b) >> 3) & 0x1f))
+
+#define UNPACK_R16(c) (((c) >> 8) & 0xf8)
+#define UNPACK_G16(c) (((c) >> 3) & 0xfc)
+#define UNPACK_B16(c) (((c) << 3) & 0xf8)
+
+#define PACK_RGB32(r, g, b) \
+ ((((r) & 0xff) << 16) | (((g) & 0xff) << 8) | ((b) & 0xff))
+
+#define UNPACK_R32(c) (((c) >> 16) & 0xff)
+#define UNPACK_G32(c) (((c) >> 8) & 0xff)
+#define UNPACK_B32(c) ((c) & 0xff)
+
+int clip_line(int *x0, int *y0, int *x1, int *y1, int xmin, int ymin, int xmax, int ymax);
+void draw_line(int x0, int y0, int x1, int y1, unsigned short color);
+
+/* scale in 24.8 fixed point */
+void blur_grey_horiz(uint16_t *dest, uint16_t *src, int xsz, int ysz, int radius, int scale);
+void blur_grey_vert(uint16_t *dest, uint16_t *src, int xsz, int ysz, int radius, int scale);
+
+void convimg_rgb24_rgb16(uint16_t *dest, unsigned char *src, int xsz, int ysz);
+
+void blitfb(uint16_t *dest, uint16_t *src, int xsz, int ysz, int pitch_pix);
+void blitfb_key(uint16_t *dest, uint16_t *src, int xsz, int ysz, int pitch_pix, uint16_t key);
+
+#endif /* GFXUTIL_H_ */
--- /dev/null
+#include <stdio.h>
+#include "menuscr.h"
+#include "imago2.h"
+#include "gfx.h"
+#include "gfxutil.h"
+#include "game.h"
+
+static void *bgpix;
+static int bgwidth, bgheight;
+
+int menu_init(void)
+{
+ if(!(bgpix = img_load_pixels("data/menpg640.png", &bgwidth, &bgheight, IMG_FMT_RGB24))) {
+ fprintf(stderr, "failed to load menu bg image\n");
+ return -1;
+ }
+ convimg_rgb24_rgb16(bgpix, bgpix, bgwidth, bgheight);
+ return 0;
+}
+
+void menu_cleanup(void)
+{
+ img_free_pixels(bgpix);
+}
+
+void menu_start(void)
+{
+}
+
+void menu_stop(void)
+{
+}
+
+void menu_draw(void)
+{
+ blit_frame(bgpix, 1);
+}
+
+void menu_keyb(int key, int pressed)
+{
+ switch(key) {
+ case 27:
+ game_quit();
+ break;
+ }
+}
--- /dev/null
+#ifndef MENUSCR_H_
+#define MENUSCR_H_
+
+int menu_init(void);
+void menu_cleanup(void);
+
+void menu_start(void);
+void menu_stop(void);
+
+void menu_draw(void);
+void menu_keyb(int key, int pressed);
+
+#endif /* MENUSCR_H_ */
projects / eradicate / commitdiff