--- /dev/null
+*.swp
+*.o
+*.d
+*.obj
+*.OBJ
+*.exe
+*.EXE
+*.lnk
+*.LNK
+*.lbc
+*.LBC
+*.lib
+*.LIB
+*.err
+*.ERR
+*.log
+*.LOG
+Debug
+Release
+*.suo
+*sdf
+demo
+*.zip
+data
+*.a
+*.dll
+*.occ
+*.OCC
+*.map
+*.MAP
+*.CFG
+*.cfg
+*.$$$
+/dosdemo.vcxproj.user
+*.dep
+*.DEP
+*.cof
+*.COF
+*.dja
+*.DJA
--- /dev/null
+src = $(wildcard src/*.c) $(wildcard src/parts/*.c) $(wildcard src/sdl/*.c)
+obj = $(src:.c=.o) $(asmsrc:.asm=.o)
+dep = $(obj:.o=.d)
+bin = demo
+
+inc = -I/usr/local/include -Isrc -Isrc/sdl -Ilibs/imago/src -Ilibs/mikmod/include
+warn = -pedantic -Wall -Wno-unused-variable -Wno-unused-function
+
+CFLAGS = $(warn) -g $(inc) `sdl-config --cflags`
+LDFLAGS = -Llibs/imago -Llibs/mikmod -limago -lmikmod `sdl-config --libs` -lm
+
+$(bin): $(obj) imago mikmod
+ $(CC) -o $@ $(obj) $(LDFLAGS)
+
+%.o: %.asm
+ nasm -f elf -o $@ $<
+
+-include $(dep)
+
+%.d: %.c
+ @$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@
+
+.PHONY: imago
+imago:
+ $(MAKE) -C libs/imago
+
+.PHONY: mikmod
+mikmod:
+ $(MAKE) -C libs/mikmod
+
+.PHONY: cleanlibs
+cleanlibs:
+ $(MAKE) -C libs/imago clean
+ $(MAKE) -C libs/mikmod clean
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(bin)
+
+.PHONY: cleandep
+cleandep:
+ rm -f $(dep)
--- /dev/null
+src = $(wildcard src/*.c) $(wildcard src/parts/*.c) $(wildcard src/dos/*.c)
+asmsrc = $(wildcard src/*.asm) $(wildcard src/dos/*.asm)
+obj = $(src:.c=.cof) $(asmsrc:.asm=.cof)
+dep = $(obj:.cof=.dep)
+bin = demo.exe
+
+ifeq ($(findstring COMMAND.COM, $(SHELL)), COMMAND.COM)
+ hostsys = dos
+else
+ hostsys = unix
+ TOOLPREFIX = i586-pc-msdosdjgpp-
+endif
+
+inc = -Isrc -Isrc/dos -Ilibs/imago/src -Ilibs/mikmod/include
+opt = -O3 -ffast-math -fno-strict-aliasing
+dbg = -g
+warn = -pedantic -Wall -Wno-unused-function -Wno-unused-variable
+
+CC = $(TOOLPREFIX)gcc
+AR = $(TOOLPREFIX)ar
+CFLAGS = $(warn) -march=pentium $(dbg) $(opt) $(inc)
+LDFLAGS = libs/imago/imago.dja libs/mikmod/dos/libmikmod.a
+
+$(bin): $(obj) imago mikmod
+ $(CC) -o $@ -Wl,-Map=ld.map $(obj) $(LDFLAGS)
+
+%.cof: %.asm
+ nasm -f coff -o $@ $<
+
+-include $(dep)
+
+%.cof: %.c
+ $(CC) $(CFLAGS) -o $@ -c $<
+
+%.dep: %.c
+ @$(CPP) $(CFLAGS) $< -MM -MT $(@:.dep=.cof) >$@
+
+.PHONY: imago
+imago:
+ $(MAKE) -C libs/imago -f Makefile.dj
+
+.PHONY: mikmod
+mikmod:
+ $(MAKE) -C libs/mikmod/dos -f Makefile.dj
+
+.PHONY: cleanlibs
+cleanlibs:
+ $(MAKE) -C libs/imago -f Makefile.dj clean
+ $(MAKE) -C libs/mikmod/dos -f Makefile.dj clean
+
+.PHONY: clean
+.PHONY: cleandep
+
+ifeq ($(hostsys), dos)
+clean:
+ del src\*.cof
+ del src\dos\*.cof
+ del $(bin)
+
+cleandep:
+ del src\*.dep
+ del src\dos\*.dep
+else
+clean:
+ rm -f $(obj) $(bin)
+
+cleandep:
+ rm -f $(dep)
+endif
--- /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
+src = $(wildcard src/*.c) \
+ $(wildcard zlib/*.c) \
+ $(wildcard libpng/*.c) \
+ $(wildcard jpeglib/*.c)
+obj = $(src:.c=.o)
+alib = libimago.a
+
+CFLAGS = -Wno-main -g -Izlib -Ilibpng -Ijpeglib
+
+$(alib): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(alib)
--- /dev/null
+libpng = png.obj pngerror.obj pngget.obj pngmem.obj pngpread.obj pngread.obj &
+pngrio.obj pngrtran.obj pngrutil.obj pngset.obj pngtrans.obj pngwio.obj &
+pngwrite.obj pngwtran.obj pngwutil.obj
+zlib = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj &
+inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
+jpeglib = jcapimin.obj jcapistd.obj jccoefct.obj jccolor.obj jcdctmgr.obj &
+jchuff.obj jcinit.obj jcmainct.obj jcmarker.obj jcmaster.obj jcomapi.obj &
+jcparam.obj jcphuff.obj jcprepct.obj jcsample.obj jctrans.obj jdapimin.obj &
+jdapistd.obj jdatadst.obj jdatasrc.obj jdcoefct.obj jdcolor.obj jddctmgr.obj &
+jdhuff.obj jdinput.obj jdmainct.obj jdmarker.obj jdmaster.obj jdmerge.obj &
+jdphuff.obj jdpostct.obj jdsample.obj jdtrans.obj jerror.obj jfdctflt.obj &
+jfdctfst.obj jfdctint.obj jidctflt.obj jidctfst.obj jidctint.obj jidctred.obj &
+jmemmgr.obj jmemnobs.obj jquant1.obj jquant2.obj jutils.obj
+
+obj = conv.obj filejpeg.obj filepng.obj fileppm.obj filergbe.obj &
+filetga.obj ftmodule.obj imago2.obj imago_gl.obj modules.obj &
+$(libpng) $(zlib) $(jpeglib)
+
+alib = imago.lib
+
+opt = -5 -fp5 -otexan
+dbg = -d1
+def = -DPNG_NO_SNPRINTF
+
+!ifdef __UNIX__
+RM = rm -f
+!else
+RM = del
+!endif
+
+CC = wcc386
+CFLAGS = $(dbg) $(opt) $(def) -zq -bt=dos -Ilibpng -Izlib -Ijpeglib
+
+$(alib): cflags.occ $(obj)
+ %write objects.lbc $(obj)
+ wlib -b -n $@ @objects
+
+.c: src;libpng;jpeglib;zlib
+
+cflags.occ: Makefile
+ %write $@ $(CFLAGS)
+
+.c.obj: .autodepend
+ $(CC) -fo=$@ @cflags.occ $[*
+
+clean: .symbolic
+ $(RM) *.obj
+ $(RM) *.occ
+ $(RM) *.lbc
+ $(RM) $(alib)
--- /dev/null
+src = $(wildcard src/*.c) \
+ $(wildcard zlib/*.c) \
+ $(wildcard libpng/*.c) \
+ $(wildcard jpeglib/*.c)
+obj = $(src:.c=.cof)
+alib = imago.dja
+
+ifeq ($(findstring COMMAND.COM, $(SHELL)), COMMAND.COM)
+ hostsys = dos
+else
+ hostsys = unix
+ TOOLPREFIX = i586-pc-msdosdjgpp-
+endif
+
+CC = $(TOOLPREFIX)gcc
+AR = $(TOOLPREFIX)ar
+CFLAGS = -Wno-main -march=pentium -g -O3 -ffast-math -Izlib -Ilibpng -Ijpeglib
+
+$(alib): $(obj)
+ $(AR) rcs $@ $(obj)
+
+%.cof: %.c
+ $(CC) $(CFLAGS) -o $@ -c $<
+
+.PHONY: clean
+ifeq ($(hostsys), dos)
+clean:
+ del src\*.cof
+ del zlib\*.cof
+ del libpng\*.cof
+ del jpeglib\*.cof
+ del $(alib)
+else
+clean:
+ rm -f $(obj) $(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
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="jpeglib\jcapimin.c" />\r
+ <ClCompile Include="jpeglib\jcapistd.c" />\r
+ <ClCompile Include="jpeglib\jccoefct.c" />\r
+ <ClCompile Include="jpeglib\jccolor.c" />\r
+ <ClCompile Include="jpeglib\jcdctmgr.c" />\r
+ <ClCompile Include="jpeglib\jchuff.c" />\r
+ <ClCompile Include="jpeglib\jcinit.c" />\r
+ <ClCompile Include="jpeglib\jcmainct.c" />\r
+ <ClCompile Include="jpeglib\jcmarker.c" />\r
+ <ClCompile Include="jpeglib\jcmaster.c" />\r
+ <ClCompile Include="jpeglib\jcomapi.c" />\r
+ <ClCompile Include="jpeglib\jcparam.c" />\r
+ <ClCompile Include="jpeglib\jcphuff.c" />\r
+ <ClCompile Include="jpeglib\jcprepct.c" />\r
+ <ClCompile Include="jpeglib\jcsample.c" />\r
+ <ClCompile Include="jpeglib\jctrans.c" />\r
+ <ClCompile Include="jpeglib\jdapimin.c" />\r
+ <ClCompile Include="jpeglib\jdapistd.c" />\r
+ <ClCompile Include="jpeglib\jdatadst.c" />\r
+ <ClCompile Include="jpeglib\jdatasrc.c" />\r
+ <ClCompile Include="jpeglib\jdcoefct.c" />\r
+ <ClCompile Include="jpeglib\jdcolor.c" />\r
+ <ClCompile Include="jpeglib\jddctmgr.c" />\r
+ <ClCompile Include="jpeglib\jdhuff.c" />\r
+ <ClCompile Include="jpeglib\jdinput.c" />\r
+ <ClCompile Include="jpeglib\jdmainct.c" />\r
+ <ClCompile Include="jpeglib\jdmarker.c" />\r
+ <ClCompile Include="jpeglib\jdmaster.c" />\r
+ <ClCompile Include="jpeglib\jdmerge.c" />\r
+ <ClCompile Include="jpeglib\jdphuff.c" />\r
+ <ClCompile Include="jpeglib\jdpostct.c" />\r
+ <ClCompile Include="jpeglib\jdsample.c" />\r
+ <ClCompile Include="jpeglib\jdtrans.c" />\r
+ <ClCompile Include="jpeglib\jerror.c" />\r
+ <ClCompile Include="jpeglib\jfdctflt.c" />\r
+ <ClCompile Include="jpeglib\jfdctfst.c" />\r
+ <ClCompile Include="jpeglib\jfdctint.c" />\r
+ <ClCompile Include="jpeglib\jidctflt.c" />\r
+ <ClCompile Include="jpeglib\jidctfst.c" />\r
+ <ClCompile Include="jpeglib\jidctint.c" />\r
+ <ClCompile Include="jpeglib\jidctred.c" />\r
+ <ClCompile Include="jpeglib\jmemmgr.c" />\r
+ <ClCompile Include="jpeglib\jmemnobs.c" />\r
+ <ClCompile Include="jpeglib\jquant1.c" />\r
+ <ClCompile Include="jpeglib\jquant2.c" />\r
+ <ClCompile Include="jpeglib\jutils.c" />\r
+ <ClCompile Include="libpng\png.c" />\r
+ <ClCompile Include="libpng\pngerror.c" />\r
+ <ClCompile Include="libpng\pngget.c" />\r
+ <ClCompile Include="libpng\pngmem.c" />\r
+ <ClCompile Include="libpng\pngpread.c" />\r
+ <ClCompile Include="libpng\pngread.c" />\r
+ <ClCompile Include="libpng\pngrio.c" />\r
+ <ClCompile Include="libpng\pngrtran.c" />\r
+ <ClCompile Include="libpng\pngrutil.c" />\r
+ <ClCompile Include="libpng\pngset.c" />\r
+ <ClCompile Include="libpng\pngtrans.c" />\r
+ <ClCompile Include="libpng\pngwio.c" />\r
+ <ClCompile Include="libpng\pngwrite.c" />\r
+ <ClCompile Include="libpng\pngwtran.c" />\r
+ <ClCompile Include="libpng\pngwutil.c" />\r
+ <ClCompile Include="src\conv.c" />\r
+ <ClCompile Include="src\filejpeg.c" />\r
+ <ClCompile Include="src\filepng.c" />\r
+ <ClCompile Include="src\fileppm.c" />\r
+ <ClCompile Include="src\filergbe.c" />\r
+ <ClCompile Include="src\filetga.c" />\r
+ <ClCompile Include="src\ftmodule.c" />\r
+ <ClCompile Include="src\imago2.c" />\r
+ <ClCompile Include="src\imago_gl.c" />\r
+ <ClCompile Include="src\modules.c" />\r
+ <ClCompile Include="zlib\adler32.c" />\r
+ <ClCompile Include="zlib\compress.c" />\r
+ <ClCompile Include="zlib\crc32.c" />\r
+ <ClCompile Include="zlib\deflate.c" />\r
+ <ClCompile Include="zlib\gzio.c" />\r
+ <ClCompile Include="zlib\infback.c" />\r
+ <ClCompile Include="zlib\inffast.c" />\r
+ <ClCompile Include="zlib\inflate.c" />\r
+ <ClCompile Include="zlib\inftrees.c" />\r
+ <ClCompile Include="zlib\trees.c" />\r
+ <ClCompile Include="zlib\uncompr.c" />\r
+ <ClCompile Include="zlib\zutil.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="jpeglib\cderror.h" />\r
+ <ClInclude Include="jpeglib\jchuff.h" />\r
+ <ClInclude Include="jpeglib\jconfig.h" />\r
+ <ClInclude Include="jpeglib\jdct.h" />\r
+ <ClInclude Include="jpeglib\jdhuff.h" />\r
+ <ClInclude Include="jpeglib\jerror.h" />\r
+ <ClInclude Include="jpeglib\jinclude.h" />\r
+ <ClInclude Include="jpeglib\jmemsys.h" />\r
+ <ClInclude Include="jpeglib\jmorecfg.h" />\r
+ <ClInclude Include="jpeglib\jpegint.h" />\r
+ <ClInclude Include="jpeglib\jpeglib.h" />\r
+ <ClInclude Include="jpeglib\jversion.h" />\r
+ <ClInclude Include="libpng\png.h" />\r
+ <ClInclude Include="libpng\pngconf.h" />\r
+ <ClInclude Include="src\ftmodule.h" />\r
+ <ClInclude Include="src\imago2.h" />\r
+ <ClInclude Include="zlib\crc32.h" />\r
+ <ClInclude Include="zlib\deflate.h" />\r
+ <ClInclude Include="zlib\inffast.h" />\r
+ <ClInclude Include="zlib\inffixed.h" />\r
+ <ClInclude Include="zlib\inflate.h" />\r
+ <ClInclude Include="zlib\inftrees.h" />\r
+ <ClInclude Include="zlib\trees.h" />\r
+ <ClInclude Include="zlib\zconf.h" />\r
+ <ClInclude Include="zlib\zlib.h" />\r
+ <ClInclude Include="zlib\zutil.h" />\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{5DDB5403-A105-470E-882B-4276EFDDAAB0}</ProjectGuid>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <RootNamespace>imago</RootNamespace>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">\r
+ <ConfigurationType>StaticLibrary</ConfigurationType>\r
+ <UseDebugLibraries>true</UseDebugLibraries>\r
+ <PlatformToolset>v120</PlatformToolset>\r
+ <CharacterSet>Unicode</CharacterSet>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">\r
+ <ConfigurationType>StaticLibrary</ConfigurationType>\r
+ <UseDebugLibraries>false</UseDebugLibraries>\r
+ <PlatformToolset>v120</PlatformToolset>\r
+ <WholeProgramOptimization>true</WholeProgramOptimization>\r
+ <CharacterSet>Unicode</CharacterSet>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup />\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+ <ClCompile>\r
+ <PrecompiledHeader>\r
+ </PrecompiledHeader>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <Optimization>Disabled</Optimization>\r
+ <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <DisableSpecificWarnings>4996;4244</DisableSpecificWarnings>\r
+ <AdditionalIncludeDirectories>$(ProjectDir)\zlib;$(ProjectDir)\libpng;$(ProjectDir)\jpeglib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+ <ClCompile>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <PrecompiledHeader>\r
+ </PrecompiledHeader>\r
+ <Optimization>MaxSpeed</Optimization>\r
+ <FunctionLevelLinking>true</FunctionLevelLinking>\r
+ <IntrinsicFunctions>true</IntrinsicFunctions>\r
+ <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <DisableSpecificWarnings>4996;4244</DisableSpecificWarnings>\r
+ <AdditionalIncludeDirectories>$(ProjectDir)\zlib;$(ProjectDir)\libpng;$(ProjectDir)\jpeglib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>\r
+ <OptimizeReferences>true</OptimizeReferences>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="src">\r
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>\r
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>\r
+ </Filter>\r
+ <Filter Include="zlib">\r
+ <UniqueIdentifier>{314b28c1-a301-4d60-84c8-145ca502a66d}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="libpng">\r
+ <UniqueIdentifier>{5f5892d0-a1e8-4d29-abb4-aa8764ec4721}</UniqueIdentifier>\r
+ </Filter>\r
+ <Filter Include="jpeglib">\r
+ <UniqueIdentifier>{51a6f302-b561-4388-b2c8-969c219a3c0f}</UniqueIdentifier>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="src\conv.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\imago_gl.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\imago2.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\modules.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\adler32.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\compress.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\crc32.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\deflate.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\gzio.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\infback.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\inffast.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\inflate.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\inftrees.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\trees.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\uncompr.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="zlib\zutil.c">\r
+ <Filter>zlib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcapimin.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcapistd.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jccoefct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jccolor.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcdctmgr.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jchuff.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcinit.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcmainct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcmarker.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcmaster.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcomapi.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcparam.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcphuff.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcprepct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jcsample.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jctrans.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdapimin.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdapistd.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdatadst.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdatasrc.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdcoefct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdcolor.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jddctmgr.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdhuff.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdinput.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdmainct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdmarker.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdmaster.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdmerge.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdphuff.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdpostct.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdsample.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jdtrans.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jerror.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jfdctflt.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jfdctfst.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jfdctint.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jidctflt.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jidctfst.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jidctint.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jidctred.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jmemmgr.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jmemnobs.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jquant1.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jquant2.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="jpeglib\jutils.c">\r
+ <Filter>jpeglib</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\png.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngerror.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngget.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngmem.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngpread.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngread.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngrio.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngrtran.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngrutil.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngset.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngtrans.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngwio.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngwrite.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngwtran.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="libpng\pngwutil.c">\r
+ <Filter>libpng</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\filejpeg.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\filepng.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\fileppm.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\filergbe.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\filetga.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\ftmodule.c">\r
+ <Filter>src</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="src\imago2.h">\r
+ <Filter>src</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\crc32.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\deflate.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\inffast.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\inffixed.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\inflate.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\inftrees.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\trees.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\zconf.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\zlib.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="zlib\zutil.h">\r
+ <Filter>zlib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\cderror.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jchuff.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jconfig.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jdct.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jdhuff.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jerror.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jinclude.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jmemsys.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jmorecfg.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jpegint.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jpeglib.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="jpeglib\jversion.h">\r
+ <Filter>jpeglib</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="libpng\png.h">\r
+ <Filter>libpng</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="libpng\pngconf.h">\r
+ <Filter>libpng</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="src\ftmodule.h">\r
+ <Filter>src</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+</Project>
\ No newline at end of file
--- /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(__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(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 */
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+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 this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+\f
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+\f
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+\f
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+ 7. 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 not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+\f
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the 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
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey 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 library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library 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 2.1 of the License, or (at your option) any later version.
+
+ This library 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 library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
--- /dev/null
+ GNU LIBRARY GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL. It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it. You can use it for
+your libraries, 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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library. If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+\f
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software. To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+ Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs. This
+license, the GNU Library General Public License, applies to certain
+designated libraries. This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+ The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it. Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program. However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+ Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries. We
+concluded that weaker conditions might promote sharing better.
+
+ However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves. This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them. (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.) The hope is that this
+will lead to faster development of free libraries.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+ Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+\f
+ GNU LIBRARY GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License"). Each licensee is
+addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+\f
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+ 6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ c) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ d) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+ 7. 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 not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+\f
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Library 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
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey 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 library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
--- /dev/null
+src = $(wildcard drivers/*.c) \
+ $(wildcard loaders/*.c) \
+ $(wildcard mmio/*.c) \
+ $(wildcard depackers/*.c) \
+ $(wildcard posix/*.c) \
+ $(wildcard playercode/*.c)
+obj = $(src:.c=.o)
+alib = libmikmod.a
+
+def = -DHAVE_CONFIG_H -DMIKMOD_BUILD
+inc = -I. -Iinclude
+warn = -pedantic -Wall -Wno-unused-variable -Wno-unused-function
+CFLAGS = $(warn) -g $(def) $(inc) `pkg-config --cflags sdl`
+
+$(alib): $(obj)
+ $(AR) rcs $@ $(obj)
+
+.PHONY: clean
+clean:
+ rm -f $(obj) $(bin)
--- /dev/null
+odrivers = drv_oss.obj drv_wss.obj drv_ultra.obj drv_sb.obj drv_sdl.obj drv_nos.obj &
+dossb.obj dosirq.obj dosgus.obj dosdma.obj doswss.obj
+oloaders = load_s3m.obj load_mod.obj load_it.obj load_xm.obj
+ommio = mmalloc.obj mmerror.obj mmio.obj
+odepackers = mmcmp.obj pp20.obj s404.obj xpk.obj
+oposix = memcmp.obj strcasecmp.obj strstr.obj
+oplayercode = mdreg.obj mlreg.obj mloader.obj virtch_common.obj munitrk.obj mplayer.obj &
+mlutil.obj sloader.obj npertab.obj virtch.obj mdulaw.obj mwav.obj virtch2.obj mdriver.obj
+
+obj = $(odrivers) $(oloaders) $(ommio) $(odepackers) $(oposix) $(oplayercode)
+
+alib = mikmod.lib
+
+opt = -5 -fp5 -otexan -zu
+dbg = -d1
+def = -DHAVE_CONFIG_H -DMIKMOD_BUILD
+
+CC = wcc386
+CFLAGS = $(dbg) $(opt) $(def) -zq -bt=dos -I. -Iinclude -Idrvdos
+
+$(alib): cflags.occ $(obj)
+ %write objects.lbc $(obj)
+ wlib -b -n $@ @objects
+
+.c: drivers;drvdos;loaders;mmio;depackers;posix;playercode
+
+cflags.occ: Makefile
+ %write $@ $(CFLAGS)
+
+.c.obj: .autodepend
+ $(CC) -fo=$@ @cflags.occ $[*
+
+clean: .symbolic
+ del *.obj
+ del *.occ
+ del *.lbc
+ del $(alib)
--- /dev/null
+ Hello folks!
+
+
+This is libmikmod, version 3.3.10, a portable sound library for Unix
+and other systems. Check out the file 'NEWS' for more history information.
+
+
+>> BUILDING LIBMIKMOD
+---------------------
+
+- If you're building libmikmod for Windows, refer to the 'README' file
+ located in the 'win32' subdirectory.
+
+- If you're building libmikmod for Mac OS X, refer to the 'README' file
+ located in the 'macosx' subdirectory.
+
+- If you're building libmikmod for Android, refer to the 'README' file
+ located in the 'android' subdirectory.
+
+- If you're building libmikmod for DOS, refer to the 'README' file
+ located in the 'dos' subdirectory.
+
+- If you're building libmikmod for OS/2, refer to the 'README' file
+ located in the 'os2' subdirectory.
+
+- If you're building libmikmod for AmigaOS, or its variants like MorphOS
+ or AROS, refer to the 'README' located in the 'amiga' subdirectory.
+
+- If you're building libmikmod for MacOS, refer to the 'README' file
+ located in the 'macintosh' subdirectory.
+
+- If you're building libmikmod for dreamcast, gp32 or psp platforms,
+ refer to the corresponding 'README' files located under the 'dc',
+ 'gp32' or 'psp' subdirectory.
+
+- If you're building libmikmod under any other system which is not a
+ Unix flavour, then be warned that your platform is probably not
+ supported and that libmikmod will probably not build out of the box.
+ Drop us a note and we'll see what we can do for this situation.
+
+So you're on a good old Unix workstation, aren't you ?
+
+You'll need an ANSI C compiler to build libmikmod. If your system does
+not come with an ANSI C compiler, you might try the GNU C compiler, gcc.
+If you're building on a 32 bit architecture, your compiler must provide
+a 64 bit integer type (usually 'long long').
+
+To prevent clobbering the sources, I recommend building libmikmod in an
+alternate directory, for example 'build':
+
+ mkdir build
+ cd build
+
+In this directory, run libmikmod's configure script:
+
+ ../configure
+
+The configure script will attempt to guess correct values for various
+system-dependent variables used during the build process, and will
+create appropriate Makefiles for proper compilation.
+
+If you're not familiar with configure scripts and their standard
+options, you can find more general information about them in the file
+INSTALL.
+
+The default behaviour of the configure script is to create both a static
+and a shared library, with as many drivers as possible, which are
+dynamically loaded whenever possible. However, it can be given several
+options to tweak your configuration of libmikmod:
+
+The --enable-af, --enable-alsa, --enable-esd, --enable-oss,
+--enable-sam9407 and --enable-ultra options will compile respectively
+the Digital AudioFile, Advanced Linux Sound Architecture (ALSA),
+Enlightened Sound Daemon, Open Sound System (OSS), sam9407 and Linux
+Ultrasound drivers.
+
+Since the configure script will search for the appropriate include files
+and libraries, to compile as much drivers as possible, these options are
+mostly useful in their negative form:
+ ../configure --disable-esd
+will configure libmikmod without the Enlightened Sound Daemon driver,
+even if all the necessary files for compiling are present on the
+system.
+
+The --enable-dl option enables the dynamic load of the alsa, esd and
+ultra drivers at runtime, if your systems support it. This option is
+enabled by default if the build system supports it, so it is more useful
+in its negative form:
+ ../configure --disable-dl
+will configure libmikmod without the dynamic loading facility.
+
+The --enable-threads option enables the creation of a thread-safe
+libmikmod library, if your system provides POSIX threads. This option is
+enabled by default, so it is more useful in its negative form:
+ ../configure --disable-threads
+will configure for a non thread-safe version of libmikmod.
+
+The --enable-shared and --enable-static options control whether a static
+library, a shared library or both should be built.
+
+The --enable-debug option creates a debug version of libmikmod.
+
+After you've successfully run configure, simply run
+
+ make
+
+to get all things build. Then, run
+
+ make install
+
+to have the library installed. Depending on where you choose to install
+it (using the --prefix= option to configure), you may need root
+privileges for this operation.
+
+
+>> DRIVER PARAMETERS
+--------------------
+
+Until a good place to put this information is found, here is the list of
+parameters recognized by the drivers, as well as the driver alias list.
+When specifying multiple parameters, use a comma (,) to separate the
+different parameters, for example: somevalue=1,someothervalue=2
+
+- AudioFile (alias "audiofile")
+ machine= same syntax as the AUDIOFILE environment variable.
+
+- AIX ("AIX") [AIX only]
+ buffer= logarithmic size of the buffer, in the range 12-19. Default
+ is 15.
+
+- DART ("dart") [OS/2 only]
+ buffer= logarithmic fragment size, in the range 12-16. Default is
+ computed to a bit more than 1/4" of playback.
+ count= fragment count, in the range 2-8. Default is 2.
+ device= waveaudio device number, in the range 0-8. Default is 0 (use
+ default waveaudio device).
+
+- DirectX ("ds") [Win32 only]
+ buffer= logarithmic size of the buffer, in the range 12-19. Default
+ is 16.
+ globalfocus
+ always play music, even if the application has not the
+ focus. Required for full-screen applications.
+
+- EsounD ("esd") [Unix only]
+ machine= same syntax as the ESPEAKER environment variable.
+
+- HP ("hp") [HP-UX only]
+ buffer= logarithmic size of the buffer, in the range 12-19. Default
+ is 15.
+ headphone redirects the output to the headphone port.
+
+- MacOS ("mac") [MacOS only]
+ buffer= logarithmic size of the buffer, in the range 10-16. Default
+ is 12.
+
+- OS/2 MMPM ("os2") [OS/2 only]
+ buffer= logarithmic size of the buffer, in the range 12-16. Default
+ is computed to a bit more than 1/4" of playback.
+ device= waveaudio device number, in the range 0-8. Default is 0 (use
+ default waveaudio device).
+
+- OSS ("oss") [Unix only]
+ card= card number. Default is the card whose driver was loaded
+ first.
+ buffer= logarithmic fragment size, in the range 7-17. Default is 14.
+ Replaces the MM_FRAGSIZE environment variable, which is now
+ deprecated.
+ count= fragment count, in the range 2-255. Default is 16.
+ Replaces the MM_NUMFRAGS environment variable, which is now
+ deprecated.
+
+- Piped output ("pipe") [Unix only]
+ pipe= Pipe command (mandatory).
+
+- SGI audio library ("sgi") [IRIX only]
+ fragsize= buffer size for libmikmod internal use.
+ Replaces the MM_SGI_FRAGSIZE environment variable, which is
+ now deprecated.
+ bufsize= buffer size for the audio library.
+ Replaces the MM_SGI_BUFSIZE environment variable, which is
+ now deprecated.
+
+- Disk writers in raw and wav formats ("raw", "wav" and "aiff")
+ file= Output file name. Default is music.raw for the raw driver
+ and music.wav for the wav driver.
+
+- OpenBSD sndio ("sndio") [OpenBSD only]
+ buffer= logarithmic fragment size, in the range 7-17. Default is 12.
+
+- Sun/Solaris/NetBSD/OpenBSD audio ("audio")
+ [SunOS, Solaris, NetBSD, OpenBSD only]
+ buffer= logarithmic fragment size, in the range 7-17. Default is 12.
+ headphone on SunOS/Solaris only, redirects the output to the headphone
+ port.
+ speaker on SunOS/Solaris only, redirects the output to the speaker.
+
+- Linux sam9407-based soundcards ("sam9407") [Linux only]
+ card= card number. Default is first card.
+
+- NoSound ("nosound"), Standard output ("stdout"), Ultrasound ("ultra"),
+ Windows Multimedia ("winmm"), Windows XAudio2 ("xaudio2"),
+ Amiga AHI ("ahi"), Linux ALSA ("alsa")
+ These drivers have no options.
+
+
+>> ALSA DRIVER SPECIFIC INFORMATION (Linux specific)
+-----------------------------------
+
+The Advanced Linux Sound Architecture (ALSA) project aims to provide
+better sound facilities than the current OSS drivers. You can find
+more information on ALSA, including a HOWTO, on the web:
+ http://www.alsa-project.org
+
+This version of libmikmod ALSA driver works with ALSA versions 1.0.x.
+ALSA versions 0.9.x and earlier are not supported any more.
+
+
+>> ENLIGHTENED SOUND DAEMON SPECIFIC INFORMATION (Unix specific)
+------------------------------------------------
+
+The Enlightened Sound Daemon (EsounD) development has long been stopped,
+but libmikmod still supports it. libmikmod should work with any esound
+version starting from 0.2.18, although the latest 0.2.41 is recommended:
+ http://ftp.gnome.org/pub/gnome/sources/esound/0.2/
+
+You can find more information on EsounD on the web:
+ http://www.tux.org/~ricdude/EsounD.html
+
+If the esd daemon dies, libmikmod will try to reconnect every 5 seconds
+and every new module, if a module ends. So, you can safely restart esd
+and wait 5 seconds, and voila! Sound is back...
+
+If you run esd and a libmikmod application on the same machine,
+everything should work fine. However, if there is a real network
+connection, synchronization problems can occur.
+
+If sound clicks or gets chopped, then you've likely got a
+synchronization problem. Pausing the player for a second should cause
+the problem to disappear. If there's still problems, perhaps your
+network is not fast enough. Lowering the playback rate will hopefully
+solve the problem.
+
+Also, the performance of the esd is really abominable if the esd
+playback frequency can't be divided by the libmikmod playback rate. For
+example, runinng a libmikmod application at 42000 Hz with esd at 44100
+Hz will sound horrible, and take a lot of CPU time due to resampling.
+
+
+>> SGI DRIVER SPECIFIC INFORMATION (IRIX specific)
+----------------------------------
+
+The SGI audio driver was written by Stephan Kanthak in 1996 and its
+author grants to distribute it with the libmikmod package under the same
+restrictions as the library.
+
+If you encounter any problems concerning crackles or short stops while
+playing, feel free to experiment with the values of the fragsize and
+bufsize options of the driver. The default values are 20000 for fragsize
+and 40000 for bufsize. Increasing bufsize might result in nonstop sound
+on slow machines, but increases latency of interactive applications. The
+value of fragsize should be set to about half of bufsize in most cases
+and needs to be increased only if you own a very slow SGI.
+
+Common problems
+
+- libmikmod does not compile on my SGI?
+ First check out whether you have the SGI audio library (libaudio) or
+ not. If the audio library is missing you should upgrade to IRIX 5.3 or
+ newer and you will obtain the media development package automatically
+ with it. If you have the audio library installed, check out if it is
+ in the linker path.
+
+ Also, the audio API has been extended in recent IRIX releases (6.4 and
+ later). The older API used by libmikmod is supposed to be still supported,
+ please drop me a note if it is not on your IRIX release.
+
+- Sound is _very_ noisy?
+ Change sample size to 16 bits.
+
+- Sound crackles or stops temporarily?
+ Try to increase the value of the fragsize driver option (default value
+ is 20000). Switch to mono mode if necessary.
+
+- libmikmod applications only react very slowly?
+ This is a typical effect on SGI machines because the audio library
+ sets up an internal buffer that seems to be quite large on many
+ installations. Try to decrease the bufsize driver option (default
+ value is 40000).
+
+How to contact the driver author:
+Stephan Kanthak <kanthak@i6.informatik.rwth-aachen.de>
+Please cc: me (miod), just in case.
+
+
+>> SUNOS, SOLARIS, NETBSD AND OPENBSD DRIVER SPECIFIC INFORMATION
+-----------------------------------------------------------------
+
+The above mentioned systems use the same interface to the audio device.
+The libmikmod driver for this interface is the Sun driver. It was coded
+by Valtteri Vuorikoski <vuori@sci.fi> and updated to libmikmod 3 by Tor
+Norbye <tor@cs.stanford.edu>, and has been modified to work under NetBSD
+and OpenBSD by Miodrag Vallat.
+
+This driver works with old sound hardware using 8 KHz mono ulaw, and
+with modern hardware using pcm mono or stereo at any frequency. If your
+settings aren't supported by the audio device, sound initialization will
+fail. Refer to the audio(7) man page under SunOS/Solaris and the
+audio(4) man page under NetBSD/OpenBSD for more details on your audio
+hardware and its capabilities.
+
+On Sun workstations, you might be interested in passing the "headphone"
+option to the driver to force output on the headphones, since plugging
+the headphones is not enough.
+
+If you run NetBSD or OpenBSD, the driver does not support the headphone
+and speaker parameters, but you can achieve the same effect with
+audioctl(1), for example:
+ audioctl -w play.port=1
+will select the speaker, while a value of 2 would have selected the
+headphone.
+
+If sound is jerky, you can pass the "buffer=xx" option to the driver to
+increase its internal buffer size. The default value (when this option
+is not used) is 12; the slower your machine, the greater this value has
+to be, in the range 7-17.
+
+If you can't get libmikmod to work with your hardware, you can use its
+raw disk writer driver, in 8 bit mono 8 kHz, and send the music.raw file
+to /dev/audio with sox, using the following command line:
+ sox -t raw -c 1 -r 8000 -u -b music.raw -t raw -U -r 8000 \
+ -c 1 -b /dev/audio
+(or use the piped output driver with this command line)
+
+Or if you played in 16 bit stereo, you can convert the file to a .au
+file:
+ audioconvert -o music.au -f sun \
+ -i rate=44.1k,channels=stereo,encoding=linear16 music.raw
+and play the file:
+ audioplay -p headphone -v 10 music.au
+
+
+>> SAM9407 DRIVER SPECIFIC INFORMATION (Linux specific)
+--------------------------------------
+
+The SAM9407 driver provides an OSS-compatible driver for the soundcards
+based on the sam9407 audio chip (MaxiSound 64 and Terratec EWS, among
+others), and provides advanced features such as hardware module
+playback.
+
+You can find more information on this driver on the web:
+ http://www.anime.net/~sam9407
+
+The version of the libmikmod sam9407 driver coincides with the latest sam9407
+driver release available when this version of libmikmod was released; for the
+3.1.10 release, this is sam9407 driver v1.0.0.
+
+
+>> THANKS
+---------
+
+I would like to thank everyone who contributed to libmikmod. Their names
+are in the AUTHORS file for the significative contributions, but some
+other names can be found in the NEWS file. Thanks a lot! Keeping
+libmikmod alive wouldn't be much fun without you.
+
+
+>> LICENSE
+----------
+
+The libmikmod sound library is covered by the GNU Library General Public
+License as published by the Free Software Fundation (you'll find it in
+the file COPYING.LIB); either version 2 of the licence, or (at your
+option) any later version.
+
+The GNU Lesser General Public License, version 2.1, in file
+COPYING.LESSER, can be considered as a later version of the LGPL, and is
+strongly recommended for people who will embed libmikmod in their
+application as a shared library.
+
+Parts of the library (in playercode/mdulaw.c) are derived from the files
+libst.h and raw.c from an old version of the sox (SOund eXchange)
+package written by Lance Norskog and Jef Poskanzer. The following
+copyright notice applies to these parts:
+
+ Copyright (C) 1989 by Jef Poskanzer.
+
+ Permission to use, copy, modify, and distribute this software and its
+ documentation for any purpose and without fee is hereby granted, provided
+ that the above copyright notice appear in all copies and that both that
+ copyright notice and this permission notice appear in supporting
+ documentation. This software is provided "as is" without express or
+ implied warranty.
+
+
+>> CONTACT AND DOWNLOAD INFO
+----------------------------
+
+libmikmod home page is located at SourceForge:
+
+ http://mikmod.sourceforge.net/
+ http://sourceforge.net/projects/mikmod/
+
+There's a mailing list (mikmod-public) for discussing the development
+of MikMod (new features, bugs, ideas...) Look for more information on
+the web site.
+
--- /dev/null
+ Hello folks !\r
+\r
+\r
+This is libmikmod, version 3.3.10, a portable sound library for DOS.\r
+Comments & feedback are welcome.\r
+\r
+\r
+>> BUILDING LIBMIKMOD\r
+---------------------\r
+\r
+- If you're not building libmikmod for DOS, then you're lost in the sources.\r
+ Go up one directory, and read the main README file.\r
+\r
+This port has been designed to work only with DJGPP compiler. However, it\r
+should not be too complex to make it compile with any other compiler. If you\r
+manage to make libmikmod compile and work with another compiler, we'd like to\r
+hear from you. You'll likely have to write an appropiate makefile, or build\r
+things manually ...\r
+\r
+If you have all proper tools installed, just type\r
+\r
+ make -f Makefile.dj\r
+\r
+To make your library ready to use, copy the files 'libmikmod.a' and\r
+'include/mikmod.h' to your '%DJGPP%/lib' and '%DJGPP%/include' directories\r
+respectively.\r
+\r
+HTML documentation of the library, for programmers, is located in the doc\r
+directory.\r
+\r
+\r
+>> SUPPORTED SOUNDCARDS\r
+-----------------------\r
+\r
+Currently three brands of sound cards are supported under DOS:\r
+\r
+- Gravis Ultrasound and compatibles. Not tested with Interwave cards. If\r
+ somebody has one and can debug the code under Interwave, please drop us a note\r
+ (see email at bottom).\r
+\r
+- SoundBlaster and compatibles. There is only one driver that supports all\r
+ flavours of SoundBlasters:\r
+\r
+ + SB original (8-bit mono, 22KHz)\r
+ + SB 2.0 (DMA autoinit mode -> less clicks, 44KHz 8-bit mono).\r
+ + SB Pro (8-bit 22KHz stereo, 8-bit 44KHz mono)\r
+ + SB 16+ (8- and 16-bit stereo, up to 44Khz both)\r
+\r
+ Note that SB16 should cover AWE32/64 as well...\r
+\r
+- Windows Sound System and compatibles. Most today SoundBlaster clones\r
+ (including the CS4236B card used for testing) emulates (in hardware) WSS.\r
+ That's because Creative Labs copyrighted the SB16 interface and thus\r
+ clonemakers cannot do similar hardware without violating their rights, so\r
+ most of them only emulate SB Pro (see above).\r
+\r
+ WSS supports up to 44KHz 16-bit stereo. The following playback rates (in both\r
+ 8- and 16-bit) are supported: 5510, 6620, 8000, 9600, 11025, 16000, 18900,\r
+ 22050, 27420, 32000, 33075, 37800, 44100 and 48000 Hz.\r
+\r
+\r
+>> THANKS\r
+---------\r
+\r
+We would like to thank everyone who contributed to libmikmod. Their names\r
+are in the AUTHORS file for the significative contributions, but some other\r
+names can be found in the NEWS file. Thanks a lot ! Keeping libmikmod alive\r
+wouldn't be much fun without you.\r
+\r
+\r
+>> LICENSE\r
+----------\r
+\r
+The libmikmod sound library is covered by the GNU Library General Public\r
+License as published by the Free Software Fundation (you'll find it in the\r
+file COPYING.LIB) ; either version 2 of the licence, or (at your option)\r
+any later version.\r
+\r
+The GNU Lesser General Public License, version 2.1, in file COPYING.LESSER, can\r
+be considered as a later version of the LGPL, and is strongly recommended for\r
+people who will embed libmikmod in their application as a shared library.\r
+\r
+\r
+>> CONTACT AND DOWNLOAD INFO\r
+----------------------------\r
+\r
+libmikmod home page is located at SourceForge:\r
+\r
+ http://mikmod.sourceforge.net/\r
+ http://sourceforge.net/projects/mikmod/\r
+\r
+There's a mailing list (mikmod-public) for discussing the development\r
+of MikMod (new features, bugs, ideas...) Look for more information on\r
+the web site.\r
+\r
+Things related to the DOS port should also be forwarded to the DOS\r
+``portmaster'', Andrew Zabolotny, at: bit@eltech.ru\r
+\r
+\r
+>> LAST NOTES\r
+-------------\r
+\r
+We hope you'll enjoy using this version of libmikmod as well as we enjoyed\r
+debugging and improving it.\r
+\r
+-- Miodrag ("Miod") Vallat, 10/19/1999\r
+ miodrag@mikmod.darkorb.net\r
+\r
+ Andrew Zabolotny\r
+ bit@eltech.ru\r
--- /dev/null
+#define HAVE_LIMITS_H 1
+#define HAVE_MEMCMP 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRING_H 1
+#define HAVE_STRSTR 1
+
+#ifdef DOS
+#define DRV_SB 1
+#define DRV_ULTRA 1
+#define DRV_WSS 1
+
+#define HAVE_UNISTD_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_IOCTL_H 1
+#endif
+
+#if defined(__unix__) || defined(__APPLE__)
+#define DRV_SDL 1
+
+#define HAVE_FCNTL_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_SYS_IOCTL_H 1
+#define HAVE_SNPRINTF 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_WAIT_H 1
+#define HAVE_UNISTD_H 1
+#define HAVE_POSIX_MEMALIGN 1
+#define HAVE_PTHREAD 1
+#define HAVE_SETENV 1
+#define HAVE_SRANDOM 1
+
+#define MIKMOD_UNIX 1
+#endif
+
+
+#if defined(WIN32)
+#define DRV_SDL 1
+
+#define HAVE_WINDOWS_H 1
+#define HAVE_MALLOC_H 1
+
+#define NO_SDL_CONFIG 1
+#endif
+
+#undef MIKMOD_DEBUG
+
+/* disable the high quality mixer (build only with the standart mixer) */
+#undef NO_HQMIXER
+
+/* Name of package */
+#undef PACKAGE
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Version number of package */
+#undef VERSION
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+ significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+# define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+# undef WORDS_BIGENDIAN
+# endif
+#endif
+
+/* Define to `__inline__' or `__inline' if that's what the C compiler
+ calls it, or to nothing if 'inline' is not supported under any name. */
+#if !defined(__cplusplus) && defined(_MSC_VER)
+#define inline __inline
+#endif
--- /dev/null
+/* MikMod sound library (c) 2003-2015 Raphael Assenat and others -
+ * see AUTHORS file for a complete list.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* MMCMP ("ziRCONia") decompression support
+ *
+ * Based on the public domain version from the libmodplug library by
+ * Olivier Lapicque <olivierl@jps.net> (sezero's fork of libmodplug
+ * at github: http://github.com/sezero/libmodplug/tree/sezero )
+ *
+ * Rewritten for libmikmod by O. Sezer <sezero@users.sourceforge.net>
+ * with some extra ideas from the libxmp version by Claudio Matsuoka.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*#define MMCMP_DEBUG*/
+
+typedef struct MMCMPFILEHDR
+{
+ UBYTE id[8]; /* string 'ziRCONia' */
+ UWORD hdrsize; /* sizeof MMCMPHEADER */
+} MMCMPFILEHDR; /* 10 bytes */
+
+typedef struct MMCMPHEADER
+{
+ UWORD version;
+ UWORD nblocks;
+ ULONG filesize;
+ ULONG blktable;
+ UBYTE glb_comp;
+ UBYTE fmt_comp;
+} MMCMPHEADER; /* 14 bytes */
+
+typedef struct MMCMPBLOCK
+{
+ ULONG unpk_size;
+ ULONG pk_size;
+ ULONG xor_chk;
+ UWORD sub_blk;
+ UWORD flags;
+ UWORD tt_entries;
+ UWORD num_bits;
+} MMCMPBLOCK; /* 20 bytes */
+
+typedef struct MMCMPSUBBLOCK
+{
+ ULONG unpk_pos;
+ ULONG unpk_size;
+} MMCMPSUBBLOCK; /* 8 bytes */
+
+#define MMCMP_COMP 0x0001
+#define MMCMP_DELTA 0x0002
+#define MMCMP_16BIT 0x0004
+#define MMCMP_STEREO 0x0100
+#define MMCMP_ABS16 0x0200
+#define MMCMP_ENDIAN 0x0400
+
+
+typedef struct MMCMPBITBUFFER
+{
+ ULONG bitcount;
+ ULONG bitbuffer;
+ const UBYTE *start;
+ const UBYTE *end;
+} MMCMPBITBUFFER;
+
+static ULONG MMCMP_GetBits(MMCMPBITBUFFER* b, ULONG nBits)
+{
+ ULONG d;
+ if (!nBits) return 0;
+ while (b->bitcount < 24)
+ {
+ b->bitbuffer |= ((b->start < b->end) ? *b->start++ : 0) << b->bitcount;
+ b->bitcount += 8;
+ }
+ d = b->bitbuffer & ((1 << nBits) - 1);
+ b->bitbuffer >>= nBits;
+ b->bitcount -= nBits;
+ return d;
+}
+
+static const ULONG MMCMP8BitCommands[8] =
+{
+ 0x01, 0x03, 0x07, 0x0F, 0x1E, 0x3C, 0x78, 0xF8
+};
+
+static const ULONG MMCMP8BitFetch[8] =
+{
+ 3, 3, 3, 3, 2, 1, 0, 0
+};
+
+static const ULONG MMCMP16BitCommands[16] =
+{
+ 0x01, 0x03, 0x07, 0x0F, 0x1E, 0x3C, 0x78, 0xF0,
+ 0x1F0, 0x3F0, 0x7F0, 0xFF0, 0x1FF0, 0x3FF0, 0x7FF0, 0xFFF0
+};
+
+static const ULONG MMCMP16BitFetch[16] =
+{
+ 4, 4, 4, 4, 3, 2, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+BOOL MMCMP_Unpack(MREADER* reader, void** out, long* outlen)
+{
+ ULONG srclen, destlen;
+ UBYTE *destbuf, *destptr;
+ MMCMPHEADER mmh;
+ ULONG *pblk_table;
+ MMCMPSUBBLOCK *subblocks;
+ ULONG i, blockidx, numsubs;
+ UBYTE *buf; ULONG bufsize;
+
+ _mm_fseek(reader,0,SEEK_END);
+ srclen = _mm_ftell(reader);
+ if (srclen < 256) return 0;
+
+ _mm_rewind(reader);
+ if (_mm_read_I_ULONG(reader) != 0x4352697A) /* 'ziRC' */
+ return 0;
+ if (_mm_read_I_ULONG(reader) != 0x61694e4f) /* 'ONia' */
+ return 0;
+ if (_mm_read_I_UWORD(reader) != 14) /* header size */
+ return 0;
+
+ mmh.version = _mm_read_I_UWORD(reader);
+ mmh.nblocks = _mm_read_I_UWORD(reader);
+ mmh.filesize = _mm_read_I_ULONG(reader);
+ mmh.blktable = _mm_read_I_ULONG(reader);
+ mmh.glb_comp = _mm_read_UBYTE(reader);
+ mmh.fmt_comp = _mm_read_UBYTE(reader);
+
+ if ((!mmh.nblocks) || (mmh.filesize < 16) || (mmh.filesize > 0x8000000) ||
+ (mmh.blktable >= srclen) || (mmh.blktable + 4*mmh.nblocks > srclen)) {
+ return 0;
+ }
+ destlen = mmh.filesize;
+ numsubs = 32;
+ bufsize = 65536;
+
+ destbuf = (UBYTE*)MikMod_malloc(destlen);
+ buf = (UBYTE*)MikMod_malloc(bufsize);
+ pblk_table = (ULONG*)MikMod_malloc(mmh.nblocks*4);
+ subblocks = (MMCMPSUBBLOCK*)MikMod_malloc(numsubs*sizeof(MMCMPSUBBLOCK));
+ if (!destbuf || !buf || !pblk_table || !subblocks)
+ goto err;
+
+ _mm_fseek(reader,mmh.blktable,SEEK_SET);
+ for (blockidx = 0; blockidx < mmh.nblocks; blockidx++) {
+ pblk_table[blockidx] = _mm_read_I_ULONG(reader);
+ }
+
+ for (blockidx = 0; blockidx < mmh.nblocks; blockidx++)
+ {
+ ULONG srcpos = pblk_table[blockidx];
+ MMCMPBLOCK block;
+
+ if (srcpos + 20 >= srclen) goto err;
+
+ _mm_fseek(reader,srcpos,SEEK_SET);
+ block.unpk_size = _mm_read_I_ULONG(reader);
+ block.pk_size = _mm_read_I_ULONG(reader);
+ block.xor_chk = _mm_read_I_ULONG(reader);
+ block.sub_blk = _mm_read_I_UWORD(reader);
+ block.flags = _mm_read_I_UWORD(reader);
+ block.tt_entries = _mm_read_I_UWORD(reader);
+ block.num_bits = _mm_read_I_UWORD(reader);
+
+ if (!block.unpk_size || !block.pk_size || !block.sub_blk)
+ goto err;
+ if (block.pk_size <= block.tt_entries)
+ goto err;
+ if (block.flags & MMCMP_COMP) {
+ if (block.flags & MMCMP_16BIT) {
+ if (block.num_bits >= 16)
+ goto err;
+ }
+ else {
+ if (block.num_bits >= 8)
+ goto err;
+ }
+ }
+
+ srcpos += 20 + block.sub_blk*8;
+ if (srcpos >= srclen) goto err;
+
+ if (numsubs < block.sub_blk) {
+ numsubs = (block.sub_blk + 31) & ~31;
+ MikMod_free(subblocks);
+ subblocks = (MMCMPSUBBLOCK*)MikMod_malloc(numsubs*sizeof(MMCMPSUBBLOCK));
+ if (!subblocks) goto err;
+ }
+ for (i = 0; i < block.sub_blk; i++) {
+ subblocks[i].unpk_pos = _mm_read_I_ULONG(reader);
+ subblocks[i].unpk_size = _mm_read_I_ULONG(reader);
+ if (subblocks[i].unpk_pos >= destlen) goto err;
+ if (subblocks[i].unpk_size > destlen) goto err;
+ if (subblocks[i].unpk_size > destlen - subblocks[i].unpk_pos) goto err;
+ }
+
+#ifdef MMCMP_DEBUG
+ fprintf(stderr, "block %u: flags=%04X sub_blocks=%u",
+ blockidx, (unsigned)block.flags, (unsigned)block.sub_blk);
+ fprintf(stderr, " pksize=%u unpksize=%u", block.pk_size, block.unpk_size);
+ fprintf(stderr, " tt_entries=%u num_bits=%u\n", block.tt_entries, block.num_bits);
+#endif
+ if (!(block.flags & MMCMP_COMP))
+ { /* Data is not packed */
+ _mm_fseek(reader,srcpos,SEEK_SET);
+ destptr = destbuf + subblocks[0].unpk_pos;
+ i = 0;
+
+ while (1) {
+#ifdef MMCMP_DEBUG
+ fprintf(stderr, " Unpacked sub-block %u: offset %u, size=%u\n",
+ i, subblocks[i].unpk_pos, subblocks[i].unpk_size);
+#endif
+ _mm_read_UBYTES(destptr,subblocks[i].unpk_size,reader);
+ destptr += subblocks[i].unpk_size;
+ if (++i == block.sub_blk) break;
+ }
+ }
+ else if (block.flags & MMCMP_16BIT)
+ { /* Data is 16-bit packed */
+ MMCMPBITBUFFER bb;
+ ULONG size;
+ ULONG pos = 0;
+ ULONG numbits = block.num_bits;
+ ULONG oldval = 0;
+
+#ifdef MMCMP_DEBUG
+ fprintf(stderr, " 16-bit block: pos=%u size=%u ",
+ subblocks[0].unpk_pos, subblocks[0].unpk_size);
+ if (block.flags & MMCMP_DELTA) fprintf(stderr, "DELTA ");
+ if (block.flags & MMCMP_ABS16) fprintf(stderr, "ABS16 ");
+ fprintf(stderr, "\n");
+#endif
+ size = block.pk_size - block.tt_entries;
+ if (bufsize < size) {
+ while (bufsize < size) bufsize += 65536;
+ MikMod_free(buf);
+ if (!(buf = (UBYTE*)MikMod_malloc(bufsize)))
+ goto err;
+ }
+
+ bb.bitcount = 0;
+ bb.bitbuffer = 0;
+ bb.start = buf;
+ bb.end = buf + size;
+
+ _mm_fseek(reader,srcpos+block.tt_entries,SEEK_SET);
+ _mm_read_UBYTES(buf,size,reader);
+ destptr = destbuf + subblocks[0].unpk_pos;
+ size = subblocks[0].unpk_size;
+ i = 0;
+
+ while (1)
+ {
+ ULONG newval = 0x10000;
+ ULONG d = MMCMP_GetBits(&bb, numbits+1);
+
+ if (d >= MMCMP16BitCommands[numbits])
+ {
+ ULONG nFetch = MMCMP16BitFetch[numbits];
+ ULONG newbits = MMCMP_GetBits(&bb, nFetch) + ((d - MMCMP16BitCommands[numbits]) << nFetch);
+ if (newbits != numbits)
+ {
+ numbits = newbits & 0x0F;
+ } else
+ {
+ if ((d = MMCMP_GetBits(&bb, 4)) == 0x0F)
+ {
+ if (MMCMP_GetBits(&bb, 1)) break;
+ newval = 0xFFFF;
+ } else
+ {
+ newval = 0xFFF0 + d;
+ }
+ }
+ } else
+ {
+ newval = d;
+ }
+ if (newval < 0x10000)
+ {
+ newval = (newval & 1) ? (ULONG)(-(SLONG)((newval+1) >> 1)) : (ULONG)(newval >> 1);
+ if (block.flags & MMCMP_DELTA)
+ {
+ newval += oldval;
+ oldval = newval;
+ } else
+ if (!(block.flags & MMCMP_ABS16))
+ {
+ newval ^= 0x8000;
+ }
+ destptr[pos++] = (UBYTE) (((UWORD)newval) & 0xff);
+ destptr[pos++] = (UBYTE) (((UWORD)newval) >> 8);
+ }
+ if (pos >= size)
+ {
+ if (++i == block.sub_blk) break;
+ size = subblocks[i].unpk_size;
+ destptr = destbuf + subblocks[i].unpk_pos;
+ pos = 0;
+ }
+ }
+ }
+ else
+ { /* Data is 8-bit packed */
+ MMCMPBITBUFFER bb;
+ ULONG size;
+ ULONG pos = 0;
+ ULONG numbits = block.num_bits;
+ ULONG oldval = 0;
+ UBYTE ptable[0x100];
+
+ size = block.pk_size - block.tt_entries;
+ if (bufsize < size) {
+ while (bufsize < size) bufsize += 65536;
+ MikMod_free(buf);
+ if (!(buf = (UBYTE*)MikMod_malloc(bufsize)))
+ goto err;
+ }
+
+ bb.bitcount = 0;
+ bb.bitbuffer = 0;
+ bb.start = buf;
+ bb.end = buf + size;
+
+ _mm_read_UBYTES(ptable,0x100,reader);
+ _mm_fseek(reader,srcpos+block.tt_entries,SEEK_SET);
+ _mm_read_UBYTES(buf,size,reader);
+ destptr = destbuf + subblocks[0].unpk_pos;
+ size = subblocks[0].unpk_size;
+ i = 0;
+
+ while (1)
+ {
+ ULONG newval = 0x100;
+ ULONG d = MMCMP_GetBits(&bb, numbits+1);
+
+ if (d >= MMCMP8BitCommands[numbits])
+ {
+ ULONG nFetch = MMCMP8BitFetch[numbits];
+ ULONG newbits = MMCMP_GetBits(&bb, nFetch) + ((d - MMCMP8BitCommands[numbits]) << nFetch);
+ if (newbits != numbits)
+ {
+ numbits = newbits & 0x07;
+ } else
+ {
+ if ((d = MMCMP_GetBits(&bb, 3)) == 7)
+ {
+ if (MMCMP_GetBits(&bb, 1)) break;
+ newval = 0xFF;
+ } else
+ {
+ newval = 0xF8 + d;
+ }
+ }
+ } else
+ {
+ newval = d;
+ }
+ if (newval < 0x100)
+ {
+ int n = ptable[newval];
+ if (block.flags & MMCMP_DELTA)
+ {
+ n += oldval;
+ oldval = n;
+ }
+ destptr[pos++] = (UBYTE)n;
+ }
+ if (pos >= size)
+ {
+ if (++i == block.sub_blk) break;
+ size = subblocks[i].unpk_size;
+ destptr = destbuf + subblocks[i].unpk_pos;
+ pos = 0;
+ }
+ }
+ }
+ }
+
+ MikMod_free(buf);
+ MikMod_free(pblk_table);
+ MikMod_free(subblocks);
+ *out = destbuf;
+ *outlen = destlen;
+ return 1;
+
+ err:
+ MikMod_free(buf);
+ MikMod_free(pblk_table);
+ MikMod_free(subblocks);
+ MikMod_free(destbuf);
+ return 0;
+}
--- /dev/null
+/* MikMod sound library (c) 2003-2015 Raphael Assenat and others -
+ * see AUTHORS file for a complete list.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* amiga Powerpack PP20 decompression support
+ *
+ * Code from Heikki Orsila's amigadepack 0.02
+ * based on code by Stuart Caie <kyzer@4u.net>
+ * This software is in the Public Domain
+ *
+ * Modified for xmp by Claudio Matsuoka, 08/2007
+ * - merged mld's checks from the old depack sources. Original credits:
+ * - corrupt file and data detection
+ * (thanks to Don Adan and Dirk Stoecker for help and infos)
+ * - implemeted "efficiency" checks
+ * - further detection based on code by Georg Hoermann
+ *
+ * Modified for xmp by Claudio Matsuoka, 05/2013
+ * - decryption code removed
+ *
+ * Modified for libmikmod by O. Sezer, Apr. 2015, with a few extra bits
+ * from the libmodplug library by Olivier Lapicque.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+#define PP_READ_BITS(nbits, var) do { \
+ bit_cnt = (nbits); \
+ while (bits_left < bit_cnt) { \
+ if (buf_src < src) return 0; /* out of source bits */ \
+ bit_buffer |= (*--buf_src << bits_left); \
+ bits_left += 8; \
+ } \
+ (var) = 0; \
+ bits_left -= bit_cnt; \
+ while (bit_cnt--) { \
+ (var) = ((var) << 1) | (bit_buffer & 1); \
+ bit_buffer >>= 1; \
+ } \
+} while(0)
+
+#define PP_BYTE_OUT(byte) do { \
+ if (out <= dest) return 0; /* output overflow */ \
+ *--out = (byte); \
+ written++; \
+} while (0)
+
+static BOOL ppDecrunch(const UBYTE *src, UBYTE *dest,
+ const UBYTE *offset_lens,
+ ULONG src_len, ULONG dest_len,
+ UBYTE skip_bits)
+{
+ ULONG bit_buffer, x, todo, offbits, offset, written;
+ const UBYTE *buf_src;
+ UBYTE *out, *dest_end, bits_left, bit_cnt;
+
+ /* set up input and output pointers */
+ buf_src = src + src_len;
+ out = dest_end = dest + dest_len;
+
+ written = 0;
+ bit_buffer = 0;
+ bits_left = 0;
+
+ /* skip the first few bits */
+ PP_READ_BITS(skip_bits, x);
+
+ /* while there are input bits left */
+ while (written < dest_len) {
+ PP_READ_BITS(1, x);
+ if (x == 0) {
+ /* 1bit==0: literal, then match. 1bit==1: just match */
+ todo = 1; do { PP_READ_BITS(2, x); todo += x; } while (x == 3);
+ while (todo--) { PP_READ_BITS(8, x); PP_BYTE_OUT(x); }
+
+ /* should we end decoding on a literal, break out of the main loop */
+ if (written == dest_len) break;
+ }
+
+ /* match: read 2 bits for initial offset bitlength / match length */
+ PP_READ_BITS(2, x);
+ offbits = offset_lens[x];
+ todo = x+2;
+ if (x == 3) {
+ PP_READ_BITS(1, x);
+ if (x==0) offbits = 7;
+ PP_READ_BITS(offbits, offset);
+ do { PP_READ_BITS(3, x); todo += x; } while (x == 7);
+ }
+ else {
+ PP_READ_BITS(offbits, offset);
+ }
+ if ((out + offset) >= dest_end) return 0; /* match overflow */
+ while (todo--) { x = out[offset]; PP_BYTE_OUT(x); }
+ }
+
+ /* all output bytes written without error */
+ return 1;
+ /* return (src == buf_src) ? 1 : 0; */
+}
+
+BOOL PP20_Unpack(MREADER* reader, void** out, long* outlen)
+{
+ ULONG srclen, destlen;
+ UBYTE *destbuf, *srcbuf;
+ UBYTE tmp[4], skip;
+ BOOL ret;
+
+ /* PP FORMAT:
+ * 1 longword identifier 'PP20' or 'PX20'
+ * [1 word checksum (if 'PX20') $ssss]
+ * 1 longword efficiency $eeeeeeee
+ * X longwords crunched file $cccccccc,$cccccccc,...
+ * 1 longword decrunch info 'decrlen' << 8 | '8 bits other info'
+ */
+
+ _mm_fseek(reader,0,SEEK_END);
+ srclen = _mm_ftell(reader);
+ if (srclen < 256) return 0;
+ /* file length should be a multiple of 4 */
+ if (srclen & 3) return 0;
+
+ _mm_rewind(reader);
+ if (_mm_read_I_ULONG(reader) != 0x30325050) /* 'PP20' */
+ return 0;
+
+ _mm_fseek(reader,srclen-4,SEEK_SET);
+ _mm_read_UBYTES(tmp,4,reader);
+ destlen = tmp[0] << 16;
+ destlen |= tmp[1] << 8;
+ destlen |= tmp[2];
+ skip = tmp[3];
+
+ _mm_fseek(reader,4,SEEK_SET);
+ _mm_read_UBYTES(tmp,4,reader);
+
+ /* original pp20 only support efficiency
+ * from 9 9 9 9 up to 9 10 12 13, afaik,
+ * but the xfd detection code says this...
+ *
+ * move.l 4(a0),d0
+ * cmp.b #9,d0
+ * blo.b .Exit
+ * and.l #$f0f0f0f0,d0
+ * bne.s .Exit
+ */
+ if ((tmp[0] < 9) || (tmp[0] & 0xf0)) return 0;
+ if ((tmp[1] < 9) || (tmp[1] & 0xf0)) return 0;
+ if ((tmp[2] < 9) || (tmp[2] & 0xf0)) return 0;
+ if ((tmp[3] < 9) || (tmp[3] & 0xf0)) return 0;
+
+ if ((destlen < 512) || (destlen > 0x400000) || (destlen > 16*srclen))
+ return 0;
+ if ((destbuf = (UBYTE*)MikMod_malloc(destlen)) == NULL)
+ return 0;
+
+ srclen -= 12;
+ if ((srcbuf = (UBYTE*)MikMod_malloc(srclen)) == NULL) {
+ MikMod_free(destbuf);
+ return 0;
+ }
+ _mm_read_UBYTES(srcbuf,srclen,reader);
+
+ ret = ppDecrunch(srcbuf, destbuf, tmp, srclen, destlen, skip);
+ MikMod_free(srcbuf);
+
+ if (!ret) {
+ MikMod_free(destbuf);
+ }
+ else {
+ *out = destbuf;
+ *outlen = destlen;
+ }
+ return ret;
+}
--- /dev/null
+/* MikMod sound library (c) 2003-2015 Raphael Assenat and others -
+ * see AUTHORS file for a complete list.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/*
+ * StoneCracker S404 algorithm data decompression routine
+ * (c) 2006 Jouni 'Mr.Spiv' Korhonen. The code is in public domain.
+ *
+ * modified for xmp by Claudio Matsuoka, Jan 2010
+ * modified for libmikmod by O. Sezer -- May 2015
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+/*#include <assert.h>*/
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+
+/*#define STC_DEBUG*/
+
+static UWORD readmem16b(UBYTE *m)
+{
+ ULONG a, b;
+ a = m[0];
+ b = m[1];
+ return (a << 8) | b;
+}
+
+struct bitstream {
+ /* bit buffer for rolling data bit by bit from the compressed file */
+ ULONG word;
+
+ /* bits left in the bit buffer */
+ int left;
+
+ /* compressed data source */
+ UWORD *src;
+ UBYTE *orgsrc;
+};
+
+static int initGetb(struct bitstream *bs, UBYTE *src, ULONG src_length)
+{
+ int eff;
+
+ bs->src = (UWORD *) (src + src_length);
+ bs->orgsrc = src;
+
+ bs->left = readmem16b((UBYTE *)bs->src); /* bit counter */
+#ifdef STC_DEBUG
+ if (bs->left & (~0xf))
+ fprintf(stderr, "Worked around an ancient stc bug\n");
+#endif
+ /* mask off any corrupt bits */
+ bs->left &= 0x000f;
+ bs->src--;
+
+ /* get the first 16-bits of the compressed stream */
+ bs->word = readmem16b((UBYTE *)bs->src);
+ bs->src--;
+
+ eff = readmem16b((UBYTE *)bs->src); /* efficiency */
+ bs->src--;
+
+ return eff;
+}
+
+/* get nbits from the compressed stream */
+static int getb(struct bitstream *bs, int nbits)
+{
+ bs->word &= 0x0000ffff;
+
+ /* If not enough bits in the bit buffer, get more */
+ if (bs->left < nbits) {
+ bs->word <<= bs->left;
+ /*assert((bs->word & 0x0000ffffU) == 0);*/
+
+ /* Check that we don't go out of bounds */
+ if (bs->orgsrc > (UBYTE *)bs->src) {
+ return -1;
+ }
+
+ bs->word |= readmem16b((UBYTE *)bs->src);
+ bs->src--;
+
+ nbits -= bs->left;
+ bs->left = 16; /* 16 unused (and some used) bits left in the word */
+ }
+
+ /* Shift nbits off the word and return them */
+ bs->left -= nbits;
+ bs->word <<= nbits;
+ return bs->word >> 16;
+}
+
+static int decompressS404(UBYTE *src, UBYTE *orgdst,
+ SLONG dst_length, SLONG src_length)
+{
+ UWORD w;
+ SLONG eff;
+ SLONG n;
+ UBYTE *dst;
+ SLONG oLen = dst_length;
+ struct bitstream bs;
+ int x;
+
+ dst = orgdst + oLen;
+
+ eff = initGetb(&bs, src, src_length);
+
+ while (oLen > 0) {
+ x = getb(&bs, 9);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+
+ w = x;
+
+ if (w < 0x100) {
+ if (orgdst >= dst) {
+ return -1;
+ }
+ *--dst = w;
+ oLen--;
+ } else if (w == 0x13e || w == 0x13f) {
+ w <<= 4;
+ x = getb(&bs, 4);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+
+ n = (w & 0x1f) + 14;
+ oLen -= n;
+ while (n-- > 0) {
+ x = getb(&bs, 8);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w = x;
+
+ if (orgdst >= dst) {
+ return -1;
+ }
+
+ *--dst = w;
+ }
+ } else {
+ if (w >= 0x180) {
+ /* copy 2-3 */
+ n = w & 0x40 ? 3 : 2;
+
+ if (w & 0x20) {
+ /* dist 545 -> */
+ w = (w & 0x1f) << (eff - 5);
+ x = getb(&bs, eff - 5);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 544;
+ } else if (w & 0x30) {
+ /* dist 1 -> 32 */
+ w = (w & 0x0f) << 1;
+ x = getb(&bs, 1);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ } else {
+ /* dist 33 -> 544 */
+ w = (w & 0x0f) << 5;
+ x = getb(&bs, 5);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 32;
+ }
+ } else if (w >= 0x140) {
+ /* copy 4-7 */
+ n = ((w & 0x30) >> 4) + 4;
+
+ if (w & 0x08) {
+ /* dist 545 -> */
+ w = (w & 0x07) << (eff - 3);
+ x = getb(&bs, eff - 3);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 544;
+ } else if (w & 0x0c) {
+ /* dist 1 -> 32 */
+ w = (w & 0x03) << 3;
+ x = getb(&bs, 3);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ } else {
+ /* dist 33 -> 544 */
+ w = (w & 0x03) << 7;
+ x = getb(&bs, 7);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 32;
+ }
+ } else if (w >= 0x120) {
+ /* copy 8-22 */
+ n = ((w & 0x1e) >> 1) + 8;
+
+ if (w & 0x01) {
+ /* dist 545 -> */
+ x = getb(&bs, eff);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w = x;
+ w += 544;
+ } else {
+ x = getb(&bs, 6);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w = x;
+
+ if (w & 0x20) {
+ /* dist 1 -> 32 */
+ w &= 0x1f;
+ } else {
+ /* dist 33 -> 544 */
+ w <<= 4;
+ x = getb(&bs, 4);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 32;
+ }
+ }
+ } else {
+ w = (w & 0x1f) << 3;
+ x = getb(&bs, 3);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ n = 23;
+
+ while (w == 0xff) {
+ n += w;
+ x = getb(&bs, 8);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w = x;
+ }
+ n += w;
+
+ x = getb(&bs, 7);
+ w = x;
+
+ if (w & 0x40) {
+ /* dist 545 -> */
+ w = (w & 0x3f) << (eff - 6);
+ x = getb(&bs, eff - 6);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 544;
+ } else if (w & 0x20) {
+ /* dist 1 -> 32 */
+ w &= 0x1f;
+ } else {
+ /* dist 33 -> 544; */
+ w <<= 4;
+ x = getb(&bs, 4);
+ /* Sanity check */
+ if (x < 0) {
+ return -1;
+ }
+ w |= x;
+ w += 32;
+ }
+ }
+
+ oLen -= n;
+
+ while (n-- > 0) {
+ dst--;
+ if (dst < orgdst || (dst + w + 1) >= (orgdst + dst_length))
+ return -1;
+ *dst = dst[w + 1];
+ }
+ }
+ }
+
+ return 0;
+}
+
+BOOL S404_Unpack(MREADER *reader, void **out, long *outlen)
+{
+ SLONG iLen, sLen, oLen, pLen;
+ UBYTE *src, *dst = NULL;
+ int err;
+
+ _mm_fseek(reader,0,SEEK_END);
+ iLen = _mm_ftell(reader);
+ if (iLen <= 16) return 0;
+
+ _mm_rewind(reader);
+ if (_mm_read_M_ULONG(reader) != 0x53343034) /* S404 */
+ return 0;
+
+ sLen = _mm_read_M_SLONG(reader); /* Security length */
+ oLen = _mm_read_M_SLONG(reader); /* Depacked length */
+ pLen = _mm_read_M_SLONG(reader); /* Packed length */
+#ifdef STC_DEBUG
+ fprintf(stderr,"S404: iLen= %d, sLen= %d, pLen= %d, oLen= %d\n",
+ iLen, sLen, pLen, oLen);
+#endif
+ if (sLen < 0 || oLen <= 0 || pLen <= 0) return 0;
+ if (pLen + 16 >= iLen) return 0; /* sanity check */
+
+ if (!(src = (UBYTE*) MikMod_malloc(iLen - 16)))
+ return 0;
+ if (!(dst = (UBYTE*) MikMod_malloc(oLen))) {
+ MikMod_free(src);
+ return 0;
+ }
+
+ _mm_read_UBYTES(src, iLen - 16, reader);
+ err = decompressS404(src, dst, oLen, pLen);
+ MikMod_free(src);
+
+ if (!err) {
+ *out = dst;
+ *outlen = oLen;
+ return 1;
+ }
+
+ MikMod_free(dst);
+ return 0;
+}
--- /dev/null
+/* MikMod sound library (c) 2003-2015 Raphael Assenat and others -
+ * see AUTHORS file for a complete list.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* XPK-SQSH depacker
+ * Algorithm from the portable decruncher by Bert Jahn (24.12.97)
+ * Checksum added by Sipos Attila <h430827@stud.u-szeged.hu>
+ * Rewritten for libxmp by Claudio Matsuoka
+ * Rewritten for libmikmod by O. Sezer
+ *
+ * Copyright (C) 2013 Claudio Matsuoka
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+struct io {
+ UBYTE *src;
+ UBYTE *dest;
+ int offs;
+};
+
+static const UBYTE ctable[]={
+ 2, 3, 4, 5, 6, 7, 8, 0,
+ 3, 2, 4, 5, 6, 7, 8, 0,
+ 4, 3, 5, 2, 6, 7, 8, 0,
+ 5, 4, 6, 2, 3, 7, 8, 0,
+ 6, 5, 7, 2, 3, 4, 8, 0,
+ 7, 6, 8, 2, 3, 4, 5, 0,
+ 8, 7, 6, 2, 3, 4, 5, 0
+};
+
+static UWORD readmem16b(UBYTE *m)
+{
+ ULONG a, b;
+
+ a = m[0];
+ b = m[1];
+
+ return (a << 8) | b;
+}
+
+static ULONG readmem24b(UBYTE *m)
+{
+ ULONG a, b, c;
+
+ a = m[0];
+ b = m[1];
+ c = m[2];
+
+ return (a << 16) | (b << 8) | c;
+}
+
+static UWORD xchecksum(ULONG * ptr, ULONG count)
+{
+ register ULONG sum = 0;
+
+ while (count-- > 0) {
+ sum ^= *ptr++;
+ }
+
+ return (UWORD) (sum ^ (sum >> 16));
+}
+
+static int get_bits(struct io *io, int count)
+{
+ int r = readmem24b(io->src + (io->offs >> 3));
+
+ r <<= io->offs % 8;
+ r &= 0xffffff;
+ r >>= 24 - count;
+ io->offs += count;
+
+ return r;
+}
+
+static int get_bits_final(struct io *io, int count)
+{
+ int r = readmem24b(io->src + (io->offs >> 3));
+
+ r <<= (io->offs % 8) + 8;
+ r >>= 32 - count;
+ io->offs += count;
+
+ return r;
+}
+
+static int copy_data(struct io *io, int d1, int *data, UBYTE *dest_start, UBYTE *dest_end)
+{
+ UBYTE *copy_src;
+ int dest_offset, count, copy_len;
+
+ if (get_bits(io, 1) == 0) {
+ copy_len = get_bits(io, 1) + 2;
+ } else if (get_bits(io, 1) == 0) {
+ copy_len = get_bits(io, 1) + 4;
+ } else if (get_bits(io, 1) == 0) {
+ copy_len = get_bits(io, 1) + 6;
+ } else if (get_bits(io, 1) == 0) {
+ copy_len = get_bits(io, 3) + 8;
+ } else {
+ copy_len = get_bits(io, 5) + 16;
+ }
+
+ if (get_bits(io, 1) == 0) {
+ if (get_bits(io, 1) == 0) {
+ count = 8;
+ dest_offset = 0;
+ } else {
+ count = 14;
+ dest_offset = -0x1100;
+ }
+ } else {
+ count = 12;
+ dest_offset = -0x100;
+ }
+
+ copy_len -= 3;
+
+ if (copy_len >= 0) {
+ if (copy_len != 0) {
+ d1--;
+ }
+ d1--;
+ if (d1 < 0) {
+ d1 = 0;
+ }
+ }
+
+ copy_len += 2;
+
+ copy_src = io->dest + dest_offset - get_bits(io, count) - 1;
+
+ /* Sanity check */
+ if (copy_src < dest_start || copy_src + copy_len >= dest_end) {
+ return -1;
+ }
+
+ do {
+ //printf("dest=%p src=%p end=%p\n", io->dest, copy_src, dest_end);
+ *io->dest++ = *copy_src++;
+ } while (copy_len--);
+
+ *data = *(--copy_src);
+
+ return d1;
+}
+
+static int unsqsh_block(struct io *io, UBYTE *dest_start, UBYTE *dest_end)
+{
+ int d1, d2, data, unpack_len, count, old_count;
+
+ d1 = d2 = data = old_count = 0;
+ io->offs = 0;
+
+ data = *(io->src++);
+ *(io->dest++) = data;
+
+ do {
+ if (d1 < 8) {
+ if (get_bits(io, 1)) {
+ d1 = copy_data(io, d1, &data, dest_start, dest_end);
+ if (d1 < 0)
+ return -1;
+ d2 -= d2 >> 3;
+ continue;
+ }
+ unpack_len = 0;
+ count = 8;
+ } else {
+ if (get_bits(io, 1)) {
+ count = 8;
+ if (count == old_count) {
+ if (d2 >= 20) {
+ unpack_len = 1;
+ d2 += 8;
+ } else {
+ unpack_len = 0;
+ }
+ } else {
+ count = old_count;
+ unpack_len = 4;
+ d2 += 8;
+ }
+ } else {
+ if (get_bits(io, 1) == 0) {
+ d1 = copy_data(io, d1, &data, dest_start, dest_end);
+ if (d1 < 0)
+ return -1;
+ d2 -= d2 >> 3;
+ continue;
+ }
+
+ if (get_bits(io, 1) == 0) {
+ count = 2;
+ } else {
+ if (get_bits(io, 1)) {
+ io->offs--;
+ count = get_bits(io, 3);
+ } else {
+ count = 3;
+ }
+ }
+
+ count = ctable[8 * old_count + count - 17];
+ if (count != 8) {
+ unpack_len = 4;
+ d2 += 8;
+ } else {
+ if (d2 >= 20) {
+ unpack_len = 1;
+ d2 += 8;
+ } else {
+ unpack_len = 0;
+ }
+ }
+ }
+ }
+
+ do {
+ data -= get_bits_final(io, count);
+ *io->dest++ = data;
+ } while (unpack_len--);
+
+ if (d1 != 31) {
+ d1++;
+ }
+
+ old_count = count;
+
+ d2 -= d2 >> 3;
+
+ } while (io->dest < dest_end);
+
+ return 0;
+}
+
+static int unsqsh(UBYTE *src, SLONG srclen, UBYTE *dest, SLONG destlen)
+{
+ SLONG len = destlen;
+ SLONG decrunched = 0;
+ UBYTE type;
+ SLONG packed_size, unpacked_size;
+ ULONG sum, lchk;
+ UBYTE *c, *dest_start, *dest_end;
+ UBYTE bc[3];
+ struct io io;
+
+ io.src = src;
+ io.dest = dest;
+
+ dest_start = io.dest;
+
+ c = src + 20;
+
+ while (len) {
+ /* Sanity check */
+ if (c >= src + srclen) {
+ return -1;
+ }
+
+ type = *c++;
+ c++; /* hchk */
+
+ sum = *(UWORD *)c;
+ c += 2; /* checksum */
+
+ packed_size = readmem16b(c); /* packed */
+ c += 2;
+
+ unpacked_size = readmem16b(c); /* unpacked */
+ c += 2;
+
+ /* Sanity check */
+ if (packed_size <= 0 || unpacked_size <= 0) {
+ return -1;
+ }
+ if (c + packed_size + 3 > src + srclen) {
+ return -1;
+ }
+
+ io.src = c + 2;
+ memcpy(bc, c + packed_size, 3);
+ memset(c + packed_size, 0, 3);
+ lchk = xchecksum((ULONG *) (c), (packed_size + 3) >> 2);
+ memcpy(c + packed_size, bc, 3);
+
+ if (lchk != sum) {
+ return decrunched;
+ }
+
+ if (type == 0) {
+ /* verbatim block */
+ memcpy(io.dest, c, packed_size);
+ io.dest += packed_size;
+ c += packed_size;
+ len -= packed_size;
+ decrunched += packed_size;
+ continue;
+ }
+
+ if (type != 1) {
+ /* unknown type */
+ return decrunched;
+ }
+
+ len -= unpacked_size;
+ decrunched += unpacked_size;
+
+ /* Sanity check */
+ if (decrunched > destlen) {
+ return -1;
+ }
+
+ packed_size = (packed_size + 3) & 0xfffc;
+ c += packed_size;
+ dest_end = io.dest + unpacked_size;
+
+ if (unsqsh_block(&io, dest_start, dest_end) < 0) {
+ return -1;
+ }
+
+ io.dest = dest_end;
+ }
+
+ return decrunched;
+
+}
+
+BOOL XPK_Unpack(MREADER *reader, void **out, long *outlen)
+{
+ UBYTE *src, *dest;
+ SLONG inlen, srclen, destlen;
+
+ _mm_fseek(reader,0,SEEK_END);
+ inlen = _mm_ftell(reader);
+ if (inlen <= 8 || inlen > 0x100000)
+ return 0;
+
+ _mm_rewind(reader);
+ if (_mm_read_M_ULONG(reader) != 0x58504b46) /* XPKF */
+ return 0;
+ srclen = _mm_read_M_SLONG(reader);
+ if (srclen <= 8 || srclen > 0x100000 || srclen > inlen-8)
+ return 0;
+ if (_mm_read_M_ULONG(reader) != 0x53515348) /* SQSH */
+ return 0;
+ destlen = _mm_read_M_SLONG(reader);
+ if (destlen < 0 || destlen > 0x200000)
+ return 0;
+
+ if ((src = (UBYTE*) MikMod_malloc(srclen + 3)) == NULL)
+ return 0;
+ if ((dest = (UBYTE*) MikMod_malloc(destlen + 100)) == NULL) {
+ MikMod_free(src);
+ return 0;
+ }
+
+ if (!_mm_read_UBYTES(src, srclen - 8, reader))
+ goto err;
+
+ if (unsqsh(src, srclen, dest, destlen) != destlen)
+ goto err;
+
+ *out = dest;
+ *outlen = destlen;
+
+ MikMod_free(src);
+
+ return 1;
+
+ err:
+ MikMod_free(dest);
+ MikMod_free(src);
+ return 0;
+}
+
--- /dev/null
+# GNU Makefile for building libMikMod using GCC / DJGPP environment
+#
+# Edit config.h to disable/enable certain drivers, etc, if necessary.
+#
+# Targets:
+# - all (default): make libmikmod.a, static MikMod sound library
+# - clean: clean up (remove all generated files)
+
+# Set to 1 for debug build
+DEBUG = 0
+CROSS = i586-pc-msdosdjgpp
+
+# The tools
+ifeq ($(CROSS),)
+CC=gcc
+AS=as
+AR=ar
+RANLIB=ranlib
+else
+CC=$(CROSS)-gcc
+AS=$(CROSS)-as
+AR=$(CROSS)-ar
+RANLIB=$(CROSS)-ranlib
+endif
+CFLAGS = -DMIKMOD_BUILD -DHAVE_CONFIG_H $(INCLUDE)
+INCLUDE = -I../dos -I../drivers/dos -I../include
+ARFLAGS = cr
+
+ifeq ($(DEBUG),1)
+CFLAGS += -g -Wall
+else
+CFLAGS += -O2 -Wall -fomit-frame-pointer -ffast-math
+endif
+
+.SUFFIXES:
+.SUFFIXES: .o .c
+
+COMPILE=$(CC) -c $(CFLAGS)
+
+OBJ=out/dosdma.o \
+ out/dosirq.o \
+ out/dosgus.o \
+ out/drv_ultra.o \
+ out/dossb.o \
+ out/drv_sb.o \
+ out/doswss.o \
+ out/drv_wss.o \
+ out/drv_nos.o \
+ out/strcasecmp.o \
+ out/load_it.o \
+ out/load_mod.o \
+ out/load_s3m.o \
+ out/load_xm.o \
+ out/mmalloc.o \
+ out/mmerror.o \
+ out/mmio.o \
+ out/mdriver.o \
+ out/mdreg.o \
+ out/mmcmp.o \
+ out/pp20.o \
+ out/s404.o \
+ out/xpk.o \
+ out/mloader.o \
+ out/mlreg.o \
+ out/mlutil.o \
+ out/mplayer.o \
+ out/munitrk.o \
+ out/mwav.o \
+ out/npertab.o \
+ out/sloader.o \
+ out/virtch.o \
+ out/virtch2.o \
+ out/virtch_common.o
+# out/mdulaw.o
+
+.PHONY: clean
+
+# The build targets
+TARGETS = libmikmod.a
+
+all: $(TARGETS)
+
+clean:
+ rm -rf out/*.o $(TARGETS)
+
+libmikmod.a: $(OBJ)
+ $(AR) $(ARFLAGS) $@ $^
+ $(RANLIB) $@
+
+HEADER_DEPS=../dos/config.h ../include/mikmod.h ../include/mikmod_internals.h ../include/mikmod_ctype.h
+out/drv_ultra.o: ../drivers/drv_ultra.c $(HEADER_DEPS) ../drivers/dos/libgus.h
+ $(COMPILE) ../drivers/drv_ultra.c -o out/drv_ultra.o
+out/drv_sb.o: ../drivers/drv_sb.c $(HEADER_DEPS) ../drivers/dos/dossb.h
+ $(COMPILE) ../drivers/drv_sb.c -o out/drv_sb.o
+out/drv_wss.o: ../drivers/drv_wss.c $(HEADER_DEPS) ../drivers/dos/doswss.h
+ $(COMPILE) ../drivers/drv_wss.c -o out/drv_wss.o
+out/dosgus.o: ../drivers/dos/dosgus.c $(HEADER_DEPS) ../drivers/dos/libgus.h
+ $(COMPILE) ../drivers/dos/dosgus.c -o out/dosgus.o
+out/dossb.o: ../drivers/dos/dossb.c $(HEADER_DEPS) ../drivers/dos/dossb.h
+ $(COMPILE) ../drivers/dos/dossb.c -o out/dossb.o
+out/doswss.o: ../drivers/dos/doswss.c $(HEADER_DEPS) ../drivers/dos/doswss.h
+ $(COMPILE) ../drivers/dos/doswss.c -o out/doswss.o
+out/dosdma.o: ../drivers/dos/dosdma.c $(HEADER_DEPS) ../drivers/dos/dosdma.h
+ $(COMPILE) ../drivers/dos/dosdma.c -o out/dosdma.o
+out/dosirq.o: ../drivers/dos/dosirq.c $(HEADER_DEPS) ../drivers/dos/dosirq.h
+ $(COMPILE) ../drivers/dos/dosirq.c -o out/dosirq.o
+out/drv_nos.o: ../drivers/drv_nos.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_nos.c -o out/drv_nos.o
+out/drv_raw.o: ../drivers/drv_raw.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_raw.c -o out/drv_raw.o
+out/drv_aiff.o: ../drivers/drv_aiff.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_aiff.c -o out/drv_aiff.o
+out/drv_wav.o: ../drivers/drv_wav.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_wav.c -o out/drv_wav.o
+out/drv_stdout.o: ../drivers/drv_stdout.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_stdout.c -o out/drv_stdout.o
+out/drv_pipe.o: ../drivers/drv_pipe.c $(HEADER_DEPS)
+ $(COMPILE) ../drivers/drv_pipe.c -o out/drv_pipe.o
+out/load_669.o: ../loaders/load_669.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_669.c -o out/load_669.o
+out/load_amf.o: ../loaders/load_amf.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_amf.c -o out/load_amf.o
+out/load_asy.o: ../loaders/load_asy.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_asy.c -o out/load_asy.o
+out/load_dsm.o: ../loaders/load_dsm.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_dsm.c -o out/load_dsm.o
+out/load_far.o: ../loaders/load_far.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_far.c -o out/load_far.o
+out/load_gdm.o: ../loaders/load_gdm.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_gdm.c -o out/load_gdm.o
+out/load_gt2.o: ../loaders/load_gt2.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_gt2.c -o out/load_gt2.o
+out/load_it.o: ../loaders/load_it.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_it.c -o out/load_it.o
+out/load_imf.o: ../loaders/load_imf.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_imf.c -o out/load_imf.o
+out/load_m15.o: ../loaders/load_m15.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_m15.c -o out/load_m15.o
+out/load_med.o: ../loaders/load_med.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_med.c -o out/load_med.o
+out/load_mod.o: ../loaders/load_mod.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_mod.c -o out/load_mod.o
+out/load_mtm.o: ../loaders/load_mtm.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_mtm.c -o out/load_mtm.o
+out/load_okt.o: ../loaders/load_okt.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_okt.c -o out/load_okt.o
+out/load_s3m.o: ../loaders/load_s3m.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_s3m.c -o out/load_s3m.o
+out/load_stm.o: ../loaders/load_stm.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_stm.c -o out/load_stm.o
+out/load_stx.o: ../loaders/load_stx.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_stx.c -o out/load_stx.o
+out/load_ult.o: ../loaders/load_ult.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_ult.c -o out/load_ult.o
+out/load_umx.o: ../loaders/load_umx.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_umx.c -o out/load_umx.o
+out/load_uni.o: ../loaders/load_uni.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_uni.c -o out/load_uni.o
+out/load_xm.o: ../loaders/load_xm.c $(HEADER_DEPS)
+ $(COMPILE) ../loaders/load_xm.c -o out/load_xm.o
+out/mmalloc.o: ../mmio/mmalloc.c $(HEADER_DEPS)
+ $(COMPILE) ../mmio/mmalloc.c -o out/mmalloc.o
+out/mmerror.o: ../mmio/mmerror.c $(HEADER_DEPS)
+ $(COMPILE) ../mmio/mmerror.c -o out/mmerror.o
+out/mmio.o: ../mmio/mmio.c $(HEADER_DEPS)
+ $(COMPILE) ../mmio/mmio.c -o out/mmio.o
+out/mmcmp.o: ../depackers/mmcmp.c $(HEADER_DEPS)
+ $(COMPILE) ../depackers/mmcmp.c -o out/mmcmp.o
+out/pp20.o: ../depackers/pp20.c $(HEADER_DEPS)
+ $(COMPILE) ../depackers/pp20.c -o out/pp20.o
+out/s404.o: ../depackers/s404.c $(HEADER_DEPS)
+ $(COMPILE) ../depackers/s404.c -o out/s404.o
+out/xpk.o: ../depackers/xpk.c $(HEADER_DEPS)
+ $(COMPILE) ../depackers/xpk.c -o out/xpk.o
+out/mdriver.o: ../playercode/mdriver.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mdriver.c -o out/mdriver.o
+out/mdreg.o: ../playercode/mdreg.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mdreg.c -o out/mdreg.o
+out/mdulaw.o: ../playercode/mdulaw.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mdulaw.c -o out/mdulaw.o
+out/mloader.o: ../playercode/mloader.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mloader.c -o out/mloader.o
+out/mlreg.o: ../playercode/mlreg.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mlreg.c -o out/mlreg.o
+out/mlutil.o: ../playercode/mlutil.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mlutil.c -o out/mlutil.o
+out/mplayer.o: ../playercode/mplayer.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mplayer.c -o out/mplayer.o
+out/munitrk.o: ../playercode/munitrk.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/munitrk.c -o out/munitrk.o
+out/mwav.o: ../playercode/mwav.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/mwav.c -o out/mwav.o
+out/npertab.o: ../playercode/npertab.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/npertab.c -o out/npertab.o
+out/sloader.o: ../playercode/sloader.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/sloader.c -o out/sloader.o
+out/virtch.o: ../playercode/virtch.c ../playercode/virtch_common.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/virtch.c -o out/virtch.o
+out/virtch2.o: ../playercode/virtch2.c ../playercode/virtch_common.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/virtch2.c -o out/virtch2.o
+out/virtch_common.o: ../playercode/virtch_common.c $(HEADER_DEPS)
+ $(COMPILE) ../playercode/virtch_common.c -o out/virtch_common.o
+out/strcasecmp.o: ../posix/strcasecmp.c $(HEADER_DEPS)
+ $(COMPILE) ../posix/strcasecmp.c -o out/strcasecmp.o
--- /dev/null
+ Hello folks !\r
+\r
+\r
+This is libmikmod, version 3.3.10, a portable sound library for DOS.\r
+Comments & feedback are welcome.\r
+\r
+\r
+>> BUILDING LIBMIKMOD\r
+---------------------\r
+\r
+- If you're not building libmikmod for DOS, then you're lost in the sources.\r
+ Go up one directory, and read the main README file.\r
+\r
+This port has been designed to work only with DJGPP compiler. However, it\r
+should not be too complex to make it compile with any other compiler. If you\r
+manage to make libmikmod compile and work with another compiler, we'd like to\r
+hear from you. You'll likely have to write an appropiate makefile, or build\r
+things manually ...\r
+\r
+If you have all proper tools installed, just type\r
+\r
+ make -f Makefile.dj\r
+\r
+To make your library ready to use, copy the files 'libmikmod.a' and\r
+'include/mikmod.h' to your '%DJGPP%/lib' and '%DJGPP%/include' directories\r
+respectively.\r
+\r
+HTML documentation of the library, for programmers, is located in the doc\r
+directory.\r
+\r
+\r
+>> SUPPORTED SOUNDCARDS\r
+-----------------------\r
+\r
+Currently three brands of sound cards are supported under DOS:\r
+\r
+- Gravis Ultrasound and compatibles. Not tested with Interwave cards. If\r
+ somebody has one and can debug the code under Interwave, please drop us a note\r
+ (see email at bottom).\r
+\r
+- SoundBlaster and compatibles. There is only one driver that supports all\r
+ flavours of SoundBlasters:\r
+\r
+ + SB original (8-bit mono, 22KHz)\r
+ + SB 2.0 (DMA autoinit mode -> less clicks, 44KHz 8-bit mono).\r
+ + SB Pro (8-bit 22KHz stereo, 8-bit 44KHz mono)\r
+ + SB 16+ (8- and 16-bit stereo, up to 44Khz both)\r
+\r
+ Note that SB16 should cover AWE32/64 as well...\r
+\r
+- Windows Sound System and compatibles. Most today SoundBlaster clones\r
+ (including the CS4236B card used for testing) emulates (in hardware) WSS.\r
+ That's because Creative Labs copyrighted the SB16 interface and thus\r
+ clonemakers cannot do similar hardware without violating their rights, so\r
+ most of them only emulate SB Pro (see above).\r
+\r
+ WSS supports up to 44KHz 16-bit stereo. The following playback rates (in both\r
+ 8- and 16-bit) are supported: 5510, 6620, 8000, 9600, 11025, 16000, 18900,\r
+ 22050, 27420, 32000, 33075, 37800, 44100 and 48000 Hz.\r
+\r
+\r
+>> THANKS\r
+---------\r
+\r
+We would like to thank everyone who contributed to libmikmod. Their names\r
+are in the AUTHORS file for the significative contributions, but some other\r
+names can be found in the NEWS file. Thanks a lot ! Keeping libmikmod alive\r
+wouldn't be much fun without you.\r
+\r
+\r
+>> LICENSE\r
+----------\r
+\r
+The libmikmod sound library is covered by the GNU Library General Public\r
+License as published by the Free Software Fundation (you'll find it in the\r
+file COPYING.LIB) ; either version 2 of the licence, or (at your option)\r
+any later version.\r
+\r
+The GNU Lesser General Public License, version 2.1, in file COPYING.LESSER, can\r
+be considered as a later version of the LGPL, and is strongly recommended for\r
+people who will embed libmikmod in their application as a shared library.\r
+\r
+\r
+>> CONTACT AND DOWNLOAD INFO\r
+----------------------------\r
+\r
+libmikmod home page is located at SourceForge:\r
+\r
+ http://mikmod.sourceforge.net/\r
+ http://sourceforge.net/projects/mikmod/\r
+\r
+There's a mailing list (mikmod-public) for discussing the development\r
+of MikMod (new features, bugs, ideas...) Look for more information on\r
+the web site.\r
+\r
+Things related to the DOS port should also be forwarded to the DOS\r
+``portmaster'', Andrew Zabolotny, at: bit@eltech.ru\r
+\r
+\r
+>> LAST NOTES\r
+-------------\r
+\r
+We hope you'll enjoy using this version of libmikmod as well as we enjoyed\r
+debugging and improving it.\r
+\r
+-- Miodrag ("Miod") Vallat, 10/19/1999\r
+ miodrag@mikmod.darkorb.net\r
+\r
+ Andrew Zabolotny\r
+ bit@eltech.ru\r
--- /dev/null
+/* config.h.in. Generated manually for DJGPP. */
+
+/* djgpp-v2.04 and newer provide snprintf() and vsnprintf().
+ * djgpp-v2.05 is already released, so let's enable them by
+ * default here. */
+/* Define if you have the snprintf function. */
+#define HAVE_SNPRINTF
+/* Define if you have the vsnprintf function. */
+#define HAVE_VSNPRINTF
+
+/* Define to disable the high quality mixer (build only with the standart mixer) */
+/*#define NO_HQMIXER*/
+
+/* Define if your system supports binary pipes (i.e. Unix) */
+/*#define DRV_PIPE*/
+/* Define if you want support for output to stdout */
+/*#define DRV_STDOUT*/
+
+/* Define if you want an .aiff file writer driver */
+#undef DRV_AIFF
+/* Define if you want a raw pcm data file writer driver */
+#undef DRV_RAW
+/* Define if you want a .wav file writer driver */
+#undef DRV_WAV
+
+/* Define if the Gravis UltraSound driver is compiled */
+#define DRV_ULTRA
+/* Define if the Windows Sound System driver is compiled */
+#define DRV_WSS
+/* Define if the SoundBlaster driver is compiled */
+#define DRV_SB
+
+/* Define if you want a debug version of the library */
+#undef MIKMOD_DEBUG
+
+/* Define if you have the ANSI C header files. */
+#define STDC_HEADERS
+
+/* Define if you have the setenv function. */
+#define HAVE_SETENV
+
+/* Define if you have the srandom function. */
+#define HAVE_SRANDOM
+
+/* Define if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H
+
+/* Define if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H
+
+/* Define if you have the <malloc.h> header file. */
+#define HAVE_MALLOC_H
+
+/* Define if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H
+
--- /dev/null
+/*
+ Implementation of DMA routines on DOS
+ Copyright (C) 1999 by Andrew Zabolotny, <bit@eltech.ru>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "dosdma.h"
+
+#include <go32.h> /* includes sys/version.h (djgpp >= 2.02) */
+#include <dos.h>
+#include <dpmi.h>
+#include <sys/nearptr.h>
+#include <malloc.h>
+#include "mikmod.h" /* for MikMod_malloc() & co */
+
+/* BUG WARNING: there is an error in DJGPP libraries <= 2.01:
+ * src/libc/dpmi/api/d0102.s loads the selector and allocsize
+ * arguments in the wrong order. DJGPP >= 2.02 have it fixed. */
+#if (!defined(__DJGPP_MINOR__) || (__DJGPP_MINOR__+0) < 2)
+#warning __dpmi_resize_dos_memory() from DJGPP <= 2.01 is broken!
+#endif
+
+__dma_regs dma[8] = {
+/* *INDENT-OFF* */
+ {DMA_ADDR_0, DMA_PAGE_0, DMA_SIZE_0,
+ DMA1_MASK_REG, DMA1_CLEAR_FF_REG, DMA1_MODE_REG},
+ {DMA_ADDR_1, DMA_PAGE_1, DMA_SIZE_1,
+ DMA1_MASK_REG, DMA1_CLEAR_FF_REG, DMA1_MODE_REG},
+
+ {DMA_ADDR_2, DMA_PAGE_2, DMA_SIZE_2,
+ DMA1_MASK_REG, DMA1_CLEAR_FF_REG, DMA1_MODE_REG},
+ {DMA_ADDR_3, DMA_PAGE_3, DMA_SIZE_3,
+ DMA1_MASK_REG, DMA1_CLEAR_FF_REG, DMA1_MODE_REG},
+
+ {DMA_ADDR_4, 0, DMA_SIZE_4,
+ DMA2_MASK_REG, DMA2_CLEAR_FF_REG, DMA2_MODE_REG},
+ {DMA_ADDR_5, DMA_PAGE_5, DMA_SIZE_5,
+ DMA2_MASK_REG, DMA2_CLEAR_FF_REG, DMA2_MODE_REG},
+
+ {DMA_ADDR_6, DMA_PAGE_6, DMA_SIZE_6,
+ DMA2_MASK_REG, DMA2_CLEAR_FF_REG, DMA2_MODE_REG},
+ {DMA_ADDR_7, DMA_PAGE_7, DMA_SIZE_7,
+ DMA2_MASK_REG, DMA2_CLEAR_FF_REG, DMA2_MODE_REG}
+/* *INDENT-ON* */
+};
+
+static int __initialized = 0;
+static int __buffer_count = 0;
+static __dpmi_meminfo __locked_data;
+
+int dma_initialize()
+{
+ if (!__djgpp_nearptr_enable())
+ return 0;
+
+ /* Trick: Avoid re-setting DS selector limit on each memory allocation
+ call */
+ __djgpp_selector_limit = 0xffffffff;
+
+ __locked_data.address = __djgpp_base_address + (unsigned long)&dma;
+ __locked_data.size = sizeof(dma);
+ if (__dpmi_lock_linear_region(&__locked_data))
+ return 0;
+
+ return (__initialized = 1);
+}
+
+void dma_finalize()
+{
+ if (!__initialized)
+ return;
+ __dpmi_unlock_linear_region(&__locked_data);
+ __djgpp_nearptr_disable();
+}
+
+dma_buffer *dma_allocate(unsigned int channel, unsigned int size)
+{
+ int parsize = (size + 15) >> 4; /* size in paragraphs */
+ int par = 0; /* Real-mode paragraph */
+ int selector = 0; /* Protected-mode selector */
+ int mask = channel <= 3 ? 0xfff : 0x1fff; /* Alignment mask in para. */
+ int allocsize = parsize; /* Allocated size in paragraphs */
+ int count; /* Try count */
+ int bound = 0; /* Nearest bound address */
+ int maxsize; /* Maximal possible block size */
+ dma_buffer *buffer = NULL;
+ __dpmi_meminfo buff_info, struct_info;
+
+ if (!dma_initialize())
+ return NULL;
+
+ /* Loop until we'll get a properly aligned memory block */
+ for (count = 8; count; count--) {
+ int resize = (selector != 0);
+
+ /* Try first to resize (possibly previously) allocated block */
+ if (resize) {
+ maxsize = (bound + parsize) - par;
+ if (maxsize > parsize * 2)
+ maxsize = parsize * 2;
+ if (maxsize == allocsize)
+ resize = 0;
+ else {
+ allocsize = maxsize;
+ if (__dpmi_resize_dos_memory(selector, allocsize, &maxsize) !=
+ 0) resize = 0;
+ }
+ }
+
+ if (!resize) {
+ if (selector)
+ __dpmi_free_dos_memory(selector), selector = 0;
+ par = __dpmi_allocate_dos_memory(allocsize, &selector);
+ }
+
+ if ((par == 0) || (par == -1))
+ goto exit;
+
+ /* If memory block contains a properly aligned portion, quit loop */
+ bound = (par + mask + 1) & ~mask;
+ if (par + parsize <= bound)
+ break;
+ if (bound + parsize <= par + allocsize) {
+ par = bound;
+ break;
+ }
+ }
+ if (!count) {
+ __dpmi_free_dos_memory(selector);
+ goto exit;
+ }
+
+ buffer = (dma_buffer *) MikMod_malloc(sizeof(dma_buffer));
+ buffer->linear = (unsigned char *)(__djgpp_conventional_base + bound * 16);
+ buffer->physical = bound * 16;
+ buffer->size = parsize * 16;
+ buffer->selector = selector;
+ buffer->channel = channel;
+
+ buff_info.address = buffer->physical;
+ buff_info.size = buffer->size;
+ /*
+ Don't pay attention to return code since under plain DOS it often
+ returns error (at least under HIMEM/CWSDPMI and EMM386/DPMI)
+ */
+ __dpmi_lock_linear_region(&buff_info);
+
+ /* Lock the DMA buffer control structure as well */
+ struct_info.address = __djgpp_base_address + (unsigned long)buffer;
+ struct_info.size = sizeof(dma_buffer);
+ if (__dpmi_lock_linear_region(&struct_info)) {
+ __dpmi_unlock_linear_region(&buff_info);
+ __dpmi_free_dos_memory(selector);
+ MikMod_free(buffer);
+ buffer = NULL;
+ goto exit;
+ }
+
+ exit:
+ if (buffer)
+ __buffer_count++;
+ else if (--__buffer_count == 0)
+ dma_finalize();
+ return buffer;
+}
+
+void dma_free(dma_buffer * buffer)
+{
+ __dpmi_meminfo buff_info;
+
+ if (!buffer)
+ return;
+
+ buff_info.address = buffer->physical;
+ buff_info.size = buffer->size;
+ __dpmi_unlock_linear_region(&buff_info);
+
+ __dpmi_free_dos_memory(buffer->selector);
+ MikMod_free(buffer);
+
+ if (--__buffer_count == 0)
+ dma_finalize();
+}
+
+void dma_start(dma_buffer * buffer, unsigned long count, unsigned char mode)
+{
+ /* Disable interrupts */
+ int old_ints = disable();
+ dma_disable(buffer->channel);
+ dma_set_mode(buffer->channel, mode);
+ dma_clear_ff(buffer->channel);
+ dma_set_addr(buffer->channel, buffer->physical);
+ dma_clear_ff(buffer->channel);
+ dma_set_count(buffer->channel, count);
+ dma_enable(buffer->channel);
+ /* Re-enable interrupts */
+ if (old_ints)
+ enable();
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/*
+ Interface for DMA routines on DOS
+ Copyright (C) 1999 by Andrew Zabolotny, <bit@eltech.ru>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __DOSDMA_H__
+#define __DOSDMA_H__
+
+#include <pc.h>
+
+#define DMA1_BASE 0x00 /* 8 bit slave DMA, channels 0..3 */
+#define DMA2_BASE 0xC0 /* 16 bit master DMA, ch 4(=slave input)..7 */
+
+#define DMA1_CMD_REG 0x08 /* command register (w) */
+#define DMA1_STAT_REG 0x08 /* status register (r) */
+#define DMA1_REQ_REG 0x09 /* request register (w) */
+#define DMA1_MASK_REG 0x0A /* single-channel mask (w) */
+#define DMA1_MODE_REG 0x0B /* mode register (w) */
+#define DMA1_CLEAR_FF_REG 0x0C /* clear pointer flip-flop (w) */
+#define DMA1_TEMP_REG 0x0D /* Temporary Register (r) */
+#define DMA1_RESET_REG 0x0D /* Master Clear (w) */
+#define DMA1_CLR_MASK_REG 0x0E /* Clear Mask */
+#define DMA1_MASK_ALL_REG 0x0F /* all-channels mask (w) */
+
+#define DMA2_CMD_REG 0xD0 /* command register (w) */
+#define DMA2_STAT_REG 0xD0 /* status register (r) */
+#define DMA2_REQ_REG 0xD2 /* request register (w) */
+#define DMA2_MASK_REG 0xD4 /* single-channel mask (w) */
+#define DMA2_MODE_REG 0xD6 /* mode register (w) */
+#define DMA2_CLEAR_FF_REG 0xD8 /* clear pointer flip-flop (w) */
+#define DMA2_TEMP_REG 0xDA /* Temporary Register (r) */
+#define DMA2_RESET_REG 0xDA /* Master Clear (w) */
+#define DMA2_CLR_MASK_REG 0xDC /* Clear Mask */
+#define DMA2_MASK_ALL_REG 0xDE /* all-channels mask (w) */
+
+#define DMA_ADDR_0 0x00 /* DMA address registers */
+#define DMA_ADDR_1 0x02
+#define DMA_ADDR_2 0x04
+#define DMA_ADDR_3 0x06
+#define DMA_ADDR_4 0xC0
+#define DMA_ADDR_5 0xC4
+#define DMA_ADDR_6 0xC8
+#define DMA_ADDR_7 0xCC
+
+#define DMA_SIZE_0 0x01 /* DMA transfer size registers */
+#define DMA_SIZE_1 0x03
+#define DMA_SIZE_2 0x05
+#define DMA_SIZE_3 0x07
+#define DMA_SIZE_4 0xC2
+#define DMA_SIZE_5 0xC6
+#define DMA_SIZE_6 0xCA
+#define DMA_SIZE_7 0xCE
+
+#define DMA_PAGE_0 0x87 /* DMA page registers */
+#define DMA_PAGE_1 0x83
+#define DMA_PAGE_2 0x81
+#define DMA_PAGE_3 0x82
+#define DMA_PAGE_5 0x8B
+#define DMA_PAGE_6 0x89
+#define DMA_PAGE_7 0x8A
+
+#define DMA_MODE_AUTOINIT 0x10 /* Auto-init mode bit */
+#define DMA_MODE_READ 0x44 /* I/O to memory, no autoinit, increment, single mode */
+#define DMA_MODE_WRITE 0x48 /* memory to I/O, no autoinit, increment, single mode */
+#define DMA_MODE_CASCADE 0xC0 /* pass thru DREQ->HRQ, DACK<-HLDA only */
+
+/* Indexable specific DMA registers */
+typedef struct __dma_regs_s {
+ unsigned char addr; /* DMA transfer address register */
+ unsigned char page; /* DMA page register */
+ unsigned char size; /* DMA transfer size register */
+ unsigned char mask; /* DMA mask/unmask register */
+ unsigned char flip; /* DMA flip-flop reset register */
+ unsigned char mode; /* DMA mode register */
+} __dma_regs;
+
+extern __dma_regs dma[8];
+
+/* Enable a specific DMA channel */
+static inline void dma_enable(unsigned int channel)
+{
+ outportb(dma[channel].mask, channel & 3);
+}
+
+/* Disable a specific DMA channel */
+static inline void dma_disable(unsigned int channel)
+{
+ outportb(dma[channel].mask, (channel & 3) | 0x04);
+}
+
+/* Clear the 'DMA Flip Flop' flag */
+static inline void dma_clear_ff(unsigned int channel)
+{
+ outportb(dma[channel].flip, 0);
+}
+
+/* Set mode for a specific DMA channel */
+static inline void dma_set_mode(unsigned int channel, char mode)
+{
+ outportb(dma[channel].mode, mode | (channel & 3));
+}
+
+/* Set DMA page register */
+static inline void dma_set_page(unsigned int channel, char page)
+{
+ if (channel > 3)
+ page &= 0xfe;
+ outportb(dma[channel].page, page);
+}
+
+/*
+ Set transfer address & page bits for specific DMA channel.
+ Assumes dma flipflop is clear.
+*/
+static inline void dma_set_addr(unsigned int channel, unsigned int address)
+{
+ unsigned char dma_reg = dma[channel].addr;
+ dma_set_page(channel, address >> 16);
+ if (channel <= 3) {
+ outportb(dma_reg, (address) & 0xff);
+ outportb(dma_reg, (address >> 8) & 0xff);
+ } else {
+ outportb(dma_reg, (address >> 1) & 0xff);
+ outportb(dma_reg, (address >> 9) & 0xff);
+ }
+}
+
+/*
+ Set transfer size for a specific DMA channel.
+ Assumes dma flip-flop is clear.
+*/
+static inline void dma_set_count(unsigned int channel, unsigned int count)
+{
+ unsigned char dma_reg = dma[channel].size;
+ count--; /* number of DMA transfers is bigger by one */
+ if (channel > 3)
+ count >>= 1;
+ outportb(dma_reg, (count) & 0xff);
+ outportb(dma_reg, (count >> 8) & 0xff);
+}
+
+/*
+ Query the number of bytes left to transfer.
+ Assumes DMA flip-flop is clear.
+*/
+static inline int dma_get_count(unsigned int channel)
+{
+ unsigned char dma_reg = dma[channel].size;
+
+ /* using short to get 16-bit wrap around */
+ unsigned short count;
+ count = inportb(dma_reg);
+ count |= inportb(dma_reg) << 8;
+ count++;
+ return (channel <= 3) ? count : (count << 1);
+}
+
+typedef struct dma_buffer_s {
+ unsigned char *linear; /* Linear address */
+ unsigned long physical; /* Physical address */
+ unsigned long size; /* Buffer size */
+ unsigned short selector; /* The selector assigned to this memory */
+ unsigned char channel; /* The DMA channel */
+} dma_buffer;
+
+/* Allocate a block of memory suitable for using as a DMA buffer */
+extern dma_buffer *dma_allocate(unsigned int channel, unsigned int size);
+/* Deallocate a DMA buffer */
+extern void dma_free(dma_buffer * buffer);
+/* Start DMA transfer to or from given buffer */
+extern void dma_start(dma_buffer * buffer, unsigned long count,
+ unsigned char mode);
+
+#endif /* __DOSDMA_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ Driver for GUS cards under DOS
+ Written by Andrew Zabolotny <bit@eltech.ru>
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DRV_ULTRA
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <dos.h>
+#include <dpmi.h>
+#include <sys/farptr.h>
+#include <sys/nearptr.h>
+#include <go32.h>
+#include <string.h>
+
+#include "dosgus.h"
+#include "mikmod.h" /* for MikMod_malloc() & co */
+
+/********************************************* Private variables/routines *****/
+
+/* The Gravis Ultrasound state/info */
+__gus_state gus;
+
+/* Try to avoid holes in DRAM less than this size */
+#define DRAM_HOLE_THRESHOLD 8192
+/* If hole is larger than that, create a free block describing it */
+#define DRAM_SPLIT_THRESHOLD 64
+/* The size of DMA buffer used for RAM->DRAM transfers */
+#define GF1_DMA_BUFFER_SIZE 8192
+
+/* Debug macro: useful to change screen locations when some event occurs */
+#ifdef MIKMOD_DEBUG
+# define DEBUG_PRINT(x) printf x;
+# define DEBUG_OFS(addr, attr) \
+ { \
+ unsigned short x; \
+ _dosmemgetw (0xb8780 + addr*2, 1, &x); \
+ if ((x >> 8) != attr) x = '0'; \
+ x = ((x + 1) & 0xff) | (attr << 8); \
+ _dosmemputw (&x, 1, 0xb8780 + addr*2); \
+ }
+#else
+# define DEBUG_PRINT(x)
+# define DEBUG_OFS(addr, attr)
+#endif
+
+static unsigned short __gus_volume_table[512] = {
+ 0x0000, 0x7000, 0x7ff0, 0x8800, 0x8ff0, 0x9400, 0x9800, 0x9c00,
+ 0x9ff0, 0xa200, 0xa400, 0xa600, 0xa800, 0xaa00, 0xac00, 0xae00,
+ 0xaff0, 0xb100, 0xb200, 0xb300, 0xb400, 0xb500, 0xb600, 0xb700,
+ 0xb800, 0xb900, 0xba00, 0xbb00, 0xbc00, 0xbd00, 0xbe00, 0xbf00,
+ 0xbff0, 0xc080, 0xc100, 0xc180, 0xc200, 0xc280, 0xc300, 0xc380,
+ 0xc400, 0xc480, 0xc500, 0xc580, 0xc600, 0xc680, 0xc700, 0xc780,
+ 0xc800, 0xc880, 0xc900, 0xc980, 0xca00, 0xca80, 0xcb00, 0xcb80,
+ 0xcc00, 0xcc80, 0xcd00, 0xcd80, 0xce00, 0xce80, 0xcf00, 0xcf80,
+ 0xcff0, 0xd040, 0xd080, 0xd0c0, 0xd100, 0xd140, 0xd180, 0xd1c0,
+ 0xd200, 0xd240, 0xd280, 0xd2c0, 0xd300, 0xd340, 0xd380, 0xd3c0,
+ 0xd400, 0xd440, 0xd480, 0xd4c0, 0xd500, 0xd540, 0xd580, 0xd5c0,
+ 0xd600, 0xd640, 0xd680, 0xd6c0, 0xd700, 0xd740, 0xd780, 0xd7c0,
+ 0xd800, 0xd840, 0xd880, 0xd8c0, 0xd900, 0xd940, 0xd980, 0xd9c0,
+ 0xda00, 0xda40, 0xda80, 0xdac0, 0xdb00, 0xdb40, 0xdb80, 0xdbc0,
+ 0xdc00, 0xdc40, 0xdc80, 0xdcc0, 0xdd00, 0xdd40, 0xdd80, 0xddc0,
+ 0xde00, 0xde40, 0xde80, 0xdec0, 0xdf00, 0xdf40, 0xdf80, 0xdfc0,
+ 0xdff0, 0xe020, 0xe040, 0xe060, 0xe080, 0xe0a0, 0xe0c0, 0xe0e0,
+ 0xe100, 0xe120, 0xe140, 0xe160, 0xe180, 0xe1a0, 0xe1c0, 0xe1e0,
+ 0xe200, 0xe220, 0xe240, 0xe260, 0xe280, 0xe2a0, 0xe2c0, 0xe2e0,
+ 0xe300, 0xe320, 0xe340, 0xe360, 0xe380, 0xe3a0, 0xe3c0, 0xe3e0,
+ 0xe400, 0xe420, 0xe440, 0xe460, 0xe480, 0xe4a0, 0xe4c0, 0xe4e0,
+ 0xe500, 0xe520, 0xe540, 0xe560, 0xe580, 0xe5a0, 0xe5c0, 0xe5e0,
+ 0xe600, 0xe620, 0xe640, 0xe660, 0xe680, 0xe6a0, 0xe6c0, 0xe6e0,
+ 0xe700, 0xe720, 0xe740, 0xe760, 0xe780, 0xe7a0, 0xe7c0, 0xe7e0,
+ 0xe800, 0xe820, 0xe840, 0xe860, 0xe880, 0xe8a0, 0xe8c0, 0xe8e0,
+ 0xe900, 0xe920, 0xe940, 0xe960, 0xe980, 0xe9a0, 0xe9c0, 0xe9e0,
+ 0xea00, 0xea20, 0xea40, 0xea60, 0xea80, 0xeaa0, 0xeac0, 0xeae0,
+ 0xeb00, 0xeb20, 0xeb40, 0xeb60, 0xeb80, 0xeba0, 0xebc0, 0xebe0,
+ 0xec00, 0xec20, 0xec40, 0xec60, 0xec80, 0xeca0, 0xecc0, 0xece0,
+ 0xed00, 0xed20, 0xed40, 0xed60, 0xed80, 0xeda0, 0xedc0, 0xede0,
+ 0xee00, 0xee20, 0xee40, 0xee60, 0xee80, 0xeea0, 0xeec0, 0xeee0,
+ 0xef00, 0xef20, 0xef40, 0xef60, 0xef80, 0xefa0, 0xefc0, 0xefe0,
+ 0xeff0, 0xf010, 0xf020, 0xf030, 0xf040, 0xf050, 0xf060, 0xf070,
+ 0xf080, 0xf090, 0xf0a0, 0xf0b0, 0xf0c0, 0xf0d0, 0xf0e0, 0xf0f0,
+ 0xf100, 0xf110, 0xf120, 0xf130, 0xf140, 0xf150, 0xf160, 0xf170,
+ 0xf180, 0xf190, 0xf1a0, 0xf1b0, 0xf1c0, 0xf1d0, 0xf1e0, 0xf1f0,
+ 0xf200, 0xf210, 0xf220, 0xf230, 0xf240, 0xf250, 0xf260, 0xf270,
+ 0xf280, 0xf290, 0xf2a0, 0xf2b0, 0xf2c0, 0xf2d0, 0xf2e0, 0xf2f0,
+ 0xf300, 0xf310, 0xf320, 0xf330, 0xf340, 0xf350, 0xf360, 0xf370,
+ 0xf380, 0xf390, 0xf3a0, 0xf3b0, 0xf3c0, 0xf3d0, 0xf3e0, 0xf3f0,
+ 0xf400, 0xf410, 0xf420, 0xf430, 0xf440, 0xf450, 0xf460, 0xf470,
+ 0xf480, 0xf490, 0xf4a0, 0xf4b0, 0xf4c0, 0xf4d0, 0xf4e0, 0xf4f0,
+ 0xf500, 0xf510, 0xf520, 0xf530, 0xf540, 0xf550, 0xf560, 0xf570,
+ 0xf580, 0xf590, 0xf5a0, 0xf5b0, 0xf5c0, 0xf5d0, 0xf5e0, 0xf5f0,
+ 0xf600, 0xf610, 0xf620, 0xf630, 0xf640, 0xf650, 0xf660, 0xf670,
+ 0xf680, 0xf690, 0xf6a0, 0xf6b0, 0xf6c0, 0xf6d0, 0xf6e0, 0xf6f0,
+ 0xf700, 0xf710, 0xf720, 0xf730, 0xf740, 0xf750, 0xf760, 0xf770,
+ 0xf780, 0xf790, 0xf7a0, 0xf7b0, 0xf7c0, 0xf7d0, 0xf7e0, 0xf7f0,
+ 0xf800, 0xf810, 0xf820, 0xf830, 0xf840, 0xf850, 0xf860, 0xf870,
+ 0xf880, 0xf890, 0xf8a0, 0xf8b0, 0xf8c0, 0xf8d0, 0xf8e0, 0xf8f0,
+ 0xf900, 0xf910, 0xf920, 0xf930, 0xf940, 0xf950, 0xf960, 0xf970,
+ 0xf980, 0xf990, 0xf9a0, 0xf9b0, 0xf9c0, 0xf9d0, 0xf9e0, 0xf9f0,
+ 0xfa00, 0xfa10, 0xfa20, 0xfa30, 0xfa40, 0xfa50, 0xfa60, 0xfa70,
+ 0xfa80, 0xfa90, 0xfaa0, 0xfab0, 0xfac0, 0xfad0, 0xfae0, 0xfaf0,
+ 0xfb00, 0xfb10, 0xfb20, 0xfb30, 0xfb40, 0xfb50, 0xfb60, 0xfb70,
+ 0xfb80, 0xfb90, 0xfba0, 0xfbb0, 0xfbc0, 0xfbd0, 0xfbe0, 0xfbf0,
+ 0xfc00, 0xfc10, 0xfc20, 0xfc30, 0xfc40, 0xfc50, 0xfc60, 0xfc70,
+ 0xfc80, 0xfc90, 0xfca0, 0xfcb0, 0xfcc0, 0xfcd0, 0xfce0, 0xfcf0,
+ 0xfd00, 0xfd10, 0xfd20, 0xfd30, 0xfd40, 0xfd50, 0xfd60, 0xfd70,
+ 0xfd80, 0xfd90, 0xfda0, 0xfdb0, 0xfdc0, 0xfdd0, 0xfde0, 0xfdf0,
+ 0xfe00, 0xfe10, 0xfe20, 0xfe30, 0xfe40, 0xfe50, 0xfe60, 0xfe70,
+ 0xfe80, 0xfe90, 0xfea0, 0xfeb0, 0xfec0, 0xfed0, 0xfee0, 0xfef0,
+ 0xff00, 0xff10, 0xff20, 0xff30, 0xff40, 0xff50, 0xff60, 0xff70,
+ 0xff80, 0xff90, 0xffa0, 0xffb0, 0xffc0, 0xffd0, 0xffe0, 0xfff0
+};
+
+/* Wait a bit for GUS before doing something
+ * Mark function as volatile: don't allow it to be inlined.
+ * It *should* be slow, no need to make it work faster :-)
+ */
+#if !defined(__GNUC__) || (__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ == 0)
+# define _func_noinline volatile /* match original code */
+# define _func_noclone
+#else
+/* avoid warnings from newer gcc:
+ * "function definition has qualified void return type" and
+ * function return types not compatible due to 'volatile' */
+# define _func_noinline __attribute__((__noinline__))
+# if (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define _func_noclone
+# else
+# define _func_noclone __attribute__((__noclone__))
+# endif
+#endif
+_func_noinline
+_func_noclone
+ void __gus_delay()
+{
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+ inportb(GF1_MIX_CTRL);
+}
+
+static void __gus_stop_controller(unsigned char gf1reg)
+{
+ register unsigned char value = __gus_inregb(gf1reg);
+ __gus_outregb(gf1reg, (value | GF1VC_STOPPED | GF1VC_STOP) &
+ ~(GF1VC_IRQ_PENDING | GF1VC_IRQ));
+}
+
+/* Returns 1 if volume is already at given position */
+static boolean __gus_volume_ramp_to(unsigned short volume,
+ unsigned char rate,
+ unsigned char vol_ctrl)
+{
+ int svol = __gus_inregw(GF1R_VOLUME) & 0xfff0;
+ int evol = volume;
+
+ /* First of all, disable volume ramp */
+ __gus_stop_controller(GF1R_VOLUME_CONTROL);
+
+ /* If voice is stopped, set the volume to zero and return */
+ if (__gus_inregb(GF1R_VOICE_CONTROL) & GF1VC_STOPPED) {
+ __gus_outregw(GF1R_VOLUME, 0);
+ return 1;
+ }
+
+ /* Avoid clicks when volume ramp goes too high or too low */
+ if (svol < 0x0400)
+ svol = 0x0400;
+ if (svol > 0xfc00)
+ svol = 0xfc00;
+ if (evol < 0x0400)
+ evol = 0x0400;
+ if (evol > 0xfc00)
+ evol = 0xfc00;
+
+ /* Adjust start/end positions */
+ if (svol > evol) {
+ unsigned short tmp = evol;
+ evol = svol;
+ svol = tmp;
+ vol_ctrl |= GF1VL_BACKWARD;
+ }
+
+ /* If we already are (near) the target volume, quit */
+ if (evol - svol < 0x1000) {
+ __gus_outregw(GF1R_VOLUME, volume);
+ return 1;
+ }
+
+ __gus_outregb(GF1R_VOLUME_START, svol >> 8);
+ __gus_outregb(GF1R_VOLUME_END, evol >> 8);
+ __gus_outregb(GF1R_VOLUME_RATE, rate);
+ __gus_outregb_slow(GF1R_VOLUME_CONTROL, vol_ctrl);
+ return 0;
+}
+
+static inline void __gus_stop_voice()
+{
+ __gus_stop_controller(GF1R_VOICE_CONTROL);
+ __gus_outregb_slow(GF1R_VOICE_CONTROL, GF1VC_STOPPED | GF1VC_STOP);
+}
+
+/* The GUS IRQ handler */
+static void gf1_irq()
+{
+ unsigned char irq_source; /* The contents of GF1_IRQ_STATUS register */
+ boolean timer_cb = 0; /* Call timer callback function */
+
+ DEBUG_OFS(0, 0xCE)
+ gus.eow_ignore = 0;
+ while ((irq_source = inportb(GF1_IRQ_STATUS))) {
+ DEBUG_OFS(1, 0xCE)
+
+ if (irq_source & GF1M_IRQ_DMA_COMPLETE) {
+ DEBUG_OFS(4, 0x9F)
+ /* reset the IRQ pending bit */
+ __gus_inregb(GF1R_DMA_CONTROL);
+ gus.dma_active = 0;
+
+ if (gus.dma_callback)
+ gus.dma_callback();
+ }
+
+ if (irq_source & (GF1M_IRQ_WAVETABLE | GF1M_IRQ_ENVELOPE)) {
+ unsigned char vcirq;
+ unsigned int done_mask = 0;
+
+ /* IRQ bits are inverse (i.e. 0 = IRQ pending) */
+ while ((vcirq = __gus_inregb(GF1R_IRQ_SOURCE) ^
+ (GF1IRQ_WAVE | GF1IRQ_VOLUME)) &
+ (GF1IRQ_WAVE | GF1IRQ_VOLUME)) {
+ unsigned long voice = (vcirq & 0x1f);
+ unsigned char voice_ctl, volume_ctl;
+ unsigned int voice_mask = (1 << voice);
+
+ /* Don't handle more than one IRQ from same voice */
+ if (done_mask & voice_mask)
+ continue;
+
+ done_mask |= voice_mask;
+
+ /* Read voice/volume selection registers */
+ __gus_select_voice(voice);
+ voice_ctl = __gus_inregb(GF1R_VOICE_CONTROL);
+ volume_ctl = __gus_inregb(GF1R_VOLUME_CONTROL);
+
+ if ((vcirq & GF1IRQ_WAVE) && (gus.wt_callback)
+ && !(gus.eow_ignore & voice_mask)) {
+ DEBUG_OFS(5, 0xAF)
+ gus.wt_callback(voice, voice_ctl, volume_ctl);
+ }
+
+ if ((vcirq & GF1IRQ_VOLUME) && (gus.vl_callback)) {
+ DEBUG_OFS(6, 0xAF)
+ gus.vl_callback(voice, voice_ctl, volume_ctl);
+ }
+ }
+ }
+
+ /* Reset timers that sent this IRQ */
+ if (irq_source & (GF1M_IRQ_TIMER1 | GF1M_IRQ_TIMER2)) {
+ unsigned char timer_ctl = gus.timer_ctl_reg;
+
+ if (irq_source & GF1M_IRQ_TIMER1)
+ timer_ctl &= ~GF1M_TIMER1;
+
+ if (irq_source & GF1M_IRQ_TIMER2)
+ timer_ctl &= ~GF1M_TIMER2;
+
+ __gus_outregb_slow(GF1R_TIMER_CONTROL, timer_ctl);
+ __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
+ }
+
+ if (irq_source & GF1M_IRQ_TIMER1)
+ if (--gus.t1_countdown == 0) {
+ gus.t1_countdown = gus.t1_multiple;
+ gus.t1_ticks++;
+
+ DEBUG_OFS(2, 0xCF)
+
+ if (gus.t1_callback) {
+ timer_cb = 1;
+ gus.t1_callback();
+ }
+ }
+
+ if (irq_source & GF1M_IRQ_TIMER2)
+ if (--gus.t2_countdown == 0) {
+ gus.t2_countdown = gus.t2_multiple;
+ gus.t2_ticks++;
+
+ DEBUG_OFS(3, 0xCF)
+
+ if (gus.t2_callback)
+ gus.t2_callback();
+ }
+#if 0
+ /* The following are not used and implemented yet */
+ if (irq_source & (GF1M_IRQ_MIDI_TX | GF1M_IRQ_MIDI_RX)) {
+ }
+#endif
+ }
+
+ irq_ack(gus.gf1_irq);
+
+ if (timer_cb && gus.timer_callback)
+ gus.timer_callback();
+}
+
+static void gf1_irq_end()
+{
+}
+
+static boolean __gus_detect()
+{
+ /* A relatively relaxed autodetection;
+ We don't count on DRAM: GUS PnP could not have it
+ (although its anyway bad for us)
+ */
+ __gus_select_voice(0);
+ __gus_stop_voice();
+ __gus_outregw(GF1R_FREQUENCY, 0x1234);
+ __gus_outregw(GF1R_VOLUME, 0x5670);
+ return ((__gus_inregw(GF1R_FREQUENCY) & 0xfffe) == 0x1234)
+ && ((__gus_inregw(GF1R_VOLUME) & 0xfff0) == 0x5670);
+}
+
+static void __gus_reset(boolean reset_io_dma)
+{
+ static unsigned char irqctl[16] = { 0, 0, 1, 3, 0, 2, 0, 4, 0, 0, 0, 5, 6, 0, 0, 7 };
+ static unsigned char dmactl[8] = { 0, 1, 0, 2, 0, 3, 4, 5 };
+ unsigned char irqtmp, dmatmp;
+
+ /* Disable interrupts while resetting to avoid spurious IRQs */
+ int i, timer, old_ints = disable();
+
+ /* Stop the timer so that GUS IRQ won't clobber registers */
+ timer = (gus.timer_ctl_reg & GF1M_TIMER1);
+ if (timer)
+ gus_timer_stop();
+
+ gus.dma_active = 0;
+
+ __gus_outregb(GF1R_RESET, 0);
+ for (i = 0; i < 10; i++)
+ __gus_delay();
+ __gus_outregb(GF1R_RESET, GF1M_MASTER_RESET);
+ for (i = 0; i < 10; i++)
+ __gus_delay();
+
+ outportb(GF1_MIDI_CTRL, GF1M_MIDI_RESET);
+ for (i = 0; i < 10; i++)
+ __gus_delay();
+ outportb(GF1_MIDI_CTRL, 0);
+
+ /* Reset all IRQ sources */
+ __gus_outregb(GF1R_DMA_CONTROL, 0);
+ __gus_outregb(GF1R_TIMER_CONTROL, 0);
+ __gus_outregb(GF1R_SAMPLE_CONTROL, 0);
+
+ /* Reset all voices */
+ gus_reset(gus.voices, gus.dynmask);
+
+ /* Flush any pending IRQs */
+ inportb(GF1_IRQ_STATUS);
+ __gus_inregb(GF1R_DMA_CONTROL);
+ __gus_inregb(GF1R_SAMPLE_CONTROL);
+ __gus_inregb(GF1R_IRQ_SOURCE);
+
+ if (reset_io_dma) {
+ /* Now set up the GUS card to required IRQs and DMAs */
+ if (gus.irq[0] == gus.irq[1])
+ irqtmp = irqctl[gus.irq[0]] | GF1M_IRQ_EQUAL;
+ else
+ irqtmp = irqctl[gus.irq[0]] | (irqctl[gus.irq[1]] << 3);
+
+ if (gus.dma[0] == gus.dma[1])
+ dmatmp = dmactl[gus.dma[0]] | GF1M_DMA_EQUAL;
+ else
+ dmatmp = dmactl[gus.dma[0]] | (dmactl[gus.dma[1]] << 3);
+
+ /* Reset IRQs if possible */
+ gus.mixer =
+ GF1M_MIXER_NO_LINE_IN | GF1M_MIXER_NO_OUTPUT | GF1M_MIXER_GF1_IRQ;
+ if (gus.version >= GUS_CARD_VERSION_CLASSIC1) {
+ outportb(GF1_REG_CTRL, 0x05);
+ outportb(GF1_MIX_CTRL, gus.mixer);
+ outportb(GF1_IRQ_CTRL, 0x00); /* Reset IRQs */
+ outportb(GF1_REG_CTRL, 0x00);
+ }
+
+ /* Set up DMA channels: NEVER disable MIXER_GF1_IRQ in the future */
+ outportb(GF1_MIX_CTRL, gus.mixer);
+ outportb(GF1_IRQ_CTRL, dmatmp);
+
+ /* Set up IRQ channels */
+ outportb(GF1_MIX_CTRL, gus.mixer | GF1M_CONTROL_SELECT);
+ outportb(GF1_IRQ_CTRL, irqtmp);
+ }
+
+ __gus_outregb(GF1R_RESET, GF1M_MASTER_RESET | GF1M_OUTPUT_ENABLE | GF1M_MASTER_IRQ);
+ __gus_delay();
+
+ /* Flush IRQs again */
+ inportb(GF1_IRQ_STATUS);
+ __gus_inregb(GF1R_DMA_CONTROL);
+ __gus_inregb(GF1R_SAMPLE_CONTROL);
+ __gus_inregb(GF1R_IRQ_SOURCE);
+
+ _irq_ack(gus.irq[0]);
+ _irq_ack(gus.irq[1]);
+
+ if (timer)
+ gus_timer_continue();
+
+ if (old_ints)
+ enable();
+
+ /* Enable output */
+ __gus_mixer_output(1);
+}
+
+/* Transfer a block of data from GUS DRAM to main RAM through port I/O */
+static void __gus_transfer_io_in(unsigned long address, unsigned char *source,
+ unsigned long size)
+{
+ while (size) {
+ register unsigned int size64k;
+
+ size64k = 0x10000 - (address & 0xffff);
+ if (size64k > size)
+ size64k = size;
+ size -= size64k;
+
+ __gus_outregb(GF1R_DRAM_HIGH, address >> 16);
+ while (size64k--) {
+ __gus_outregw(GF1R_DRAM_LOW, address++);
+ *source++ = inportb(GF1_DRAM);
+ }
+ }
+}
+
+/* Transfer a block of data into GUS DRAM through port I/O */
+static void __gus_transfer_io(unsigned long address, unsigned char *source,
+ unsigned long size, int flags)
+{
+ while (size) {
+ register unsigned int size64k;
+
+ size64k = 0x10000 - (address & 0xffff);
+ if (size64k > size)
+ size64k = size;
+ size -= size64k;
+
+ __gus_outregb(GF1R_DRAM_HIGH, address >> 16);
+ if (flags & GUS_WAVE_INVERT)
+ if (flags & GUS_WAVE_16BIT)
+ while (size64k-- && size64k--) {
+ __gus_outregw(GF1R_DRAM_LOW, address++);
+ outportb(GF1_DRAM, *source++);
+ __gus_outregw(GF1R_DRAM_LOW, address++);
+ outportb(GF1_DRAM, (*source++) ^ 0x80);
+ } else
+ while (size64k--) {
+ __gus_outregw(GF1R_DRAM_LOW, address++);
+ outportb(GF1_DRAM, (*source++) ^ 0x80);
+ } else
+ while (size64k--) {
+ __gus_outregw(GF1R_DRAM_LOW, address++);
+ outportb(GF1_DRAM, *source++);
+ }
+ }
+}
+
+/* Wait for DMA transfer to finish between 8-9 1/18sec timer ticks */
+static int __gus_wait_dma()
+{
+ unsigned long timer;
+ _farsetsel(_dos_ds);
+ timer = _farnspeekl(0x46c);
+ while (gus.dma_active)
+ if (_farnspeekl(0x46c) - timer > 8) {
+ /* Force DMA abort since something went wrong */
+ __gus_reset(0);
+ return -1;
+ }
+
+ return 0;
+}
+
+/* Transfer a block of data into GUS DRAM through DMA controller */
+static void __gus_transfer_dma(unsigned long address, unsigned char *source,
+ unsigned long size, int flags)
+{
+ unsigned char dma_control;
+ unsigned long bytes_left;
+ unsigned long cur_size;
+ unsigned long dest_addr;
+
+ if ((gus.dma[0] > 3) || (flags & GUS_WAVE_16BIT))
+ size = (size + 1) & ~1;
+
+ bytes_left = size;
+ while (bytes_left) {
+ __gus_wait_dma();
+
+ cur_size = gus.dma_buff->size;
+ if (cur_size > bytes_left)
+ cur_size = bytes_left;
+ bytes_left -= cur_size;
+ dest_addr = address;
+
+ if (gus.dma_buff->linear != source)
+ memmove(gus.dma_buff->linear, source, cur_size);
+ source += cur_size;
+ address += cur_size;
+
+ /* Disable GUS -> DMA tie */
+ __gus_outregb(GF1R_DMA_CONTROL, 0);
+ __gus_delay();
+
+ /* Set up the DMA */
+ dma_start(gus.dma_buff, cur_size, DMA_MODE_WRITE);
+ gus.dma_active = 1;
+
+ /* Reset the DMA IRQ pending bit if set */
+ __gus_inregb(GF1R_DMA_CONTROL);
+
+ /* The 16-bit DMA channels needs a slightly different approach */
+ dma_control = GF1M_DMAR_ENABLE | GF1M_DMAR_IRQ_ENABLE | gus.dma_rate;
+ if (gus.dma[0] > 3) {
+ dest_addr = __gus_convert_addr16(dest_addr);
+ dma_control |= GF1M_DMAR_CHAN16;
+ }
+
+ __gus_outregw(GF1R_DMA_ADDRESS, dest_addr >> 4);
+
+ if (flags & GUS_WAVE_16BIT)
+ dma_control |= GF1M_DMAR_DATA16;
+ if (flags & GUS_WAVE_INVERT)
+ dma_control |= GF1M_DMAR_TOGGLE_SIGN;
+
+ /* Tell GUS to start transfer */
+ __gus_outregb(GF1R_DMA_CONTROL, dma_control);
+ }
+}
+
+static void __gus_detect_version()
+{
+ unsigned char tmp;
+
+ switch (gus.version = inportb(GF1_REVISION)) {
+ case 5:
+ gus.version = GUS_CARD_VERSION_CLASSIC_ICS;
+ gus.ics = 1;
+ gus.ics_flipped = 1;
+ break;
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ gus.version = GUS_CARD_VERSION_CLASSIC_ICS;
+ gus.ics = 1;
+ break;
+ case 10:
+ gus.version = GUS_CARD_VERSION_MAX;
+ gus.codec = 1;
+ break;
+ case 11:
+ gus.version = GUS_CARD_VERSION_MAX1;
+ gus.codec = 1;
+ break;
+ case 0x30:
+ gus.version = GUS_CARD_VERSION_ACE;
+ break;
+ case 0x50:
+ gus.version = GUS_CARD_VERSION_EXTREME;
+ break;
+ case 0xff:
+ /* Pre-3.7 board */
+ outportb(GF1_REG_CTRL, 0x20);
+ tmp = inportb(GF1_REG_CTRL);
+ if ((tmp != 0xff) && (tmp & 0x06))
+ gus.version = GUS_CARD_VERSION_CLASSIC1;
+ else
+ gus.version = GUS_CARD_VERSION_CLASSIC;
+ break;
+ default:
+ /* Hmm... unknown revision. Assume a safe Classic model */
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr, "libgus: Unknown board revision (%02x)\n",
+ gus.version);
+#endif
+ gus.version = GUS_CARD_VERSION_CLASSIC;
+ break;
+ }
+}
+
+static void __gus_detect_transfer()
+{
+ unsigned char *outbuff, *inbuff;
+ unsigned int i, j, seed = 0x13243546;
+ __gus_transfer_func func;
+
+#define TRANSFER_SIZE 0x4000
+
+ outbuff = (unsigned char *) MikMod_malloc(TRANSFER_SIZE);
+ inbuff = (unsigned char *) MikMod_malloc(TRANSFER_SIZE);
+
+ /* Suppose we have an malfunctioning GUS */
+ gus.transfer = NULL;
+
+ for (i = (gus.dma_buff ? 0 : 4); i <= 4; i++) {
+ switch (i) {
+ case 0:
+ gus.dma_rate = GF1M_DMAR_RATE0;
+ func = __gus_transfer_dma;
+ break;
+ case 1:
+ gus.dma_rate = GF1M_DMAR_RATE1;
+ func = __gus_transfer_dma;
+ break;
+ case 2:
+ gus.dma_rate = GF1M_DMAR_RATE2;
+ func = __gus_transfer_dma;
+ break;
+ case 3:
+ gus.dma_rate = GF1M_DMAR_RATE3;
+ func = __gus_transfer_dma;
+ break;
+ case 4:
+ func = __gus_transfer_io;
+ break;
+ }
+
+ /* Fill data array each time with pseudo-random values */
+ for (j = 0; j < TRANSFER_SIZE; j++)
+ outbuff[j] = seed, seed =
+ ((seed + 358979323) ^ (seed >> 16)) * 314159265;
+
+ /* Transfer the random array to GUS */
+ /* Poke a security fence around dest block */
+ __gus_poke(0x100 - 1, 0xAA);
+ __gus_poke(0x100 - 2, 0x55);
+ __gus_poke(0x100 + TRANSFER_SIZE + 0, 0xAA);
+ __gus_poke(0x100 + TRANSFER_SIZE + 1, 0x55);
+
+ func(0x100, outbuff, TRANSFER_SIZE, 0);
+
+ if (__gus_wait_dma() == 0) {
+ /* Check if the security fence was not damaged */
+ if ((__gus_peek(0x100 - 1) != 0xAA)
+ || (__gus_peek(0x100 - 2) != 0x55)
+ || (__gus_peek(0x100 + TRANSFER_SIZE + 0) != 0xAA)
+ || (__gus_peek(0x100 + TRANSFER_SIZE + 1) != 0x55))
+ continue;
+
+ /* Now check if GUS DRAM really data that we expects to be transferred */
+ __gus_transfer_io_in(0x100, inbuff, TRANSFER_SIZE);
+ if (memcmp(outbuff, inbuff, TRANSFER_SIZE) == 0) {
+ gus.transfer = func;
+ break;
+ }
+ }
+ }
+
+#undef TRANSFER_SIZE
+
+ MikMod_free(inbuff);
+ MikMod_free(outbuff);
+}
+
+static void __gus_detect_memory()
+{
+ unsigned int size;
+ for (size = 0; size < 1024; size += 256) {
+ __gus_poke(size * 1024, 0xaa);
+ if (__gus_peek(size * 1024) != 0xaa)
+ break;
+ __gus_poke(size * 1024, 0x55);
+ if (__gus_peek(size * 1024) != 0x55)
+ break;
+ }
+ gus.ram = size;
+}
+
+static void __gus_init()
+{
+ char *gusenv = getenv("ULTRASND");
+
+ memset((void *)&gus, 0, sizeof(gus));
+ gus.cmd_voice = -1;
+
+ if (!gusenv)
+ return;
+
+ sscanf(gusenv, "%x,%d,%d,%d,%d", &gus.port, &gus.dma[0], &gus.dma[1],
+ &gus.irq[0], &gus.irq[1]);
+
+ /* A relaxed sanity check */
+ if ((gus.port < 0x100) || (gus.port > 0x1000)
+ || (gus.irq[0] < 2) || (gus.irq[0] > 15)
+ || (gus.irq[1] < 2) || (gus.irq[1] > 15)
+ || (gus.dma[0] < 0) || (gus.dma[0] > 7)
+ || (gus.dma[1] < 0) || (gus.dma[1] > 7))
+ return;
+
+ gus.voices = 32;
+ gus.timer_ctl = GF1M_MASK_TIMER1 | GF1M_MASK_TIMER2;
+
+ /* Detect if the card is really there */
+ if (__gus_detect() == 0)
+ return;
+
+ /* Detect the version of Gravis Ultrasound */
+ __gus_detect_version();
+
+ /* Reset the card */
+ __gus_reset(1);
+
+ /* Detect the amount of on-board memory */
+ __gus_detect_memory();
+
+ gus.ok = 1;
+}
+
+static void __gus_kick(gus_wave_t * wave, unsigned int wave_offset)
+{
+ unsigned char vc;
+
+ vc = GF1VC_IRQ;
+ if (wave->format & GUS_WAVE_16BIT)
+ vc |= GF1VC_DATA16;
+ if (wave->format & GUS_WAVE_BACKWARD)
+ vc |= GF1VC_BACKWARD;
+ if (wave->format & GUS_WAVE_LOOP) {
+ vc |= GF1VC_LOOP_ENABLE;
+ if (wave->format & GUS_WAVE_BIDIR)
+ vc |= GF1VC_BI_LOOP;
+ }
+ __gus_set_loop_start(vc, (wave->begin.memory << 4) + wave->loop_start);
+ if (wave->format & GUS_WAVE_LOOP)
+ __gus_set_loop_end(vc, (wave->begin.memory << 4) + wave->loop_end);
+ else
+ __gus_set_loop_end(vc, (wave->begin.memory + wave->size) << 4);
+ __gus_set_current(vc, (wave->begin.memory << 4) + wave_offset + 100);
+ __gus_outregb_slow(GF1R_VOICE_CONTROL, vc);
+}
+
+/* Timer 1 callback function (updates voices) */
+static void __gus_timer_update()
+{
+ gus_wave_t *wave;
+ unsigned long wave_offset;
+ unsigned char *src, *top;
+ unsigned int vmask = (1 << gus.cur_voice);
+
+ if (!gus.cmd_pool_ready)
+ return;
+
+ __gus_select_voice(gus.cur_voice);
+ wave_offset = 0;
+ src = gus.cmd_pool;
+ top = gus.cmd_pool + gus.cmd_pool_top;
+
+#define GET_B *src
+#define GET_W *((unsigned short *)src)
+#define GET_L *((unsigned long *)src)
+
+ while (src < top) {
+ __gus_delay();
+ switch (GET_B++) {
+ case PCMD_VOICE:
+ __gus_select_voice(gus.cur_voice = GET_B++);
+ vmask = (1 << gus.cur_voice);
+ break;
+ case PCMD_FREQ:
+ /* __gus_outregw(GF1R_FREQUENCY, GET_W++);*/
+ __gus_outregw(GF1R_FREQUENCY, *(unsigned short *)src);
+ src += 2;
+ break;
+ case PCMD_PAN:
+ __gus_outregb(GF1R_BALANCE, GET_B++);
+ break;
+ case PCMD_VOLUME:
+ __gus_volume_ramp_to(gus.cur_vol[gus.cur_voice] =
+ /* GET_W++, GUS_VOLCHANGE_RAMP, GF1VL_IRQ);*/
+ *(unsigned short *)src, GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
+ src += 2;
+ break;
+ case PCMD_VOLUME_PREPARE:
+ /* gus.cur_vol[gus.cur_voice] = GET_W++;*/
+ gus.cur_vol[gus.cur_voice] = *(unsigned short *)src;
+ src += 2;
+ break;
+ case PCMD_OFFSET:
+ /* wave_offset = GET_L++;*/
+ wave_offset = *(unsigned long *)src;
+ src += 4;
+ break;
+ case PCMD_START:
+ /* wave = (gus_wave_t *) GET_L++;*/
+ wave = (gus_wave_t *) *(unsigned long *)src;
+ src += 4;
+ gus.cur_wave[gus.cur_voice] = wave;
+ gus.kick_offs[gus.cur_voice] = wave_offset;
+ if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ)) {
+ __gus_kick(wave, wave_offset);
+ __gus_volume_ramp_to(gus.cur_vol[gus.cur_voice],
+ GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
+ } else
+ gus.voice_kick[gus.cur_voice] = 1;
+ wave_offset = 0;
+ gus.eow_ignore |= vmask;
+ break;
+ case PCMD_STOP:
+ /* If volume is close to nothing, abort immediately instead of
+ ramping */
+ gus.cur_vol[gus.cur_voice] = 0;
+ gus.cur_wave[gus.cur_voice] = NULL;
+ if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ))
+ __gus_stop_voice();
+ break;
+ case PCMD_STOP_LOOP:
+ __gus_outregb_slow(GF1R_VOICE_CONTROL,
+ (__gus_inregb(GF1R_VOICE_CONTROL) | GF1VC_IRQ)
+ & ~GF1VC_LOOP_ENABLE);
+ __gus_outregb_slow(GF1R_VOLUME_CONTROL,
+ __gus_inregb(GF1R_VOLUME_CONTROL) &
+ ~GF1VL_ROLLOVER);
+ break;
+ default:
+ /* Alarm! Break out immediately */
+ src = top;
+ break;
+ }
+ }
+
+#undef GET_B
+#undef GET_W
+#undef GET_L
+
+ gus.cmd_pool_ready = 0;
+ gus.cmd_pool_top = 0;
+}
+
+static void __gus_wavetable_update(unsigned int voice, unsigned int voice_ctl,
+ unsigned int volume_ctl)
+{
+ gus_wave_t *wave = gus.cur_wave[voice];
+
+ if (!wave || !(wave->format & GUS_WAVE_LOOP)) {
+ __gus_stop_voice();
+ gus.cur_wave[voice] = NULL;
+ gus.cur_vol[voice] = 0;
+ if (__gus_volume_ramp_to(0, GUS_VOLCHANGE_RAMP, GF1VL_IRQ))
+ __gus_stop_voice();
+ }
+}
+
+static void __gus_volume_update(unsigned int voice, unsigned int voice_ctl,
+ unsigned int volume_ctl)
+{
+ __gus_volume_ramp_to(gus.cur_vol[voice], GUS_VOLCHANGE_RAMP, GF1VL_IRQ);
+ if (!gus.cur_wave[voice])
+ __gus_stop_voice();
+ else if (gus.voice_kick[voice])
+ __gus_kick(gus.cur_wave[voice], gus.kick_offs[voice]);
+ gus.voice_kick[voice] = 0;
+}
+
+/***************************************************** GUS memory manager *****/
+
+/* Mark all GUS memory as available */
+static void __gus_mem_clear()
+{
+ __gus_mcb *cur = gus.mcb;
+
+ while (cur) {
+ __gus_mcb *next = cur->next;
+ if (cur != gus.mcb)
+ MikMod_free(cur);
+ cur = next;
+ }
+
+ if (!gus.mcb)
+ gus.mcb = (__gus_mcb *) MikMod_malloc(sizeof(__gus_mcb));
+
+ gus.mcb->next = gus.mcb->prev = NULL;
+ gus.mcb->addr = 0;
+ gus.mcb->size = gus.ram * 1024;
+ gus.mcb->free = 1;
+}
+
+/* Return amount of free memory */
+static unsigned int __gus_mem_get_free()
+{
+ __gus_mcb *cur = gus.mcb;
+ unsigned int size = 0;
+
+ if (!gus.open)
+ return gus.ram * 1024;
+
+ while (cur) {
+ if (cur->free)
+ size += cur->size;
+ cur = cur->next;
+ }
+
+ return size;
+}
+
+/* Return largest size for a 8-bit sample */
+static unsigned int __gus_mem_get_free_8()
+{
+ __gus_mcb *cur = gus.mcb;
+ unsigned int size = 0;
+
+ if (!gus.open)
+ return 0;
+
+ while (cur) {
+ if (cur->free && (cur->size > size))
+ size = cur->size;
+ cur = cur->next;
+ }
+
+ return size;
+}
+
+/* Return largest size for a 16-bit sample */
+static unsigned int __gus_mem_get_free_16()
+{
+ __gus_mcb *cur = gus.mcb;
+ unsigned int size = 0;
+
+ if (!gus.open)
+ return 0;
+
+ while (cur) {
+ if (cur->free) {
+ unsigned int size16 = cur->size;
+ unsigned int tmp;
+ /* 16-bit samples cannot cross 256K boundaries */
+ tmp = 0x40000 - (cur->addr & 0x3ffff);
+ if (size16 > tmp)
+ size16 = tmp;
+ /* 16-bit samples should be aligned on a 32-byte boundary */
+ size16 -= (32 - cur->addr) & 0x1f;
+
+ if (size16 > size)
+ size = size16;
+
+ /* Now try vice versa: skip a portion of aligned memory */
+ size16 =
+ (cur->addr + cur->size) - ((cur->addr + 0x3ffff) & ~0x3ffff);
+ if ((size16 < 0x7fffffff) && (size16 > size))
+ size = size16;
+ }
+ cur = cur->next;
+ }
+
+ return size;
+}
+
+/* Allocate a segment of GUS DRAM for a sample with given bits per sample.
+ * The algorithm tries to find the smallest free block that fits requested
+ * size; but if found free block is larger by some (large) delta than
+ * requested block size, the largest possible block is preffered.
+ */
+static unsigned int __gus_mem_alloc(unsigned int size, int bits16)
+{
+ __gus_mcb *cur = gus.mcb;
+ __gus_mcb *best_max = NULL, *best_min = NULL;
+ unsigned int best_max_delta = 0, best_min_delta = 0xffffffff;
+ unsigned int best_max_prefix = 0, best_min_prefix = 0;
+ unsigned int memaddr, memsize;
+
+ if (!gus.open || !size || (bits16 && size > 0x40000))
+ return -1;
+
+ /* Round block size up to nearest acceptable DMA bound */
+ if (bits16)
+ size = (size + 0x1f) & ~0x1f;
+ else
+ size = (size + 0x0f) & ~0x0f;
+
+ while (cur) {
+ if (cur->free) {
+ unsigned char fits = 0;
+
+ memsize = cur->size;
+ memaddr = cur->addr;
+
+ if (bits16) {
+ /* 16-bit samples cannot cross 256K boundaries */
+ unsigned int tmp = 256 * 1024 - (memaddr & 0x3ffff);
+ if (memsize > tmp)
+ memsize = tmp;
+ /* 16-bit samples should be aligned on a 32-byte boundary */
+ memsize -= (32 - memaddr) & 0x1f;
+ memaddr = (memaddr + 0x1f) & ~0x1f;
+ }
+
+ /* If block fits, analyze it */
+ if (size <= memsize)
+ fits = 1;
+ /* Look if we still can complete the request by creating a free
+ block */
+ else if (size <= cur->size) {
+ /* Align start address to next 256k boundary */
+ unsigned int endaddr = cur->addr + cur->size;
+ memaddr = (cur->addr + 0x3ffff) & ~0x3ffff;
+ /* Can we split current block by inserting a free block at the
+ beginning? */
+ if ((memaddr < endaddr) && (memaddr + size <= endaddr))
+ fits = 1;
+ }
+
+ if (fits) {
+ unsigned int size_delta = cur->size - size;
+ unsigned int size_prefix = memaddr - cur->addr;
+ if (size_delta < best_min_delta)
+ best_min = cur, best_min_delta =
+ size_delta, best_min_prefix = size_prefix;
+ if (size_delta > best_max_delta)
+ best_max = cur, best_max_delta =
+ size_delta, best_max_prefix = size_prefix;
+ }
+ }
+
+ cur = cur->next;
+ }
+
+ if (!best_min)
+ return -1;
+
+ /* If minimal block that fits is too large, use largest block that fits */
+ /* But if using the maximal block is going to create a small hole, forget
+ it */
+ if ((best_max_prefix == 0)
+ || (best_max_prefix >= DRAM_HOLE_THRESHOLD)
+ || (best_min_prefix != 0))
+ if (
+ ((best_min_delta < DRAM_HOLE_THRESHOLD) &&
+ (best_max_delta >= DRAM_HOLE_THRESHOLD)) ||
+ ((best_min_prefix > 0) && (best_min_prefix < DRAM_HOLE_THRESHOLD)
+ && ((best_max_prefix == 0) ||
+ (best_max_prefix > best_min_prefix))) ||
+ ((best_min_prefix != 0) && (best_max_prefix == 0))) {
+ best_min = best_max;
+ best_min_delta = best_max_delta;
+ best_min_prefix = best_max_prefix;
+ }
+
+ /* Compute the DRAM address to return */
+ memaddr = best_min->addr + best_min_prefix;
+ if (bits16)
+ memaddr = (memaddr + 0x1f) & ~0x1f;
+ else
+ memaddr = (memaddr + 0x0f) & ~0x0f;
+
+ /* If we have a considerable hole at the beginning of sample,
+ create a free node describing the hole */
+ if (memaddr - best_min->addr >= DRAM_SPLIT_THRESHOLD) {
+ __gus_mcb *newmcb = (__gus_mcb *) MikMod_malloc(sizeof(__gus_mcb));
+ newmcb->prev = best_min->prev;
+ newmcb->next = best_min;
+ newmcb->addr = best_min->addr;
+ newmcb->size = memaddr - best_min->addr;
+ newmcb->free = 1;
+ best_min->addr = memaddr;
+ best_min->size -= newmcb->size;
+ best_min->prev = newmcb;
+ if (newmcb->prev)
+ newmcb->prev->next = newmcb;
+ }
+
+ /* Compute the size of hole at the end of block */
+ memsize = (best_min->addr + best_min->size) - (memaddr + size);
+
+ /* Split the block if the block is larger than requested amount */
+ if (memsize > DRAM_SPLIT_THRESHOLD) {
+ /* The next node cannot be free since free blocks are always glued
+ together */
+ __gus_mcb *newmcb = (__gus_mcb *) MikMod_malloc(sizeof(__gus_mcb));
+ best_min->size -= memsize;
+ newmcb->prev = best_min;
+ newmcb->next = best_min->next;
+ newmcb->addr = best_min->addr + best_min->size;
+ newmcb->size = memsize;
+ newmcb->free = 1;
+ if (best_min->next)
+ best_min->next->prev = newmcb;
+ best_min->next = newmcb;
+ }
+ best_min->free = 0;
+
+ return memaddr;
+}
+
+static void __gus_mem_free(unsigned int addr)
+{
+ __gus_mcb *cur = gus.mcb;
+ while (cur) {
+ if (!cur->free && (cur->addr <= addr) &&
+ (cur->addr + cur->size > addr)) {
+ cur->free = 1;
+
+ /* If next block is free as well, link them together */
+ if (cur->next && cur->next->free) {
+ __gus_mcb *next = cur->next;
+ cur->size += next->size;
+ cur->next = next->next;
+ if (next->next)
+ next->next->prev = cur;
+ MikMod_free(next);
+ }
+
+ /* If previous block is free, link current block with it */
+ if (cur->prev && cur->prev->free) {
+ cur->prev->size += cur->size;
+ cur->prev->next = cur->next;
+ if (cur->next)
+ cur->next->prev = cur->prev;
+ MikMod_free(cur);
+ }
+ return;
+ }
+ cur = cur->next;
+ }
+}
+
+static void __gus_mem_pack()
+{
+}
+
+#ifdef MIKMOD_DEBUG
+
+/* Debug dump of GUS DRAM heap */
+void __gus_mem_dump()
+{
+ __gus_mcb *cur = gus.mcb;
+ fprintf(stderr, "/-- Offset --+-- Prev --+-- Size --+-- Free --\\\n");
+ while (cur) {
+ fprintf(stderr, "| %08X | %08X | %6d | %s |\n",
+ cur->addr, cur->prev ? cur->prev->addr : -1, cur->size,
+ cur->free ? "yes" : " no");
+ cur = cur->next;
+ }
+ fprintf(stderr, "\\------------+----------+----------+----------/\n");
+}
+
+#endif
+
+/************************************************** Middle-level routines *****/
+
+static int __gus_instrument_free(gus_instrument_t * instrument)
+{
+ gus_instrument_t **cur_instr;
+ gus_layer_t *cur_layer;
+ gus_wave_t *cur_wave, *wave_head;
+
+ /* Remove the instrument from the list of registered instruments */
+ cur_instr = (gus_instrument_t **) & gus.instr;
+ while (*cur_instr) {
+ if (*cur_instr == instrument) {
+ *cur_instr = instrument->next;
+ goto instr_loaded;
+ }
+ cur_instr = &(*cur_instr)->next;
+ }
+ return -1;
+
+instr_loaded:
+ wave_head = NULL;
+ for (cur_layer = instrument->info.layer; cur_layer;
+ cur_layer = cur_layer->next)
+ /* Free all waves */
+ for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next) {
+ if (!wave_head)
+ wave_head = cur_wave;
+ if (cur_wave->begin.memory != (unsigned int)-1)
+ __gus_mem_free(cur_wave->begin.memory);
+ }
+ if (wave_head)
+ MikMod_free(wave_head);
+
+ MikMod_free(instrument->info.layer);
+ if (instrument->name)
+ MikMod_free(instrument->name);
+ MikMod_free(instrument);
+ return 0;
+}
+
+static gus_instrument_t *__gus_instrument_get(int program)
+{
+ gus_instrument_t *cur_instr = (gus_instrument_t *) gus.instr;
+ while (cur_instr) {
+ if (cur_instr->number.instrument == program)
+ return cur_instr;
+ cur_instr = cur_instr->next;
+ }
+ return NULL;
+}
+
+static gus_instrument_t *__gus_instrument_copy(gus_instrument_t * instrument)
+{
+ gus_instrument_t **cur_instr, *instr;
+ gus_layer_t *cur_layer, *dest_layer;
+ gus_wave_t *cur_wave, *dest_wave;
+ unsigned int waves, layers;
+
+ if (!instrument || !instrument->info.layer || !gus.open)
+ return NULL;
+
+ if (__gus_instrument_get(instrument->number.instrument))
+ return NULL;
+
+ instr = (gus_instrument_t *) MikMod_malloc(sizeof(gus_instrument_t));
+ *instr = *instrument;
+
+ if (instrument->name)
+ instr->name = MikMod_strdup(instrument->name);
+
+ /* Make a copy of all layers at once */
+ for (layers = 0, cur_layer = instrument->info.layer; cur_layer; layers++)
+ cur_layer = cur_layer->next;
+
+ if (!(dest_layer = instr->info.layer = (gus_layer_t *) MikMod_malloc(sizeof(gus_layer_t) * layers))) {
+ if (instr->name)
+ MikMod_free(instr->name);
+ MikMod_free(instr);
+ return NULL;
+ }
+ for (waves = 0, cur_layer = instrument->info.layer; cur_layer;
+ cur_layer = cur_layer->next) {
+ *dest_layer = *cur_layer;
+ dest_layer->wave = NULL;
+ /* Count the total number of waves */
+ for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next)
+ waves++;
+ if (cur_layer->next)
+ dest_layer->next = dest_layer + 1;
+ else
+ dest_layer->next = NULL;
+ dest_layer++;
+ }
+
+ /* Allocate memory for waves */
+ if (!(dest_wave = (gus_wave_t *) MikMod_malloc(sizeof(gus_wave_t) * waves))) {
+ MikMod_free(instr->info.layer);
+ if (instr->name)
+ MikMod_free(instr->name);
+ MikMod_free(instr);
+ return NULL;
+ }
+ for (cur_layer = instrument->info.layer, dest_layer = instr->info.layer;
+ cur_layer; cur_layer = cur_layer->next, dest_layer = dest_layer->next)
+ /* Copy all waves */
+ for (cur_wave = cur_layer->wave; cur_wave; cur_wave = cur_wave->next) {
+ if (!dest_layer->wave)
+ dest_layer->wave = dest_wave;
+
+ *dest_wave = *cur_wave;
+ /* Mark DRAM address as unallocated */
+ dest_wave->begin.memory = -1;
+
+ if (cur_wave->next)
+ dest_wave->next = (dest_wave + 1);
+ else
+ dest_wave->next = NULL;
+ dest_wave++;
+ }
+
+ /* Insert the instrument into list of registered instruments */
+ cur_instr = (gus_instrument_t **) & gus.instr;
+ while (*cur_instr)
+ cur_instr = &(*cur_instr)->next;
+ *cur_instr = instr;
+
+ return instr;
+}
+
+static void __gus_instruments_clear()
+{
+ gus_instrument_t *next_instr, *cur_instr = (gus_instrument_t *) gus.instr;
+ while (cur_instr) {
+ next_instr = cur_instr->next;
+ __gus_instrument_free(cur_instr);
+ cur_instr = next_instr;
+ }
+}
+
+/******************************************************* libGUS interface *****/
+
+/* return value: number of GUS cards installed in system */
+int gus_cards()
+{
+ if (!gus.ok)
+ __gus_init();
+ return gus.ok ? 1 : 0;
+}
+
+int gus_info(gus_info_t * info, int reread)
+{
+ if (!gus.ok)
+ __gus_init();
+ if (!gus.ok)
+ return -1;
+
+ strcpy((char *)info->id, "gus0");
+ info->flags = (gus.ram ? GUS_STRU_INFO_F_PCM : 0);
+ info->version = gus.version;
+ info->port = gus.port;
+ info->irq = gus.irq[0];
+ info->dma1 = gus.dma[0];
+ info->dma2 = gus.dma[1];
+
+ info->mixing_freq = gus.freq;
+
+ info->memory_size = gus.ram * 1024;
+ info->memory_free = __gus_mem_get_free();
+ info->memory_block_8 = __gus_mem_get_free_8();
+ info->memory_block_16 = __gus_mem_get_free_16();
+ return 0;
+}
+
+int gus_open(int card, size_t queue_buffer_size, int non_block)
+{
+ __dpmi_meminfo struct_info, pool_info;
+
+ if (!gus.ok)
+ __gus_init();
+
+ if (!gus.ok || gus.open || card != 0)
+ return -1;
+
+ /* Now lock the gus structure in memory */
+ struct_info.address = __djgpp_base_address + (unsigned long)&gus;
+ struct_info.size = sizeof(gus);
+ if (__dpmi_lock_linear_region(&struct_info))
+ return -1;
+
+ /* And hook the GF1 interrupt */
+ __irq_stack_count = 4;
+ gus.gf1_irq =
+ irq_hook(gus.irq[0], gf1_irq, (long)gf1_irq_end - (long)gf1_irq);
+ __irq_stack_count = 1;
+ if (!gus.gf1_irq) {
+ __dpmi_unlock_linear_region(&struct_info);
+ return -1;
+ }
+
+ /* Enable the interrupt */
+ irq_enable(gus.gf1_irq);
+ if (gus.irq[0] > 7)
+ _irq_enable(2);
+
+ /* Allocate a DMA buffer: if we fail, we just use I/O so don't fail */
+ if ((gus.transfer == NULL) || (gus.transfer == __gus_transfer_dma))
+ gus.dma_buff = dma_allocate(gus.dma[0], GF1_DMA_BUFFER_SIZE);
+ else
+ gus.dma_buff = NULL;
+
+ /* Detect the best available RAM -> DRAM transfer function */
+ if (!gus.transfer) {
+ __gus_detect_transfer();
+ if (gus.transfer != __gus_transfer_dma || !gus.transfer)
+ dma_free(gus.dma_buff), gus.dma_buff = NULL;
+
+ /* If no transfer function worked, fail */
+ if (!gus.transfer) {
+ if (gus.dma_buff) {
+ dma_free(gus.dma_buff);
+ gus.dma_buff = NULL;
+ }
+ __dpmi_unlock_linear_region(&struct_info);
+ irq_unhook(gus.gf1_irq);
+ gus.gf1_irq = NULL;
+ return -1;
+ }
+ }
+
+ /* Allocate and lock command pool buffer */
+ if (queue_buffer_size < 64)
+ queue_buffer_size = 64;
+ if (queue_buffer_size > 16384)
+ queue_buffer_size = 16384;
+ gus.cmd_pool = (unsigned char *) MikMod_malloc(queue_buffer_size);
+ pool_info.address = __djgpp_base_address + (unsigned long)&gus.cmd_pool;
+ pool_info.size = sizeof(queue_buffer_size);
+ if (__dpmi_lock_linear_region(&pool_info)) {
+ if (gus.dma_buff) {
+ dma_free(gus.dma_buff);
+ gus.dma_buff = NULL;
+ }
+ __dpmi_unlock_linear_region(&struct_info);
+ irq_unhook(gus.gf1_irq);
+ gus.gf1_irq = NULL;
+ return -1;
+ }
+
+ gus.open++;
+
+ __gus_mem_clear();
+ gus.t1_callback = __gus_timer_update;
+ gus.wt_callback = __gus_wavetable_update;
+ gus.vl_callback = __gus_volume_update;
+ gus_do_tempo(60); /* Default is 60 Hz */
+
+ return 0;
+}
+
+int gus_close(int card)
+{
+ __dpmi_meminfo struct_info;
+
+ if (!gus.open || card != 0)
+ return -1;
+
+ /* First reset the card: disable any operation it can currently perform */
+ __gus_reset(0);
+
+ gus.open--;
+
+ /* Stop the timer */
+ gus_timer_stop();
+
+ /* Free DMA buffer if used */
+ if (gus.dma_buff) {
+ dma_free(gus.dma_buff);
+ gus.dma_buff = NULL;
+ }
+
+ /* And unhook the GF1 interrupt */
+ irq_unhook(gus.gf1_irq);
+ gus.gf1_irq = NULL;
+
+ /* Unlock the gus structure */
+ struct_info.address = __djgpp_base_address + (unsigned long)&gus;
+ struct_info.size = sizeof(gus);
+ __dpmi_unlock_linear_region(&struct_info);
+
+ __gus_mem_clear();
+ __gus_instruments_clear();
+
+ return 0;
+}
+
+int gus_select(int card)
+{
+ if (!gus.open || (card != 0))
+ return -1;
+
+ return 0;
+}
+
+/* return value: same as gus_reset function
+ note: this command doesn't change number of active voices and doesn't do
+ hardware reset */
+int gus_reset_engine_only()
+{
+ gus.timer_base = 100;
+ return 0;
+}
+
+int gus_reset(int voices, unsigned int channel_voices)
+{
+ static unsigned short freq_table[32 - 14 + 1] = {
+ 44100, 41160, 38587, 36317, 34300, 32494, 30870, 29400, 28063, 26843,
+ 25725, 24696, 23746, 22866, 22050, 21289, 20580, 19916, 19293
+ };
+ int voice;
+ int timer;
+
+ /* No support for dynamically allocated voices for now */
+ gus.dynmask = channel_voices;
+
+ if (voices < 14)
+ voices = 14;
+ if (voices > 32)
+ voices = 32;
+
+ /* Stop the timer so that GUS IRQ won't clobber registers */
+ timer = (gus.timer_ctl_reg & GF1M_TIMER1);
+ if (timer)
+ gus_timer_stop();
+
+ /* Stop all voices */
+ for (voice = 0; voice < 32; voice++) {
+ __gus_select_voice(voice);
+ __gus_stop_voice();
+ gus.cur_wave[voice] = NULL;
+ gus.cur_vol[voice] = 0;
+
+ __gus_delay();
+
+ /* Reset voice parameters to reasonable values */
+ __gus_set_current(0, 0);
+ __gus_set_loop_start(0, 0);
+ __gus_set_loop_end(0, 0);
+ __gus_outregw(GF1R_VOLUME, 0);
+ __gus_outregb(GF1R_VOLUME_RATE, 0);
+ __gus_outregb(GF1R_VOLUME_START, 0);
+ __gus_outregb(GF1R_VOLUME_END, 0);
+ __gus_outregb(GF1R_BALANCE, 0x7);
+ }
+
+ voice = (__gus_inregb(GF1R_VOICES) & 0x1f) + 1;
+
+ if (voice != voices) {
+ int reset = __gus_inregb(GF1R_RESET);
+ __gus_outregb(GF1R_RESET, reset & ~GF1M_OUTPUT_ENABLE);
+ __gus_delay();
+ __gus_outregb(GF1R_VOICES, 0xc0 | (voices - 1));
+ __gus_delay();
+ __gus_outregb(GF1R_RESET, reset);
+ }
+
+ /* Compute the discretization frequence */
+ gus.voices = voices;
+ if (gus.interwave)
+ gus.freq = 44100;
+ else
+ gus.freq = freq_table[voices - 14];
+
+ gus_reset_engine_only();
+
+ if (timer)
+ gus_timer_continue();
+
+ return gus.voices;
+}
+
+int gus_do_flush()
+{
+ DEBUG_PRINT(("gus_do_flush: top = %d\n", gus.cmd_pool_top))
+ gus.cmd_pool_ready = 1;
+ return 0;
+}
+
+/* set new tempo */
+void gus_do_tempo(unsigned int tempo)
+{
+ DEBUG_PRINT(("gus_do_tempo (%d)\n", tempo))
+ gus_timer_tempo(tempo);
+ gus_timer_start();
+}
+
+/* set voice frequency in Hz */
+void gus_do_voice_frequency(unsigned char voice, unsigned int freq)
+{
+ DEBUG_PRINT(("gus_do_voice_frequency (%d, %d)\n", voice, freq))
+ __pool_select_voice(voice);
+ __pool_command_w(PCMD_FREQ,
+ (((freq << 9) + (gus.freq >> 1)) / gus.freq) << 1);
+}
+
+/* set voice pan (0-16384) (full left - full right) */
+void gus_do_voice_pan(unsigned char voice, unsigned short pan)
+{
+ DEBUG_PRINT(("gus_do_voice_pan (%d, %d)\n", voice, pan))
+ pan >>= 10;
+ if (pan > 15)
+ pan = 15;
+ __pool_select_voice(voice);
+ __pool_command_b(PCMD_PAN, pan);
+}
+
+/* set voice volume level 0-16384 (linear) */
+void gus_do_voice_volume(unsigned char voice, unsigned short vol)
+{
+ DEBUG_PRINT(("gus_do_voice_volume (%d, %d)\n", voice, vol))
+ if (vol > 0x3fff)
+ vol = 0x3fff;
+ __pool_select_voice(voice);
+ __pool_command_w(PCMD_VOLUME, __gus_volume_table[vol >> 5]);
+}
+
+/* start voice
+ * voice : voice #
+ * program : program # or ~0 = current
+ * freq : frequency in Hz
+ * volume : volume level (0-16384) or ~0 = current
+ * pan : pan level (0-16384) or ~0 = current
+ */
+void gus_do_voice_start(unsigned char voice, unsigned int program,
+ unsigned int freq, unsigned short volume,
+ unsigned short pan)
+{
+ gus_do_voice_start_position(voice, program, freq, volume, pan, 0);
+}
+
+/* start voice
+ * voice : voice #
+ * program : program # or ~0 = current
+ * freq : frequency in Hz
+ * volume : volume level (0-16384) or ~0 = current
+ * pan : pan level (0-16384) or ~0 = current
+ * position : offset to wave in bytes * 16 (lowest 4 bits - fraction)
+ */
+void gus_do_voice_start_position(unsigned char voice, unsigned int program,
+ unsigned int freq, unsigned short volume,
+ unsigned short pan, unsigned int position)
+{
+ gus_instrument_t *instrument;
+ gus_wave_t *wave;
+
+ DEBUG_PRINT(
+ ("gus_do_voice_start_position (%d, %d, pos: %d)\n", voice,
+ program, position))
+
+ instrument = __gus_instrument_get(program);
+
+ if (!instrument
+ || !instrument->info.layer
+ || !instrument->info.layer->wave
+ || instrument->flags == GUS_INSTR_F_NOT_FOUND
+ || instrument->flags == GUS_INSTR_F_NOT_LOADED) return;
+
+ gus_do_voice_frequency(voice, freq);
+ gus_do_voice_pan(voice, pan);
+
+ /* We have to set volume different way, to avoid unneeded work in handler */
+ if (volume > 0x3fff)
+ volume = 0x3fff;
+ __pool_command_w(PCMD_VOLUME_PREPARE, __gus_volume_table[volume >> 5]);
+
+ switch (instrument->mode) {
+ case GUS_INSTR_SIMPLE:
+ wave = instrument->info.layer->wave;
+ if (position)
+ __pool_command_l(PCMD_OFFSET, position);
+ __pool_command_l(PCMD_START, (unsigned long)wave);
+ break;
+ }
+}
+
+/* stop voice
+ * mode = 0 : stop voice now
+ * mode = 1 : disable wave loop and finish it
+ */
+void gus_do_voice_stop(unsigned char voice, unsigned char mode)
+{
+ __pool_select_voice(voice);
+ if (mode)
+ __pool_command(PCMD_STOP_LOOP);
+ else
+ __pool_command(PCMD_STOP);
+}
+
+/* wait x ticks - this command is block separator
+ all commands between blocks are interpreted in the begining of one tick */
+void gus_do_wait(unsigned int ticks)
+{
+ DEBUG_PRINT(("gus_do_wait (%d)\n", ticks))
+
+ ticks += gus.t1_ticks;
+ while ((int)(ticks - gus.t1_ticks) > 0);
+}
+
+int gus_get_voice_status(int voice)
+{
+ __gus_select_voice(voice);
+ return __gus_inregb(GF1R_VOICE_CONTROL) & GF1VC_STOPPED ? 0 : 1;
+}
+
+/* return value: file handle (descriptor) for /dev/gus */
+int gus_get_handle()
+{
+ /* Return stdout handle so that select() will "work" with it */
+ return 0;
+}
+
+/* return value: zero if instrument was successfully allocated */
+int gus_memory_alloc(gus_instrument_t * instrument)
+{
+ gus_instrument_t *instr = __gus_instrument_copy(instrument);
+ gus_layer_t *cur_layer;
+ gus_wave_t *cur_wave;
+
+ DEBUG_PRINT(("gus_memory_alloc (%d)\n", instrument->number.instrument))
+
+ if (!instr)
+ return -1;
+
+ for (cur_layer = instr->info.layer; cur_layer;
+ cur_layer = cur_layer->next) for (cur_wave = cur_layer->wave;
+ cur_wave;
+ cur_wave = cur_wave->next) {
+ if (cur_layer->mode == GUS_INSTR_SIMPLE) {
+ cur_wave->begin.memory = __gus_mem_alloc(cur_wave->size,
+ cur_wave->format &
+ GUS_WAVE_16BIT);
+ if (cur_wave->begin.memory == (unsigned int)-1) {
+ __gus_instrument_free(instr);
+ return -1;
+ }
+ gus.transfer(cur_wave->begin.memory, cur_wave->begin.ptr,
+ cur_wave->size, cur_wave->format);
+ } else if (cur_layer->mode == GUS_INSTR_PATCH)
+ /* not supported yet */ ;
+ }
+
+ return 0;
+}
+
+/* return value: zero if instrument was successfully removed */
+int gus_memory_free(gus_instrument_t * instrument)
+{
+ gus_instrument_t *cur_instr = gus.instr;
+
+ DEBUG_PRINT(("gus_memory_free (%d)\n", instrument->number.instrument))
+
+ for (; cur_instr; cur_instr = cur_instr->next)
+ if (cur_instr->number.instrument == instrument->number.instrument)
+ return __gus_instrument_free(cur_instr);
+
+ return -1;
+}
+
+/* return value: unused gus memory in bytes */
+int gus_memory_free_size()
+{
+ return __gus_mem_get_free();
+}
+
+/* return value: zero if success */
+int gus_memory_pack()
+{
+ __gus_mem_pack();
+ return 0;
+}
+
+/* return value: gus memory size in bytes */
+int gus_memory_size()
+{
+ return gus.ram * 1024;
+}
+
+/* return value: current largest free block for 8-bit or 16-bit wave */
+int gus_memory_free_block(int w_16bit)
+{
+ return w_16bit ? __gus_mem_get_free_16() : __gus_mem_get_free_8();
+}
+
+/* input value: see to GUS_DOWNLOAD_MODE_XXXX constants (gus.h)
+ return value: zero if samples & instruments was successfully removed from
+ GF1 memory manager */
+int gus_memory_reset(int mode)
+{
+ __gus_mem_clear();
+ __gus_instruments_clear();
+ return 0;
+}
+
+/* return value: zero if command queue was successfully flushed */
+int gus_queue_flush()
+{
+ return 0;
+}
+
+/* input value: echo buffer size in items (if 0 - erase echo buffer) */
+int gus_queue_read_set_size(int items)
+{
+ return 0;
+}
+
+/* input value: write queue size in items (each item have 8 bytes) */
+int gus_queue_write_set_size(int items)
+{
+ return 0;
+}
+
+/* return value: zero if successfull */
+int gus_timer_start()
+{
+ gus.timer_ctl_reg |= GF1M_TIMER1;
+ __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
+
+ gus.timer_ctl = gus.timer_ctl & ~GF1M_MASK_TIMER1;
+ outportb(GF1_TIMER_CTRL, 0x04);
+ outportb(GF1_TIMER_DATA, gus.timer_ctl | GF1M_START_TIMER1);
+ return 0;
+}
+
+/* return value: zero if timer was stoped */
+int gus_timer_stop()
+{
+ gus.timer_ctl_reg &= ~GF1M_TIMER1;
+ __gus_outregb_slow(GF1R_TIMER_CONTROL, gus.timer_ctl_reg);
+
+ gus.timer_ctl = gus.timer_ctl | GF1M_MASK_TIMER1;
+ outportb(GF1_TIMER_CTRL, 0x04);
+ outportb(GF1_TIMER_DATA, gus.timer_ctl);
+ return 0;
+}
+
+/* return value: zero if setup was success */
+int gus_timer_tempo(int ticks)
+{
+ unsigned int counter;
+
+ /* Limit ticks per second to 1..1000 range */
+ if (ticks < 1)
+ ticks = 1;
+ if (ticks > 1000)
+ ticks = 1000;
+
+ /* GF1 timer1 period is 80 usecs, 12500 times per second */
+ counter = 1250000 / (ticks * gus.timer_base);
+ gus.t1_multiple = 1;
+ while (counter > 255) {
+ counter >>= 1;
+ gus.t1_multiple <<= 1;
+ }
+ gus.t1_countdown = gus.t1_multiple;
+ __gus_outregb(GF1R_TIMER1, 256 - counter);
+ return 0;
+}
+
+/* return value: zero if timer will be continue */
+int gus_timer_continue()
+{
+ return gus_timer_start();
+}
+
+/* return value: zero if setup was success (default timebase = 100) */
+int gus_timer_base(int base)
+{
+ gus.timer_base = base;
+ return 0;
+}
+
+void gus_timer_callback(void (*timer_callback) ())
+{
+ gus.timer_callback = timer_callback;
+}
+
+void gus_convert_delta(unsigned int type, unsigned char *dest,
+ unsigned char *src, size_t size)
+{
+ if (!(type & GUS_WAVE_DELTA))
+ return;
+
+ /* This doesn't depend much on wave signedness, since addition/subtraction
+ do not depend on operand signedness */
+ if (type & GUS_WAVE_16BIT) {
+ unsigned short delta = type & GUS_WAVE_UNSIGNED ? 0x8000 : 0;
+ while (size--) {
+ delta = *(unsigned short *)dest = *(unsigned short *)src + delta;
+ src += sizeof(unsigned short);
+ dest += sizeof(unsigned short);
+ }
+ } else {
+ unsigned char delta = type & GUS_WAVE_UNSIGNED ? 0x80 : 0;
+ while (size--) {
+ delta = *(unsigned char *)dest = *(unsigned char *)src + delta;
+ src++;
+ dest++;
+ }
+ }
+}
+
+int gus_dma_usage (int use)
+{
+ if (gus.dma_buff)
+ return -1;
+ gus.transfer = __gus_transfer_io;
+ return 0;
+}
+
+#endif /* DRV_ULTRA */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ libGUS-alike definitions for DOS
+
+==============================================================================*/
+
+#ifndef __DOSGUS_H__
+#define __DOSGUS_H__
+
+#include <pc.h>
+#include "dosdma.h"
+#include "dosirq.h"
+#include "libgus.h"
+
+/* Private header file for a libGUS-alike library for DOS */
+
+#define JOYSTICK_TIMER (gus.port+0x201) /* 201 */
+#define JOYSTICK_DATA (gus.port+0x201) /* 201 */
+
+#define GF1_MIDI_CTRL (gus.port+0x100) /* 3X0 */
+#define GF1_MIDI_DATA (gus.port+0x101) /* 3X1 */
+
+#define GF1_VOICESEL (gus.port+0x102) /* 3X2 */
+#define GF1_REGSEL (gus.port+0x103) /* 3X3 */
+#define GF1_DATA (gus.port+0x104) /* 3X4 */
+#define GF1_DATA_LOW (gus.port+0x104) /* 3X4 */
+#define GF1_DATA_HIGH (gus.port+0x105) /* 3X5 */
+#define GF1_IRQ_STATUS (gus.port+0x006) /* 2X6 */
+#define GF1_DRAM (gus.port+0x107) /* 3X7 */
+
+#define GF1_MIX_CTRL (gus.port+0x000) /* 2X0 */
+#define GF1_TIMER_CTRL (gus.port+0x008) /* 2X8 */
+#define GF1_TIMER_DATA (gus.port+0x009) /* 2X9 */
+#define GF1_IRQ_CTRL (gus.port+0x00B) /* 2XB */
+#define GF1_REG_CTRL (gus.port+0x00F) /* 2XF */
+
+#define GF1_REVISION (gus.port+0x506) /* 7X6 */
+
+/* The GF1 hardware clock rate */
+#define CLOCK_RATE 9878400L
+
+/* GF1 voice-independent registers */
+#define GF1R_DMA_CONTROL 0x41
+#define GF1R_DMA_ADDRESS 0x42
+#define GF1R_DRAM_LOW 0x43
+#define GF1R_DRAM_HIGH 0x44
+
+#define GF1R_TIMER_CONTROL 0x45
+#define GF1R_TIMER1 0x46
+#define GF1R_TIMER2 0x47
+
+#define GF1R_SAMPLE_RATE 0x48
+#define GF1R_SAMPLE_CONTROL 0x49
+
+#define GF1R_JOYSTICK 0x4B
+#define GF1R_RESET 0x4C
+
+/* GF1 voice-specific registers */
+#define GF1R_VOICE_CONTROL 0x00
+#define GF1R_FREQUENCY 0x01
+#define GF1R_START_HIGH 0x02
+#define GF1R_START_LOW 0x03
+#define GF1R_END_HIGH 0x04
+#define GF1R_END_LOW 0x05
+#define GF1R_VOLUME_RATE 0x06
+#define GF1R_VOLUME_START 0x07
+#define GF1R_VOLUME_END 0x08
+#define GF1R_VOLUME 0x09
+#define GF1R_ACC_HIGH 0x0a
+#define GF1R_ACC_LOW 0x0b
+#define GF1R_BALANCE 0x0c
+#define GF1R_VOLUME_CONTROL 0x0d
+#define GF1R_VOICES 0x0e
+#define GF1R_IRQ_SOURCE 0x0f
+
+/* Add this to above registers for reading */
+#define GF1R_READ_MASK 0x80
+
+/* MIDI */
+#define GF1M_MIDI_RESET 0x03
+#define GF1M_MIDI_ENABLE_XMIT 0x20
+#define GF1M_MIDI_ENABLE_RCV 0x80
+
+#define GF1M_MIDI_RCV_FULL 0x01
+#define GF1M_MIDI_XMIT_EMPTY 0x02
+#define GF1M_MIDI_FRAME_ERR 0x10
+#define GF1M_MIDI_OVERRUN 0x20
+#define GF1M_MIDI_IRQ_PEND 0x80
+
+/* Joystick */
+#define GF1M_JOY_POSITION 0x0f
+#define GF1M_JOY_BUTTONS 0xf0
+
+/* GF1_IRQ_STATUS (port 2X6) */
+#define GF1M_IRQ_MIDI_TX 0x01 /* pending MIDI xmit IRQ */
+#define GF1M_IRQ_MIDI_RX 0x02 /* pending MIDI recv IRQ */
+#define GF1M_IRQ_TIMER1 0x04 /* general purpose timer */
+#define GF1M_IRQ_TIMER2 0x08 /* general purpose timer */
+#define GF1M_IRQ_WAVETABLE 0x20 /* pending wavetable IRQ */
+#define GF1M_IRQ_ENVELOPE 0x40 /* pending volume envelope IRQ */
+#define GF1M_IRQ_DMA_COMPLETE 0x80 /* pending dma transfer complete IRQ */
+
+/* GF1_MIX_CTRL (port 2X0) */
+#define GF1M_MIXER_NO_LINE_IN 0x01 /* 0: enable */
+#define GF1M_MIXER_NO_OUTPUT 0x02 /* 0: enable */
+#define GF1M_MIXER_MIC_IN 0x04 /* 1: enable */
+#define GF1M_MIXER_GF1_IRQ 0x08 /* 1: enable */
+#define GF1M_GF1_COMBINED_IRQ 0x10 /* 1: IRQ1 == IRQ2 */
+#define GF1M_MIDI_LOOPBACK 0x20 /* 1: enable loop back */
+#define GF1M_CONTROL_SELECT 0x40 /* 0: DMA latches; 1: IRQ latches */
+
+/* Timer data register (2X9) */
+#define GF1M_START_TIMER1 0x01
+#define GF1M_START_TIMER2 0x02
+#define GF1M_MASK_TIMER1 0x20
+#define GF1M_MASK_TIMER2 0x40
+#define GF1M_TIMER_CLRIRQ 0x80
+
+/* IRQ/DMA control register (2XB) */
+#define GF1M_IRQ_EQUAL 0x40
+#define GF1M_DMA_EQUAL 0x40
+
+/* (0x41) DMA control register bits */
+#define GF1M_DMAR_ENABLE 0x01 /* 1: go */
+#define GF1M_DMAR_READ 0x02 /* 1: read (->RAM), 0: write (->DRAM) */
+#define GF1M_DMAR_CHAN16 0x04 /* 1: 16 bit, 0: 8 bit DMA channel */
+#define GF1M_DMAR_RATE 0x18 /* 00: fast, 11: slow */
+#define GF1M_DMAR_IRQ_ENABLE 0x20 /* 1: enable */
+#define GF1M_DMAR_IRQ_PENDING 0x40 /* R: DMA irq pending */
+#define GF1M_DMAR_DATA16 0x40 /* W: 0: 8 bits; 1: 16 bits per sample */
+#define GF1M_DMAR_TOGGLE_SIGN 0x80 /* W: 1: invert high bit */
+
+/* DMA transfer rate divisors */
+#define GF1M_DMAR_RATE0 0x00 /* Fastest DMA xfer (~650khz) */
+#define GF1M_DMAR_RATE1 0x08 /* fastest / 2 */
+#define GF1M_DMAR_RATE2 0x10 /* fastest / 4 */
+#define GF1M_DMAR_RATE3 0x18 /* Slowest DMA xfer (fastest / 8) */
+
+/* (0x45) Timer Control */
+#define GF1M_TIMER1 0x04 /* Enable timer 1 IRQ */
+#define GF1M_TIMER2 0x08 /* Enable timer 2 IRQ */
+
+/* (0x49) Sampling (ADC) control register */
+#define GF1M_DMAW_ENABLE 0x01 /* 1: Start sampling */
+#define GF1M_DMAW_MODE 0x02 /* 0: mono, 1: stereo */
+#define GF1M_DMAW_CHAN16 0x04 /* 0: 8 bit, 1: 16 bit */
+#define GF1M_DMAW_IRQ_ENABLE 0x20 /* 1: enable IRQ */
+#define GF1M_DMAW_IRQ_PENDING 0x40 /* 1: irq pending */
+#define GF1M_DMAW_TOGGLE_SIGN 0x80 /* 1: invert sign bit */
+
+/* (0x4C) GF1 reset register */
+#define GF1M_MASTER_RESET 0x01 /* 0: hold in reset */
+#define GF1M_OUTPUT_ENABLE 0x02 /* 1: enable output */
+#define GF1M_MASTER_IRQ 0x04 /* 1: master IRQ enable */
+
+/* (0x0,0x80) Voice control register - GF1R_VOICE_CONTROL */
+#define GF1VC_STOPPED 0x01 /* 1: voice has stopped */
+#define GF1VC_STOP 0x02 /* 1: stop voice */
+#define GF1VC_DATA16 0x04 /* 0: 8 bit, 1: 16 bit */
+#define GF1VC_LOOP_ENABLE 0x08 /* 1: enable */
+#define GF1VC_BI_LOOP 0x10 /* 1: bi directional looping */
+#define GF1VC_IRQ 0x20 /* 1: enable voice's wave irq */
+#define GF1VC_BACKWARD 0x40 /* 0: increasing, 1: decreasing */
+#define GF1VC_IRQ_PENDING 0x80 /* 1: wavetable irq pending */
+
+/* (0x01,0x81) Frequency control */
+/* Bit 0 - Unused */
+/* Bits 1-9 - Fractional portion */
+/* Bits 10-15 - Integer portion */
+
+/* (0x02,0x82) Accumulator start address - GF1R_START_HIGH */
+/* Bits 0-11 - HIGH 12 bits of address */
+/* Bits 12-15 - Unused */
+
+/* (0x03,0x83) Accumulator start address - GF1R_START_LOW */
+/* Bits 0-4 - Unused */
+/* Bits 5-8 - Fractional portion */
+/* Bits 9-15 - Low 7 bits of integer portion */
+
+/* (0x04,0x84) Accumulator end address - GF1R_END_HIGH */
+/* Bits 0-11 - HIGH 12 bits of address */
+/* Bits 12-15 - Unused */
+
+/* (0x05,0x85) Accumulator end address - GF1R_END_LOW */
+/* Bits 0-4 - Unused */
+/* Bits 5-8 - Fractional portion */
+/* Bits 9-15 - Low 7 bits of integer portion */
+
+/* (0x06,0x86) Volume Envelope control register - GF1R_VOLUME_RATE */
+#define GF1VL_RATE_MANTISSA 0x3f
+#define GF1VL_RATE_RANGE 0xC0
+
+/* (0x07,0x87) Volume envelope start - GF1R_VOLUME_START */
+#define GF1VL_START_MANT 0x0F
+#define GF1VL_START_EXP 0xF0
+
+/* (0x08,0x88) Volume envelope end - GF1R_VOLUME_END */
+#define GF1VL_END_MANT 0x0F
+#define GF1VL_END_EXP 0xF0
+
+/* (0x09,0x89) Current volume register - GF1R_VOLUME */
+/* Bits 0-3 - Unused */
+/* Bits 4-11 - Mantissa of current volume */
+/* Bits 10-15 - Exponent of current volume */
+
+/* (0x0A,0x8A) Accumulator value (high) */
+/* Bits 0-12 - HIGH 12 bits of current position (a19-a7) */
+
+/* (0x0B,0x8B) Accumulator value (low) */
+/* Bits 0-8 - Fractional portion */
+/* Bits 9-15 - Integer portion of low adress (a6-a0) */
+
+/* (0x0C,0x8C) Pan (balance) position */
+/* Bits 0-3 - Balance position 0=full left, 0x0f=full right */
+
+/* (0x0D,0x8D) Volume control register - GF1R_VOLUME_CONTROL */
+#define GF1VL_STOPPED 0x01 /* volume has stopped */
+#define GF1VL_STOP 0x02 /* stop volume */
+#define GF1VL_ROLLOVER 0x04 /* Roll PAST end & gen IRQ */
+#define GF1VL_LOOP_ENABLE 0x08 /* 1: enable */
+#define GF1VL_BI_LOOP 0x10 /* 1: bi directional looping */
+#define GF1VL_IRQ 0x20 /* 1: enable voice's volume irq */
+#define GF1VL_BACKWARD 0x40 /* 0: increasing, 1: decreasing */
+#define GF1VL_IRQ_PENDING 0x80 /* 1: wavetable irq pending */
+
+/* (0x0E,0x8E) Number of active voices */
+/* Bits 0-5 - Number of active voices - 1 */
+
+/* (0x0F,0x8F) Sources of IRQs */
+/* Bits 0-4 - interrupting voice number */
+/* Bit 5 - Always a 1 */
+#define GF1IRQ_VOLUME 0x40 /* individual voice irq bit */
+#define GF1IRQ_WAVE 0x80 /* individual waveform irq bit */
+
+/* Commands are pooled and executed ON TIMER (1st timer) interrupt.
+ * Currently there is a limit on the number of commands that you can
+ * issue between gus_do_flush (...); this should not be an issue however
+ * because each voice has a limited (little) set of parameters that
+ * you can change (freq, vol, pan... what else?)
+ *
+ * The pool is a pseudo-CPU code that gets executed once per timer interrupt.
+ */
+
+/* Below are definitions for commands placed in GUS command pool */
+#define PCMD_NOP 0x00 /* Traditionally ... */
+#define PCMD_VOICE 0x01 /* +B: select voice */
+#define PCMD_START 0x02 /* +L: start voice */
+#define PCMD_STOP 0x03 /* stop voice */
+#define PCMD_FREQ 0x04 /* +W: set frequence */
+#define PCMD_VOLUME 0x05 /* +W: set volume */
+#define PCMD_VOLUME_PREPARE 0x06 /* +W: prepare to set volume on (soon to follow) kick */
+#define PCMD_PAN 0x07 /* +B: set panning */
+#define PCMD_OFFSET 0x08 /* +L: set DRAM offset */
+#define PCMD_STOP_LOOP 0x09 /* stop looping */
+
+#define GUS_VOLCHANGE_RAMP 0x20 /* Volume change ramp speed */
+
+/* Definition for the boolean type */
+typedef unsigned char boolean;
+/* Prototype for functions that do block transfers to GUS DRAM:
+ flags can contain any of the following bits:
+ GUS_WAVE_16BIT - sample is 16-bit
+ GUS_WAVE_UNSIGNED - do not invert sign bit while downloading
+ */
+typedef void (*__gus_transfer_func) (unsigned long address,
+ unsigned char *source,
+ unsigned long size, int flags);
+typedef void (*__gus_callback) ();
+typedef void (*__gus_callback_3) (unsigned int, unsigned int, unsigned int);
+
+/* Structure used to keep track of all on-board GUS memory */
+typedef struct __struct_gus_mcb {
+ struct __struct_gus_mcb *next; /* Next MCB in chain */
+ struct __struct_gus_mcb *prev; /* Previous MCB in chain */
+ unsigned int addr; /* GUS DRAM address */
+ unsigned int size; /* Memory block size */
+ int free; /* 1: block is free */
+} __gus_mcb;
+
+/* Structure defining overall GUS state/information */
+typedef struct __gus_state_s {
+ unsigned int port; /* Base I/O port (0x220, 0x240, ...) */
+ unsigned int irq[2]; /* GF1 IRQ and MIDI IRQ */
+ unsigned int dma[2]; /* Play / record DMA */
+ unsigned int ram; /* Memory size (K), i.e. 256, 1024 etc */
+ unsigned int version; /* GUS version (see GUS_CARD_VERSION_XXX in libgus.h */
+ unsigned int freq; /* Current mixing frequency */
+ unsigned int voices; /* Active voices (14-32) */
+ unsigned int dynmask; /* Dynamically allocated voices mask */
+ unsigned int timer_base; /* The relative timer speed in percents (def: 100) */
+ volatile unsigned int t1_ticks; /* Incremented per each timer1 tick */
+ volatile unsigned int t2_ticks; /* Incremented per each timer2 tick */
+ volatile unsigned int t1_countdown; /* t1_callback is called when this reaches zero */
+ volatile unsigned int t2_countdown; /* t2_callback is called when this reaches zero */
+ unsigned int t1_multiple; /* Timer1 handler is called once per such many ticks */
+ unsigned int t2_multiple; /* Timer2 handler is called once per such many ticks */
+ struct irq_handle *gf1_irq; /* The interrupt handler for GF1 events */
+ dma_buffer *dma_buff; /* Pre-allocated DMA buffer */
+ __gus_callback dma_callback; /* Routine called at end of DMA transfers */
+ __gus_callback t1_callback; /* Routine called on Timer1 events */
+ __gus_callback t2_callback; /* Routine called on Timer1 events */
+ __gus_callback timer_callback; /* Called once per TEMPO ticks */
+ __gus_callback_3 wt_callback; /* Routine called on WaveTable events */
+ __gus_callback_3 vl_callback; /* Routine called on Volume ramp events */
+ __gus_mcb *mcb; /* Chained list of memory control blocks */
+ __gus_transfer_func transfer; /* Best working function for DRAM transfer */
+ gus_instrument_t *instr; /* The list of registered instruments */
+ unsigned short mixer; /* Current mixer register state */
+ unsigned char dma_rate; /* One of GF1M_DMAR_RATEX constants defined above */
+ unsigned char timer_ctl; /* Timer control register value (2x8/2x9) */
+ unsigned char timer_ctl_reg; /* Timer control register value (GF1/0x45) */
+ boolean ok; /* Is the information below okay? */
+ boolean open; /* 1 if between gus_open() and gus_close() */
+ boolean ics; /* Is it equipped with an ICS mixer? */
+ boolean ics_flipped; /* rev 5 (3.7) has flipped R/L mixer */
+ boolean codec; /* Is it equipped with a GUS MAX codec? */
+ boolean interwave; /* GUS InterWave card */
+ volatile boolean dma_active; /* DMA is transferring data */
+ volatile boolean cmd_pool_ready; /* Flush cmd_pool during timer interrupt */
+ unsigned char cmd_voice; /* Pool selection index cache */
+ unsigned int cmd_pool_top; /* Command pool top */
+ unsigned char *cmd_pool; /* Async commands pool */
+ /* The following data is for private use only by interrupt routines! */
+ gus_wave_t *cur_wave[32]; /* Currently played waves */
+ boolean voice_kick[32]; /* Kick wave on next volume ramp IRQ */
+ unsigned int kick_offs[32]; /* Sample start position on kick */
+ unsigned short cur_vol[32]; /* Current voice volumes */
+ unsigned int cur_voice; /* Current voice */
+ unsigned int eow_ignore; /* Temp ignore end-of-wave IRQ for these voices */
+} __gus_state;
+
+extern __gus_state gus;
+extern void __gus_delay();
+
+static unsigned long __gus_convert_addr16(unsigned long address)
+{
+ return ((address & 0x0003ffff) >> 1) | (address & ~0x0003ffff);
+}
+
+/* The XXX_slow routines cannot be used outside IRQ handler! */
+static inline void __gus_outregb_slow(unsigned char reg, unsigned char value)
+{
+ outportb(GF1_REGSEL, reg);
+ outportb(GF1_DATA_HIGH, value);
+ __gus_delay();
+ outportb(GF1_DATA_HIGH, value);
+}
+
+static inline void __gus_outregw_slow(unsigned char reg, unsigned short value)
+{
+ outportb(GF1_REGSEL, reg);
+ outportw(GF1_DATA, value);
+ __gus_delay();
+ outportw(GF1_DATA, value);
+}
+
+static inline void __gus_outregb(unsigned char reg, unsigned char value)
+{
+ outportb(GF1_REGSEL, reg);
+ outportb(GF1_DATA_HIGH, value);
+}
+
+static inline void __gus_outregw(unsigned char reg, unsigned short value)
+{
+ outportb(GF1_REGSEL, reg);
+ outportw(GF1_DATA, value);
+}
+
+static inline unsigned char __gus_inregb(unsigned char reg)
+{
+ if (reg < 0x10)
+ reg |= GF1R_READ_MASK;
+ outportb(GF1_REGSEL, reg);
+ return inportb(GF1_DATA_HIGH);
+}
+
+static inline unsigned short __gus_inregw(unsigned char reg)
+{
+ if (reg < 0x10)
+ reg |= GF1R_READ_MASK;
+ outportb(GF1_REGSEL, reg);
+ return inportw(GF1_DATA);
+}
+
+static inline void __gus_set_dram_address(unsigned int address)
+{
+ __gus_outregb(GF1R_DRAM_HIGH, address >> 16);
+ __gus_outregw(GF1R_DRAM_LOW, address);
+}
+
+static inline unsigned char __gus_peek(unsigned int address)
+{
+ __gus_set_dram_address(address);
+ return inportb(GF1_DRAM);
+}
+
+static inline void __gus_poke(unsigned int address, unsigned char value)
+{
+ __gus_set_dram_address(address);
+ outportb(GF1_DRAM, value);
+}
+
+static inline void __gus_select_voice(unsigned char voice)
+{
+ outportb(GF1_VOICESEL, voice);
+}
+
+static inline void __gus_set_current(unsigned char mode,
+ unsigned long address)
+{
+ if (mode & GF1VC_DATA16)
+ address = __gus_convert_addr16(address);
+ __gus_outregw_slow(GF1R_ACC_HIGH, address >> 11);
+ __gus_outregw_slow(GF1R_ACC_LOW, address << 5);
+}
+
+static inline void __gus_set_loop_start(unsigned char mode,
+ unsigned long address)
+{
+ if (mode & GF1VC_DATA16)
+ address = __gus_convert_addr16(address);
+ __gus_outregw_slow(GF1R_START_HIGH, address >> 11);
+ __gus_outregw_slow(GF1R_START_LOW, address << 5);
+}
+
+static inline void __gus_set_loop_end(unsigned char mode,
+ unsigned long address)
+{
+ address--;
+ if (mode & GF1VC_DATA16)
+ address = __gus_convert_addr16(address);
+ __gus_outregw_slow(GF1R_END_HIGH, address >> 11);
+ __gus_outregw_slow(GF1R_END_LOW, address << 5);
+}
+
+static inline void __gus_mixer_output(boolean state)
+{
+ if (state)
+ gus.mixer &= ~GF1M_MIXER_NO_OUTPUT;
+ else
+ gus.mixer |= GF1M_MIXER_NO_OUTPUT;
+ outportb(GF1_MIX_CTRL, gus.mixer);
+ /* Dummy read to avoid touching DMA latches */
+ __gus_inregb(GF1R_BALANCE);
+}
+
+/* Inline routines for working with command pools */
+
+/* WARNING: no bounds checking due to performance reasons */
+#define __POOL_VALUE(type,value) \
+ *((unsigned type *)&gus.cmd_pool [gus.cmd_pool_top]) = value; \
+ gus.cmd_pool_top += sizeof (type);
+
+static inline void __pool_command(unsigned char command)
+{
+ __POOL_VALUE(char, command);
+}
+
+static inline void __pool_command_b(unsigned char command, unsigned char arg)
+{
+ __POOL_VALUE(char, command);
+ __POOL_VALUE(char, arg);
+}
+
+static inline void __pool_command_w(unsigned char command, unsigned short arg)
+{
+ __POOL_VALUE(char, command);
+ __POOL_VALUE(short, arg);
+}
+
+static inline void __pool_command_l(unsigned char command, unsigned long arg)
+{
+ __POOL_VALUE(char, command);
+ __POOL_VALUE(long, arg);
+}
+
+static inline void __pool_select_voice(unsigned char voice)
+{
+ if (gus.cmd_voice != voice)
+ __pool_command_b(PCMD_VOICE, gus.cmd_voice = voice);
+}
+
+#undef __POOL_VALUE
+
+#ifdef DEBUG
+/* Debug dump of GUS DRAM heap */
+extern void __gus_mem_dump();
+#endif
+
+#endif /* __DOSGUS_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/*
+ Implementation of IRQ routines on DOS
+ Copyright (C) 1999 by Andrew Zabolotny, <bit@eltech.ru>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "dosirq.h"
+
+#include <dpmi.h>
+#include <go32.h>
+#include <dos.h>
+#include <sys/nearptr.h>
+#include <malloc.h>
+#include <string.h>
+#include "mikmod.h" /* for MikMod_malloc() & co */
+
+unsigned int __irq_stack_size = 0x4000;
+unsigned int __irq_stack_count = 1;
+
+static void __int_stub_template (void)
+{
+/* *INDENT-OFF* */
+ asm(" pushal\n"
+ " pushl %ds\n"
+ " pushl %es\n"
+ " pushl %fs\n"
+ " pushl %gs\n"
+ " movw $0x1234,%ax\n" /* Get DPMI data selector */
+ " movw %ax,%ds\n" /* Set DS and ES to data selector */
+ " movw %ax,%es\n"
+ " movl $0x12345678,%ebx\n" /* Interrupt stack top */
+ " movl (%ebx),%ecx\n"
+ " movl %ecx,%edx\n"
+ " subl $0x12345678,%ecx\n" /* Subtract irq_stack_count */
+ " movl %ecx,(%ebx)\n"
+ " movw %ss,%si\n" /* Save old SS:ESP */
+ " movl %esp,%edi\n"
+ " movl %edx,%esp\n" /* Set SS:ESP to interrupt stack */
+ " movw %ax,%ss\n"
+ " pushl %esi\n"
+ " pushl %edi\n"
+ " pushl %ebx\n"
+ " pushl %edx\n"
+ " call 1f\n" /* Call user interrupt handler */
+ "1: popl %edx\n"
+ " popl %ebx\n"
+ " movl %edx,(%ebx)\n"
+ " popl %edi\n"
+ " popl %esi\n"
+ " movl %edi,%esp\n" /* Restore old SS:ESP */
+ " movw %si,%ss\n"
+ " popl %gs\n"
+ " popl %fs\n"
+ " popl %es\n"
+ " popl %ds\n"
+ " popal\n"
+ " iret\n");
+/* *INDENT-ON* */
+}
+
+#include <stdio.h>
+
+static int _allocate_iret_wrapper(_go32_dpmi_seginfo * info)
+{
+ unsigned char *irqtpl = (unsigned char *)__int_stub_template;
+ unsigned char *irqend, *irqwrapper, *tmp;
+ __dpmi_meminfo handler_info;
+ unsigned int wrappersize;
+
+ /* First, skip until pushal */
+ while (*irqtpl != 0x60)
+ irqtpl++;
+ /* Now find the iret */
+ irqend = irqtpl;
+ while (*irqend++ != 0xcf);
+
+ wrappersize = 4 + __irq_stack_size * __irq_stack_count + 4 +
+ ((long)irqend - (long)irqtpl);
+ irqwrapper = (unsigned char *) MikMod_malloc(wrappersize);
+ /* Lock the wrapper */
+ handler_info.address = __djgpp_base_address + (unsigned long)irqwrapper;
+ handler_info.size = wrappersize;
+ if (__dpmi_lock_linear_region(&handler_info)) {
+ MikMod_free(irqwrapper);
+ return -1;
+ }
+
+ /* First comes the interrupt wrapper size */
+ *(unsigned long *)irqwrapper = wrappersize;
+
+ /* Next comes the interrupt stack */
+ tmp = irqwrapper + 4 + __irq_stack_size * __irq_stack_count;
+
+ /* The following dword is interrupt stack pointer */
+ *((void **)tmp) = tmp;
+ tmp += 4;
+
+ /* Now comes the interrupt wrapper itself */
+ memcpy(tmp, irqtpl, irqend - irqtpl);
+ *(unsigned short *)(tmp + 9) = _my_ds();
+ *(unsigned long *)(tmp + 16) = (unsigned long)tmp - 4;
+ *(unsigned long *)(tmp + 26) = __irq_stack_size;
+ *(unsigned long *)(tmp + 46) =
+ info->pm_offset - (unsigned long)(tmp + 50);
+
+ info->pm_offset = (unsigned long)tmp;
+ info->pm_selector = _my_cs();
+
+ return 0;
+}
+
+static void _free_iret_wrapper(_go32_dpmi_seginfo * info)
+{
+ __dpmi_meminfo handler_info;
+
+ info->pm_offset -= 4 + __irq_stack_size * __irq_stack_count + 4;
+
+ handler_info.address = __djgpp_base_address + info->pm_offset;
+ handler_info.size = *(unsigned long *)info->pm_offset;
+ __dpmi_unlock_linear_region(&handler_info);
+
+ MikMod_free((void *)info->pm_offset);
+}
+
+struct irq_handle *irq_hook(int irqno, void (*handler)(), unsigned long size)
+{
+ int interrupt;
+ struct irq_handle *irq;
+ __dpmi_version_ret version;
+ __dpmi_meminfo handler_info, struct_info;
+ _go32_dpmi_seginfo info;
+ unsigned long old_sel, old_ofs;
+
+ __dpmi_get_version(&version);
+ if (irqno < 8)
+ interrupt = version.master_pic + irqno;
+ else
+ interrupt = version.slave_pic + (irqno - 8);
+
+ if (_go32_dpmi_get_protected_mode_interrupt_vector(interrupt, &info))
+ return NULL;
+
+ old_sel = info.pm_selector;
+ old_ofs = info.pm_offset;
+
+ info.pm_offset = (unsigned long)handler;
+ if (_allocate_iret_wrapper(&info))
+ return NULL;
+
+ /* Lock the interrupt handler in memory */
+ handler_info.address = __djgpp_base_address + (unsigned long)handler;
+ handler_info.size = size;
+ if (__dpmi_lock_linear_region(&handler_info)) {
+ _free_iret_wrapper(&info);
+ return NULL;
+ }
+
+ irq = (struct irq_handle *) MikMod_malloc(sizeof(struct irq_handle));
+ irq->c_handler = handler;
+ irq->handler_size = size;
+ irq->handler = info.pm_offset;
+ irq->prev_selector = old_sel;
+ irq->prev_offset = old_ofs;
+ irq->int_num = interrupt;
+ irq->irq_num = irqno;
+ irq->pic_base = irqno < 8 ? PIC1_BASE : PIC2_BASE;
+
+ struct_info.address = __djgpp_base_address + (unsigned long)irq;
+ struct_info.size = sizeof(struct irq_handle);
+ if (__dpmi_lock_linear_region(&struct_info)) {
+ MikMod_free(irq);
+ __dpmi_unlock_linear_region(&handler_info);
+ _free_iret_wrapper(&info);
+ return NULL;
+ }
+
+ _go32_dpmi_set_protected_mode_interrupt_vector(interrupt, &info);
+
+ irq->pic_mask = irq_state(irq);
+ return irq;
+}
+
+void irq_unhook(struct irq_handle *irq)
+{
+ _go32_dpmi_seginfo info;
+ __dpmi_meminfo mem_info;
+
+ if (!irq)
+ return;
+
+ /* Restore the interrupt vector */
+ irq_disable(irq);
+ info.pm_offset = irq->prev_offset;
+ info.pm_selector = irq->prev_selector;
+ _go32_dpmi_set_protected_mode_interrupt_vector(irq->int_num, &info);
+
+ /* Unlock the interrupt handler */
+ mem_info.address = __djgpp_base_address + (unsigned long)irq->c_handler;
+ mem_info.size = irq->handler_size;
+ __dpmi_unlock_linear_region(&mem_info);
+
+ /* Unlock the irq_handle structure */
+ mem_info.address = __djgpp_base_address + (unsigned long)irq;
+ mem_info.size = sizeof(struct irq_handle);
+ __dpmi_unlock_linear_region(&mem_info);
+
+ info.pm_offset = irq->handler;
+ _free_iret_wrapper(&info);
+
+ /* If IRQ was enabled before we hooked, restore enabled state */
+ if (irq->pic_mask)
+ irq_enable(irq);
+ else
+ irq_disable(irq);
+
+ MikMod_free(irq);
+}
+
+/*---------------------------------------------- IRQ detection mechanism -----*/
+static struct irq_handle *__irqs[16];
+static int (*__irq_confirm) (int irqno);
+static volatile unsigned int __irq_mask;
+static volatile unsigned int __irq_count[16];
+
+#define DECLARE_IRQ_HANDLER(irqno) \
+static void __irq##irqno##_handler () \
+{ \
+ if (irq_check (__irqs [irqno]) && __irq_confirm (irqno)) \
+ { \
+ __irq_count [irqno]++; \
+ __irq_mask |= (1 << irqno); \
+ } \
+ irq_ack (__irqs [irqno]); \
+}
+
+/* *INDENT-OFF* */
+DECLARE_IRQ_HANDLER(0)
+DECLARE_IRQ_HANDLER(1)
+DECLARE_IRQ_HANDLER(2)
+DECLARE_IRQ_HANDLER(3)
+DECLARE_IRQ_HANDLER(4)
+DECLARE_IRQ_HANDLER(5)
+DECLARE_IRQ_HANDLER(6)
+DECLARE_IRQ_HANDLER(7)
+DECLARE_IRQ_HANDLER(8)
+DECLARE_IRQ_HANDLER(9)
+DECLARE_IRQ_HANDLER(10)
+DECLARE_IRQ_HANDLER(11)
+DECLARE_IRQ_HANDLER(12)
+DECLARE_IRQ_HANDLER(13)
+DECLARE_IRQ_HANDLER(14)
+DECLARE_IRQ_HANDLER(15)
+/* *INDENT-ON* */
+
+static void (*__irq_handlers[16]) () = {
+ __irq0_handler, __irq1_handler, __irq2_handler, __irq3_handler,
+ __irq4_handler, __irq5_handler, __irq6_handler, __irq7_handler,
+ __irq8_handler, __irq9_handler, __irq10_handler, __irq11_handler,
+ __irq12_handler, __irq13_handler, __irq14_handler, __irq15_handler};
+
+void irq_detect_start(unsigned int irqs, int (*irq_confirm) (int irqno))
+{
+ int i;
+
+ __irq_mask = 0;
+ __irq_confirm = irq_confirm;
+ memset(&__irqs, 0, sizeof(__irqs));
+ memset((void *) &__irq_count, 0, sizeof(__irq_count));
+
+ /* Hook all specified IRQs */
+ for (i = 1; i <= 15; i++)
+ if (irqs & (1 << i)) {
+ __irqs[i] = irq_hook(i, __irq_handlers[i], 200);
+ /* Enable the interrupt */
+ irq_enable(__irqs[i]);
+ }
+ /* Enable IRQ2 if we need at least one IRQ above 7 */
+ if (irqs & 0xff00)
+ _irq_enable(2);
+}
+
+void irq_detect_end()
+{
+ int i;
+ for (i = 15; i >= 1; i--)
+ if (__irqs[i])
+ irq_unhook(__irqs[i]);
+}
+
+int irq_detect_get(int irqno, unsigned int *irqmask)
+{
+ int oldirq = disable();
+ int count = __irq_count[irqno];
+ *irqmask = __irq_mask;
+ __irq_mask = 0;
+ if (oldirq)
+ enable();
+ return count;
+}
+
+void irq_detect_clear()
+{
+ int oldirq = disable();
+ memset((void *) &__irq_count, 0, sizeof(__irq_count));
+ __irq_mask = 0;
+ if (oldirq)
+ enable();
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/*
+ Interface for IRQ routines on DOS
+ Copyright (C) 1999 by Andrew Zabolotny, <bit@eltech.ru>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __DOSIRQ_H__
+#define __DOSIRQ_H__
+
+#include <pc.h>
+
+#define PIC1_BASE 0x20 /* PIC1 base */
+#define PIC2_BASE 0xA0 /* PIC2 base */
+
+struct irq_handle {
+ void (*c_handler) (); /* The real interrupt handler */
+ unsigned long handler_size; /* The size of interrupt handler */
+ unsigned long handler; /* Interrupt wrapper address */
+ unsigned long prev_selector; /* Selector of previous handler */
+ unsigned long prev_offset; /* Offset of previous handler */
+ unsigned char irq_num; /* IRQ number */
+ unsigned char int_num; /* Interrupt number */
+ unsigned char pic_base; /* PIC base (0x20 or 0xA0) */
+ unsigned char pic_mask; /* Old PIC mask state */
+};
+
+/* Return the enabled state for specific IRQ */
+static inline unsigned char irq_state(struct irq_handle * irq)
+{
+ return ((~inportb(irq->pic_base + 1)) & (0x01 << (irq->irq_num & 7)));
+}
+
+/* Acknowledge the end of interrupt */
+static inline void _irq_ack(int irqno)
+{
+ outportb(irqno > 7 ? PIC2_BASE : PIC1_BASE, 0x60 | (irqno & 7));
+ /* For second controller we also should acknowledge first controller */
+ if (irqno > 7)
+ outportb(PIC1_BASE, 0x20); /* 0x20, 0x62? */
+}
+
+/* Acknowledge the end of interrupt */
+static inline void irq_ack(struct irq_handle * irq)
+{
+ outportb(irq->pic_base, 0x60 | (irq->irq_num & 7));
+ /* For second controller we also should acknowledge first controller */
+ if (irq->pic_base != PIC1_BASE)
+ outportb(PIC1_BASE, 0x20); /* 0x20, 0x62? */
+}
+
+/* Mask (disable) the particular IRQ given his ordinal */
+static inline void _irq_disable(int irqno)
+{
+ unsigned int port_no = (irqno < 8 ? PIC1_BASE : PIC2_BASE) + 1;
+ outportb(port_no, inportb(port_no) | (1 << (irqno & 7)));
+}
+
+/* Unmask (enable) the particular IRQ given its ordinal */
+static inline void _irq_enable(int irqno)
+{
+ unsigned int port_no = (irqno < 8 ? PIC1_BASE : PIC2_BASE) + 1;
+ outportb(port_no, inportb(port_no) & ~(1 << (irqno & 7)));
+}
+
+/* Mask (disable) the particular IRQ given its irq_handle structure */
+static inline void irq_disable(struct irq_handle * irq)
+{
+ outportb(irq->pic_base + 1,
+ inportb(irq->pic_base + 1) | (1 << (irq->irq_num & 7)));
+}
+
+/* Unmask (enable) the particular IRQ given its irq_handle structure */
+static inline void irq_enable(struct irq_handle * irq)
+{
+ outportb(irq->pic_base + 1,
+ inportb(irq->pic_base + 1) & ~(1 << (irq->irq_num & 7)));
+}
+
+/* Check if a specific IRQ is pending: return 0 is no */
+static inline int irq_check(struct irq_handle * irq)
+{
+ outportb(irq->pic_base, 0x0B); /* Read IRR vector */
+ return (inportb(irq->pic_base) & (1 << (irq->irq_num & 7)));
+}
+
+/* Hook a specific IRQ; NOTE: IRQ is disabled upon return, irq_enable() it */
+extern struct irq_handle *irq_hook(int irqno, void (*handler)(),
+ unsigned long size);
+/* Unhook a previously hooked IRQ */
+extern void irq_unhook(struct irq_handle * irq);
+/* Start IRQ detection process (IRQ list is given with irq mask) */
+/* irq_confirm should return "1" if the IRQ really comes from the device */
+extern void irq_detect_start(unsigned int irqs,
+ int (*irq_confirm) (int irqno));
+/* Finish IRQ detection process */
+extern void irq_detect_end();
+/* Get the count of specific irqno that happened */
+extern int irq_detect_get(int irqno, unsigned int *irqmask);
+/* Clear IRQ counters */
+extern void irq_detect_clear();
+
+/* The size of interrupt stack */
+extern unsigned int __irq_stack_size;
+/* The number of nested interrupts that can be handled */
+extern unsigned int __irq_stack_count;
+
+#endif /* __DOSIRQ_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ Sound Blaster I/O routines, common for SB8, SBPro and SB16
+ Written by Andrew Zabolotny <bit@eltech.ru>
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DRV_SB
+
+#include <stdlib.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <dos.h>
+#include <sys/nearptr.h>
+#include <sys/farptr.h>
+#include <string.h>
+
+#include "dossb.h"
+
+/********************************************* Private variables/routines *****/
+
+__sb_state sb;
+
+/* Wait for SoundBlaster for some time */
+#if !defined(__GNUC__) || (__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ == 0)
+# define _func_noinline volatile /* match original code */
+# define _func_noclone
+#else
+/* avoid warnings from newer gcc:
+ * "function definition has qualified void return type" and
+ * function return types not compatible due to 'volatile' */
+# define _func_noinline __attribute__((__noinline__))
+# if (__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define _func_noclone
+# else
+# define _func_noclone __attribute__((__noclone__))
+# endif
+#endif
+_func_noinline
+_func_noclone
+ void __sb_wait()
+{
+ inportb(SB_DSP_RESET);
+ inportb(SB_DSP_RESET);
+ inportb(SB_DSP_RESET);
+ inportb(SB_DSP_RESET);
+ inportb(SB_DSP_RESET);
+ inportb(SB_DSP_RESET);
+}
+
+static void sb_irq()
+{
+ /* Make sure its not a spurious IRQ */
+ if (!irq_check(sb.irq_handle))
+ return;
+
+ sb.irqcount++;
+
+ /* Acknowledge DMA transfer is complete */
+ if (sb.mode & SBMODE_16BITS)
+ __sb_dsp_ack_dma16();
+ else
+ __sb_dsp_ack_dma8();
+
+ /* SoundBlaster 1.x cannot do autoinit ... */
+ if (sb.dspver < SBVER_20)
+ __sb_dspreg_outwlh(SBDSP_DMA_PCM8, (sb.dma_buff->size >> 1) - 1);
+
+ /* Send EOI */
+ irq_ack(sb.irq_handle);
+
+ enable();
+ if (sb.timer_callback)
+ sb.timer_callback();
+}
+
+static void sb_irq_end()
+{
+}
+
+static boolean __sb_reset()
+{
+ /* Disable the output */
+ sb_output(FALSE);
+
+ /* Clear pending ints if any */
+ __sb_dsp_ack_dma8();
+ __sb_dsp_ack_dma16();
+
+ /* Reset the DSP */
+ outportb(SB_DSP_RESET, SBM_DSP_RESET);
+ __sb_wait();
+ __sb_wait();
+ outportb(SB_DSP_RESET, 0);
+
+ /* Now wait for AA coming from datain port */
+ if (__sb_dsp_in() != 0xaa)
+ return FALSE;
+
+ /* Finally, get the DSP version */
+ if ((sb.dspver = __sb_dsp_version()) == 0xffff)
+ return FALSE;
+ /* Check again */
+ if (sb.dspver != __sb_dsp_version())
+ return FALSE;
+
+ return TRUE;
+}
+
+/***************************************************** SB detection stuff *****/
+
+static int __sb_irq_irqdetect(int irqno)
+{
+ __sb_dsp_ack_dma8();
+ return 1;
+}
+
+static void __sb_irq_dmadetect()
+{
+ /* Make sure its not a spurious IRQ */
+ if (!irq_check(sb.irq_handle))
+ return;
+
+ sb.irqcount++;
+
+ /* Acknowledge DMA transfer is complete */
+ if (sb.mode & SBMODE_16BITS)
+ __sb_dsp_ack_dma16();
+ else
+ __sb_dsp_ack_dma8();
+
+ /* Send EOI */
+ irq_ack(sb.irq_handle);
+}
+
+static boolean __sb_detect()
+{
+ /* First find the port number */
+ if (!sb.port) {
+ int i;
+ for (i = 5; i >= 0; i--) {
+ sb.port = 0x210 + i * 0x10;
+ if (__sb_reset())
+ break;
+ }
+ if (i < 0) {
+ sb.port = 0;
+ return FALSE;
+ }
+ }
+
+ /* Now detect the IRQ and DMA numbers */
+ if (!sb.irq) {
+ unsigned int irqmask, sbirqmask, sbirqcount;
+ unsigned long timer;
+
+ /* IRQ can be one of 2,3,5,7,10 */
+ irq_detect_start(0x04ac, __sb_irq_irqdetect);
+
+ /* Prepare timeout counter */
+ _farsetsel(_dos_ds);
+ timer = _farnspeekl(0x46c);
+
+ sbirqmask = 0;
+ sbirqcount = 10; /* Emit 10 SB irqs */
+
+ /* Tell SoundBlaster to emit IRQ for 8-bit transfers */
+ __sb_dsp_out(SBDSP_GEN_IRQ8);
+ __sb_wait();
+ for (;;) {
+ irq_detect_get(0, &irqmask);
+ if (irqmask) {
+ sbirqmask |= irqmask;
+ if (!--sbirqcount)
+ break;
+ __sb_dsp_out(SBDSP_GEN_IRQ8);
+ }
+ if (_farnspeekl(0x46c) - timer >= 9) /* Wait ~1/2 secs */
+ break;
+ }
+ if (sbirqmask)
+ for (sb.irq = 15; sb.irq > 0; sb.irq--)
+ if (irq_detect_get(sb.irq, &irqmask) == 10)
+ break;
+
+ irq_detect_end();
+ if (!sb.irq)
+ return FALSE;
+ }
+
+ /* Detect the 8-bit and 16-bit DMAs */
+ if (!sb.dma8 || ((sb.dspver >= SBVER_16) && !sb.dma16)) {
+ static int __dma8[] = { 0, 1, 3 };
+ static int __dma16[] = { 5, 6, 7 };
+ int *dma;
+
+ sb_output(FALSE);
+ /* Temporary hook SB IRQ */
+ sb.irq_handle = irq_hook(sb.irq, __sb_irq_dmadetect, 200);
+ irq_enable(sb.irq_handle);
+ if (sb.irq > 7)
+ _irq_enable(2);
+
+ /* Start a short DMA transfer and check if IRQ happened */
+ for (;;) {
+ int i;
+ unsigned int timer, oldcount;
+
+ if (!sb.dma8)
+ dma = &sb.dma8;
+ else if ((sb.dspver >= SBVER_16) && !sb.dma16)
+ dma = &sb.dma16;
+ else
+ break;
+
+ for (i = 0; i < 3; i++) {
+ boolean success = 1;
+
+ *dma = (dma == &sb.dma8) ? __dma8[i] : __dma16[i];
+ oldcount = sb.irqcount;
+
+ dma_disable(*dma);
+ dma_set_mode(*dma, DMA_MODE_WRITE);
+ dma_clear_ff(*dma);
+ dma_set_count(*dma, 2);
+ dma_enable(*dma);
+
+ __sb_dspreg_out(SBDSP_SET_TIMING, 206); /* 20KHz */
+ if (dma == &sb.dma8) {
+ sb.mode = 0;
+ __sb_dspreg_outwlh(SBDSP_DMA_PCM8, 1);
+ } else {
+ sb.mode = SBMODE_16BITS;
+ __sb_dspreg_out(SBDSP_DMA_GENERIC16, 0);
+ __sb_dsp_out(0);
+ __sb_dsp_out(1);
+ }
+
+ _farsetsel(_dos_ds);
+ timer = _farnspeekl(0x46c);
+
+ while (oldcount == sb.irqcount)
+ if (_farnspeekl(0x46c) - timer >= 2) {
+ success = 0;
+ break;
+ }
+ dma_disable(*dma);
+ if (success)
+ break;
+ *dma = 0;
+ }
+ if (!*dma)
+ break;
+ }
+
+ irq_unhook(sb.irq_handle);
+ sb.irq_handle = NULL;
+ if (!sb.dma8 || ((sb.dspver >= SBVER_16) && !sb.dma16))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/*************************************************** High-level interface *****/
+
+/* Detect whenever SoundBlaster is present and fill "sb" structure */
+boolean sb_detect()
+{
+ char *env;
+
+ /* Try to find the port and DMA from environment */
+ env = getenv("BLASTER");
+
+ while (env && *env) {
+ /* Skip whitespace */
+ while ((*env == ' ') || (*env == '\t'))
+ env++;
+ if (!*env)
+ break;
+
+ switch (*env++) {
+ case 'A':
+ case 'a':
+ if (!sb.port)
+ sb.port = strtol(env, &env, 16);
+ break;
+ case 'E':
+ case 'e':
+ if (!sb.aweport)
+ sb.aweport = strtol(env, &env, 16);
+ break;
+ case 'I':
+ case 'i':
+ if (!sb.irq)
+ sb.irq = strtol(env, &env, 10);
+ break;
+ case 'D':
+ case 'd':
+ if (!sb.dma8)
+ sb.dma8 = strtol(env, &env, 10);
+ break;
+ case 'H':
+ case 'h':
+ if (!sb.dma16)
+ sb.dma16 = strtol(env, &env, 10);
+ break;
+ default:
+ /* Skip other values (H == MIDI, T == model, any other?) */
+ while (*env && (*env != ' ') && (*env != '\t'))
+ env++;
+ break;
+ }
+ }
+
+ /* Try to detect missing sound card parameters */
+ __sb_detect();
+
+ if (!sb.port || !sb.irq || !sb.dma8)
+ return FALSE;
+
+ if (!__sb_reset())
+ return FALSE;
+
+ if ((sb.dspver >= SBVER_16) && !sb.dma16)
+ return FALSE;
+
+ if (sb.dspver >= SBVER_PRO)
+ sb.caps |= SBMODE_STEREO;
+ if (sb.dspver >= SBVER_16 && sb.dma16)
+ sb.caps |= SBMODE_16BITS;
+ if (sb.dspver < SBVER_20)
+ sb.maxfreq_mono = 22222;
+ else
+ sb.maxfreq_mono = 45454;
+ if (sb.dspver <= SBVER_16)
+ sb.maxfreq_stereo = 22727;
+ else
+ sb.maxfreq_stereo = 45454;
+
+ sb.ok = 1;
+ return TRUE;
+}
+
+/* Reset SoundBlaster */
+void sb_reset()
+{
+ sb_stop_dma();
+ __sb_reset();
+}
+
+/* Start working with SoundBlaster */
+boolean sb_open()
+{
+ __dpmi_meminfo struct_info;
+
+ if (!sb.ok)
+ if (!sb_detect())
+ return FALSE;
+
+ if (sb.open)
+ return FALSE;
+
+ /* Now lock the sb structure in memory */
+ struct_info.address = __djgpp_base_address + (unsigned long)&sb;
+ struct_info.size = sizeof(sb);
+ if (__dpmi_lock_linear_region(&struct_info))
+ return FALSE;
+
+ /* Hook the SB IRQ */
+ sb.irq_handle = irq_hook(sb.irq, sb_irq, (long)sb_irq_end - (long)sb_irq);
+ if (!sb.irq_handle) {
+ __dpmi_unlock_linear_region(&struct_info);
+ return FALSE;
+ }
+
+ /* Enable the interrupt */
+ irq_enable(sb.irq_handle);
+ if (sb.irq > 7)
+ _irq_enable(2);
+
+ sb.open++;
+
+ return TRUE;
+}
+
+/* Finish working with SoundBlaster */
+boolean sb_close()
+{
+ __dpmi_meminfo struct_info;
+ if (!sb.open)
+ return FALSE;
+
+ sb.open--;
+
+ /* Stop/free DMA buffer */
+ sb_stop_dma();
+
+ /* Unhook IRQ */
+ irq_unhook(sb.irq_handle);
+ sb.irq_handle = NULL;
+
+ /* Unlock the sb structure */
+ struct_info.address = __djgpp_base_address + (unsigned long)&sb;
+ struct_info.size = sizeof(sb);
+ __dpmi_unlock_linear_region(&struct_info);
+
+ return TRUE;
+}
+
+/* Enable/disable stereo DSP mode */
+/* Enable/disable speaker output */
+void sb_output(boolean enable)
+{
+ __sb_dsp_out(enable ? SBDSP_SPEAKER_ENA : SBDSP_SPEAKER_DIS);
+}
+
+/* Start playing from DMA buffer */
+boolean sb_start_dma(unsigned char mode, unsigned int freq)
+{
+ int dmachannel = (mode & SBMODE_16BITS) ? sb.dma16 : sb.dma8;
+ int dmabuffsize;
+ unsigned int tc = 0; /* timing constant (<=sbpro only) */
+
+ /* Stop DMA transfer if it is enabled */
+ sb_stop_dma();
+
+ /* Sanity check */
+ if ((mode & SBMODE_MASK & sb.caps) != (mode & SBMODE_MASK))
+ return FALSE;
+
+ /* Check this SB can perform at requested frequency */
+ if (((mode & SBMODE_STEREO) && (freq > sb.maxfreq_stereo))
+ || (!(mode & SBMODE_STEREO) && (freq > sb.maxfreq_mono)))
+ return FALSE;
+
+ /* Check the timing constant here to avoid failing later */
+ if (sb.dspver < SBVER_16) {
+ /* SBpro cannot do signed transfer */
+ if (mode & SBMODE_SIGNED)
+ return FALSE;
+
+ /* Old SBs have a different way on setting DMA timing constant */
+ tc = freq;
+ if (mode & SBMODE_STEREO)
+ tc *= 2;
+ tc = 1000000 / tc;
+ if (tc > 255)
+ return FALSE;
+ }
+
+ sb.mode = mode;
+
+ /* Get a DMA buffer enough for a 1/4sec interval... 4K <= dmasize <= 32K */
+ dmabuffsize = freq;
+ if (mode & SBMODE_STEREO)
+ dmabuffsize *= 2;
+ if (mode & SBMODE_16BITS)
+ dmabuffsize *= 2;
+ dmabuffsize >>= 2;
+ if (dmabuffsize < 4096)
+ dmabuffsize = 4096;
+ if (dmabuffsize > 32768)
+ dmabuffsize = 32768;
+ dmabuffsize = (dmabuffsize + 255) & 0xffffff00;
+
+ sb.dma_buff = dma_allocate(dmachannel, dmabuffsize);
+ if (!sb.dma_buff)
+ return FALSE;
+
+ /* Fill DMA buffer with silence */
+ dmabuffsize = sb.dma_buff->size;
+ if (mode & SBMODE_SIGNED)
+ memset(sb.dma_buff->linear, 0, dmabuffsize);
+ else
+ memset(sb.dma_buff->linear, 0x80, dmabuffsize);
+
+ /* Prime DMA for transfer */
+ dma_start(sb.dma_buff, dmabuffsize, DMA_MODE_WRITE | DMA_MODE_AUTOINIT);
+
+ /* Tell SoundBlaster to start transfer */
+ if (sb.dspver >= SBVER_16) { /* SB16 */
+ __sb_dspreg_outwhl(SBDSP_SET_RATE, freq);
+
+ /* Start DMA->DAC transfer */
+ __sb_dspreg_out(SBM_GENDAC_AUTOINIT | SBM_GENDAC_FIFO |
+ ((mode & SBMODE_16BITS) ? SBDSP_DMA_GENERIC16 :
+ SBDSP_DMA_GENERIC8),
+ ((mode & SBMODE_SIGNED) ? SBM_GENDAC_SIGNED : 0) |
+ ((mode & SBMODE_STEREO) ? SBM_GENDAC_STEREO : 0));
+
+ /* Write the length of transfer */
+ dmabuffsize = (dmabuffsize >> 2) - 1;
+ __sb_dsp_out(dmabuffsize);
+ __sb_dsp_out(dmabuffsize >> 8);
+ } else {
+ __sb_dspreg_out(SBDSP_SET_TIMING, 256 - tc);
+ dmabuffsize = (dmabuffsize >> 1) - 1;
+ if (sb.dspver >= SBVER_20) { /* SB 2.0/Pro */
+ /* Set stereo mode */
+ __sb_stereo((mode & SBMODE_STEREO) ? TRUE : FALSE);
+ __sb_dspreg_outwlh(SBDSP_SET_DMA_BLOCK, dmabuffsize);
+ if (sb.dspver >= SBVER_PRO)
+ __sb_dsp_out(SBDSP_HS_DMA_DAC8_AUTO);
+ else
+ __sb_dsp_out(SBDSP_DMA_PCM8_AUTO);
+ } else { /* Original SB */
+ /* Start DMA->DAC transfer */
+ __sb_dspreg_outwlh(SBDSP_DMA_PCM8, dmabuffsize);
+ }
+ }
+
+ return TRUE;
+}
+
+/* Stop playing from DMA buffer */
+void sb_stop_dma()
+{
+ if (!sb.dma_buff)
+ return;
+
+ if (sb.mode & SBMODE_16BITS)
+ __sb_dsp_out(SBDSP_DMA_HALT16);
+ else
+ __sb_dsp_out(SBDSP_DMA_HALT8);
+
+ dma_disable(sb.dma_buff->channel);
+ dma_free(sb.dma_buff);
+ sb.dma_buff = NULL;
+}
+
+/* Query current position/total size of the DMA buffer */
+void sb_query_dma(unsigned int *dma_size, unsigned int *dma_pos)
+{
+ unsigned int dma_left;
+ *dma_size = sb.dma_buff->size;
+ /* It can happen we try to read DMA count when HI/LO bytes will be
+ inconsistent */
+ for (;;) {
+ unsigned int dma_left_test;
+ dma_clear_ff(sb.dma_buff->channel);
+ dma_left_test = dma_get_count(sb.dma_buff->channel);
+ dma_left = dma_get_count(sb.dma_buff->channel);
+ if ((dma_left >= dma_left_test) && (dma_left - dma_left_test < 10))
+ break;
+ }
+ *dma_pos = *dma_size - dma_left;
+}
+
+#endif /* DRV_SB */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ SoundBlaster and compatible soundcards definitions
+
+==============================================================================*/
+
+#ifndef __DOSSB_H__
+#define __DOSSB_H__
+
+#include "dosdma.h"
+#include "dosirq.h"
+
+#define SB_FM_LEFT_STATUS (sb.port + 0x00) /* (r) Left FM status */
+#define SB_FM_LEFT_REGSEL (sb.port + 0x00) /* (w) Left FM register select */
+#define SB_FM_LEFT_DATA (sb.port + 0x01) /* (w) Left FM data */
+#define SB_FM_RIGHT_STATUS (sb.port + 0x02) /* (r) Right FM status */
+#define SB_FM_RIGHT_REGSEL (sb.port + 0x02) /* (w) Right FM register select */
+#define SB_FM_RIGHT_DATA (sb.port + 0x03) /* (w) Right FM data */
+#define SB_MIXER_REGSEL (sb.port + 0x04) /* (w) Mixer register select */
+#define SB_MIXER_DATA (sb.port + 0x05) /* (rw)Mixer data */
+#define SB_DSP_RESET (sb.port + 0x06) /* (w) DSP reset */
+#define SB_FM_STATUS (sb.port + 0x08) /* (r) FM status */
+#define SB_FM_REGSEL (sb.port + 0x08) /* (w) FM register select */
+#define SB_FM_DATA (sb.port + 0x09) /* (w) FM data */
+#define SB_DSP_DATA_IN (sb.port + 0x0a) /* (r) DSP data input */
+#define SB_DSP_DATA_OUT (sb.port + 0x0c) /* (w) DSP data output */
+#define SB_DSP_DATA_OUT_STATUS (sb.port + 0x0c) /* (r) DSP data output status */
+#define SB_DSP_TIMER_IRQ (sb.port + 0x0d) /* (r) clear timer IRQ? */
+#define SB_DSP_DATA_IN_STATUS (sb.port + 0x0e) /* (r) DSP data input status */
+#define SB_DSP_DMA8_IRQ (sb.port + 0x0e) /* (r) Acknowledge 8-bit DMA transfer */
+#define SB_DSP_DMA16_IRQ (sb.port + 0x0f) /* (r) Acknowledge 16-bit DMA transfer */
+
+/* DSP commands */
+#define SBDSP_ASP_STATUS 0x03 /* ASP Status (SB16ASP) */
+#define SBDSP_STATUS_OLD 0x04 /* DSP Status (Obsolete) (SB2.0-Pro2) */
+#define SBDSP_DIRECT_DAC 0x10 /* Direct DAC, 8-bit (SB) */
+#define SBDSP_DMA_PCM8 0x14 /* DMA DAC, 8-bit (SB) */
+#define SBDSP_DMA_ADPCM2 0x16 /* DMA DAC, 2-bit ADPCM (SB) */
+#define SBDSP_DMA_ADPCM2R 0x17 /* DMA DAC, 2-bit ADPCM Reference (SB) */
+#define SBDSP_DMA_PCM8_AUTO 0x1C /* Auto-Initialize DMA DAC, 8-bit (SB2.0) */
+#define SBDSP_DMA_ADPCM2R_AUTO 0x1F /* Auto-Initialize DMA DAC, 2-bit ADPCM Reference (SB2.0) */
+#define SBDSP_DIRECT_ADC 0x20 /* Direct ADC, 8-bit (SB) */
+#define SBDSP_DMA_ADC8 0x24 /* DMA ADC, 8-bit (SB) */
+#define SBDSP_DIRECT_ADC8_BURST 0x28 /* Direct ADC, 8-bit (Burst) (SB-Pro2) */
+#define SBDSP_DMA_ADC8_AUTO 0x2C /* Auto-Initialize DMA ADC, 8-bit (SB2.0) */
+#define SBDSP_MIDI_READ_POLL 0x30 /* MIDI Read Poll (SB) */
+#define SBDSP_MIDI_READ_IRQ 0x31 /* MIDI Read Interrupt (SB) */
+#define SBDSP_MIDI_READ_TIME 0x32 /* MIDI Read Timestamp Poll (SB???) */
+#define SBDSP_MIDI_READ_TIME_IRQ 0x33 /* MIDI Read Timestamp Interrupt (SB???) */
+#define SBDSP_MIDI_RW_POLL 0x34 /* MIDI Read Poll + Write Poll (UART) (SB2.0) */
+#define SBDSP_MIDI_RW_IRQ 0x35 /* MIDI Read Interrupt + Write Poll (UART) (SB2.0???) */
+#define SBDSP_MIDI_RW_TIME_IRQ 0x37 /* MIDI Read Timestamp Interrupt + Write Poll (UART) (SB2.0???) */
+#define SBDSP_MIDI_WRITE_POLL 0x38 /* MIDI Write Poll (SB) */
+#define SBDSP_SET_TIMING 0x40 /* Set Time Constant (SB) */
+#define SBDSP_SET_RATE 0x41 /* Set Sample Rate, Hz (SB16) */
+#define SBDSP_DMA_CONT8_AUTO 0x45 /* Continue Auto-Initialize DMA, 8-bit (SB16) */
+#define SBDSP_DMA_CONT16_AUTO 0x47 /* Continue Auto-Initialize DMA, 16-bit (SB16) */
+#define SBDSP_SET_DMA_BLOCK 0x48 /* Set DMA Block Size (SB2.0) */
+#define SBDSP_DMA_ADPCM4 0x74 /* DMA DAC, 4-bit ADPCM (SB) */
+#define SBDSP_DMA_ADPCM4_REF 0x75 /* DMA DAC, 4-bit ADPCM Reference (SB) */
+#define SBDSP_DMA_ADPCM26 0x76 /* DMA DAC, 2.6-bit ADPCM (SB) */
+#define SBDSP_DMA_ADPCM26_REF 0x77 /* DMA DAC, 2.6-bit ADPCM Reference (SB) */
+#define SBDSP_DMA_ADPCM4R_AUTO 0x7D /* Auto-Initialize DMA DAC, 4-bit ADPCM Reference (SB2.0) */
+#define SBDSP_DMA_ADPCM26R_AUTO 0x7F /* Auto-Initialize DMA DAC, 2.6-bit ADPCM Reference (SB2.0) */
+#define SBDSP_DISABLE_DAC 0x80 /* Silence DAC (SB) */
+#define SBDSP_HS_DMA_DAC8_AUTO 0x90 /* Auto-Initialize DMA DAC, 8-bit (High Speed) (SB2.0-Pro2) */
+#define SBDSP_HS_DMA_ADC8_AUTO 0x98 /* Auto-Initialize DMA ADC, 8-bit (High Speed) (SB2.0-Pro2) */
+#define SBDSP_STEREO_ADC_DIS 0xA0 /* Disable Stereo Input Mode (SBPro Only) */
+#define SBDSP_STEREO_ADC_ENA 0xA8 /* Enable Stereo Input Mode (SBPro Only) */
+#define SBDSP_DMA_GENERIC16 0xB0 /* Generic DAC/ADC DMA (16-bit) (SB16) */
+#define SBDSP_DMA_GENERIC8 0xC0 /* Generic DAC/ADC DMA (8-bit) (SB16) */
+#define SBDSP_DMA_HALT8 0xD0 /* Halt DMA Operation, 8-bit (SB) */
+#define SBDSP_SPEAKER_ENA 0xD1 /* Enable Speaker (SB) */
+#define SBDSP_SPEAKER_DIS 0xD3 /* Disable Speaker (SB) */
+#define SBDSP_DMA_CONT8 0xD4 /* Continue DMA Operation, 8-bit (SB) */
+#define SBDSP_DMA_HALT16 0xD5 /* Halt DMA Operation, 16-bit (SB16) */
+#define SBDSP_DMA_CONT16 0xD6 /* Continue DMA Operation, 16-bit (SB16) */
+#define SBDSP_SPEAKER_STATUS 0xD8 /* Speaker Status (SB) */
+#define SBDSP_DMA_EXIT16_AUTO 0xD9 /* Exit Auto-Initialize DMA Operation, 16-bit (SB16) */
+#define SBDSP_DMA_EXIT8_AUTO 0xDA /* Exit Auto-Initialize DMA Operation, 8-bit (SB2.0) */
+#define SBDSP_IDENTIFY 0xE0 /* DSP Identification (SB2.0) */
+#define SBDSP_VERSION 0xE1 /* DSP Version (SB) */
+#define SBDSP_COPYRIGHT 0xE3 /* DSP Copyright (SBPro2???) */
+#define SBDSP_WRITE_TEST 0xE4 /* Write Test Register (SB2.0) */
+#define SBDSP_READ_TEST 0xE8 /* Read Test Register (SB2.0) */
+#define SBDSP_SINE_GEN 0xF0 /* Sine Generator (SB) */
+#define SBDSP_AUX_STATUS_PRO 0xF1 /* DSP Auxiliary Status (Obsolete) (SB-Pro2) */
+#define SBDSP_GEN_IRQ8 0xF2 /* IRQ Request, 8-bit (SB) */
+#define SBDSP_GEN_IRQ16 0xF3 /* IRQ Request, 16-bit (SB16) */
+#define SBDSP_STATUS 0xFB /* DSP Status (SB16) */
+#define SBDSP_AUX_STATUS_16 0xFC /* DSP Auxiliary Status (SB16) */
+#define SBDSP_CMD_STATUS 0xFD /* DSP Command Status (SB16) */
+
+/* Mixer commands */
+#define SBMIX_RESET 0x00 /* Reset Write SBPro */
+#define SBMIX_STATUS 0x01 /* Status Read SBPro */
+#define SBMIX_MASTER_LEVEL1 0x02 /* Master Volume Read/Write SBPro Only */
+#define SBMIX_DAC_LEVEL 0x04 /* DAC Level Read/Write SBPro */
+#define SBMIX_FM_OUTPUT 0x06 /* FM Output Control Read/Write SBPro Only */
+#define SBMIX_MIC_LEVEL 0x0A /* Microphone Level Read/Write SBPro */
+#define SBMIX_INPUT_SELECT 0x0C /* Input/Filter Select Read/Write SBPro Only */
+#define SBMIX_OUTPUT_SELECT 0x0E /* Output/Stereo Select Read/Write SBPro Only */
+#define SBMIX_FM_LEVEL 0x22 /* Master Volume Read/Write SBPro */
+#define SBMIX_MASTER_LEVEL 0x26 /* FM Level Read/Write SBPro */
+#define SBMIX_CD_LEVEL 0x28 /* CD Audio Level Read/Write SBPro */
+#define SBMIX_LINEIN_LEVEL 0x2E /* Line In Level Read/Write SBPro */
+#define SBMIX_MASTER_LEVEL_L 0x30 /* Master Volume Left Read/Write SB16 */
+#define SBMIX_MASTER_LEVEL_R 0x31 /* Master Volume Right Read/Write SB16 */
+#define SBMIX_DAC_LEVEL_L 0x32 /* DAC Level Left Read/Write SB16 */
+#define SBMIX_DAC_LEVEL_R 0x33 /* DAC Level Right Read/Write SB16 */
+#define SBMIX_FM_LEVEL_L 0x34 /* FM Level Left Read/Write SB16 */
+#define SBMIX_FM_LEVEL_R 0x35 /* FM Level Right Read/Write SB16 */
+#define SBMIX_CD_LEVEL_L 0x36 /* CD Audio Level Left Read/Write SB16 */
+#define SBMIX_CD_LEVEL_R 0x37 /* CD Audio Level Right Read/Write SB16 */
+#define SBMIX_LINEIN_LEVEL_L 0x38 /* Line In Level Left Read/Write SB16 */
+#define SBMIX_LINEIN_LEVEL_R 0x39 /* Line In Level Right Read/Write SB16 */
+#define SBMIX_MIC_LEVEL_16 0x3A /* Microphone Level Read/Write SB16 */
+#define SBMIX_PCSPK_LEVEL 0x3B /* PC Speaker Level Read/Write SB16 */
+#define SBMIX_OUTPUT_CONTROL 0x3C /* Output Control Read/Write SB16 */
+#define SBMIX_INPUT_CONTROL_L 0x3D /* Input Control Left Read/Write SB16 */
+#define SBMIX_INPUT_CONTROL_R 0x3E /* Input Control Right Read/Write SB16 */
+#define SBMIX_INPUT_GAIN_L 0x3F /* Input Gain Control Left Read/Write SB16 */
+#define SBMIX_INPUT_GAIN_R 0x40 /* Input Gain Control Right Read/Write SB16 */
+#define SBMIX_OUTPUT_GAIN_L 0x41 /* Output Gain Control Left Read/Write SB16 */
+#define SBMIX_OUTPUT_GAIN_R 0x42 /* Output Gain Control Right Read/Write SB16 */
+#define SBMIX_AGC_CONTROL 0x43 /* Automatic Gain Control (AGC) Read/Write SB16 */
+#define SBMIX_TREBLE_L 0x44 /* Treble Left Read/Write SB16 */
+#define SBMIX_TREBLE_R 0x45 /* Treble Right Read/Write SB16 */
+#define SBMIX_BASS_L 0x46 /* Bass Left Read/Write SB16 */
+#define SBMIX_BASS_R 0x47 /* Bass Right Read/Write SB16 */
+#define SBMIX_IRQ_SELECT 0x80 /* IRQ Select Read/Write SB16 */
+#define SBMIX_DMA_SELECT 0x81 /* DMA Select Read/Write SB16 */
+#define SBMIX_IRQ_STATUS 0x82 /* IRQ Status Read SB16 */
+
+/* SB_DSP_DATA_OUT_STATUS and SB_DSP_DATA_IN_STATUS bits */
+#define SBM_DSP_READY 0x80
+
+/* SB_DSP_RESET / SBMIX_RESET */
+#define SBM_DSP_RESET 0x01
+
+/* SBMIX_OUTPUT_SELECT */
+#define SBM_MIX_STEREO 0x02
+#define SBM_MIX_FILTER 0x20
+
+/* SBDSP_DMA_GENERIC16/SBDSP_DMA_GENERIC8 */
+#define SBM_GENDAC_FIFO 0x02
+#define SBM_GENDAC_AUTOINIT 0x04
+#define SBM_GENDAC_ADC 0x08
+/* Second (mode) byte */
+#define SBM_GENDAC_SIGNED 0x10
+#define SBM_GENDAC_STEREO 0x20
+
+/* DSP version masks */
+#define SBVER_10 0x0100 /* Original SoundBlaster */
+#define SBVER_15 0x0105 /* SoundBlaster 1.5 */
+#define SBVER_20 0x0200 /* SoundBlaster 2.0 */
+#define SBVER_PRO 0x0300 /* SoundBlaster Pro */
+#define SBVER_PRO2 0x0301 /* SoundBlaster Pro 2 */
+#define SBVER_16 0x0400 /* SoundBlaster 16 */
+#define SBVER_AWE32 0x040c /* SoundBlaster AWE32 */
+
+typedef unsigned char boolean;
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+/* Play mode bits */
+#define SBMODE_16BITS 0x0001
+#define SBMODE_STEREO 0x0002
+#define SBMODE_SIGNED 0x0004
+
+/* Mask for capabilities that never change */
+#define SBMODE_MASK (SBMODE_16BITS | SBMODE_STEREO)
+
+/* You can fill some members of this struct (i.e. port,irq,dma) before
+ * calling sb_detect() or sb_open()... this will ignore environment settings.
+ */
+typedef struct __sb_state_s {
+ boolean ok; /* Are structure contents valid? */
+ int port, aweport; /* sb/awe32 base port */
+ int irq; /* SoundBlaster IRQ */
+ int dma8, dma16; /* 8-bit and 16-bit DMAs */
+ int maxfreq_mono; /* Maximum discretization frequency / mono mode */
+ int maxfreq_stereo; /* Maximum discretization frequency / stereo mode */
+ unsigned short dspver; /* DSP version number */
+ struct irq_handle *irq_handle; /* The interrupt handler */
+ dma_buffer *dma_buff; /* Pre-allocated DMA buffer */
+ unsigned char caps; /* SoundBlaster capabilities (SBMODE_XXX) */
+ unsigned char mode; /* Current SB mode (SBMODE_XXX) */
+ boolean open; /* Whenever the card has been opened */
+ volatile int irqcount; /* Incremented on each IRQ... for diagnostics */
+ void (*timer_callback) (); /* Called TWICE per buffer play */
+} __sb_state;
+
+extern __sb_state sb;
+
+extern void __sb_wait();
+
+static inline boolean __sb_dsp_ready_in()
+{
+ int count;
+ for (count = 10000; count >= 0; count--)
+ if (inportb(SB_DSP_DATA_IN_STATUS) & SBM_DSP_READY)
+ return TRUE;
+ return FALSE;
+}
+
+static inline boolean __sb_dsp_ready_out()
+{
+ int count;
+ for (count = 10000; count >= 0; count--)
+ if ((inportb(SB_DSP_DATA_OUT_STATUS) & SBM_DSP_READY) == 0)
+ return TRUE;
+ return FALSE;
+}
+
+static inline void __sb_dsp_out(unsigned char reg)
+{
+ __sb_dsp_ready_out();
+ outportb(SB_DSP_DATA_OUT, reg);
+}
+
+static inline unsigned char __sb_dsp_in()
+{
+ __sb_dsp_ready_in();
+ return inportb(SB_DSP_DATA_IN);
+}
+
+static inline void __sb_dspreg_out(unsigned char reg, unsigned char val)
+{
+ __sb_dsp_out(reg);
+ __sb_dsp_out(val);
+}
+
+static inline void __sb_dspreg_outwlh(unsigned char reg, unsigned short val)
+{
+ __sb_dsp_out(reg);
+ __sb_dsp_out(val);
+ __sb_dsp_out(val >> 8);
+}
+
+static inline void __sb_dspreg_outwhl(unsigned char reg, unsigned short val)
+{
+ __sb_dsp_out(reg);
+ __sb_dsp_out(val >> 8);
+ __sb_dsp_out(val);
+}
+
+static inline unsigned char __sb_dspreg_in(unsigned char reg)
+{
+ __sb_dsp_out(reg);
+ return __sb_dsp_in();
+}
+
+static inline void __sb_dsp_ack_dma8()
+{
+ inportb(SB_DSP_DMA8_IRQ);
+}
+
+static inline void __sb_dsp_ack_dma16()
+{
+ inportb(SB_DSP_DMA16_IRQ);
+}
+
+static inline unsigned short __sb_dsp_version()
+{
+ unsigned short ver;
+ __sb_dsp_out(SBDSP_VERSION);
+ __sb_dsp_ready_in();
+ ver = ((unsigned short)__sb_dsp_in()) << 8;
+ ver |= __sb_dsp_in();
+ return ver;
+}
+
+static inline void __sb_mixer_out(unsigned char reg, unsigned char val)
+{
+ outportb(SB_MIXER_REGSEL, reg);
+ outportb(SB_MIXER_DATA, val);
+}
+
+static inline unsigned char __sb_mixer_in(unsigned char reg)
+{
+ outportb(SB_MIXER_REGSEL, reg);
+ return inportb(SB_MIXER_DATA);
+}
+
+/* Enable stereo transfers: sbpro mode only */
+static inline void __sb_stereo(boolean stereo)
+{
+ unsigned char val = __sb_mixer_in(SBMIX_OUTPUT_SELECT);
+ if (stereo)
+ val |= SBM_MIX_STEREO;
+ else
+ val &= ~SBM_MIX_STEREO;
+ __sb_mixer_out(SBMIX_OUTPUT_SELECT, val);
+}
+
+/* Detect whenever SoundBlaster is present and fill "sb" structure */
+extern boolean sb_detect();
+/* Reset SoundBlaster */
+extern void sb_reset();
+/* Start working with SoundBlaster */
+extern boolean sb_open();
+/* Finish working with SoundBlaster */
+extern boolean sb_close();
+/* Enable/disable speaker output */
+extern void sb_output(boolean enable);
+/* Start playing from DMA buffer in either 8/16 bit mono/stereo */
+extern boolean sb_start_dma(unsigned char mode, unsigned int freq);
+/* Stop playing from DMA buffer */
+extern void sb_stop_dma();
+/* Query current position/total size of the DMA buffer */
+extern void sb_query_dma(unsigned int *dma_size, unsigned int *dma_pos);
+
+#endif /* __DOSSB_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ Windows Sound System I/O routines (CS42XX, ESS18XX, GUS+DaughterBoard etc)
+ Written by Andrew Zabolotny <bit@eltech.ru>
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DRV_WSS
+
+#include <stdlib.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <dos.h>
+#include <sys/nearptr.h>
+#include <sys/farptr.h>
+#include <string.h>
+
+#include "doswss.h"
+
+/********************************************* Private variables/routines *****/
+
+__wss_state wss;
+
+/* WSS frequency rates... lower bit selects one of two frequency generators */
+static unsigned int wss_rates[14][2] = {
+ {5510, 0x00 | WSSM_XTAL2},
+ {6620, 0x0E | WSSM_XTAL2},
+ {8000, 0x00 | WSSM_XTAL1},
+ {9600, 0x0E | WSSM_XTAL1},
+ {11025, 0x02 | WSSM_XTAL2},
+ {16000, 0x02 | WSSM_XTAL1},
+ {18900, 0x04 | WSSM_XTAL2},
+ {22050, 0x06 | WSSM_XTAL2},
+ {27420, 0x04 | WSSM_XTAL1},
+ {32000, 0x06 | WSSM_XTAL1},
+ {33075, 0x0C | WSSM_XTAL2},
+ {37800, 0x08 | WSSM_XTAL2},
+ {44100, 0x0A | WSSM_XTAL2},
+ {48000, 0x0C | WSSM_XTAL1}
+};
+
+static void wss_irq()
+{
+ /* Make sure its not a spurious IRQ */
+ if (!irq_check(wss.irq_handle))
+ return;
+
+ wss.irqcount++;
+
+ /* Clear IRQ status */
+ outportb(WSS_STATUS, 0);
+
+ /* Write transfer count again */
+ __wss_outreg(WSSR_COUNT_LOW, wss.samples & 0xff);
+ __wss_outreg(WSSR_COUNT_HIGH, wss.samples >> 8);
+ irq_ack(wss.irq_handle);
+
+ enable();
+ if (wss.timer_callback)
+ wss.timer_callback();
+}
+
+static void wss_irq_end()
+{
+}
+
+/* WSS accepts some conventional values instead of frequency in Hz... */
+static unsigned char __wss_getrate(unsigned int *freq)
+{
+ int i, best = -1, delta = 0xffff;
+
+ for (i = 0; i < 14; i++) {
+ int newdelta = abs(wss_rates[i][0] - *freq);
+ if (newdelta < delta)
+ best = i, delta = newdelta;
+ }
+
+ *freq = wss_rates[best][0];
+ return wss_rates[best][1];
+}
+
+/* Check if we really have a WSS compatible card on given address */
+static boolean __wss_ping()
+{
+ /* Disable CODEC operations first */
+ __wss_regbit_reset(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+ /* Now put some harmless values in registers and check them */
+ __wss_outreg(WSSR_COUNT_LOW, 0xaa);
+ __wss_outreg(WSSR_COUNT_HIGH, 0x55);
+ return (__wss_inreg(WSSR_COUNT_LOW) == 0xaa)
+ && (__wss_inreg(WSSR_COUNT_HIGH) == 0x55);
+}
+
+static boolean __wss_reset()
+{
+ int count;
+
+ /* Disable output */
+ wss_output(FALSE);
+
+ /* Now select the test/initialization register */
+ count = 10000;
+ while (inportb(WSS_ADDR) != WSSR_TEST_INIT) {
+ outportb(WSS_ADDR, WSSR_TEST_INIT);
+ if (!--count)
+ return FALSE;
+ }
+
+ count = 10000;
+ while (inportb(WSS_DATA) & WSSM_CALIB_IN_PROGRESS) {
+ outportb(WSS_ADDR, WSSR_TEST_INIT);
+ if (!--count)
+ return FALSE;
+ }
+
+ /* Enable playback IRQ */
+ __wss_regbit_set(WSSR_PIN_CTRL, WSSM_IRQ_ENABLE);
+ __wss_outreg(WSSR_IRQ_STATUS, WSSM_PLAYBACK_IRQ);
+
+ /* Clear IRQ status */
+ outportb(WSS_STATUS, 0);
+
+ return TRUE;
+}
+
+static boolean __wss_setformat(unsigned char format)
+{
+ int count;
+
+ outportb(WSS_ADDR, WSSM_MCE | WSSR_PLAY_FORMAT);
+ outportb(WSS_DATA, format);
+ inportb(WSS_DATA); /* ERRATA SHEETS ... */
+ inportb(WSS_DATA); /* ERRATA SHEETS ... */
+
+ /* Wait end of syncronization ... */
+ if (!__wss_wait())
+ return FALSE;
+
+ /* Turn off the ModeChangeEnable bit: do it until it works */
+ count = 10000;
+ while (inportb(WSS_ADDR) != WSSR_PLAY_FORMAT) {
+ outportb(WSS_ADDR, WSSR_PLAY_FORMAT);
+ if (!--count)
+ return FALSE;
+ }
+
+ return __wss_reset();
+}
+
+/**************************************************** WSS detection stuff *****/
+
+static int __wss_irq_irqdetect(int irqno)
+{
+ unsigned char status = inportb(WSS_STATUS);
+ /* Clear IRQ status */
+ outportb(WSS_STATUS, 0);
+ /* Reset transfer counter */
+ __wss_outreg(WSSR_COUNT_LOW, 0);
+ __wss_outreg(WSSR_COUNT_HIGH, 0);
+ return (status & WSSM_INT);
+}
+
+static boolean __wss_detect()
+{
+ /* First find the port number */
+ if (!wss.port) {
+ static unsigned int wss_ports[] =
+ { 0x32c, 0x530, 0x604, 0xE80, 0xF40 };
+ int i;
+ for (i = 0; i < 5; i++) {
+ wss.port = wss_ports[i];
+ if (__wss_ping())
+ break;
+ }
+ if (i < 0) {
+ wss.port = 0;
+ return FALSE;
+ }
+ }
+
+ /* Now disable output */
+ wss_output(FALSE);
+
+ /* Detect the DMA channel */
+ if (!wss.dma) {
+ static int __dma[] = { 0, 1, 3 };
+ int i;
+
+ /* Enable playback IRQ */
+ __wss_regbit_set(WSSR_PIN_CTRL, WSSM_IRQ_ENABLE);
+ __wss_outreg(WSSR_IRQ_STATUS, WSSM_PLAYBACK_IRQ);
+
+ /* Start a short DMA transfer and check if DMA count is zero */
+ for (i = 0; i < 3; i++) {
+ unsigned int timer, status, freq = 44100;
+
+ wss.dma = __dma[i];
+
+ dma_disable(wss.dma);
+ dma_set_mode(wss.dma, DMA_MODE_WRITE);
+ dma_clear_ff(wss.dma);
+ dma_set_count(wss.dma, 10);
+ dma_enable(wss.dma);
+
+ /* Clear IRQ status */
+ outportb(WSS_STATUS, 0);
+
+ __wss_setformat(__wss_getrate(&freq));
+ __wss_outreg(WSSR_COUNT_LOW, 1);
+ __wss_outreg(WSSR_COUNT_HIGH, 0);
+ /* Tell codec to start transfer */
+ __wss_regbit_set(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+
+ _farsetsel(_dos_ds);
+ timer = _farnspeekl(0x46c);
+
+ while (_farnspeekl(0x46c) - timer <= 2)
+ if (dma_get_count(wss.dma) == 0)
+ break;
+ __wss_regbit_reset(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+ dma_disable(wss.dma);
+
+ /* Now check if DMA transfer count is zero and an IRQ is pending */
+ status = inportb(WSS_STATUS);
+ outportb(WSS_STATUS, 0);
+ if ((dma_get_count(wss.dma) == 0) && (status & WSSM_INT))
+ break;
+
+ wss.dma = 0;
+ }
+
+ if (!wss.dma)
+ return FALSE;
+ }
+
+ /* Now detect the IRQ number */
+ if (!wss.irq) {
+ unsigned int i, irqmask, freq = 5510;
+ unsigned long timer, delta = 0x7fffffff;
+
+ /* IRQ can be one of 2,3,5,7,10 */
+ irq_detect_start(0x04ac, __wss_irq_irqdetect);
+
+ dma_disable(wss.dma);
+ dma_set_mode(wss.dma, DMA_MODE_WRITE | DMA_MODE_AUTOINIT);
+ dma_clear_ff(wss.dma);
+ dma_set_count(wss.dma, 1);
+ dma_enable(wss.dma);
+
+ __wss_setformat(__wss_getrate(&freq));
+
+ /* Clear IRQ status */
+ outportb(WSS_STATUS, 0);
+
+ __wss_outreg(WSSR_COUNT_LOW, 0);
+ __wss_outreg(WSSR_COUNT_HIGH, 0);
+
+ /* Prepare timeout counter */
+ _farsetsel(_dos_ds);
+ timer = _farnspeekl(0x46c);
+ while (timer == _farnspeekl(0x46c));
+ timer = _farnspeekl(0x46c);
+
+ /* Reset all IRQ counters */
+ irq_detect_clear();
+
+ /* Tell codec to start transfer */
+ __wss_regbit_set(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+
+ /* Now wait 1/18 seconds */
+ while (timer == _farnspeekl(0x46c));
+ __wss_regbit_reset(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+ dma_disable(wss.dma);
+
+ /* Given frequency 5510Hz, a buffer size of 1 byte and a time interval
+ of 1/18.2 second, we should have received about 302 interrupts */
+ for (i = 2; i <= 10; i++) {
+ int count = abs(302 - irq_detect_get(i, &irqmask));
+ if (count < delta)
+ wss.irq = i, delta = count;
+ }
+ if (delta > 150)
+ wss.irq = 0;
+
+ irq_detect_end();
+ if (!wss.irq)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/*************************************************** High-level interface *****/
+
+/* Detect whenever WSS is present and fill "wss" structure */
+boolean wss_detect()
+{
+ char *env;
+
+ /* Try to find the port and DMA from environment */
+ env = getenv("WSS");
+
+ while (env && *env) {
+ /* Skip whitespace */
+ while ((*env == ' ') || (*env == '\t'))
+ env++;
+ if (!*env)
+ break;
+
+ switch (*env++) {
+ case 'A':
+ case 'a':
+ if (!wss.port)
+ wss.port = strtol(env, &env, 16);
+ break;
+ case 'I':
+ case 'i':
+ if (!wss.irq)
+ wss.irq = strtol(env, &env, 10);
+ break;
+ case 'D':
+ case 'd':
+ if (!wss.dma)
+ wss.dma = strtol(env, &env, 10);
+ break;
+ default:
+ /* Skip other values */
+ while (*env && (*env != ' ') && (*env != '\t'))
+ env++;
+ break;
+ }
+ }
+
+ /* Try to fill the gaps in wss hardware parameters */
+ __wss_detect();
+
+ if (!wss.port || !wss.irq || !wss.dma)
+ return FALSE;
+
+ if (!__wss_ping())
+ return FALSE;
+
+ if (!__wss_reset())
+ return FALSE;
+
+ wss.ok = 1;
+ return TRUE;
+}
+
+/* Reset WSS */
+void wss_reset()
+{
+ wss_stop_dma();
+ __wss_reset();
+}
+
+/* Open WSS for usage */
+boolean wss_open()
+{
+ __dpmi_meminfo struct_info;
+
+ if (!wss.ok)
+ if (!wss_detect())
+ return FALSE;
+
+ if (wss.open)
+ return FALSE;
+
+ /* Now lock the wss structure in memory */
+ struct_info.address = __djgpp_base_address + (unsigned long)&wss;
+ struct_info.size = sizeof(wss);
+ if (__dpmi_lock_linear_region(&struct_info))
+ return FALSE;
+
+ /* Hook the WSS IRQ */
+ wss.irq_handle =
+ irq_hook(wss.irq, wss_irq, (long)wss_irq_end - (long)wss_irq);
+ if (!wss.irq_handle) {
+ __dpmi_unlock_linear_region(&struct_info);
+ return FALSE;
+ }
+
+ /* Enable the interrupt */
+ irq_enable(wss.irq_handle);
+ if (wss.irq > 7)
+ _irq_enable(2);
+
+ wss.open++;
+
+ return TRUE;
+}
+
+/* Finish working with WSS */
+boolean wss_close()
+{
+ __dpmi_meminfo struct_info;
+ if (!wss.open)
+ return FALSE;
+
+ wss.open--;
+
+ /* Stop/free DMA buffer */
+ wss_stop_dma();
+
+ /* Unhook IRQ */
+ irq_unhook(wss.irq_handle);
+ wss.irq_handle = NULL;
+
+ /* Unlock the wss structure */
+ struct_info.address = __djgpp_base_address + (unsigned long)&wss;
+ struct_info.size = sizeof(wss);
+ __dpmi_unlock_linear_region(&struct_info);
+
+ return TRUE;
+}
+
+/* Adjust frequency rate to nearest WSS available */
+unsigned int wss_adjust_freq(unsigned int freq)
+{
+ __wss_getrate(&freq);
+ return freq;
+}
+
+/* Enable/disable speaker output */
+/* Start playing from DMA buffer in either 8/16 bit mono/stereo */
+boolean wss_start_dma(unsigned char mode, unsigned int freq)
+{
+ int dmabuffsize;
+ unsigned char format;
+
+ /* Stop DMA transfer if it is enabled */
+ wss_stop_dma();
+
+ /* Sanity check: we support only 8-bit unsigned and 16-bit signed formats */
+ if (((mode & WSSMODE_16BITS) && !(mode & WSSMODE_SIGNED))
+ || (!(mode & WSSMODE_16BITS) && (mode & WSSMODE_SIGNED)))
+ return FALSE;
+
+ /* Find the nearest frequency divisor (rate) */
+ format = __wss_getrate(&freq);
+ wss.mode = mode;
+
+ /* Get a DMA buffer enough for a 1sec interval... 4K <= dmasize <= 32K */
+ dmabuffsize = freq;
+ if (mode & WSSMODE_STEREO)
+ dmabuffsize *= 2;
+ if (mode & WSSMODE_16BITS)
+ dmabuffsize *= 2;
+ dmabuffsize >>= 2;
+ if (dmabuffsize < 4096)
+ dmabuffsize = 4096;
+ if (dmabuffsize > 32768)
+ dmabuffsize = 32768;
+ dmabuffsize = (dmabuffsize + 255) & 0xffffff00;
+
+ wss.dma_buff = dma_allocate(wss.dma, dmabuffsize);
+ if (!wss.dma_buff)
+ return FALSE;
+
+ /* Fill DMA buffer with silence */
+ dmabuffsize = wss.dma_buff->size;
+ if (mode & WSSMODE_SIGNED)
+ memset(wss.dma_buff->linear, 0, dmabuffsize);
+ else
+ memset(wss.dma_buff->linear, 0x80, dmabuffsize);
+
+ /* Check data size and build a WSSR_PLAY_FORMAT value accordingly */
+ wss.samples = dmabuffsize;
+ if (mode & WSSMODE_16BITS) {
+ wss.samples >>= 1;
+ format |= WSSM_16BITS;
+ }
+
+ if (mode & WSSMODE_STEREO) {
+ wss.samples >>= 1;
+ format |= WSSM_STEREO;
+ }
+
+ if (!__wss_setformat(format)) {
+ wss_stop_dma();
+ return FALSE;
+ }
+
+ /* Prime DMA for transfer */
+ dma_start(wss.dma_buff, dmabuffsize, DMA_MODE_WRITE | DMA_MODE_AUTOINIT);
+
+ /* Tell codec how many samples to transfer */
+ wss.samples = (wss.samples >> 1) - 1;
+ __wss_outreg(WSSR_COUNT_LOW, wss.samples & 0xff);
+ __wss_outreg(WSSR_COUNT_HIGH, wss.samples >> 8);
+
+ /* Tell codec to start transfer */
+ __wss_regbit_set(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+
+ return TRUE;
+}
+
+/* Stop playing from DMA buffer */
+void wss_stop_dma()
+{
+ if (!wss.dma_buff)
+ return;
+
+ __wss_regbit_reset(WSSR_IFACE_CTRL, WSSM_PLAYBACK_ENABLE);
+ dma_disable(wss.dma);
+ dma_free(wss.dma_buff);
+ wss.dma_buff = NULL;
+}
+
+/* Query current position/total size of the DMA buffer */
+void wss_query_dma(unsigned int *dma_size, unsigned int *dma_pos)
+{
+ unsigned int dma_left;
+ *dma_size = wss.dma_buff->size;
+ /* It can happen we try to read DMA count when HI/LO bytes will be
+ inconsistent */
+ for (;;) {
+ unsigned int dma_left_test;
+ dma_clear_ff(wss.dma);
+ dma_left_test = dma_get_count(wss.dma);
+ dma_left = dma_get_count(wss.dma);
+ if ((dma_left >= dma_left_test) && (dma_left - dma_left_test < 10))
+ break;
+ }
+ *dma_pos = *dma_size - dma_left;
+}
+
+void wss_output(boolean enable)
+{
+ if (enable)
+ wss.curlevel = wss.level;
+ else
+ wss.curlevel = 0x3f;
+
+ __wss_outreg(WSSR_MASTER_L, wss.curlevel);
+ __wss_outreg(WSSR_MASTER_R, wss.curlevel);
+}
+
+void wss_level(int level)
+{
+ if (level < 0)
+ level = 0;
+ if (level > 63)
+ level = 63;
+ wss.curlevel = wss.level = level ^ 63;
+
+ __wss_outreg(WSSR_MASTER_L, wss.curlevel);
+ __wss_outreg(WSSR_MASTER_R, wss.curlevel);
+}
+
+#endif /* DRV_WSS */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Windows Sound System and compatible soundcards definitions
+
+==============================================================================*/
+
+#ifndef __DOSWSS_H__
+#define __DOSWSS_H__
+
+#include "dosdma.h"
+#include "dosirq.h"
+
+#define WSS_ADDR (wss.port + 0x04)
+#define WSS_DATA (wss.port + 0x05)
+#define WSS_STATUS (wss.port + 0x06)
+#define WSS_PIO (wss.port + 0x07)
+
+/* WSS_ADDR: Bits 0-4 select an internal register to read/write */
+#define WSSR_INPUT_L 0x00 /* Left input control register */
+#define WSSR_INPUT_R 0x01 /* RIght input control register */
+#define WSSR_AUX1_L 0x02 /* Left Aux #1 input control */
+#define WSSR_AUX1_R 0x03 /* Right Aux #1 input control */
+#define WSSR_CD_L 0x04 /* Left Aux #2 input control */
+#define WSSR_CD_R 0x05 /* Right Aux #2 input control */
+#define WSSR_MASTER_L 0x06 /* Left output control */
+#define WSSR_MASTER_R 0x07 /* Right output control */
+#define WSSR_PLAY_FORMAT 0x08 /* Clock and data format */
+#define WSSR_IFACE_CTRL 0x09 /* Interface control */
+#define WSSR_PIN_CTRL 0x0a /* Pin control */
+#define WSSR_TEST_INIT 0x0b /* Test and initialization */
+#define WSSR_MISC_INFO 0x0c /* Miscellaneaous information */
+#define WSSR_LOOPBACK 0x0d /* Digital Mix */
+#define WSSR_COUNT_HIGH 0x0e /* Playback Upper Base Count */
+#define WSSR_COUNT_LOW 0x0f /* Playback Lower Base Count */
+#define WSSR_ALT_FEATURE_1 0x10 /* alternate #1 feature enable */
+#define WSSR_ALT_FEATURE_2 0x11 /* alternate #2 feature enable */
+#define WSSR_LINE_IN_L 0x12 /* left line input control */
+#define WSSR_LINE_IN_R 0x13 /* right line input control */
+#define WSSR_TIMER_LOW 0x14 /* timer low byte */
+#define WSSR_TIMER_HIGH 0x15 /* timer high byte */
+#define WSSR_IRQ_STATUS 0x18 /* irq status register */
+#define WSSR_MONO_IO_CTRL 0x1a /* mono input/output control */
+#define WSSR_REC_FORMAT 0x1c /* record format */
+#define WSSR_REC_COUNT_HIGH 0x1e /* record upper count */
+#define WSSR_REC_COUNT_LOW 0x1f /* record lower count */
+
+/* WSS_ADDR bits 7-5 definition */
+#define WSSM_INIT 0x80 /* Codec is initializing */
+#define WSSM_MCE 0x40 /* Mode change enable */
+#define WSSM_TRD 0x20 /* Transfer Request Disable */
+/* bits 4-0 are indirect register address (0-15) */
+
+/* WSS_STATUS bit masks */
+#define WSSM_CUL 0x80 /* Capture data upper/lower byte */
+#define WSSM_CLR 0x40 /* Capture left/right sample */
+#define WSSM_CRDY 0x20 /* Capture data read */
+#define WSSM_SOUR 0x10 /* Playback over/under run error */
+#define WSSM_PUL 0x08 /* Playback upper/lower byte */
+#define WSSM_PLR 0x04 /* Playback left/right sample */
+#define WSSM_PRDY 0x02 /* Playback data register read */
+#define WSSM_INT 0x01 /* interrupt status */
+
+/* Definitions for output level registers */
+#define WSSM_MUTE 0x80 /* Mute this output source */
+/* bits 5-0 are left output attenuation select (0-63) */
+/* bits 5-0 are right output attenuation select (0-63) */
+
+/* Definitions for clock and data format register (WSSR_PLAY_FORMAT) */
+#define WSSM_STEREO 0x10 /* stero mode */
+#define WSSM_ULAW_8 0x20 /* 8-bit U-law companded */
+#define WSSM_16BITS 0x40 /* 16 bit twos complement data - little endian */
+#define WSSM_ALAW_8 0x60 /* 8-bit A-law companded */
+#define WSSM_16BITS_BE 0xc0 /* 16-bit twos complement data - big endian */
+#define WSSM_ADPCM_16 0xa0 /* 16-bit ADPCM */
+/* Bits 3-1 define frequency divisor */
+#define WSSM_XTAL1 0x00 /* 24.576 crystal */
+#define WSSM_XTAL2 0x01 /* 16.9344 crystal */
+
+/* Definitions for interface control register (WSSR_IFACE_CTRL) */
+#define WSSM_CAPTURE_PIO 0x80 /* Capture PIO enable */
+#define WSSM_PLAYBACK_PIO 0x40 /* Playback PIO enable */
+#define WSSM_AUTOCALIB 0x08 /* auto calibrate */
+#define WSSM_SINGLE_DMA 0x04 /* Use single DMA channel */
+#define WSSM_PLAYBACK_ENABLE 0x01 /* playback enable */
+
+/* Definitions for Pin control register (WSSR_PIN_CTRL) */
+#define WSSM_IRQ_ENABLE 0x02 /* interrupt enable */
+#define WSSM_XCTL1 0x40 /* external control #1 */
+#define WSSM_XCTL0 0x80 /* external control #0 */
+
+/* Definitions for WSSR_TEST_INIT register */
+#define WSSM_CALIB_IN_PROGRESS 0x20 /* auto calibrate in progress */
+
+/* Definitions for misc control register (WSR_MISC_INFO) */
+#define WSSM_MODE2 0x40 /* MODE 2 */
+#define WSSM_MODE3 0x6c /* MODE 3 - enhanced mode */
+
+/* Definitions for codec irq status (WSSR_IRQ_STATUS) */
+#define WSSM_PLAYBACK_IRQ 0x10
+#define WSSM_RECORD_IRQ 0x20
+#define WSSM_TIMER_IRQ 0x40
+
+typedef unsigned char boolean;
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+/* Play mode bits */
+#define WSSMODE_16BITS 0x0001
+#define WSSMODE_STEREO 0x0002
+#define WSSMODE_SIGNED 0x0004
+
+/* You can fill some members of this struct (i.e. port,irq,dma) before
+ * calling wss_detect() or wss_open()... this will ignore environment settings.
+ */
+typedef struct __wss_state_s {
+ boolean ok; /* Set if this structure is properly filled */
+ int port; /* Base codec port */
+ int irq; /* codec IRQ */
+ int dma; /* codec DMA */
+ struct irq_handle *irq_handle; /* The interrupt handler */
+ dma_buffer *dma_buff; /* Pre-allocated DMA buffer */
+ unsigned char mode; /* Current WSS mode (WSSMODE_XXX) */
+ boolean open; /* Whenever the card has been opened */
+ int samples; /* Number of samples in DMA buffer */
+ unsigned char level; /* Output level (63..0): doesn't change when mute */
+ unsigned char curlevel; /* Current output level (63(min)..0(max)) */
+ volatile int irqcount; /* Incremented on each IRQ... for diagnostics */
+ void (*timer_callback) (); /* Called TWICE per buffer play */
+} __wss_state;
+
+extern __wss_state wss;
+
+/* Wait until codec finishes initialization */
+static inline boolean __wss_wait()
+{
+ int count;
+ for (count = 10000; count >= 0; count--)
+ if (!(inportb(WSS_ADDR) & WSSM_INIT))
+ return TRUE;
+ return FALSE;
+}
+
+static inline void __wss_outreg(unsigned char reg, unsigned char val)
+{
+ outportb(WSS_ADDR, reg);
+ outportb(WSS_DATA, val);
+}
+
+static inline unsigned char __wss_inreg(unsigned char reg)
+{
+ outportb(WSS_ADDR, reg);
+ return inportb(WSS_DATA);
+}
+
+/* Set some bits in a specific register */
+static inline void __wss_regbit_set(unsigned char reg, unsigned char mask)
+{
+ outportb(WSS_ADDR, reg);
+ outportb(WSS_DATA, inportb(WSS_DATA) | mask);
+}
+
+/* Reset some bits in a specific register */
+static inline void __wss_regbit_reset(unsigned char reg, unsigned char mask)
+{
+ outportb(WSS_ADDR, reg);
+ outportb(WSS_DATA, inportb(WSS_DATA) & ~mask);
+}
+
+/* Detect whenever WSS is present and fill "wss" structure */
+extern boolean wss_detect();
+/* Reset WSS */
+extern void wss_reset();
+/* Open WSS for usage */
+extern boolean wss_open();
+/* Finish working with WSS */
+extern boolean wss_close();
+/* Enable/disable speaker output */
+extern void wss_output(boolean enable);
+/* Adjust frequency rate to nearest WSS available */
+extern unsigned int wss_adjust_freq(unsigned int freq);
+/* Start playing from DMA buffer in either 8/16 bit mono/stereo */
+extern boolean wss_start_dma(unsigned char mode, unsigned int freq);
+/* Stop playing from DMA buffer */
+extern void wss_stop_dma();
+/* Query current position/total size of the DMA buffer */
+extern void wss_query_dma(unsigned int *dma_size, unsigned int *dma_pos);
+/* Set output level (0(min)-63(max)) */
+extern void wss_level(int level);
+
+#endif /* __DOSWSS_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Linux libGUS-alike library for DOS, used by drv_ultra.c under DOS.
+
+==============================================================================*/
+
+/*
+ Current limitations:
+ - Only a subset of libgus is supported
+ - Only one GUS card is supported (due to the fact that ULTRASND environment
+ variable is used)
+ - No Interwawe support (if IW works the old way, it's ok).
+*/
+
+#ifndef __LIBGUS_H__
+#define __LIBGUS_H__
+
+#include <stddef.h>
+
+#define __LITTLE_ENDIAN
+
+typedef struct _gus_info_t gus_info_t;
+typedef struct _gus_instrument_t gus_instrument_t;
+typedef struct _gus_wave_t gus_wave_t;
+typedef struct _gus_layer_t gus_layer_t;
+
+#define GUS_CARD_VERSION_CLASSIC 0x0024 /* revision 2.4 */
+#define GUS_CARD_VERSION_CLASSIC1 0x0034 /* revision 3.4? */
+#define GUS_CARD_VERSION_CLASSIC_ICS 0x0037 /* revision 3.7 (ICS mixer) */
+#define GUS_CARD_VERSION_EXTREME 0x0050 /* GUS Extreme */
+#define GUS_CARD_VERSION_ACE 0x0090 /* GUS ACE */
+#define GUS_CARD_VERSION_MAX 0x00a0 /* GUS MAX - revision 10 */
+#define GUS_CARD_VERSION_MAX1 0x00a1 /* GUS MAX - revision 11 */
+#define GUS_CARD_VERSION_PNP 0x0100 /* GUS Plug & Play */
+
+#define GUS_STRU_INFO_F_DB16 0x00000001 /* 16-bit daughter board present */
+#define GUS_STRU_INFO_F_PCM 0x00000004 /* GF1 PCM during SYNTH enabled */
+#define GUS_STRU_INFO_F_ENHANCED 0x00000008 /* InterWave - enhanced mode */
+#define GUS_STRU_INFO_F_DAEMON 0x00000010 /* instrument daemon is present */
+
+struct _gus_info_t {
+ unsigned char id[8]; /* id of this card (warning! maybe unterminated!!!) */
+
+ unsigned int flags; /* some info flags - see to GUS_STRU_INFO_F_XXXX */
+ unsigned int version; /* see to GUS_CARD_VERSION_XXXX constants */
+
+ unsigned short port;
+ unsigned short irq;
+ unsigned short dma1; /* DMA1 - GF1 download & codec record */
+ unsigned short dma2; /* DMA2 - GF1 record & codec playback */
+
+ unsigned int mixing_freq; /* mixing frequency in Hz */
+
+ unsigned int memory_size; /* in bytes */
+ unsigned int memory_free; /* in bytes */
+ unsigned int memory_block_8; /* largest free 8-bit block in memory */
+ unsigned int memory_block_16; /* largest free 16-bit block in memory */
+};
+
+/* struct gus_instrument_t - mode */
+
+#define GUS_INSTR_SIMPLE 0x00 /* simple format - for MOD players */
+#define GUS_INSTR_PATCH 0x01 /* old GF1 patch format */
+#define GUS_INSTR_COUNT 2
+
+#define GUS_INSTR_F_NORMAL 0x0000 /* normal mode */
+#define GUS_INSTR_F_NOT_FOUND 0x0001 /* instrument can't be loaded */
+#define GUS_INSTR_F_ALIAS 0x0002 /* alias */
+#define GUS_INSTR_F_NOT_LOADED 0x00ff /* instrument not loaded (not found) */
+
+#define GUS_INSTR_E_NONE 0x0000 /* exclusion mode - none */
+#define GUS_INSTR_E_SINGLE 0x0001 /* exclude single - single note from this instrument */
+#define GUS_INSTR_E_MULTIPLE 0x0002 /* exclude multiple - stop only same note from this instrument */
+
+#define GUS_INSTR_L_NONE 0x0000 /* not layered */
+#define GUS_INSTR_L_ON 0x0001 /* layered */
+#define GUS_INSTR_L_VELOCITY 0x0002 /* layered by velocity */
+#define GUS_INSTR_L_FREQUENCY 0x0003 /* layered by frequency */
+
+struct _gus_instrument_t {
+ union {
+ unsigned int instrument;/* instrument number */
+ } number;
+
+ char *name; /* name of this instrument or NULL */
+
+ unsigned int mode:8, /* see to GUS_INSTR_XXXX */
+ flags:8, /* see to GUS_INSTR_F_XXXX */
+ exclusion:4, /* see to GUS_INSTR_E_XXXX */
+ layer:4; /* see to GUS_INSTR_L_XXXX */
+ unsigned short exclusion_group; /* 0 - none, 1-65535 */
+
+ struct {
+ unsigned char effect1:4,/* use global effect if available */
+ effect2:4; /* use global effect if available */
+ unsigned char effect1_depth;/* 0-127 */
+ unsigned char effect2_depth;/* 0-127 */
+ } patch;
+
+ union {
+ gus_layer_t *layer; /* first layer */
+ unsigned int alias; /* pointer to instrument */
+ } info;
+ gus_instrument_t *next; /* next instrument */
+};
+
+struct _gus_layer_t {
+ unsigned char mode; /* see to GUS_INSTR_XXXX constants */
+
+ gus_wave_t *wave;
+ gus_layer_t *next;
+};
+
+/* bits for format variable in gus_wave_t */
+
+#define GUS_WAVE_16BIT 0x0001 /* 16-bit wave */
+#define GUS_WAVE_UNSIGNED 0x0002 /* unsigned wave */
+#define GUS_WAVE_INVERT 0x0002 /* same as unsigned wave */
+#define GUS_WAVE_BACKWARD 0x0004 /* forward mode */
+#define GUS_WAVE_LOOP 0x0008 /* loop mode */
+#define GUS_WAVE_BIDIR 0x0010 /* bidirectional mode */
+#define GUS_WAVE_ULAW 0x0020 /* uLaw compressed wave */
+#define GUS_WAVE_RAM 0x0040 /* wave is _preloaded_ in RAM (it is used for ROM simulation) */
+#define GUS_WAVE_ROM 0x0080 /* wave is in ROM */
+#define GUS_WAVE_DELTA 0x0100
+
+#define GUS_WAVE_PATCH_ENVELOPE 0x01 /* envelopes on */
+#define GUS_WAVE_PATCH_SUSTAIN 0x02 /* sustain mode */
+
+struct _gus_wave_t {
+ unsigned char mode; /* see to GUS_INSTR_XXXX constants */
+ unsigned char format; /* see to GUS_WAVE_XXXX constants */
+ unsigned int size; /* size of waveform in bytes */
+ unsigned int start; /* start offset in bytes * 16 (lowest 4 bits - fraction) */
+ unsigned int loop_start; /* bits loop start offset in bytes * 16 (lowest 4 bits - fraction) */
+ unsigned int loop_end; /* loop start offset in bytes * 16 (lowest 4 bits - fraction) */
+ unsigned short loop_repeat; /* loop repeat - 0 = forever */
+ struct {
+ unsigned int memory; /* begin of waveform in GUS's memory */
+ unsigned char *ptr; /* pointer to waveform in system memory */
+ } begin;
+
+ struct {
+ unsigned char flags;
+ unsigned int sample_rate;
+ unsigned int low_frequency;/* low frequency range for this waveform */
+ unsigned int high_frequency;/* high frequency range for this waveform */
+ unsigned int root_frequency;/* root frequency for this waveform */
+ signed short tune;
+ unsigned char balance;
+ unsigned char envelope_rate[6];
+ unsigned char envelope_offset[6];
+ unsigned char tremolo_sweep;
+ unsigned char tremolo_rate;
+ unsigned char tremolo_depth;
+ unsigned char vibrato_sweep;
+ unsigned char vibrato_rate;
+ unsigned char vibrato_depth;
+ unsigned short scale_frequency;
+ unsigned short scale_factor;/* 0-2048 or 0-2 */
+ } patch;
+
+ gus_wave_t *next;
+};
+
+/* defines for gus_memory_reset () */
+#define GUS_DOWNLOAD_MODE_NORMAL 0x0000
+#define GUS_DOWNLOAD_MODE_TEST 0x0001
+
+/*
+ A subset of libgus functions (used by MikMod Ultrasound driver)
+*/
+int gus_cards(void);
+ /*
+ * return value: number of GUS cards installed in system or
+ * zero if driver isn't installed
+ */
+int gus_close(int card);
+ /*
+ * close file (gus synthesizer) previously opened with gusOpen function
+ * return value: zero if success
+ */
+int gus_do_flush(void);
+ /*
+ * return value: zero if command queue was successfully flushed
+ * in non block mode - number of written bytes
+ */
+void gus_do_tempo(unsigned int tempo);
+ /*
+ * set new tempo
+ */
+void gus_do_voice_frequency(unsigned char voice, unsigned int freq);
+ /*
+ * set voice frequency in Hz
+ */
+void gus_do_voice_pan(unsigned char voice, unsigned short pan);
+ /*
+ * set voice pan (0-16384) (full left - full right)
+ */
+void gus_do_voice_start(unsigned char voice, unsigned int program,
+ unsigned int freq, unsigned short volume,
+ unsigned short pan);
+ /*
+ * start voice
+ * voice : voice #
+ * program : program # or ~0 = current
+ * freq : frequency in Hz
+ * volume : volume level (0-16384) or ~0 = current
+ * pan : pan level (0-16384) or ~0 = current
+ */
+void gus_do_voice_start_position(unsigned char voice, unsigned int program,
+ unsigned int freq, unsigned short volume,
+ unsigned short pan, unsigned int position);
+ /*
+ * start voice
+ * voice : voice #
+ * program : program # or ~0 = current
+ * freq : frequency in Hz
+ * volume : volume level (0-16384) or ~0 = current
+ * pan : pan level (0-16384) or ~0 = current
+ * position : offset to wave in bytes * 16 (lowest 4 bits - fraction)
+ */
+void gus_do_voice_stop(unsigned char voice, unsigned char mode);
+ /*
+ * stop voice
+ * mode = 0 : stop voice now
+ * mode = 1 : disable wave loop and finish it
+ */
+void gus_do_voice_volume(unsigned char voice, unsigned short vol);
+ /*
+ * set voice volume level 0-16384 (linear)
+ */
+void gus_do_wait(unsigned int ticks);
+ /*
+ * wait x ticks - this command is block separator
+ * all commands between blocks are interpreted in the begining of one tick
+ */
+int gus_get_voice_status(int voice);
+ /*
+ * THIS IS NOT A FUNCTION OF ORIGINAL libGUS!
+ * Return voice status: -1 on error, 0 if voice stopped, 1 if playing
+ */
+int gus_get_handle(void);
+ /*
+ * return value: file handle (descriptor) for /dev/gus
+ */
+int gus_info(gus_info_t * info, int reread);
+ /*
+ * return value: filled info variable with actual values
+ * (look at gus.h header file for more informations)
+ * version field: 0x0024 - GUS revision 2.4
+ * 0x0035 - GUS revision 3.7 with flipped mixer channels
+ * 0x0037 - GUS revision 3.7
+ * 0x0090 - GUS ACE
+ * 0x00a0 - GUS MAX revision 10
+ * 0x00a1 - GUS MAX revision 11
+ * 0x0100 - InterWave (full version)
+ * flags field: see to GUS_STRU_INFO_F_???? constants (gus.h header file)
+ * port field: port number (for example 0x220)
+ * irq field: irq number (for example 11)
+ * dma1 field: dma1 number (for example 5)
+ * dma2 field: dma2 number (for example 6)
+ * note: dma1 and dma2 could be same in case of only one dma channel used
+ */
+int gus_memory_alloc(gus_instrument_t * instrument);
+ /*
+ * input value: look at gus.h for more details about gus_instrument_t structure
+ * return value: zero if instrument was successfully allocated
+ */
+int gus_memory_free(gus_instrument_t * instrument);
+ /*
+ * input value: look at gus.h for more details about gus_instrument_t structure
+ * return value: zero if instrument was successfully removed
+ */
+int gus_memory_size(void);
+ /*
+ * return value: gus memory size in bytes
+ */
+int gus_memory_free_size(void);
+ /*
+ * return value: unused gus memory in bytes
+ * warning: reset function must be called before
+ */
+int gus_memory_free_block(int w_16bit);
+ /*
+ * return value: current largest free block for 8-bit or 16-bit wave
+ */
+int gus_memory_pack(void);
+ /*
+ * return value: zero if success
+ */
+int gus_memory_reset(int mode);
+ /*
+ * input value: see to GUS_DOWNLOAD_MODE_XXXX constants (gus.h)
+ * return value: zero if samples & instruments was successfully removed
+ * from GF1 memory manager
+ */
+
+int gus_open(int card, size_t queue_buffer_size, int non_block);
+ /*
+ * input values: card number,
+ * size of command queue buffer (512-1MB)
+ * buffer is allocated dynamically,
+ * non block mode
+ * return value: zero if success
+ * note 1: this function must be called as first
+ * open file /dev/gus
+ * note 2: you can open more cards with one process
+ */
+int gus_queue_flush(void);
+ /*
+ * return value: zero if command queue was successfully flushed
+ */
+int gus_queue_read_set_size(int items);
+ /*
+ * input value: echo buffer size in items (if 0 - erase echo buffer)
+ */
+int gus_queue_write_set_size(int items);
+ /*
+ * input value: write queue size in items (each item have 8 bytes)
+ */
+int gus_reset(int voices, unsigned int channel_voices);
+ /*
+ * input values: active voices and channel voices (for dynamic allocation)
+ * return value: number of active voices if reset was successfull (GF1 chip active)
+ */
+int gus_reset_engine_only(void);
+ /*
+ * return value: same as gus_reset function
+ * note: this command doesn't change number of active
+ * voices and doesn't do hardware reset
+ */
+int gus_select(int card);
+ /*
+ * select specified card
+ * return value: zero if success
+ */
+int gus_timer_start(void);
+ /*
+ * return value: zero if successfull
+ */
+int gus_timer_stop(void);
+ /*
+ * return value: zero if timer was stoped
+ */
+int gus_timer_continue(void);
+ /*
+ * return value: zero if timer will be continue
+ */
+int gus_timer_tempo(int ticks);
+ /*
+ * return value: zero if setup was success
+ */
+int gus_timer_base(int base);
+ /*
+ * return value: zero if setup was success (default timebase = 100)
+ */
+
+void gus_convert_delta(unsigned int type, unsigned char *dest,
+ unsigned char *src, size_t size);
+ /*
+ * note: dest and src pointers can be equal
+ */
+
+void gus_timer_callback(void (*timer_callback) ());
+ /*
+ * Set a callback to be called once per tempo tick
+ */
+
+int gus_dma_usage (int use);
+ /*
+ * Tell GUS library to use/to not use DMA for sample transfer.
+ * In some environments/on some hardware platforms you will need
+ * to disable DMA in order to function properly. You should call
+ * this function before opening the card.
+ */
+
+#endif /* __LIBGUS_H__ */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Driver for no output
+
+==============================================================================*/
+
+/*
+
+ Written by Jean-Paul Mikkers <mikmak@via.nl>
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "mikmod_internals.h"
+
+#define ZEROLEN 32768
+
+static SBYTE *zerobuf=NULL;
+
+static BOOL NS_IsThere(void)
+{
+ return 1;
+}
+
+static int NS_Init(void)
+{
+ zerobuf=(SBYTE*)MikMod_malloc(ZEROLEN);
+ return VC_Init();
+}
+
+static void NS_Exit(void)
+{
+ VC_Exit();
+ MikMod_free(zerobuf);
+ zerobuf=NULL;
+}
+
+static void NS_Update(void)
+{
+ if (zerobuf)
+ VC_WriteBytes(zerobuf,ZEROLEN);
+}
+
+MIKMODAPI MDRIVER drv_nos={
+ NULL,
+ "No Sound",
+ "Nosound Driver v3.0",
+ 255,255,
+ "nosound",
+ NULL,
+ NULL,
+ NS_IsThere,
+ VC_SampleLoad,
+ VC_SampleUnload,
+ VC_SampleSpace,
+ VC_SampleLength,
+ NS_Init,
+ NS_Exit,
+ NULL,
+ VC_SetNumVoices,
+ VC_PlayStart,
+ VC_PlayStop,
+ NS_Update,
+ NULL,
+ VC_VoiceSetVolume,
+ VC_VoiceGetVolume,
+ VC_VoiceSetFrequency,
+ VC_VoiceGetFrequency,
+ VC_VoiceSetPanning,
+ VC_VoiceGetPanning,
+ VC_VoicePlay,
+ VC_VoiceStop,
+ VC_VoiceStopped,
+ VC_VoiceGetPosition,
+ VC_VoiceRealVolume
+};
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Driver for output on Linux and FreeBSD Open Sound System (OSS) (/dev/dsp)
+
+==============================================================================*/
+
+/*
+
+ Written by Chris Conn <cconn@tohs.abacom.com>
+
+ Extended by Miodrag Vallat:
+ - compatible with all OSS/Voxware versions on Linux/i386, at least
+ - support for uLaw output (for sparc systems)
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+#ifdef DRV_OSS
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <errno.h>
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#ifdef HAVE_SYS_SOUNDCARD_H
+#include <sys/soundcard.h> /* Linux and newer BSD versions - OSS standart */
+#elif defined(HAVE_MACHINE_SOUNDCARD_H)
+#include <machine/soundcard.h> /* Some old BSD versions */
+#elif defined(HAVE_SOUNDCARD_H)
+#include <soundcard.h> /* Some old BSD versions and also newer OpenBSD versions */
+#endif
+
+/* Compatibility with old versions of OSS
+ (Voxware <= 2.03, Linux kernel < 1.1.31) */
+#ifndef AFMT_S16_LE
+#define AFMT_S16_LE 16
+#endif
+#ifndef AFMT_S16_BE
+#define AFMT_S16_BE 0x20
+#endif
+#ifndef AFMT_U8
+#define AFMT_U8 8
+#endif
+#ifndef SNDCTL_DSP_SETFMT
+#define SNDCTL_DSP_SETFMT SNDCTL_DSP_SAMPLESIZE
+#endif
+
+/* Compatibility with not-so-old versions of OSS
+ (OSS < 3.7, Linux kernel < 2.1.16) */
+#ifndef AFMT_S16_NE
+#if defined(_AIX) || defined(AIX) || defined(sparc) || defined(HPPA) || defined(PPC)
+#define AFMT_S16_NE AFMT_S16_BE
+#else
+#define AFMT_S16_NE AFMT_S16_LE
+#endif
+#endif
+
+/* Compatibility with OSS 4.x: AFMT_FLOAT is documented
+ as "not recommended" on the OSS website. This post
+ on the OSS mailing lists says: "In general AFMT_FLOAT
+ is not supported by OSS except in some special cases."
+ (http://sf.net/p/opensound/mailman/message/28840674/) */
+#ifndef AFMT_FLOAT
+#define AFMT_FLOAT 0x00004000
+#endif
+
+static int sndfd=-1;
+static SBYTE *audiobuffer=NULL;
+static int buffersize;
+static int play_precision;
+
+#define DEFAULT_CARD 0
+static int card=DEFAULT_CARD;
+
+#ifdef SNDCTL_DSP_SETFRAGMENT
+
+#define DEFAULT_FRAGSIZE 14
+#define DEFAULT_NUMFRAGS 16
+
+static int fragsize=DEFAULT_FRAGSIZE;
+static int numfrags=DEFAULT_NUMFRAGS;
+
+#endif
+
+static void OSS_CommandLine(const CHAR *cmdline)
+{
+ CHAR *ptr;
+
+#ifdef SNDCTL_DSP_SETFRAGMENT
+ if((ptr=MD_GetAtom("buffer",cmdline,0)) != NULL) {
+ fragsize=atoi(ptr);
+ if((fragsize<7)||(fragsize>17)) fragsize=DEFAULT_FRAGSIZE;
+ MikMod_free(ptr);
+ }
+ if((ptr=MD_GetAtom("count",cmdline,0)) != NULL) {
+ numfrags=atoi(ptr);
+ if((numfrags<2)||(numfrags>255)) numfrags=DEFAULT_NUMFRAGS;
+ MikMod_free(ptr);
+ }
+#endif
+ if((ptr=MD_GetAtom("card",cmdline,0)) != NULL) {
+ card = atoi(ptr);
+ if((card<0)||(card>99)) card=DEFAULT_CARD;
+ MikMod_free(ptr);
+ }
+}
+
+static char *OSS_GetDeviceName(void)
+{
+ static char sounddevice[20];
+
+ /* First test for devfs enabled Linux sound devices */
+ if (card)
+ sprintf(sounddevice,"/dev/sound/dsp%d",card);
+ else
+ strcpy(sounddevice,"/dev/sound/dsp");
+ if(!access(sounddevice,F_OK))
+ return sounddevice;
+
+ sprintf(sounddevice,"/dev/dsp%d",card);
+ if (!card) {
+ /* prefer /dev/dsp0 over /dev/dsp, as /dev/dsp might be a symbolic link
+ to something else than /dev/dsp0. Revert to /dev/dsp if /dev/dsp0
+ does not exist. */
+ if(access("/dev/dsp0",F_OK))
+ strcpy(sounddevice,"/dev/dsp");
+ }
+
+ return sounddevice;
+}
+
+static BOOL OSS_IsThere(void)
+{
+ /* under Linux, and perhaps other Unixes, access()ing the device is not
+ enough since it won't fail if the machine doesn't have sound support
+ in the kernel or sound hardware */
+ int fd;
+
+ if((fd=open(OSS_GetDeviceName(),O_WRONLY|O_NONBLOCK))>=0) {
+ close(fd);
+ return 1;
+ }
+ return (errno==EACCES?1:0);
+}
+
+static int OSS_Init_internal(void)
+{
+ int play_stereo,play_rate;
+ int orig_precision,orig_stereo;
+ int formats;
+#if SOUND_VERSION >= 301
+ audio_buf_info buffinf;
+#endif
+
+#ifdef SNDCTL_DSP_GETFMTS
+ /* Ask device for supported formats */
+ if(ioctl(sndfd,SNDCTL_DSP_GETFMTS,&formats)<0) {
+ _mm_errno=MMERR_OPENING_AUDIO;
+ return 1;
+ }
+#else
+ formats=AFMT_S16_NE|AFMT_U8;
+#endif
+
+ orig_precision=play_precision=(md_mode&DMODE_FLOAT)? AFMT_FLOAT :
+ (md_mode&DMODE_16BITS)? AFMT_S16_NE : AFMT_U8;
+
+ /* Device does not support the format we would prefer... */
+ if(!(formats & play_precision)) {
+ if(play_precision==AFMT_FLOAT) {
+ _mm_errno=MMERR_NO_FLOAT32;
+ return 1;
+ }
+ /* We could try 8 bit sound if available */
+ if(play_precision==AFMT_S16_NE &&(formats&AFMT_U8)) {
+ _mm_errno=MMERR_8BIT_ONLY;
+ return 1;
+ }
+#ifdef AFMT_MU_LAW
+ /* We could try uLaw if available */
+ if(formats&AFMT_MU_LAW) {
+ if((md_mode&DMODE_STEREO)||(md_mode&DMODE_16BITS)||
+ md_mixfreq!=8000) {
+ _mm_errno=MMERR_ULAW;
+ return 1;
+ } else
+ orig_precision=play_precision=AFMT_MU_LAW;
+ } else
+#endif
+ /* Otherwise, just abort */
+ {
+ _mm_errno=MMERR_OSS_SETSAMPLESIZE;
+ return 1;
+ }
+ }
+
+ if((ioctl(sndfd,SNDCTL_DSP_SETFMT,&play_precision)<0)||
+ (orig_precision!=play_precision)) {
+ _mm_errno=MMERR_OSS_SETSAMPLESIZE;
+ return 1;
+ }
+#ifdef SNDCTL_DSP_CHANNELS
+ orig_stereo=play_stereo=(md_mode&DMODE_STEREO)?2:1;
+ if((ioctl(sndfd,SNDCTL_DSP_CHANNELS,&play_stereo)<0)||
+ (orig_stereo!=play_stereo)) {
+ _mm_errno=MMERR_OSS_SETSTEREO;
+ return 1;
+ }
+#else
+ orig_stereo=play_stereo=(md_mode&DMODE_STEREO)?1:0;
+ if((ioctl(sndfd,SNDCTL_DSP_STEREO,&play_stereo)<0)||
+ (orig_stereo!=play_stereo)) {
+ _mm_errno=MMERR_OSS_SETSTEREO;
+ return 1;
+ }
+#endif
+
+ play_rate=md_mixfreq;
+ if((ioctl(sndfd,SNDCTL_DSP_SPEED,&play_rate)<0)) {
+ _mm_errno=MMERR_OSS_SETSPEED;
+ return 1;
+ }
+ md_mixfreq=play_rate;
+
+#if SOUND_VERSION >= 301
+ /* This call fails on Linux/PPC */
+ if((ioctl(sndfd,SNDCTL_DSP_GETOSPACE,&buffinf)<0))
+ ioctl(sndfd,SNDCTL_DSP_GETBLKSIZE,&buffinf.fragsize);
+ if(!(audiobuffer=(SBYTE*)MikMod_malloc(buffinf.fragsize)))
+ return 1;
+
+ buffersize = buffinf.fragsize;
+#else
+ ioctl(sndfd,SNDCTL_DSP_GETBLKSIZE,&buffersize);
+ if(!(audiobuffer=(SBYTE*)MikMod_malloc(buffersize)))
+ return 1;
+#endif
+
+ return VC_Init();
+}
+
+static int OSS_Init(void)
+{
+#ifdef SNDCTL_DSP_SETFRAGMENT
+ int fragmentsize;
+#endif
+
+ if((sndfd=open(OSS_GetDeviceName(),O_WRONLY))<0) {
+ _mm_errno=MMERR_OPENING_AUDIO;
+ return 1;
+ }
+
+#ifdef SNDCTL_DSP_SETFRAGMENT
+ if((fragsize==DEFAULT_FRAGSIZE)&&(getenv("MM_FRAGSIZE"))) {
+ fragsize=atoi(getenv("MM_FRAGSIZE"));
+ if((fragsize<7)||(fragsize>17)) fragsize=DEFAULT_FRAGSIZE;
+ }
+ if((numfrags==DEFAULT_NUMFRAGS)&&(getenv("MM_NUMFRAGS"))) {
+ numfrags=atoi(getenv("MM_NUMFRAGS"));
+ if((numfrags<2)||(numfrags>255)) numfrags=DEFAULT_NUMFRAGS;
+ }
+
+ fragmentsize=(numfrags<<16)|fragsize;
+
+ if(ioctl(sndfd,SNDCTL_DSP_SETFRAGMENT,&fragmentsize)<0) {
+ _mm_errno=MMERR_OSS_SETFRAGMENT;
+ return 1;
+ }
+#endif
+
+ return OSS_Init_internal();
+}
+
+static void OSS_Exit_internal(void)
+{
+ VC_Exit();
+ MikMod_free(audiobuffer);
+ audiobuffer = NULL;
+}
+
+static void OSS_Exit(void)
+{
+ OSS_Exit_internal();
+
+ if (sndfd>=0) {
+ close(sndfd);
+ sndfd=-1;
+ }
+}
+
+static void OSS_PlayStop(void)
+{
+ VC_PlayStop();
+
+ ioctl(sndfd,SNDCTL_DSP_POST,0);
+}
+
+static void OSS_Update(void)
+{
+ int done;
+
+#if SOUND_VERSION >= 301
+ audio_buf_info buffinf;
+
+ buffinf.fragments = 2;
+ for(;;) {
+ /* This call fails on Linux/PPC */
+ if ((ioctl(sndfd,SNDCTL_DSP_GETOSPACE,&buffinf)<0)) {
+ buffinf.fragments--;
+ buffinf.fragsize = buffinf.bytes = buffersize;
+ }
+ if(!buffinf.fragments)
+ break;
+ done=VC_WriteBytes(audiobuffer,buffinf.fragsize>buffinf.bytes?
+ buffinf.bytes:buffinf.fragsize);
+#ifdef AFMT_MU_LAW
+ if (play_precision==AFMT_MU_LAW)
+ unsignedtoulaw((char *)audiobuffer,done);
+#endif
+ write(sndfd,audiobuffer,done);
+ }
+#else
+ done=VC_WriteBytes(audiobuffer,buffersize);
+#ifdef AFMT_MU_LAW
+ if (play_precision==AFMT_MU_LAW)
+ unsignedtoulaw(audiobuffer,done);
+#endif
+ write(sndfd,audiobuffer,done);
+#endif
+}
+
+static int OSS_Reset(void)
+{
+ OSS_Exit_internal();
+ ioctl(sndfd,SNDCTL_DSP_RESET,0);
+ return OSS_Init_internal();
+}
+
+MIKMODAPI MDRIVER drv_oss={
+ NULL,
+ "Open Sound System",
+ "Open Sound System driver v1.7",
+ 0,255,
+ "oss",
+#ifdef SNDCTL_DSP_SETFRAGMENT
+ "buffer:r:7,17,14:Audio buffer log2 size\n"
+ "count:r:2,255,16:Audio buffer count\n"
+#endif
+ "card:r:0,99,0:Sound card id\n",
+ OSS_CommandLine,
+ OSS_IsThere,
+ VC_SampleLoad,
+ VC_SampleUnload,
+ VC_SampleSpace,
+ VC_SampleLength,
+ OSS_Init,
+ OSS_Exit,
+ OSS_Reset,
+ VC_SetNumVoices,
+ VC_PlayStart,
+ OSS_PlayStop,
+ OSS_Update,
+ NULL,
+ VC_VoiceSetVolume,
+ VC_VoiceGetVolume,
+ VC_VoiceSetFrequency,
+ VC_VoiceGetFrequency,
+ VC_VoiceSetPanning,
+ VC_VoiceGetPanning,
+ VC_VoicePlay,
+ VC_VoiceStop,
+ VC_VoiceStopped,
+ VC_VoiceGetPosition,
+ VC_VoiceRealVolume
+};
+
+#else
+
+MISSING(drv_oss);
+
+#endif
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Driver for SoundBlaster/Pro/16/AWE32 under DOS
+
+==============================================================================*/
+
+/*
+
+ Written by Andrew Zabolotny <bit@eltech.ru>
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DRV_SB
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+#include "mikmod_internals.h"
+
+#include "dossb.h"
+
+static void SB_CommandLine(const CHAR *cmdline)
+{
+ char *ptr, *end;
+
+ if ((ptr=MD_GetAtom("port",cmdline,0)) != NULL) {
+ sb.port = strtol(ptr, &end, 16);
+ MikMod_free(ptr);
+ }
+ if ((ptr=MD_GetAtom("irq",cmdline,0)) != NULL) {
+ sb.irq = strtol(ptr, &end, 10);
+ MikMod_free(ptr);
+ }
+ if ((ptr=MD_GetAtom("dma",cmdline,0)) != NULL) {
+ sb.dma8 = strtol(ptr, &end, 10);
+ MikMod_free(ptr);
+ }
+ if ((ptr=MD_GetAtom("hidma",cmdline,0)) != NULL) {
+ sb.dma16 = strtol(ptr, &end, 10);
+ MikMod_free(ptr);
+ }
+}
+
+static BOOL SB_IsThere(void)
+{
+ return sb_detect();
+}
+
+static int SB_Init(void)
+{
+ if (!sb_open()) {
+ _mm_errno = MMERR_INVALID_DEVICE;
+ return 1;
+ }
+
+ /* Adjust md_mode according to sound card capabilities */
+ if (!(sb.caps & SBMODE_STEREO))
+ md_mode &= ~DMODE_STEREO;
+ if (!(sb.caps & SBMODE_16BITS))
+ md_mode &= ~DMODE_16BITS;
+
+ if (md_mixfreq < 4000)
+ md_mixfreq = 4000;
+ if (md_mode & DMODE_STEREO) {
+ if (md_mixfreq > sb.maxfreq_stereo)
+ md_mixfreq = sb.maxfreq_stereo;
+ } else {
+ if (md_mixfreq > sb.maxfreq_mono)
+ md_mixfreq = sb.maxfreq_mono;
+ }
+
+ return VC_Init();
+}
+
+static void SB_Exit(void)
+{
+ VC_Exit();
+ sb_close();
+}
+
+/* The last buffer byte filled with sound */
+static unsigned int buff_tail = 0;
+
+static void SB_Callback(void)
+{
+ unsigned int dma_size, dma_pos;
+ ULONG (*mixer)(SBYTE *buf, ULONG todo);
+
+ sb_query_dma(&dma_size, &dma_pos);
+ /* There isn't much sense in filling less than 256 bytes */
+ dma_pos &= ~255;
+
+ /* If nothing to mix, quit */
+ if (buff_tail == dma_pos)
+ return;
+
+ if (Player_Paused_internal())
+ mixer = VC_SilenceBytes;
+ else
+ mixer = VC_WriteBytes;
+
+ /* If DMA pointer still didn't wrapped around ... */
+ if (dma_pos > buff_tail) {
+ buff_tail += mixer ((SBYTE *)(sb.dma_buff->linear + buff_tail), dma_pos - buff_tail);
+ /* If we arrived right to the DMA buffer end, jump to the beginning */
+ if (buff_tail >= dma_size)
+ buff_tail = 0;
+ } else {
+ /* If wrapped around, fill first to the end of buffer */
+ mixer ((SBYTE *)(sb.dma_buff->linear + buff_tail), dma_size - buff_tail);
+ /* Now fill from buffer beginning to current DMA pointer */
+ buff_tail = mixer ((SBYTE *)sb.dma_buff->linear, dma_pos);
+ }
+}
+
+static void SB_Update(void)
+{
+ /* Do nothing: the real update is done during SB interrupts */
+}
+
+static int SB_PlayStart (void)
+{
+ if (VC_PlayStart())
+ return 1;
+
+ /* Enable speaker output */
+ sb_output(TRUE);
+
+ /* Set our routine to be called during SB IRQs */
+ buff_tail = 0;
+ sb.timer_callback = SB_Callback;
+
+ /* Start cyclic DMA transfer */
+ if (!sb_start_dma(((md_mode & DMODE_16BITS) ? SBMODE_16BITS | SBMODE_SIGNED : 0) |
+ ((md_mode & DMODE_STEREO) ? SBMODE_STEREO : 0), md_mixfreq))
+ {
+ _mm_errno = MMERR_DOSSB_STARTDMA;
+ return 1;
+ }
+
+ return 0;
+}
+
+static int SB_Reset(void)
+{
+ sb_reset();
+ VC_Exit();
+ return VC_Init();
+}
+
+static void SB_PlayStop(void)
+{
+ sb.timer_callback = NULL;
+ sb_output(FALSE);
+ sb_stop_dma();
+ VC_PlayStop();
+}
+
+MDRIVER drv_sb =
+{
+ NULL,
+ "Sound Blaster",
+ "Sound Blaster Orig/2.0/Pro/16 v1.0",
+ 0, 255,
+ "sb",
+ "port:c:220,230,240,250,260,270,280,32C,530,604,E80,F40,220:Sound Blaster base I/O port\n"
+ "irq:c:2,3,5,7,10,5:Sound Blaster IRQ\n"
+ "dma:c:0,1,3,1:Sound Blaster 8 bit DMA channel\n"
+ "hidma:c:5,6,7,5:Sound Blaster 16 bit DMA channel (SB16/AWE32 only)\n",
+
+ SB_CommandLine,
+ SB_IsThere,
+ VC_SampleLoad,
+ VC_SampleUnload,
+ VC_SampleSpace,
+ VC_SampleLength,
+ SB_Init,
+ SB_Exit,
+ SB_Reset,
+ VC_SetNumVoices,
+ SB_PlayStart,
+ SB_PlayStop,
+ SB_Update,
+ NULL,
+ VC_VoiceSetVolume,
+ VC_VoiceGetVolume,
+ VC_VoiceSetFrequency,
+ VC_VoiceGetFrequency,
+ VC_VoiceSetPanning,
+ VC_VoiceGetPanning,
+ VC_VoicePlay,
+ VC_VoiceStop,
+ VC_VoiceStopped,
+ VC_VoiceGetPosition,
+ VC_VoiceRealVolume
+};
+
+#else /* DRV_SB */
+
+#include "mikmod_internals.h"
+MISSING(drv_sb);
+
+#endif
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998-2005 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+ */
+
+/*==============================================================================
+
+ libmikmod driver for audio output on SDL-supported platforms.
+ Initially written by Paul Spark <sparkynz74@gmail.com>
+ Rewrite/major fixes by O. Sezer <sezero@users.sourceforge.net>
+
+ ==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+#ifdef DRV_SDL
+
+#include <string.h>
+#if defined(SDL_FRAMEWORK) || defined(NO_SDL_CONFIG)
+#include <SDL/SDL.h>
+#else
+#include "SDL.h"
+#endif
+
+#define NUMSAMPLES 256 /* a fair default for md_mixfreq <= 11025 Hz */
+static SDL_AudioSpec spec;
+static int enabled = 0;
+
+static void SDLSoundCallback(void *userdata, Uint8 *stream, int len)
+{
+ if (!enabled) return;
+ if (enabled < 0) {
+ if (++enabled == 0)
+ enabled = 1;
+ return;
+ }
+
+ MUTEX_LOCK(vars);
+ if (Player_Paused_internal()) {
+ VC_SilenceBytes((SBYTE *) stream, (ULONG)len);
+ }
+ else
+ {
+ int got = (int) VC_WriteBytes((SBYTE *) stream, (ULONG)len);
+ if (got < len) { /* fill the rest with silence, then */
+ VC_SilenceBytes((SBYTE *) &stream[got], (ULONG)(len-got));
+ }
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+static BOOL SetupSDLAudio(void)
+{
+ SDL_AudioSpec wanted;
+
+ wanted.freq = md_mixfreq;
+ wanted.format =
+#if (SDL_MAJOR_VERSION >= 2)
+ (md_mode & DMODE_FLOAT) ? AUDIO_F32SYS :
+#endif
+ (md_mode & DMODE_16BITS)? AUDIO_S16SYS : AUDIO_U8;
+ wanted.channels = (md_mode & DMODE_STEREO)? 2 : 1;
+ wanted.samples = (md_mixfreq <= 11025)? (NUMSAMPLES ) :
+ (md_mixfreq <= 22050)? (NUMSAMPLES * 2) :
+ (md_mixfreq <= 44100)? (NUMSAMPLES * 4) :
+ (NUMSAMPLES * 8);
+ wanted.userdata = NULL;
+ wanted.callback = SDLSoundCallback;
+
+ if (SDL_OpenAudio(&wanted, &spec) < 0) {
+ _mm_errno=MMERR_OPENING_AUDIO;
+ return 0;
+ }
+
+ return 1;
+}
+
+static BOOL SDLDrv_IsPresent(void)
+{
+ if ((SDL_WasInit(SDL_INIT_AUDIO)) == 0) {
+ if (SDL_Init(SDL_INIT_AUDIO) < 0)
+ return 0;
+ SDL_QuitSubSystem(SDL_INIT_AUDIO);
+ }
+ return 1;
+}
+
+static int SDLDrv_Init(void)
+{
+#if (SDL_MAJOR_VERSION < 2)
+ if (md_mode & DMODE_FLOAT) {
+ _mm_errno=MMERR_NO_FLOAT32;
+ return 1;
+ }
+#endif
+ if (SDL_Init(SDL_INIT_AUDIO) < 0) {
+ _mm_errno=MMERR_OPENING_AUDIO;
+ return 1;
+ }
+ if (!SetupSDLAudio()) {
+ return 1;
+ }
+
+ md_mode |= DMODE_SOFT_MUSIC;
+ if (VC_Init())
+ return 1;
+
+ enabled = -2; /* delay the callback 2 frames */
+ return 0;
+}
+
+static void SDLDrv_Exit(void)
+{
+ SDL_LockAudio();
+ enabled = 0;
+ SDL_UnlockAudio();
+ SDL_CloseAudio();
+ VC_Exit();
+}
+
+static int SDLDrv_Reset(void)
+{
+ SDLDrv_Exit();
+ return SDLDrv_Init();
+}
+
+static void SDLDrv_Update( void )
+{
+/* do nothing */
+}
+
+static void SDLDrv_PlayStop(void)
+{
+ SDL_PauseAudio(1);
+ VC_PlayStop();
+}
+
+static int SDLDrv_PlayStart(void)
+{
+ if (VC_PlayStart())
+ return 1;
+ SDL_PauseAudio(0);
+ return 0;
+}
+
+MIKMODAPI struct MDRIVER drv_sdl =
+{
+ NULL,
+ "SDL",
+ "SDL Driver v1.3",
+ 0,255,
+ "sdl",
+ NULL,
+ NULL,
+ SDLDrv_IsPresent,
+ VC_SampleLoad,
+ VC_SampleUnload,
+ VC_SampleSpace,
+ VC_SampleLength,
+ SDLDrv_Init,
+ SDLDrv_Exit,
+ SDLDrv_Reset,
+ VC_SetNumVoices,
+ SDLDrv_PlayStart,
+ SDLDrv_PlayStop,
+ SDLDrv_Update,
+ NULL,
+ VC_VoiceSetVolume,
+ VC_VoiceGetVolume,
+ VC_VoiceSetFrequency,
+ VC_VoiceGetFrequency,
+ VC_VoiceSetPanning,
+ VC_VoiceGetPanning,
+ VC_VoicePlay,
+ VC_VoiceStop,
+ VC_VoiceStopped,
+ VC_VoiceGetPosition,
+ VC_VoiceRealVolume
+};
+
+#else
+
+MISSING(drv_sdl);
+
+#endif
+
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Driver for Gravis Ultrasound cards using libGUS.
+ A subset of libGUS is provided for DOS/DJGPP and OS/2
+
+==============================================================================*/
+
+/*
+
+ Written by Andy Lo A Foe <andy@alsa-project.org>
+
+ Updated to work with later versions of both the ultrasound driver and
+ libmikmod by C. Ray C. <crayc@pyro.net>
+
+ Major fixes by Andrew Zabolotny <bit@eltech.ru>
+ + Ported to OS/2 and DOS.
+ + Eight-bit samples are not converted to 16-bit anymore.
+ + Samples are no longer kept in normal memory.
+ + Removed sample 'unclick' logic... libGUS does unclick internally.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+#ifdef DRV_ULTRA
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+
+#ifdef MIKMOD_DYNAMIC
+#include <dlfcn.h>
+#endif
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libgus.h>
+
+#if !defined(GUS_INSTR_SIMPLE) || !defined(GUS_WAVE_BIDIR)
+#error libgus version is too old
+#endif
+/* just in case */
+#ifndef LIBGUS_VERSION_MAJOR
+#define LIBGUS_VERSION_MAJOR 0x0003
+#endif
+
+/* DOS/DJGPP and OS/2 libGUS'es have gus_get_voice_status() */
+#if defined(__EMX__) || defined(__DJGPP__)
+#define HAVE_VOICE_STATUS
+#else
+#include <time.h>
+#endif
+
+
+#ifdef MIKMOD_DYNAMIC
+/* runtime link with libgus */
+static int (*_libgus_cards) (void);
+
+#if LIBGUS_VERSION_MAJOR < 0x0004
+static int (*_libgus_close) (int);
+static int (*_libgus_do_flush) (void);
+static void (*_libgus_do_tempo) (unsigned int);
+static void (*_libgus_do_voice_frequency) (unsigned char, unsigned int);
+static void (*_libgus_do_voice_pan) (unsigned char, unsigned short);
+static void (*_libgus_do_voice_start) (unsigned char, unsigned int,
+ unsigned int, unsigned short,
+ unsigned short);
+static void (*_libgus_do_voice_start_position) (unsigned char, unsigned int,
+ unsigned int, unsigned short,
+ unsigned short, unsigned int);
+static void (*_libgus_do_voice_stop) (unsigned char, unsigned char);
+static void (*_libgus_do_voice_volume) (unsigned char, unsigned short);
+static void (*_libgus_do_wait) (unsigned int);
+static int (*_libgus_get_handle) (void);
+static int (*_libgus_info) (gus_info_t *, int);
+static int (*_libgus_memory_alloc) (gus_instrument_t *);
+static int (*_libgus_memory_free) (gus_instrument_t *);
+static int (*_libgus_memory_free_size) (void);
+static int (*_libgus_memory_pack) (void);
+static int (*_libgus_open) (int, size_t, int);
+static int (*_libgus_queue_flush) (void);
+static int (*_libgus_queue_read_set_size) (int);
+static int (*_libgus_queue_write_set_size) (int);
+static int (*_libgus_reset) (int, unsigned int);
+static int (*_libgus_select) (int);
+static int (*_libgus_timer_start) (void);
+static int (*_libgus_timer_stop) (void);
+static int (*_libgus_timer_tempo) (int);
+#else
+static int (*_libgus_close) (void*);
+static int (*_libgus_do_flush) (void*);
+static void (*_libgus_do_tempo) (void*, unsigned int);
+static void (*_libgus_do_voice_frequency) (void*, unsigned char, unsigned int);
+static void (*_libgus_do_voice_pan) (void*, unsigned char,unsigned short);
+static void (*_libgus_do_voice_start) (void*, unsigned char, unsigned int,
+ unsigned int, unsigned short,
+ unsigned short);
+static void (*_libgus_do_voice_start_position) (void*, unsigned char, unsigned int,
+ unsigned int,unsigned short,
+ unsigned short, unsigned int);
+static void (*_libgus_do_voice_stop) (void*, unsigned char, unsigned char);
+static void (*_libgus_do_voice_volume) (void*, unsigned char, unsigned short);
+static void (*_libgus_do_wait) (void*, unsigned int);
+static int (*_libgus_get_file_descriptor) (void*);
+static int (*_libgus_info) (void*, gus_info_t*, int);
+static int (*_libgus_memory_alloc) (void*, gus_instrument_t*);
+static int (*_libgus_memory_free) (void*, gus_instrument_t*);
+static int (*_libgus_memory_free_size) (void*);
+static int (*_libgus_memory_pack) (void*);
+static int (*_libgus_open) (void**, int, int, size_t, int);
+static int (*_libgus_queue_flush) (void*);
+static int (*_libgus_queue_read_set_size) (void*, int);
+static int (*_libgus_queue_write_set_size) (void*, int);
+static int (*_libgus_reset) (void*, int, unsigned int);
+static int (*_libgus_timer_start)(void*);
+static int (*_libgus_timer_stop) (void*);
+static int (*_libgus_timer_tempo) (void*, int);
+#endif
+#ifndef HAVE_RTLD_GLOBAL
+#define RTLD_GLOBAL (0)
+#endif
+static void *libgus = NULL;
+
+#else
+/* compile-time link with libgus */
+#define _libgus_cards gus_cards
+#define _libgus_close gus_close
+#define _libgus_do_flush gus_do_flush
+#define _libgus_do_tempo gus_do_tempo
+#define _libgus_do_voice_frequency gus_do_voice_frequency
+#define _libgus_do_voice_pan gus_do_voice_pan
+#define _libgus_do_voice_start gus_do_voice_start
+#define _libgus_do_voice_start_position gus_do_voice_start_position
+#define _libgus_do_voice_stop gus_do_voice_stop
+#define _libgus_do_voice_volume gus_do_voice_volume
+#define _libgus_do_wait gus_do_wait
+#if LIBGUS_VERSION_MAJOR < 0x0004
+#define _libgus_get_handle gus_get_handle
+#else
+#define _libgus_get_file_descriptor gus_get_file_descriptor
+#endif
+#define _libgus_info gus_info
+#define _libgus_memory_alloc gus_memory_alloc
+#define _libgus_memory_free gus_memory_free
+#define _libgus_memory_free_size gus_memory_free_size
+#define _libgus_memory_pack gus_memory_pack
+#define _libgus_open gus_open
+#define _libgus_queue_flush gus_queue_flush
+#define _libgus_queue_read_set_size gus_queue_read_set_size
+#define _libgus_queue_write_set_size gus_queue_write_set_size
+#define _libgus_reset gus_reset
+#if LIBGUS_VERSION_MAJOR < 0x0004
+#define _libgus_select gus_select
+#endif
+#define _libgus_timer_start gus_timer_start
+#define _libgus_timer_stop gus_timer_stop
+#define _libgus_timer_tempo gus_timer_tempo
+#endif
+
+#define libgus_cards _libgus_cards /* same between v3 and v4 */
+#define libgus_open _libgus_open /* different between v3 and v4: must use #ifdef */
+#define libgus_close _libgus_close /* different between v3 and v4: must use #ifdef */
+/* the following can be handled easily by macros: v4 only adds them the handle as the first param */
+#if LIBGUS_VERSION_MAJOR < 0x0004
+#define libgus_get_handle _libgus_get_handle /* only in v3 */
+#define libgus_do_flush _libgus_do_flush
+#define libgus_do_tempo _libgus_do_tempo
+#define libgus_do_voice_frequency _libgus_do_voice_frequency
+#define libgus_do_voice_pan _libgus_do_voice_pan
+#define libgus_do_voice_start _libgus_do_voice_start
+#define libgus_do_voice_start_position _libgus_do_voice_start_position
+#define libgus_do_voice_stop _libgus_do_voice_stop
+#define libgus_do_voice_volume _libgus_do_voice_volume
+#define libgus_do_wait _libgus_do_wait
+#define libgus_info _libgus_info
+#define libgus_memory_alloc _libgus_memory_alloc
+#define libgus_memory_free _libgus_memory_free
+#define libgus_memory_free_size _libgus_memory_free_size
+#define libgus_memory_pack _libgus_memory_pack
+#define libgus_queue_flush _libgus_queue_flush
+#define libgus_queue_read_set_size _libgus_queue_read_set_size
+#define libgus_queue_write_set_size _libgus_queue_write_set_size
+#define libgus_reset _libgus_reset
+#define libgus_select _libgus_select
+#define libgus_timer_start _libgus_timer_start
+#define libgus_timer_stop _libgus_timer_stop
+#define libgus_timer_tempo _libgus_timer_tempo
+#else
+#define libgus_get_file_descriptor _libgus_get_file_descriptor /* only in v4 */
+#define libgus_do_flush() _libgus_do_flush(ultra_h)
+#define libgus_do_tempo(t) _libgus_do_tempo(ultra_h,t)
+#define libgus_do_voice_frequency(a,b) _libgus_do_voice_frequency(ultra_h,a,b)
+#define libgus_do_voice_pan(a,b) _libgus_do_voice_pan(ultra_h,a,b)
+#define libgus_do_voice_start(a,b,c,d,e) _libgus_do_voice_start(ultra_h,a,b,c,d,e)
+#define libgus_do_voice_start_position(a,b,c,d,e,f) _libgus_do_voice_start_position(ultra_h,a,b,c,d,e,f)
+#define libgus_do_voice_stop(a,b) _libgus_do_voice_stop(ultra_h,a,b)
+#define libgus_do_voice_volume(a,b) _libgus_do_voice_volume(ultra_h,a,b)
+#define libgus_do_wait(a) _libgus_do_wait(ultra_h,a)
+#define libgus_info(a,b) _libgus_info(ultra_h,a,b)
+#define libgus_memory_alloc(a) _libgus_memory_alloc(ultra_h,a)
+#define libgus_memory_free(a) _libgus_memory_free(ultra_h,a)
+#define libgus_memory_free_size() _libgus_memory_free_size(ultra_h)
+#define libgus_memory_pack() _libgus_memory_pack(ultra_h)
+#define libgus_queue_flush() _libgus_queue_flush(ultra_h)
+#define libgus_queue_read_set_size(a) _libgus_queue_read_set_size(ultra_h,a)
+#define libgus_queue_write_set_size(a) _libgus_queue_write_set_size(ultra_h,a)
+#define libgus_reset(a,b) _libgus_reset(ultra_h,a,b)
+#define libgus_timer_start() _libgus_timer_start(ultra_h)
+#define libgus_timer_stop() _libgus_timer_stop(ultra_h)
+#define libgus_timer_tempo(a) _libgus_timer_tempo(ultra_h,a)
+#endif
+
+#define GUS_SAMPLES 256 /* Max. GUS samples loadable */
+#define GUS_CHANNELS 32 /* Max. GUS channels available */
+#define SIZE_OF_SEQBUF (8 * 1024) /* Size of the sequence buffer */
+#define ULTRA_PAN_MIDDLE (16383 >> 1) /* Middle balance position */
+
+#define CH_FREQ 1
+#define CH_VOL 2
+#define CH_PAN 4
+
+/* This structure holds the current state of a GUS voice channel. */
+typedef struct GUS_VOICE {
+ UBYTE kick;
+ UBYTE active;
+ UWORD flags;
+ SWORD handle;
+ ULONG start;
+ ULONG size;
+ ULONG reppos;
+ ULONG repend;
+ ULONG frq;
+ int vol;
+ int decvol;
+ int pan;
+
+ int changes;
+#ifndef HAVE_VOICE_STATUS
+ time_t started;
+#endif
+} GUS_VOICE;
+
+/* Global declarations follow */
+
+static SAMPLE *samples[GUS_SAMPLES]; /* sample handles */
+static GUS_VOICE voices[GUS_CHANNELS]; /* channel status */
+
+static int ultra_dev = 0; /* GUS index, if more than one card */
+#if LIBGUS_VERSION_MAJOR < 0x0004
+static int ultra_card = -1; /* returned by gus_open(ultra_dev,,) - must be same as ultra_dev */
+#else
+static void* ultra_h = NULL; /* GUS handle */
+#endif
+static int ultra_fd = -1; /* GUS file descriptor */
+
+
+#ifdef MIKMOD_DYNAMIC
+static int Ultra_Link(void)
+{
+ if (libgus)
+ return 0;
+
+ /* load libgus.so */
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ libgus = dlopen("libgus.so.3", RTLD_LAZY | RTLD_GLOBAL);
+#else
+ libgus = dlopen("libgus.so.4", RTLD_LAZY | RTLD_GLOBAL);
+#endif
+ if (!libgus) /* then this won't succeed either, but whatever.. */
+ libgus = dlopen("libgus.so", RTLD_LAZY | RTLD_GLOBAL);
+ if (!libgus)
+ return 1;
+
+ /* resolve function references */
+#define IMPORT_SYMBOL(x,ret,params) \
+ if (!(_lib##x = (ret (*)params) dlsym(libgus, #x))) return 1
+
+ IMPORT_SYMBOL(gus_cards, int, (void));
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ IMPORT_SYMBOL(gus_close, int, (int));
+ IMPORT_SYMBOL(gus_do_flush, int, (void));
+ IMPORT_SYMBOL(gus_do_tempo, void, (unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_frequency, void, (unsigned char, unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_pan, void, (unsigned char, unsigned short));
+ IMPORT_SYMBOL(gus_do_voice_start, void, (unsigned char, unsigned int, unsigned int, unsigned short, unsigned short));
+ IMPORT_SYMBOL(gus_do_voice_start_position, void, (unsigned char, unsigned int, unsigned int, unsigned short, unsigned short, unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_stop, void, (unsigned char, unsigned char));
+ IMPORT_SYMBOL(gus_do_voice_volume, void, (unsigned char, unsigned short));
+ IMPORT_SYMBOL(gus_do_wait, void, (unsigned int));
+ IMPORT_SYMBOL(gus_get_handle, int, (void));
+ IMPORT_SYMBOL(gus_info, int, (gus_info_t *, int));
+ IMPORT_SYMBOL(gus_memory_alloc, int, (gus_instrument_t *));
+ IMPORT_SYMBOL(gus_memory_free, int, (gus_instrument_t *));
+ IMPORT_SYMBOL(gus_memory_free_size, int, (void));
+ IMPORT_SYMBOL(gus_memory_pack, int, (void));
+ IMPORT_SYMBOL(gus_open, int, (int, size_t, int));
+ IMPORT_SYMBOL(gus_queue_flush, int, (void));
+ IMPORT_SYMBOL(gus_queue_read_set_size, int, (int));
+ IMPORT_SYMBOL(gus_queue_write_set_size, int, (int));
+ IMPORT_SYMBOL(gus_reset, int, (int, unsigned int));
+ IMPORT_SYMBOL(gus_select, int, (int));
+ IMPORT_SYMBOL(gus_timer_start, int, (void));
+ IMPORT_SYMBOL(gus_timer_stop, int, (void));
+ IMPORT_SYMBOL(gus_timer_tempo, int, (int));
+#else
+ IMPORT_SYMBOL(gus_close, int, (void*));
+ IMPORT_SYMBOL(gus_do_flush, int, (void*));
+ IMPORT_SYMBOL(gus_do_tempo, void, (void*, unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_frequency, void, (void*, unsigned char, unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_pan, void, (void*, unsigned char, unsigned short));
+ IMPORT_SYMBOL(gus_do_voice_start, void, (void*, unsigned char, unsigned int, unsigned int, unsigned short, unsigned short));
+ IMPORT_SYMBOL(gus_do_voice_start_position, void, (void*, unsigned char, unsigned int, unsigned int, unsigned short, unsigned short, unsigned int));
+ IMPORT_SYMBOL(gus_do_voice_stop, void, (void*, unsigned char, unsigned char));
+ IMPORT_SYMBOL(gus_do_voice_volume, void, (void*, unsigned char, unsigned short));
+ IMPORT_SYMBOL(gus_do_wait, void, (void*, unsigned int));
+ IMPORT_SYMBOL(gus_get_file_descriptor, int, (void*));
+ IMPORT_SYMBOL(gus_info, int, (void*, gus_info_t *, int));
+ IMPORT_SYMBOL(gus_memory_alloc, int, (void*, gus_instrument_t *));
+ IMPORT_SYMBOL(gus_memory_free, int, (void*, gus_instrument_t *));
+ IMPORT_SYMBOL(gus_memory_free_size, int, (void*));
+ IMPORT_SYMBOL(gus_memory_pack, int, (void*));
+ IMPORT_SYMBOL(gus_open, int, (void**, int, int, size_t, int));
+ IMPORT_SYMBOL(gus_queue_flush, int, (void*));
+ IMPORT_SYMBOL(gus_queue_read_set_size, int, (void*, int));
+ IMPORT_SYMBOL(gus_queue_write_set_size, int, (void*, int));
+ IMPORT_SYMBOL(gus_reset, int, (void*, int, unsigned int));
+ IMPORT_SYMBOL(gus_timer_start, int, (void*));
+ IMPORT_SYMBOL(gus_timer_stop, int, (void*));
+ IMPORT_SYMBOL(gus_timer_tempo, int, (void*, int));
+#endif
+#undef IMPORT_SYMBOL
+
+ return 0;
+}
+
+static void Ultra_Unlink(void)
+{
+ _libgus_cards = NULL;
+ _libgus_close = NULL;
+ _libgus_do_flush = NULL;
+ _libgus_do_tempo = NULL;
+ _libgus_do_voice_frequency = NULL;
+ _libgus_do_voice_pan = NULL;
+ _libgus_do_voice_start = NULL;
+ _libgus_do_voice_start_position = NULL;
+ _libgus_do_voice_stop = NULL;
+ _libgus_do_voice_volume = NULL;
+ _libgus_do_wait = NULL;
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ _libgus_get_handle = NULL;
+#else
+ _libgus_get_file_descriptor = NULL;
+#endif
+ _libgus_info = NULL;
+ _libgus_memory_alloc = NULL;
+ _libgus_memory_free = NULL;
+ _libgus_memory_free_size = NULL;
+ _libgus_memory_pack = NULL;
+ _libgus_open = NULL;
+ _libgus_queue_flush = NULL;
+ _libgus_queue_read_set_size = NULL;
+ _libgus_queue_write_set_size = NULL;
+ _libgus_reset = NULL;
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ _libgus_select = NULL;
+#endif
+ _libgus_timer_start = NULL;
+ _libgus_timer_stop = NULL;
+ _libgus_timer_tempo = NULL;
+
+ if (libgus) {
+ dlclose(libgus);
+ libgus = NULL;
+ }
+}
+#endif
+
+static void Ultra_CommandLine(const CHAR *cmdline)
+{
+ CHAR *ptr = MD_GetAtom("card", cmdline, 0);
+
+ if (ptr) {
+ int buf = atoi(ptr);
+
+ if (buf >= 0 && buf <= 8)
+ ultra_dev = buf;
+ MikMod_free(ptr);
+ }
+#ifdef __DJGPP__
+ ptr = MD_GetAtom("dma", cmdline, 0);
+ if (ptr) {
+ gus_dma_usage (atoi(ptr));
+ MikMod_free(ptr);
+ }
+#endif
+}
+
+/* Checks for the presence of GUS cards */
+static BOOL Ultra_IsThere(void)
+{
+ BOOL retval;
+
+#ifdef MIKMOD_DYNAMIC
+ if (Ultra_Link())
+ return 0;
+#endif
+ retval = libgus_cards()? 1 : 0;
+#ifdef MIKMOD_DYNAMIC
+ Ultra_Unlink();
+#endif
+ return retval;
+}
+
+/* Load a new sample directly into GUS DRAM and return a handle */
+static SWORD Ultra_SampleLoad(struct SAMPLOAD *sload, int type)
+{
+ int handle;
+ SAMPLE *s = sload->sample;
+ gus_instrument_t instrument;
+ gus_layer_t layer;
+ gus_wave_t wave;
+ unsigned char *buffer;
+ unsigned int length, loopstart, loopend;
+
+ /* Find empty slot to put sample in */
+ for (handle = 0; handle < GUS_SAMPLES; handle++)
+ if (!samples[handle])
+ break;
+
+ if (handle == GUS_SAMPLES) {
+ _mm_errno = MMERR_OUT_OF_HANDLES;
+ return -1;
+ }
+
+ /* Fill an gus_instrument_t structure and feed it to libgus. We can
+ download 8 and 16 bit, both signed and unsigned samples into GUS, so
+ don't bother much about formats here. */
+
+ /* convert position/length data from samples to bytes */
+ length = s->length;
+ loopstart = s->loopstart;
+ loopend = s->loopend ? s->loopend : length;
+ /* sanity checks */
+ if (loopend > length)
+ loopend = length;
+ if (loopstart > loopend)
+ loopstart = loopend;
+ if (s->flags & SF_16BITS) {
+ length <<= 1;
+ loopstart <<= 1;
+ loopend <<= 1;
+ }
+
+ /* Load sample into normal memory */
+ if (!(buffer = (unsigned char *) MikMod_malloc(length))) {
+ _mm_errno = MMERR_SAMPLE_TOO_BIG;
+ return -1;
+ }
+
+ if (SL_Load(buffer, sload, s->length)) {
+ MikMod_free(buffer);
+ return -1;
+ }
+
+ samples[handle] = s;
+
+ memset(&wave, 0, sizeof(wave));
+ memset(&layer, 0, sizeof(layer));
+ memset(&instrument, 0, sizeof(instrument));
+
+ wave.format =
+ ((s->flags & SF_SIGNED) ? 0 : GUS_WAVE_INVERT) |
+ ((s->flags & SF_16BITS) ? GUS_WAVE_16BIT : 0) |
+ ((s->flags & SF_DELTA ) ? GUS_WAVE_DELTA : 0) |
+ ((s->flags & SF_LOOP ) ? GUS_WAVE_LOOP : 0) |
+ ((s->flags & SF_BIDI ) ? GUS_WAVE_BIDIR : 0);
+ wave.begin.ptr = buffer;
+ wave.loop_start = loopstart << 4;
+ wave.loop_end = loopend << 4;
+ wave.size = length;
+
+ layer.wave = &wave;
+
+ instrument.mode = layer.mode = wave.mode = GUS_INSTR_SIMPLE;
+ instrument.number.instrument = handle;
+ instrument.info.layer = &layer;
+
+ /* Download the sample to GUS RAM */
+ if (libgus_memory_alloc(&instrument)) {
+ MikMod_free(buffer);
+ _mm_errno = MMERR_SAMPLE_TOO_BIG;
+ return -1;
+ }
+
+ MikMod_free(buffer);
+ return handle;
+}
+
+/* Discards a sample from the GUS memory and mark handle as free */
+static void Ultra_SampleUnload(SWORD handle)
+{
+ gus_instrument_t instrument;
+
+ if (handle >= GUS_SAMPLES || handle < 0 || !samples[handle])
+ return;
+
+ memset(&instrument, 0, sizeof(instrument));
+ instrument.mode = GUS_INSTR_SIMPLE;
+ instrument.number.instrument = handle;
+ libgus_memory_free(&instrument);
+ samples[handle] = NULL;
+}
+
+/* Reports available sample space */
+static ULONG Ultra_SampleSpace(int type)
+{
+ libgus_memory_pack();
+ return (libgus_memory_free_size());
+}
+
+/* Reports the size of a sample */
+static ULONG Ultra_SampleLength(int type, SAMPLE *s)
+{
+ if (!s)
+ return 0;
+
+ if (s->flags & SF_16BITS)
+ return ((s->length << 1) + 31) & ~31;
+ else
+ return ( s->length + 15) & ~15;
+}
+
+/* Initializes the driver */
+static int Ultra_Init_internal(void)
+{
+ gus_info_t info;
+
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ if ((ultra_card = libgus_open(ultra_dev, SIZE_OF_SEQBUF, 0)) < 0) {
+ _mm_errno = (errno == ENOMEM)? MMERR_OUT_OF_MEMORY : MMERR_INVALID_DEVICE;
+ return 1;
+ }
+ libgus_select(ultra_card);
+ ultra_fd = libgus_get_handle();
+#else
+ if (libgus_open(&ultra_h, ultra_dev, 0, SIZE_OF_SEQBUF, GUS_OPEN_FLAG_NONE) < 0) {
+ _mm_errno = (errno == ENOMEM)? MMERR_OUT_OF_MEMORY : MMERR_INVALID_DEVICE;
+ return 1;
+ }
+ ultra_fd = libgus_get_file_descriptor(ultra_h);
+#endif
+
+ /* We support only 16-bit stereo with 44K mixing frequency. On UltraSound
+ Classic mixing frequency depends on number of channels, on Interwave it
+ is always 44KHz. */
+ md_mode |= DMODE_16BITS | DMODE_STEREO;
+ md_mixfreq = info.mixing_freq;
+
+ libgus_info(&info, 0);
+#ifdef MIKMOD_DEBUG
+ switch (info.version) {
+ case 0x24:
+ fputs("GUS 2.4", stderr);
+ break;
+ case 0x35:
+ fputs("GUS 3.7 (flipped)", stderr);
+ break;
+ case 0x37:
+ fputs("GUS 3.7", stderr);
+ break;
+ case 0x90:
+ fputs("GUS ACE", stderr);
+ break;
+ case 0xa0:
+ fputs("GUS MAX 10", stderr);
+ break;
+ case 0xa1:
+ fputs("GUS MAX 11", stderr);
+ break;
+ case 0x100:
+ fputs("Interwave/GUS PnP", stderr);
+ break;
+ default:
+ fprintf(stderr, "Unknown GUS type %x", info.version);
+ break;
+ }
+ fprintf(stderr, " with %dKb RAM on board\n", info.memory_size >> 10);
+#endif
+
+ /* Zero the voice states and sample handles */
+ memset (&voices, 0, sizeof (voices));
+ memset (&samples, 0, sizeof (samples));
+
+ return 0;
+}
+
+static int Ultra_Init(void)
+{
+#ifdef MIKMOD_DYNAMIC
+ if (Ultra_Link()) {
+ _mm_errno = MMERR_DYNAMIC_LINKING;
+ return 1;
+ }
+#endif
+ return Ultra_Init_internal();
+}
+
+/* Closes the driver */
+static void Ultra_Exit_internal(void)
+{
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ if (ultra_card >= 0) {
+ ultra_card = -1;
+ libgus_close(ultra_dev);
+ }
+#else
+ if (ultra_h) {
+ libgus_close(ultra_h);
+ ultra_h = NULL;
+ }
+#endif
+ ultra_fd = -1;
+}
+
+static void Ultra_Exit(void)
+{
+ Ultra_Exit_internal();
+#ifdef MIKMOD_DYNAMIC
+ Ultra_Unlink();
+#endif
+}
+
+/* Poor man's reset function */
+static int Ultra_Reset(void)
+{
+ Ultra_Exit_internal();
+ return Ultra_Init_internal();
+}
+
+static int Ultra_SetNumVoices(void)
+{
+ return 0;
+}
+
+/* Module player tick function */
+static void UltraPlayer(void)
+{
+ int channel, panning;
+ struct GUS_VOICE *voice;
+ static BOOL ultra_pause = 1; /* paused status */
+
+ md_player();
+
+ if (ultra_pause != Player_Paused())
+ if ((ultra_pause = Player_Paused()))
+ for (channel = 0, voice = voices; channel < md_numchn;
+ channel++, voice++) {
+ libgus_do_voice_volume (channel, 0);
+ voices->changes |= (CH_VOL | CH_FREQ | CH_PAN);
+ }
+
+ if (ultra_pause)
+ return;
+
+ for (channel = 0, voice = voices; channel < md_numchn; channel++, voice++) {
+ panning = (voice->pan == PAN_SURROUND) ?
+ ULTRA_PAN_MIDDLE : (voice->pan << 6);
+
+ if (voice->kick) {
+ voice->kick = 0;
+ voice->decvol = voice->vol;
+ if (voice->start > 0)
+ libgus_do_voice_start_position(channel, voice->handle,
+ voice->frq, voice->vol << 6, panning, voice->start << 4);
+ else
+ libgus_do_voice_start(channel, voice->handle, voice->frq,
+ voice->vol << 6, voice->pan << 6);
+ } else {
+ if (voice->changes & CH_FREQ)
+ libgus_do_voice_frequency(channel, voice->frq);
+ if (voice->changes & CH_VOL)
+ libgus_do_voice_volume(channel, voice->vol << 6);
+ if (voice->changes & CH_PAN)
+ libgus_do_voice_pan(channel, panning);
+ if (voice->decvol)
+ voice->decvol -= 4;
+ }
+ voice->changes = 0;
+ }
+}
+
+/* Play sound */
+#if defined(__DJGPP__) || defined(__EMX__)
+static void Ultra_Callback(void)
+{
+ UltraPlayer();
+ libgus_do_flush();
+}
+
+static void Ultra_Update(void)
+{
+ static UWORD ultra_bpm = 0; /* current GUS tempo */
+
+ /* All real work is done during GF1 timer 1 interrupt */
+ if (ultra_bpm != md_bpm) {
+ libgus_do_tempo((md_bpm * 50) / 125);
+ ultra_bpm = md_bpm;
+ }
+}
+
+#else
+static void Ultra_Update(void)
+{
+ fd_set write_fds;
+ int need_write;
+ static UWORD ultra_bpm = 0; /* current GUS tempo */
+
+ if (ultra_bpm != md_bpm) {
+ libgus_do_tempo((md_bpm * 50) / 125);
+ ultra_bpm = md_bpm;
+ }
+
+ UltraPlayer();
+
+ do {
+ need_write = libgus_do_flush();
+
+ FD_ZERO(&write_fds);
+ do {
+ FD_SET(ultra_fd, &write_fds);
+
+ select(ultra_fd + 1, NULL, &write_fds, NULL, NULL);
+ } while (!FD_ISSET(ultra_fd, &write_fds));
+ } while(need_write > 0);
+
+ /* Wait so that all voice commands gets executed */
+ libgus_do_wait (1);
+}
+
+#endif
+
+/* Start playback */
+static int Ultra_PlayStart(void)
+{
+ int t;
+ gus_info_t info;
+
+ for (t = 0; t < md_numchn; t++) {
+ voices[t].flags = 0;
+ voices[t].handle = 0;
+ voices[t].size = 0;
+ voices[t].start = 0;
+ voices[t].reppos = 0;
+ voices[t].repend = 0;
+ voices[t].changes = 0;
+ voices[t].kick = 0;
+ voices[t].frq = 10000;
+ voices[t].vol = 0;
+ voices[t].pan = ULTRA_PAN_MIDDLE;
+ voices[t].active = 0;
+ }
+
+#if LIBGUS_VERSION_MAJOR < 0x0004
+ libgus_select(ultra_card);
+#endif
+ if (libgus_reset(md_numchn, 0) < 0) {
+ _mm_errno = MMERR_GUS_RESET;
+ return 1;
+ }
+
+ /* Query mixing frequency */
+ libgus_info(&info, 0);
+ md_mixfreq = info.mixing_freq;
+
+ libgus_queue_write_set_size(1024);
+ libgus_queue_read_set_size(128);
+
+ if (libgus_timer_start() < 0) {
+ _mm_errno = MMERR_GUS_TIMER;
+ return 1;
+ }
+
+#if defined(__DJGPP__) || defined(__EMX__)
+ gus_timer_callback(Ultra_Callback);
+#endif
+
+ libgus_timer_tempo(50);
+
+ for (t = 0; t < md_numchn; t++) {
+ libgus_do_voice_pan(t, ULTRA_PAN_MIDDLE);
+ libgus_do_voice_volume(t, 0 << 8);
+ }
+
+ libgus_do_flush();
+
+ return 0;
+}
+
+/* Stop playback */
+static void Ultra_PlayStop(void)
+{
+ int voice;
+
+ libgus_queue_flush();
+ libgus_timer_stop();
+ libgus_queue_write_set_size(0);
+ libgus_queue_read_set_size(0);
+ for(voice = 0; voice < md_numchn; voice++)
+ libgus_do_voice_stop(voice, 0);
+
+#if defined(__DJGPP__) || defined(__EMX__)
+ gus_timer_callback(NULL);
+#endif
+
+ libgus_do_flush();
+}
+
+/* Set the volume for the given voice */
+static void Ultra_VoiceSetVolume(UBYTE voice, UWORD vol)
+{
+ if (voice < md_numchn)
+ if (vol != voices[voice].vol) {
+ voices[voice].decvol =
+ voices[voice].vol = vol;
+ voices[voice].changes |= CH_VOL;
+ }
+}
+
+/* Returns the volume of the given voice */
+static UWORD Ultra_VoiceGetVolume(UBYTE voice)
+{
+ return (voice < md_numchn) ? voices[voice].vol : 0;
+}
+
+/* Set the pitch for the given voice */
+static void Ultra_VoiceSetFrequency(UBYTE voice, ULONG frq)
+{
+ if (voice < md_numchn)
+ if (frq != voices[voice].frq) {
+ voices[voice].frq = frq;
+ voices[voice].changes |= CH_FREQ;
+ }
+}
+
+/* Returns the frequency of the given voice */
+static ULONG Ultra_VoiceGetFrequency(UBYTE voice)
+{
+ return (voice < md_numchn) ? voices[voice].frq : 0;
+}
+
+/* Set the panning position for the given voice */
+static void Ultra_VoiceSetPanning(UBYTE voice, ULONG pan)
+{
+ if (voice < md_numchn)
+ if (pan != voices[voice].pan) {
+ voices[voice].pan = pan;
+ voices[voice].changes |= CH_PAN;
+ }
+}
+
+/* Returns the panning of the given voice */
+static ULONG Ultra_VoiceGetPanning(UBYTE voice)
+{
+ return (voice < md_numchn) ? voices[voice].pan : 0;
+}
+
+/* Start a new sample on a voice */
+static void Ultra_VoicePlay(UBYTE voice, SWORD handle, ULONG start,
+ ULONG size, ULONG reppos, ULONG repend,
+ UWORD flags)
+{
+ if ((voice >= md_numchn) || (start >= size))
+ return;
+
+ if (flags & SF_LOOP)
+ if (repend > size)
+ repend = size;
+
+ voices[voice].flags = flags;
+ voices[voice].handle = handle;
+ voices[voice].start = start;
+ voices[voice].size = size;
+ voices[voice].reppos = reppos;
+ voices[voice].repend = repend;
+ voices[voice].kick = 1;
+ voices[voice].active = 1;
+#ifndef HAVE_VOICE_STATUS
+ voices[voice].started = time(NULL);
+#endif
+}
+
+/* Stops a voice */
+static void Ultra_VoiceStop(UBYTE voice)
+{
+ if (voice < md_numchn)
+ voices[voice].active = 0;
+}
+
+/* Returns whether a voice is stopped */
+static BOOL Ultra_VoiceStopped(UBYTE voice)
+{
+ if (voice >= md_numchn)
+ return 1;
+
+#ifdef HAVE_VOICE_STATUS
+ if (voices[voice].active)
+ return gus_get_voice_status(voice) ? 0 : 1;
+ else
+ return 1;
+#else
+ if (voices[voice].active) {
+ /* is sample looping ? */
+ if (voices[voice].flags & (SF_LOOP | SF_BIDI))
+ return 0;
+ else
+ if (time(NULL) - voices[voice].started >=
+ ((voices[voice].size - voices[voice].start + md_mixfreq -1)
+ / md_mixfreq)) {
+ voices[voice].active = 0;
+ return 1;
+ }
+ return 0;
+ } else
+ return 1;
+#endif
+}
+
+/* Returns current voice position */
+static SLONG Ultra_VoiceGetPosition(UBYTE voice)
+{
+ /* NOTE This information can not be determined. */
+ return -1;
+}
+
+/* Returns voice real volume */
+static ULONG Ultra_VoiceRealVolume(UBYTE voice)
+{
+ int retval = 0;
+ if (!Ultra_VoiceStopped (voice)) {
+ /* NOTE This information can not be accurately determined. */
+ retval = (voices [voice].decvol) << 8;
+ if (retval > 0xffff) retval = 0xffff;
+ }
+ return retval;
+}
+
+MDRIVER drv_ultra = {
+ NULL,
+ "Gravis Ultrasound native mode",
+ "Gravis Ultrasound native mode driver v1.2",
+ 0, (GUS_CHANNELS)-1,
+ "ultra",
+#ifdef __DJGPP__
+ "dma:b:1:Use DMA for transferring samples into GUS DRAM\n"
+#endif
+ "card:r:0,8,0:Soundcard number\n",
+
+ Ultra_CommandLine,
+ Ultra_IsThere,
+ Ultra_SampleLoad,
+ Ultra_SampleUnload,
+ Ultra_SampleSpace,
+ Ultra_SampleLength,
+ Ultra_Init,
+ Ultra_Exit,
+ Ultra_Reset,
+ Ultra_SetNumVoices,
+ Ultra_PlayStart,
+ Ultra_PlayStop,
+ Ultra_Update,
+ NULL,
+ Ultra_VoiceSetVolume,
+ Ultra_VoiceGetVolume,
+ Ultra_VoiceSetFrequency,
+ Ultra_VoiceGetFrequency,
+ Ultra_VoiceSetPanning,
+ Ultra_VoiceGetPanning,
+ Ultra_VoicePlay,
+ Ultra_VoiceStop,
+ Ultra_VoiceStopped,
+ Ultra_VoiceGetPosition,
+ Ultra_VoiceRealVolume
+};
+#else
+
+MISSING(drv_ultra);
+
+#endif /* DRV_ULTRA */
+
+/* ex:set ts=8: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Driver for Windows Sound System under DOS
+
+==============================================================================*/
+
+/*
+
+ Written by Andrew Zabolotny <bit@eltech.ru>
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DRV_WSS
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+#include "mikmod_internals.h"
+
+#include "doswss.h"
+
+static void WSS_CommandLine(const CHAR *cmdline)
+{
+ char *ptr, *end;
+
+ if ((ptr=MD_GetAtom("port",cmdline,0)) != NULL) {
+ wss.port = strtol(ptr, &end, 16);
+ MikMod_free(ptr);
+ }
+ if ((ptr=MD_GetAtom("irq",cmdline,0)) != NULL) {
+ wss.irq = strtol(ptr, &end, 10);
+ MikMod_free(ptr);
+ }
+ if ((ptr=MD_GetAtom("dma",cmdline,0)) != NULL) {
+ wss.dma = strtol(ptr, &end, 10);
+ MikMod_free(ptr);
+ }
+}
+
+static BOOL WSS_IsThere(void)
+{
+ return wss_detect();
+}
+
+static int WSS_Init(void)
+{
+ if (!wss_open()) {
+ _mm_errno = MMERR_INVALID_DEVICE;
+ return 1;
+ }
+
+ /* Adjust mixing frequency according to card capabilities */
+ md_mixfreq = wss_adjust_freq(md_mixfreq);
+
+ return VC_Init();
+}
+
+static void WSS_Exit(void)
+{
+ VC_Exit();
+ wss_close();
+}
+
+/* The last buffer byte filled with sound */
+static unsigned int buff_tail = 0;
+
+static void WSS_Callback(void)
+{
+ unsigned int dma_size, dma_pos;
+ ULONG (*mixer)(SBYTE *buf, ULONG todo);
+
+ wss_query_dma(&dma_size, &dma_pos);
+ /* There isn't much sense in filling less than 256 bytes */
+ dma_pos &= ~255;
+
+ /* If nothing to mix, quit */
+ if (buff_tail == dma_pos)
+ return;
+
+ if (Player_Paused_internal())
+ mixer = VC_SilenceBytes;
+ else
+ mixer = VC_WriteBytes;
+
+ /* If DMA pointer still didn't wrapped around ... */
+ if (dma_pos > buff_tail) {
+ buff_tail += mixer ((SBYTE *)(wss.dma_buff->linear + buff_tail), dma_pos - buff_tail);
+ /* If we arrived right to the DMA buffer end, jump to the beginning */
+ if (buff_tail >= dma_size)
+ buff_tail = 0;
+ } else {
+ /* If wrapped around, fill first to the end of buffer */
+ mixer ((SBYTE *)(wss.dma_buff->linear + buff_tail), dma_size - buff_tail);
+ /* Now fill from buffer beginning to current DMA pointer */
+ buff_tail = mixer ((SBYTE *)wss.dma_buff->linear, dma_pos);
+ }
+}
+
+static void WSS_Update(void)
+{
+ /* Do nothing: the real update is done during SB interrupts */
+}
+
+static int WSS_PlayStart(void)
+{
+ if (VC_PlayStart())
+ return 1;
+
+ /* Set our routine to be called during WSS IRQs */
+ buff_tail = 0;
+ wss.timer_callback = WSS_Callback;
+
+ /* Start cyclic DMA transfer */
+ if (!wss_start_dma(((md_mode & DMODE_16BITS) ? WSSMODE_16BITS | WSSMODE_SIGNED : 0) |
+ ((md_mode & DMODE_STEREO) ? WSSMODE_STEREO : 0), md_mixfreq))
+ {
+ _mm_errno = MMERR_DOSWSS_STARTDMA;
+ return 1;
+ }
+
+ /* Enable speaker output */
+ wss_output(TRUE);
+
+ return 0;
+}
+
+static int WSS_Reset(void)
+{
+ wss_reset();
+ VC_Exit();
+ return VC_Init();
+}
+
+static void WSS_PlayStop(void)
+{
+ wss.timer_callback = NULL;
+ wss_output(FALSE);
+ wss_stop_dma();
+ VC_PlayStop();
+}
+
+MDRIVER drv_wss =
+{
+ NULL,
+ "Windows Sound System",
+ "Windows Sound System (CS423*,ESS*) v1.0",
+ 0, 255,
+ "wss",
+ "port:c:32C,530,604,E80,F40,530:Windows Sound System base I/O port\n"
+ "irq:c:2,3,5,7,10,5:Windows Sound System IRQ\n"
+ "dma:c:0,1,3,0:Windows Sound System DMA channel\n",
+
+ WSS_CommandLine,
+ WSS_IsThere,
+ VC_SampleLoad,
+ VC_SampleUnload,
+ VC_SampleSpace,
+ VC_SampleLength,
+ WSS_Init,
+ WSS_Exit,
+ WSS_Reset,
+ VC_SetNumVoices,
+ WSS_PlayStart,
+ WSS_PlayStop,
+ WSS_Update,
+ NULL,
+ VC_VoiceSetVolume,
+ VC_VoiceGetVolume,
+ VC_VoiceSetFrequency,
+ VC_VoiceGetFrequency,
+ VC_VoiceSetPanning,
+ VC_VoiceGetPanning,
+ VC_VoicePlay,
+ VC_VoiceStop,
+ VC_VoiceStopped,
+ VC_VoiceGetPosition,
+ VC_VoiceRealVolume
+};
+
+#else /* ifdef DRV_WSS */
+
+#include "mikmod_internals.h"
+MISSING(drv_wss);
+
+#endif
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998-2014 Miodrag Vallat and others - see the AUTHORS file
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ MikMod sound library include file
+
+ ==============================================================================*/
+
+#ifndef _MIKMOD_H_
+#define _MIKMOD_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MIKMOD_STATIC
+#define MIKMOD_STATIC
+#endif
+
+/*
+ * ========== Compiler magic for shared libraries
+ *
+ * ========== NOTE TO WINDOWS DEVELOPERS:
+ * If you are compiling for Windows and will link to the static library
+ * (libmikmod.a with MinGW, or mikmod_static.lib with MSVC or LCC, etc),
+ * you must define MIKMOD_STATIC in your project. Otherwise, dllimport
+ * will be assumed.
+ */
+#if defined(_WIN32) || defined(__CYGWIN__)
+# if defined(MIKMOD_BUILD) && defined(DLL_EXPORT) /* building libmikmod as a dll for windows */
+# define MIKMODAPI __declspec(dllexport)
+# elif defined(MIKMOD_BUILD) || defined(MIKMOD_STATIC) /* building or using static libmikmod for windows */
+# define MIKMODAPI
+# else
+# define MIKMODAPI __declspec(dllimport) /* using libmikmod dll for windows */
+# endif
+#elif defined(__OS2__) && defined(__WATCOMC__)
+# if defined(MIKMOD_BUILD) && defined(__SW_BD) /* building libmikmod as a dll for os/2 */
+# define MIKMODAPI __declspec(dllexport)
+# else
+# define MIKMODAPI /* using dll or static libmikmod for os/2 */
+# endif
+/* SYM_VISIBILITY should be defined if both the compiler
+ * and the target support the visibility attributes. the
+ * configury does that automatically. for the standalone
+ * makefiles, etc, the developer should add the required
+ * flags, i.e.: -DSYM_VISIBILITY -fvisibility=hidden */
+#elif defined(MIKMOD_BUILD) && defined(SYM_VISIBILITY)
+# define MIKMODAPI __attribute__((visibility("default")))
+#else
+# define MIKMODAPI
+#endif
+
+/*
+ * ========== Library version
+ */
+
+#define LIBMIKMOD_VERSION_MAJOR 3L
+#define LIBMIKMOD_VERSION_MINOR 3L
+#define LIBMIKMOD_REVISION 10L
+
+#define LIBMIKMOD_VERSION \
+ ((LIBMIKMOD_VERSION_MAJOR<<16)| \
+ (LIBMIKMOD_VERSION_MINOR<< 8)| \
+ (LIBMIKMOD_REVISION))
+
+MIKMODAPI extern long MikMod_GetVersion(void);
+
+/*
+ * ========== Dependency platform headers
+ */
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <io.h>
+#include <mmsystem.h>
+#define _MIKMOD_WIN32
+#endif
+
+#if defined(__DJGPP__) || defined(MSDOS) || defined(__MSDOS__) || defined(__DOS__)
+#define _MIKMOD_DOS
+#endif
+
+#if defined(__OS2__) || defined(__EMX__)
+#define INCL_DOSSEMAPHORES
+#include <os2.h>
+#include <io.h>
+#define _MIKMOD_OS2
+#endif
+
+#if defined(__MORPHOS__) || defined(__AROS__) || defined(_AMIGA) || defined(__AMIGA__) || defined(__amigaos__) || defined(AMIGAOS)
+#include <exec/types.h>
+#define _MIKMOD_AMIGA
+#endif
+
+/*
+ * ========== Platform independent-type definitions
+ * (pain when it comes to cross-platform maintenance..)
+ */
+
+#if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32))
+typedef char CHAR;
+#endif
+
+/* BOOL: 0=false, <>0 true -- 16 bits on Amiga, int-wide on others. */
+#if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32) || defined(_MIKMOD_AMIGA))
+typedef int BOOL;
+#endif
+
+/* 1 byte, signed and unsigned: */
+typedef signed char SBYTE;
+#ifndef _MIKMOD_AMIGA
+typedef unsigned char UBYTE;
+#endif
+
+/* 2 bytes, signed and unsigned: */
+#ifndef __LCC__
+typedef signed short int SWORD;
+#endif
+#if !(defined(__LCC__) || defined(_MIKMOD_AMIGA))
+typedef unsigned short int UWORD;
+#endif
+
+/* 4 bytes, signed and unsigned: */
+#if defined(_LP64) || defined(__LP64__) || defined(__arch64__) || defined(__alpha) || defined(__x86_64) || defined(__powerpc64__)
+ /* 64 bit architectures: */
+typedef signed int SLONG;
+#if !(defined(_WIN32) || defined(_MIKMOD_AMIGA))
+typedef unsigned int ULONG;
+#endif
+
+#else /* 32 bit architectures: */
+typedef signed long int SLONG;
+#if !(defined(_MIKMOD_OS2) || defined(_MIKMOD_WIN32) || defined(_MIKMOD_AMIGA))
+typedef unsigned long int ULONG;
+#endif
+#endif
+
+/* make sure types are of correct sizes: */
+typedef int __mikmod_typetest [
+ (
+ (sizeof(SBYTE)==1) && (sizeof(UBYTE)==1)
+ && (sizeof(SWORD)==2) && (sizeof(UWORD)==2)
+ && (sizeof(SLONG)==4) && (sizeof(ULONG)==4)
+#ifndef _MIKMOD_AMIGA
+ && (sizeof(BOOL) == sizeof(int))
+#endif
+ && (sizeof(CHAR) == sizeof(char))
+ ) * 2 - 1 ];
+
+/*
+ * ========== Error codes
+ */
+
+enum {
+ MMERR_OPENING_FILE = 1,
+ MMERR_OUT_OF_MEMORY,
+ MMERR_DYNAMIC_LINKING,
+
+ MMERR_SAMPLE_TOO_BIG,
+ MMERR_OUT_OF_HANDLES,
+ MMERR_UNKNOWN_WAVE_TYPE,
+
+ MMERR_LOADING_PATTERN,
+ MMERR_LOADING_TRACK,
+ MMERR_LOADING_HEADER,
+ MMERR_LOADING_SAMPLEINFO,
+ MMERR_NOT_A_MODULE,
+ MMERR_NOT_A_STREAM,
+ MMERR_MED_SYNTHSAMPLES,
+ MMERR_ITPACK_INVALID_DATA,
+
+ MMERR_DETECTING_DEVICE,
+ MMERR_INVALID_DEVICE,
+ MMERR_INITIALIZING_MIXER,
+ MMERR_OPENING_AUDIO,
+ MMERR_8BIT_ONLY,
+ MMERR_16BIT_ONLY,
+ MMERR_STEREO_ONLY,
+ MMERR_ULAW,
+ MMERR_NON_BLOCK,
+
+ MMERR_AF_AUDIO_PORT,
+
+ MMERR_AIX_CONFIG_INIT,
+ MMERR_AIX_CONFIG_CONTROL,
+ MMERR_AIX_CONFIG_START,
+
+ MMERR_GUS_SETTINGS,
+ MMERR_GUS_RESET,
+ MMERR_GUS_TIMER,
+
+ MMERR_HP_SETSAMPLESIZE,
+ MMERR_HP_SETSPEED,
+ MMERR_HP_CHANNELS,
+ MMERR_HP_AUDIO_OUTPUT,
+ MMERR_HP_AUDIO_DESC,
+ MMERR_HP_BUFFERSIZE,
+
+ MMERR_OSS_SETFRAGMENT,
+ MMERR_OSS_SETSAMPLESIZE,
+ MMERR_OSS_SETSTEREO,
+ MMERR_OSS_SETSPEED,
+
+ MMERR_SGI_SPEED,
+ MMERR_SGI_16BIT,
+ MMERR_SGI_8BIT,
+ MMERR_SGI_STEREO,
+ MMERR_SGI_MONO,
+
+ MMERR_SUN_INIT,
+
+ MMERR_OS2_MIXSETUP,
+ MMERR_OS2_SEMAPHORE,
+ MMERR_OS2_TIMER,
+ MMERR_OS2_THREAD,
+
+ MMERR_DS_PRIORITY,
+ MMERR_DS_BUFFER,
+ MMERR_DS_FORMAT,
+ MMERR_DS_NOTIFY,
+ MMERR_DS_EVENT,
+ MMERR_DS_THREAD,
+ MMERR_DS_UPDATE,
+
+ MMERR_WINMM_HANDLE,
+ MMERR_WINMM_ALLOCATED,
+ MMERR_WINMM_DEVICEID,
+ MMERR_WINMM_FORMAT,
+ MMERR_WINMM_UNKNOWN,
+
+ MMERR_MAC_SPEED,
+ MMERR_MAC_START,
+
+ MMERR_OSX_UNKNOWN_DEVICE,
+ MMERR_OSX_BAD_PROPERTY,
+ MMERR_OSX_UNSUPPORTED_FORMAT,
+ MMERR_OSX_SET_STEREO,
+ MMERR_OSX_BUFFER_ALLOC,
+ MMERR_OSX_ADD_IO_PROC,
+ MMERR_OSX_DEVICE_START,
+ MMERR_OSX_PTHREAD,
+
+ MMERR_DOSWSS_STARTDMA,
+ MMERR_DOSSB_STARTDMA,
+
+ MMERR_NO_FLOAT32,/* should actually be after MMERR_ULAW or something */
+
+ MMERR_OPENAL_CREATECTX,
+ MMERR_OPENAL_CTXCURRENT,
+ MMERR_OPENAL_GENBUFFERS,
+ MMERR_OPENAL_GENSOURCES,
+ MMERR_OPENAL_SOURCE,
+ MMERR_OPENAL_QUEUEBUFFERS,
+ MMERR_OPENAL_UNQUEUEBUFFERS,
+ MMERR_OPENAL_BUFFERDATA,
+ MMERR_OPENAL_GETSOURCE,
+ MMERR_OPENAL_SOURCEPLAY,
+ MMERR_OPENAL_SOURCESTOP,
+
+ MMERR_ALSA_NOCONFIG,
+ MMERR_ALSA_SETPARAMS,
+ MMERR_ALSA_SETFORMAT,
+ MMERR_ALSA_SETRATE,
+ MMERR_ALSA_SETCHANNELS,
+ MMERR_ALSA_BUFFERSIZE,
+ MMERR_ALSA_PCM_START,
+ MMERR_ALSA_PCM_WRITE,
+ MMERR_ALSA_PCM_RECOVER,
+
+ MMERR_SNDIO_SETPARAMS,
+ MMERR_SNDIO_BADPARAMS,
+
+ MMERR_MAX
+};
+
+/*
+ * ========== Error handling
+ */
+
+typedef void (MikMod_handler)(void);
+typedef MikMod_handler *MikMod_handler_t;
+
+MIKMODAPI extern int MikMod_errno;
+MIKMODAPI extern BOOL MikMod_critical;
+MIKMODAPI extern const char *MikMod_strerror(int);
+
+MIKMODAPI extern MikMod_handler_t MikMod_RegisterErrorHandler(MikMod_handler_t);
+
+/*
+ * ========== Library initialization and core functions
+ */
+
+struct MDRIVER;
+
+MIKMODAPI extern void MikMod_RegisterAllDrivers(void);
+
+MIKMODAPI extern CHAR* MikMod_InfoDriver(void);
+MIKMODAPI extern void MikMod_RegisterDriver(struct MDRIVER*);
+MIKMODAPI extern int MikMod_DriverFromAlias(const CHAR*);
+MIKMODAPI extern struct MDRIVER *MikMod_DriverByOrdinal(int);
+
+MIKMODAPI extern int MikMod_Init(const CHAR*);
+MIKMODAPI extern void MikMod_Exit(void);
+MIKMODAPI extern int MikMod_Reset(const CHAR*);
+MIKMODAPI extern int MikMod_SetNumVoices(int,int);
+MIKMODAPI extern BOOL MikMod_Active(void);
+MIKMODAPI extern int MikMod_EnableOutput(void);
+MIKMODAPI extern void MikMod_DisableOutput(void);
+MIKMODAPI extern void MikMod_Update(void);
+
+MIKMODAPI extern BOOL MikMod_InitThreads(void);
+MIKMODAPI extern void MikMod_Lock(void);
+MIKMODAPI extern void MikMod_Unlock(void);
+
+MIKMODAPI extern void* MikMod_malloc(size_t);
+MIKMODAPI extern void* MikMod_calloc(size_t,size_t);
+MIKMODAPI extern void* MikMod_realloc(void*,size_t);
+MIKMODAPI extern CHAR* MikMod_strdup(const CHAR*);
+MIKMODAPI extern void MikMod_free(void*); /* frees if ptr != NULL */
+
+/*
+ * ========== Reader, Writer
+ */
+
+typedef struct MREADER {
+ int (*Seek)(struct MREADER*,long,int);
+ long (*Tell)(struct MREADER*);
+ BOOL (*Read)(struct MREADER*,void*,size_t);
+ int (*Get)(struct MREADER*);
+ BOOL (*Eof)(struct MREADER*);
+ long iobase;
+ long prev_iobase;
+} MREADER;
+
+typedef struct MWRITER {
+ int (*Seek)(struct MWRITER*, long, int);
+ long (*Tell)(struct MWRITER*);
+ BOOL (*Write)(struct MWRITER*, const void*, size_t);
+ int (*Put)(struct MWRITER*, int);
+} MWRITER;
+
+/*
+ * ========== Samples
+ */
+
+/* Sample playback should not be interrupted */
+#define SFX_CRITICAL 1
+
+/* Sample format [loading and in-memory] flags: */
+#define SF_16BITS 0x0001
+#define SF_STEREO 0x0002
+#define SF_SIGNED 0x0004
+#define SF_BIG_ENDIAN 0x0008
+#define SF_DELTA 0x0010
+#define SF_ITPACKED 0x0020
+
+#define SF_FORMATMASK 0x003F
+
+/* General Playback flags */
+
+#define SF_LOOP 0x0100
+#define SF_BIDI 0x0200
+#define SF_REVERSE 0x0400
+#define SF_SUSTAIN 0x0800
+
+#define SF_PLAYBACKMASK 0x0C00
+
+/* Module-only Playback Flags */
+
+#define SF_OWNPAN 0x1000
+#define SF_UST_LOOP 0x2000
+
+#define SF_EXTRAPLAYBACKMASK 0x3000
+
+/* Panning constants */
+#define PAN_LEFT 0
+#define PAN_HALFLEFT 64
+#define PAN_CENTER 128
+#define PAN_HALFRIGHT 192
+#define PAN_RIGHT 255
+#define PAN_SURROUND 512 /* panning value for Dolby Surround */
+
+typedef struct SAMPLE {
+ SWORD panning; /* panning (0-255 or PAN_SURROUND) */
+ ULONG speed; /* Base playing speed/frequency of note */
+ UBYTE volume; /* volume 0-64 */
+ UWORD inflags; /* sample format on disk */
+ UWORD flags; /* sample format in memory */
+ ULONG length; /* length of sample (in samples!) */
+ ULONG loopstart; /* repeat position (relative to start, in samples) */
+ ULONG loopend; /* repeat end */
+ ULONG susbegin; /* sustain loop begin (in samples) \ Not Supported */
+ ULONG susend; /* sustain loop end / Yet! */
+
+ /* Variables used by the module player only! (ignored for sound effects) */
+ UBYTE globvol; /* global volume */
+ UBYTE vibflags; /* autovibrato flag stuffs */
+ UBYTE vibtype; /* Vibratos moved from INSTRUMENT to SAMPLE */
+ UBYTE vibsweep;
+ UBYTE vibdepth;
+ UBYTE vibrate;
+ CHAR* samplename; /* name of the sample */
+
+ /* Values used internally only */
+ UWORD avibpos; /* autovibrato pos [player use] */
+ UBYTE divfactor; /* for sample scaling, maintains proper period slides */
+ ULONG seekpos; /* seek position in file */
+ SWORD handle; /* sample handle used by individual drivers */
+ void (*onfree)(void *ctx); /* called from Sample_Free if not NULL */
+ void *ctx; /* context passed to previous function*/
+} SAMPLE;
+
+/* Sample functions */
+
+MIKMODAPI extern SAMPLE *Sample_LoadRaw(const CHAR *,ULONG rate, ULONG channel, ULONG flags);
+MIKMODAPI extern SAMPLE *Sample_LoadRawFP(FILE *fp,ULONG rate,ULONG channel, ULONG flags);
+MIKMODAPI extern SAMPLE *Sample_LoadRawMem(const char *buf, int len, ULONG rate, ULONG channel, ULONG flags);
+MIKMODAPI extern SAMPLE *Sample_LoadRawGeneric(MREADER*reader,ULONG rate, ULONG channel, ULONG flags);
+
+MIKMODAPI extern SAMPLE *Sample_Load(const CHAR*);
+MIKMODAPI extern SAMPLE *Sample_LoadFP(FILE*);
+MIKMODAPI extern SAMPLE *Sample_LoadMem(const char *buf, int len);
+MIKMODAPI extern SAMPLE *Sample_LoadGeneric(MREADER*);
+MIKMODAPI extern void Sample_Free(SAMPLE*);
+MIKMODAPI extern SBYTE Sample_Play(SAMPLE*,ULONG,UBYTE);
+
+MIKMODAPI extern void Voice_SetVolume(SBYTE,UWORD);
+MIKMODAPI extern UWORD Voice_GetVolume(SBYTE);
+MIKMODAPI extern void Voice_SetFrequency(SBYTE,ULONG);
+MIKMODAPI extern ULONG Voice_GetFrequency(SBYTE);
+MIKMODAPI extern void Voice_SetPanning(SBYTE,ULONG);
+MIKMODAPI extern ULONG Voice_GetPanning(SBYTE);
+MIKMODAPI extern void Voice_Play(SBYTE,SAMPLE*,ULONG);
+MIKMODAPI extern void Voice_Stop(SBYTE);
+MIKMODAPI extern BOOL Voice_Stopped(SBYTE);
+MIKMODAPI extern SLONG Voice_GetPosition(SBYTE);
+MIKMODAPI extern ULONG Voice_RealVolume(SBYTE);
+
+/*
+ * ========== Internal module representation (UniMod)
+ */
+
+/*
+ Instrument definition - for information only, the only field which may be
+ of use in user programs is the name field
+*/
+
+/* Instrument note count */
+#define INSTNOTES 120
+
+/* Envelope point */
+typedef struct ENVPT {
+ SWORD pos;
+ SWORD val;
+} ENVPT;
+
+/* Envelope point count */
+#define ENVPOINTS 32
+
+/* Instrument structure */
+typedef struct INSTRUMENT {
+ CHAR* insname;
+
+ UBYTE flags;
+ UWORD samplenumber[INSTNOTES];
+ UBYTE samplenote[INSTNOTES];
+
+ UBYTE nnatype;
+ UBYTE dca; /* duplicate check action */
+ UBYTE dct; /* duplicate check type */
+ UBYTE globvol;
+ UWORD volfade;
+ SWORD panning; /* instrument-based panning var */
+
+ UBYTE pitpansep; /* pitch pan separation (0 to 255) */
+ UBYTE pitpancenter; /* pitch pan center (0 to 119) */
+ UBYTE rvolvar; /* random volume varations (0 - 100%) */
+ UBYTE rpanvar; /* random panning varations (0 - 100%) */
+
+ /* volume envelope */
+ UBYTE volflg; /* bit 0: on 1: sustain 2: loop */
+ UBYTE volpts;
+ UBYTE volsusbeg;
+ UBYTE volsusend;
+ UBYTE volbeg;
+ UBYTE volend;
+ ENVPT volenv[ENVPOINTS];
+ /* panning envelope */
+ UBYTE panflg; /* bit 0: on 1: sustain 2: loop */
+ UBYTE panpts;
+ UBYTE pansusbeg;
+ UBYTE pansusend;
+ UBYTE panbeg;
+ UBYTE panend;
+ ENVPT panenv[ENVPOINTS];
+ /* pitch envelope */
+ UBYTE pitflg; /* bit 0: on 1: sustain 2: loop */
+ UBYTE pitpts;
+ UBYTE pitsusbeg;
+ UBYTE pitsusend;
+ UBYTE pitbeg;
+ UBYTE pitend;
+ ENVPT pitenv[ENVPOINTS];
+} INSTRUMENT;
+
+struct MP_CONTROL;
+struct MP_VOICE;
+
+/*
+ Module definition
+*/
+
+/* maximum master channels supported */
+#define UF_MAXCHAN 64
+
+/* Module flags */
+#define UF_XMPERIODS 0x0001 /* XM periods / finetuning */
+#define UF_LINEAR 0x0002 /* LINEAR periods (UF_XMPERIODS must be set) */
+#define UF_INST 0x0004 /* Instruments are used */
+#define UF_NNA 0x0008 /* IT: NNA used, set numvoices rather
+ than numchn */
+#define UF_S3MSLIDES 0x0010 /* uses old S3M volume slides */
+#define UF_BGSLIDES 0x0020 /* continue volume slides in the background */
+#define UF_HIGHBPM 0x0040 /* MED: can use >255 bpm */
+#define UF_NOWRAP 0x0080 /* XM-type (i.e. illogical) pattern break
+ semantics */
+#define UF_ARPMEM 0x0100 /* IT: need arpeggio memory */
+#define UF_FT2QUIRKS 0x0200 /* emulate some FT2 replay quirks */
+#define UF_PANNING 0x0400 /* module uses panning effects or have
+ non-tracker default initial panning */
+
+typedef struct MODULE {
+ /* general module information */
+ CHAR* songname; /* name of the song */
+ CHAR* modtype; /* string type of module loaded */
+ CHAR* comment; /* module comments */
+
+ UWORD flags; /* See module flags above */
+ UBYTE numchn; /* number of module channels */
+ UBYTE numvoices; /* max # voices used for full NNA playback */
+ UWORD numpos; /* number of positions in this song */
+ UWORD numpat; /* number of patterns in this song */
+ UWORD numins; /* number of instruments */
+ UWORD numsmp; /* number of samples */
+
+ struct INSTRUMENT* instruments; /* all instruments */
+ struct SAMPLE* samples; /* all samples */
+
+ UBYTE realchn; /* real number of channels used */
+ UBYTE totalchn; /* total number of channels used (incl NNAs) */
+
+ /* playback settings */
+ UWORD reppos; /* restart position */
+ UBYTE initspeed; /* initial song speed */
+ UWORD inittempo; /* initial song tempo */
+ UBYTE initvolume; /* initial global volume (0 - 128) */
+ UWORD panning[UF_MAXCHAN]; /* panning positions */
+ UBYTE chanvol[UF_MAXCHAN]; /* channel positions */
+ UWORD bpm; /* current beats-per-minute speed */
+ UWORD sngspd; /* current song speed */
+ SWORD volume; /* song volume (0-128) (or user volume) */
+
+ BOOL extspd; /* extended speed flag (default enabled) */
+ BOOL panflag; /* panning flag (default enabled) */
+ BOOL wrap; /* wrap module ? (default disabled) */
+ BOOL loop; /* allow module to loop ? (default enabled) */
+ BOOL fadeout; /* volume fade out during last pattern */
+
+ UWORD patpos; /* current row number */
+ SWORD sngpos; /* current song position */
+ ULONG sngtime; /* current song time in 2^-10 seconds */
+
+ SWORD relspd; /* relative speed factor */
+
+ /* internal module representation */
+ UWORD numtrk; /* number of tracks */
+ UBYTE** tracks; /* array of numtrk pointers to tracks */
+ UWORD* patterns; /* array of Patterns */
+ UWORD* pattrows; /* array of number of rows for each pattern */
+ UWORD* positions; /* all positions */
+
+ BOOL forbid; /* if true, no player update! */
+ UWORD numrow; /* number of rows on current pattern */
+ UWORD vbtick; /* tick counter (counts from 0 to sngspd) */
+ UWORD sngremainder;/* used for song time computation */
+
+ struct MP_CONTROL* control; /* Effects Channel info (size pf->numchn) */
+ struct MP_VOICE* voice; /* Audio Voice information (size md_numchn) */
+
+ UBYTE globalslide; /* global volume slide rate */
+ UBYTE pat_repcrazy;/* module has just looped to position -1 */
+ UWORD patbrk; /* position where to start a new pattern */
+ UBYTE patdly; /* patterndelay counter (command memory) */
+ UBYTE patdly2; /* patterndelay counter (real one) */
+ SWORD posjmp; /* flag to indicate a jump is needed... */
+ UWORD bpmlimit; /* threshold to detect bpm or speed values */
+} MODULE;
+
+
+/* This structure is used to query current playing voices status */
+typedef struct VOICEINFO {
+ INSTRUMENT* i; /* Current channel instrument */
+ SAMPLE* s; /* Current channel sample */
+ SWORD panning; /* panning position */
+ SBYTE volume; /* channel's "global" volume (0..64) */
+ UWORD period; /* period to play the sample at */
+ UBYTE kick; /* if true = sample has been restarted */
+} VOICEINFO;
+
+/*
+ * ========== Module loaders
+ */
+
+struct MLOADER;
+
+MIKMODAPI extern CHAR* MikMod_InfoLoader(void);
+MIKMODAPI extern void MikMod_RegisterAllLoaders(void);
+MIKMODAPI extern void MikMod_RegisterLoader(struct MLOADER*);
+
+MIKMODAPI extern struct MLOADER load_669; /* 669 and Extended-669 (by Tran/Renaissance) */
+MIKMODAPI extern struct MLOADER load_amf; /* DMP Advanced Module Format (by Otto Chrons) */
+MIKMODAPI extern struct MLOADER load_asy; /* ASYLUM Music Format 1.0 */
+MIKMODAPI extern struct MLOADER load_dsm; /* DSIK internal module format */
+MIKMODAPI extern struct MLOADER load_far; /* Farandole Composer (by Daniel Potter) */
+MIKMODAPI extern struct MLOADER load_gdm; /* General DigiMusic (by Edward Schlunder) */
+MIKMODAPI extern struct MLOADER load_gt2; /* Graoumf tracker */
+MIKMODAPI extern struct MLOADER load_it; /* Impulse Tracker (by Jeffrey Lim) */
+MIKMODAPI extern struct MLOADER load_imf; /* Imago Orpheus (by Lutz Roeder) */
+MIKMODAPI extern struct MLOADER load_med; /* Amiga MED modules (by Teijo Kinnunen) */
+MIKMODAPI extern struct MLOADER load_m15; /* Soundtracker 15-instrument */
+MIKMODAPI extern struct MLOADER load_mod; /* Standard 31-instrument Module loader */
+MIKMODAPI extern struct MLOADER load_mtm; /* Multi-Tracker Module (by Renaissance) */
+MIKMODAPI extern struct MLOADER load_okt; /* Amiga Oktalyzer */
+MIKMODAPI extern struct MLOADER load_stm; /* ScreamTracker 2 (by Future Crew) */
+MIKMODAPI extern struct MLOADER load_stx; /* STMIK 0.2 (by Future Crew) */
+MIKMODAPI extern struct MLOADER load_s3m; /* ScreamTracker 3 (by Future Crew) */
+MIKMODAPI extern struct MLOADER load_ult; /* UltraTracker (by MAS) */
+MIKMODAPI extern struct MLOADER load_umx; /* Unreal UMX container of Epic Games */
+MIKMODAPI extern struct MLOADER load_uni; /* MikMod and APlayer internal module format */
+MIKMODAPI extern struct MLOADER load_xm; /* FastTracker 2 (by Triton) */
+
+/*
+ * ========== Module player
+ */
+
+MIKMODAPI extern MODULE* Player_Load(const CHAR*,int,BOOL);
+MIKMODAPI extern MODULE* Player_LoadFP(FILE*,int,BOOL);
+MIKMODAPI extern MODULE* Player_LoadMem(const char *buffer,int len,int maxchan,BOOL curious);
+MIKMODAPI extern MODULE* Player_LoadGeneric(MREADER*,int,BOOL);
+MIKMODAPI extern CHAR* Player_LoadTitle(const CHAR*);
+MIKMODAPI extern CHAR* Player_LoadTitleFP(FILE*);
+MIKMODAPI extern CHAR* Player_LoadTitleMem(const char *buffer,int len);
+MIKMODAPI extern CHAR* Player_LoadTitleGeneric(MREADER*);
+
+MIKMODAPI extern void Player_Free(MODULE*);
+MIKMODAPI extern void Player_Start(MODULE*);
+MIKMODAPI extern BOOL Player_Active(void);
+MIKMODAPI extern void Player_Stop(void);
+MIKMODAPI extern void Player_TogglePause(void);
+MIKMODAPI extern BOOL Player_Paused(void);
+MIKMODAPI extern void Player_NextPosition(void);
+MIKMODAPI extern void Player_PrevPosition(void);
+MIKMODAPI extern void Player_SetPosition(UWORD);
+MIKMODAPI extern BOOL Player_Muted(UBYTE);
+MIKMODAPI extern void Player_SetVolume(SWORD);
+MIKMODAPI extern MODULE* Player_GetModule(void);
+MIKMODAPI extern void Player_SetSpeed(UWORD);
+MIKMODAPI extern void Player_SetTempo(UWORD);
+MIKMODAPI extern void Player_Unmute(SLONG,...);
+MIKMODAPI extern void Player_Mute(SLONG,...);
+MIKMODAPI extern void Player_ToggleMute(SLONG,...);
+MIKMODAPI extern int Player_GetChannelVoice(UBYTE);
+MIKMODAPI extern UWORD Player_GetChannelPeriod(UBYTE);
+MIKMODAPI extern int Player_QueryVoices(UWORD numvoices, VOICEINFO *vinfo);
+MIKMODAPI extern int Player_GetRow(void);
+MIKMODAPI extern int Player_GetOrder(void);
+
+typedef void (*MikMod_player_t)(void);
+typedef void (*MikMod_callback_t)(unsigned char *data, size_t len);
+
+MIKMODAPI extern MikMod_player_t MikMod_RegisterPlayer(MikMod_player_t);
+
+#define MUTE_EXCLUSIVE 32000
+#define MUTE_INCLUSIVE 32001
+
+/*
+ * ========== Drivers
+ */
+
+enum {
+ MD_MUSIC = 0,
+ MD_SNDFX
+};
+
+enum {
+ MD_HARDWARE = 0,
+ MD_SOFTWARE
+};
+
+/* Mixing flags */
+
+/* These ones take effect only after MikMod_Init or MikMod_Reset */
+#define DMODE_16BITS 0x0001 /* enable 16 bit output */
+#define DMODE_STEREO 0x0002 /* enable stereo output */
+#define DMODE_SOFT_SNDFX 0x0004 /* Process sound effects via software mixer */
+#define DMODE_SOFT_MUSIC 0x0008 /* Process music via software mixer */
+#define DMODE_HQMIXER 0x0010 /* Use high-quality (slower) software mixer */
+#define DMODE_FLOAT 0x0020 /* enable float output */
+/* These take effect immediately. */
+#define DMODE_SURROUND 0x0100 /* enable surround sound */
+#define DMODE_INTERP 0x0200 /* enable interpolation */
+#define DMODE_REVERSE 0x0400 /* reverse stereo */
+#define DMODE_SIMDMIXER 0x0800 /* enable SIMD mixing */
+#define DMODE_NOISEREDUCTION 0x1000 /* Low pass filtering */
+
+
+struct SAMPLOAD;
+
+typedef struct MDRIVER {
+ struct MDRIVER* next;
+ const CHAR* Name;
+ const CHAR* Version;
+
+ UBYTE HardVoiceLimit; /* Limit of hardware mixer voices */
+ UBYTE SoftVoiceLimit; /* Limit of software mixer voices */
+
+ const CHAR* Alias;
+ const CHAR* CmdLineHelp;
+
+ void (*CommandLine) (const CHAR*);
+ BOOL (*IsPresent) (void);
+ SWORD (*SampleLoad) (struct SAMPLOAD*,int);
+ void (*SampleUnload) (SWORD);
+ ULONG (*FreeSampleSpace) (int);
+ ULONG (*RealSampleLength) (int,struct SAMPLE*);
+ int (*Init) (void);
+ void (*Exit) (void);
+ int (*Reset) (void);
+ int (*SetNumVoices) (void);
+ int (*PlayStart) (void);
+ void (*PlayStop) (void);
+ void (*Update) (void);
+ void (*Pause) (void);
+ void (*VoiceSetVolume) (UBYTE,UWORD);
+ UWORD (*VoiceGetVolume) (UBYTE);
+ void (*VoiceSetFrequency)(UBYTE,ULONG);
+ ULONG (*VoiceGetFrequency)(UBYTE);
+ void (*VoiceSetPanning) (UBYTE,ULONG);
+ ULONG (*VoiceGetPanning) (UBYTE);
+ void (*VoicePlay) (UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
+ void (*VoiceStop) (UBYTE);
+ BOOL (*VoiceStopped) (UBYTE);
+ SLONG (*VoiceGetPosition) (UBYTE);
+ ULONG (*VoiceRealVolume) (UBYTE);
+} MDRIVER;
+
+/* These variables can be changed at ANY time and results will be immediate */
+MIKMODAPI extern UBYTE md_volume; /* global sound volume (0-128) */
+MIKMODAPI extern UBYTE md_musicvolume; /* volume of song */
+MIKMODAPI extern UBYTE md_sndfxvolume; /* volume of sound effects */
+MIKMODAPI extern UBYTE md_reverb; /* 0 = none; 15 = chaos */
+MIKMODAPI extern UBYTE md_pansep; /* 0 = mono; 128 == 100% (full left/right) */
+
+/* The variables below can be changed at any time, but changes will not be
+ implemented until MikMod_Reset is called. A call to MikMod_Reset may result
+ in a skip or pop in audio (depending on the soundcard driver and the settings
+ changed). */
+MIKMODAPI extern UWORD md_device; /* device */
+MIKMODAPI extern UWORD md_mixfreq; /* mixing frequency */
+MIKMODAPI extern UWORD md_mode; /* mode. See DMODE_? flags above */
+
+/* The following variable should not be changed! */
+MIKMODAPI extern MDRIVER* md_driver; /* Current driver in use. */
+
+/* Known drivers list */
+
+MIKMODAPI extern struct MDRIVER drv_nos; /* no sound */
+MIKMODAPI extern struct MDRIVER drv_pipe; /* piped output */
+MIKMODAPI extern struct MDRIVER drv_raw; /* raw file disk writer [music.raw] */
+MIKMODAPI extern struct MDRIVER drv_stdout; /* output to stdout */
+MIKMODAPI extern struct MDRIVER drv_wav; /* RIFF WAVE file disk writer [music.wav] */
+MIKMODAPI extern struct MDRIVER drv_aiff; /* AIFF file disk writer [music.aiff] */
+
+MIKMODAPI extern struct MDRIVER drv_ultra; /* Linux Ultrasound driver */
+MIKMODAPI extern struct MDRIVER drv_sam9407;/* Linux sam9407 driver */
+
+MIKMODAPI extern struct MDRIVER drv_AF; /* Dec Alpha AudioFile */
+MIKMODAPI extern struct MDRIVER drv_ahi; /* Amiga AHI */
+MIKMODAPI extern struct MDRIVER drv_aix; /* AIX audio device */
+MIKMODAPI extern struct MDRIVER drv_alsa; /* Advanced Linux Sound Architecture (ALSA) */
+MIKMODAPI extern struct MDRIVER drv_esd; /* Enlightened sound daemon (EsounD) */
+MIKMODAPI extern struct MDRIVER drv_pulseaudio; /* PulseAudio */
+MIKMODAPI extern struct MDRIVER drv_hp; /* HP-UX audio device */
+MIKMODAPI extern struct MDRIVER drv_nas; /* Network Audio System (NAS) */
+MIKMODAPI extern struct MDRIVER drv_oss; /* OpenSound System (Linux,FreeBSD...) */
+MIKMODAPI extern struct MDRIVER drv_openal; /* OpenAL driver */
+MIKMODAPI extern struct MDRIVER drv_sdl; /* SDL audio driver */
+MIKMODAPI extern struct MDRIVER drv_sgi; /* SGI audio library */
+MIKMODAPI extern struct MDRIVER drv_sndio; /* OpenBSD sndio */
+MIKMODAPI extern struct MDRIVER drv_sun; /* Sun/NetBSD/OpenBSD audio device */
+
+MIKMODAPI extern struct MDRIVER drv_dart; /* OS/2 Direct Audio RealTime */
+MIKMODAPI extern struct MDRIVER drv_os2; /* OS/2 MMPM/2 */
+
+MIKMODAPI extern struct MDRIVER drv_ds; /* Win32 DirectSound driver */
+MIKMODAPI extern struct MDRIVER drv_xaudio2;/* Win32 XAudio2 driver */
+MIKMODAPI extern struct MDRIVER drv_win; /* Win32 multimedia API driver */
+
+MIKMODAPI extern struct MDRIVER drv_mac; /* Macintosh Sound Manager driver */
+MIKMODAPI extern struct MDRIVER drv_osx; /* MacOS X CoreAudio Driver */
+
+MIKMODAPI extern struct MDRIVER drv_dc; /* Dreamcast driver */
+MIKMODAPI extern struct MDRIVER drv_gp32; /* GP32 Sound driver */
+MIKMODAPI extern struct MDRIVER drv_psp; /* PlayStation Portable driver */
+
+MIKMODAPI extern struct MDRIVER drv_wss; /* DOS WSS driver */
+MIKMODAPI extern struct MDRIVER drv_sb; /* DOS S/B driver */
+
+MIKMODAPI extern struct MDRIVER drv_osles; /* OpenSL ES driver for android */
+
+/*========== Virtual channel mixer interface (for user-supplied drivers only) */
+
+MIKMODAPI extern int VC_Init(void);
+MIKMODAPI extern void VC_Exit(void);
+MIKMODAPI extern void VC_SetCallback(MikMod_callback_t callback);
+MIKMODAPI extern int VC_SetNumVoices(void);
+MIKMODAPI extern ULONG VC_SampleSpace(int);
+MIKMODAPI extern ULONG VC_SampleLength(int,SAMPLE*);
+
+MIKMODAPI extern int VC_PlayStart(void);
+MIKMODAPI extern void VC_PlayStop(void);
+
+MIKMODAPI extern SWORD VC_SampleLoad(struct SAMPLOAD*,int);
+MIKMODAPI extern void VC_SampleUnload(SWORD);
+
+MIKMODAPI extern ULONG VC_WriteBytes(SBYTE*,ULONG);
+MIKMODAPI extern ULONG VC_SilenceBytes(SBYTE*,ULONG);
+
+MIKMODAPI extern void VC_VoiceSetVolume(UBYTE,UWORD);
+MIKMODAPI extern UWORD VC_VoiceGetVolume(UBYTE);
+MIKMODAPI extern void VC_VoiceSetFrequency(UBYTE,ULONG);
+MIKMODAPI extern ULONG VC_VoiceGetFrequency(UBYTE);
+MIKMODAPI extern void VC_VoiceSetPanning(UBYTE,ULONG);
+MIKMODAPI extern ULONG VC_VoiceGetPanning(UBYTE);
+MIKMODAPI extern void VC_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
+
+MIKMODAPI extern void VC_VoiceStop(UBYTE);
+MIKMODAPI extern BOOL VC_VoiceStopped(UBYTE);
+MIKMODAPI extern SLONG VC_VoiceGetPosition(UBYTE);
+MIKMODAPI extern ULONG VC_VoiceRealVolume(UBYTE);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* ex:set ts=4: */
--- /dev/null
+/* Locale insensitive ctype.h functions taken from the RPM library.
+ * RPM is Copyright (c) 1998 by Red Hat Software, Inc.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MIKMOD_CTYPE_H
+#define MIKMOD_CTYPE_H
+
+static inline int mik_isascii(int c) {
+ return ((c & ~0x7f) == 0);
+}
+
+static inline int mik_islower(int c) {
+ return (c >= 'a' && c <= 'z');
+}
+
+static inline int mik_isupper(int c) {
+ return (c >= 'A' && c <= 'Z');
+}
+
+static inline int mik_isalpha(int c) {
+ return (mik_islower(c) || mik_isupper(c));
+}
+
+static inline int mik_isdigit(int c) {
+ return (c >= '0' && c <= '9');
+}
+
+static inline int mik_isxdigit(int c) {
+ return (mik_isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
+}
+
+static inline int mik_isalnum(int c) {
+ return (mik_isalpha(c) || mik_isdigit(c));
+}
+
+static inline int mik_isblank(int c) {
+ return (c == ' ' || c == '\t');
+}
+
+static inline int mik_isspace(int c) {
+ switch (c) {
+ case ' ': case '\t':
+ case '\n': case '\r':
+ case '\f': case '\v': return 1;
+ }
+ return 0;
+}
+
+static inline int mik_isgraph(int c) {
+ return (c > 0x20 && c <= 0x7e);
+}
+
+static inline int mik_isprint(int c) {
+ return (c >= 0x20 && c <= 0x7e);
+}
+
+static inline int mik_toascii(int c) {
+ return (c & 0x7f);
+}
+
+static inline int mik_tolower(int c) {
+ return ((mik_isupper(c)) ? (c | ('a' - 'A')) : c);
+}
+
+static inline int mik_toupper(int c) {
+ return ((mik_islower(c)) ? (c & ~('a' - 'A')) : c);
+}
+
+#endif /* MIKMOD_CTYPE_H */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2005 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ MikMod sound library internal definitions
+
+ ==============================================================================*/
+
+#ifndef _MIKMOD_INTERNALS_H
+#define _MIKMOD_INTERNALS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+
+#if defined(_MSC_VER) && !defined(__cplusplus) && !defined(HAVE_CONFIG_H)
+#define inline __inline
+#endif
+
+#ifndef MIKMOD_UNIX
+#if (defined(unix) || defined(__unix__) || defined(__unix) || \
+ (defined(__APPLE__) && defined(__MACH__))) && \
+ !(defined(__DJGPP__) || defined(_WIN32) || defined(__OS2__) || defined(__EMX__))
+#define MIKMOD_UNIX 1
+#endif
+#endif /* MIKMOD_UNIX */
+
+#include "mikmod.h"
+
+/*========== More type definitions */
+
+/* SLONGLONG: 64bit, signed */
+#if !defined(_WIN32) && \
+ (defined(_LP64) || defined(__LP64__) || defined(__arch64__) || defined(__alpha) || defined(__x64_64) || defined(__powerpc64__))
+typedef long SLONGLONG;
+#define NATIVE_64BIT_INT
+#elif defined(_WIN64) /* win64 is LLP64, not LP64 */
+#define NATIVE_64BIT_INT
+typedef long long SLONGLONG;
+#elif defined(__WATCOMC__)
+typedef __int64 SLONGLONG;
+#elif defined(_WIN32) && !defined(__MWERKS__)
+typedef LONGLONG SLONGLONG;
+#elif defined(macintosh) && !TYPE_LONGLONG
+#include <Types.h>
+typedef SInt64 SLONGLONG;
+#else
+typedef long long SLONGLONG;
+#endif
+typedef int __s64_typetest [(sizeof(SLONGLONG)==8) * 2 - 1];
+
+/* pointer-sized signed int (ssize_t/intptr_t) : */
+#if defined(_WIN64) /* win64 is LLP64, not LP64 */
+typedef long long SINTPTR_T;
+#else
+/* long should be pointer-sized for all others : */
+typedef long SINTPTR_T;
+#endif
+typedef int __iptr_typetest [(sizeof(SINTPTR_T)==sizeof(void*)) * 2 - 1];
+
+/*========== Error handling */
+
+#define _mm_errno MikMod_errno
+#define _mm_critical MikMod_critical
+extern MikMod_handler_t _mm_errorhandler;
+
+/*========== MT stuff */
+
+#ifdef HAVE_PTHREAD
+#include <pthread.h>
+#define DECLARE_MUTEX(name) \
+ extern pthread_mutex_t _mm_mutex_##name
+#define MUTEX_LOCK(name) \
+ pthread_mutex_lock(&_mm_mutex_##name)
+#define MUTEX_UNLOCK(name) \
+ pthread_mutex_unlock(&_mm_mutex_##name)
+
+#elif defined(__OS2__)||defined(__EMX__)
+#define DECLARE_MUTEX(name) \
+ extern HMTX _mm_mutex_##name
+#define MUTEX_LOCK(name) \
+ if(_mm_mutex_##name)\
+ DosRequestMutexSem(_mm_mutex_##name,SEM_INDEFINITE_WAIT)
+#define MUTEX_UNLOCK(name) \
+ if(_mm_mutex_##name)\
+ DosReleaseMutexSem(_mm_mutex_##name)
+
+#elif defined(_WIN32)
+#include <windows.h>
+#define DECLARE_MUTEX(name) \
+ extern HANDLE _mm_mutex_##name
+#define MUTEX_LOCK(name) \
+ if(_mm_mutex_##name)\
+ WaitForSingleObject(_mm_mutex_##name,INFINITE)
+#define MUTEX_UNLOCK(name) \
+ if(_mm_mutex_##name)\
+ ReleaseMutex(_mm_mutex_##name)
+
+#else
+#define DECLARE_MUTEX(name) \
+ extern void *_mm_mutex_##name
+#define MUTEX_LOCK(name)
+#define MUTEX_UNLOCK(name)
+#endif
+
+DECLARE_MUTEX(lists);
+DECLARE_MUTEX(vars);
+
+/*========== Replacement funcs */
+
+extern int _mm_strcasecmp (const char *__s1, const char *__s2);
+
+/*========== Portable file I/O */
+
+extern MREADER* _mm_new_mem_reader(const void *buffer, long len);
+extern void _mm_delete_mem_reader(MREADER *reader);
+
+extern MREADER* _mm_new_file_reader(FILE* fp);
+extern void _mm_delete_file_reader(MREADER*);
+
+extern MWRITER* _mm_new_file_writer(FILE *fp);
+extern void _mm_delete_file_writer(MWRITER*);
+
+extern BOOL _mm_FileExists(const CHAR *fname);
+
+#define _mm_write_SBYTE(x,y) y->Put(y,(int)x)
+#define _mm_write_UBYTE(x,y) y->Put(y,(int)x)
+
+#define _mm_read_SBYTE(x) (SBYTE)x->Get(x)
+#define _mm_read_UBYTE(x) (UBYTE)x->Get(x)
+#define _mm_skip_BYTE(x) (void)x->Get(x)
+
+#define _mm_write_SBYTES(x,y,z) z->Write(z,(const void *)x,y)
+#define _mm_write_UBYTES(x,y,z) z->Write(z,(const void *)x,y)
+#define _mm_read_SBYTES(x,y,z) z->Read(z,(void *)x,y)
+#define _mm_read_UBYTES(x,y,z) z->Read(z,(void *)x,y)
+
+#define _mm_fseek(x,y,z) x->Seek(x,y,z)
+#define _mm_ftell(x) x->Tell(x)
+#define _mm_rewind(x) _mm_fseek(x,0,SEEK_SET)
+
+#define _mm_eof(x) x->Eof(x)
+
+extern void _mm_iobase_setcur(MREADER*);
+extern void _mm_iobase_revert(MREADER*);
+extern FILE* _mm_fopen(const CHAR *, const CHAR *);
+extern int _mm_fclose(FILE *);
+extern void _mm_write_string(const CHAR*,MWRITER*);
+extern BOOL _mm_read_string (CHAR*,int,MREADER*);
+
+extern SWORD _mm_read_M_SWORD(MREADER*);
+extern SWORD _mm_read_I_SWORD(MREADER*);
+extern UWORD _mm_read_M_UWORD(MREADER*);
+extern UWORD _mm_read_I_UWORD(MREADER*);
+
+extern SLONG _mm_read_M_SLONG(MREADER*);
+extern SLONG _mm_read_I_SLONG(MREADER*);
+extern ULONG _mm_read_M_ULONG(MREADER*);
+extern ULONG _mm_read_I_ULONG(MREADER*);
+
+extern BOOL _mm_read_M_SWORDS(SWORD*,int,MREADER*);
+extern BOOL _mm_read_I_SWORDS(SWORD*,int,MREADER*);
+extern BOOL _mm_read_M_UWORDS(UWORD*,int,MREADER*);
+extern BOOL _mm_read_I_UWORDS(UWORD*,int,MREADER*);
+
+extern BOOL _mm_read_M_SLONGS(SLONG*,int,MREADER*);
+extern BOOL _mm_read_I_SLONGS(SLONG*,int,MREADER*);
+extern BOOL _mm_read_M_ULONGS(ULONG*,int,MREADER*);
+extern BOOL _mm_read_I_ULONGS(ULONG*,int,MREADER*);
+
+extern void _mm_write_M_SWORD(SWORD,MWRITER*);
+extern void _mm_write_I_SWORD(SWORD,MWRITER*);
+extern void _mm_write_M_UWORD(UWORD,MWRITER*);
+extern void _mm_write_I_UWORD(UWORD,MWRITER*);
+
+extern void _mm_write_M_SLONG(SLONG,MWRITER*);
+extern void _mm_write_I_SLONG(SLONG,MWRITER*);
+extern void _mm_write_M_ULONG(ULONG,MWRITER*);
+extern void _mm_write_I_ULONG(ULONG,MWRITER*);
+
+extern void _mm_write_M_SWORDS(SWORD*,int,MWRITER*);
+extern void _mm_write_I_SWORDS(SWORD*,int,MWRITER*);
+extern void _mm_write_M_UWORDS(UWORD*,int,MWRITER*);
+extern void _mm_write_I_UWORDS(UWORD*,int,MWRITER*);
+
+extern void _mm_write_M_SLONGS(SLONG*,int,MWRITER*);
+extern void _mm_write_I_SLONGS(SLONG*,int,MWRITER*);
+extern void _mm_write_M_ULONGS(ULONG*,int,MWRITER*);
+extern void _mm_write_I_ULONGS(ULONG*,int,MWRITER*);
+
+/*========== Samples */
+
+/* This is a handle of sorts attached to any sample registered with
+ SL_RegisterSample. Generally, this only need be used or changed by the
+ loaders and drivers of mikmod. */
+typedef struct SAMPLOAD {
+ struct SAMPLOAD *next;
+
+ ULONG length; /* length of sample (in samples!) */
+ ULONG loopstart; /* repeat position (relative to start, in samples) */
+ ULONG loopend; /* repeat end */
+ UWORD infmt,outfmt;
+ int scalefactor;
+ SAMPLE* sample;
+ MREADER* reader;
+} SAMPLOAD;
+
+/*========== Sample and waves loading interface */
+
+extern void SL_HalveSample(SAMPLOAD*,int);
+extern void SL_Sample8to16(SAMPLOAD*);
+extern void SL_Sample16to8(SAMPLOAD*);
+extern void SL_SampleSigned(SAMPLOAD*);
+extern void SL_SampleUnsigned(SAMPLOAD*);
+extern int SL_LoadSamples(void);
+extern SAMPLOAD* SL_RegisterSample(SAMPLE*,int,MREADER*);
+extern int SL_Load(void*,SAMPLOAD*,ULONG);
+extern BOOL SL_Init(SAMPLOAD*);
+extern void SL_Exit(SAMPLOAD*);
+
+/*========== Internal module representation (UniMod) interface */
+
+/* number of notes in an octave */
+#define OCTAVE 12
+
+extern void UniSetRow(UBYTE*);
+extern UBYTE UniGetByte(void);
+extern UWORD UniGetWord(void);
+extern UBYTE* UniFindRow(UBYTE*,UWORD);
+extern void UniSkipOpcode(void);
+extern void UniReset(void);
+extern void UniWriteByte(UBYTE);
+extern void UniWriteWord(UWORD);
+extern void UniNewline(void);
+extern UBYTE* UniDup(void);
+extern BOOL UniInit(void);
+extern void UniCleanup(void);
+extern void UniEffect(UWORD,UWORD);
+#define UniInstrument(x) UniEffect(UNI_INSTRUMENT,x)
+#define UniNote(x) UniEffect(UNI_NOTE,x)
+extern void UniPTEffect(UBYTE,UBYTE);
+extern void UniVolEffect(UWORD,UBYTE);
+
+/*========== Module Commands */
+
+enum {
+ /* Simple note */
+ UNI_NOTE = 1,
+ /* Instrument change */
+ UNI_INSTRUMENT,
+ /* Protracker effects */
+ UNI_PTEFFECT0, /* arpeggio */
+ UNI_PTEFFECT1, /* porta up */
+ UNI_PTEFFECT2, /* porta down */
+ UNI_PTEFFECT3, /* porta to note */
+ UNI_PTEFFECT4, /* vibrato */
+ UNI_PTEFFECT5, /* dual effect 3+A */
+ UNI_PTEFFECT6, /* dual effect 4+A */
+ UNI_PTEFFECT7, /* tremolo */
+ UNI_PTEFFECT8, /* pan */
+ UNI_PTEFFECT9, /* sample offset */
+ UNI_PTEFFECTA, /* volume slide */
+ UNI_PTEFFECTB, /* pattern jump */
+ UNI_PTEFFECTC, /* set volume */
+ UNI_PTEFFECTD, /* pattern break */
+ UNI_PTEFFECTE, /* extended effects */
+ UNI_PTEFFECTF, /* set speed */
+ /* Scream Tracker effects */
+ UNI_S3MEFFECTA, /* set speed */
+ UNI_S3MEFFECTD, /* volume slide */
+ UNI_S3MEFFECTE, /* porta down */
+ UNI_S3MEFFECTF, /* porta up */
+ UNI_S3MEFFECTI, /* tremor */
+ UNI_S3MEFFECTQ, /* retrig */
+ UNI_S3MEFFECTR, /* tremolo */
+ UNI_S3MEFFECTT, /* set tempo */
+ UNI_S3MEFFECTU, /* fine vibrato */
+ UNI_KEYOFF, /* note off */
+ /* Fast Tracker effects */
+ UNI_KEYFADE, /* note fade */
+ UNI_VOLEFFECTS, /* volume column effects */
+ UNI_XMEFFECT4, /* vibrato */
+ UNI_XMEFFECT6, /* dual effect 4+A */
+ UNI_XMEFFECTA, /* volume slide */
+ UNI_XMEFFECTE1, /* fine porta up */
+ UNI_XMEFFECTE2, /* fine porta down */
+ UNI_XMEFFECTEA, /* fine volume slide up */
+ UNI_XMEFFECTEB, /* fine volume slide down */
+ UNI_XMEFFECTG, /* set global volume */
+ UNI_XMEFFECTH, /* global volume slide */
+ UNI_XMEFFECTL, /* set envelope position */
+ UNI_XMEFFECTP, /* pan slide */
+ UNI_XMEFFECTX1, /* extra fine porta up */
+ UNI_XMEFFECTX2, /* extra fine porta down */
+ /* Impulse Tracker effects */
+ UNI_ITEFFECTG, /* porta to note */
+ UNI_ITEFFECTH, /* vibrato */
+ UNI_ITEFFECTI, /* tremor (xy not incremented) */
+ UNI_ITEFFECTM, /* set channel volume */
+ UNI_ITEFFECTN, /* slide / fineslide channel volume */
+ UNI_ITEFFECTP, /* slide / fineslide channel panning */
+ UNI_ITEFFECTT, /* slide tempo */
+ UNI_ITEFFECTU, /* fine vibrato */
+ UNI_ITEFFECTW, /* slide / fineslide global volume */
+ UNI_ITEFFECTY, /* panbrello */
+ UNI_ITEFFECTZ, /* resonant filters */
+ UNI_ITEFFECTS0,
+ /* UltraTracker effects */
+ UNI_ULTEFFECT9, /* Sample fine offset */
+ /* OctaMED effects */
+ UNI_MEDSPEED,
+ UNI_MEDEFFECTF1,/* play note twice */
+ UNI_MEDEFFECTF2,/* delay note */
+ UNI_MEDEFFECTF3,/* play note three times */
+ /* Oktalyzer effects */
+ UNI_OKTARP, /* arpeggio */
+
+ UNI_LAST
+};
+
+extern const UWORD unioperands[UNI_LAST];
+
+/* IT / S3M Extended SS effects: */
+enum {
+ SS_GLISSANDO = 1,
+ SS_FINETUNE,
+ SS_VIBWAVE,
+ SS_TREMWAVE,
+ SS_PANWAVE,
+ SS_FRAMEDELAY,
+ SS_S7EFFECTS,
+ SS_PANNING,
+ SS_SURROUND,
+ SS_HIOFFSET,
+ SS_PATLOOP,
+ SS_NOTECUT,
+ SS_NOTEDELAY,
+ SS_PATDELAY
+};
+
+/* IT Volume column effects */
+enum {
+ VOL_VOLUME = 1,
+ VOL_PANNING,
+ VOL_VOLSLIDE,
+ VOL_PITCHSLIDEDN,
+ VOL_PITCHSLIDEUP,
+ VOL_PORTAMENTO,
+ VOL_VIBRATO
+};
+
+/* IT resonant filter information */
+
+#define UF_MAXMACRO 0x10
+#define UF_MAXFILTER 0x100
+
+#define FILT_CUT 0x80
+#define FILT_RESONANT 0x81
+
+typedef struct FILTER {
+ UBYTE filter,inf;
+} FILTER;
+
+/*========== Instruments */
+
+/* Instrument format flags */
+#define IF_OWNPAN 1
+#define IF_PITCHPAN 2
+
+/* Envelope flags: */
+#define EF_ON 1
+#define EF_SUSTAIN 2
+#define EF_LOOP 4
+#define EF_VOLENV 8
+
+/* New Note Action Flags */
+#define NNA_CUT 0
+#define NNA_CONTINUE 1
+#define NNA_OFF 2
+#define NNA_FADE 3
+
+#define NNA_MASK 3
+
+#define DCT_OFF 0
+#define DCT_NOTE 1
+#define DCT_SAMPLE 2
+#define DCT_INST 3
+
+#define DCA_CUT 0
+#define DCA_OFF 1
+#define DCA_FADE 2
+
+#define KEY_KICK 0
+#define KEY_OFF 1
+#define KEY_FADE 2
+#define KEY_KILL (KEY_OFF|KEY_FADE)
+
+#define KICK_ABSENT 0
+#define KICK_NOTE 1
+#define KICK_KEYOFF 2
+#define KICK_ENV 4
+
+#define AV_IT 1 /* IT vs. XM vibrato info */
+
+/*========== Playing */
+
+#define POS_NONE (-2) /* no loop position defined */
+
+#define LAST_PATTERN (UWORD)(-1) /* special ``end of song'' pattern */
+
+typedef struct ENVPR {
+ UBYTE flg; /* envelope flag */
+ UBYTE pts; /* number of envelope points */
+ UBYTE susbeg; /* envelope sustain index begin */
+ UBYTE susend; /* envelope sustain index end */
+ UBYTE beg; /* envelope loop begin */
+ UBYTE end; /* envelope loop end */
+ SWORD p; /* current envelope counter */
+ UWORD a; /* envelope index a */
+ UWORD b; /* envelope index b */
+ ENVPT* env; /* envelope points */
+} ENVPR;
+
+typedef struct MP_CHANNEL {
+ INSTRUMENT* i;
+ SAMPLE *s;
+ UBYTE sample; /* which sample number */
+ UBYTE note; /* the audible note as heard, direct rep of period */
+ SWORD outvolume; /* output volume (vol + sampcol + instvol) */
+ SBYTE chanvol; /* channel's "global" volume */
+ UWORD fadevol; /* fading volume rate */
+ SWORD panning; /* panning position */
+ UBYTE kick; /* if true = sample has to be restarted */
+ UBYTE kick_flag; /* kick has been true */
+ UWORD period; /* period to play the sample at */
+ UBYTE nna; /* New note action type + master/slave flags */
+
+ UBYTE volflg; /* volume envelope settings */
+ UBYTE panflg; /* panning envelope settings */
+ UBYTE pitflg; /* pitch envelope settings */
+
+ UBYTE keyoff; /* if true = fade out and stuff */
+ SWORD handle; /* which sample-handle */
+ UBYTE notedelay; /* (used for note delay) */
+ SLONG start; /* The starting byte index in the sample */
+} MP_CHANNEL;
+
+typedef struct MP_CONTROL {
+ struct MP_CHANNEL main;
+
+ struct MP_VOICE* slave; /* Audio Slave of current effects control channel */
+
+ UBYTE slavechn; /* Audio Slave of current effects control channel */
+ UBYTE muted; /* if set, channel not played */
+ UWORD ultoffset; /* fine sample offset memory */
+ UBYTE anote; /* the note that indexes the audible */
+ UBYTE oldnote;
+ SWORD ownper;
+ SWORD ownvol;
+ UBYTE dca; /* duplicate check action */
+ UBYTE dct; /* duplicate check type */
+ UBYTE* row; /* row currently playing on this channel */
+ SBYTE retrig; /* retrig value (0 means don't retrig) */
+ ULONG speed; /* what finetune to use */
+ SWORD volume; /* amiga volume (0 t/m 64) to play the sample at */
+
+ SWORD tmpvolume; /* tmp volume */
+ UWORD tmpperiod; /* tmp period */
+ UWORD wantedperiod;/* period to slide to (with effect 3 or 5) */
+
+ UBYTE arpmem; /* arpeggio command memory */
+ UBYTE pansspd; /* panslide speed */
+ UWORD slidespeed;
+ UWORD portspeed; /* noteslide speed (toneportamento) */
+
+ UBYTE s3mtremor; /* s3m tremor (effect I) counter */
+ UBYTE s3mtronof; /* s3m tremor ontime/offtime */
+ UBYTE s3mvolslide;/* last used volslide */
+ SBYTE sliding;
+ UBYTE s3mrtgspeed;/* last used retrig speed */
+ UBYTE s3mrtgslide;/* last used retrig slide */
+
+ UBYTE glissando; /* glissando (0 means off) */
+ UBYTE wavecontrol;
+
+ SBYTE vibpos; /* current vibrato position */
+ UBYTE vibspd; /* "" speed */
+ UBYTE vibdepth; /* "" depth */
+
+ SBYTE trmpos; /* current tremolo position */
+ UBYTE trmspd; /* "" speed */
+ UBYTE trmdepth; /* "" depth */
+
+ UBYTE fslideupspd;
+ UBYTE fslidednspd;
+ UBYTE fportupspd; /* fx E1 (extra fine portamento up) data */
+ UBYTE fportdnspd; /* fx E2 (extra fine portamento dn) data */
+ UBYTE ffportupspd;/* fx X1 (extra fine portamento up) data */
+ UBYTE ffportdnspd;/* fx X2 (extra fine portamento dn) data */
+
+ ULONG hioffset; /* last used high order of sample offset */
+ UWORD soffset; /* last used low order of sample-offset (effect 9) */
+
+ UBYTE sseffect; /* last used Sxx effect */
+ UBYTE ssdata; /* last used Sxx data info */
+ UBYTE chanvolslide;/* last used channel volume slide */
+
+ UBYTE panbwave; /* current panbrello waveform */
+ UBYTE panbpos; /* current panbrello position */
+ SBYTE panbspd; /* "" speed */
+ UBYTE panbdepth; /* "" depth */
+
+ UWORD newsamp; /* set to 1 upon a sample / inst change */
+ UBYTE voleffect; /* Volume Column Effect Memory as used by IT */
+ UBYTE voldata; /* Volume Column Data Memory */
+
+ SWORD pat_reppos; /* patternloop position */
+ UWORD pat_repcnt; /* times to loop */
+} MP_CONTROL;
+
+/* Used by NNA only player (audio control. AUDTMP is used for full effects
+ control). */
+typedef struct MP_VOICE {
+ struct MP_CHANNEL main;
+
+ ENVPR venv;
+ ENVPR penv;
+ ENVPR cenv;
+
+ UWORD avibpos; /* autovibrato pos */
+ UWORD aswppos; /* autovibrato sweep pos */
+
+ ULONG totalvol; /* total volume of channel (before global mixings) */
+
+ BOOL mflag;
+ SWORD masterchn;
+ UWORD masterperiod;
+
+ MP_CONTROL* master; /* index of "master" effects channel */
+} MP_VOICE;
+
+/*========== Loaders */
+
+typedef struct MLOADER {
+ struct MLOADER* next;
+ const CHAR* type;
+ const CHAR* version;
+ BOOL (*Init)(void);
+ BOOL (*Test)(void);
+ BOOL (*Load)(BOOL);
+ void (*Cleanup)(void);
+ CHAR* (*LoadTitle)(void);
+} MLOADER;
+
+/* internal loader variables */
+extern MREADER* modreader;
+extern MODULE of; /* static unimod loading space */
+extern const UWORD finetune[16];
+extern const UWORD npertab[7*OCTAVE];/* used by the original MOD loaders */
+
+extern SBYTE remap[UF_MAXCHAN]; /* for removing empty channels */
+extern UBYTE* poslookup; /* lookup table for pattern jumps after
+ blank pattern removal */
+extern UWORD poslookupcnt;
+extern UWORD* origpositions;
+
+extern BOOL filters; /* resonant filters in use */
+extern UBYTE activemacro; /* active midi macro number for Sxx */
+extern UBYTE filtermacros[UF_MAXMACRO]; /* midi macro settings */
+extern FILTER filtersettings[UF_MAXFILTER]; /* computed filter settings */
+
+extern int* noteindex;
+
+/*========== Internal loader interface */
+
+extern BOOL ReadComment(UWORD);
+extern BOOL ReadLinedComment(UWORD,UWORD);
+extern BOOL AllocPositions(int);
+extern BOOL AllocPatterns(void);
+extern BOOL AllocTracks(void);
+extern BOOL AllocInstruments(void);
+extern BOOL AllocSamples(void);
+extern CHAR* DupStr(const CHAR*, UWORD, BOOL);
+
+/* loader utility functions */
+extern int* AllocLinear(void);
+extern void FreeLinear(void);
+extern int speed_to_finetune(ULONG,int);
+extern void S3MIT_ProcessCmd(UBYTE,UBYTE,unsigned int);
+extern void S3MIT_CreateOrders(BOOL);
+
+/* flags for S3MIT_ProcessCmd */
+#define S3MIT_OLDSTYLE 1 /* behave as old scream tracker */
+#define S3MIT_IT 2 /* behave as impulse tracker */
+#define S3MIT_SCREAM 4 /* enforce scream tracker specific limits */
+
+/* used to convert c4spd to linear XM periods (IT and IMF loaders). */
+extern UWORD getlinearperiod(UWORD,ULONG);
+extern ULONG getfrequency(UWORD,ULONG);
+
+/* loader shared data */
+#define STM_NTRACKERS 3
+extern const CHAR *STM_Signatures[STM_NTRACKERS];
+
+/*========== Player interface */
+
+extern int Player_Init(MODULE*);
+extern void Player_Exit(MODULE*);
+extern void Player_HandleTick(void);
+
+/*========== UnPackers */
+
+typedef BOOL (*MUNPACKER) (struct MREADER*,
+ void** /* unpacked data out */ ,
+ long* /* unpacked data size */ );
+extern BOOL PP20_Unpack(MREADER*, void**, long*);
+extern BOOL MMCMP_Unpack(MREADER*, void**, long*);
+extern BOOL XPK_Unpack(MREADER*, void**, long*);
+extern BOOL S404_Unpack(MREADER*, void**, long*);
+
+/*========== Drivers */
+
+/* max. number of handles a driver has to provide. (not strict) */
+#define MAXSAMPLEHANDLES 384
+
+/* These variables can be changed at ANY time and results will be immediate */
+extern UWORD md_bpm; /* current song / hardware BPM rate */
+
+/* Variables below can be changed via MD_SetNumVoices at any time. However, a
+ call to MD_SetNumVoicess while the driver is active will cause the sound to
+ skip slightly. */
+extern UBYTE md_numchn; /* number of song + sound effects voices */
+extern UBYTE md_sngchn; /* number of song voices */
+extern UBYTE md_sfxchn; /* number of sound effects voices */
+extern UBYTE md_hardchn; /* number of hardware mixed voices */
+extern UBYTE md_softchn; /* number of software mixed voices */
+
+/* This is for use by the hardware drivers only. It points to the registered
+ tickhandler function. */
+extern void (*md_player)(void);
+
+extern SWORD MD_SampleLoad(SAMPLOAD*,int);
+extern void MD_SampleUnload(SWORD);
+extern ULONG MD_SampleSpace(int);
+extern ULONG MD_SampleLength(int,SAMPLE*);
+
+/* uLaw conversion */
+extern void unsignedtoulaw(char *,int);
+
+/* Parameter extraction helper */
+extern CHAR *MD_GetAtom(const CHAR*, const CHAR*, BOOL);
+
+/* Internal software mixer stuff */
+extern void VC_SetupPointers(void);
+extern int VC1_Init(void);
+extern int VC2_Init(void);
+
+#if (MIKMOD_UNIX)
+/* POSIX helper functions */
+extern BOOL MD_Access(const CHAR *);
+extern int MD_DropPrivileges(void);
+#endif
+
+/* Macro to define a missing driver, yet allowing binaries to dynamically link
+ with the library without missing symbol errors */
+#define MISSING(a) MDRIVER a = { NULL, NULL, NULL, 0, 0 }
+
+/*========== Prototypes for non-MT safe versions of some public functions */
+
+extern void _mm_registerdriver(struct MDRIVER*);
+extern void _mm_registerloader(struct MLOADER*);
+extern BOOL MikMod_Active_internal(void);
+extern void MikMod_DisableOutput_internal(void);
+extern int MikMod_EnableOutput_internal(void);
+extern void MikMod_Exit_internal(void);
+extern int MikMod_SetNumVoices_internal(int,int);
+extern void Player_Exit_internal(MODULE*);
+extern void Player_Stop_internal(void);
+extern BOOL Player_Paused_internal(void);
+extern void Sample_Free_internal(SAMPLE*);
+extern void Voice_Play_internal(SBYTE,SAMPLE*,ULONG);
+extern void Voice_SetFrequency_internal(SBYTE,ULONG);
+extern void Voice_SetPanning_internal(SBYTE,ULONG);
+extern void Voice_SetVolume_internal(SBYTE,UWORD);
+extern void Voice_Stop_internal(SBYTE);
+extern BOOL Voice_Stopped_internal(SBYTE);
+
+extern int VC1_PlayStart(void);
+extern int VC2_PlayStart(void);
+extern void VC1_PlayStop(void);
+extern void VC2_PlayStop(void);
+extern int VC1_SetNumVoices(void);
+extern int VC2_SetNumVoices(void);
+
+extern MikMod_callback_t vc_callback;
+
+#ifdef __cplusplus
+}
+#endif
+
+/*========== SIMD mixing routines */
+#undef HAVE_ALTIVEC
+#undef HAVE_SSE2
+#if defined(MIKMOD_SIMD)
+
+#if (defined(__ppc__) || defined(__ppc64__)) && defined(__VEC__) && !(defined(__GNUC__) && (__GNUC__ < 3))
+#define HAVE_ALTIVEC
+
+#elif defined(__GNUC__) && defined(__SSE2__) /* x86 / x86_64 */
+#define HAVE_SSE2
+
+#elif defined(_MSC_VER) && (_MSC_VER >= 1300) && (defined(_M_IX86) || defined(_M_AMD64))
+/* FIXME: emmintrin.h requires VC6 processor pack or VC2003+ */
+#define HAVE_SSE2
+/* avoid some warnings */
+#pragma warning(disable:4761)
+#pragma warning(disable:4391)
+#pragma warning(disable:4244)
+
+#endif /* AltiVec/SSE2 */
+#endif /* MIKMOD_SIMD */
+
+/*========== SIMD mixing helper functions =============*/
+
+#if defined(_WIN64)
+# if defined(_MSC_VER)
+# define IS_ALIGNED_16(ptr) (!((__int64)(ptr) & 15i64))
+# else /* GCC, LCC, .. */
+# define IS_ALIGNED_16(ptr) (!((long long)(ptr) & 15LL))
+# endif
+#else /* long cast should be OK for all else */
+#define IS_ALIGNED_16(ptr) (!((long)(ptr) & 15L))
+#endif
+
+/* Altivec helper function */
+#if defined HAVE_ALTIVEC
+
+#define simd_m128i vector signed int
+#define simd_m128 vector float
+
+#ifdef __GNUC__
+#include <ppc_intrinsics.h>
+#endif
+
+/* Helper functions */
+
+/* Set single float across the four values */
+static inline vector float vec_mul(const vector float a, const vector float b) {
+ return vec_madd(a, b, (const vector float)(0.f));
+}
+
+/* Set single float across the four values */
+static inline vector float vec_load_ps1(const float *pF) {
+ vector float data = vec_lde(0, pF);
+ return vec_splat(vec_perm(data, data, vec_lvsl(0, pF)), 0);
+}
+
+/* Set vector to 0 */
+static inline vector float vec_setzero() {
+ return (vector float) (0.);
+}
+
+static inline vector signed char vec_set1_8(unsigned char splatchar) {
+ vector unsigned char splatmap = vec_lvsl(0, &splatchar);
+ vector unsigned char result = vec_lde(0, &splatchar);
+ splatmap = vec_splat(splatmap, 0);
+ return (vector signed char)vec_perm(result, result, splatmap);
+}
+
+#define PERM_A0 0x00,0x01,0x02,0x03
+#define PERM_A1 0x04,0x05,0x06,0x07
+#define PERM_A2 0x08,0x09,0x0A,0x0B
+#define PERM_A3 0x0C,0x0D,0x0E,0x0F
+#define PERM_B0 0x10,0x11,0x12,0x13
+#define PERM_B1 0x14,0x15,0x16,0x17
+#define PERM_B2 0x18,0x19,0x1A,0x1B
+#define PERM_B3 0x1C,0x1D,0x1E,0x1F
+
+/* Equivalent to _mm_unpacklo_epi32 */
+static inline vector signed int vec_unpacklo(vector signed int a, vector signed int b) {
+ return vec_perm(a, b, (vector unsigned char)(PERM_A0,PERM_A1,PERM_B0,PERM_B1));
+}
+
+/* Equivalent to _mm_srli_si128(a, 8) (without the zeroing in high part). */
+static inline vector signed int vec_hiqq(vector signed int a) {
+ vector signed int b = vec_splat_s32(0);
+ return vec_perm(a, b, (vector unsigned char)(PERM_A2,PERM_A3,PERM_B2,PERM_B3));
+}
+
+/* vec_sra is max +15. We have to do in two times ... */
+#define EXTRACT_SAMPLE_SIMD_F(srce, var, size, mul) var = vec_mul(vec_ctf(vec_sra(vec_ld(0, (vector signed int const *)(srce)), vec_splat_u32(BITSHIFT-size)),0), mul);
+#define EXTRACT_SAMPLE_SIMD_0(srce, var) var = vec_sra(vec_sra(vec_ld(0, (vector signed int const *)(srce)), vec_splat_u32(15)), vec_splat_u32(BITSHIFT+16-15-0));
+#define EXTRACT_SAMPLE_SIMD_8(srce, var) var = vec_sra(vec_sra(vec_ld(0, (vector signed int const *)(srce)), vec_splat_u32(15)), vec_splat_u32(BITSHIFT+16-15-8));
+#define EXTRACT_SAMPLE_SIMD_16(srce, var) var = vec_sra(vec_ld(0, (vector signed int const *)(srce)), vec_splat_u32(BITSHIFT+16-16));
+#define PUT_SAMPLE_SIMD_W(dste, v1, v2) vec_st(vec_packs(v1, v2), 0, dste);
+#define PUT_SAMPLE_SIMD_B(dste, v1, v2, v3, v4) vec_st(vec_add(vec_packs((vector signed short)vec_packs(v1, v2), (vector signed short)vec_packs(v3, v4)), vec_set1_8(128)), 0, dste);
+#define PUT_SAMPLE_SIMD_F(dste, v1) vec_st(v1, 0, dste);
+#define LOAD_PS1_SIMD(ptr) vec_load_ps1(ptr)
+
+#elif defined HAVE_SSE2
+
+#include <emmintrin.h>
+
+/* SSE2 helper function */
+
+static __inline __m128i mm_hiqq(const __m128i a) {
+ return _mm_srli_si128(a, 8); /* get the 64bit upper part. new 64bit upper is undefined (zeroed is fine). */
+}
+
+/* 128-bit mixing macros */
+#define EXTRACT_SAMPLE_SIMD(srce, var, size) var = _mm_srai_epi32(_mm_load_si128((__m128i const *)(srce)), BITSHIFT+16-size);
+#define EXTRACT_SAMPLE_SIMD_F(srce, var, size, mul) var = _mm_mul_ps(_mm_cvtepi32_ps(_mm_srai_epi32(_mm_load_si128((__m128i const *)(srce)), BITSHIFT-size)), mul);
+#define EXTRACT_SAMPLE_SIMD_0(srce, var) EXTRACT_SAMPLE_SIMD(srce, var, 0)
+#define EXTRACT_SAMPLE_SIMD_8(srce, var) EXTRACT_SAMPLE_SIMD(srce, var, 8)
+#define EXTRACT_SAMPLE_SIMD_16(srce, var) EXTRACT_SAMPLE_SIMD(srce, var, 16)
+#define PUT_SAMPLE_SIMD_W(dste, v1, v2) _mm_store_si128((__m128i*)(dste), _mm_packs_epi32(v1, v2));
+#define PUT_SAMPLE_SIMD_B(dste, v1, v2, v3, v4) _mm_store_si128((__m128i*)(dste), _mm_add_epi8(_mm_packs_epi16(_mm_packs_epi32(v1, v2), _mm_packs_epi32(v3, v4)), _mm_set1_epi8(128)));
+#define PUT_SAMPLE_SIMD_F(dste, v1) _mm_store_ps((float*)(dste), v1);
+#define LOAD_PS1_SIMD(ptr) _mm_load_ps1(ptr)
+#define simd_m128i __m128i
+#define simd_m128 __m128
+
+#endif
+
+#if defined(HAVE_SSE2) || defined(HAVE_ALTIVEC)
+/* MikMod_amalloc() returns a 16 byte aligned zero-filled
+ memory in SIMD-enabled builds.
+ - the returned memory can be freed with MikMod_afree()
+ - the returned memory CAN NOT be realloc()'ed safely. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+void* MikMod_amalloc(size_t);
+void MikMod_afree(void *); /* frees if ptr != NULL */
+#ifdef __cplusplus
+}
+#endif
+
+#else /* NO SIMD */
+#define MikMod_amalloc MikMod_malloc
+#define MikMod_afree MikMod_free
+#endif
+
+#endif /* _MIKMOD_INTERNALS_H */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Impulse tracker (IT) module loader
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+#include "mikmod_ctype.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*========== Module structure */
+
+/* header */
+typedef struct ITHEADER {
+ CHAR songname[26];
+ UBYTE blank01[2];
+ UWORD ordnum;
+ UWORD insnum;
+ UWORD smpnum;
+ UWORD patnum;
+ UWORD cwt; /* Created with tracker (y.xx = 0x0yxx) */
+ UWORD cmwt; /* Compatible with tracker ver > than val. */
+ UWORD flags;
+ UWORD special; /* bit 0 set = song message attached */
+ UBYTE globvol;
+ UBYTE mixvol; /* mixing volume [ignored] */
+ UBYTE initspeed;
+ UBYTE inittempo;
+ UBYTE pansep; /* panning separation between channels */
+ UBYTE zerobyte;
+ UWORD msglength;
+ ULONG msgoffset;
+ UBYTE blank02[4];
+ UBYTE pantable[64];
+ UBYTE voltable[64];
+} ITHEADER;
+
+/* sample information */
+typedef struct ITSAMPLE {
+ CHAR filename[12];
+ UBYTE zerobyte;
+ UBYTE globvol;
+ UBYTE flag;
+ UBYTE volume;
+ UBYTE panning;
+ CHAR sampname[28];
+ UWORD convert; /* sample conversion flag */
+ ULONG length;
+ ULONG loopbeg;
+ ULONG loopend;
+ ULONG c5spd;
+ ULONG susbegin;
+ ULONG susend;
+ ULONG sampoffset;
+ UBYTE vibspeed;
+ UBYTE vibdepth;
+ UBYTE vibrate;
+ UBYTE vibwave; /* 0=sine, 1=rampdown, 2=square, 3=random (speed ignored) */
+} ITSAMPLE;
+
+/* instrument information */
+
+#define ITENVCNT 25
+#define ITNOTECNT 120
+typedef struct ITINSTHEADER {
+ ULONG size; /* (dword) Instrument size */
+ CHAR filename[12]; /* (char) Instrument filename */
+ UBYTE zerobyte; /* (byte) Instrument type (always 0) */
+ UBYTE volflg;
+ UBYTE volpts;
+ UBYTE volbeg; /* (byte) Volume loop start (node) */
+ UBYTE volend; /* (byte) Volume loop end (node) */
+ UBYTE volsusbeg; /* (byte) Volume sustain begin (node) */
+ UBYTE volsusend; /* (byte) Volume Sustain end (node) */
+ UBYTE panflg;
+ UBYTE panpts;
+ UBYTE panbeg; /* (byte) channel loop start (node) */
+ UBYTE panend; /* (byte) channel loop end (node) */
+ UBYTE pansusbeg; /* (byte) channel sustain begin (node) */
+ UBYTE pansusend; /* (byte) channel Sustain end (node) */
+ UBYTE pitflg;
+ UBYTE pitpts;
+ UBYTE pitbeg; /* (byte) pitch loop start (node) */
+ UBYTE pitend; /* (byte) pitch loop end (node) */
+ UBYTE pitsusbeg; /* (byte) pitch sustain begin (node) */
+ UBYTE pitsusend; /* (byte) pitch Sustain end (node) */
+ UWORD blank;
+ UBYTE globvol;
+ UBYTE chanpan;
+ UWORD fadeout; /* Envelope end / NNA volume fadeout */
+ UBYTE dnc; /* Duplicate note check */
+ UBYTE dca; /* Duplicate check action */
+ UBYTE dct; /* Duplicate check type */
+ UBYTE nna; /* New Note Action [0,1,2,3] */
+ UWORD trkvers; /* tracker version used to save [files only] */
+ UBYTE ppsep; /* Pitch-pan Separation */
+ UBYTE ppcenter; /* Pitch-pan Center */
+ UBYTE rvolvar; /* random volume varations */
+ UBYTE rpanvar; /* random panning varations */
+ UWORD numsmp; /* Number of samples in instrument [files only] */
+ CHAR name[26]; /* Instrument name */
+ UBYTE blank01[6];
+ UWORD samptable[ITNOTECNT];/* sample for each note [note / samp pairs] */
+ UBYTE volenv[200]; /* volume envelope (IT 1.x stuff) */
+ UBYTE oldvoltick[ITENVCNT];/* volume tick position (IT 1.x stuff) */
+ UBYTE volnode[ITENVCNT]; /* amplitude of volume nodes */
+ UWORD voltick[ITENVCNT]; /* tick value of volume nodes */
+ SBYTE pannode[ITENVCNT]; /* panenv - node points */
+ UWORD pantick[ITENVCNT]; /* tick value of panning nodes */
+ SBYTE pitnode[ITENVCNT]; /* pitchenv - node points */
+ UWORD pittick[ITENVCNT]; /* tick value of pitch nodes */
+} ITINSTHEADER;
+
+/* unpacked note */
+
+typedef struct ITNOTE {
+ UBYTE note,ins,volpan,cmd,inf;
+} ITNOTE;
+
+/*========== Loader data */
+
+static ULONG *paraptr=NULL; /* parapointer array (see IT docs) */
+static ITHEADER *mh=NULL;
+static ITNOTE *itpat=NULL; /* allocate to space for one full pattern */
+static UBYTE *mask=NULL; /* arrays allocated to 64 elements and used for */
+static ITNOTE *last=NULL; /* uncompressing IT's pattern information */
+static int numtrk=0;
+static unsigned int old_effect; /* if set, use S3M old-effects stuffs */
+
+static const CHAR* IT_Version[]={
+ "ImpulseTracker . ",
+ "Compressed ImpulseTracker . ",
+ "ImpulseTracker 2.14p3",
+ "Compressed ImpulseTracker 2.14p3",
+ "ImpulseTracker 2.14p4",
+ "Compressed ImpulseTracker 2.14p4",
+};
+
+/* table for porta-to-note command within volume/panning column */
+static const UBYTE portatable[10]= {0,1,4,8,16,32,64,96,128,255};
+
+/*========== Loader code */
+
+static BOOL IT_Test(void)
+{
+ UBYTE id[4];
+
+ if(!_mm_read_UBYTES(id,4,modreader)) return 0;
+ if(!memcmp(id,"IMPM",4)) return 1;
+ return 0;
+}
+
+static BOOL IT_Init(void)
+{
+ if(!(mh=(ITHEADER*)MikMod_malloc(sizeof(ITHEADER)))) return 0;
+ if(!(poslookup=(UBYTE*)MikMod_malloc(256*sizeof(UBYTE)))) return 0;
+ if(!(itpat=(ITNOTE*)MikMod_malloc(200*64*sizeof(ITNOTE)))) return 0;
+ if(!(mask=(UBYTE*)MikMod_malloc(64*sizeof(UBYTE)))) return 0;
+ if(!(last=(ITNOTE*)MikMod_malloc(64*sizeof(ITNOTE)))) return 0;
+
+ return 1;
+}
+
+static void IT_Cleanup(void)
+{
+ FreeLinear();
+
+ MikMod_free(mh);
+ MikMod_free(poslookup);
+ MikMod_free(itpat);
+ MikMod_free(mask);
+ MikMod_free(last);
+ MikMod_free(paraptr);
+ MikMod_free(origpositions);
+ mh=NULL;
+ poslookup=NULL;
+ itpat=NULL;
+ mask=NULL;
+ last=NULL;
+ paraptr=NULL;
+ origpositions=NULL;
+}
+
+/* Because so many IT files have 64 channels as the set number used, but really
+ only use far less (usually from 8 to 24 still), I had to make this function,
+ which determines the number of channels that are actually USED by a pattern.
+
+ NOTE: You must first seek to the file location of the pattern before calling
+ this procedure.
+
+ Returns 0 on error
+*/
+static BOOL IT_GetNumChannels(UWORD patrows)
+{
+ int row=0,flag,ch;
+
+ do {
+ if((flag=_mm_read_UBYTE(modreader))==EOF) {
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ if(!flag)
+ row++;
+ else {
+ ch=(flag-1)&63;
+ remap[ch]=0;
+ if(flag & 128) mask[ch]=_mm_read_UBYTE(modreader);
+ if(mask[ch]&1) _mm_skip_BYTE(modreader);
+ if(mask[ch]&2) _mm_skip_BYTE(modreader);
+ if(mask[ch]&4) _mm_skip_BYTE(modreader);
+ if(mask[ch]&8) { _mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader); }
+ }
+ } while(row<patrows);
+
+ return 1;
+}
+
+static UBYTE* IT_ConvertTrack(ITNOTE* tr,UWORD numrows)
+{
+ int t;
+ UBYTE note,ins,volpan;
+
+ UniReset();
+
+ for(t=0;t<numrows;t++) {
+ note=tr[t*of.numchn].note;
+ ins=tr[t*of.numchn].ins;
+ volpan=tr[t*of.numchn].volpan;
+
+ if(note!=255) {
+ if(note==253)
+ UniWriteByte(UNI_KEYOFF);
+ else if(note==254) {
+ UniPTEffect(0xc,-1); /* note cut command */
+ volpan=255;
+ } else
+ UniNote(note);
+ }
+
+ if((ins)&&(ins<100))
+ UniInstrument(ins-1);
+ else if(ins==253)
+ UniWriteByte(UNI_KEYOFF);
+ else if(ins!=255) { /* crap */
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return NULL;
+ }
+
+ /* process volume / panning column
+ volume / panning effects do NOT all share the same memory address
+ yet. */
+ if(volpan<=64)
+ UniVolEffect(VOL_VOLUME,volpan);
+ else if(volpan==65) /* fine volume slide up (65-74) - A0 case */
+ UniVolEffect(VOL_VOLSLIDE,0);
+ else if(volpan<=74) { /* fine volume slide up (65-74) - general case */
+ UniVolEffect(VOL_VOLSLIDE,0x0f+((volpan-65)<<4));
+ } else if(volpan==75) /* fine volume slide down (75-84) - B0 case */
+ UniVolEffect(VOL_VOLSLIDE,0);
+ else if(volpan<=84) { /* fine volume slide down (75-84) - general case*/
+ UniVolEffect(VOL_VOLSLIDE,0xf0+(volpan-75));
+ } else if(volpan<=94) /* volume slide up (85-94) */
+ UniVolEffect(VOL_VOLSLIDE,((volpan-85)<<4));
+ else if(volpan<=104)/* volume slide down (95-104) */
+ UniVolEffect(VOL_VOLSLIDE,(volpan-95));
+ else if(volpan<=114)/* pitch slide down (105-114) */
+ UniVolEffect(VOL_PITCHSLIDEDN,(volpan-105));
+ else if(volpan<=124)/* pitch slide up (115-124) */
+ UniVolEffect(VOL_PITCHSLIDEUP,(volpan-115));
+ else if(volpan<=127) { /* crap */
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return NULL;
+ } else if(volpan<=192)
+ UniVolEffect(VOL_PANNING,((volpan-128)==64)?255:((volpan-128)<<2));
+ else if(volpan<=202)/* portamento to note */
+ UniVolEffect(VOL_PORTAMENTO,portatable[volpan-193]);
+ else if(volpan<=212)/* vibrato */
+ UniVolEffect(VOL_VIBRATO,(volpan-203));
+ else if((volpan!=239)&&(volpan!=255)) { /* crap */
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return NULL;
+ }
+
+ S3MIT_ProcessCmd(tr[t*of.numchn].cmd,tr[t*of.numchn].inf,
+ old_effect|S3MIT_IT);
+
+ UniNewline();
+ }
+ return UniDup();
+}
+
+static BOOL IT_ReadPattern(UWORD patrows)
+{
+ int row=0,flag,ch,blah;
+ ITNOTE *itt=itpat,dummy,*n,*l;
+
+ memset(itt,255,200*64*sizeof(ITNOTE));
+
+ do {
+ if((flag=_mm_read_UBYTE(modreader))==EOF) {
+ _mm_errno = MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ if(!flag) {
+ itt=&itt[of.numchn];
+ row++;
+ } else {
+ ch=remap[(flag-1)&63];
+ if(ch!=-1) {
+ n=&itt[ch];
+ l=&last[ch];
+ } else
+ n=l=&dummy;
+
+ if(flag&128) mask[ch]=_mm_read_UBYTE(modreader);
+ if(mask[ch]&1)
+ /* convert IT note off to internal note off */
+ if((l->note=n->note=_mm_read_UBYTE(modreader))==255)
+ l->note=n->note=253;
+ if(mask[ch]&2)
+ l->ins=n->ins=_mm_read_UBYTE(modreader);
+ if(mask[ch]&4)
+ l->volpan=n->volpan=_mm_read_UBYTE(modreader);
+ if(mask[ch]&8) {
+ l->cmd=n->cmd=_mm_read_UBYTE(modreader);
+ l->inf=n->inf=_mm_read_UBYTE(modreader);
+ }
+ if(mask[ch]&16)
+ n->note=l->note;
+ if(mask[ch]&32)
+ n->ins=l->ins;
+ if(mask[ch]&64)
+ n->volpan=l->volpan;
+ if(mask[ch]&128) {
+ n->cmd=l->cmd;
+ n->inf=l->inf;
+ }
+ }
+ } while(row<patrows);
+
+ for(blah=0;blah<of.numchn;blah++) {
+ if(!(of.tracks[numtrk++]=IT_ConvertTrack(&itpat[blah],patrows)))
+ return 0;
+ }
+
+ return 1;
+}
+
+static void LoadMidiString(MREADER* r,CHAR* dest)
+{
+ CHAR *curp,*lastp;
+
+ _mm_read_UBYTES(dest,32,r);
+ curp=lastp=dest;
+ /* remove blanks and uppercase all */
+ while(*lastp) {
+ if(mik_isalnum((int)*lastp)) *(curp++)=mik_toupper((int)*lastp);
+ lastp++;
+ }
+ *curp=0;
+}
+
+/* Load embedded midi information for resonant filters */
+static void IT_LoadMidiConfiguration(MREADER* r)
+{
+ int i;
+
+ memset(filtermacros,0,sizeof(filtermacros));
+ memset(filtersettings,0,sizeof(filtersettings));
+
+ if (r) { /* information is embedded in file */
+ UWORD dat;
+ CHAR midiline[33];
+
+ dat=_mm_read_I_UWORD(r);
+ _mm_fseek(r,8*dat+0x120,SEEK_CUR);
+
+ /* read midi macros */
+ for(i=0;i<UF_MAXMACRO;i++) {
+ LoadMidiString(r,midiline);
+ if((!strncmp(midiline,"F0F00",5))&&
+ ((midiline[5]=='0')||(midiline[5]=='1')))
+ filtermacros[i]=(midiline[5]-'0')|0x80;
+ }
+
+ /* read standalone filters */
+ for(i=0x80;i<0x100;i++) {
+ LoadMidiString(r,midiline);
+ if((!strncmp(midiline,"F0F00",5))&&
+ ((midiline[5]=='0')||(midiline[5]=='1'))) {
+ filtersettings[i].filter=(midiline[5]-'0')|0x80;
+ dat=(midiline[6])?(midiline[6]-'0'):0;
+ if(midiline[7])dat=(dat<<4)|(midiline[7]-'0');
+ filtersettings[i].inf=dat;
+ }
+ }
+ } else { /* use default information */
+ filtermacros[0]=FILT_CUT;
+ for(i=0x80;i<0x90;i++) {
+ filtersettings[i].filter=FILT_RESONANT;
+ filtersettings[i].inf=(i&0x7f)<<3;
+ }
+ }
+ activemacro=0;
+ for(i=0;i<0x80;i++) {
+ filtersettings[i].filter=filtermacros[0];
+ filtersettings[i].inf=i;
+ }
+}
+
+static BOOL IT_Load(BOOL curious)
+{
+ int t,u,lp;
+ INSTRUMENT *d;
+ SAMPLE *q;
+ /*BOOL compressed=0;*/
+
+ numtrk=0;
+ filters=0;
+
+ /* try to read module header */
+ _mm_read_I_ULONG(modreader); /* kill the 4 byte header */
+ _mm_read_string(mh->songname,26,modreader);
+ _mm_read_UBYTES(mh->blank01,2,modreader);
+ mh->ordnum =_mm_read_I_UWORD(modreader);
+ mh->insnum =_mm_read_I_UWORD(modreader);
+ mh->smpnum =_mm_read_I_UWORD(modreader);
+ mh->patnum =_mm_read_I_UWORD(modreader);
+ mh->cwt =_mm_read_I_UWORD(modreader);
+ mh->cmwt =_mm_read_I_UWORD(modreader);
+ mh->flags =_mm_read_I_UWORD(modreader);
+ mh->special =_mm_read_I_UWORD(modreader);
+ mh->globvol =_mm_read_UBYTE(modreader);
+ mh->mixvol =_mm_read_UBYTE(modreader);
+ mh->initspeed =_mm_read_UBYTE(modreader);
+ mh->inittempo =_mm_read_UBYTE(modreader);
+ mh->pansep =_mm_read_UBYTE(modreader);
+ mh->zerobyte =_mm_read_UBYTE(modreader);
+ mh->msglength =_mm_read_I_UWORD(modreader);
+ mh->msgoffset =_mm_read_I_ULONG(modreader);
+ _mm_read_UBYTES(mh->blank02,4,modreader);
+ _mm_read_UBYTES(mh->pantable,64,modreader);
+ _mm_read_UBYTES(mh->voltable,64,modreader);
+
+ if(_mm_eof(modreader)) {
+ _mm_errno=MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* set module variables */
+ of.songname = DupStr(mh->songname,26,0); /* make a cstr of songname */
+ of.reppos = 0;
+ of.numpat = mh->patnum;
+ of.numins = mh->insnum;
+ of.numsmp = mh->smpnum;
+ of.initspeed = mh->initspeed;
+ of.inittempo = mh->inittempo;
+ of.initvolume = mh->globvol;
+ of.flags |= UF_BGSLIDES | UF_ARPMEM;
+ if (!(mh->flags & 1))
+ of.flags |= UF_PANNING;
+ of.bpmlimit=32;
+
+ if(mh->songname[25]) {
+ of.numvoices=1+mh->songname[25];
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr,"Embedded IT limitation to %d voices\n",of.numvoices);
+#endif
+ }
+
+ /* set the module type */
+ /* 2.17 : IT 2.14p4 */
+ /* 2.16 : IT 2.14p3 with resonant filters */
+ /* 2.15 : IT 2.14p3 (improved compression) */
+ if((mh->cwt<=0x219)&&(mh->cwt>=0x217))
+ of.modtype=MikMod_strdup(IT_Version[mh->cmwt<0x214?4:5]);
+ else if (mh->cwt>=0x215)
+ of.modtype=MikMod_strdup(IT_Version[mh->cmwt<0x214?2:3]);
+ else {
+ of.modtype = MikMod_strdup(IT_Version[mh->cmwt<0x214?0:1]);
+ of.modtype[mh->cmwt<0x214?15:26] = (mh->cwt>>8)+'0';
+ of.modtype[mh->cmwt<0x214?17:28] = ((mh->cwt>>4)&0xf)+'0';
+ of.modtype[mh->cmwt<0x214?18:29] = ((mh->cwt)&0xf)+'0';
+ }
+
+ if(mh->flags&8)
+ of.flags |= UF_XMPERIODS | UF_LINEAR;
+
+ if((mh->cwt>=0x106)&&(mh->flags&16))
+ old_effect=S3MIT_OLDSTYLE;
+ else
+ old_effect=0;
+
+ /* set panning positions */
+ if (mh->flags & 1)
+ for(t=0;t<64;t++) {
+ mh->pantable[t]&=0x7f;
+ if(mh->pantable[t]<64)
+ of.panning[t]=mh->pantable[t]<<2;
+ else if(mh->pantable[t]==64)
+ of.panning[t]=255;
+ else if(mh->pantable[t]==100)
+ of.panning[t]=PAN_SURROUND;
+ else if(mh->pantable[t]==127)
+ of.panning[t]=PAN_CENTER;
+ else {
+ _mm_errno=MMERR_LOADING_HEADER;
+ return 0;
+ }
+ }
+ else
+ for(t=0;t<64;t++)
+ of.panning[t]=PAN_CENTER;
+
+ /* set channel volumes */
+ memcpy(of.chanvol,mh->voltable,64);
+
+ /* read the order data */
+ if(!AllocPositions(mh->ordnum)) return 0;
+ if(!(origpositions=(UWORD*)MikMod_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
+
+ for(t=0;t<mh->ordnum;t++) {
+ origpositions[t]=_mm_read_UBYTE(modreader);
+ if((origpositions[t]>mh->patnum)&&(origpositions[t]<254))
+ origpositions[t]=255;
+ }
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ poslookupcnt=mh->ordnum;
+ S3MIT_CreateOrders(curious);
+
+ if(!(paraptr=(ULONG*)MikMod_malloc((mh->insnum+mh->smpnum+of.numpat)*
+ sizeof(ULONG)))) return 0;
+
+ /* read the instrument, sample, and pattern parapointers */
+ _mm_read_I_ULONGS(paraptr,mh->insnum+mh->smpnum+of.numpat,modreader);
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* Check for and load midi information for resonant filters */
+ if(mh->cmwt>=0x216) {
+ if(mh->special&8) {
+ IT_LoadMidiConfiguration(modreader);
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+ } else
+ IT_LoadMidiConfiguration(NULL);
+ filters=1;
+ }
+
+ /* Check for and load song comment */
+ if((mh->special&1)&&(mh->cwt>=0x104)&&(mh->msglength)) {
+ _mm_fseek(modreader,(long)(mh->msgoffset),SEEK_SET);
+ if(!ReadComment(mh->msglength)) return 0;
+ }
+
+ if(!(mh->flags&4)) of.numins=of.numsmp;
+ if(!AllocSamples()) return 0;
+
+ if(!AllocLinear()) return 0;
+
+ /* Load all samples */
+ q = of.samples;
+ for(t=0;t<mh->smpnum;t++) {
+ ITSAMPLE s;
+
+ /* seek to sample position */
+ _mm_fseek(modreader,(long)(paraptr[mh->insnum+t]+4),SEEK_SET);
+
+ /* load sample info */
+ _mm_read_string(s.filename,12,modreader);
+ s.zerobyte = _mm_read_UBYTE(modreader);
+ s.globvol = _mm_read_UBYTE(modreader);
+ s.flag = _mm_read_UBYTE(modreader);
+ s.volume = _mm_read_UBYTE(modreader);
+ _mm_read_string(s.sampname,26,modreader);
+ s.convert = _mm_read_UBYTE(modreader);
+ s.panning = _mm_read_UBYTE(modreader);
+ s.length = _mm_read_I_ULONG(modreader);
+ s.loopbeg = _mm_read_I_ULONG(modreader);
+ s.loopend = _mm_read_I_ULONG(modreader);
+ s.c5spd = _mm_read_I_ULONG(modreader);
+ s.susbegin = _mm_read_I_ULONG(modreader);
+ s.susend = _mm_read_I_ULONG(modreader);
+ s.sampoffset = _mm_read_I_ULONG(modreader);
+ s.vibspeed = _mm_read_UBYTE(modreader);
+ s.vibdepth = _mm_read_UBYTE(modreader);
+ s.vibrate = _mm_read_UBYTE(modreader);
+ s.vibwave = _mm_read_UBYTE(modreader);
+
+ /* Generate an error if c5spd is > 512k, or samplelength > 256 megs
+ (nothing would EVER be that high) */
+
+ if(_mm_eof(modreader)||(s.c5spd>0x7ffffL)||(s.length>0xfffffffUL)) {
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ /* Reality check for sample loop information */
+ if((s.flag&16)&&
+ ((s.loopbeg>0xfffffffUL)||(s.loopend>0xfffffffUL))) {
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ q->samplename = DupStr(s.sampname,26,0);
+ q->speed = s.c5spd / 2;
+ q->panning = ((s.panning&127)==64)?255:(s.panning&127)<<2;
+ q->length = s.length;
+ q->loopstart = s.loopbeg;
+ q->loopend = s.loopend;
+ q->volume = s.volume;
+ q->globvol = s.globvol;
+ q->seekpos = s.sampoffset;
+
+ /* Convert speed to XM linear finetune */
+ if(of.flags&UF_LINEAR)
+ q->speed=speed_to_finetune(s.c5spd,t);
+
+ if(s.panning&128) q->flags|=SF_OWNPAN;
+
+ if(s.vibrate) {
+ q->vibflags |= AV_IT;
+ q->vibtype = s.vibwave;
+ q->vibsweep = s.vibrate * 2;
+ q->vibdepth = s.vibdepth;
+ q->vibrate = s.vibspeed;
+ }
+
+ if(s.flag&2) q->flags|=SF_16BITS;
+ if((s.flag&8)&&(mh->cwt>=0x214)) {
+ q->flags|=SF_ITPACKED;
+ /*compressed=1;*/
+ }
+ if(s.flag&16) q->flags|=SF_LOOP;
+ if(s.flag&64) q->flags|=SF_BIDI;
+
+ if(mh->cwt>=0x200) {
+ if(s.convert&1) q->flags|=SF_SIGNED;
+ if(s.convert&4) q->flags|=SF_DELTA;
+ }
+ q++;
+ }
+
+ /* Load instruments if instrument mode flag enabled */
+ if(mh->flags&4) {
+ if(!AllocInstruments()) return 0;
+ d=of.instruments;
+ of.flags|=UF_NNA|UF_INST;
+
+ for(t=0;t<mh->insnum;t++) {
+ ITINSTHEADER ih;
+
+ /* seek to instrument position */
+ _mm_fseek(modreader,paraptr[t]+4,SEEK_SET);
+
+ /* load instrument info */
+ _mm_read_string(ih.filename,12,modreader);
+ ih.zerobyte = _mm_read_UBYTE(modreader);
+ if(mh->cwt<0x200) {
+ /* load IT 1.xx inst header */
+ ih.volflg = _mm_read_UBYTE(modreader);
+ ih.volbeg = _mm_read_UBYTE(modreader);
+ ih.volend = _mm_read_UBYTE(modreader);
+ ih.volsusbeg = _mm_read_UBYTE(modreader);
+ ih.volsusend = _mm_read_UBYTE(modreader);
+ _mm_read_I_UWORD(modreader);
+ ih.fadeout = _mm_read_I_UWORD(modreader);
+ ih.nna = _mm_read_UBYTE(modreader);
+ ih.dnc = _mm_read_UBYTE(modreader);
+ } else {
+ /* Read IT200+ header */
+ ih.nna = _mm_read_UBYTE(modreader);
+ ih.dct = _mm_read_UBYTE(modreader);
+ ih.dca = _mm_read_UBYTE(modreader);
+ ih.fadeout = _mm_read_I_UWORD(modreader);
+ ih.ppsep = _mm_read_UBYTE(modreader);
+ ih.ppcenter = _mm_read_UBYTE(modreader);
+ ih.globvol = _mm_read_UBYTE(modreader);
+ ih.chanpan = _mm_read_UBYTE(modreader);
+ ih.rvolvar = _mm_read_UBYTE(modreader);
+ ih.rpanvar = _mm_read_UBYTE(modreader);
+ }
+
+ ih.trkvers = _mm_read_I_UWORD(modreader);
+ ih.numsmp = _mm_read_UBYTE(modreader);
+ _mm_skip_BYTE(modreader);
+ _mm_read_string(ih.name,26,modreader);
+ _mm_read_UBYTES(ih.blank01,6,modreader);
+ _mm_read_I_UWORDS(ih.samptable,ITNOTECNT,modreader);
+ if(mh->cwt<0x200) {
+ /* load IT 1xx volume envelope */
+ _mm_read_UBYTES(ih.volenv,200,modreader);
+ for(lp=0;lp<ITENVCNT;lp++) {
+ ih.oldvoltick[lp] = _mm_read_UBYTE(modreader);
+ ih.volnode[lp] = _mm_read_UBYTE(modreader);
+ }
+ } else {
+ /* load IT 2xx volume, pan and pitch envelopes */
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define IT_LoadEnvelope(name,type) \
+ ih. name##flg =_mm_read_UBYTE(modreader); \
+ ih. name##pts =_mm_read_UBYTE(modreader); \
+ if (ih. name##pts > ITENVCNT) \
+ ih. name##pts = ITENVCNT; \
+ ih. name##beg =_mm_read_UBYTE(modreader); \
+ ih. name##end =_mm_read_UBYTE(modreader); \
+ ih. name##susbeg=_mm_read_UBYTE(modreader); \
+ ih. name##susend=_mm_read_UBYTE(modreader); \
+ for(lp=0;lp<ITENVCNT;lp++) { \
+ ih. name##node[lp]=_mm_read_##type (modreader); \
+ ih. name##tick[lp]=_mm_read_I_UWORD(modreader); \
+ } \
+ _mm_skip_BYTE(modreader)
+#else
+#define IT_LoadEnvelope(name,type) \
+ ih. name/**/flg =_mm_read_UBYTE(modreader); \
+ ih. name/**/pts =_mm_read_UBYTE(modreader); \
+ if (ih. name/**/pts > ITENVCNT) \
+ ih. name/**/pts = ITENVCNT; \
+ ih. name/**/beg =_mm_read_UBYTE(modreader); \
+ ih. name/**/end =_mm_read_UBYTE(modreader); \
+ ih. name/**/susbeg=_mm_read_UBYTE(modreader); \
+ ih. name/**/susend=_mm_read_UBYTE(modreader); \
+ for(lp=0;lp<ITENVCNT;lp++) { \
+ ih. name/**/node[lp]=_mm_read_/**/type (modreader); \
+ ih. name/**/tick[lp]=_mm_read_I_UWORD(modreader); \
+ } \
+ _mm_skip_BYTE(modreader)
+#endif
+
+ IT_LoadEnvelope(vol,UBYTE);
+ IT_LoadEnvelope(pan,SBYTE);
+ IT_LoadEnvelope(pit,SBYTE);
+#undef IT_LoadEnvelope
+ }
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ d->volflg|=EF_VOLENV;
+ d->insname = DupStr(ih.name,26,0);
+ d->nnatype = ih.nna & NNA_MASK;
+
+ if(mh->cwt<0x200) {
+ d->volfade=ih.fadeout<< 6;
+ if(ih.dnc) {
+ d->dct=DCT_NOTE;
+ d->dca=DCA_CUT;
+ }
+
+ if(ih.volflg&1) d->volflg|=EF_ON;
+ if(ih.volflg&2) d->volflg|=EF_LOOP;
+ if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
+
+ /* XM conversion of IT envelope Array */
+ d->volbeg = ih.volbeg;
+ d->volend = ih.volend;
+ d->volsusbeg = ih.volsusbeg;
+ d->volsusend = ih.volsusend;
+
+ if(ih.volflg&1) {
+ for(u=0;u<ITENVCNT;u++)
+ if(ih.oldvoltick[d->volpts]!=0xff) {
+ d->volenv[d->volpts].val=(ih.volnode[d->volpts]<<2);
+ d->volenv[d->volpts].pos=ih.oldvoltick[d->volpts];
+ d->volpts++;
+ } else
+ break;
+ }
+ } else {
+ d->panning=((ih.chanpan&127)==64)?255:(ih.chanpan&127)<<2;
+ if(!(ih.chanpan&128)) d->flags|=IF_OWNPAN;
+
+ if(!(ih.ppsep & 128)) {
+ d->pitpansep=ih.ppsep<<2;
+ d->pitpancenter=ih.ppcenter;
+ d->flags|=IF_PITCHPAN;
+ }
+ d->globvol=ih.globvol>>1;
+ d->volfade=ih.fadeout<<5;
+ d->dct =ih.dct;
+ d->dca =ih.dca;
+
+ if(mh->cwt>=0x204) {
+ d->rvolvar = ih.rvolvar;
+ d->rpanvar = ih.rpanvar;
+ }
+
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define IT_ProcessEnvelope(name) \
+ if(ih. name##flg&1) d-> name##flg|=EF_ON; \
+ if(ih. name##flg&2) d-> name##flg|=EF_LOOP; \
+ if(ih. name##flg&4) d-> name##flg|=EF_SUSTAIN; \
+ d-> name##pts=ih. name##pts; \
+ d-> name##beg=ih. name##beg; \
+ d-> name##end=ih. name##end; \
+ d-> name##susbeg=ih. name##susbeg; \
+ d-> name##susend=ih. name##susend; \
+ \
+ for(u=0;u<ih. name##pts;u++) \
+ d-> name##env[u].pos=ih. name##tick[u]; \
+ \
+ if((d-> name##flg&EF_ON)&&(d-> name##pts<2)) \
+ d-> name##flg&=~EF_ON
+#else
+#define IT_ProcessEnvelope(name) \
+ if(ih. name/**/flg&1) d-> name/**/flg|=EF_ON; \
+ if(ih. name/**/flg&2) d-> name/**/flg|=EF_LOOP; \
+ if(ih. name/**/flg&4) d-> name/**/flg|=EF_SUSTAIN; \
+ d-> name/**/pts=ih. name/**/pts; \
+ d-> name/**/beg=ih. name/**/beg; \
+ d-> name/**/end=ih. name/**/end; \
+ d-> name/**/susbeg=ih. name/**/susbeg; \
+ d-> name/**/susend=ih. name/**/susend; \
+ \
+ for(u=0;u<ih. name/**/pts;u++) \
+ d-> name/**/env[u].pos=ih. name/**/tick[u]; \
+ \
+ if((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2)) \
+ d-> name/**/flg&=~EF_ON
+#endif
+
+ IT_ProcessEnvelope(vol);
+
+ for(u=0;u<ih.volpts;u++)
+ d->volenv[u].val=(ih.volnode[u]<<2);
+
+ IT_ProcessEnvelope(pan);
+ for(u=0;u<ih.panpts;u++)
+ d->panenv[u].val=
+ ih.pannode[u]==32?255:(ih.pannode[u]+32)<<2;
+
+ IT_ProcessEnvelope(pit);
+ for(u=0;u<ih.pitpts;u++)
+ d->pitenv[u].val=ih.pitnode[u]+32;
+#undef IT_ProcessEnvelope
+
+ if(ih.pitflg&0x80) {
+ /* filter envelopes not supported yet */
+ d->pitflg&=~EF_ON;
+ ih.pitpts=ih.pitbeg=ih.pitend=0;
+#ifdef MIKMOD_DEBUG
+ {
+ static int warn=0;
+
+ if(!warn)
+ fprintf(stderr, "\rFilter envelopes not supported yet\n");
+ warn=1;
+ }
+#endif
+ }
+ }
+
+ for(u=0;u<ITNOTECNT;u++) {
+ d->samplenote[u]=(ih.samptable[u]&255);
+ d->samplenumber[u]=
+ (ih.samptable[u]>>8)?((ih.samptable[u]>>8)-1):0xffff;
+ if(d->samplenumber[u]>=of.numsmp)
+ d->samplenote[u]=255;
+ else if (of.flags&UF_LINEAR) {
+ int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
+ d->samplenote[u]=(note<0)?0:(note>255?255:note);
+ }
+ }
+
+ d++;
+ }
+ } else if(of.flags & UF_LINEAR) {
+ if(!AllocInstruments()) return 0;
+ d=of.instruments;
+ of.flags|=UF_INST;
+
+ for(t=0;t<mh->smpnum;t++,d++)
+ for(u=0;u<ITNOTECNT;u++) {
+ if(d->samplenumber[u]>=of.numsmp)
+ d->samplenote[u]=255;
+ else {
+ int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
+ d->samplenote[u]=(note<0)?0:(note>255?255:note);
+ }
+ }
+ }
+
+ /* Figure out how many channels this song actually uses */
+ of.numchn=0;
+ memset(remap,-1,UF_MAXCHAN*sizeof(UBYTE));
+ for(t=0;t<of.numpat;t++) {
+ UWORD packlen;
+
+ /* seek to pattern position */
+ if(paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */
+ _mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);
+ _mm_read_I_UWORD(modreader);
+ /* read pattern length (# of rows)
+ Impulse Tracker never creates patterns with less than 32 rows,
+ but some other trackers do, so we only check for more than 256
+ rows */
+ packlen=_mm_read_I_UWORD(modreader);
+ if(packlen>256) {
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ _mm_read_I_ULONG(modreader);
+ if(!IT_GetNumChannels(packlen)) return 0;
+ }
+ }
+
+ /* give each of them a different number */
+ for(t=0;t<UF_MAXCHAN;t++)
+ if(!remap[t])
+ remap[t]=of.numchn++;
+
+ of.numtrk = of.numpat*of.numchn;
+ if(of.numvoices)
+ if (of.numvoices<of.numchn) of.numvoices=of.numchn;
+
+ if(!AllocPatterns()) return 0;
+ if(!AllocTracks()) return 0;
+
+ for(t=0;t<of.numpat;t++) {
+ UWORD packlen;
+
+ /* seek to pattern position */
+ if(!paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */
+ of.pattrows[t]=64;
+ for(u=0;u<of.numchn;u++) {
+ int k;
+
+ UniReset();
+ for(k=0;k<64;k++) UniNewline();
+ of.tracks[numtrk++]=UniDup();
+ }
+ } else {
+ _mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);
+ packlen=_mm_read_I_UWORD(modreader);
+ (void)packlen; /* unused */
+ of.pattrows[t]=_mm_read_I_UWORD(modreader);
+ _mm_read_I_ULONG(modreader);
+ if(!IT_ReadPattern(of.pattrows[t])) return 0;
+ }
+ }
+
+ return 1;
+}
+
+static CHAR *IT_LoadTitle(void)
+{
+ CHAR s[26];
+
+ _mm_fseek(modreader,4,SEEK_SET);
+ if(!_mm_read_UBYTES(s,26,modreader)) return NULL;
+
+ return(DupStr(s,26,0));
+}
+
+/*========== Loader information */
+
+MIKMODAPI MLOADER load_it={
+ NULL,
+ "IT",
+ "IT (Impulse Tracker)",
+ IT_Init,
+ IT_Test,
+ IT_Load,
+ IT_Cleanup,
+ IT_LoadTitle
+};
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Generic MOD loader (Protracker, StarTracker, FastTracker, etc)
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+#include "mikmod_ctype.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*========== Module structure */
+
+typedef struct MSAMPINFO {
+ CHAR samplename[23]; /* 22 in module, 23 in memory */
+ UWORD length;
+ UBYTE finetune;
+ UBYTE volume;
+ UWORD reppos;
+ UWORD replen;
+} MSAMPINFO;
+
+typedef struct MODULEHEADER {
+ CHAR songname[21]; /* the songname.. 20 in module, 21 in memory */
+ MSAMPINFO samples[31]; /* all sampleinfo */
+ UBYTE songlength; /* number of patterns used */
+ UBYTE magic1; /* should be 127 */
+ UBYTE positions[128]; /* which pattern to play at pos */
+ UBYTE magic2[4]; /* string "M.K." or "FLT4" or "FLT8" */
+} MODULEHEADER;
+
+typedef struct MODTYPE {
+ CHAR id[5];
+ UBYTE channels;
+ CHAR *name;
+} MODTYPE;
+
+typedef struct MODNOTE {
+ UBYTE a, b, c, d;
+} MODNOTE;
+
+/*========== Loader variables */
+
+#define MODULEHEADERSIZE 0x438
+
+static CHAR protracker[] = "Protracker";
+static CHAR startrekker[] = "Startrekker";
+static CHAR fasttracker[] = "Fasttracker";
+static CHAR oktalyser[] = "Oktalyser";
+static CHAR oktalyzer[] = "Oktalyzer";
+static CHAR taketracker[] = "TakeTracker";
+static CHAR orpheus[] = "Imago Orpheus (MOD format)";
+
+static MODULEHEADER *mh = NULL;
+static MODNOTE *patbuf = NULL;
+static int modtype, trekker;
+
+/*========== Loader code */
+
+/* given the module ID, determine the number of channels and the tracker
+ description ; also alters modtype */
+static BOOL MOD_CheckType(UBYTE *id, UBYTE *numchn, CHAR **descr)
+{
+ modtype = trekker = 0;
+
+ /* Protracker and variants */
+ if ((!memcmp(id, "M.K.", 4)) || (!memcmp(id, "M!K!", 4))) {
+ *descr = protracker;
+ modtype = 0;
+ *numchn = 4;
+ return 1;
+ }
+
+ /* Star Tracker */
+ if (((!memcmp(id, "FLT", 3)) || (!memcmp(id, "EXO", 3))) &&
+ (mik_isdigit(id[3]))) {
+ *descr = startrekker;
+ modtype = trekker = 1;
+ *numchn = id[3] - '0';
+ if (*numchn == 4 || *numchn == 8)
+ return 1;
+#ifdef MIKMOD_DEBUG
+ else
+ fprintf(stderr, "\rUnknown FLT%d module type\n", *numchn);
+#endif
+ return 0;
+ }
+
+ /* Oktalyzer (Amiga) */
+ if (!memcmp(id, "OKTA", 4)) {
+ *descr = oktalyzer;
+ modtype = 1;
+ *numchn = 8;
+ return 1;
+ }
+
+ /* Oktalyser (Atari) */
+ if (!memcmp(id, "CD81", 4)) {
+ *descr = oktalyser;
+ modtype = 1;
+ *numchn = 8;
+ return 1;
+ }
+
+ /* Fasttracker */
+ if ((!memcmp(id + 1, "CHN", 3)) && (mik_isdigit(id[0]))) {
+ *descr = fasttracker;
+ modtype = 1;
+ *numchn = id[0] - '0';
+ return 1;
+ }
+ /* Fasttracker or Taketracker */
+ if (((!memcmp(id + 2, "CH", 2)) || (!memcmp(id + 2, "CN", 2)))
+ && (mik_isdigit(id[0])) && (mik_isdigit(id[1]))) {
+ if (id[3] == 'H') {
+ *descr = fasttracker;
+ modtype = 2; /* this can also be Imago Orpheus */
+ } else {
+ *descr = taketracker;
+ modtype = 1;
+ }
+ *numchn = (id[0] - '0') * 10 + (id[1] - '0');
+ return 1;
+ }
+
+ return 0;
+}
+
+static BOOL MOD_Test(void)
+{
+ UBYTE id[4], numchn;
+ CHAR *descr;
+
+ _mm_fseek(modreader, MODULEHEADERSIZE, SEEK_SET);
+ if (!_mm_read_UBYTES(id, 4, modreader))
+ return 0;
+
+ if (MOD_CheckType(id, &numchn, &descr))
+ return 1;
+
+ return 0;
+}
+
+static BOOL MOD_Init(void)
+{
+ if (!(mh = (MODULEHEADER *)MikMod_malloc(sizeof(MODULEHEADER))))
+ return 0;
+ return 1;
+}
+
+static void MOD_Cleanup(void)
+{
+ MikMod_free(mh);
+ MikMod_free(patbuf);
+ mh=NULL;
+ patbuf=NULL;
+}
+
+/*
+Old (amiga) noteinfo:
+
+_____byte 1_____ byte2_ _____byte 3_____ byte4_
+/ \ / \ / \ / \
+0000 0000-00000000 0000 0000-00000000
+
+Upper four 12 bits for Lower four Effect command.
+bits of sam- note period. bits of sam-
+ple number. ple number.
+
+*/
+
+static UBYTE ConvertNote(MODNOTE *n, UBYTE lasteffect)
+{
+ UBYTE instrument, effect, effdat, note;
+ UWORD period;
+ UBYTE lastnote = 0;
+
+ /* extract the various information from the 4 bytes that make up a note */
+ instrument = (n->a & 0x10) | (n->c >> 4);
+ period = (((UWORD)n->a & 0xf) << 8) + n->b;
+ effect = n->c & 0xf;
+ effdat = n->d;
+
+ /* Convert the period to a note number */
+ note = 0;
+ if (period) {
+ for (note = 0; note < 7 * OCTAVE; note++)
+ if (period >= npertab[note])
+ break;
+ if (note == 7 * OCTAVE)
+ note = 0;
+ else
+ note++;
+ }
+
+ if (instrument) {
+ /* if instrument does not exist, note cut */
+ if ((instrument > 31) || (!mh->samples[instrument - 1].length)) {
+ UniPTEffect(0xc, 0);
+ if (effect == 0xc)
+ effect = effdat = 0;
+ } else {
+ /* Protracker handling */
+ if (!modtype) {
+ /* if we had a note, then change instrument... */
+ if (note)
+ UniInstrument(instrument - 1);
+ /* ...otherwise, only adjust volume... */
+ else {
+ /* ...unless an effect was specified, which forces a new
+ note to be played */
+ if (effect || effdat) {
+ UniInstrument(instrument - 1);
+ note = lastnote;
+ } else
+ UniPTEffect(0xc,
+ mh->samples[instrument -
+ 1].volume & 0x7f);
+ }
+ } else {
+ /* Fasttracker handling */
+ UniInstrument(instrument - 1);
+ if (!note)
+ note = lastnote;
+ }
+ }
+ }
+ if (note) {
+ UniNote(note + 2 * OCTAVE - 1);
+ lastnote = note;
+ }
+
+ /* Convert pattern jump from Dec to Hex */
+ if (effect == 0xd)
+ effdat = (((effdat & 0xf0) >> 4) * 10) + (effdat & 0xf);
+
+ /* Volume slide, up has priority */
+ if ((effect == 0xa) && (effdat & 0xf) && (effdat & 0xf0))
+ effdat &= 0xf0;
+
+ /* Handle ``heavy'' volumes correctly */
+ if ((effect == 0xc) && (effdat > 0x40))
+ effdat = 0x40;
+
+ /* An isolated 100, 200 or 300 effect should be ignored (no
+ "standalone" porta memory in mod files). However, a sequence such
+ as 1XX, 100, 100, 100 is fine. */
+ if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&
+ (lasteffect < 0x10) && (effect != lasteffect))
+ effect = 0;
+
+ UniPTEffect(effect, effdat);
+ if (effect == 8)
+ of.flags |= UF_PANNING;
+
+ return effect;
+}
+
+static UBYTE *ConvertTrack(MODNOTE *n, int numchn)
+{
+ int t;
+ UBYTE lasteffect = 0x10; /* non existant effect */
+
+ UniReset();
+ for (t = 0; t < 64; t++) {
+ lasteffect = ConvertNote(n,lasteffect);
+ UniNewline();
+ n += numchn;
+ }
+ return UniDup();
+}
+
+/* Loads all patterns of a modfile and converts them into the 3 byte format. */
+static BOOL ML_LoadPatterns(void)
+{
+ int t, s, tracks = 0;
+
+ if (!AllocPatterns())
+ return 0;
+ if (!AllocTracks())
+ return 0;
+
+ /* Allocate temporary buffer for loading and converting the patterns */
+ if (!(patbuf = (MODNOTE *)MikMod_calloc(64U * of.numchn, sizeof(MODNOTE))))
+ return 0;
+
+ if (trekker && of.numchn == 8) {
+ /* Startrekker module dual pattern */
+ for (t = 0; t < of.numpat; t++) {
+ for (s = 0; s < (64U * 4); s++) {
+ patbuf[s].a = _mm_read_UBYTE(modreader);
+ patbuf[s].b = _mm_read_UBYTE(modreader);
+ patbuf[s].c = _mm_read_UBYTE(modreader);
+ patbuf[s].d = _mm_read_UBYTE(modreader);
+ }
+ for (s = 0; s < 4; s++)
+ if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))
+ return 0;
+ for (s = 0; s < (64U * 4); s++) {
+ patbuf[s].a = _mm_read_UBYTE(modreader);
+ patbuf[s].b = _mm_read_UBYTE(modreader);
+ patbuf[s].c = _mm_read_UBYTE(modreader);
+ patbuf[s].d = _mm_read_UBYTE(modreader);
+ }
+ for (s = 0; s < 4; s++)
+ if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))
+ return 0;
+ }
+ } else {
+ /* Generic module pattern */
+ for (t = 0; t < of.numpat; t++) {
+ /* Load the pattern into the temp buffer and convert it */
+ for (s = 0; s < (int)(64U * of.numchn); s++) {
+ patbuf[s].a = _mm_read_UBYTE(modreader);
+ patbuf[s].b = _mm_read_UBYTE(modreader);
+ patbuf[s].c = _mm_read_UBYTE(modreader);
+ patbuf[s].d = _mm_read_UBYTE(modreader);
+ }
+ for (s = 0; s < of.numchn; s++)
+ if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, of.numchn)))
+ return 0;
+ }
+ }
+ return 1;
+}
+
+static BOOL MOD_Load(BOOL curious)
+{
+ int t, scan;
+ SAMPLE *q;
+ MSAMPINFO *s;
+ CHAR *descr;
+
+ /* try to read module header */
+ _mm_read_string((CHAR *)mh->songname, 20, modreader);
+ mh->songname[20] = 0; /* just in case */
+
+ for (t = 0; t < 31; t++) {
+ s = &mh->samples[t];
+ _mm_read_string(s->samplename, 22, modreader);
+ s->samplename[22] = 0; /* just in case */
+ s->length = _mm_read_M_UWORD(modreader);
+ s->finetune = _mm_read_UBYTE(modreader);
+ s->volume = _mm_read_UBYTE(modreader);
+ s->reppos = _mm_read_M_UWORD(modreader);
+ s->replen = _mm_read_M_UWORD(modreader);
+ }
+
+ mh->songlength = _mm_read_UBYTE(modreader);
+
+ /* this fixes mods which declare more than 128 positions.
+ * eg: beatwave.mod */
+ if (mh->songlength > 128) { mh->songlength = 128; }
+
+ mh->magic1 = _mm_read_UBYTE(modreader);
+ _mm_read_UBYTES(mh->positions, 128, modreader);
+ _mm_read_UBYTES(mh->magic2, 4, modreader);
+
+ if (_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* set module variables */
+ of.initspeed = 6;
+ of.inittempo = 125;
+ if (!(MOD_CheckType(mh->magic2, &of.numchn, &descr))) {
+ _mm_errno = MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ if (trekker && of.numchn == 8)
+ for (t = 0; t < 128; t++)
+ /* if module pretends to be FLT8, yet the order table
+ contains odd numbers, chances are it's a lying FLT4... */
+ if (mh->positions[t] & 1) {
+ of.numchn = 4;
+ break;
+ }
+ if (trekker && of.numchn == 8)
+ for (t = 0; t < 128; t++)
+ mh->positions[t] >>= 1;
+
+ of.songname = DupStr(mh->songname, 21, 1);
+ of.numpos = mh->songlength;
+ of.reppos = 0;
+
+ /* Count the number of patterns */
+ of.numpat = 0;
+ for (t = 0; t < of.numpos; t++)
+ if (mh->positions[t] > of.numpat)
+ of.numpat = mh->positions[t];
+
+ /* since some old modules embed extra patterns, we have to check the
+ whole list to get the samples' file offsets right - however we can find
+ garbage here, so check carefully */
+ scan = 1;
+ for (t = of.numpos; t < 128; t++)
+ if (mh->positions[t] >= 0x80)
+ scan = 0;
+ if (scan)
+ for (t = of.numpos; t < 128; t++) {
+ if (mh->positions[t] > of.numpat)
+ of.numpat = mh->positions[t];
+ if ((curious) && (mh->positions[t]))
+ of.numpos = t + 1;
+ }
+ of.numpat++;
+ of.numtrk = of.numpat * of.numchn;
+
+ if (!AllocPositions(of.numpos))
+ return 0;
+ for (t = 0; t < of.numpos; t++)
+ of.positions[t] = mh->positions[t];
+
+ /* Finally, init the sampleinfo structures */
+ of.numins = of.numsmp = 31;
+ if (!AllocSamples())
+ return 0;
+ s = mh->samples;
+ q = of.samples;
+ for (t = 0; t < of.numins; t++) {
+ /* convert the samplename */
+ q->samplename = DupStr(s->samplename, 23, 1);
+ /* init the sampleinfo variables and convert the size pointers */
+ q->speed = finetune[s->finetune & 0xf];
+ q->volume = s->volume & 0x7f;
+ q->loopstart = (ULONG)s->reppos << 1;
+ q->loopend = q->loopstart + ((ULONG)s->replen << 1);
+ q->length = (ULONG)s->length << 1;
+ q->flags = SF_SIGNED;
+ /* Imago Orpheus creates MODs with 16 bit samples, check */
+ if ((modtype == 2) && (s->volume & 0x80)) {
+ q->flags |= SF_16BITS;
+ descr = orpheus;
+ }
+ if (s->replen > 2)
+ q->flags |= SF_LOOP;
+
+ s++;
+ q++;
+ }
+
+ of.modtype = MikMod_strdup(descr);
+
+ if (!ML_LoadPatterns())
+ return 0;
+
+ return 1;
+}
+
+static CHAR *MOD_LoadTitle(void)
+{
+ CHAR s[21];
+
+ _mm_fseek(modreader, 0, SEEK_SET);
+ if (!_mm_read_UBYTES(s, 20, modreader))
+ return NULL;
+ s[20] = 0; /* just in case */
+
+ return (DupStr(s, 21, 1));
+}
+
+/*========== Loader information */
+
+MIKMODAPI MLOADER load_mod = {
+ NULL,
+ "Standard module",
+ "MOD (31 instruments)",
+ MOD_Init,
+ MOD_Test,
+ MOD_Load,
+ MOD_Cleanup,
+ MOD_LoadTitle
+};
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Screamtracker (S3M) module loader
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*========== Module structure */
+
+/* header */
+typedef struct S3MHEADER {
+ CHAR songname[28];
+ UBYTE t1a;
+ UBYTE type;
+ UBYTE unused1[2];
+ UWORD ordnum;
+ UWORD insnum;
+ UWORD patnum;
+ UWORD flags;
+ UWORD tracker;
+ UWORD fileformat;
+ CHAR scrm[4];
+ UBYTE mastervol;
+ UBYTE initspeed;
+ UBYTE inittempo;
+ UBYTE mastermult;
+ UBYTE ultraclick;
+ UBYTE pantable;
+ UBYTE unused2[8];
+ UWORD special;
+ UBYTE channels[32];
+} S3MHEADER;
+
+/* sample information */
+typedef struct S3MSAMPLE {
+ UBYTE type;
+ CHAR filename[12];
+ UBYTE memsegh;
+ UWORD memsegl;
+ ULONG length;
+ ULONG loopbeg;
+ ULONG loopend;
+ UBYTE volume;
+ UBYTE dsk;
+ UBYTE pack;
+ UBYTE flags;
+ ULONG c2spd;
+ UBYTE unused[12];
+ CHAR sampname[28];
+ CHAR scrs[4];
+} S3MSAMPLE;
+
+typedef struct S3MNOTE {
+ UBYTE note,ins,vol,cmd,inf;
+} S3MNOTE;
+
+/*========== Loader variables */
+
+static S3MNOTE *s3mbuf = NULL; /* pointer to a complete S3M pattern */
+static S3MHEADER *mh = NULL;
+static UWORD *paraptr = NULL; /* parapointer array (see S3M docs) */
+static unsigned int tracker; /* tracker id */
+
+/* tracker identifiers */
+#define NUMTRACKERS 4
+static const CHAR * S3M_Version[] = {
+ "Screamtracker x.xx",
+ "Imago Orpheus x.xx (S3M format)",
+ "Impulse Tracker x.xx (S3M format)",
+ "Unknown tracker x.xx (S3M format)",
+ "Impulse Tracker 2.14p3 (S3M format)",
+ "Impulse Tracker 2.14p4 (S3M format)"
+};
+/* version number position in above array */
+static const int numeric[NUMTRACKERS]={14,14,16,16};
+
+/*========== Loader code */
+
+static BOOL S3M_Test(void)
+{
+ UBYTE id[4];
+
+ _mm_fseek(modreader,0x2c,SEEK_SET);
+ if(!_mm_read_UBYTES(id,4,modreader)) return 0;
+ if(!memcmp(id,"SCRM",4)) return 1;
+ return 0;
+}
+
+static BOOL S3M_Init(void)
+{
+ if(!(s3mbuf=(S3MNOTE*)MikMod_malloc(32*64*sizeof(S3MNOTE)))) return 0;
+ if(!(mh=(S3MHEADER*)MikMod_malloc(sizeof(S3MHEADER)))) return 0;
+ if(!(poslookup=(UBYTE*)MikMod_malloc(sizeof(UBYTE)*256))) return 0;
+ memset(poslookup,-1,256);
+
+ return 1;
+}
+
+static void S3M_Cleanup(void)
+{
+ MikMod_free(s3mbuf);
+ MikMod_free(paraptr);
+ MikMod_free(poslookup);
+ MikMod_free(mh);
+ MikMod_free(origpositions);
+ s3mbuf=NULL;
+ paraptr=NULL;
+ poslookup=NULL;
+ mh=NULL;
+ origpositions=NULL;
+}
+
+/* Because so many s3m files have 16 channels as the set number used, but really
+ only use far less (usually 8 to 12 still), I had to make this function, which
+ determines the number of channels that are actually USED by a pattern.
+
+ For every channel that's used, it sets the appropriate array entry of the
+ global variable 'remap'
+
+ NOTE: You must first seek to the file location of the pattern before calling
+ this procedure.
+
+ Returns 0 on fail. */
+static BOOL S3M_GetNumChannels(void)
+{
+ int row=0,flag,ch;
+
+ while(row<64) {
+ flag=_mm_read_UBYTE(modreader);
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_PATTERN;
+ return 0;
+ }
+
+ if(flag) {
+ ch=flag&31;
+ if(mh->channels[ch]<32) remap[ch] = 0;
+ if(flag&32) {_mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader);}
+ if(flag&64) _mm_skip_BYTE(modreader);
+ if(flag&128){_mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader);}
+ } else row++;
+ }
+ return 1;
+}
+
+static BOOL S3M_ReadPattern(void)
+{
+ int row=0,flag,ch;
+ S3MNOTE *n,dummy;
+
+ /* clear pattern data */
+ memset(s3mbuf,255,32*64*sizeof(S3MNOTE));
+
+ while(row<64) {
+ flag=_mm_read_UBYTE(modreader);
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_PATTERN;
+ return 0;
+ }
+
+ if(flag) {
+ ch=remap[flag&31];
+
+ if(ch!=-1)
+ n=&s3mbuf[(64U*ch)+row];
+ else
+ n=&dummy;
+
+ if(flag&32) {
+ n->note=_mm_read_UBYTE(modreader);
+ n->ins=_mm_read_UBYTE(modreader);
+ }
+ if(flag&64) {
+ n->vol=_mm_read_UBYTE(modreader);
+ if (n->vol>64) n->vol=64;
+ }
+ if(flag&128) {
+ n->cmd=_mm_read_UBYTE(modreader);
+ n->inf=_mm_read_UBYTE(modreader);
+ }
+ } else row++;
+ }
+ return 1;
+}
+
+static UBYTE* S3M_ConvertTrack(S3MNOTE* tr)
+{
+ int t;
+
+ UniReset();
+ for(t=0;t<64;t++) {
+ UBYTE note,ins,vol;
+
+ note=tr[t].note;
+ ins=tr[t].ins;
+ vol=tr[t].vol;
+
+ if((ins)&&(ins!=255)) UniInstrument(ins-1);
+ if(note!=255) {
+ if(note==254) {
+ UniPTEffect(0xc,0); /* note cut command */
+ vol=255;
+ } else
+ UniNote(((note>>4)*OCTAVE)+(note&0xf)); /* normal note */
+ }
+ if(vol<255) UniPTEffect(0xc,vol);
+
+ S3MIT_ProcessCmd(tr[t].cmd,tr[t].inf,
+ tracker == 1 ? S3MIT_OLDSTYLE | S3MIT_SCREAM : S3MIT_OLDSTYLE);
+ UniNewline();
+ }
+ return UniDup();
+}
+
+static BOOL S3M_Load(BOOL curious)
+{
+ int t,u,track = 0;
+ SAMPLE *q;
+ UBYTE pan[32];
+
+ /* try to read module header */
+ _mm_read_string(mh->songname,28,modreader);
+ mh->t1a =_mm_read_UBYTE(modreader);
+ mh->type =_mm_read_UBYTE(modreader);
+ _mm_read_UBYTES(mh->unused1,2,modreader);
+ mh->ordnum =_mm_read_I_UWORD(modreader);
+ mh->insnum =_mm_read_I_UWORD(modreader);
+ mh->patnum =_mm_read_I_UWORD(modreader);
+ mh->flags =_mm_read_I_UWORD(modreader);
+ mh->tracker =_mm_read_I_UWORD(modreader);
+ mh->fileformat =_mm_read_I_UWORD(modreader);
+ _mm_read_string(mh->scrm,4,modreader);
+ mh->mastervol =_mm_read_UBYTE(modreader);
+ mh->initspeed =_mm_read_UBYTE(modreader);
+ mh->inittempo =_mm_read_UBYTE(modreader);
+ mh->mastermult =_mm_read_UBYTE(modreader);
+ mh->ultraclick =_mm_read_UBYTE(modreader);
+ mh->pantable =_mm_read_UBYTE(modreader);
+ _mm_read_UBYTES(mh->unused2,8,modreader);
+ mh->special =_mm_read_I_UWORD(modreader);
+ _mm_read_UBYTES(mh->channels,32,modreader);
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* then we can decide the module type */
+ tracker=mh->tracker>>12;
+ if((!tracker)||(tracker>=NUMTRACKERS))
+ tracker=NUMTRACKERS-1; /* unknown tracker */
+ else {
+ if(mh->tracker>=0x3217)
+ tracker=NUMTRACKERS+1; /* IT 2.14p4 */
+ else if(mh->tracker>=0x3216)
+ tracker=NUMTRACKERS; /* IT 2.14p3 */
+ else tracker--;
+ }
+ of.modtype = MikMod_strdup(S3M_Version[tracker]);
+ if(tracker<NUMTRACKERS) {
+ of.modtype[numeric[tracker]] = ((mh->tracker>>8) &0xf)+'0';
+ of.modtype[numeric[tracker]+2] = ((mh->tracker>>4)&0xf)+'0';
+ of.modtype[numeric[tracker]+3] = ((mh->tracker)&0xf)+'0';
+ }
+ /* set module variables */
+ of.songname = DupStr(mh->songname,28,0);
+ of.numpat = mh->patnum;
+ of.reppos = 0;
+ of.numins = of.numsmp = mh->insnum;
+ of.initspeed = mh->initspeed;
+ of.inittempo = mh->inittempo;
+ of.initvolume = mh->mastervol<<1;
+ of.flags |= UF_ARPMEM | UF_PANNING;
+ if((mh->tracker==0x1300)||(mh->flags&64))
+ of.flags|=UF_S3MSLIDES;
+ of.bpmlimit = 32;
+
+ /* read the order data */
+ if(!AllocPositions(mh->ordnum)) return 0;
+ if(!(origpositions=(UWORD*)MikMod_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
+
+ for(t=0;t<mh->ordnum;t++) {
+ origpositions[t]=_mm_read_UBYTE(modreader);
+ if((origpositions[t]>=mh->patnum)&&(origpositions[t]<254))
+ origpositions[t]=255/*mh->patnum-1*/;
+ }
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ poslookupcnt=mh->ordnum;
+ S3MIT_CreateOrders(curious);
+
+ if(!(paraptr=(UWORD*)MikMod_malloc((of.numins+of.numpat)*sizeof(UWORD))))
+ return 0;
+
+ /* read the instrument+pattern parapointers */
+ _mm_read_I_UWORDS(paraptr,of.numins+of.numpat,modreader);
+
+ if(mh->pantable==252) {
+ /* read the panning table (ST 3.2 addition. See below for further
+ portions of channel panning [past reampper]). */
+ _mm_read_UBYTES(pan,32,modreader);
+ }
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* load samples */
+ if(!AllocSamples()) return 0;
+ q = of.samples;
+ for(t=0;t<of.numins;t++) {
+ S3MSAMPLE s;
+
+ /* seek to instrument position */
+ _mm_fseek(modreader,((long)paraptr[t])<<4,SEEK_SET);
+ /* and load sample info */
+ s.type =_mm_read_UBYTE(modreader);
+ _mm_read_string(s.filename,12,modreader);
+ s.memsegh =_mm_read_UBYTE(modreader);
+ s.memsegl =_mm_read_I_UWORD(modreader);
+ s.length =_mm_read_I_ULONG(modreader);
+ s.loopbeg =_mm_read_I_ULONG(modreader);
+ s.loopend =_mm_read_I_ULONG(modreader);
+ s.volume =_mm_read_UBYTE(modreader);
+ s.dsk =_mm_read_UBYTE(modreader);
+ s.pack =_mm_read_UBYTE(modreader);
+ s.flags =_mm_read_UBYTE(modreader);
+ s.c2spd =_mm_read_I_ULONG(modreader);
+ _mm_read_UBYTES(s.unused,12,modreader);
+ _mm_read_string(s.sampname,28,modreader);
+ _mm_read_string(s.scrs,4,modreader);
+
+ /* ScreamTracker imposes a 64000 bytes (not 64k !) limit */
+ /* enforce it, if we'll use S3MIT_SCREAM in S3M_ConvertTrack() */
+ if (s.length > 64000 && tracker == 1)
+ s.length = 64000;
+
+ if(_mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ q->samplename = DupStr(s.sampname,28,0);
+ q->speed = s.c2spd;
+ q->length = s.length;
+ q->loopstart = s.loopbeg;
+ q->loopend = s.loopend;
+ q->volume = s.volume;
+ q->seekpos = (((ULONG)s.memsegh)<<16|s.memsegl)<<4;
+
+ if(s.flags&1) q->flags |= SF_LOOP;
+ if(s.flags&4) q->flags |= SF_16BITS;
+ if(mh->fileformat==1) q->flags |= SF_SIGNED;
+
+ /* don't load sample if it doesn't have the SCRS tag */
+ if(memcmp(s.scrs,"SCRS",4)) q->length = 0;
+
+ q++;
+ }
+
+ /* determine the number of channels actually used. */
+ of.numchn = 0;
+ memset(remap,-1,32*sizeof(UBYTE));
+ for(t=0;t<of.numpat;t++) {
+ /* seek to pattern position (+2 skip pattern length) */
+ _mm_fseek(modreader,(long)((paraptr[of.numins+t])<<4)+2,SEEK_SET);
+ if(!S3M_GetNumChannels()) return 0;
+ }
+
+ /* build the remap array */
+ for(t=0;t<32;t++)
+ if(!remap[t])
+ remap[t]=of.numchn++;
+
+ /* set panning positions after building remap chart! */
+ for(t=0;t<32;t++)
+ if((mh->channels[t]<32)&&(remap[t]!=-1)) {
+ if(mh->channels[t]<8)
+ of.panning[remap[t]]=0x30;
+ else
+ of.panning[remap[t]]=0xc0;
+ }
+ if(mh->pantable==252)
+ /* set panning positions according to panning table (new for st3.2) */
+ for(t=0;t<32;t++)
+ if((pan[t]&0x20)&&(mh->channels[t]<32)&&(remap[t]!=-1))
+ of.panning[remap[t]]=(pan[t]&0xf)<<4;
+
+ /* load pattern info */
+ of.numtrk=of.numpat*of.numchn;
+ if(!AllocTracks()) return 0;
+ if(!AllocPatterns()) return 0;
+
+ for(t=0;t<of.numpat;t++) {
+ /* seek to pattern position (+2 skip pattern length) */
+ _mm_fseek(modreader,(((long)paraptr[of.numins+t])<<4)+2,SEEK_SET);
+ if(!S3M_ReadPattern()) return 0;
+ for(u=0;u<of.numchn;u++)
+ if(!(of.tracks[track++]=S3M_ConvertTrack(&s3mbuf[u*64]))) return 0;
+ }
+
+ return 1;
+}
+
+static CHAR *S3M_LoadTitle(void)
+{
+ CHAR s[28];
+
+ _mm_fseek(modreader,0,SEEK_SET);
+ if(!_mm_read_UBYTES(s,28,modreader)) return NULL;
+
+ return(DupStr(s,28,0));
+}
+
+/*========== Loader information */
+
+MIKMODAPI MLOADER load_s3m={
+ NULL,
+ "S3M",
+ "S3M (Scream Tracker 3)",
+ S3M_Init,
+ S3M_Test,
+ S3M_Load,
+ S3M_Cleanup,
+ S3M_LoadTitle
+};
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Fasttracker (XM) module loader
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*========== Module structure */
+
+typedef struct XMHEADER {
+ CHAR id[17]; /* ID text: 'Extended module: ' */
+ CHAR songname[21]; /* Module name */
+ CHAR trackername[20]; /* Tracker name */
+ UWORD version; /* Version number */
+ ULONG headersize; /* Header size */
+ UWORD songlength; /* Song length (in patten order table) */
+ UWORD restart; /* Restart position */
+ UWORD numchn; /* Number of channels (2,4,6,8,10,...,32) */
+ UWORD numpat; /* Number of patterns (max 256) */
+ UWORD numins; /* Number of instruments (max 128) */
+ UWORD flags;
+ UWORD tempo; /* Default tempo */
+ UWORD bpm; /* Default BPM */
+ UBYTE orders[256]; /* Pattern order table */
+} XMHEADER;
+
+typedef struct XMINSTHEADER {
+ ULONG size; /* Instrument size */
+ CHAR name[22]; /* Instrument name */
+ UBYTE type; /* Instrument type (always 0) */
+ UWORD numsmp; /* Number of samples in instrument */
+ ULONG ssize;
+} XMINSTHEADER;
+
+#define XMENVCNT (12*2)
+#define XMNOTECNT (8*OCTAVE)
+typedef struct XMPATCHHEADER {
+ UBYTE what[XMNOTECNT]; /* Sample number for all notes */
+ UWORD volenv[XMENVCNT]; /* Points for volume envelope */
+ UWORD panenv[XMENVCNT]; /* Points for panning envelope */
+ UBYTE volpts; /* Number of volume points */
+ UBYTE panpts; /* Number of panning points */
+ UBYTE volsus; /* Volume sustain point */
+ UBYTE volbeg; /* Volume loop start point */
+ UBYTE volend; /* Volume loop end point */
+ UBYTE pansus; /* Panning sustain point */
+ UBYTE panbeg; /* Panning loop start point */
+ UBYTE panend; /* Panning loop end point */
+ UBYTE volflg; /* Volume type: bit 0: On; 1: Sustain; 2: Loop */
+ UBYTE panflg; /* Panning type: bit 0: On; 1: Sustain; 2: Loop */
+ UBYTE vibflg; /* Vibrato type */
+ UBYTE vibsweep; /* Vibrato sweep */
+ UBYTE vibdepth; /* Vibrato depth */
+ UBYTE vibrate; /* Vibrato rate */
+ UWORD volfade; /* Volume fadeout */
+} XMPATCHHEADER;
+
+typedef struct XMWAVHEADER {
+ ULONG length; /* Sample length */
+ ULONG loopstart; /* Sample loop start */
+ ULONG looplength; /* Sample loop length */
+ UBYTE volume; /* Volume */
+ SBYTE finetune; /* Finetune (signed byte -128..+127) */
+ UBYTE type; /* Loop type */
+ UBYTE panning; /* Panning (0-255) */
+ SBYTE relnote; /* Relative note number (signed byte) */
+ UBYTE reserved;
+ CHAR samplename[22]; /* Sample name */
+ UBYTE vibtype; /* Vibrato type */
+ UBYTE vibsweep; /* Vibrato sweep */
+ UBYTE vibdepth; /* Vibrato depth */
+ UBYTE vibrate; /* Vibrato rate */
+} XMWAVHEADER;
+
+typedef struct XMPATHEADER {
+ ULONG size; /* Pattern header length */
+ UBYTE packing; /* Packing type (always 0) */
+ UWORD numrows; /* Number of rows in pattern (1..256) */
+ SWORD packsize; /* Packed patterndata size */
+} XMPATHEADER;
+
+typedef struct XMNOTE {
+ UBYTE note,ins,vol,eff,dat;
+} XMNOTE;
+
+/*========== Loader variables */
+
+static XMNOTE *xmpat=NULL;
+static XMHEADER *mh=NULL;
+
+/* increment unit for sample array reallocation */
+#define XM_SMPINCR 64
+static ULONG *nextwav=NULL;
+static XMWAVHEADER *wh=NULL,*s=NULL;
+
+/*========== Loader code */
+
+static BOOL XM_Test(void)
+{
+ UBYTE id[38];
+
+ if(!_mm_read_UBYTES(id,38,modreader)) return 0;
+ if(memcmp(id,"Extended Module: ",17)) return 0;
+ if(id[37]==0x1a) return 1;
+ return 0;
+}
+
+static BOOL XM_Init(void)
+{
+ if(!(mh=(XMHEADER *)MikMod_malloc(sizeof(XMHEADER)))) return 0;
+ return 1;
+}
+
+static void XM_Cleanup(void)
+{
+ MikMod_free(mh);
+ mh=NULL;
+}
+
+static int XM_ReadNote(XMNOTE* n)
+{
+ UBYTE cmp,result=1;
+
+ memset(n,0,sizeof(XMNOTE));
+ cmp=_mm_read_UBYTE(modreader);
+
+ if(cmp&0x80) {
+ if(cmp&1) { result++;n->note = _mm_read_UBYTE(modreader); }
+ if(cmp&2) { result++;n->ins = _mm_read_UBYTE(modreader); }
+ if(cmp&4) { result++;n->vol = _mm_read_UBYTE(modreader); }
+ if(cmp&8) { result++;n->eff = _mm_read_UBYTE(modreader); }
+ if(cmp&16) { result++;n->dat = _mm_read_UBYTE(modreader); }
+ } else {
+ n->note = cmp;
+ n->ins = _mm_read_UBYTE(modreader);
+ n->vol = _mm_read_UBYTE(modreader);
+ n->eff = _mm_read_UBYTE(modreader);
+ n->dat = _mm_read_UBYTE(modreader);
+ result += 4;
+ }
+ return result;
+}
+
+static UBYTE* XM_Convert(XMNOTE* xmtrack,UWORD rows)
+{
+ int t;
+ UBYTE note,ins,vol,eff,dat;
+
+ UniReset();
+ for(t=0;t<rows;t++) {
+ note = xmtrack->note;
+ ins = xmtrack->ins;
+ vol = xmtrack->vol;
+ eff = xmtrack->eff;
+ dat = xmtrack->dat;
+
+ if(note) {
+ if(note>XMNOTECNT)
+ UniEffect(UNI_KEYFADE,0);
+ else
+ UniNote(note-1);
+ }
+ if(ins) UniInstrument(ins-1);
+
+ switch(vol>>4) {
+ case 0x6: /* volslide down */
+ if(vol&0xf) UniEffect(UNI_XMEFFECTA,vol&0xf);
+ break;
+ case 0x7: /* volslide up */
+ if(vol&0xf) UniEffect(UNI_XMEFFECTA,vol<<4);
+ break;
+
+ /* volume-row fine volume slide is compatible with protracker
+ EBx and EAx effects i.e. a zero nibble means DO NOT SLIDE, as
+ opposed to 'take the last sliding value'. */
+ case 0x8: /* finevol down */
+ UniPTEffect(0xe,0xb0|(vol&0xf));
+ break;
+ case 0x9: /* finevol up */
+ UniPTEffect(0xe,0xa0|(vol&0xf));
+ break;
+ case 0xa: /* set vibrato speed */
+ UniEffect(UNI_XMEFFECT4,vol<<4);
+ break;
+ case 0xb: /* vibrato */
+ UniEffect(UNI_XMEFFECT4,vol&0xf);
+ break;
+ case 0xc: /* set panning */
+ UniPTEffect(0x8,vol<<4);
+ break;
+ case 0xd: /* panning slide left (only slide when data not zero) */
+ if(vol&0xf) UniEffect(UNI_XMEFFECTP,vol&0xf);
+ break;
+ case 0xe: /* panning slide right (only slide when data not zero) */
+ if(vol&0xf) UniEffect(UNI_XMEFFECTP,vol<<4);
+ break;
+ case 0xf: /* tone porta */
+ UniPTEffect(0x3,vol<<4);
+ break;
+ default:
+ if((vol>=0x10)&&(vol<=0x50))
+ UniPTEffect(0xc,vol-0x10);
+ }
+
+ switch(eff) {
+ case 0x4:
+ UniEffect(UNI_XMEFFECT4,dat);
+ break;
+ case 0x6:
+ UniEffect(UNI_XMEFFECT6,dat);
+ break;
+ case 0xa:
+ UniEffect(UNI_XMEFFECTA,dat);
+ break;
+ case 0xe: /* Extended effects */
+ switch(dat>>4) {
+ case 0x1: /* XM fine porta up */
+ UniEffect(UNI_XMEFFECTE1,dat&0xf);
+ break;
+ case 0x2: /* XM fine porta down */
+ UniEffect(UNI_XMEFFECTE2,dat&0xf);
+ break;
+ case 0xa: /* XM fine volume up */
+ UniEffect(UNI_XMEFFECTEA,dat&0xf);
+ break;
+ case 0xb: /* XM fine volume down */
+ UniEffect(UNI_XMEFFECTEB,dat&0xf);
+ break;
+ default:
+ UniPTEffect(eff,dat);
+ }
+ break;
+ case 'G'-55: /* G - set global volume */
+ UniEffect(UNI_XMEFFECTG,dat>64?128:dat<<1);
+ break;
+ case 'H'-55: /* H - global volume slide */
+ UniEffect(UNI_XMEFFECTH,dat);
+ break;
+ case 'K'-55: /* K - keyOff and KeyFade */
+ UniEffect(UNI_KEYFADE,dat);
+ break;
+ case 'L'-55: /* L - set envelope position */
+ UniEffect(UNI_XMEFFECTL,dat);
+ break;
+ case 'P'-55: /* P - panning slide */
+ UniEffect(UNI_XMEFFECTP,dat);
+ break;
+ case 'R'-55: /* R - multi retrig note */
+ UniEffect(UNI_S3MEFFECTQ,dat);
+ break;
+ case 'T'-55: /* T - Tremor */
+ UniEffect(UNI_S3MEFFECTI,dat);
+ break;
+ case 'X'-55:
+ switch(dat>>4) {
+ case 1: /* X1 - Extra Fine Porta up */
+ UniEffect(UNI_XMEFFECTX1,dat&0xf);
+ break;
+ case 2: /* X2 - Extra Fine Porta down */
+ UniEffect(UNI_XMEFFECTX2,dat&0xf);
+ break;
+ }
+ break;
+ default:
+ if(eff<=0xf) {
+ /* the pattern jump destination is written in decimal,
+ but it seems some poor tracker software writes them
+ in hexadecimal... (sigh) */
+ if (eff==0xd)
+ /* don't change anything if we're sure it's in hexa */
+ if ((((dat&0xf0)>>4)<=9)&&((dat&0xf)<=9))
+ /* otherwise, convert from dec to hex */
+ dat=(((dat&0xf0)>>4)*10)+(dat&0xf);
+ UniPTEffect(eff,dat);
+ }
+ break;
+ }
+ UniNewline();
+ xmtrack++;
+ }
+ return UniDup();
+}
+
+static BOOL LoadPatterns(BOOL dummypat)
+{
+ int t,u,v,numtrk;
+
+ if(!AllocTracks()) return 0;
+ if(!AllocPatterns()) return 0;
+
+ numtrk=0;
+ for(t=0;t<mh->numpat;t++) {
+ XMPATHEADER ph;
+
+ ph.size =_mm_read_I_ULONG(modreader);
+ if (ph.size<(mh->version==0x0102?8:9)) {
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ ph.packing =_mm_read_UBYTE(modreader);
+ if(ph.packing) {
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ if(mh->version==0x0102)
+ ph.numrows =_mm_read_UBYTE(modreader)+1;
+ else
+ ph.numrows =_mm_read_I_UWORD(modreader);
+ ph.packsize =_mm_read_I_UWORD(modreader);
+
+ ph.size-=(mh->version==0x0102?8:9);
+ if(ph.size)
+ _mm_fseek(modreader,ph.size,SEEK_CUR);
+
+ of.pattrows[t]=ph.numrows;
+
+ if(ph.numrows) {
+ if(!(xmpat=(XMNOTE*)MikMod_calloc(ph.numrows*of.numchn,sizeof(XMNOTE))))
+ return 0;
+
+ /* when packsize is 0, don't try to load a pattern.. it's empty. */
+ if(ph.packsize)
+ for(u=0;u<ph.numrows;u++)
+ for(v=0;v<of.numchn;v++) {
+ if(!ph.packsize) break;
+
+ ph.packsize-=XM_ReadNote(&xmpat[(v*ph.numrows)+u]);
+ if(ph.packsize<0) {
+ MikMod_free(xmpat);xmpat=NULL;
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+ }
+
+ if(ph.packsize) {
+ _mm_fseek(modreader,ph.packsize,SEEK_CUR);
+ }
+
+ if(_mm_eof(modreader)) {
+ MikMod_free(xmpat);xmpat=NULL;
+ _mm_errno=MMERR_LOADING_PATTERN;
+ return 0;
+ }
+
+ for(v=0;v<of.numchn;v++)
+ of.tracks[numtrk++]=XM_Convert(&xmpat[v*ph.numrows],ph.numrows);
+
+ MikMod_free(xmpat);xmpat=NULL;
+ } else {
+ for(v=0;v<of.numchn;v++)
+ of.tracks[numtrk++]=XM_Convert(NULL,ph.numrows);
+ }
+ }
+
+ if(dummypat) {
+ of.pattrows[t]=64;
+ if(!(xmpat=(XMNOTE*)MikMod_calloc(64*of.numchn,sizeof(XMNOTE)))) return 0;
+ for(v=0;v<of.numchn;v++)
+ of.tracks[numtrk++]=XM_Convert(&xmpat[v*64],64);
+ MikMod_free(xmpat);xmpat=NULL;
+ }
+
+ return 1;
+}
+
+static void FixEnvelope(ENVPT *cur, int pts)
+{
+ int u, old, tmp;
+ ENVPT *prev;
+
+ /* Some broken XM editing program will only save the low byte
+ of the position value. Try to compensate by adding the
+ missing high byte. */
+
+ prev = cur++;
+ old = prev->pos;
+
+ for (u = 1; u < pts; u++, prev++, cur++) {
+ if (cur->pos < prev->pos) {
+ if (cur->pos < 0x100) {
+ if (cur->pos > old) /* same hex century */
+ tmp = cur->pos + (prev->pos - old);
+ else
+ tmp = cur->pos | ((prev->pos + 0x100) & 0xff00);
+ old = cur->pos;
+ cur->pos = tmp;
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr, "\rbroken envelope position(%d/%d), %d %d -> %d\n",
+ u, pts, prev->pos, old, cur->pos);
+#endif
+ } else {
+#ifdef MIKMOD_DEBUG
+ /* different brokenness style... fix unknown */
+ fprintf(stderr, "\rbroken envelope position(%d/%d), %d %d\n",
+ u, pts, old, cur->pos);
+#endif
+ old = cur->pos;
+ }
+ } else
+ old = cur->pos;
+ }
+}
+
+static BOOL LoadInstruments(void)
+{
+ int t,u, ck;
+ INSTRUMENT *d;
+ ULONG next=0;
+ UWORD wavcnt=0;
+
+ if(!AllocInstruments()) return 0;
+ d=of.instruments;
+ for(t=0;t<of.numins;t++,d++) {
+ XMINSTHEADER ih;
+ long headend;
+
+ memset(d->samplenumber,0xff,INSTNOTES*sizeof(UWORD));
+
+ /* read instrument header */
+ headend = _mm_ftell(modreader);
+ ih.size = _mm_read_I_ULONG(modreader);
+ headend += ih.size;
+ ck = _mm_ftell(modreader);
+ _mm_fseek(modreader,0,SEEK_END);
+ if ((headend<0) || (_mm_ftell(modreader)<headend) || (headend<ck)) {
+ _mm_fseek(modreader,ck,SEEK_SET);
+ break;
+ }
+ _mm_fseek(modreader,ck,SEEK_SET);
+ _mm_read_string(ih.name, 22, modreader);
+ ih.type = _mm_read_UBYTE(modreader);
+ ih.numsmp = _mm_read_I_UWORD(modreader);
+
+ d->insname = DupStr(ih.name,22,1);
+
+ if((SWORD)ih.size>29) {
+ ih.ssize = _mm_read_I_ULONG(modreader);
+ if(((SWORD)ih.numsmp>0)&&(ih.numsmp<=XMNOTECNT)) {
+ XMPATCHHEADER pth;
+ int p;
+
+ _mm_read_UBYTES (pth.what,XMNOTECNT,modreader);
+ _mm_read_I_UWORDS (pth.volenv, XMENVCNT, modreader);
+ _mm_read_I_UWORDS (pth.panenv, XMENVCNT, modreader);
+ pth.volpts = _mm_read_UBYTE(modreader);
+ pth.panpts = _mm_read_UBYTE(modreader);
+ pth.volsus = _mm_read_UBYTE(modreader);
+ pth.volbeg = _mm_read_UBYTE(modreader);
+ pth.volend = _mm_read_UBYTE(modreader);
+ pth.pansus = _mm_read_UBYTE(modreader);
+ pth.panbeg = _mm_read_UBYTE(modreader);
+ pth.panend = _mm_read_UBYTE(modreader);
+ pth.volflg = _mm_read_UBYTE(modreader);
+ pth.panflg = _mm_read_UBYTE(modreader);
+ pth.vibflg = _mm_read_UBYTE(modreader);
+ pth.vibsweep = _mm_read_UBYTE(modreader);
+ pth.vibdepth = _mm_read_UBYTE(modreader);
+ pth.vibrate = _mm_read_UBYTE(modreader);
+ pth.volfade = _mm_read_I_UWORD(modreader);
+
+ /* read the remainder of the header
+ (2 bytes for 1.03, 22 for 1.04) */
+ if (headend>=_mm_ftell(modreader)) {
+ for(u=headend-_mm_ftell(modreader);u;u--) {
+ _mm_skip_BYTE(modreader);
+ }
+ }
+
+ /* we can't trust the envelope point count here, as some
+ modules have incorrect values (K_OSPACE.XM reports 32 volume
+ points, for example). */
+ if(pth.volpts>XMENVCNT/2) pth.volpts=XMENVCNT/2;
+ if(pth.panpts>XMENVCNT/2) pth.panpts=XMENVCNT/2;
+
+ if((_mm_eof(modreader))||(pth.volpts>XMENVCNT/2)||(pth.panpts>XMENVCNT/2)) {
+ MikMod_free(nextwav);nextwav=NULL;
+ MikMod_free(wh);wh=NULL;
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ for(u=0;u<XMNOTECNT;u++)
+ d->samplenumber[u]=pth.what[u]+of.numsmp;
+ d->volfade = pth.volfade;
+
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define XM_ProcessEnvelope(name) \
+ for (u = 0; u < (XMENVCNT >> 1); u++) { \
+ d-> name##env[u].pos = pth. name##env[u << 1]; \
+ d-> name##env[u].val = pth. name##env[(u << 1)+ 1]; \
+ } \
+ if (pth. name##flg&1) d-> name##flg|=EF_ON; \
+ if (pth. name##flg&2) d-> name##flg|=EF_SUSTAIN; \
+ if (pth. name##flg&4) d-> name##flg|=EF_LOOP; \
+ d-> name##susbeg=d-> name##susend=pth. name##sus; \
+ d-> name##beg=pth. name##beg; \
+ d-> name##end=pth. name##end; \
+ d-> name##pts=pth. name##pts; \
+ \
+ /* scale envelope */ \
+ for (p=0;p<XMENVCNT/2;p++) \
+ d-> name##env[p].val<<=2; \
+ \
+ if ((d-> name##flg&EF_ON)&&(d-> name##pts<2)) \
+ d-> name##flg&=~EF_ON
+#else
+#define XM_ProcessEnvelope(name) \
+ for (u = 0; u < (XMENVCNT >> 1); u++) { \
+ d-> name/**/env[u].pos = pth. name/**/env[u << 1]; \
+ d-> name/**/env[u].val = pth. name/**/env[(u << 1)+ 1]; \
+ } \
+ if (pth. name/**/flg&1) d-> name/**/flg|=EF_ON; \
+ if (pth. name/**/flg&2) d-> name/**/flg|=EF_SUSTAIN; \
+ if (pth. name/**/flg&4) d-> name/**/flg|=EF_LOOP; \
+ d-> name/**/susbeg=d-> name/**/susend= \
+ pth. name/**/sus; \
+ d-> name/**/beg=pth. name/**/beg; \
+ d-> name/**/end=pth. name/**/end; \
+ d-> name/**/pts=pth. name/**/pts; \
+ \
+ /* scale envelope */ \
+ for (p=0;p<XMENVCNT/2;p++) \
+ d-> name/**/env[p].val<<=2; \
+ \
+ if ((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2)) \
+ d-> name/**/flg&=~EF_ON
+#endif
+
+ XM_ProcessEnvelope(vol);
+ XM_ProcessEnvelope(pan);
+#undef XM_ProcessEnvelope
+
+ if (d->volflg & EF_ON)
+ FixEnvelope(d->volenv, d->volpts);
+ if (d->panflg & EF_ON)
+ FixEnvelope(d->panenv, d->panpts);
+
+ /* Samples are stored outside the instrument struct now, so we
+ have to load them all into a temp area, count the of.numsmp
+ along the way and then do an AllocSamples() and move
+ everything over */
+ if(mh->version>0x0103) next = 0;
+ for(u=0;u<ih.numsmp;u++,s++) {
+ /* Allocate more room for sample information if necessary */
+ if(of.numsmp+u==wavcnt) {
+ wavcnt+=XM_SMPINCR;
+ if(!(nextwav=(ULONG*)MikMod_realloc(nextwav,wavcnt*sizeof(ULONG)))){
+ MikMod_free(wh);wh=NULL;
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ return 0;
+ }
+ if(!(wh=(XMWAVHEADER*)MikMod_realloc(wh,wavcnt*sizeof(XMWAVHEADER)))) {
+ MikMod_free(nextwav);nextwav=NULL;
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ return 0;
+ }
+ s=wh+(wavcnt-XM_SMPINCR);
+ }
+
+ s->length =_mm_read_I_ULONG (modreader);
+ s->loopstart =_mm_read_I_ULONG (modreader);
+ s->looplength =_mm_read_I_ULONG (modreader);
+ s->volume =_mm_read_UBYTE (modreader);
+ s->finetune =_mm_read_SBYTE (modreader);
+ s->type =_mm_read_UBYTE (modreader);
+ s->panning =_mm_read_UBYTE (modreader);
+ s->relnote =_mm_read_SBYTE (modreader);
+ s->vibtype = pth.vibflg;
+ s->vibsweep = pth.vibsweep;
+ s->vibdepth = pth.vibdepth*4;
+ s->vibrate = pth.vibrate;
+ s->reserved =_mm_read_UBYTE (modreader);
+ _mm_read_string(s->samplename, 22, modreader);
+
+ nextwav[of.numsmp+u]=next;
+ next+=s->length;
+
+ /* last instrument is at the end of file in version 0x0104 */
+ if(_mm_eof(modreader) && (mh->version<0x0104 || t<of.numins-1)) {
+ MikMod_free(nextwav);MikMod_free(wh);
+ nextwav=NULL;wh=NULL;
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+ }
+
+ if(mh->version>0x0103) {
+ for(u=0;u<ih.numsmp;u++)
+ nextwav[of.numsmp++]+=_mm_ftell(modreader);
+ _mm_fseek(modreader,next,SEEK_CUR);
+ } else
+ of.numsmp+=ih.numsmp;
+ } else {
+ /* read the remainder of the header */
+ ck = _mm_ftell(modreader);
+ _mm_fseek(modreader,0,SEEK_END);
+ if ((headend<0) || (_mm_ftell(modreader)<headend) || (headend<ck)) {
+ _mm_fseek(modreader,ck,SEEK_SET);
+ break;
+ }
+ _mm_fseek(modreader,ck,SEEK_SET);
+ for(u=headend-_mm_ftell(modreader);u;u--) {
+ _mm_skip_BYTE(modreader);
+ }
+
+ /* last instrument is at the end of file in version 0x0104 */
+ if(_mm_eof(modreader) && (mh->version<0x0104 || t<of.numins-1)) {
+ MikMod_free(nextwav);MikMod_free(wh);
+ nextwav=NULL;wh=NULL;
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+ }
+ }
+ }
+
+ /* sanity check */
+ if(!of.numsmp) {
+ MikMod_free(nextwav);nextwav=NULL;
+ MikMod_free(wh);wh=NULL;
+ _mm_errno = MMERR_LOADING_SAMPLEINFO;
+ return 0;
+ }
+
+ return 1;
+}
+
+static BOOL XM_Load(BOOL curious)
+{
+ INSTRUMENT *d;
+ SAMPLE *q;
+ int t,u;
+ BOOL dummypat=0;
+ char tracker[21],modtype[60];
+
+ /* try to read module header */
+ _mm_read_string(mh->id,17,modreader);
+ _mm_read_string(mh->songname,21,modreader);
+ _mm_read_string(mh->trackername,20,modreader);
+ mh->version =_mm_read_I_UWORD(modreader);
+ if((mh->version<0x102)||(mh->version>0x104)) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ mh->headersize =_mm_read_I_ULONG(modreader);
+ mh->songlength =_mm_read_I_UWORD(modreader);
+ mh->restart =_mm_read_I_UWORD(modreader);
+ mh->numchn =_mm_read_I_UWORD(modreader);
+ mh->numpat =_mm_read_I_UWORD(modreader);
+ mh->numins =_mm_read_I_UWORD(modreader);
+ mh->flags =_mm_read_I_UWORD(modreader);
+ mh->tempo =_mm_read_I_UWORD(modreader);
+ mh->bpm =_mm_read_I_UWORD(modreader);
+ if(!mh->bpm || mh->songlength > 256) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+/* _mm_read_UBYTES(mh->orders,256,modreader);*/
+/* _mm_read_UBYTES(mh->orders,mh->headersize-20,modreader);*/
+ _mm_read_UBYTES(mh->orders,mh->songlength,modreader);
+ if(_mm_fseek(modreader, mh->headersize+60, SEEK_SET) ||
+ _mm_eof(modreader)) {
+ _mm_errno = MMERR_LOADING_HEADER;
+ return 0;
+ }
+
+ /* set module variables */
+ of.initspeed = mh->tempo;
+ of.inittempo = mh->bpm;
+ strncpy(tracker,mh->trackername,20);tracker[20]=0;
+ for(t=20;(t>=0)&&(tracker[t]<=' ');t--) tracker[t]=0;
+
+ /* some modules have the tracker name empty */
+ if (!tracker[0])
+ strcpy(tracker,"Unknown tracker");
+
+#ifdef HAVE_SNPRINTF
+ snprintf(modtype,60,"%s (XM format %d.%02d)",
+ tracker,mh->version>>8,mh->version&0xff);
+#else
+ sprintf(modtype,"%s (XM format %d.%02d)",
+ tracker,mh->version>>8,mh->version&0xff);
+#endif
+ of.modtype = MikMod_strdup(modtype);
+ of.numchn = mh->numchn;
+ of.numpat = mh->numpat;
+ of.numtrk = (UWORD)of.numpat*of.numchn; /* get number of channels */
+ of.songname = DupStr(mh->songname,20,1);
+ of.numpos = mh->songlength; /* copy the songlength */
+ of.reppos = mh->restart<mh->songlength?mh->restart:0;
+ of.numins = mh->numins;
+ of.flags |= UF_XMPERIODS | UF_INST | UF_NOWRAP | UF_FT2QUIRKS |
+ UF_PANNING;
+ if(mh->flags&1) of.flags |= UF_LINEAR;
+ of.bpmlimit = 32;
+
+ memset(of.chanvol,64,of.numchn); /* store channel volumes */
+
+ if(!AllocPositions(of.numpos+1)) return 0;
+ for(t=0;t<of.numpos;t++)
+ of.positions[t]=mh->orders[t];
+
+ /* We have to check for any pattern numbers in the order list greater than
+ the number of patterns total. If one or more is found, we set it equal to
+ the pattern total and make a dummy pattern to workaround the problem */
+ for(t=0;t<of.numpos;t++) {
+ if(of.positions[t]>=of.numpat) {
+ of.positions[t]=of.numpat;
+ dummypat=1;
+ }
+ }
+ if(dummypat) {
+ of.numpat++;of.numtrk+=of.numchn;
+ }
+
+ if(mh->version<0x0104) {
+ if(!LoadInstruments()) return 0;
+ if(!LoadPatterns(dummypat)) return 0;
+ for(t=0;t<of.numsmp;t++)
+ nextwav[t]+=_mm_ftell(modreader);
+ } else {
+ if(!LoadPatterns(dummypat)) return 0;
+ if(!LoadInstruments()) return 0;
+ }
+
+ if(!AllocSamples()) {
+ MikMod_free(nextwav);MikMod_free(wh);
+ nextwav=NULL;wh=NULL;
+ return 0;
+ }
+ q = of.samples;
+ s = wh;
+ for(u=0;u<of.numsmp;u++,q++,s++) {
+ q->samplename = DupStr(s->samplename,22,1);
+ q->length = s->length;
+ q->loopstart = s->loopstart;
+ q->loopend = s->loopstart+s->looplength;
+ q->volume = s->volume;
+ q->speed = s->finetune+128;
+ q->panning = s->panning;
+ q->seekpos = nextwav[u];
+ q->vibtype = s->vibtype;
+ q->vibsweep = s->vibsweep;
+ q->vibdepth = s->vibdepth;
+ q->vibrate = s->vibrate;
+
+ if(s->type & 0x10) {
+ q->length >>= 1;
+ q->loopstart >>= 1;
+ q->loopend >>= 1;
+ }
+
+ q->flags|=SF_OWNPAN|SF_DELTA|SF_SIGNED;
+ if(s->type&0x3) q->flags|=SF_LOOP;
+ if(s->type&0x2) q->flags|=SF_BIDI;
+ if(s->type&0x10) q->flags|=SF_16BITS;
+ }
+
+ d=of.instruments;
+ s=wh;
+ for(u=0;u<of.numins;u++,d++)
+ for(t=0;t<XMNOTECNT;t++) {
+ if (d->samplenumber[t]>=of.numsmp)
+ d->samplenote[t]=255;
+ else {
+ int note=t+s[d->samplenumber[t]].relnote;
+ d->samplenote[t]=(note<0)?0:note;
+ }
+ }
+
+ MikMod_free(wh);MikMod_free(nextwav);
+ wh=NULL;nextwav=NULL;
+ return 1;
+}
+
+static CHAR *XM_LoadTitle(void)
+{
+ CHAR str[21];
+
+ _mm_fseek(modreader,17,SEEK_SET);
+ if(!_mm_read_UBYTES(str, 21, modreader)) return NULL;
+
+ return(DupStr(str,21,1));
+}
+
+/*========== Loader information */
+
+MIKMODAPI MLOADER load_xm={
+ NULL,
+ "XM",
+ "XM (FastTracker 2)",
+ XM_Init,
+ XM_Test,
+ XM_Load,
+ XM_Cleanup,
+ XM_LoadTitle
+};
+
+/* ex:set ts=4: */
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup Label="ProjectConfigurations">
+ <ProjectConfiguration Include="Debug|Win32">
+ <Configuration>Debug</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ <ProjectConfiguration Include="Release|Win32">
+ <Configuration>Release</Configuration>
+ <Platform>Win32</Platform>
+ </ProjectConfiguration>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="depackers\mmcmp.c" />
+ <ClCompile Include="depackers\pp20.c" />
+ <ClCompile Include="depackers\s404.c" />
+ <ClCompile Include="depackers\xpk.c" />
+ <ClCompile Include="drivers\drv_nos.c" />
+ <ClCompile Include="drivers\drv_oss.c" />
+ <ClCompile Include="drivers\drv_sb.c" />
+ <ClCompile Include="drivers\drv_sdl.c" />
+ <ClCompile Include="drivers\drv_ultra.c" />
+ <ClCompile Include="drivers\drv_wss.c" />
+ <ClCompile Include="loaders\load_it.c" />
+ <ClCompile Include="loaders\load_mod.c" />
+ <ClCompile Include="loaders\load_s3m.c" />
+ <ClCompile Include="loaders\load_xm.c" />
+ <ClCompile Include="mmio\mmalloc.c" />
+ <ClCompile Include="mmio\mmerror.c" />
+ <ClCompile Include="mmio\mmio.c" />
+ <ClCompile Include="playercode\mdreg.c" />
+ <ClCompile Include="playercode\mdriver.c" />
+ <ClCompile Include="playercode\mdulaw.c" />
+ <ClCompile Include="playercode\mloader.c" />
+ <ClCompile Include="playercode\mlreg.c" />
+ <ClCompile Include="playercode\mlutil.c" />
+ <ClCompile Include="playercode\mplayer.c" />
+ <ClCompile Include="playercode\munitrk.c" />
+ <ClCompile Include="playercode\mwav.c" />
+ <ClCompile Include="playercode\npertab.c" />
+ <ClCompile Include="playercode\sloader.c" />
+ <ClCompile Include="playercode\virtch.c" />
+ <ClCompile Include="playercode\virtch2.c" />
+ <ClCompile Include="playercode\virtch_common.c" />
+ <ClCompile Include="posix\strcasecmp.c" />
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="config.h" />
+ <ClInclude Include="include\mikmod.h" />
+ <ClInclude Include="include\mikmod_ctype.h" />
+ <ClInclude Include="include\mikmod_internals.h" />
+ </ItemGroup>
+ <PropertyGroup Label="Globals">
+ <ProjectGuid>{A5835F2B-734E-4730-8D0B-6288CDA4F73C}</ProjectGuid>
+ <Keyword>Win32Proj</Keyword>
+ <RootNamespace>mikmod</RootNamespace>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <UseDebugLibraries>true</UseDebugLibraries>
+ <PlatformToolset>v120</PlatformToolset>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+ <ConfigurationType>StaticLibrary</ConfigurationType>
+ <UseDebugLibraries>false</UseDebugLibraries>
+ <PlatformToolset>v120</PlatformToolset>
+ <WholeProgramOptimization>false</WholeProgramOptimization>
+ <CharacterSet>MultiByte</CharacterSet>
+ </PropertyGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+ <ImportGroup Label="ExtensionSettings">
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+ </ImportGroup>
+ <PropertyGroup Label="UserMacros" />
+ <PropertyGroup />
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+ <ClCompile>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <WarningLevel>Level3</WarningLevel>
+ <Optimization>Disabled</Optimization>
+ <PreprocessorDefinitions>WIN32;MIKMOD_BUILD;MIKMOD_STATIC;HAVE_CONFIG_H;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>.;drivers;loaders;depackers;include;mmio;posix;playercode</AdditionalIncludeDirectories>
+ <DisableSpecificWarnings>4244;4996</DisableSpecificWarnings>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ </Link>
+ </ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+ <ClCompile>
+ <WarningLevel>Level3</WarningLevel>
+ <PrecompiledHeader>
+ </PrecompiledHeader>
+ <Optimization>MaxSpeed</Optimization>
+ <FunctionLevelLinking>true</FunctionLevelLinking>
+ <IntrinsicFunctions>true</IntrinsicFunctions>
+ <PreprocessorDefinitions>WIN32;MIKMOD_BUILD;MIKMOD_STATIC;HAVE_CONFIG_H;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+ <AdditionalIncludeDirectories>.;drivers;loaders;depackers;include;mmio;posix;playercode</AdditionalIncludeDirectories>
+ <DisableSpecificWarnings>4244;4996</DisableSpecificWarnings>
+ </ClCompile>
+ <Link>
+ <SubSystem>Windows</SubSystem>
+ <GenerateDebugInformation>true</GenerateDebugInformation>
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>
+ <OptimizeReferences>true</OptimizeReferences>
+ </Link>
+ </ItemDefinitionGroup>
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+ <ImportGroup Label="ExtensionTargets">
+ </ImportGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <ItemGroup>
+ <Filter Include="drivers">
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+ </Filter>
+ <Filter Include="loaders">
+ <UniqueIdentifier>{017243a1-5836-429c-b07f-1c41ae84dab3}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="depackers">
+ <UniqueIdentifier>{9502d697-4f36-483a-9cd4-9a622b9f972f}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="include">
+ <UniqueIdentifier>{811f40e2-6099-4a33-8010-f8c7ded742c2}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="mmio">
+ <UniqueIdentifier>{8d8d8423-0563-415b-be3f-132de39d20ab}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="playercode">
+ <UniqueIdentifier>{6c502424-758a-4ba5-ad0f-16fe1d8b78b6}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="posix">
+ <UniqueIdentifier>{282937aa-35d1-403d-85ab-ae64b1eb0d5b}</UniqueIdentifier>
+ </Filter>
+ </ItemGroup>
+ <ItemGroup>
+ <ClCompile Include="drivers\drv_nos.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="drivers\drv_oss.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="drivers\drv_sb.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="drivers\drv_sdl.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="drivers\drv_ultra.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="drivers\drv_wss.c">
+ <Filter>drivers</Filter>
+ </ClCompile>
+ <ClCompile Include="loaders\load_it.c">
+ <Filter>loaders</Filter>
+ </ClCompile>
+ <ClCompile Include="loaders\load_mod.c">
+ <Filter>loaders</Filter>
+ </ClCompile>
+ <ClCompile Include="loaders\load_s3m.c">
+ <Filter>loaders</Filter>
+ </ClCompile>
+ <ClCompile Include="loaders\load_xm.c">
+ <Filter>loaders</Filter>
+ </ClCompile>
+ <ClCompile Include="depackers\mmcmp.c">
+ <Filter>depackers</Filter>
+ </ClCompile>
+ <ClCompile Include="depackers\pp20.c">
+ <Filter>depackers</Filter>
+ </ClCompile>
+ <ClCompile Include="depackers\s404.c">
+ <Filter>depackers</Filter>
+ </ClCompile>
+ <ClCompile Include="depackers\xpk.c">
+ <Filter>depackers</Filter>
+ </ClCompile>
+ <ClCompile Include="mmio\mmalloc.c">
+ <Filter>mmio</Filter>
+ </ClCompile>
+ <ClCompile Include="mmio\mmerror.c">
+ <Filter>mmio</Filter>
+ </ClCompile>
+ <ClCompile Include="mmio\mmio.c">
+ <Filter>mmio</Filter>
+ </ClCompile>
+ <ClCompile Include="posix\strcasecmp.c">
+ <Filter>posix</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mdreg.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mdriver.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mdulaw.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mloader.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mlreg.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mlutil.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mplayer.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\munitrk.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\mwav.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\npertab.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\sloader.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\virtch.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\virtch_common.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ <ClCompile Include="playercode\virtch2.c">
+ <Filter>playercode</Filter>
+ </ClCompile>
+ </ItemGroup>
+ <ItemGroup>
+ <ClInclude Include="include\mikmod.h">
+ <Filter>include</Filter>
+ </ClInclude>
+ <ClInclude Include="include\mikmod_ctype.h">
+ <Filter>include</Filter>
+ </ClInclude>
+ <ClInclude Include="include\mikmod_internals.h">
+ <Filter>include</Filter>
+ </ClInclude>
+ <ClInclude Include="config.h" />
+ </ItemGroup>
+</Project>
\ No newline at end of file
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Dynamic memory routines
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_POSIX_MEMALIGN
+#define _XOPEN_SOURCE 600 /* for posix_memalign */
+#endif
+
+#include "string.h"
+#include "mikmod_internals.h"
+
+#if defined(HAVE_SSE2) || defined(HAVE_ALTIVEC)
+#undef WIN32_ALIGNED_MALLOC
+#if defined(_WIN32) && !defined(_WIN32_WCE)
+# if defined(_WIN64) /* OK with MSVC and MinGW */
+# define WIN32_ALIGNED_MALLOC
+# elif defined(_MSC_VER) && (_MSC_VER >= 1300)
+# define WIN32_ALIGNED_MALLOC
+# elif defined(__MINGW32__)
+ /* no guarantees that msvcrt.dll will have it */
+# endif
+#endif
+
+#define PTRSIZE (sizeof(void*))
+
+/* return a 16 byte aligned address */
+void* MikMod_amalloc(size_t size)
+{
+ void *d;
+#if defined(HAVE_POSIX_MEMALIGN)
+ if (!posix_memalign(&d, 16, size)) {
+ memset(d, 0, size);
+ return d;
+ }
+#elif defined(WIN32_ALIGNED_MALLOC)
+ d = _aligned_malloc(size, 16);
+ if (d) {
+ ZeroMemory(d, size);
+ return d;
+ }
+#else
+ size_t s = (size)? ((size + (PTRSIZE-1)) & ~(PTRSIZE-1)) : PTRSIZE;
+ s += PTRSIZE + 16;
+ d = calloc(1, s);
+ if (d) {
+ char *pptr = (char *)d + PTRSIZE;
+ size_t err = ((size_t)pptr) & 15;
+ char *fptr = pptr + (16 - err);
+ *(size_t*)(fptr - PTRSIZE) = (size_t)d;
+ return fptr;
+ }
+#endif
+
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ return NULL;
+}
+
+void MikMod_afree(void *data)
+{
+ if (!data) return;
+#if defined(HAVE_POSIX_MEMALIGN)
+ free(data);
+#elif defined(WIN32_ALIGNED_MALLOC)
+ _aligned_free(data);
+#else
+ free((void *) *(size_t*)((unsigned char *)data - PTRSIZE));
+#endif
+}
+#endif /* (HAVE_SSE2) || (HAVE_ALTIVEC) */
+
+void* MikMod_realloc(void *data, size_t size)
+{
+ if (data) return realloc(data, size);
+ return calloc(1, size);
+}
+
+/* Same as malloc, but sets error variable _mm_error when fails */
+void* MikMod_malloc(size_t size)
+{
+ return MikMod_calloc(1, size);
+}
+
+/* Same as calloc, but sets error variable _mm_error when fails */
+void* MikMod_calloc(size_t nitems, size_t size)
+{
+ void *d = calloc(nitems, size);
+ if (d) return d;
+
+ _mm_errno = MMERR_OUT_OF_MEMORY;
+ if(_mm_errorhandler) _mm_errorhandler();
+ return NULL;
+}
+
+void MikMod_free(void *data)
+{
+ if (data) free(data);
+}
+
+/* like strdup(), but the result must be freed using MikMod_free() */
+CHAR *MikMod_strdup(const CHAR *s)
+{
+ size_t l;
+ CHAR *d;
+
+ if (!s) return NULL;
+
+ l = strlen(s) + 1;
+ d = (CHAR *) MikMod_calloc(1, l * sizeof(CHAR));
+ if (d) strcpy(d, s);
+ return d;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Error handling functions.
+ Register an error handler with _mm_RegisterErrorHandler() and you're all set.
+
+==============================================================================*/
+
+/*
+
+ The global variables _mm_errno, and _mm_critical are set before the error
+ handler in called. See below for the values of these variables.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+#define _mmerr_invalid "Invalid error code"
+
+static const char *_mm_errmsg[MMERR_MAX+1] =
+{
+/* No error */
+
+ "No error",
+
+/* Generic errors */
+
+ "Could not open requested file",
+ "Out of memory",
+ "Dynamic linking failed",
+
+/* Sample errors */
+
+ "Out of memory to load sample",
+ "Out of sample handles to load sample",
+ "Sample format not recognized",
+
+/* Module errors */
+
+ "Failure loading module pattern",
+ "Failure loading module track",
+ "Failure loading module header",
+ "Failure loading sampleinfo",
+ "Module format not recognized",
+ "Module sample format not recognized",
+ "Synthsounds not supported in MED files",
+ "Compressed sample is invalid",
+
+/* Driver errors: */
+
+ "Sound device not detected",
+ "Device number out of range",
+ "Software mixer failure",
+ "Could not open sound device",
+ "This driver supports 8 bit linear output only",
+ "This driver supports 16 bit linear output only",
+ "This driver supports stereo output only",
+ "This driver supports uLaw output (8 bit mono, 8 kHz) only",
+ "Unable to set non-blocking mode for audio device",
+
+/* AudioFile driver errors */
+#ifdef DRV_AF
+ "Cannot find suitable AudioFile audio port",
+#else
+ _mmerr_invalid,
+#endif
+
+/* AIX driver errors */
+#ifdef DRV_AIX
+ "Configuration (init step) of audio device failed",
+ "Configuration (control step) of audio device failed",
+ "Configuration (start step) of audio device failed",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Ultrasound driver errors */
+#ifdef DRV_ULTRA
+ "Ultrasound driver only works in 16 bit stereo 44 KHz",
+ "Ultrasound card could not be reset",
+ "Could not start Ultrasound timer",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* HP driver errors */
+#ifdef DRV_HP
+ "Unable to select 16bit-linear sample format",
+ "Could not select requested sample-rate",
+ "Could not select requested number of channels",
+ "Unable to select audio output",
+ "Unable to get audio description",
+ "Could not set transmission buffer size",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Open Sound System driver errors */
+#ifdef DRV_OSS
+ "Could not set fragment size",
+ "Could not set sample size",
+ "Could not set mono/stereo setting",
+ "Could not set sample rate",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid,
+#endif
+
+/* SGI driver errors */
+#ifdef DRV_SGI
+ "Unsupported sample rate",
+ "Hardware does not support 16 bit sound",
+ "Hardware does not support 8 bit sound",
+ "Hardware does not support stereo sound",
+ "Hardware does not support mono sound",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Sun driver errors */
+#ifdef DRV_SUN
+ "Sound device initialization failed",
+#else
+ _mmerr_invalid,
+#endif
+
+/* OS/2 drivers errors */
+#if defined(DRV_OS2) || defined(DRV_DART)
+ "Could not set mixing parameters",
+#else
+ _mmerr_invalid,
+#endif
+#ifdef DRV_OS2
+ "Could not create playback semaphores",
+ "Could not create playback timer",
+ "Could not create playback thread",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* DirectSound driver errors */
+#ifdef DRV_DS
+ "Could not set playback priority",
+ "Could not create playback buffers",
+ "Could not set playback format",
+ "Could not register callback",
+ "Could not register event",
+ "Could not create playback thread",
+ "Could not initialize playback thread",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid,
+#endif
+
+/* Windows Multimedia API driver errors */
+#ifdef DRV_WIN
+ "Invalid device handle",
+ "The resource is already allocated",
+ "Invalid device identifier",
+ "Unsupported output format",
+ "Unknown error",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Macintosh driver errors */
+#ifdef DRV_MAC
+ "Unsupported sample rate",
+ "Could not start playback",
+#else
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* MacOS X/Darwin driver errors */
+#ifdef DRV_OSX
+ "Unknown device",
+ "Bad property",
+ "Could not set playback format",
+ "Could not set mono/stereo setting",
+ "Could not create playback buffers",
+ "Could not create playback thread",
+ "Could not start audio device",
+ "Could not create buffer thread",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* DOS driver errors */
+#ifdef DRV_WSS
+ "WSS_STARTDMA",
+#else
+ _mmerr_invalid,
+#endif
+#ifdef DRV_SB
+ "SB_STARTDMA",
+#else
+ _mmerr_invalid,
+#endif
+
+/* float32 output */
+
+ "This driver doesn't support 32 bit float output",
+
+/* OpenAL driver errors */
+#ifdef DRV_OPENAL
+ "Could not create context",
+ "Could not make context current",
+ "Could not create buffers",
+ "Could not create sources",
+ "Could not change source parameters",
+ "Could not queue buffers",
+ "Could not unqueue buffers",
+ "Could not copy buffer data",
+ "Could not get source parameters",
+ "Could not play source",
+ "Could not stop source",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* ALSA driver errors */
+#ifdef DRV_ALSA
+ "No ALSA configurations available",
+ "Could not set ALSA output params",
+ "Could not set playback format",
+ "Could not set sample rate",
+ "Could not set mono/stereo setting",
+ "Could not get buffer size from ALSA",
+ "ALSA PCM start error",
+ "ALSA PCM write error",
+ "ALSA PCM recovery failure",
+#else
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+ _mmerr_invalid, _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Sndio errors */
+#ifdef DRV_SNDIO
+ "Could not set SNDIO output params",
+ "Unsupported SNDIO output params",
+#else
+ _mmerr_invalid, _mmerr_invalid,
+#endif
+
+/* Invalid error */
+
+ _mmerr_invalid
+};
+
+MIKMODAPI const char *MikMod_strerror(int code)
+{
+ if ((code<0)||(code>MMERR_MAX)) code=MMERR_MAX;
+ return _mm_errmsg[code];
+}
+
+/* User installed error callback */
+MikMod_handler_t _mm_errorhandler = NULL;
+MIKMODAPI int _mm_errno = 0;
+MIKMODAPI BOOL _mm_critical = 0;
+
+static MikMod_handler_t _mm_registererrorhandler(MikMod_handler_t proc)
+{
+ MikMod_handler_t oldproc=_mm_errorhandler;
+
+ _mm_errorhandler = proc;
+ return oldproc;
+}
+
+MIKMODAPI MikMod_handler_t MikMod_RegisterErrorHandler(MikMod_handler_t proc)
+{
+ MikMod_handler_t result;
+
+ MUTEX_LOCK(vars);
+ result=_mm_registererrorhandler(proc);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Portable file I/O routines
+
+==============================================================================*/
+
+/*
+
+ The way this module works:
+
+ - _mm_fopen will call the errorhandler [see mmerror.c] in addition to
+ setting _mm_errno on exit.
+ - _mm_iobase is for internal use. It is used by Player_LoadFP to
+ ensure that it works properly with wad files.
+ - _mm_read_I_* and _mm_read_M_* differ : the first is for reading data
+ written by a little endian (intel) machine, and the second is for reading
+ big endian (Mac, RISC, Alpha) machine data.
+ - _mm_write functions work the same as the _mm_read functions.
+ - _mm_read_string is for reading binary strings. It is basically the same
+ as an fread of bytes.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fclose(FILE *);
+extern int fgetc(FILE *);
+extern int fputc(int, FILE *);
+extern size_t fread(void *, size_t, size_t, FILE *);
+extern int fseek(FILE *, long, int);
+extern size_t fwrite(const void *, size_t, size_t, FILE *);
+#endif
+
+#define COPY_BUFSIZE 1024
+
+/* some prototypes */
+static BOOL _mm_MemReader_Eof(MREADER* reader);
+static BOOL _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size);
+static int _mm_MemReader_Get(MREADER* reader);
+static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence);
+static long _mm_MemReader_Tell(MREADER* reader);
+
+/*static long _mm_iobase = 0, temp_iobase = 0;*/
+
+FILE* _mm_fopen(const CHAR* fname, const CHAR* attrib)
+{
+ FILE *fp;
+
+ if(!(fp=fopen(fname,attrib))) {
+ _mm_errno = MMERR_OPENING_FILE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ }
+ return fp;
+}
+
+BOOL _mm_FileExists(const CHAR* fname)
+{
+ FILE *fp;
+
+ if(!(fp=fopen(fname,"r"))) return 0;
+ fclose(fp);
+
+ return 1;
+}
+
+int _mm_fclose(FILE *fp)
+{
+ return fclose(fp);
+}
+
+/* Sets the current file-position as the new iobase */
+void _mm_iobase_setcur(MREADER* reader)
+{
+ reader->prev_iobase=reader->iobase; /* store old value in case of revert */
+ reader->iobase=reader->Tell(reader);
+}
+
+/* Reverts to the last known iobase value. */
+void _mm_iobase_revert(MREADER* reader)
+{
+ reader->iobase=reader->prev_iobase;
+}
+
+/*========== File Reader */
+
+typedef struct MFILEREADER {
+ MREADER core;
+ FILE* file;
+} MFILEREADER;
+
+static BOOL _mm_FileReader_Eof(MREADER* reader)
+{
+ return feof(((MFILEREADER*)reader)->file);
+}
+
+static BOOL _mm_FileReader_Read(MREADER* reader,void* ptr,size_t size)
+{
+ return !!fread(ptr,size,1,((MFILEREADER*)reader)->file);
+}
+
+static int _mm_FileReader_Get(MREADER* reader)
+{
+ return fgetc(((MFILEREADER*)reader)->file);
+}
+
+static int _mm_FileReader_Seek(MREADER* reader,long offset,int whence)
+{
+ return fseek(((MFILEREADER*)reader)->file,
+ (whence==SEEK_SET)?offset+reader->iobase:offset,whence);
+}
+
+static long _mm_FileReader_Tell(MREADER* reader)
+{
+ return ftell(((MFILEREADER*)reader)->file)-reader->iobase;
+}
+
+MREADER *_mm_new_file_reader(FILE* fp)
+{
+ MFILEREADER* reader=(MFILEREADER*)MikMod_calloc(1,sizeof(MFILEREADER));
+ if (reader) {
+ reader->core.Eof =&_mm_FileReader_Eof;
+ reader->core.Read=&_mm_FileReader_Read;
+ reader->core.Get =&_mm_FileReader_Get;
+ reader->core.Seek=&_mm_FileReader_Seek;
+ reader->core.Tell=&_mm_FileReader_Tell;
+ reader->file=fp;
+ }
+ return (MREADER*)reader;
+}
+
+void _mm_delete_file_reader (MREADER* reader)
+{
+ MikMod_free(reader);
+}
+
+/*========== File Writer */
+
+typedef struct MFILEWRITER {
+ MWRITER core;
+ FILE* file;
+} MFILEWRITER;
+
+static int _mm_FileWriter_Seek(MWRITER* writer,long offset,int whence)
+{
+ return fseek(((MFILEWRITER*)writer)->file,offset,whence);
+}
+
+static long _mm_FileWriter_Tell(MWRITER* writer)
+{
+ return ftell(((MFILEWRITER*)writer)->file);
+}
+
+static BOOL _mm_FileWriter_Write(MWRITER* writer, const void* ptr, size_t size)
+{
+ return (fwrite(ptr,size,1,((MFILEWRITER*)writer)->file)==size);
+}
+
+static int _mm_FileWriter_Put(MWRITER* writer,int value)
+{
+ return fputc(value,((MFILEWRITER*)writer)->file);
+}
+
+MWRITER *_mm_new_file_writer(FILE* fp)
+{
+ MFILEWRITER* writer=(MFILEWRITER*)MikMod_calloc(1,sizeof(MFILEWRITER));
+ if (writer) {
+ writer->core.Seek =&_mm_FileWriter_Seek;
+ writer->core.Tell =&_mm_FileWriter_Tell;
+ writer->core.Write=&_mm_FileWriter_Write;
+ writer->core.Put =&_mm_FileWriter_Put;
+ writer->file=fp;
+ }
+ return (MWRITER*) writer;
+}
+
+void _mm_delete_file_writer (MWRITER* writer)
+{
+ MikMod_free (writer);
+}
+
+/*========== Memory Reader */
+
+typedef struct MMEMREADER {
+ MREADER core;
+ const void *buffer;
+ long len;
+ long pos;
+} MMEMREADER;
+
+void _mm_delete_mem_reader(MREADER* reader)
+{
+ MikMod_free(reader);
+}
+
+MREADER *_mm_new_mem_reader(const void *buffer, long len)
+{
+ MMEMREADER* reader=(MMEMREADER*)MikMod_calloc(1,sizeof(MMEMREADER));
+ if (reader)
+ {
+ reader->core.Eof =&_mm_MemReader_Eof;
+ reader->core.Read=&_mm_MemReader_Read;
+ reader->core.Get =&_mm_MemReader_Get;
+ reader->core.Seek=&_mm_MemReader_Seek;
+ reader->core.Tell=&_mm_MemReader_Tell;
+ reader->buffer = buffer;
+ reader->len = len;
+ reader->pos = 0;
+ }
+ return (MREADER*)reader;
+}
+
+static BOOL _mm_MemReader_Eof(MREADER* reader)
+{
+ MMEMREADER* mr = (MMEMREADER*) reader;
+ if (!mr) return 1;
+ if (mr->pos >= mr->len) return 1;
+ return 0;
+}
+
+static BOOL _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size)
+{
+ unsigned char *d;
+ const unsigned char *s;
+ MMEMREADER* mr;
+ long siz;
+ BOOL ret;
+
+ if (!reader || !size || (size > (size_t) LONG_MAX))
+ return 0;
+
+ mr = (MMEMREADER*) reader;
+ siz = (long) size;
+ if (mr->pos >= mr->len) return 0; /* @ eof */
+ if (mr->pos + siz > mr->len) {
+ siz = mr->len - mr->pos;
+ ret = 0; /* not enough remaining bytes */
+ }
+ else {
+ ret = 1;
+ }
+
+ s = (const unsigned char *) mr->buffer;
+ s += mr->pos;
+ mr->pos += siz;
+ d = (unsigned char *) ptr;
+
+ while (siz) {
+ *d++ = *s++;
+ siz--;
+ }
+
+ return ret;
+}
+
+static int _mm_MemReader_Get(MREADER* reader)
+{
+ MMEMREADER* mr;
+ int c;
+
+ mr = (MMEMREADER*) reader;
+ if (mr->pos >= mr->len) return EOF;
+ c = ((const unsigned char*) mr->buffer)[mr->pos];
+ mr->pos++;
+
+ return c;
+}
+
+static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence)
+{
+ MMEMREADER* mr;
+
+ if (!reader) return -1;
+ mr = (MMEMREADER*) reader;
+ switch(whence)
+ {
+ case SEEK_CUR:
+ mr->pos += offset;
+ break;
+ case SEEK_SET:
+ mr->pos = reader->iobase + offset;
+ break;
+ case SEEK_END:
+ mr->pos = mr->len + offset;
+ break;
+ }
+ if (mr->pos < reader->iobase) {
+ mr->pos = mr->core.iobase;
+ return -1;
+ }
+ if (mr->pos > mr->len) {
+ mr->pos = mr->len;
+ }
+ return 0;
+}
+
+static long _mm_MemReader_Tell(MREADER* reader)
+{
+ if (reader) {
+ return ((MMEMREADER*)reader)->pos - reader->iobase;
+ }
+ return 0;
+}
+
+/*========== Write functions */
+
+void _mm_write_string(const CHAR* data,MWRITER* writer)
+{
+ if(data)
+ _mm_write_UBYTES(data,strlen(data),writer);
+}
+
+void _mm_write_M_UWORD(UWORD data,MWRITER* writer)
+{
+ _mm_write_UBYTE(data>>8,writer);
+ _mm_write_UBYTE(data&0xff,writer);
+}
+
+void _mm_write_I_UWORD(UWORD data,MWRITER* writer)
+{
+ _mm_write_UBYTE(data&0xff,writer);
+ _mm_write_UBYTE(data>>8,writer);
+}
+
+void _mm_write_M_ULONG(ULONG data,MWRITER* writer)
+{
+ _mm_write_M_UWORD(data>>16,writer);
+ _mm_write_M_UWORD(data&0xffff,writer);
+}
+
+void _mm_write_I_ULONG(ULONG data,MWRITER* writer)
+{
+ _mm_write_I_UWORD(data&0xffff,writer);
+ _mm_write_I_UWORD(data>>16,writer);
+}
+
+void _mm_write_M_SWORD(SWORD data,MWRITER* writer)
+{
+ _mm_write_M_UWORD((UWORD)data,writer);
+}
+
+void _mm_write_I_SWORD(SWORD data,MWRITER* writer)
+{
+ _mm_write_I_UWORD((UWORD)data,writer);
+}
+
+void _mm_write_M_SLONG(SLONG data,MWRITER* writer)
+{
+ _mm_write_M_ULONG((ULONG)data,writer);
+}
+
+void _mm_write_I_SLONG(SLONG data,MWRITER* writer)
+{
+ _mm_write_I_ULONG((ULONG)data,writer);
+}
+
+void _mm_write_M_SWORDS(SWORD *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_M_SWORD(*(buffer++),writer);
+}
+
+void _mm_write_M_UWORDS(UWORD *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_M_UWORD(*(buffer++),writer);
+}
+
+void _mm_write_I_SWORDS(SWORD *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_I_SWORD(*(buffer++),writer);
+}
+
+void _mm_write_I_UWORDS(UWORD *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_I_UWORD(*(buffer++),writer);
+}
+
+void _mm_write_M_SLONGS(SLONG *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_M_SLONG(*(buffer++),writer);
+}
+
+void _mm_write_M_ULONGS(ULONG *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_M_ULONG(*(buffer++),writer);
+}
+
+void _mm_write_I_SLONGS(SLONG *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_I_SLONG(*(buffer++),writer);
+}
+
+void _mm_write_I_ULONGS(ULONG *buffer,int cnt,MWRITER* writer)
+{
+ while(cnt-- > 0) _mm_write_I_ULONG(*(buffer++),writer);
+}
+
+/*========== Read functions */
+
+BOOL _mm_read_string(CHAR* buffer,int cnt,MREADER* reader)
+{
+ return reader->Read(reader,buffer,cnt);
+}
+
+UWORD _mm_read_M_UWORD(MREADER* reader)
+{
+ UWORD result=((UWORD)_mm_read_UBYTE(reader))<<8;
+ result|=_mm_read_UBYTE(reader);
+ return result;
+}
+
+UWORD _mm_read_I_UWORD(MREADER* reader)
+{
+ UWORD result=_mm_read_UBYTE(reader);
+ result|=((UWORD)_mm_read_UBYTE(reader))<<8;
+ return result;
+}
+
+ULONG _mm_read_M_ULONG(MREADER* reader)
+{
+ ULONG result=((ULONG)_mm_read_M_UWORD(reader))<<16;
+ result|=_mm_read_M_UWORD(reader);
+ return result;
+}
+
+ULONG _mm_read_I_ULONG(MREADER* reader)
+{
+ ULONG result=_mm_read_I_UWORD(reader);
+ result|=((ULONG)_mm_read_I_UWORD(reader))<<16;
+ return result;
+}
+
+SWORD _mm_read_M_SWORD(MREADER* reader)
+{
+ return((SWORD)_mm_read_M_UWORD(reader));
+}
+
+SWORD _mm_read_I_SWORD(MREADER* reader)
+{
+ return((SWORD)_mm_read_I_UWORD(reader));
+}
+
+SLONG _mm_read_M_SLONG(MREADER* reader)
+{
+ return((SLONG)_mm_read_M_ULONG(reader));
+}
+
+SLONG _mm_read_I_SLONG(MREADER* reader)
+{
+ return((SLONG)_mm_read_I_ULONG(reader));
+}
+
+BOOL _mm_read_M_SWORDS(SWORD *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_M_SWORD(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_M_UWORDS(UWORD *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_M_UWORD(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_I_SWORDS(SWORD *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_I_SWORD(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_I_UWORDS(UWORD *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_I_UWORD(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_M_SLONGS(SLONG *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_M_SLONG(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_M_ULONGS(ULONG *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_M_ULONG(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_I_SLONGS(SLONG *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_I_SLONG(reader);
+ return !reader->Eof(reader);
+}
+
+BOOL _mm_read_I_ULONGS(ULONG *buffer,int cnt,MREADER* reader)
+{
+ while(cnt-- > 0) *(buffer++)=_mm_read_I_ULONG(reader);
+ return !reader->Eof(reader);
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ Routine for registering all drivers in libmikmod for the current platform.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+static void _mm_registeralldrivers(void)
+{
+ /* Register network drivers */
+#ifdef DRV_AF
+ _mm_registerdriver(&drv_AF);
+#endif
+#ifdef DRV_PULSEAUDIO
+ _mm_registerdriver(&drv_pulseaudio);
+#endif
+#ifdef DRV_ESD
+ _mm_registerdriver(&drv_esd);
+#endif
+#ifdef DRV_NAS
+ _mm_registerdriver(&drv_nas);
+#endif
+
+ /* Register hardware drivers - hardware mixing */
+#ifdef DRV_ULTRA
+ _mm_registerdriver(&drv_ultra);
+#endif
+#ifdef DRV_SAM9407
+ _mm_registerdriver(&drv_sam9407);
+#endif
+
+ /* Register multi-platform drivers -- software mixing */
+#ifdef DRV_SDL
+ _mm_registerdriver(&drv_sdl);
+#endif
+#ifdef DRV_OPENAL
+ _mm_registerdriver(&drv_openal);
+#endif
+
+ /* Register OS-specific hardware drivers - software mixing */
+#ifdef DRV_AHI
+ _mm_registerdriver(&drv_ahi);
+#endif
+#ifdef DRV_AIX
+ _mm_registerdriver(&drv_aix);
+#endif
+#ifdef DRV_ALSA
+ _mm_registerdriver(&drv_alsa);
+#endif
+#ifdef DRV_HP
+ _mm_registerdriver(&drv_hp);
+#endif
+#ifdef DRV_SNDIO
+ _mm_registerdriver(&drv_sndio);
+#endif
+#ifdef DRV_OSS
+ _mm_registerdriver(&drv_oss);
+#endif
+#ifdef DRV_SGI
+ _mm_registerdriver(&drv_sgi);
+#endif
+#ifdef DRV_SUN
+ _mm_registerdriver(&drv_sun);
+#endif
+#ifdef DRV_DART
+ _mm_registerdriver(&drv_dart);
+#endif
+#ifdef DRV_OS2
+ _mm_registerdriver(&drv_os2);
+#endif
+#ifdef DRV_XAUDIO2
+ _mm_registerdriver(&drv_xaudio2);
+#endif
+#ifdef DRV_DS
+ _mm_registerdriver(&drv_ds);
+#endif
+#ifdef DRV_WIN
+ _mm_registerdriver(&drv_win);
+#endif
+#ifdef DRV_MAC
+ _mm_registerdriver(&drv_mac);
+#endif
+#ifdef DRV_OSX
+ _mm_registerdriver(&drv_osx);
+#endif
+#ifdef DRV_DC
+ _mm_registerdriver(&drv_dc);
+#endif
+#ifdef DRV_GP32
+ _mm_registerdriver(&drv_gp32);
+#endif
+#ifdef DRV_PSP
+ _mm_registerdriver(&drv_psp);
+#endif
+#ifdef DRV_OSLES
+ _mm_registerdriver(&drv_osles);
+#endif
+
+ /* dos drivers - wss first, since some cards emulate sb */
+#ifdef DRV_WSS
+ _mm_registerdriver(&drv_wss);
+#endif
+#ifdef DRV_SB
+ _mm_registerdriver(&drv_sb);
+#endif
+
+ /* Register disk writers */
+#ifdef DRV_WAV
+ _mm_registerdriver(&drv_wav);
+#endif
+#ifdef DRV_AIFF
+ _mm_registerdriver(&drv_aiff);
+#endif
+#ifdef DRV_RAW
+ _mm_registerdriver(&drv_raw);
+#endif
+
+ /* Register other drivers */
+#ifdef DRV_PIPE
+ _mm_registerdriver(&drv_pipe);
+#endif
+#if defined(DRV_STDOUT) && !defined(macintosh)
+ _mm_registerdriver(&drv_stdout);
+#endif
+
+ /* Register 'nosound' driver */
+ _mm_registerdriver(&drv_nos);
+}
+
+MIKMODAPI void MikMod_RegisterAllDrivers(void)
+{
+ MUTEX_LOCK(lists);
+ _mm_registeralldrivers();
+ MUTEX_UNLOCK(lists);
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998-2014 Miodrag Vallat and others - see file AUTHORS
+ for a complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ These routines are used to access the available soundcard drivers.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#if (MIKMOD_UNIX)
+#include <pwd.h>
+#include <sys/stat.h>
+#endif
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+extern MODULE *pf; /* modfile being played */
+
+/* EXPORTED GLOBALS */
+MIKMODAPI MDRIVER *md_driver = NULL;
+
+/* Initial global settings */
+MIKMODAPI UWORD md_device = 0; /* autodetect */
+MIKMODAPI UWORD md_mixfreq = 44100;
+MIKMODAPI UWORD md_mode = DMODE_STEREO | DMODE_16BITS |
+ DMODE_SURROUND |
+ DMODE_SOFT_MUSIC | DMODE_SOFT_SNDFX;
+MIKMODAPI UBYTE md_pansep = 128; /* 128 == 100% (full left/right) */
+MIKMODAPI UBYTE md_reverb = 0; /* no reverb */
+MIKMODAPI UBYTE md_volume = 128; /* global sound volume (0-128) */
+MIKMODAPI UBYTE md_musicvolume = 128; /* volume of song */
+MIKMODAPI UBYTE md_sndfxvolume = 128; /* volume of sound effects */
+
+/* INTERNAL GLOBALS */
+UWORD md_bpm = 125; /* tempo */
+
+/* Do not modify the numchn variables yourself! use MikMod_SetNumVoices() */
+UBYTE md_numchn = 0, md_sngchn = 0, md_sfxchn = 0;
+UBYTE md_hardchn = 0, md_softchn= 0;
+
+void (*md_player)(void) = Player_HandleTick;
+
+MikMod_callback_t vc_callback = NULL;
+
+/* PRIVATE VARS */
+static MDRIVER *firstdriver = NULL;
+
+static volatile BOOL isplaying = 0, initialized = 0;
+
+static UBYTE *sfxinfo;
+static int sfxpool;
+
+static SAMPLE **md_sample = NULL;
+
+/* Previous driver in use */
+static SWORD olddevice = -1;
+
+/* Limits the number of hardware voices to the specified amount.
+ This function should only be used by the low-level drivers. */
+static void LimitHardVoices(int limit)
+{
+ int t=0;
+
+ if (!(md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>limit)) md_sfxchn=limit;
+ if (!(md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>limit)) md_sngchn=limit;
+
+ if (!(md_mode & DMODE_SOFT_SNDFX))
+ md_hardchn=md_sfxchn;
+ else
+ md_hardchn=0;
+
+ if (!(md_mode & DMODE_SOFT_MUSIC)) md_hardchn += md_sngchn;
+
+ while (md_hardchn>limit) {
+ if (++t & 1) {
+ if (!(md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>4)) md_sfxchn--;
+ } else {
+ if (!(md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>8)) md_sngchn--;
+ }
+
+ if (!(md_mode & DMODE_SOFT_SNDFX))
+ md_hardchn=md_sfxchn;
+ else
+ md_hardchn=0;
+
+ if (!(md_mode & DMODE_SOFT_MUSIC))
+ md_hardchn+=md_sngchn;
+ }
+ md_numchn=md_hardchn+md_softchn;
+}
+
+/* Limits the number of hardware voices to the specified amount.
+ This function should only be used by the low-level drivers. */
+static void LimitSoftVoices(int limit)
+{
+ int t=0;
+
+ if ((md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>limit)) md_sfxchn=limit;
+ if ((md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>limit)) md_sngchn=limit;
+
+ if (md_mode & DMODE_SOFT_SNDFX)
+ md_softchn=md_sfxchn;
+ else
+ md_softchn=0;
+
+ if (md_mode & DMODE_SOFT_MUSIC) md_softchn+=md_sngchn;
+
+ while (md_softchn>limit) {
+ if (++t & 1) {
+ if ((md_mode & DMODE_SOFT_SNDFX) && (md_sfxchn>4)) md_sfxchn--;
+ } else {
+ if ((md_mode & DMODE_SOFT_MUSIC) && (md_sngchn>8)) md_sngchn--;
+ }
+
+ if (!(md_mode & DMODE_SOFT_SNDFX))
+ md_softchn=md_sfxchn;
+ else
+ md_softchn=0;
+
+ if (!(md_mode & DMODE_SOFT_MUSIC))
+ md_softchn+=md_sngchn;
+ }
+ md_numchn=md_hardchn+md_softchn;
+}
+
+/* Note: 'type' indicates whether the returned value should be for music or for
+ sound effects. */
+ULONG MD_SampleSpace(int type)
+{
+ if(type==MD_MUSIC)
+ type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
+ else if(type==MD_SNDFX)
+ type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
+
+ return md_driver->FreeSampleSpace(type);
+}
+
+ULONG MD_SampleLength(int type,SAMPLE* s)
+{
+ if(type==MD_MUSIC)
+ type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
+ else
+ if(type==MD_SNDFX)
+ type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
+
+ return md_driver->RealSampleLength(type,s);
+}
+
+MIKMODAPI CHAR* MikMod_InfoDriver(void)
+{
+ int t;
+ size_t len=0;
+ MDRIVER *l;
+ CHAR *list=NULL;
+
+ MUTEX_LOCK(lists);
+ /* compute size of buffer */
+ for(l = firstdriver; l; l = l->next)
+ len += 4 + (l->next ? 1 : 0) + strlen(l->Version);
+
+ if(len)
+ if((list=(CHAR*)MikMod_malloc(len*sizeof(CHAR))) != NULL) {
+ CHAR *list_end = list;
+ list[0] = 0;
+ /* list all registered device drivers : */
+ for(t = 1, l = firstdriver; l; l = l->next, t++) {
+ list_end += sprintf(list_end, "%2d %s%s", t, l->Version, (l->next)? "\n" : "");
+ }
+ }
+ MUTEX_UNLOCK(lists);
+ return list;
+}
+
+void _mm_registerdriver(struct MDRIVER* drv)
+{
+ MDRIVER *cruise = firstdriver;
+
+ /* don't register a MISSING() driver */
+ if ((drv->Name) && (drv->Version)) {
+ if (cruise) {
+ if ( cruise == drv )
+ return;
+ while(cruise->next) {
+ cruise = cruise->next;
+ if ( cruise == drv )
+ return;
+ }
+ cruise->next = drv;
+ } else
+ firstdriver = drv;
+ }
+}
+
+MIKMODAPI void MikMod_RegisterDriver(struct MDRIVER* drv)
+{
+ /* if we try to register an invalid driver, or an already registered driver,
+ ignore this attempt */
+ if ((!drv)||(drv->next)||(!drv->Name))
+ return;
+
+ MUTEX_LOCK(lists);
+ _mm_registerdriver(drv);
+ MUTEX_UNLOCK(lists);
+}
+
+MIKMODAPI int MikMod_DriverFromAlias(const CHAR *alias)
+{
+ int rank=1;
+ MDRIVER *cruise;
+
+ MUTEX_LOCK(lists);
+ cruise=firstdriver;
+ while(cruise) {
+ if (cruise->Alias) {
+ if (!(_mm_strcasecmp(alias,cruise->Alias))) break;
+ rank++;
+ }
+ cruise=cruise->next;
+ }
+ if(!cruise) rank=0;
+ MUTEX_UNLOCK(lists);
+
+ return rank;
+}
+
+MIKMODAPI MDRIVER *MikMod_DriverByOrdinal(int ordinal)
+{
+ MDRIVER *cruise;
+
+ /* Allow only driver ordinals > 0 */
+ if (!ordinal) return NULL;
+
+ MUTEX_LOCK(lists);
+ cruise = firstdriver;
+ while (cruise && --ordinal)
+ cruise = cruise->next;
+ MUTEX_UNLOCK(lists);
+ return cruise;
+}
+
+SWORD MD_SampleLoad(SAMPLOAD* s, int type)
+{
+ SWORD result;
+
+ if(type==MD_MUSIC)
+ type=(md_mode & DMODE_SOFT_MUSIC)?MD_SOFTWARE:MD_HARDWARE;
+ else if(type==MD_SNDFX)
+ type=(md_mode & DMODE_SOFT_SNDFX)?MD_SOFTWARE:MD_HARDWARE;
+
+ SL_Init(s);
+ result=md_driver->SampleLoad(s,type);
+ SL_Exit(s);
+
+ return result;
+}
+
+void MD_SampleUnload(SWORD handle)
+{
+ md_driver->SampleUnload(handle);
+}
+
+MIKMODAPI MikMod_player_t MikMod_RegisterPlayer(MikMod_player_t player)
+{
+ MikMod_player_t result;
+
+ MUTEX_LOCK(vars);
+ result=md_player;
+ md_player=player;
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI void MikMod_Update(void)
+{
+ MUTEX_LOCK(vars);
+ if(isplaying) {
+ if((!pf)||(!pf->forbid))
+ md_driver->Update();
+ else {
+ if (md_driver->Pause)
+ md_driver->Pause();
+ }
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+void Voice_SetVolume_internal(SBYTE voice,UWORD vol)
+{
+ ULONG tmp;
+
+ if((voice<0)||(voice>=md_numchn)) return;
+
+ /* range checks */
+ if(md_musicvolume>128) md_musicvolume=128;
+ if(md_sndfxvolume>128) md_sndfxvolume=128;
+ if(md_volume>128) md_volume=128;
+
+ tmp=(ULONG)vol*(ULONG)md_volume*
+ ((voice<md_sngchn)?(ULONG)md_musicvolume:(ULONG)md_sndfxvolume);
+ md_driver->VoiceSetVolume(voice,tmp/16384UL);
+}
+
+MIKMODAPI void Voice_SetVolume(SBYTE voice,UWORD vol)
+{
+ MUTEX_LOCK(vars);
+ Voice_SetVolume_internal(voice,vol);
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI UWORD Voice_GetVolume(SBYTE voice)
+{
+ UWORD result=0;
+
+ MUTEX_LOCK(vars);
+ if((voice>=0)&&(voice<md_numchn))
+ result=md_driver->VoiceGetVolume(voice);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+void Voice_SetFrequency_internal(SBYTE voice,ULONG frq)
+{
+ if((voice<0)||(voice>=md_numchn)) return;
+ if((md_sample[voice])&&(md_sample[voice]->divfactor))
+ frq/=md_sample[voice]->divfactor;
+ md_driver->VoiceSetFrequency(voice,frq);
+}
+
+MIKMODAPI void Voice_SetFrequency(SBYTE voice,ULONG frq)
+{
+ MUTEX_LOCK(vars);
+ Voice_SetFrequency_internal(voice,frq);
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI ULONG Voice_GetFrequency(SBYTE voice)
+{
+ ULONG result=0;
+
+ MUTEX_LOCK(vars);
+ if((voice>=0)&&(voice<md_numchn))
+ result=md_driver->VoiceGetFrequency(voice);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+void Voice_SetPanning_internal(SBYTE voice,ULONG pan)
+{
+ if((voice<0)||(voice>=md_numchn)) return;
+ if(pan!=PAN_SURROUND) {
+ if(md_pansep>128) md_pansep=128;
+ if(md_mode & DMODE_REVERSE) pan=255-pan;
+ pan = (((SWORD)(pan-128)*md_pansep)/128)+128;
+ }
+ md_driver->VoiceSetPanning(voice, pan);
+}
+
+MIKMODAPI void Voice_SetPanning(SBYTE voice,ULONG pan)
+{
+#ifdef MIKMOD_DEBUG
+ if((pan!=PAN_SURROUND)&&((pan<0)||(pan>255)))
+ fprintf(stderr,"\rVoice_SetPanning called with pan=%ld\n",(long)pan);
+#endif
+
+ MUTEX_LOCK(vars);
+ Voice_SetPanning_internal(voice,pan);
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI ULONG Voice_GetPanning(SBYTE voice)
+{
+ ULONG result=PAN_CENTER;
+
+ MUTEX_LOCK(vars);
+ if((voice>=0)&&(voice<md_numchn))
+ result=md_driver->VoiceGetPanning(voice);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+void Voice_Play_internal(SBYTE voice,SAMPLE* s,ULONG start)
+{
+ ULONG repend;
+
+ if((voice<0)||(voice>=md_numchn)) return;
+
+ md_sample[voice]=s;
+ repend=s->loopend;
+
+ if(s->flags&SF_LOOP)
+ /* repend can't be bigger than size */
+ if(repend>s->length) repend=s->length;
+
+ md_driver->VoicePlay(voice,s->handle,start,s->length,s->loopstart,repend,s->flags);
+}
+
+MIKMODAPI void Voice_Play(SBYTE voice,SAMPLE* s,ULONG start)
+{
+ if(start>s->length) return;
+
+ MUTEX_LOCK(vars);
+ Voice_Play_internal(voice,s,start);
+ MUTEX_UNLOCK(vars);
+}
+
+void Voice_Stop_internal(SBYTE voice)
+{
+ if((voice<0)||(voice>=md_numchn)) return;
+ if(voice>=md_sngchn)
+ /* It is a sound effects channel, so flag the voice as non-critical! */
+ sfxinfo[voice-md_sngchn]=0;
+ md_driver->VoiceStop(voice);
+}
+
+MIKMODAPI void Voice_Stop(SBYTE voice)
+{
+ MUTEX_LOCK(vars);
+ Voice_Stop_internal(voice);
+ MUTEX_UNLOCK(vars);
+}
+
+BOOL Voice_Stopped_internal(SBYTE voice)
+{
+ if((voice<0)||(voice>=md_numchn)) return 0;
+ return(md_driver->VoiceStopped(voice));
+}
+
+MIKMODAPI BOOL Voice_Stopped(SBYTE voice)
+{
+ BOOL result;
+
+ MUTEX_LOCK(vars);
+ result=Voice_Stopped_internal(voice);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI SLONG Voice_GetPosition(SBYTE voice)
+{
+ SLONG result=0;
+
+ MUTEX_LOCK(vars);
+ if((voice>=0)&&(voice<md_numchn)) {
+ if (md_driver->VoiceGetPosition)
+ result=(md_driver->VoiceGetPosition(voice));
+ else
+ result=-1;
+ }
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI ULONG Voice_RealVolume(SBYTE voice)
+{
+ ULONG result=0;
+
+ MUTEX_LOCK(vars);
+ if((voice>=0)&&(voice<md_numchn)&& md_driver->VoiceRealVolume)
+ result=(md_driver->VoiceRealVolume(voice));
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI void VC_SetCallback(MikMod_callback_t callback)
+{
+ vc_callback = callback;
+}
+
+static int _mm_init(const CHAR *cmdline)
+{
+ UWORD t;
+
+ _mm_critical = 1;
+
+ /* if md_device==0, try to find a device number */
+ if(!md_device) {
+ cmdline=NULL;
+
+ for(t=1,md_driver=firstdriver;md_driver;md_driver=md_driver->next,t++)
+ if(md_driver->IsPresent()) break;
+
+ if(!md_driver) {
+ _mm_errno = MMERR_DETECTING_DEVICE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ md_driver = &drv_nos;
+ return 1;
+ }
+
+ md_device = t;
+ } else {
+ /* if n>0, use that driver */
+ for(t=1,md_driver=firstdriver;(md_driver)&&(t!=md_device);md_driver=md_driver->next)
+ t++;
+
+ if(!md_driver) {
+ _mm_errno = MMERR_INVALID_DEVICE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ md_driver = &drv_nos;
+ return 1;
+ }
+
+ /* arguments here might be necessary for the presence check to succeed */
+ if(cmdline&&(md_driver->CommandLine))
+ md_driver->CommandLine(cmdline);
+
+ if(!md_driver->IsPresent()) {
+ _mm_errno = MMERR_DETECTING_DEVICE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ md_driver = &drv_nos;
+ return 1;
+ }
+ }
+
+ olddevice = md_device;
+ if(md_driver->Init()) {
+ MikMod_Exit_internal();
+ if(_mm_errorhandler) _mm_errorhandler();
+ return 1;
+ }
+
+ initialized=1;
+ _mm_critical=0;
+
+ return 0;
+}
+
+MIKMODAPI int MikMod_Init(const CHAR *cmdline)
+{
+ int result;
+
+ MUTEX_LOCK(vars);
+ MUTEX_LOCK(lists);
+ result=_mm_init(cmdline);
+ MUTEX_UNLOCK(lists);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+void MikMod_Exit_internal(void)
+{
+ MikMod_DisableOutput_internal();
+ md_driver->Exit();
+ md_numchn = md_sfxchn = md_sngchn = 0;
+ md_driver = &drv_nos;
+
+ MikMod_free(sfxinfo);
+ MikMod_free(md_sample);
+ md_sample = NULL;
+ sfxinfo = NULL;
+
+ initialized = 0;
+}
+
+MIKMODAPI void MikMod_Exit(void)
+{
+ MUTEX_LOCK(vars);
+ MUTEX_LOCK(lists);
+ MikMod_Exit_internal();
+ MUTEX_UNLOCK(lists);
+ MUTEX_UNLOCK(vars);
+}
+
+/* Reset the driver using the new global variable settings.
+ If the driver has not been initialized, it will be now. */
+static int _mm_reset(const CHAR *cmdline)
+{
+ BOOL wasplaying = 0;
+
+ if(!initialized) return _mm_init(cmdline);
+
+ if (isplaying) {
+ wasplaying = 1;
+ md_driver->PlayStop();
+ }
+
+ if((!md_driver->Reset)||(md_device != olddevice)) {
+ /* md_driver->Reset was NULL, or md_device was changed, so do a full
+ reset of the driver. */
+ md_driver->Exit();
+ if(_mm_init(cmdline)) {
+ MikMod_Exit_internal();
+ if(_mm_errno)
+ if(_mm_errorhandler) _mm_errorhandler();
+ return 1;
+ }
+ } else {
+ if(md_driver->Reset()) {
+ MikMod_Exit_internal();
+ if(_mm_errno)
+ if(_mm_errorhandler) _mm_errorhandler();
+ return 1;
+ }
+ }
+
+ if (wasplaying) return md_driver->PlayStart();
+ return 0;
+}
+
+MIKMODAPI int MikMod_Reset(const CHAR *cmdline)
+{
+ int result;
+
+ MUTEX_LOCK(vars);
+ MUTEX_LOCK(lists);
+ result=_mm_reset(cmdline);
+ MUTEX_UNLOCK(lists);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+/* If either parameter is -1, the current set value will be retained. */
+int MikMod_SetNumVoices_internal(int music, int sfx)
+{
+ BOOL resume = 0;
+ int t, oldchn = 0;
+
+ if((!music)&&(!sfx)) return 1;
+ _mm_critical = 1;
+ if(isplaying) {
+ MikMod_DisableOutput_internal();
+ oldchn = md_numchn;
+ resume = 1;
+ }
+
+ MikMod_free(sfxinfo);
+ MikMod_free(md_sample);
+ md_sample = NULL;
+ sfxinfo = NULL;
+
+ if(music!=-1) md_sngchn = music;
+ if(sfx!=-1) md_sfxchn = sfx;
+ md_numchn = md_sngchn + md_sfxchn;
+
+ LimitHardVoices(md_driver->HardVoiceLimit);
+ LimitSoftVoices(md_driver->SoftVoiceLimit);
+
+ if(md_driver->SetNumVoices()) {
+ MikMod_Exit_internal();
+ if(_mm_errno)
+ if(_mm_errorhandler!=NULL) _mm_errorhandler();
+ md_numchn = md_softchn = md_hardchn = md_sfxchn = md_sngchn = 0;
+ return 1;
+ }
+
+ if(md_sngchn+md_sfxchn)
+ md_sample=(SAMPLE**)MikMod_calloc(md_sngchn+md_sfxchn,sizeof(SAMPLE*));
+ if(md_sfxchn)
+ sfxinfo = (UBYTE *)MikMod_calloc(md_sfxchn,sizeof(UBYTE));
+
+ /* make sure the player doesn't start with garbage */
+ for(t=oldchn;t<md_numchn;t++) Voice_Stop_internal(t);
+
+ sfxpool = 0;
+ if(resume) MikMod_EnableOutput_internal();
+ _mm_critical = 0;
+
+ return 0;
+}
+
+MIKMODAPI int MikMod_SetNumVoices(int music, int sfx)
+{
+ int result;
+
+ MUTEX_LOCK(vars);
+ result=MikMod_SetNumVoices_internal(music,sfx);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+int MikMod_EnableOutput_internal(void)
+{
+ _mm_critical = 1;
+ if(!isplaying) {
+ if(md_driver->PlayStart()) return 1;
+ isplaying = 1;
+ }
+ _mm_critical = 0;
+ return 0;
+}
+
+MIKMODAPI int MikMod_EnableOutput(void)
+{
+ int result;
+
+ MUTEX_LOCK(vars);
+ result=MikMod_EnableOutput_internal();
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+void MikMod_DisableOutput_internal(void)
+{
+ if(isplaying && md_driver) {
+ isplaying = 0;
+ md_driver->PlayStop();
+ }
+}
+
+MIKMODAPI void MikMod_DisableOutput(void)
+{
+ MUTEX_LOCK(vars);
+ MikMod_DisableOutput_internal();
+ MUTEX_UNLOCK(vars);
+}
+
+BOOL MikMod_Active_internal(void)
+{
+ return isplaying;
+}
+
+MIKMODAPI BOOL MikMod_Active(void)
+{
+ BOOL result;
+
+ MUTEX_LOCK(vars);
+ result=MikMod_Active_internal();
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+/* Plays a sound effects sample. Picks a voice from the number of voices
+ allocated for use as sound effects (loops through voices, skipping all active
+ criticals).
+
+ Returns the voice that the sound is being played on. */
+static SBYTE Sample_Play_internal(SAMPLE *s,ULONG start,UBYTE flags)
+{
+ int orig=sfxpool;/* for cases where all channels are critical */
+ int c;
+
+ if(!md_sfxchn) return -1;
+ if(s->volume>64) s->volume = 64;
+
+ /* check the first location after sfxpool */
+ do {
+ if(sfxinfo[sfxpool]&SFX_CRITICAL) {
+ if(md_driver->VoiceStopped(c=sfxpool+md_sngchn)) {
+ sfxinfo[sfxpool]=flags;
+ Voice_Play_internal(c,s,start);
+ md_driver->VoiceSetVolume(c,s->volume<<2);
+ Voice_SetPanning_internal(c,s->panning);
+ md_driver->VoiceSetFrequency(c,s->speed);
+ sfxpool++;
+ if(sfxpool>=md_sfxchn) sfxpool=0;
+ return c;
+ }
+ } else {
+ sfxinfo[sfxpool]=flags;
+ Voice_Play_internal(c=sfxpool+md_sngchn,s,start);
+ md_driver->VoiceSetVolume(c,s->volume<<2);
+ Voice_SetPanning_internal(c,s->panning);
+ md_driver->VoiceSetFrequency(c,s->speed);
+ sfxpool++;
+ if(sfxpool>=md_sfxchn) sfxpool=0;
+ return c;
+ }
+
+ sfxpool++;
+ if(sfxpool>=md_sfxchn) sfxpool = 0;
+ } while(sfxpool!=orig);
+
+ return -1;
+}
+
+MIKMODAPI SBYTE Sample_Play(SAMPLE *s,ULONG start,UBYTE flags)
+{
+ SBYTE result;
+
+ MUTEX_LOCK(vars);
+ result=Sample_Play_internal(s,start,flags);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI long MikMod_GetVersion(void)
+{
+ return LIBMIKMOD_VERSION;
+}
+
+/*========== MT-safe stuff */
+
+#ifdef HAVE_PTHREAD
+#define INIT_MUTEX(name) \
+ pthread_mutex_t _mm_mutex_##name=PTHREAD_MUTEX_INITIALIZER
+
+#elif defined(__OS2__)||defined(__EMX__)
+#define INIT_MUTEX(name) \
+ HMTX _mm_mutex_##name
+
+#elif defined(_WIN32)
+#define INIT_MUTEX(name) \
+ HANDLE _mm_mutex_##name
+
+#else
+#define INIT_MUTEX(name) \
+ void *_mm_mutex_##name = NULL
+#endif
+
+INIT_MUTEX(vars);
+INIT_MUTEX(lists);
+
+MIKMODAPI BOOL MikMod_InitThreads(void)
+{
+ static int firstcall=1;
+ static BOOL result = 0;
+
+ if (firstcall) {
+ firstcall=0;
+#ifdef HAVE_PTHREAD
+ result=1;
+#elif defined(__OS2__)||defined(__EMX__)
+ if(DosCreateMutexSem((PSZ)NULL,&_mm_mutex_lists,0,0) ||
+ DosCreateMutexSem((PSZ)NULL,&_mm_mutex_vars,0,0)) {
+ _mm_mutex_lists=_mm_mutex_vars=(HMTX)NULL;
+ result=0;
+ } else
+ result=1;
+#elif defined(_WIN32)
+ if((!(_mm_mutex_lists=CreateMutex(NULL,FALSE,TEXT("libmikmod(lists)"))))||
+ (!(_mm_mutex_vars=CreateMutex(NULL,FALSE,TEXT("libmikmod(vars)")))))
+ result=0;
+ else
+ result=1;
+#endif
+ }
+ return result;
+}
+
+MIKMODAPI void MikMod_Unlock(void)
+{
+ MUTEX_UNLOCK(lists);
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void MikMod_Lock(void)
+{
+ MUTEX_LOCK(vars);
+ MUTEX_LOCK(lists);
+}
+
+/*========== Parameter extraction helper */
+
+CHAR *MD_GetAtom(const CHAR *atomname, const CHAR *cmdline, BOOL implicit)
+{
+ CHAR *ret=NULL;
+
+ if(cmdline) {
+ const CHAR *buf=strstr(cmdline,atomname);
+
+ if((buf)&&((buf==cmdline)||(*(buf-1)==','))) {
+ const CHAR *ptr=buf+strlen(atomname);
+
+ if(*ptr=='=') {
+ for(buf=++ptr;(*ptr)&&((*ptr)!=',');ptr++);
+ ret=(CHAR *)MikMod_malloc((1+ptr-buf)*sizeof(CHAR));
+ if(ret)
+ strncpy(ret,buf,ptr-buf);
+ } else if((*ptr==',')||(!*ptr)) {
+ if(implicit) {
+ ret=(CHAR *)MikMod_malloc((1+ptr-buf)*sizeof(CHAR));
+ if(ret)
+ strncpy(ret,buf,ptr-buf);
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+#if (MIKMOD_UNIX)
+
+/*========== Posix helper functions */
+
+/* Check if the file is a regular or nonexistant file (or a link to a such a
+ file), and that, should the calling program be setuid, the access rights are
+ reasonable. Returns 1 if it is safe to rewrite the file, 0 otherwise.
+ The goal is to prevent a setuid root libmikmod application from overriding
+ files like /etc/passwd with digital sound... */
+BOOL MD_Access(const CHAR * filename)
+{
+ struct stat buf;
+
+ if(!stat(filename,&buf)) {
+ /* not a regular file ? */
+ if(!S_ISREG(buf.st_mode)) return 0;
+ /* more than one hard link to the file ? */
+ if(buf.st_nlink>1) return 0;
+ /* check access rights with the real user and group id */
+ if(getuid()==buf.st_uid) {
+ if(!(buf.st_mode&S_IWUSR)) return 0;
+ } else if(getgid()==buf.st_gid) {
+ if(!(buf.st_mode&S_IWGRP)) return 0;
+ } else
+ if(!(buf.st_mode&S_IWOTH)) return 0;
+ }
+
+ return 1;
+}
+
+/* Drop all root privileges we might have */
+int MD_DropPrivileges(void)
+{
+ if(!geteuid()) {
+ if(getuid()) {
+ /* we are setuid root -> drop setuid to become the real user */
+ if(setuid(getuid())) return 1;
+ } else {
+ /* we are run as root -> drop all and become user 'nobody' */
+ struct passwd *nobody;
+ int uid;
+
+ if(!(nobody=getpwnam("nobody"))) return 1; /* no such user ? */
+ uid=nobody->pw_uid;
+ if (!uid) /* user 'nobody' has root privileges ? weird... */
+ return 1;
+ if (setuid(uid)) return 1;
+ }
+ }
+ return 0;
+}
+
+#endif
+
+/* ex:set ts=8: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2002 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Mu-law routines
+
+==============================================================================*/
+
+/*
+ The contents of this file are derived from the files libst.h and raw.c from
+ an old version of the sox (SOund eXchange) package written by Lance Norskog
+ and Jef Poskanzer.
+ The following copyright notice applies:
+
+ ** Copyright (C) 1989 by Jef Poskanzer.
+ **
+ ** Permission to use, copy, modify, and distribute this software and its
+ ** documentation for any purpose and without fee is hereby granted, provided
+ ** that the above copyright notice appear in all copies and that both that
+ ** copyright notice and this permission notice appear in supporting
+ ** documentation. This software is provided "as is" without express or
+ ** implied warranty.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "mikmod_internals.h"
+
+static const unsigned char ulaw_comp_table[16384] = {
+ 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb,
+ 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7,
+ 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3,
+ 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xef,
+ 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed,
+ 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb,
+ 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xe9,
+ 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7,
+ 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5,
+ 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3,
+ 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1,
+ 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf,
+ 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xde,
+ 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdd,
+ 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc,
+ 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdb,
+ 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xda,
+ 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xd9,
+ 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd8,
+ 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7,
+ 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd6,
+ 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd5,
+ 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4,
+ 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3,
+ 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2,
+ 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd1,
+ 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd0,
+ 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xcf,
+ 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf,
+ 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xce,
+ 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce,
+ 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xcd,
+ 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
+ 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcb,
+ 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb,
+ 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xca,
+ 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca,
+ 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xc9,
+ 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9,
+ 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc8,
+ 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8,
+ 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc7,
+ 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7,
+ 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc6,
+ 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
+ 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc5,
+ 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5,
+ 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc4,
+ 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
+ 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc3,
+ 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3,
+ 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc2,
+ 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2,
+ 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc1,
+ 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
+ 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0,
+ 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
+ 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xbf,
+ 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
+ 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
+ 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
+ 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbe,
+ 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
+ 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
+ 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
+ 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbd,
+ 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
+ 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
+ 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
+ 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc,
+ 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
+ 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
+ 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
+ 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbb,
+ 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+ 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+ 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
+ 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba,
+ 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
+ 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
+ 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
+ 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xb9,
+ 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
+ 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
+ 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
+ 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb8,
+ 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
+ 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
+ 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
+ 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb7,
+ 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
+ 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
+ 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
+ 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb6,
+ 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
+ 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
+ 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
+ 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb5,
+ 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
+ 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
+ 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
+ 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb4,
+ 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
+ 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
+ 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
+ 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb3,
+ 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
+ 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
+ 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
+ 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb2,
+ 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
+ 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
+ 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
+ 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb1,
+ 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
+ 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
+ 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
+ 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb0,
+ 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
+ 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
+ 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
+ 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
+ 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
+ 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
+ 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
+ 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
+ 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
+ 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
+ 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
+ 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
+ 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
+ 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
+ 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
+ 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
+ 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
+ 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
+ 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
+ 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
+ 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
+ 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
+ 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
+ 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
+ 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
+ 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
+ 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
+ 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
+ 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+ 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
+ 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
+ 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
+ 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
+ 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
+ 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
+ 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
+ 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
+ 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
+ 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+ 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
+ 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
+ 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
+ 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
+ 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
+ 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
+ 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
+ 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
+ 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+ 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+ 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
+ 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+ 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
+ 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
+ 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
+ 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+ 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
+ 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
+ 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
+ 0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
+ 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
+ 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
+ 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+ 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+ 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
+ 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
+ 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
+ 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
+ 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
+ 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
+ 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+ 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
+ 0x23, 0x23, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
+ 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
+ 0x26, 0x26, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
+ 0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
+ 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
+ 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
+ 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
+ 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
+ 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
+ 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
+ 0x2f, 0x2f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+ 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+ 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+ 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+ 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+ 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+ 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+ 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+ 0x31, 0x31, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+ 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+ 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+ 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+ 0x33, 0x33, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
+ 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
+ 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
+ 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
+ 0x34, 0x34, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
+ 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
+ 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
+ 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
+ 0x35, 0x35, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
+ 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
+ 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
+ 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
+ 0x37, 0x37, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
+ 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
+ 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
+ 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
+ 0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
+ 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
+ 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
+ 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
+ 0x39, 0x39, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
+ 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
+ 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
+ 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
+ 0x3a, 0x3a, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
+ 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
+ 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
+ 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
+ 0x3b, 0x3b, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
+ 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
+ 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
+ 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
+ 0x3c, 0x3c, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
+ 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
+ 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
+ 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
+ 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
+ 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
+ 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
+ 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
+ 0x3e, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+ 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+ 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+ 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
+ 0x3f, 0x3f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
+ 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
+ 0x41, 0x41, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
+ 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
+ 0x42, 0x42, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
+ 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
+ 0x43, 0x43, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
+ 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
+ 0x44, 0x44, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
+ 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
+ 0x45, 0x45, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+ 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+ 0x46, 0x46, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47,
+ 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47,
+ 0x47, 0x47, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
+ 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
+ 0x48, 0x48, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+ 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+ 0x49, 0x49, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a,
+ 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a,
+ 0x4a, 0x4a, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
+ 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
+ 0x4b, 0x4b, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,
+ 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,
+ 0x4c, 0x4c, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d,
+ 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d,
+ 0x4d, 0x4d, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e,
+ 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e,
+ 0x4e, 0x4e, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
+ 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
+ 0x4f, 0x4f, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
+ 0x50, 0x50, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51,
+ 0x51, 0x51, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52,
+ 0x52, 0x52, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
+ 0x53, 0x53, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
+ 0x54, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+ 0x55, 0x55, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56,
+ 0x56, 0x56, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57,
+ 0x57, 0x57, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58,
+ 0x58, 0x58, 0x59, 0x59, 0x59, 0x59, 0x59, 0x59,
+ 0x59, 0x59, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a,
+ 0x5a, 0x5a, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b,
+ 0x5b, 0x5b, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
+ 0x5c, 0x5c, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d,
+ 0x5d, 0x5d, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e,
+ 0x5e, 0x5e, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f,
+ 0x5f, 0x5f, 0x60, 0x60, 0x60, 0x60, 0x61, 0x61,
+ 0x61, 0x61, 0x62, 0x62, 0x62, 0x62, 0x63, 0x63,
+ 0x63, 0x63, 0x64, 0x64, 0x64, 0x64, 0x65, 0x65,
+ 0x65, 0x65, 0x66, 0x66, 0x66, 0x66, 0x67, 0x67,
+ 0x67, 0x67, 0x68, 0x68, 0x68, 0x68, 0x69, 0x69,
+ 0x69, 0x69, 0x6a, 0x6a, 0x6a, 0x6a, 0x6b, 0x6b,
+ 0x6b, 0x6b, 0x6c, 0x6c, 0x6c, 0x6c, 0x6d, 0x6d,
+ 0x6d, 0x6d, 0x6e, 0x6e, 0x6e, 0x6e, 0x6f, 0x6f,
+ 0x6f, 0x6f, 0x70, 0x70, 0x71, 0x71, 0x72, 0x72,
+ 0x73, 0x73, 0x74, 0x74, 0x75, 0x75, 0x76, 0x76,
+ 0x77, 0x77, 0x78, 0x78, 0x79, 0x79, 0x7a, 0x7a,
+ 0x7b, 0x7b, 0x7c, 0x7c, 0x7d, 0x7d, 0x7e, 0x7e
+};
+
+#define st_linear_to_ulaw(x) ulaw_comp_table[(x / 4) & 0x3fff]
+
+/* convert unsigned linear data from Mixer_WriteBytes() to ulaw */
+void unsignedtoulaw(char *buf, int nsamp)
+{
+ while (nsamp--) {
+ register long datum = (long)*((unsigned char *)buf);
+
+ datum ^= 128; /* convert to signed */
+ datum <<= 8;
+ /* round up to 12 bits of data */
+ datum += 0x8; /* + 0b1000 */
+ datum = st_linear_to_ulaw(datum);
+ *buf++ = (char)datum;
+ }
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ These routines are used to access the available module loaders
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+MREADER *modreader;
+MODULE of;
+
+static MLOADER *firstloader=NULL;
+
+static MUNPACKER unpackers[] = {
+ PP20_Unpack,
+ MMCMP_Unpack,
+ XPK_Unpack,
+ S404_Unpack,
+ NULL
+};
+
+const UWORD finetune[16] = {
+ 8363,8413,8463,8529,8581,8651,8723,8757,
+ 7895,7941,7985,8046,8107,8169,8232,8280
+};
+
+MIKMODAPI CHAR* MikMod_InfoLoader(void)
+{
+ int len=0;
+ MLOADER *l;
+ CHAR *list=NULL;
+
+ MUTEX_LOCK(lists);
+ /* compute size of buffer */
+ for(l = firstloader; l; l = l->next)
+ len += 1 + (l->next ? 1 : 0) + strlen(l->version);
+
+ if(len)
+ if((list=(CHAR*)MikMod_malloc(len*sizeof(CHAR))) != NULL) {
+ CHAR *list_end = list;
+ list[0] = 0;
+ /* list all registered module loders */
+ for(l = firstloader; l; l = l->next) {
+ list_end += sprintf(list_end, "%s%s", l->version, (l->next) ? "\n" : "");
+ }
+ }
+ MUTEX_UNLOCK(lists);
+ return list;
+}
+
+void _mm_registerloader(MLOADER* ldr)
+{
+ MLOADER *cruise=firstloader;
+
+ if(cruise) {
+ while(cruise->next) cruise = cruise->next;
+ cruise->next=ldr;
+ } else
+ firstloader=ldr;
+}
+
+MIKMODAPI void MikMod_RegisterLoader(struct MLOADER* ldr)
+{
+ /* if we try to register an invalid loader, or an already registered loader,
+ ignore this attempt */
+ if ((!ldr)||(ldr->next))
+ return;
+
+ MUTEX_LOCK(lists);
+ _mm_registerloader(ldr);
+ MUTEX_UNLOCK(lists);
+}
+
+BOOL ReadComment(UWORD len)
+{
+ if(len) {
+ int i;
+
+ if(!(of.comment=(CHAR*)MikMod_malloc(len+1))) return 0;
+ _mm_read_UBYTES(of.comment,len,modreader);
+
+ /* translate IT linefeeds */
+ for(i=0;i<len;i++)
+ if(of.comment[i]=='\r') of.comment[i]='\n';
+
+ of.comment[len]=0; /* just in case */
+ }
+ if(!of.comment[0]) {
+ MikMod_free(of.comment);
+ of.comment=NULL;
+ }
+ return 1;
+}
+
+BOOL ReadLinedComment(UWORD len,UWORD linelen)
+{
+ CHAR *tempcomment,*line,*storage;
+ UWORD total=0,t,lines;
+ int i;
+
+ lines = (len + linelen - 1) / linelen;
+ if (len) {
+ if(!(tempcomment=(CHAR*)MikMod_malloc(len+1))) return 0;
+ if(!(storage=(CHAR*)MikMod_malloc(linelen+1))) {
+ MikMod_free(tempcomment);
+ return 0;
+ }
+ memset(tempcomment, ' ', len);
+ _mm_read_UBYTES(tempcomment,len,modreader);
+
+ /* compute message length */
+ for(line=tempcomment,total=t=0;t<lines;t++,line+=linelen) {
+ for(i=linelen;(i>=0)&&(line[i]==' ');i--) line[i]=0;
+ for(i=0;i<linelen;i++) if (!line[i]) break;
+ total+=1+i;
+ }
+
+ if(total>lines) {
+ if(!(of.comment=(CHAR*)MikMod_malloc(total+1))) {
+ MikMod_free(storage);
+ MikMod_free(tempcomment);
+ return 0;
+ }
+
+ /* convert message */
+ for(line=tempcomment,t=0;t<lines;t++,line+=linelen) {
+ for(i=0;i<linelen;i++) if(!(storage[i]=line[i])) break;
+ storage[i]=0; /* if (i==linelen) */
+ strcat(of.comment,storage);strcat(of.comment,"\r");
+ }
+ MikMod_free(storage);
+ MikMod_free(tempcomment);
+ }
+ }
+ return 1;
+}
+
+BOOL AllocPositions(int total)
+{
+ if(!total) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ if(!(of.positions=(UWORD*)MikMod_calloc(total,sizeof(UWORD)))) return 0;
+ return 1;
+}
+
+BOOL AllocPatterns(void)
+{
+ int s,t,tracks = 0;
+
+ if((!of.numpat)||(!of.numchn)) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ /* Allocate track sequencing array */
+ if(!(of.patterns=(UWORD*)MikMod_calloc((ULONG)(of.numpat+1)*of.numchn,sizeof(UWORD)))) return 0;
+ if(!(of.pattrows=(UWORD*)MikMod_calloc(of.numpat+1,sizeof(UWORD)))) return 0;
+
+ for(t=0;t<=of.numpat;t++) {
+ of.pattrows[t]=64;
+ for(s=0;s<of.numchn;s++)
+ of.patterns[(t*of.numchn)+s]=tracks++;
+ }
+
+ return 1;
+}
+
+BOOL AllocTracks(void)
+{
+ if(!of.numtrk) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ if(!(of.tracks=(UBYTE **)MikMod_calloc(of.numtrk,sizeof(UBYTE *)))) return 0;
+ return 1;
+}
+
+BOOL AllocInstruments(void)
+{
+ int t,n;
+
+ if(!of.numins) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ if(!(of.instruments=(INSTRUMENT*)MikMod_calloc(of.numins,sizeof(INSTRUMENT))))
+ return 0;
+
+ for(t=0;t<of.numins;t++) {
+ for(n=0;n<INSTNOTES;n++) {
+ /* Init note / sample lookup table */
+ of.instruments[t].samplenote[n] = n;
+ of.instruments[t].samplenumber[n] = t;
+ }
+ of.instruments[t].globvol = 64;
+ }
+ return 1;
+}
+
+BOOL AllocSamples(void)
+{
+ UWORD u;
+
+ if(!of.numsmp) {
+ _mm_errno=MMERR_NOT_A_MODULE;
+ return 0;
+ }
+ if(!(of.samples=(SAMPLE*)MikMod_calloc(of.numsmp,sizeof(SAMPLE)))) return 0;
+
+ for(u=0;u<of.numsmp;u++) {
+ of.samples[u].panning = 128; /* center */
+ of.samples[u].handle = -1;
+ of.samples[u].globvol = 64;
+ of.samples[u].volume = 64;
+ }
+ return 1;
+}
+
+static BOOL ML_LoadSamples(void)
+{
+ SAMPLE *s;
+ int u;
+
+ for(u=of.numsmp,s=of.samples;u;u--,s++)
+ if(s->length) SL_RegisterSample(s,MD_MUSIC,modreader);
+
+ return 1;
+}
+
+/* Creates a CSTR out of a character buffer of 'len' bytes, but strips any
+ terminating non-printing characters like 0, spaces etc. */
+CHAR *DupStr(const CHAR* s, UWORD len, BOOL strict)
+{
+ UWORD t;
+ CHAR *d=NULL;
+
+ /* Scan for last printing char in buffer [includes high ascii up to 254] */
+ while(len) {
+ if(s[len-1]>0x20) break;
+ len--;
+ }
+
+ /* Scan forward for possible NULL character */
+ if(strict) {
+ for(t=0;t<len;t++) if (!s[t]) break;
+ if (t<len) len=t;
+ }
+
+ /* When the buffer wasn't completely empty, allocate a cstring and copy the
+ buffer into that string, except for any control-chars */
+ if((d=(CHAR*)MikMod_malloc(sizeof(CHAR)*(len+1))) != NULL) {
+ for(t=0;t<len;t++) d[t]=(s[t]<32)?'.':s[t];
+ d[len]=0;
+ }
+ return d;
+}
+
+static void ML_XFreeSample(SAMPLE *s)
+{
+ if(s->handle>=0)
+ MD_SampleUnload(s->handle);
+
+/* moved samplename freeing to our caller ML_FreeEx(),
+ * because we are called conditionally. */
+}
+
+static void ML_XFreeInstrument(INSTRUMENT *i)
+{
+ MikMod_free(i->insname);
+}
+
+static void ML_FreeEx(MODULE *mf)
+{
+ UWORD t;
+
+ MikMod_free(mf->songname);
+ MikMod_free(mf->comment);
+
+ MikMod_free(mf->modtype);
+ MikMod_free(mf->positions);
+ MikMod_free(mf->patterns);
+ MikMod_free(mf->pattrows);
+
+ if(mf->tracks) {
+ for(t=0;t<mf->numtrk;t++)
+ MikMod_free(mf->tracks[t]);
+ MikMod_free(mf->tracks);
+ }
+ if(mf->instruments) {
+ for(t=0;t<mf->numins;t++)
+ ML_XFreeInstrument(&mf->instruments[t]);
+ MikMod_free(mf->instruments);
+ }
+ if(mf->samples) {
+ for(t=0;t<mf->numsmp;t++) {
+ MikMod_free(mf->samples[t].samplename);
+ if(mf->samples[t].length) ML_XFreeSample(&mf->samples[t]);
+ }
+ MikMod_free(mf->samples);
+ }
+ memset(mf,0,sizeof(MODULE));
+ if(mf!=&of) MikMod_free(mf);
+}
+
+static MODULE *ML_AllocUniMod(void)
+{
+ return (MODULE *) MikMod_malloc(sizeof(MODULE));
+}
+
+static BOOL ML_TryUnpack(MREADER *reader,void **out,long *outlen)
+{
+ int i;
+
+ *out = NULL;
+ *outlen = 0;
+
+ for(i=0;unpackers[i]!=NULL;++i) {
+ _mm_rewind(reader);
+ if(unpackers[i](reader,out,outlen)) return 1;
+ }
+ return 0;
+}
+
+static void Player_Free_internal(MODULE *mf)
+{
+ if(mf) {
+ Player_Exit_internal(mf);
+ ML_FreeEx(mf);
+ }
+}
+
+MIKMODAPI void Player_Free(MODULE *mf)
+{
+ MUTEX_LOCK(vars);
+ Player_Free_internal(mf);
+ MUTEX_UNLOCK(vars);
+}
+
+static CHAR* Player_LoadTitle_internal(MREADER *reader)
+{
+ MLOADER *l;
+ CHAR *title;
+ void *unpk;
+ long newlen;
+
+ modreader=reader;
+ _mm_errno = 0;
+ _mm_critical = 0;
+ _mm_iobase_setcur(modreader);
+
+ if(ML_TryUnpack(modreader,&unpk,&newlen)) {
+ if(!(modreader=_mm_new_mem_reader(unpk,newlen))) {
+ modreader=reader;
+ MikMod_free(unpk);
+ return NULL;
+ }
+ }
+
+ /* Try to find a loader that recognizes the module */
+ for(l=firstloader;l;l=l->next) {
+ _mm_rewind(modreader);
+ if(l->Test()) break;
+ }
+
+ if(l) {
+ title = l->LoadTitle();
+ }
+ else {
+ _mm_errno = MMERR_NOT_A_MODULE;
+ if(_mm_errorhandler) _mm_errorhandler();
+ title = NULL;
+ }
+
+ if (modreader!=reader) {
+ _mm_delete_mem_reader(modreader);
+ modreader=reader;
+ MikMod_free(unpk);
+ }
+ return title;
+}
+
+MIKMODAPI CHAR* Player_LoadTitleFP(FILE *fp)
+{
+ CHAR* result=NULL;
+ MREADER* reader;
+
+ if(fp && (reader=_mm_new_file_reader(fp)) != NULL) {
+ MUTEX_LOCK(lists);
+ result=Player_LoadTitle_internal(reader);
+ MUTEX_UNLOCK(lists);
+ _mm_delete_file_reader(reader);
+ }
+ return result;
+}
+
+MIKMODAPI CHAR* Player_LoadTitleMem(const char *buffer,int len)
+{
+ CHAR *result=NULL;
+ MREADER* reader;
+
+ if (!buffer || len <= 0) return NULL;
+ if ((reader=_mm_new_mem_reader(buffer,len)) != NULL)
+ {
+ MUTEX_LOCK(lists);
+ result=Player_LoadTitle_internal(reader);
+ MUTEX_UNLOCK(lists);
+ _mm_delete_mem_reader(reader);
+ }
+
+ return result;
+}
+
+MIKMODAPI CHAR* Player_LoadTitleGeneric(MREADER *reader)
+{
+ CHAR *result=NULL;
+
+ if (reader) {
+ MUTEX_LOCK(lists);
+ result=Player_LoadTitle_internal(reader);
+ MUTEX_UNLOCK(lists);
+ }
+ return result;
+}
+
+MIKMODAPI CHAR* Player_LoadTitle(const CHAR* filename)
+{
+ CHAR* result=NULL;
+ FILE* fp;
+ MREADER* reader;
+
+ if((fp=_mm_fopen(filename,"rb")) != NULL) {
+ if((reader=_mm_new_file_reader(fp)) != NULL) {
+ MUTEX_LOCK(lists);
+ result=Player_LoadTitle_internal(reader);
+ MUTEX_UNLOCK(lists);
+ _mm_delete_file_reader(reader);
+ }
+ _mm_fclose(fp);
+ }
+ return result;
+}
+
+/* Loads a module given an reader */
+static MODULE* Player_LoadGeneric_internal(MREADER *reader,int maxchan,BOOL curious)
+{
+ int t;
+ MLOADER *l;
+ BOOL ok;
+ MODULE *mf;
+ void *unpk;
+ long newlen;
+
+ modreader = reader;
+ _mm_errno = 0;
+ _mm_critical = 0;
+ _mm_iobase_setcur(modreader);
+
+ if(ML_TryUnpack(modreader,&unpk,&newlen)) {
+ if(!(modreader=_mm_new_mem_reader(unpk,newlen))) {
+ modreader=reader;
+ MikMod_free(unpk);
+ return NULL;
+ }
+ }
+
+ /* Try to find a loader that recognizes the module */
+ for(l=firstloader;l;l=l->next) {
+ _mm_rewind(modreader);
+ if(l->Test()) break;
+ }
+
+ if(!l) {
+ _mm_errno = MMERR_NOT_A_MODULE;
+ if(modreader!=reader) {
+ _mm_delete_mem_reader(modreader);
+ modreader=reader;
+ MikMod_free(unpk);
+ }
+ if(_mm_errorhandler) _mm_errorhandler();
+ _mm_rewind(modreader);
+ _mm_iobase_revert(modreader);
+ return NULL;
+ }
+
+ /* init unitrk routines */
+ if(!UniInit()) {
+ if(modreader!=reader) {
+ _mm_delete_mem_reader(modreader);
+ modreader=reader;
+ MikMod_free(unpk);
+ }
+ if(_mm_errorhandler) _mm_errorhandler();
+ _mm_rewind(modreader);
+ _mm_iobase_revert(modreader);
+ return NULL;
+ }
+
+ /* init the module structure with vanilla settings */
+ memset(&of,0,sizeof(MODULE));
+ of.bpmlimit = 33;
+ of.initvolume = 128;
+ for (t = 0; t < UF_MAXCHAN; t++) of.chanvol[t] = 64;
+ for (t = 0; t < UF_MAXCHAN; t++)
+ of.panning[t] = ((t + 1) & 2) ? PAN_RIGHT : PAN_LEFT;
+
+ /* init module loader and load the header / patterns */
+ if (!l->Init || l->Init()) {
+ _mm_rewind(modreader);
+ ok = l->Load(curious);
+ if (ok) {
+ /* propagate inflags=flags for in-module samples */
+ for (t = 0; t < of.numsmp; t++)
+ if (of.samples[t].inflags == 0)
+ of.samples[t].inflags = of.samples[t].flags;
+ }
+ } else
+ ok = 0;
+
+ /* free loader and unitrk allocations */
+ if (l->Cleanup) l->Cleanup();
+ UniCleanup();
+
+ if(ok) ok = ML_LoadSamples();
+ if(ok) ok = ((mf=ML_AllocUniMod()) != NULL);
+ if(!ok) {
+ ML_FreeEx(&of);
+ if(modreader!=reader) {
+ _mm_delete_mem_reader(modreader);
+ modreader=reader;
+ MikMod_free(unpk);
+ }
+ if(_mm_errorhandler) _mm_errorhandler();
+ _mm_rewind(modreader);
+ _mm_iobase_revert(modreader);
+ return NULL;
+ }
+
+ /* If the module doesn't have any specific panning, create a
+ MOD-like panning, with the channels half-separated. */
+ if (!(of.flags & UF_PANNING))
+ for (t = 0; t < of.numchn; t++)
+ of.panning[t] = ((t + 1) & 2) ? PAN_HALFRIGHT : PAN_HALFLEFT;
+
+ /* Copy the static MODULE contents into the dynamic MODULE struct. */
+ memcpy(mf,&of,sizeof(MODULE));
+
+ if(maxchan>0) {
+ if(!(mf->flags&UF_NNA)&&(mf->numchn<maxchan))
+ maxchan = mf->numchn;
+ else
+ if((mf->numvoices)&&(mf->numvoices<maxchan))
+ maxchan = mf->numvoices;
+
+ if(maxchan<mf->numchn) mf->flags |= UF_NNA;
+
+ ok = !MikMod_SetNumVoices_internal(maxchan,-1);
+ }
+
+ if(ok) ok = !SL_LoadSamples();
+ if(ok) ok = !Player_Init(mf);
+
+ if(modreader!=reader) {
+ _mm_delete_mem_reader(modreader);
+ modreader=reader;
+ MikMod_free(unpk);
+ }
+ _mm_iobase_revert(modreader);
+
+ if(!ok) {
+ Player_Free_internal(mf);
+ return NULL;
+ }
+ return mf;
+}
+
+MIKMODAPI MODULE* Player_LoadGeneric(MREADER *reader,int maxchan,BOOL curious)
+{
+ MODULE* result;
+
+ MUTEX_LOCK(vars);
+ MUTEX_LOCK(lists);
+ result=Player_LoadGeneric_internal(reader,maxchan,curious);
+ MUTEX_UNLOCK(lists);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI MODULE* Player_LoadMem(const char *buffer,int len,int maxchan,BOOL curious)
+{
+ MODULE* result=NULL;
+ MREADER* reader;
+
+ if (!buffer || len <= 0) return NULL;
+ if ((reader=_mm_new_mem_reader(buffer, len)) != NULL) {
+ result=Player_LoadGeneric(reader,maxchan,curious);
+ _mm_delete_mem_reader(reader);
+ }
+ return result;
+}
+
+/* Loads a module given a file pointer.
+ File is loaded from the current file seek position. */
+MIKMODAPI MODULE* Player_LoadFP(FILE* fp,int maxchan,BOOL curious)
+{
+ MODULE* result=NULL;
+ struct MREADER* reader;
+
+ if (fp && (reader=_mm_new_file_reader(fp)) != NULL) {
+ result=Player_LoadGeneric(reader,maxchan,curious);
+ _mm_delete_file_reader(reader);
+ }
+ return result;
+}
+
+/* Open a module via its filename. The loader will initialize the specified
+ song-player 'player'. */
+MIKMODAPI MODULE* Player_Load(const CHAR* filename,int maxchan,BOOL curious)
+{
+ FILE *fp;
+ MODULE *mf=NULL;
+
+ if((fp=_mm_fopen(filename,"rb")) != NULL) {
+ mf=Player_LoadFP(fp,maxchan,curious);
+ _mm_fclose(fp);
+ }
+ return mf;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Routine for registering all loaders in libmikmod for the current platform.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+static void MikMod_RegisterAllLoaders_internal(void)
+{
+ _mm_registerloader(&load_it);
+ _mm_registerloader(&load_mod);
+ _mm_registerloader(&load_s3m);
+ _mm_registerloader(&load_xm);
+}
+
+MIKMODAPI void MikMod_RegisterAllLoaders(void)
+{
+ MUTEX_LOCK(lists);
+ MikMod_RegisterAllLoaders_internal();
+ MUTEX_UNLOCK(lists);
+}
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Utility functions for the module loader
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+/*========== Shared tracker identifiers */
+
+const CHAR *STM_Signatures[STM_NTRACKERS] = {
+ "!Scream!",
+ "BMOD2STM",
+ "WUZAMOD!"
+};
+
+const CHAR *STM_Version[STM_NTRACKERS] = {
+ "Screamtracker 2",
+ "Converted by MOD2STM (STM format)",
+ "Wuzamod (STM format)"
+};
+
+/*========== Shared loader variables */
+
+SBYTE remap[UF_MAXCHAN]; /* for removing empty channels */
+UBYTE* poslookup=NULL; /* lookup table for pattern jumps after blank
+ pattern removal */
+UWORD poslookupcnt;
+UWORD* origpositions=NULL;
+
+BOOL filters; /* resonant filters in use */
+UBYTE activemacro; /* active midi macro number for Sxx,xx<80h */
+UBYTE filtermacros[UF_MAXMACRO]; /* midi macro settings */
+FILTER filtersettings[UF_MAXFILTER]; /* computed filter settings */
+
+/*========== Linear periods stuff */
+
+int* noteindex=NULL; /* remap value for linear period modules */
+static unsigned noteindexcount=0;
+
+int *AllocLinear(void)
+{
+ if(of.numsmp>noteindexcount) {
+ noteindexcount=of.numsmp;
+ noteindex=(int*)MikMod_realloc(noteindex,noteindexcount*sizeof(int));
+ }
+ return noteindex;
+}
+
+void FreeLinear(void)
+{
+ MikMod_free(noteindex);
+ noteindex=NULL;
+ noteindexcount=0;
+}
+
+int speed_to_finetune(ULONG speed,int sample)
+{
+ int ctmp=0,tmp,note=1,ft=0;
+
+ speed>>=1;
+ while((tmp=(int)getfrequency(of.flags,getlinearperiod(note<<1,0)))<speed) {
+ ctmp=tmp;
+ note++;
+ }
+
+ if(tmp!=speed) {
+ if((tmp-speed)<(speed-ctmp))
+ while(tmp>(int)speed)
+ tmp=getfrequency(of.flags,getlinearperiod(note<<1,--ft));
+ else {
+ note--;
+ while(ctmp<(int)speed)
+ ctmp=getfrequency(of.flags,getlinearperiod(note<<1,++ft));
+ }
+ }
+
+ noteindex[sample]=note-4*OCTAVE;
+ return ft;
+}
+
+/*========== Order stuff */
+
+/* handles S3M and IT orders */
+void S3MIT_CreateOrders(BOOL curious)
+{
+ int t;
+
+ of.numpos = 0;
+ memset(of.positions,0,poslookupcnt*sizeof(UWORD));
+ memset(poslookup,-1,256);
+ for(t=0;t<poslookupcnt;t++) {
+ int order=origpositions[t];
+ if(order==255) order=LAST_PATTERN;
+ of.positions[of.numpos]=order;
+ poslookup[t]=of.numpos; /* bug fix for freaky S3Ms / ITs */
+ if(origpositions[t]<254) of.numpos++;
+ else
+ /* end of song special order */
+ if((order==LAST_PATTERN)&&(!(curious--))) break;
+ }
+}
+
+/*========== Effect stuff */
+
+/* handles S3M and IT effects */
+void S3MIT_ProcessCmd(UBYTE cmd, UBYTE inf, unsigned int flags)
+{
+ UBYTE lo = inf&0xF;
+ /* process S3M / IT specific command structure */
+
+ if(cmd!=255) {
+ switch(cmd) {
+ case 1: /* Axx set speed to xx */
+ UniEffect(UNI_S3MEFFECTA,inf);
+ break;
+ case 2: /* Bxx position jump */
+ if (inf<poslookupcnt) {
+ /* switch to curious mode if necessary, for example
+ sympex.it, deep joy.it */
+ if(((SBYTE)poslookup[inf]<0)&&(origpositions[inf]!=255))
+ S3MIT_CreateOrders(1);
+
+ if(!((SBYTE)poslookup[inf]<0))
+ UniPTEffect(0xb,poslookup[inf]);
+ }
+ break;
+ case 3: /* Cxx patternbreak to row xx */
+ if ((flags & S3MIT_OLDSTYLE) && !(flags & S3MIT_IT))
+ UniPTEffect(0xd,(inf>>4)*10+(inf&0xf));
+ else
+ UniPTEffect(0xd,inf);
+ break;
+ case 4: /* Dxy volumeslide */
+ UniEffect(UNI_S3MEFFECTD,inf);
+ break;
+ case 5: /* Exy toneslide down */
+ UniEffect(UNI_S3MEFFECTE,inf);
+ break;
+ case 6: /* Fxy toneslide up */
+ UniEffect(UNI_S3MEFFECTF,inf);
+ break;
+ case 7: /* Gxx Tone portamento, speed xx */
+ if (flags & S3MIT_OLDSTYLE)
+ UniPTEffect(0x3,inf);
+ else
+ UniEffect(UNI_ITEFFECTG,inf);
+ break;
+ case 8: /* Hxy vibrato */
+ if (flags & S3MIT_OLDSTYLE)
+ UniPTEffect(0x4,inf);
+ else
+ UniEffect(UNI_ITEFFECTH,inf);
+ break;
+ case 9: /* Ixy tremor, ontime x, offtime y */
+ if (flags & S3MIT_OLDSTYLE)
+ UniEffect(UNI_S3MEFFECTI,inf);
+ else
+ UniEffect(UNI_ITEFFECTI,inf);
+ break;
+ case 0xa: /* Jxy arpeggio */
+ UniPTEffect(0x0,inf);
+ break;
+ case 0xb: /* Kxy Dual command H00 & Dxy */
+ if (flags & S3MIT_OLDSTYLE)
+ UniPTEffect(0x4,0);
+ else
+ UniEffect(UNI_ITEFFECTH,0);
+ UniEffect(UNI_S3MEFFECTD,inf);
+ break;
+ case 0xc: /* Lxy Dual command G00 & Dxy */
+ if (flags & S3MIT_OLDSTYLE)
+ UniPTEffect(0x3,0);
+ else
+ UniEffect(UNI_ITEFFECTG,0);
+ UniEffect(UNI_S3MEFFECTD,inf);
+ break;
+ case 0xd: /* Mxx Set Channel Volume */
+ UniEffect(UNI_ITEFFECTM,inf);
+ break;
+ case 0xe: /* Nxy Slide Channel Volume */
+ UniEffect(UNI_ITEFFECTN,inf);
+ break;
+ case 0xf: /* Oxx set sampleoffset xx00h */
+ UniPTEffect(0x9,inf);
+ break;
+ case 0x10: /* Pxy Slide Panning Commands */
+ UniEffect(UNI_ITEFFECTP,inf);
+ break;
+ case 0x11: /* Qxy Retrig (+volumeslide) */
+ UniWriteByte(UNI_S3MEFFECTQ);
+ if(inf && !lo && !(flags & S3MIT_OLDSTYLE))
+ UniWriteByte(1);
+ else
+ UniWriteByte(inf);
+ break;
+ case 0x12: /* Rxy tremolo speed x, depth y */
+ UniEffect(UNI_S3MEFFECTR,inf);
+ break;
+ case 0x13: /* Sxx special commands */
+ if (inf>=0xf0) {
+ /* change resonant filter settings if necessary */
+ if((filters)&&((inf&0xf)!=activemacro)) {
+ activemacro=inf&0xf;
+ for(inf=0;inf<0x80;inf++)
+ filtersettings[inf].filter=filtermacros[activemacro];
+ }
+ } else {
+ /* Scream Tracker does not have samples larger than
+ 64 Kb, thus doesn't need the SAx effect */
+ if ((flags & S3MIT_SCREAM) && ((inf & 0xf0) == 0xa0))
+ break;
+
+ UniEffect(UNI_ITEFFECTS0,inf);
+ }
+ break;
+ case 0x14: /* Txx tempo */
+ if(inf>=0x20)
+ UniEffect(UNI_S3MEFFECTT,inf);
+ else {
+ if(!(flags & S3MIT_OLDSTYLE))
+ /* IT Tempo slide */
+ UniEffect(UNI_ITEFFECTT,inf);
+ }
+ break;
+ case 0x15: /* Uxy Fine Vibrato speed x, depth y */
+ if(flags & S3MIT_OLDSTYLE)
+ UniEffect(UNI_S3MEFFECTU,inf);
+ else
+ UniEffect(UNI_ITEFFECTU,inf);
+ break;
+ case 0x16: /* Vxx Set Global Volume */
+ UniEffect(UNI_XMEFFECTG,inf);
+ break;
+ case 0x17: /* Wxy Global Volume Slide */
+ UniEffect(UNI_ITEFFECTW,inf);
+ break;
+ case 0x18: /* Xxx amiga command 8xx */
+ if(flags & S3MIT_OLDSTYLE) {
+ if(inf>128)
+ UniEffect(UNI_ITEFFECTS0,0x91); /* surround */
+ else
+ UniPTEffect(0x8,(inf==128)?255:(inf<<1));
+ } else
+ UniPTEffect(0x8,inf);
+ break;
+ case 0x19: /* Yxy Panbrello speed x, depth y */
+ UniEffect(UNI_ITEFFECTY,inf);
+ break;
+ case 0x1a: /* Zxx midi/resonant filters */
+ if(filtersettings[inf].filter) {
+ UniWriteByte(UNI_ITEFFECTZ);
+ UniWriteByte(filtersettings[inf].filter);
+ UniWriteByte(filtersettings[inf].inf);
+ }
+ break;
+ }
+ }
+}
+
+/*========== Unitrk stuff */
+
+/* Generic effect writing routine */
+void UniEffect(UWORD eff,UWORD dat)
+{
+ if((!eff)||(eff>=UNI_LAST)) return;
+
+ UniWriteByte(eff);
+ if(unioperands[eff]==2)
+ UniWriteWord(dat);
+ else
+ UniWriteByte(dat);
+}
+
+/* Appends UNI_PTEFFECTX opcode to the unitrk stream. */
+void UniPTEffect(UBYTE eff, UBYTE dat)
+{
+#ifdef MIKMOD_DEBUG
+ if (eff>=0x10)
+ fprintf(stderr,"UniPTEffect called with incorrect eff value %d\n",eff);
+ else
+#endif
+ if((eff)||(dat)||(of.flags&UF_ARPMEM)) UniEffect(UNI_PTEFFECT0+eff,dat);
+}
+
+/* Appends UNI_VOLEFFECT + effect/dat to unistream. */
+void UniVolEffect(UWORD eff,UBYTE dat)
+{
+ if((eff)||(dat)) { /* don't write empty effect */
+ UniWriteByte(UNI_VOLEFFECTS);
+ UniWriteByte(eff);UniWriteByte(dat);
+ }
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ The Protracker Player Driver
+
+ The protracker driver supports all base Protracker 3.x commands and features.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+#include <stdarg.h>
+#ifdef SRANDOM_IN_MATH_H
+#include <math.h>
+#else
+#include <stdlib.h>
+#endif
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+extern long int random(void);
+#endif
+
+/* The currently playing module */
+MODULE *pf = NULL;
+
+#define NUMVOICES(mod) (md_sngchn < (mod)->numvoices ? md_sngchn : (mod)->numvoices)
+
+#define HIGH_OCTAVE 2 /* number of above-range octaves */
+
+static const UWORD oldperiods[OCTAVE*2]={
+ 0x6b00, 0x6800, 0x6500, 0x6220, 0x5f50, 0x5c80,
+ 0x5a00, 0x5740, 0x54d0, 0x5260, 0x5010, 0x4dc0,
+ 0x4b90, 0x4960, 0x4750, 0x4540, 0x4350, 0x4160,
+ 0x3f90, 0x3dc0, 0x3c10, 0x3a40, 0x38b0, 0x3700
+};
+
+static const UBYTE VibratoTable[32]={
+ 0, 24, 49, 74, 97,120,141,161,180,197,212,224,235,244,250,253,
+ 255,253,250,244,235,224,212,197,180,161,141,120, 97, 74, 49, 24
+};
+
+static const UBYTE avibtab[128]={
+ 0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23,
+ 24,25,27,28,30,31,32,34,35,36,38,39,40,41,42,44,
+ 45,46,47,48,49,50,51,52,53,54,54,55,56,57,57,58,
+ 59,59,60,60,61,61,62,62,62,63,63,63,63,63,63,63,
+ 64,63,63,63,63,63,63,63,62,62,62,61,61,60,60,59,
+ 59,58,57,57,56,55,54,54,53,52,51,50,49,48,47,46,
+ 45,44,42,41,40,39,38,36,35,34,32,31,30,28,27,25,
+ 24,23,21,20,18,17,15,14,12,10, 9, 7, 6, 4, 3, 1
+};
+
+/* Triton's linear periods to frequency translation table (for XM modules) */
+static const ULONG lintab[768]={
+ 535232,534749,534266,533784,533303,532822,532341,531861,
+ 531381,530902,530423,529944,529466,528988,528511,528034,
+ 527558,527082,526607,526131,525657,525183,524709,524236,
+ 523763,523290,522818,522346,521875,521404,520934,520464,
+ 519994,519525,519057,518588,518121,517653,517186,516720,
+ 516253,515788,515322,514858,514393,513929,513465,513002,
+ 512539,512077,511615,511154,510692,510232,509771,509312,
+ 508852,508393,507934,507476,507018,506561,506104,505647,
+ 505191,504735,504280,503825,503371,502917,502463,502010,
+ 501557,501104,500652,500201,499749,499298,498848,498398,
+ 497948,497499,497050,496602,496154,495706,495259,494812,
+ 494366,493920,493474,493029,492585,492140,491696,491253,
+ 490809,490367,489924,489482,489041,488600,488159,487718,
+ 487278,486839,486400,485961,485522,485084,484647,484210,
+ 483773,483336,482900,482465,482029,481595,481160,480726,
+ 480292,479859,479426,478994,478562,478130,477699,477268,
+ 476837,476407,475977,475548,475119,474690,474262,473834,
+ 473407,472979,472553,472126,471701,471275,470850,470425,
+ 470001,469577,469153,468730,468307,467884,467462,467041,
+ 466619,466198,465778,465358,464938,464518,464099,463681,
+ 463262,462844,462427,462010,461593,461177,460760,460345,
+ 459930,459515,459100,458686,458272,457859,457446,457033,
+ 456621,456209,455797,455386,454975,454565,454155,453745,
+ 453336,452927,452518,452110,451702,451294,450887,450481,
+ 450074,449668,449262,448857,448452,448048,447644,447240,
+ 446836,446433,446030,445628,445226,444824,444423,444022,
+ 443622,443221,442821,442422,442023,441624,441226,440828,
+ 440430,440033,439636,439239,438843,438447,438051,437656,
+ 437261,436867,436473,436079,435686,435293,434900,434508,
+ 434116,433724,433333,432942,432551,432161,431771,431382,
+ 430992,430604,430215,429827,429439,429052,428665,428278,
+ 427892,427506,427120,426735,426350,425965,425581,425197,
+ 424813,424430,424047,423665,423283,422901,422519,422138,
+ 421757,421377,420997,420617,420237,419858,419479,419101,
+ 418723,418345,417968,417591,417214,416838,416462,416086,
+ 415711,415336,414961,414586,414212,413839,413465,413092,
+ 412720,412347,411975,411604,411232,410862,410491,410121,
+ 409751,409381,409012,408643,408274,407906,407538,407170,
+ 406803,406436,406069,405703,405337,404971,404606,404241,
+ 403876,403512,403148,402784,402421,402058,401695,401333,
+ 400970,400609,400247,399886,399525,399165,398805,398445,
+ 398086,397727,397368,397009,396651,396293,395936,395579,
+ 395222,394865,394509,394153,393798,393442,393087,392733,
+ 392378,392024,391671,391317,390964,390612,390259,389907,
+ 389556,389204,388853,388502,388152,387802,387452,387102,
+ 386753,386404,386056,385707,385359,385012,384664,384317,
+ 383971,383624,383278,382932,382587,382242,381897,381552,
+ 381208,380864,380521,380177,379834,379492,379149,378807,
+ 378466,378124,377783,377442,377102,376762,376422,376082,
+ 375743,375404,375065,374727,374389,374051,373714,373377,
+ 373040,372703,372367,372031,371695,371360,371025,370690,
+ 370356,370022,369688,369355,369021,368688,368356,368023,
+ 367691,367360,367028,366697,366366,366036,365706,365376,
+ 365046,364717,364388,364059,363731,363403,363075,362747,
+ 362420,362093,361766,361440,361114,360788,360463,360137,
+ 359813,359488,359164,358840,358516,358193,357869,357547,
+ 357224,356902,356580,356258,355937,355616,355295,354974,
+ 354654,354334,354014,353695,353376,353057,352739,352420,
+ 352103,351785,351468,351150,350834,350517,350201,349885,
+ 349569,349254,348939,348624,348310,347995,347682,347368,
+ 347055,346741,346429,346116,345804,345492,345180,344869,
+ 344558,344247,343936,343626,343316,343006,342697,342388,
+ 342079,341770,341462,341154,340846,340539,340231,339924,
+ 339618,339311,339005,338700,338394,338089,337784,337479,
+ 337175,336870,336566,336263,335959,335656,335354,335051,
+ 334749,334447,334145,333844,333542,333242,332941,332641,
+ 332341,332041,331741,331442,331143,330844,330546,330247,
+ 329950,329652,329355,329057,328761,328464,328168,327872,
+ 327576,327280,326985,326690,326395,326101,325807,325513,
+ 325219,324926,324633,324340,324047,323755,323463,323171,
+ 322879,322588,322297,322006,321716,321426,321136,320846,
+ 320557,320267,319978,319690,319401,319113,318825,318538,
+ 318250,317963,317676,317390,317103,316817,316532,316246,
+ 315961,315676,315391,315106,314822,314538,314254,313971,
+ 313688,313405,313122,312839,312557,312275,311994,311712,
+ 311431,311150,310869,310589,310309,310029,309749,309470,
+ 309190,308911,308633,308354,308076,307798,307521,307243,
+ 306966,306689,306412,306136,305860,305584,305308,305033,
+ 304758,304483,304208,303934,303659,303385,303112,302838,
+ 302565,302292,302019,301747,301475,301203,300931,300660,
+ 300388,300117,299847,299576,299306,299036,298766,298497,
+ 298227,297958,297689,297421,297153,296884,296617,296349,
+ 296082,295815,295548,295281,295015,294749,294483,294217,
+ 293952,293686,293421,293157,292892,292628,292364,292100,
+ 291837,291574,291311,291048,290785,290523,290261,289999,
+ 289737,289476,289215,288954,288693,288433,288173,287913,
+ 287653,287393,287134,286875,286616,286358,286099,285841,
+ 285583,285326,285068,284811,284554,284298,284041,283785,
+ 283529,283273,283017,282762,282507,282252,281998,281743,
+ 281489,281235,280981,280728,280475,280222,279969,279716,
+ 279464,279212,278960,278708,278457,278206,277955,277704,
+ 277453,277203,276953,276703,276453,276204,275955,275706,
+ 275457,275209,274960,274712,274465,274217,273970,273722,
+ 273476,273229,272982,272736,272490,272244,271999,271753,
+ 271508,271263,271018,270774,270530,270286,270042,269798,
+ 269555,269312,269069,268826,268583,268341,268099,267857
+};
+
+#define LOGFAC 2*16
+static const UWORD logtab[104]={
+ LOGFAC*907,LOGFAC*900,LOGFAC*894,LOGFAC*887,
+ LOGFAC*881,LOGFAC*875,LOGFAC*868,LOGFAC*862,
+ LOGFAC*856,LOGFAC*850,LOGFAC*844,LOGFAC*838,
+ LOGFAC*832,LOGFAC*826,LOGFAC*820,LOGFAC*814,
+ LOGFAC*808,LOGFAC*802,LOGFAC*796,LOGFAC*791,
+ LOGFAC*785,LOGFAC*779,LOGFAC*774,LOGFAC*768,
+ LOGFAC*762,LOGFAC*757,LOGFAC*752,LOGFAC*746,
+ LOGFAC*741,LOGFAC*736,LOGFAC*730,LOGFAC*725,
+ LOGFAC*720,LOGFAC*715,LOGFAC*709,LOGFAC*704,
+ LOGFAC*699,LOGFAC*694,LOGFAC*689,LOGFAC*684,
+ LOGFAC*678,LOGFAC*675,LOGFAC*670,LOGFAC*665,
+ LOGFAC*660,LOGFAC*655,LOGFAC*651,LOGFAC*646,
+ LOGFAC*640,LOGFAC*636,LOGFAC*632,LOGFAC*628,
+ LOGFAC*623,LOGFAC*619,LOGFAC*614,LOGFAC*610,
+ LOGFAC*604,LOGFAC*601,LOGFAC*597,LOGFAC*592,
+ LOGFAC*588,LOGFAC*584,LOGFAC*580,LOGFAC*575,
+ LOGFAC*570,LOGFAC*567,LOGFAC*563,LOGFAC*559,
+ LOGFAC*555,LOGFAC*551,LOGFAC*547,LOGFAC*543,
+ LOGFAC*538,LOGFAC*535,LOGFAC*532,LOGFAC*528,
+ LOGFAC*524,LOGFAC*520,LOGFAC*516,LOGFAC*513,
+ LOGFAC*508,LOGFAC*505,LOGFAC*502,LOGFAC*498,
+ LOGFAC*494,LOGFAC*491,LOGFAC*487,LOGFAC*484,
+ LOGFAC*480,LOGFAC*477,LOGFAC*474,LOGFAC*470,
+ LOGFAC*467,LOGFAC*463,LOGFAC*460,LOGFAC*457,
+ LOGFAC*453,LOGFAC*450,LOGFAC*447,LOGFAC*443,
+ LOGFAC*440,LOGFAC*437,LOGFAC*434,LOGFAC*431
+};
+
+static const SBYTE PanbrelloTable[256]={
+ 0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 16, 17, 19, 20, 22, 23,
+ 24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44,
+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59,
+ 59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 64, 64, 64,
+ 64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 60, 60,
+ 59, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46,
+ 45, 44, 43, 42, 41, 39, 38, 37, 36, 34, 33, 32, 30, 29, 27, 26,
+ 24, 23, 22, 20, 19, 17, 16, 14, 12, 11, 9, 8, 6, 5, 3, 2,
+ 0,- 2,- 3,- 5,- 6,- 8,- 9,-11,-12,-14,-16,-17,-19,-20,-22,-23,
+ -24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,-43,-44,
+ -45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,-56,-57,-58,-59,
+ -59,-60,-60,-61,-61,-62,-62,-62,-63,-63,-63,-64,-64,-64,-64,-64,
+ -64,-64,-64,-64,-64,-64,-63,-63,-63,-62,-62,-62,-61,-61,-60,-60,
+ -59,-59,-58,-57,-56,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46,
+ -45,-44,-43,-42,-41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26,
+ -24,-23,-22,-20,-19,-17,-16,-14,-12,-11,- 9,- 8,- 6,- 5,- 3,- 2
+};
+
+/* returns a random value between 0 and ceil-1, ceil must be a power of two */
+static int getrandom(int ceilval)
+{
+#if defined(HAVE_SRANDOM) && !defined(_MIKMOD_AMIGA)
+ return random()&(ceilval-1);
+#else
+ return (rand()*ceilval)/(RAND_MAX+1.0);
+#endif
+}
+
+/* New Note Action Scoring System :
+ --------------------------------
+ 1) total-volume (fadevol, chanvol, volume) is the main scorer.
+ 2) a looping sample is a bonus x2
+ 3) a foreground channel is a bonus x4
+ 4) an active envelope with keyoff is a handicap -x2
+*/
+static int MP_FindEmptyChannel(MODULE *mod)
+{
+ MP_VOICE *a;
+ ULONG t,k,tvol,pp;
+
+ for (t=0;t<NUMVOICES(mod);t++)
+ if (((mod->voice[t].main.kick==KICK_ABSENT)||
+ (mod->voice[t].main.kick==KICK_ENV))&&
+ Voice_Stopped_internal(t))
+ return t;
+
+ tvol=0xffffffUL;t=-1;a=mod->voice;
+ for (k=0;k<NUMVOICES(mod);k++,a++) {
+ /* allow us to take over a nonexisting sample */
+ if (!a->main.s)
+ return k;
+
+ if ((a->main.kick==KICK_ABSENT)||(a->main.kick==KICK_ENV)) {
+ pp=a->totalvol<<((a->main.s->flags&SF_LOOP)?1:0);
+ if ((a->master)&&(a==a->master->slave))
+ pp<<=2;
+
+ if (pp<tvol) {
+ tvol=pp;
+ t=k;
+ }
+ }
+ }
+
+ if (tvol>8000*7) return -1;
+ return t;
+}
+
+static SWORD Interpolate(SWORD p,SWORD p1,SWORD p2,SWORD v1,SWORD v2)
+{
+ if ((p1==p2)||(p==p1)) return v1;
+ return v1+((SLONG)((p-p1)*(v2-v1))/(p2-p1));
+}
+
+UWORD getlinearperiod(UWORD note,ULONG fine)
+{
+ UWORD t;
+
+ t=((20L+2*HIGH_OCTAVE)*OCTAVE+2-note)*32L-(fine>>1);
+ return t;
+}
+
+static UWORD getlogperiod(UWORD note,ULONG fine)
+{
+ UWORD n,o;
+ UWORD p1,p2;
+ ULONG i;
+
+ n=note%(2*OCTAVE);
+ o=note/(2*OCTAVE);
+ i=(n<<2)+(fine>>4); /* n*8 + fine/16 */
+
+ p1=logtab[i];
+ p2=logtab[i+1];
+
+ return (Interpolate(fine>>4,0,15,p1,p2)>>o);
+}
+
+static UWORD getoldperiod(UWORD note,ULONG speed)
+{
+ UWORD n,o;
+
+ /* This happens sometimes on badly converted AMF, and old MOD */
+ if (!speed) {
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr,"\rmplayer: getoldperiod() called with note=%d, speed=0 !\n",note);
+#endif
+ return 4242; /* <- prevent divide overflow.. (42 hehe) */
+ }
+
+ n=note%(2*OCTAVE);
+ o=note/(2*OCTAVE);
+ return ((8363L*(ULONG)oldperiods[n])>>o)/speed;
+}
+
+static UWORD GetPeriod(UWORD flags, UWORD note, ULONG speed)
+{
+ if (flags & UF_XMPERIODS) {
+ if (flags & UF_LINEAR)
+ return getlinearperiod(note, speed);
+ else
+ return getlogperiod(note, speed);
+ } else
+ return getoldperiod(note, speed);
+}
+
+static SWORD InterpolateEnv(SWORD p,ENVPT *a,ENVPT *b)
+{
+ return (Interpolate(p,a->pos,b->pos,a->val,b->val));
+}
+
+static SWORD DoPan(SWORD envpan,SWORD pan)
+{
+ int newpan;
+
+ newpan=pan+(((envpan-PAN_CENTER)*(128-abs(pan-PAN_CENTER)))/128);
+
+ return (newpan<PAN_LEFT)?PAN_LEFT:(newpan>PAN_RIGHT?PAN_RIGHT:newpan);
+}
+
+static SWORD StartEnvelope(ENVPR *t,UBYTE flg,UBYTE pts,UBYTE susbeg,UBYTE susend,UBYTE beg,UBYTE end,ENVPT *p,UBYTE keyoff)
+{
+ t->flg=flg;
+ t->pts=pts;
+ t->susbeg=susbeg;
+ t->susend=susend;
+ t->beg=beg;
+ t->end=end;
+ t->env=p;
+ t->p=0;
+ t->a=0;
+ t->b=((t->flg&EF_SUSTAIN)&&(!(keyoff&KEY_OFF)))?0:1;
+
+ /* Imago Orpheus sometimes stores an extra initial point in the envelope */
+ if ((t->pts>=2)&&(t->env[0].pos==t->env[1].pos)) {
+ t->a++;
+ t->b++;
+ }
+
+ /* Fit in the envelope, still */
+ if (t->a >= t->pts)
+ t->a = t->pts - 1;
+ if (t->b >= t->pts)
+ t->b = t->pts-1;
+
+ return t->env[t->a].val;
+}
+
+/* This procedure processes all envelope types, include volume, pitch, and
+ panning. Envelopes are defined by a set of points, each with a magnitude
+ [relating either to volume, panning position, or pitch modifier] and a tick
+ position.
+
+ Envelopes work in the following manner:
+
+ (a) Each tick the envelope is moved a point further in its progression. For
+ an accurate progression, magnitudes between two envelope points are
+ interpolated.
+
+ (b) When progression reaches a defined point on the envelope, values are
+ shifted to interpolate between this point and the next, and checks for
+ loops or envelope end are done.
+
+ Misc:
+ Sustain loops are loops that are only active as long as the keyoff flag is
+ clear. When a volume envelope terminates, so does the current fadeout.
+*/
+static SWORD ProcessEnvelope(MP_VOICE *aout, ENVPR *t, SWORD v)
+{
+ if (t->flg & EF_ON) {
+ UBYTE a, b; /* actual points in the envelope */
+ UWORD p; /* the 'tick counter' - real point being played */
+
+ a = t->a;
+ b = t->b;
+ p = t->p;
+
+ /*
+ * Sustain loop on one point (XM type).
+ * Not processed if KEYOFF.
+ * Don't move and don't interpolate when the point is reached
+ */
+ if ((t->flg & EF_SUSTAIN) && t->susbeg == t->susend &&
+ (!(aout->main.keyoff & KEY_OFF) && p == t->env[t->susbeg].pos)) {
+ v = t->env[t->susbeg].val;
+ } else {
+ /*
+ * All following situations will require interpolation between
+ * two envelope points.
+ */
+
+ /*
+ * Sustain loop between two points (IT type).
+ * Not processed if KEYOFF.
+ */
+ /* if we were on a loop point, loop now */
+ if ((t->flg & EF_SUSTAIN) && !(aout->main.keyoff & KEY_OFF) &&
+ a >= t->susend) {
+ a = t->susbeg;
+ b = (t->susbeg==t->susend)?a:a+1;
+ p = t->env[a].pos;
+ v = t->env[a].val;
+ } else
+ /*
+ * Regular loop.
+ * Be sure to correctly handle single point loops.
+ */
+ if ((t->flg & EF_LOOP) && a >= t->end) {
+ a = t->beg;
+ b = t->beg == t->end ? a : a + 1;
+ p = t->env[a].pos;
+ v = t->env[a].val;
+ } else
+ /*
+ * Non looping situations.
+ */
+ if (a != b)
+ v = InterpolateEnv(p, &t->env[a], &t->env[b]);
+ else
+ v = t->env[a].val;
+
+ /*
+ * Start to fade if the volume envelope is finished.
+ */
+ if (p >= t->env[t->pts - 1].pos) {
+ if (t->flg & EF_VOLENV) {
+ aout->main.keyoff |= KEY_FADE;
+ if (!v)
+ aout->main.fadevol = 0;
+ }
+ } else {
+ p++;
+ /* did pointer reach point b? */
+ if (p >= t->env[b].pos)
+ a = b++; /* shift points a and b */
+ }
+ t->a = a;
+ t->b = b;
+ t->p = p;
+ }
+ }
+ return v;
+}
+
+/* XM linear period to frequency conversion */
+ULONG getfrequency(UWORD flags,ULONG period)
+{
+ if (flags & UF_LINEAR) {
+ SLONG shift = ((SLONG)period / 768) - HIGH_OCTAVE;
+
+ if (shift >= 0)
+ return lintab[period % 768] >> shift;
+ else
+ return lintab[period % 768] << (-shift);
+ } else
+ return (8363L*1712L)/(period?period:1);
+}
+
+/*========== Protracker effects */
+
+static void DoArpeggio(UWORD tick, UWORD flags, MP_CONTROL *a, UBYTE style)
+{
+ UBYTE note=a->main.note;
+
+ if (a->arpmem) {
+ switch (style) {
+ case 0: /* mod style: N, N+x, N+y */
+ switch (tick % 3) {
+ /* case 0: unchanged */
+ case 1:
+ note += (a->arpmem >> 4);
+ break;
+ case 2:
+ note += (a->arpmem & 0xf);
+ break;
+ }
+ break;
+ case 3: /* okt arpeggio 3: N-x, N, N+y */
+ switch (tick % 3) {
+ case 0:
+ note -= (a->arpmem >> 4);
+ break;
+ /* case 1: unchanged */
+ case 2:
+ note += (a->arpmem & 0xf);
+ break;
+ }
+ break;
+ case 4: /* okt arpeggio 4: N, N+y, N, N-x */
+ switch (tick % 4) {
+ /* case 0, case 2: unchanged */
+ case 1:
+ note += (a->arpmem & 0xf);
+ break;
+ case 3:
+ note -= (a->arpmem >> 4);
+ break;
+ }
+ break;
+ case 5: /* okt arpeggio 5: N-x, N+y, N, and nothing at tick 0 */
+ if (!tick)
+ break;
+ switch (tick % 3) {
+ /* case 0: unchanged */
+ case 1:
+ note -= (a->arpmem >> 4);
+ break;
+ case 2:
+ note += (a->arpmem & 0xf);
+ break;
+ }
+ break;
+ }
+ a->main.period = GetPeriod(flags, (UWORD)note << 1, a->speed);
+ a->ownper = 1;
+ }
+}
+
+static int DoPTEffect0(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (!tick) {
+ if (!dat && (flags & UF_ARPMEM))
+ dat=a->arpmem;
+ else
+ a->arpmem=dat;
+ }
+ if (a->main.period)
+ DoArpeggio(tick, flags, a, 0);
+
+ return 0;
+}
+
+static int DoPTEffect1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (!tick && dat)
+ a->slidespeed = (UWORD)dat << 2;
+ if (a->main.period)
+ if (tick)
+ a->tmpperiod -= a->slidespeed;
+
+ return 0;
+}
+
+static int DoPTEffect2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (!tick && dat)
+ a->slidespeed = (UWORD)dat << 2;
+ if (a->main.period)
+ if (tick)
+ a->tmpperiod += a->slidespeed;
+
+ return 0;
+}
+
+static void DoToneSlide(UWORD tick, MP_CONTROL *a)
+{
+ if (!a->main.fadevol)
+ a->main.kick = (a->main.kick == KICK_NOTE)? KICK_NOTE : KICK_KEYOFF;
+ else
+ a->main.kick = (a->main.kick == KICK_NOTE)? KICK_ENV : KICK_ABSENT;
+
+ if (tick != 0) {
+ int dist;
+
+ /* We have to slide a->main.period towards a->wantedperiod, so compute
+ the difference between those two values */
+ dist=a->main.period-a->wantedperiod;
+
+ /* if they are equal or if portamentospeed is too big ...*/
+ if (dist == 0 || a->portspeed > abs(dist))
+ /* ...make tmpperiod equal tperiod */
+ a->tmpperiod=a->main.period=a->wantedperiod;
+ else if (dist>0) {
+ a->tmpperiod-=a->portspeed;
+ a->main.period-=a->portspeed; /* dist>0, slide up */
+ } else {
+ a->tmpperiod+=a->portspeed;
+ a->main.period+=a->portspeed; /* dist<0, slide down */
+ }
+ } else
+ a->tmpperiod=a->main.period;
+ a->ownper = 1;
+}
+
+static int DoPTEffect3(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if ((!tick)&&(dat)) a->portspeed=(UWORD)dat<<2;
+ if (a->main.period)
+ DoToneSlide(tick, a);
+
+ return 0;
+}
+
+static void DoVibrato(UWORD tick, MP_CONTROL *a)
+{
+ UBYTE q;
+ UWORD temp = 0; /* silence warning */
+
+ if (!tick)
+ return;
+
+ q=(a->vibpos>>2)&0x1f;
+
+ switch (a->wavecontrol&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* ramp down */
+ q<<=3;
+ if (a->vibpos<0) q=255-q;
+ temp=q;
+ break;
+ case 2: /* square wave */
+ temp=255;
+ break;
+ case 3: /* random wave */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->vibdepth;
+ temp>>=7;temp<<=2;
+
+ if (a->vibpos>=0)
+ a->main.period=a->tmpperiod+temp;
+ else
+ a->main.period=a->tmpperiod-temp;
+ a->ownper = 1;
+
+ if (tick != 0)
+ a->vibpos+=a->vibspd;
+}
+
+static int DoPTEffect4(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->vibdepth=dat&0xf;
+ if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
+ }
+ if (a->main.period)
+ DoVibrato(tick, a);
+
+ return 0;
+}
+
+static void DoVolSlide(MP_CONTROL *a, UBYTE dat)
+{
+ if (dat&0xf) {
+ a->tmpvolume-=(dat&0x0f);
+ if (a->tmpvolume<0)
+ a->tmpvolume=0;
+ } else {
+ a->tmpvolume+=(dat>>4);
+ if (a->tmpvolume>64)
+ a->tmpvolume=64;
+ }
+}
+
+static int DoPTEffect5(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (a->main.period)
+ DoToneSlide(tick, a);
+
+ if (tick)
+ DoVolSlide(a, dat);
+
+ return 0;
+}
+
+/* DoPTEffect6 after DoPTEffectA */
+
+static int DoPTEffect7(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+ UBYTE q;
+ UWORD temp = 0; /* silence warning */
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->trmdepth=dat&0xf;
+ if (dat&0xf0) a->trmspd=(dat&0xf0)>>2;
+ }
+ if (a->main.period) {
+ q=(a->trmpos>>2)&0x1f;
+
+ switch ((a->wavecontrol>>4)&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* ramp down */
+ q<<=3;
+ if (a->trmpos<0) q=255-q;
+ temp=q;
+ break;
+ case 2: /* square wave */
+ temp=255;
+ break;
+ case 3: /* random wave */
+ temp=getrandom(256);
+ break;
+ }
+ temp*=a->trmdepth;
+ temp>>=6;
+
+ if (a->trmpos>=0) {
+ a->volume=a->tmpvolume+temp;
+ if (a->volume>64) a->volume=64;
+ } else {
+ a->volume=a->tmpvolume-temp;
+ if (a->volume<0) a->volume=0;
+ }
+ a->ownvol = 1;
+
+ if (tick)
+ a->trmpos+=a->trmspd;
+ }
+
+ return 0;
+}
+
+static int DoPTEffect8(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (mod->panflag)
+ a->main.panning = mod->panning[channel] = dat;
+
+ return 0;
+}
+
+static int DoPTEffect9(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat) a->soffset=(UWORD)dat<<8;
+ a->main.start=a->hioffset|a->soffset;
+
+ if ((a->main.s)&&(a->main.start>a->main.s->length))
+ a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
+ a->main.s->loopstart:a->main.s->length;
+ }
+
+ return 0;
+}
+
+static int DoPTEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (tick)
+ DoVolSlide(a, dat);
+
+ return 0;
+}
+
+static int DoPTEffect6(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ if (a->main.period)
+ DoVibrato(tick, a);
+ DoPTEffectA(tick, flags, a, mod, channel);
+
+ return 0;
+}
+
+static int DoPTEffectB(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+
+ if (tick || mod->patdly2)
+ return 0;
+
+ /* Vincent Voois uses a nasty trick in "Universal Bolero" */
+ if (dat == mod->sngpos && mod->patbrk == mod->patpos)
+ return 0;
+
+ if (!mod->loop && !mod->patbrk &&
+ (dat < mod->sngpos ||
+ (mod->sngpos == (mod->numpos - 1) && !mod->patbrk) ||
+ (dat == mod->sngpos && (flags & UF_NOWRAP)) ) )
+ {
+ /* if we don't loop, better not to skip the end of the
+ pattern, after all... so:
+ mod->patbrk=0; */
+ mod->posjmp=3;
+ } else {
+ /* if we were fading, adjust... */
+ if (mod->sngpos == (mod->numpos-1))
+ mod->volume=mod->initvolume>128?128:mod->initvolume;
+ mod->sngpos=dat;
+ mod->posjmp=2;
+ mod->patpos=0;
+ /* cancel the FT2 pattern loop (E60) bug.
+ * also see DoEEffects() below for it. */
+ if (flags & UF_FT2QUIRKS) mod->patbrk=0;
+ }
+
+ return 0;
+}
+
+static int DoPTEffectC(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (tick) return 0;
+ if (dat==(UBYTE)-1) a->anote=dat=0; /* note cut */
+ else if (dat>64) dat=64;
+ a->tmpvolume=dat;
+
+ return 0;
+}
+
+static int DoPTEffectD(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if ((tick)||(mod->patdly2)) return 0;
+ if ((mod->positions[mod->sngpos]!=LAST_PATTERN)&&
+ (dat>mod->pattrows[mod->positions[mod->sngpos]])) {
+ dat=mod->pattrows[mod->positions[mod->sngpos]];
+ }
+ mod->patbrk=dat;
+ if (!mod->posjmp) {
+ /* don't ask me to explain this code - it makes
+ backwards.s3m and children.xm (heretic's version) play
+ correctly, among others. Take that for granted, or write
+ the page of comments yourself... you might need some
+ aspirin - Miod */
+ if ((mod->sngpos==mod->numpos-1)&&(dat)&&
+ ((mod->loop) || (mod->positions[mod->sngpos]==(mod->numpat-1) && !(flags&UF_NOWRAP)))) {
+ mod->sngpos=0;
+ mod->posjmp=2;
+ } else
+ mod->posjmp=3;
+ }
+
+ return 0;
+}
+
+static void DoEEffects(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod,
+ SWORD channel, UBYTE dat)
+{
+ UBYTE nib = dat & 0xf;
+
+ switch (dat>>4) {
+ case 0x0: /* hardware filter toggle, not supported */
+ break;
+ case 0x1: /* fineslide up */
+ if (a->main.period)
+ if (!tick)
+ a->tmpperiod-=(nib<<2);
+ break;
+ case 0x2: /* fineslide dn */
+ if (a->main.period)
+ if (!tick)
+ a->tmpperiod+=(nib<<2);
+ break;
+ case 0x3: /* glissando ctrl */
+ a->glissando=nib;
+ break;
+ case 0x4: /* set vibrato waveform */
+ a->wavecontrol&=0xf0;
+ a->wavecontrol|=nib;
+ break;
+ case 0x5: /* set finetune */
+ if (a->main.period) {
+ if (flags&UF_XMPERIODS)
+ a->speed=nib+128;
+ else
+ a->speed=finetune[nib];
+ a->tmpperiod=GetPeriod(flags, (UWORD)a->main.note<<1,a->speed);
+ }
+ break;
+ case 0x6: /* set patternloop */
+ if (tick)
+ break;
+ if (nib) { /* set reppos or repcnt ? */
+ /* set repcnt, so check if repcnt already is set, which means we
+ are already looping */
+ if (a->pat_repcnt)
+ a->pat_repcnt--; /* already looping, decrease counter */
+ else {
+#if 0
+ /* this would make walker.xm, shipped with Xsoundtracker,
+ play correctly, but it's better to remain compatible
+ with FT2 */
+ if ((!(flags&UF_NOWRAP))||(a->pat_reppos!=POS_NONE))
+#endif
+ a->pat_repcnt=nib; /* not yet looping, so set repcnt */
+ }
+
+ if (a->pat_repcnt) { /* jump to reppos if repcnt>0 */
+ if (a->pat_reppos==POS_NONE)
+ a->pat_reppos=mod->patpos-1;
+ if (a->pat_reppos==-1) {
+ mod->pat_repcrazy=1;
+ mod->patpos=0;
+ } else
+ mod->patpos=a->pat_reppos;
+ } else a->pat_reppos=POS_NONE;
+ } else {
+ a->pat_reppos=mod->patpos-1; /* set reppos - can be (-1) */
+ /* emulate the FT2 pattern loop (E60) bug:
+ * http://milkytracker.org/docs/MilkyTracker.html#fxE6x
+ * roadblas.xm plays correctly with this. */
+ if (flags & UF_FT2QUIRKS) mod->patbrk=mod->patpos;
+ }
+ break;
+ case 0x7: /* set tremolo waveform */
+ a->wavecontrol&=0x0f;
+ a->wavecontrol|=nib<<4;
+ break;
+ case 0x8: /* set panning */
+ if (mod->panflag) {
+ if (nib<=8) nib<<=4;
+ else nib*=17;
+ a->main.panning=mod->panning[channel]=nib;
+ }
+ break;
+ case 0x9: /* retrig note */
+ /* do not retrigger on tick 0, until we are emulating FT2 and effect
+ data is zero */
+ if (!tick && !((flags & UF_FT2QUIRKS) && (!nib)))
+ break;
+ /* only retrigger if data nibble > 0, or if tick 0 (FT2 compat) */
+ if (nib || !tick) {
+ if (!a->retrig) {
+ /* when retrig counter reaches 0, reset counter and restart
+ the sample */
+ if (a->main.period) a->main.kick=KICK_NOTE;
+ a->retrig=nib;
+ }
+ a->retrig--; /* countdown */
+ }
+ break;
+ case 0xa: /* fine volume slide up */
+ if (tick)
+ break;
+ a->tmpvolume+=nib;
+ if (a->tmpvolume>64) a->tmpvolume=64;
+ break;
+ case 0xb: /* fine volume slide dn */
+ if (tick)
+ break;
+ a->tmpvolume-=nib;
+ if (a->tmpvolume<0)a->tmpvolume=0;
+ break;
+ case 0xc: /* cut note */
+ /* When tick reaches the cut-note value, turn the volume to
+ zero (just like on the amiga) */
+ if (tick>=nib)
+ a->tmpvolume=0; /* just turn the volume down */
+ break;
+ case 0xd: /* note delay */
+ /* delay the start of the sample until tick==nib */
+ if (!tick)
+ a->main.notedelay=nib;
+ else if (a->main.notedelay)
+ a->main.notedelay--;
+ break;
+ case 0xe: /* pattern delay */
+ if (!tick)
+ if (!mod->patdly2)
+ mod->patdly=nib+1; /* only once, when tick=0 */
+ break;
+ case 0xf: /* invert loop, not supported */
+ break;
+ }
+}
+
+static int DoPTEffectE(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoEEffects(tick, flags, a, mod, channel, UniGetByte());
+
+ return 0;
+}
+
+static int DoPTEffectF(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (tick||mod->patdly2) return 0;
+ if (mod->extspd&&(dat>=mod->bpmlimit))
+ mod->bpm=dat;
+ else
+ if (dat) {
+ mod->sngspd=(dat>=mod->bpmlimit)?mod->bpmlimit-1:dat;
+ mod->vbtick=0;
+ }
+
+ return 0;
+}
+
+/*========== Scream Tracker effects */
+
+static int DoS3MEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE speed;
+
+ speed = UniGetByte();
+
+ if (tick || mod->patdly2)
+ return 0;
+
+ if (speed > 128)
+ speed -= 128;
+ if (speed) {
+ mod->sngspd = speed;
+ mod->vbtick = 0;
+ }
+
+ return 0;
+}
+
+static void DoS3MVolSlide(UWORD tick, UWORD flags, MP_CONTROL *a, UBYTE inf)
+{
+ UBYTE lo, hi;
+
+ if (inf)
+ a->s3mvolslide=inf;
+ else
+ inf=a->s3mvolslide;
+
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ if (!lo) {
+ if ((tick)||(flags&UF_S3MSLIDES)) a->tmpvolume+=hi;
+ } else
+ if (!hi) {
+ if ((tick)||(flags&UF_S3MSLIDES)) a->tmpvolume-=lo;
+ } else
+ if (lo==0xf) {
+ if (!tick) a->tmpvolume+=(hi?hi:0xf);
+ } else
+ if (hi==0xf) {
+ if (!tick) a->tmpvolume-=(lo?lo:0xf);
+ } else
+ return;
+
+ if (a->tmpvolume<0)
+ a->tmpvolume=0;
+ else if (a->tmpvolume>64)
+ a->tmpvolume=64;
+}
+
+static int DoS3MEffectD(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoS3MVolSlide(tick, flags, a, UniGetByte());
+
+ return 1;
+}
+
+static void DoS3MSlideDn(UWORD tick, MP_CONTROL *a, UBYTE inf)
+{
+ UBYTE hi,lo;
+
+ if (inf)
+ a->slidespeed=inf;
+ else
+ inf=a->slidespeed;
+
+ hi=inf>>4;
+ lo=inf&0xf;
+
+ if (hi==0xf) {
+ if (!tick) a->tmpperiod+=(UWORD)lo<<2;
+ } else
+ if (hi==0xe) {
+ if (!tick) a->tmpperiod+=lo;
+ } else {
+ if (tick) a->tmpperiod+=(UWORD)inf<<2;
+ }
+}
+
+static int DoS3MEffectE(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (a->main.period)
+ DoS3MSlideDn(tick, a,dat);
+
+ return 0;
+}
+
+static void DoS3MSlideUp(UWORD tick, MP_CONTROL *a, UBYTE inf)
+{
+ UBYTE hi,lo;
+
+ if (inf) a->slidespeed=inf;
+ else inf=a->slidespeed;
+
+ hi=inf>>4;
+ lo=inf&0xf;
+
+ if (hi==0xf) {
+ if (!tick) a->tmpperiod-=(UWORD)lo<<2;
+ } else
+ if (hi==0xe) {
+ if (!tick) a->tmpperiod-=lo;
+ } else {
+ if (tick) a->tmpperiod-=(UWORD)inf<<2;
+ }
+}
+
+static int DoS3MEffectF(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (a->main.period)
+ DoS3MSlideUp(tick, a,dat);
+
+ return 0;
+}
+
+static int DoS3MEffectI(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, on, off;
+
+ inf = UniGetByte();
+ if (inf)
+ a->s3mtronof = inf;
+ else {
+ inf = a->s3mtronof;
+ if (!inf)
+ return 0;
+ }
+
+ if (!tick)
+ return 0;
+
+ on=(inf>>4)+1;
+ off=(inf&0xf)+1;
+ a->s3mtremor%=(on+off);
+ a->volume=(a->s3mtremor<on)?a->tmpvolume:0;
+ a->ownvol=1;
+ a->s3mtremor++;
+
+ return 0;
+}
+
+static int DoS3MEffectQ(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf;
+
+ inf = UniGetByte();
+ if (a->main.period) {
+ if (inf) {
+ a->s3mrtgslide=inf>>4;
+ a->s3mrtgspeed=inf&0xf;
+ }
+
+ /* only retrigger if low nibble > 0 */
+ if (a->s3mrtgspeed>0) {
+ if (!a->retrig) {
+ /* when retrig counter reaches 0, reset counter and restart the
+ sample */
+ if (a->main.kick!=KICK_NOTE) a->main.kick=KICK_KEYOFF;
+ a->retrig=a->s3mrtgspeed;
+
+ if ((tick)||(flags&UF_S3MSLIDES)) {
+ switch (a->s3mrtgslide) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ a->tmpvolume-=(1<<(a->s3mrtgslide-1));
+ break;
+ case 6:
+ a->tmpvolume=(2*a->tmpvolume)/3;
+ break;
+ case 7:
+ a->tmpvolume>>=1;
+ break;
+ case 9:
+ case 0xa:
+ case 0xb:
+ case 0xc:
+ case 0xd:
+ a->tmpvolume+=(1<<(a->s3mrtgslide-9));
+ break;
+ case 0xe:
+ a->tmpvolume=(3*a->tmpvolume)>>1;
+ break;
+ case 0xf:
+ a->tmpvolume=a->tmpvolume<<1;
+ break;
+ }
+ if (a->tmpvolume<0)
+ a->tmpvolume=0;
+ else if (a->tmpvolume>64)
+ a->tmpvolume=64;
+ }
+ }
+ a->retrig--; /* countdown */
+ }
+ }
+
+ return 0;
+}
+
+static int DoS3MEffectR(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, q;
+ UWORD temp=0; /* silence warning */
+
+ dat = UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->trmdepth=dat&0xf;
+ if (dat&0xf0) a->trmspd=(dat&0xf0)>>2;
+ }
+
+ q=(a->trmpos>>2)&0x1f;
+
+ switch ((a->wavecontrol>>4)&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* ramp down */
+ q<<=3;
+ if (a->trmpos<0) q=255-q;
+ temp=q;
+ break;
+ case 2: /* square wave */
+ temp=255;
+ break;
+ case 3: /* random */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->trmdepth;
+ temp>>=7;
+
+ if (a->trmpos>=0) {
+ a->volume=a->tmpvolume+temp;
+ if (a->volume>64) a->volume=64;
+ } else {
+ a->volume=a->tmpvolume-temp;
+ if (a->volume<0) a->volume=0;
+ }
+ a->ownvol = 1;
+
+ if (tick)
+ a->trmpos+=a->trmspd;
+
+ return 0;
+}
+
+static int DoS3MEffectT(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE tempo;
+
+ tempo = UniGetByte();
+
+ if (tick || mod->patdly2)
+ return 0;
+
+ mod->bpm = (tempo < 32) ? 32 : tempo;
+
+ return 0;
+}
+
+static int DoS3MEffectU(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, q;
+ UWORD temp = 0; /* silence warning */
+
+ dat = UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->vibdepth=dat&0xf;
+ if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
+ } else
+ if (a->main.period) {
+ q=(a->vibpos>>2)&0x1f;
+
+ switch (a->wavecontrol&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* ramp down */
+ q<<=3;
+ if (a->vibpos<0) q=255-q;
+ temp=q;
+ break;
+ case 2: /* square wave */
+ temp=255;
+ break;
+ case 3: /* random */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->vibdepth;
+ temp>>=8;
+
+ if (a->vibpos>=0)
+ a->main.period=a->tmpperiod+temp;
+ else
+ a->main.period=a->tmpperiod-temp;
+ a->ownper = 1;
+
+ a->vibpos+=a->vibspd;
+ }
+
+ return 0;
+}
+
+/*========== Envelope helpers */
+
+static int DoKeyOff(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ a->main.keyoff|=KEY_OFF;
+ if ((!(a->main.volflg&EF_ON))||(a->main.volflg&EF_LOOP))
+ a->main.keyoff=KEY_KILL;
+
+ return 0;
+}
+
+static int DoKeyFade(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if ((tick>=dat)||(tick==mod->sngspd-1)) {
+ a->main.keyoff=KEY_KILL;
+ if (!(a->main.volflg&EF_ON))
+ a->main.fadevol=0;
+ }
+
+ return 0;
+}
+
+/*========== Fast Tracker effects */
+
+/* DoXMEffect6 after DoXMEffectA */
+
+static int DoXMEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, lo, hi;
+
+ inf = UniGetByte();
+ if (inf)
+ a->s3mvolslide = inf;
+ else
+ inf = a->s3mvolslide;
+
+ if (tick) {
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ if (!hi) {
+ a->tmpvolume-=lo;
+ if (a->tmpvolume<0) a->tmpvolume=0;
+ } else {
+ a->tmpvolume+=hi;
+ if (a->tmpvolume>64) a->tmpvolume=64;
+ }
+ }
+
+ return 0;
+}
+
+static int DoXMEffect6(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ if (a->main.period)
+ DoVibrato(tick, a);
+
+ return DoXMEffectA(tick, flags, a, mod, channel);
+}
+
+static int DoXMEffectE1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat) a->fportupspd=dat;
+ if (a->main.period)
+ a->tmpperiod-=(a->fportupspd<<2);
+ }
+
+ return 0;
+}
+
+static int DoXMEffectE2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat) a->fportdnspd=dat;
+ if (a->main.period)
+ a->tmpperiod+=(a->fportdnspd<<2);
+ }
+
+ return 0;
+}
+
+static int DoXMEffectEA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick)
+ if (dat) a->fslideupspd=dat;
+ a->tmpvolume+=a->fslideupspd;
+ if (a->tmpvolume>64) a->tmpvolume=64;
+
+ return 0;
+}
+
+static int DoXMEffectEB(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if (!tick)
+ if (dat) a->fslidednspd=dat;
+ a->tmpvolume-=a->fslidednspd;
+ if (a->tmpvolume<0) a->tmpvolume=0;
+
+ return 0;
+}
+
+static int DoXMEffectG(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ mod->volume=UniGetByte()<<1;
+ if (mod->volume>128) mod->volume=128;
+
+ return 0;
+}
+
+static int DoXMEffectH(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf;
+
+ inf = UniGetByte();
+
+ if (tick) {
+ if (inf) mod->globalslide=inf;
+ else inf=mod->globalslide;
+ if (inf & 0xf0) inf&=0xf0;
+ mod->volume=mod->volume+((inf>>4)-(inf&0xf))*2;
+
+ if (mod->volume<0)
+ mod->volume=0;
+ else if (mod->volume>128)
+ mod->volume=128;
+ }
+
+ return 0;
+}
+
+static int DoXMEffectL(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat=UniGetByte();
+ if ((!tick)&&(a->main.i)) {
+ UWORD points;
+ INSTRUMENT *i=a->main.i;
+ MP_VOICE *aout;
+
+ if ((aout=a->slave) != NULL) {
+ if (aout->venv.env) {
+ points=i->volenv[i->volpts-1].pos;
+ aout->venv.p=aout->venv.env[(dat>points)?points:dat].pos;
+ }
+ if (aout->penv.env) {
+ points=i->panenv[i->panpts-1].pos;
+ aout->penv.p=aout->penv.env[(dat>points)?points:dat].pos;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int DoXMEffectP(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, lo, hi;
+ SWORD pan;
+
+ inf = UniGetByte();
+ if (!mod->panflag)
+ return 0;
+
+ if (inf)
+ a->pansspd = inf;
+ else
+ inf =a->pansspd;
+
+ if (tick) {
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ /* slide right has absolute priority */
+ if (hi)
+ lo = 0;
+
+ pan=((a->main.panning==PAN_SURROUND)?PAN_CENTER:a->main.panning)+hi-lo;
+ a->main.panning=(pan<PAN_LEFT)?PAN_LEFT:(pan>PAN_RIGHT?PAN_RIGHT:pan);
+ }
+
+ return 0;
+}
+
+static int DoXMEffectX1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (dat)
+ a->ffportupspd = dat;
+ else
+ dat = a->ffportupspd;
+
+ if (a->main.period)
+ if (!tick) {
+ a->main.period-=dat;
+ a->tmpperiod-=dat;
+ a->ownper = 1;
+ }
+
+ return 0;
+}
+
+static int DoXMEffectX2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat;
+
+ dat = UniGetByte();
+ if (dat)
+ a->ffportdnspd=dat;
+ else
+ dat = a->ffportdnspd;
+
+ if (a->main.period)
+ if (!tick) {
+ a->main.period+=dat;
+ a->tmpperiod+=dat;
+ a->ownper = 1;
+ }
+
+ return 0;
+}
+
+/*========== Impulse Tracker effects */
+
+static void DoITToneSlide(UWORD tick, MP_CONTROL *a, UBYTE dat)
+{
+ if (dat)
+ a->portspeed = dat;
+
+ /* if we don't come from another note, ignore the slide and play the note
+ as is */
+ if (!a->oldnote || !a->main.period)
+ return;
+
+ if ((!tick)&&(a->newsamp)){
+ a->main.kick=KICK_NOTE;
+ a->main.start=-1;
+ } else
+ a->main.kick=(a->main.kick==KICK_NOTE)?KICK_ENV:KICK_ABSENT;
+
+ if (tick) {
+ int dist;
+
+ /* We have to slide a->main.period towards a->wantedperiod, compute the
+ difference between those two values */
+ dist=a->main.period-a->wantedperiod;
+
+ /* if they are equal or if portamentospeed is too big... */
+ if ((!dist)||((a->portspeed<<2)>abs(dist)))
+ /* ... make tmpperiod equal tperiod */
+ a->tmpperiod=a->main.period=a->wantedperiod;
+ else
+ if (dist>0) {
+ a->tmpperiod-=a->portspeed<<2;
+ a->main.period-=a->portspeed<<2; /* dist>0 slide up */
+ } else {
+ a->tmpperiod+=a->portspeed<<2;
+ a->main.period+=a->portspeed<<2; /* dist<0 slide down */
+ }
+ } else
+ a->tmpperiod=a->main.period;
+ a->ownper=1;
+}
+
+static int DoITEffectG(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoITToneSlide(tick, a, UniGetByte());
+
+ return 0;
+}
+
+static void DoITVibrato(UWORD tick, MP_CONTROL *a, UBYTE dat)
+{
+ UBYTE q;
+ UWORD temp=0;
+
+ if (!tick) {
+ if (dat&0x0f) a->vibdepth=dat&0xf;
+ if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
+ }
+ if (!a->main.period)
+ return;
+
+ q=(a->vibpos>>2)&0x1f;
+
+ switch (a->wavecontrol&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* square wave */
+ temp=255;
+ break;
+ case 2: /* ramp down */
+ q<<=3;
+ if (a->vibpos<0) q=255-q;
+ temp=q;
+ break;
+ case 3: /* random */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->vibdepth;
+ temp>>=8;
+ temp<<=2;
+
+ if (a->vibpos>=0)
+ a->main.period=a->tmpperiod+temp;
+ else
+ a->main.period=a->tmpperiod-temp;
+ a->ownper=1;
+
+ a->vibpos+=a->vibspd;
+}
+
+static int DoITEffectH(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoITVibrato(tick, a, UniGetByte());
+
+ return 0;
+}
+
+static int DoITEffectI(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, on, off;
+
+ inf = UniGetByte();
+ if (inf)
+ a->s3mtronof = inf;
+ else {
+ inf = a->s3mtronof;
+ if (!inf)
+ return 0;
+ }
+
+ on=(inf>>4);
+ off=(inf&0xf);
+
+ a->s3mtremor%=(on+off);
+ a->volume=(a->s3mtremor<on)?a->tmpvolume:0;
+ a->ownvol = 1;
+ a->s3mtremor++;
+
+ return 0;
+}
+
+static int DoITEffectM(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ a->main.chanvol=UniGetByte();
+ if (a->main.chanvol>64)
+ a->main.chanvol=64;
+ else if (a->main.chanvol<0)
+ a->main.chanvol=0;
+
+ return 0;
+}
+
+static int DoITEffectN(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, lo, hi;
+
+ inf = UniGetByte();
+
+ if (inf)
+ a->chanvolslide = inf;
+ else
+ inf = a->chanvolslide;
+
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ if (!hi)
+ a->main.chanvol-=lo;
+ else
+ if (!lo) {
+ a->main.chanvol+=hi;
+ } else
+ if (hi==0xf) {
+ if (!tick) a->main.chanvol-=lo;
+ } else
+ if (lo==0xf) {
+ if (!tick) a->main.chanvol+=hi;
+ }
+
+ if (a->main.chanvol<0)
+ a->main.chanvol=0;
+ else if (a->main.chanvol>64)
+ a->main.chanvol=64;
+
+ return 0;
+}
+
+static int DoITEffectP(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, lo, hi;
+ SWORD pan;
+
+ inf = UniGetByte();
+ if (inf)
+ a->pansspd = inf;
+ else
+ inf = a->pansspd;
+
+ if (!mod->panflag)
+ return 0;
+
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ pan=(a->main.panning==PAN_SURROUND)?PAN_CENTER:a->main.panning;
+
+ if (!hi)
+ pan+=lo<<2;
+ else
+ if (!lo) {
+ pan-=hi<<2;
+ } else
+ if (hi==0xf) {
+ if (!tick) pan+=lo<<2;
+ } else
+ if (lo==0xf) {
+ if (!tick) pan-=hi<<2;
+ }
+ a->main.panning=
+ (pan<PAN_LEFT)?PAN_LEFT:(pan>PAN_RIGHT?PAN_RIGHT:pan);
+
+ return 0;
+}
+
+static int DoITEffectT(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE tempo;
+ SWORD temp;
+
+ tempo = UniGetByte();
+
+ if (mod->patdly2)
+ return 0;
+
+ temp = mod->bpm;
+ if (tempo & 0x10)
+ temp += (tempo & 0x0f);
+ else
+ temp -= tempo;
+
+ mod->bpm=(temp>255)?255:(temp<1?1:temp);
+
+ return 0;
+}
+
+static int DoITEffectU(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, q;
+ UWORD temp = 0; /* silence warning */
+
+ dat = UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->vibdepth=dat&0xf;
+ if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
+ }
+ if (a->main.period) {
+ q=(a->vibpos>>2)&0x1f;
+
+ switch (a->wavecontrol&3) {
+ case 0: /* sine */
+ temp=VibratoTable[q];
+ break;
+ case 1: /* square wave */
+ temp=255;
+ break;
+ case 2: /* ramp down */
+ q<<=3;
+ if (a->vibpos<0) q=255-q;
+ temp=q;
+ break;
+ case 3: /* random */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->vibdepth;
+ temp>>=8;
+
+ if (a->vibpos>=0)
+ a->main.period=a->tmpperiod+temp;
+ else
+ a->main.period=a->tmpperiod-temp;
+ a->ownper = 1;
+
+ a->vibpos+=a->vibspd;
+ }
+
+ return 0;
+}
+
+static int DoITEffectW(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE inf, lo, hi;
+
+ inf = UniGetByte();
+
+ if (inf)
+ mod->globalslide = inf;
+ else
+ inf = mod->globalslide;
+
+ lo=inf&0xf;
+ hi=inf>>4;
+
+ if (!lo) {
+ if (tick) mod->volume+=hi;
+ } else
+ if (!hi) {
+ if (tick) mod->volume-=lo;
+ } else
+ if (lo==0xf) {
+ if (!tick) mod->volume+=hi;
+ } else
+ if (hi==0xf) {
+ if (!tick) mod->volume-=lo;
+ }
+
+ if (mod->volume<0)
+ mod->volume=0;
+ else if (mod->volume>128)
+ mod->volume=128;
+
+ return 0;
+}
+
+static int DoITEffectY(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, q;
+ SLONG temp = 0; /* silence warning */
+
+
+ dat=UniGetByte();
+ if (!tick) {
+ if (dat&0x0f) a->panbdepth=(dat&0xf);
+ if (dat&0xf0) a->panbspd=(dat&0xf0)>>4;
+ }
+ if (mod->panflag) {
+ q=a->panbpos;
+
+ switch (a->panbwave) {
+ case 0: /* sine */
+ temp=PanbrelloTable[q];
+ break;
+ case 1: /* square wave */
+ temp=(q<0x80)?64:0;
+ break;
+ case 2: /* ramp down */
+ q<<=3;
+ temp=q;
+ break;
+ case 3: /* random */
+ temp=getrandom(256);
+ break;
+ }
+
+ temp*=a->panbdepth;
+ temp=(temp/8)+mod->panning[channel];
+
+ a->main.panning=
+ (temp<PAN_LEFT)?PAN_LEFT:(temp>PAN_RIGHT?PAN_RIGHT:temp);
+ a->panbpos+=a->panbspd;
+
+ }
+
+ return 0;
+}
+
+static void DoNNAEffects(MODULE *, MP_CONTROL *, UBYTE);
+
+/* Impulse/Scream Tracker Sxx effects.
+ All Sxx effects share the same memory space. */
+static int DoITEffectS0(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, inf, c;
+
+ dat = UniGetByte();
+ inf=dat&0xf;
+ c=dat>>4;
+
+ if (!dat) {
+ c=a->sseffect;
+ inf=a->ssdata;
+ } else {
+ a->sseffect=c;
+ a->ssdata=inf;
+ }
+
+ switch (c) {
+ case SS_GLISSANDO: /* S1x set glissando voice */
+ DoEEffects(tick, flags, a, mod, channel, 0x30|inf);
+ break;
+ case SS_FINETUNE: /* S2x set finetune */
+ DoEEffects(tick, flags, a, mod, channel, 0x50|inf);
+ break;
+ case SS_VIBWAVE: /* S3x set vibrato waveform */
+ DoEEffects(tick, flags, a, mod, channel, 0x40|inf);
+ break;
+ case SS_TREMWAVE: /* S4x set tremolo waveform */
+ DoEEffects(tick, flags, a, mod, channel, 0x70|inf);
+ break;
+ case SS_PANWAVE: /* S5x panbrello */
+ a->panbwave=inf;
+ break;
+ case SS_FRAMEDELAY: /* S6x delay x number of frames (patdly) */
+ DoEEffects(tick, flags, a, mod, channel, 0xe0|inf);
+ break;
+ case SS_S7EFFECTS: /* S7x instrument / NNA commands */
+ DoNNAEffects(mod, a, inf);
+ break;
+ case SS_PANNING: /* S8x set panning position */
+ DoEEffects(tick, flags, a, mod, channel, 0x80 | inf);
+ break;
+ case SS_SURROUND: /* S9x set surround sound */
+ if (mod->panflag)
+ a->main.panning = mod->panning[channel] = PAN_SURROUND;
+ break;
+ case SS_HIOFFSET: /* SAy set high order sample offset yxx00h */
+ if (!tick) {
+ a->hioffset=inf<<16;
+ a->main.start=a->hioffset|a->soffset;
+
+ if ((a->main.s)&&(a->main.start>a->main.s->length))
+ a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
+ a->main.s->loopstart:a->main.s->length;
+ }
+ break;
+ case SS_PATLOOP: /* SBx pattern loop */
+ DoEEffects(tick, flags, a, mod, channel, 0x60|inf);
+ break;
+ case SS_NOTECUT: /* SCx notecut */
+ if (!inf) inf = 1;
+ DoEEffects(tick, flags, a, mod, channel, 0xC0|inf);
+ break;
+ case SS_NOTEDELAY: /* SDx notedelay */
+ DoEEffects(tick, flags, a, mod, channel, 0xD0|inf);
+ break;
+ case SS_PATDELAY: /* SEx patterndelay */
+ DoEEffects(tick, flags, a, mod, channel, 0xE0|inf);
+ break;
+ }
+
+ return 0;
+}
+
+/*========== Impulse Tracker Volume/Pan Column effects */
+
+/*
+ * All volume/pan column effects share the same memory space.
+ */
+
+static int DoVolEffects(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE c, inf;
+
+ c = UniGetByte();
+ inf = UniGetByte();
+
+ if ((!c)&&(!inf)) {
+ c=a->voleffect;
+ inf=a->voldata;
+ } else {
+ a->voleffect=c;
+ a->voldata=inf;
+ }
+
+ if (c)
+ switch (c) {
+ case VOL_VOLUME:
+ if (tick) break;
+ if (inf>64) inf=64;
+ a->tmpvolume=inf;
+ break;
+ case VOL_PANNING:
+ if (mod->panflag)
+ a->main.panning=inf;
+ break;
+ case VOL_VOLSLIDE:
+ DoS3MVolSlide(tick, flags, a, inf);
+ return 1;
+ case VOL_PITCHSLIDEDN:
+ if (a->main.period)
+ DoS3MSlideDn(tick, a, inf);
+ break;
+ case VOL_PITCHSLIDEUP:
+ if (a->main.period)
+ DoS3MSlideUp(tick, a, inf);
+ break;
+ case VOL_PORTAMENTO:
+ DoITToneSlide(tick, a, inf);
+ break;
+ case VOL_VIBRATO:
+ DoITVibrato(tick, a, inf);
+ break;
+ }
+
+ return 0;
+}
+
+/*========== UltraTracker effects */
+
+static int DoULTEffect9(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UWORD offset=UniGetWord();
+
+ if (offset)
+ a->ultoffset=offset;
+
+ a->main.start=a->ultoffset<<2;
+ if ((a->main.s)&&(a->main.start>a->main.s->length))
+ a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
+ a->main.s->loopstart:a->main.s->length;
+
+ return 0;
+}
+
+/*========== OctaMED effects */
+
+static int DoMEDSpeed(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UWORD speed=UniGetWord();
+
+ mod->bpm=speed;
+
+ return 0;
+}
+
+static int DoMEDEffectF1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoEEffects(tick, flags, a, mod, channel, 0x90|(mod->sngspd/2));
+
+ return 0;
+}
+
+static int DoMEDEffectF2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoEEffects(tick, flags, a, mod, channel, 0xd0|(mod->sngspd/2));
+
+ return 0;
+}
+
+static int DoMEDEffectF3(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ DoEEffects(tick, flags, a, mod, channel, 0x90|(mod->sngspd/3));
+
+ return 0;
+}
+
+/*========== Oktalyzer effects */
+
+static int DoOktArp(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UBYTE dat, dat2;
+
+ dat2 = UniGetByte(); /* arpeggio style */
+ dat = UniGetByte();
+ if (!tick) {
+ if (!dat && (flags & UF_ARPMEM))
+ dat=a->arpmem;
+ else
+ a->arpmem=dat;
+ }
+ if (a->main.period)
+ DoArpeggio(tick, flags, a, dat2);
+
+ return 0;
+}
+
+/*========== General player functions */
+
+static int DoNothing(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
+{
+ UniSkipOpcode();
+
+ return 0;
+}
+
+typedef int (*effect_func) (UWORD, UWORD, MP_CONTROL *, MODULE *, SWORD);
+
+static effect_func effects[UNI_LAST] = {
+ DoNothing, /* 0 */
+ DoNothing, /* UNI_NOTE */
+ DoNothing, /* UNI_INSTRUMENT */
+ DoPTEffect0, /* UNI_PTEFFECT0 */
+ DoPTEffect1, /* UNI_PTEFFECT1 */
+ DoPTEffect2, /* UNI_PTEFFECT2 */
+ DoPTEffect3, /* UNI_PTEFFECT3 */
+ DoPTEffect4, /* UNI_PTEFFECT4 */
+ DoPTEffect5, /* UNI_PTEFFECT5 */
+ DoPTEffect6, /* UNI_PTEFFECT6 */
+ DoPTEffect7, /* UNI_PTEFFECT7 */
+ DoPTEffect8, /* UNI_PTEFFECT8 */
+ DoPTEffect9, /* UNI_PTEFFECT9 */
+ DoPTEffectA, /* UNI_PTEFFECTA */
+ DoPTEffectB, /* UNI_PTEFFECTB */
+ DoPTEffectC, /* UNI_PTEFFECTC */
+ DoPTEffectD, /* UNI_PTEFFECTD */
+ DoPTEffectE, /* UNI_PTEFFECTE */
+ DoPTEffectF, /* UNI_PTEFFECTF */
+ DoS3MEffectA, /* UNI_S3MEFFECTA */
+ DoS3MEffectD, /* UNI_S3MEFFECTD */
+ DoS3MEffectE, /* UNI_S3MEFFECTE */
+ DoS3MEffectF, /* UNI_S3MEFFECTF */
+ DoS3MEffectI, /* UNI_S3MEFFECTI */
+ DoS3MEffectQ, /* UNI_S3MEFFECTQ */
+ DoS3MEffectR, /* UNI_S3MEFFECTR */
+ DoS3MEffectT, /* UNI_S3MEFFECTT */
+ DoS3MEffectU, /* UNI_S3MEFFECTU */
+ DoKeyOff, /* UNI_KEYOFF */
+ DoKeyFade, /* UNI_KEYFADE */
+ DoVolEffects, /* UNI_VOLEFFECTS */
+ DoPTEffect4, /* UNI_XMEFFECT4 */
+ DoXMEffect6, /* UNI_XMEFFECT6 */
+ DoXMEffectA, /* UNI_XMEFFECTA */
+ DoXMEffectE1, /* UNI_XMEFFECTE1 */
+ DoXMEffectE2, /* UNI_XMEFFECTE2 */
+ DoXMEffectEA, /* UNI_XMEFFECTEA */
+ DoXMEffectEB, /* UNI_XMEFFECTEB */
+ DoXMEffectG, /* UNI_XMEFFECTG */
+ DoXMEffectH, /* UNI_XMEFFECTH */
+ DoXMEffectL, /* UNI_XMEFFECTL */
+ DoXMEffectP, /* UNI_XMEFFECTP */
+ DoXMEffectX1, /* UNI_XMEFFECTX1 */
+ DoXMEffectX2, /* UNI_XMEFFECTX2 */
+ DoITEffectG, /* UNI_ITEFFECTG */
+ DoITEffectH, /* UNI_ITEFFECTH */
+ DoITEffectI, /* UNI_ITEFFECTI */
+ DoITEffectM, /* UNI_ITEFFECTM */
+ DoITEffectN, /* UNI_ITEFFECTN */
+ DoITEffectP, /* UNI_ITEFFECTP */
+ DoITEffectT, /* UNI_ITEFFECTT */
+ DoITEffectU, /* UNI_ITEFFECTU */
+ DoITEffectW, /* UNI_ITEFFECTW */
+ DoITEffectY, /* UNI_ITEFFECTY */
+ DoNothing, /* UNI_ITEFFECTZ */
+ DoITEffectS0, /* UNI_ITEFFECTS0 */
+ DoULTEffect9, /* UNI_ULTEFFECT9 */
+ DoMEDSpeed, /* UNI_MEDSPEED */
+ DoMEDEffectF1, /* UNI_MEDEFFECTF1 */
+ DoMEDEffectF2, /* UNI_MEDEFFECTF2 */
+ DoMEDEffectF3, /* UNI_MEDEFFECTF3 */
+ DoOktArp, /* UNI_OKTARP */
+};
+
+static int pt_playeffects(MODULE *mod, SWORD channel, MP_CONTROL *a)
+{
+ UWORD tick = mod->vbtick;
+ UWORD flags = mod->flags;
+ UBYTE c;
+ int explicitslides = 0;
+ effect_func f;
+
+ while((c=UniGetByte()) != 0) {
+#if 0 /* this doesn't normally happen unless things go fubar elsewhere */
+ if (c >= UNI_LAST)
+ fprintf(stderr,"fubar'ed opcode %u\n",c);
+#endif
+ f = effects[c];
+ if (f != DoNothing)
+ a->sliding = 0;
+ explicitslides |= f(tick, flags, a, mod, channel);
+ }
+ return explicitslides;
+}
+
+static void DoNNAEffects(MODULE *mod, MP_CONTROL *a, UBYTE dat)
+{
+ int t;
+ MP_VOICE *aout;
+
+ dat&=0xf;
+ aout=(a->slave)?a->slave:NULL;
+
+ switch (dat) {
+ case 0x0: /* past note cut */
+ for (t=0;t<NUMVOICES(mod);t++)
+ if (mod->voice[t].master==a)
+ mod->voice[t].main.fadevol=0;
+ break;
+ case 0x1: /* past note off */
+ for (t=0;t<NUMVOICES(mod);t++)
+ if (mod->voice[t].master==a) {
+ mod->voice[t].main.keyoff|=KEY_OFF;
+ if ((!(mod->voice[t].venv.flg & EF_ON))||
+ (mod->voice[t].venv.flg & EF_LOOP))
+ mod->voice[t].main.keyoff=KEY_KILL;
+ }
+ break;
+ case 0x2: /* past note fade */
+ for (t=0;t<NUMVOICES(mod);t++)
+ if (mod->voice[t].master==a)
+ mod->voice[t].main.keyoff|=KEY_FADE;
+ break;
+ case 0x3: /* set NNA note cut */
+ a->main.nna=(a->main.nna&~NNA_MASK)|NNA_CUT;
+ break;
+ case 0x4: /* set NNA note continue */
+ a->main.nna=(a->main.nna&~NNA_MASK)|NNA_CONTINUE;
+ break;
+ case 0x5: /* set NNA note off */
+ a->main.nna=(a->main.nna&~NNA_MASK)|NNA_OFF;
+ break;
+ case 0x6: /* set NNA note fade */
+ a->main.nna=(a->main.nna&~NNA_MASK)|NNA_FADE;
+ break;
+ case 0x7: /* disable volume envelope */
+ if (aout)
+ aout->main.volflg&=~EF_ON;
+ break;
+ case 0x8: /* enable volume envelope */
+ if (aout)
+ aout->main.volflg|=EF_ON;
+ break;
+ case 0x9: /* disable panning envelope */
+ if (aout)
+ aout->main.panflg&=~EF_ON;
+ break;
+ case 0xa: /* enable panning envelope */
+ if (aout)
+ aout->main.panflg|=EF_ON;
+ break;
+ case 0xb: /* disable pitch envelope */
+ if (aout)
+ aout->main.pitflg&=~EF_ON;
+ break;
+ case 0xc: /* enable pitch envelope */
+ if (aout)
+ aout->main.pitflg|=EF_ON;
+ break;
+ }
+}
+
+static void pt_UpdateVoices(MODULE *mod, int max_volume)
+{
+ SWORD envpan,envvol,envpit,channel;
+ UWORD playperiod;
+ SLONG vibval,vibdpt;
+ ULONG tmpvol;
+
+ MP_VOICE *aout;
+ INSTRUMENT *i;
+ SAMPLE *s;
+
+ mod->totalchn=mod->realchn=0;
+ for (channel=0;channel<NUMVOICES(mod);channel++) {
+ aout=&mod->voice[channel];
+ i=aout->main.i;
+ s=aout->main.s;
+
+ if (!s || !s->length) continue;
+
+ if (aout->main.period<40)
+ aout->main.period=40;
+ else if (aout->main.period>50000)
+ aout->main.period=50000;
+
+ if ((aout->main.kick==KICK_NOTE)||(aout->main.kick==KICK_KEYOFF)) {
+ Voice_Play_internal(channel,s,(aout->main.start==-1)?
+ ((s->flags&SF_UST_LOOP)?s->loopstart:0):aout->main.start);
+ aout->main.fadevol=32768;
+ aout->aswppos=0;
+ }
+
+ envvol = 256;
+ envpan = PAN_CENTER;
+ envpit = 32;
+ if (i && ((aout->main.kick==KICK_NOTE)||(aout->main.kick==KICK_ENV))) {
+ if (aout->main.volflg & EF_ON)
+ envvol = StartEnvelope(&aout->venv,aout->main.volflg,
+ i->volpts,i->volsusbeg,i->volsusend,
+ i->volbeg,i->volend,i->volenv,aout->main.keyoff);
+ if (aout->main.panflg & EF_ON)
+ envpan = StartEnvelope(&aout->penv,aout->main.panflg,
+ i->panpts,i->pansusbeg,i->pansusend,
+ i->panbeg,i->panend,i->panenv,aout->main.keyoff);
+ if (aout->main.pitflg & EF_ON)
+ envpit = StartEnvelope(&aout->cenv,aout->main.pitflg,
+ i->pitpts,i->pitsusbeg,i->pitsusend,
+ i->pitbeg,i->pitend,i->pitenv,aout->main.keyoff);
+
+ if (aout->cenv.flg & EF_ON)
+ aout->masterperiod=GetPeriod(mod->flags,
+ (UWORD)aout->main.note<<1, aout->master->speed);
+ } else {
+ if (aout->main.volflg & EF_ON)
+ envvol = ProcessEnvelope(aout,&aout->venv,256);
+ if (aout->main.panflg & EF_ON)
+ envpan = ProcessEnvelope(aout,&aout->penv,PAN_CENTER);
+ if (aout->main.pitflg & EF_ON)
+ envpit = ProcessEnvelope(aout,&aout->cenv,32);
+ }
+ if (aout->main.kick == KICK_NOTE) {
+ aout->main.kick_flag = 1;
+ }
+ aout->main.kick=KICK_ABSENT;
+
+ tmpvol = aout->main.fadevol; /* max 32768 */
+ tmpvol *= aout->main.chanvol; /* * max 64 */
+ tmpvol *= aout->main.outvolume; /* * max 256 */
+ tmpvol /= (256 * 64); /* tmpvol is max 32768 again */
+ aout->totalvol = tmpvol >> 2; /* used to determine samplevolume */
+ tmpvol *= envvol; /* * max 256 */
+ tmpvol *= mod->volume; /* * max 128 */
+ tmpvol /= (128 * 256 * 128);
+
+ /* fade out */
+ if (mod->sngpos>=mod->numpos)
+ tmpvol=0;
+ else
+ tmpvol=(tmpvol*max_volume)/128;
+
+ if ((aout->masterchn!=-1)&& mod->control[aout->masterchn].muted)
+ Voice_SetVolume_internal(channel,0);
+ else {
+ Voice_SetVolume_internal(channel,tmpvol);
+ if ((tmpvol)&&(aout->master)&&(aout->master->slave==aout))
+ mod->realchn++;
+ mod->totalchn++;
+ }
+
+ if (aout->main.panning==PAN_SURROUND)
+ Voice_SetPanning_internal(channel,PAN_SURROUND);
+ else
+ if ((mod->panflag)&&(aout->penv.flg & EF_ON))
+ Voice_SetPanning_internal(channel,
+ DoPan(envpan,aout->main.panning));
+ else
+ Voice_SetPanning_internal(channel,aout->main.panning);
+
+ if (aout->main.period && s->vibdepth)
+ switch (s->vibtype) {
+ case 0:
+ vibval=avibtab[s->avibpos&127];
+ if (aout->avibpos & 0x80) vibval=-vibval;
+ break;
+ case 1:
+ vibval=64;
+ if (aout->avibpos & 0x80) vibval=-vibval;
+ break;
+ case 2:
+ vibval=63-(((aout->avibpos+128)&255)>>1);
+ break;
+ default:
+ vibval=(((aout->avibpos+128)&255)>>1)-64;
+ break;
+ }
+ else
+ vibval=0;
+
+ if (s->vibflags & AV_IT) {
+ if ((aout->aswppos>>8)<s->vibdepth) {
+ aout->aswppos += s->vibsweep;
+ vibdpt=aout->aswppos;
+ } else
+ vibdpt=s->vibdepth<<8;
+ vibval=(vibval*vibdpt)>>16;
+ if (aout->mflag) {
+ if (!(mod->flags&UF_LINEAR)) vibval>>=1;
+ aout->main.period-=vibval;
+ }
+ } else {
+ /* do XM style auto-vibrato */
+ if (!(aout->main.keyoff & KEY_OFF)) {
+ if (aout->aswppos<s->vibsweep) {
+ vibdpt=(aout->aswppos*s->vibdepth)/s->vibsweep;
+ aout->aswppos++;
+ } else
+ vibdpt=s->vibdepth;
+ } else {
+ /* keyoff -> depth becomes 0 if final depth wasn't reached or
+ stays at final level if depth WAS reached */
+ if (aout->aswppos>=s->vibsweep)
+ vibdpt=s->vibdepth;
+ else
+ vibdpt=0;
+ }
+ vibval=(vibval*vibdpt)>>8;
+ aout->main.period-=vibval;
+ }
+
+ /* update vibrato position */
+ aout->avibpos=(aout->avibpos+s->vibrate)&0xff;
+
+ /* process pitch envelope */
+ playperiod=aout->main.period;
+
+ if ((aout->main.pitflg&EF_ON)&&(envpit!=32)) {
+ long p1;
+
+ envpit-=32;
+ if ((aout->main.note<<1)+envpit<=0) envpit=-(aout->main.note<<1);
+
+ p1=GetPeriod(mod->flags, ((UWORD)aout->main.note<<1)+envpit,
+ aout->master->speed)-aout->masterperiod;
+ if (p1>0) {
+ if ((UWORD)(playperiod+p1)<=playperiod) {
+ p1=0;
+ aout->main.keyoff|=KEY_OFF;
+ }
+ } else if (p1<0) {
+ if ((UWORD)(playperiod+p1)>=playperiod) {
+ p1=0;
+ aout->main.keyoff|=KEY_OFF;
+ }
+ }
+ playperiod+=p1;
+ }
+
+ if (!aout->main.fadevol) { /* check for a dead note (fadevol=0) */
+ Voice_Stop_internal(channel);
+ mod->totalchn--;
+ if ((tmpvol)&&(aout->master)&&(aout->master->slave==aout))
+ mod->realchn--;
+ } else {
+ Voice_SetFrequency_internal(channel,
+ getfrequency(mod->flags,playperiod));
+
+ /* if keyfade, start substracting fadeoutspeed from fadevol: */
+ if ((i)&&(aout->main.keyoff&KEY_FADE)) {
+ if (aout->main.fadevol>=i->volfade)
+ aout->main.fadevol-=i->volfade;
+ else
+ aout->main.fadevol=0;
+ }
+ }
+
+ md_bpm=mod->bpm+mod->relspd;
+ if (md_bpm<32)
+ md_bpm=32;
+ else if ((!(mod->flags&UF_HIGHBPM)) && md_bpm>255)
+ md_bpm=255;
+ }
+}
+
+/* Handles new notes or instruments */
+static void pt_Notes(MODULE *mod)
+{
+ SWORD channel;
+ MP_CONTROL *a;
+ UBYTE c,inst;
+ int tr,funky; /* funky is set to indicate note or instrument change */
+
+ for (channel=0;channel<mod->numchn;channel++) {
+ a=&mod->control[channel];
+
+ if (mod->sngpos>=mod->numpos) {
+ tr=mod->numtrk;
+ mod->numrow=0;
+ } else {
+ tr=mod->patterns[(mod->positions[mod->sngpos]*mod->numchn)+channel];
+ mod->numrow=mod->pattrows[mod->positions[mod->sngpos]];
+ }
+
+ a->row=(tr<mod->numtrk)?UniFindRow(mod->tracks[tr],mod->patpos):NULL;
+ a->newsamp=0;
+ if (!mod->vbtick) a->main.notedelay=0;
+
+ if (!a->row) continue;
+ UniSetRow(a->row);
+ funky=0;
+
+ while((c=UniGetByte()) != 0)
+ switch (c) {
+ case UNI_NOTE:
+ funky|=1;
+ a->oldnote=a->anote,a->anote=UniGetByte();
+ a->main.kick =KICK_NOTE;
+ a->main.start=-1;
+ a->sliding=0;
+
+ /* retrig tremolo and vibrato waves ? */
+ if (!(a->wavecontrol & 0x80)) a->trmpos=0;
+ if (!(a->wavecontrol & 0x08)) a->vibpos=0;
+ if (!a->panbwave) a->panbpos=0;
+ break;
+ case UNI_INSTRUMENT:
+ inst=UniGetByte();
+ if (inst>=mod->numins) break; /* safety valve */
+ funky|=2;
+ a->main.i=(mod->flags & UF_INST)?&mod->instruments[inst]:NULL;
+ a->retrig=0;
+ a->s3mtremor=0;
+ a->ultoffset=0;
+ a->main.sample=inst;
+ break;
+ default:
+ UniSkipOpcode();
+ break;
+ }
+
+ if (funky) {
+ INSTRUMENT *i;
+ SAMPLE *s;
+
+ if ((i=a->main.i) != NULL) {
+ if (i->samplenumber[a->anote] >= mod->numsmp) continue;
+ s=&mod->samples[i->samplenumber[a->anote]];
+ a->main.note=i->samplenote[a->anote];
+ } else {
+ a->main.note=a->anote;
+ s=&mod->samples[a->main.sample];
+ }
+
+ if (a->main.s!=s) {
+ a->main.s=s;
+ a->newsamp=a->main.period;
+ }
+
+ /* channel or instrument determined panning ? */
+ a->main.panning=mod->panning[channel];
+ if (s->flags & SF_OWNPAN)
+ a->main.panning=s->panning;
+ else if ((i)&&(i->flags & IF_OWNPAN))
+ a->main.panning=i->panning;
+
+ a->main.handle=s->handle;
+ a->speed=s->speed;
+
+ if (i) {
+ if ((mod->panflag)&&(i->flags & IF_PITCHPAN)
+ &&(a->main.panning!=PAN_SURROUND)){
+ a->main.panning+=
+ ((a->anote-i->pitpancenter)*i->pitpansep)/8;
+ if (a->main.panning<PAN_LEFT)
+ a->main.panning=PAN_LEFT;
+ else if (a->main.panning>PAN_RIGHT)
+ a->main.panning=PAN_RIGHT;
+ }
+ a->main.pitflg=i->pitflg;
+ a->main.volflg=i->volflg;
+ a->main.panflg=i->panflg;
+ a->main.nna=i->nnatype;
+ a->dca=i->dca;
+ a->dct=i->dct;
+ } else {
+ a->main.pitflg=a->main.volflg=a->main.panflg=0;
+ a->main.nna=a->dca=0;
+ a->dct=DCT_OFF;
+ }
+
+ if (funky&2) /* instrument change */ {
+ /* IT random volume variations: 0:8 bit fixed, and one bit for
+ sign. */
+ a->volume=a->tmpvolume=s->volume;
+ if ((s)&&(i)) {
+ if (i->rvolvar) {
+ a->volume=a->tmpvolume=s->volume+
+ ((s->volume*((SLONG)i->rvolvar*(SLONG)getrandom(512)
+ ))/25600);
+ if (a->volume<0)
+ a->volume=a->tmpvolume=0;
+ else if (a->volume>64)
+ a->volume=a->tmpvolume=64;
+ }
+ if ((mod->panflag)&&(a->main.panning!=PAN_SURROUND)) {
+ a->main.panning+=((a->main.panning*((SLONG)i->rpanvar*
+ (SLONG)getrandom(512)))/25600);
+ if (a->main.panning<PAN_LEFT)
+ a->main.panning=PAN_LEFT;
+ else if (a->main.panning>PAN_RIGHT)
+ a->main.panning=PAN_RIGHT;
+ }
+ }
+ }
+
+ a->wantedperiod=a->tmpperiod=
+ GetPeriod(mod->flags, (UWORD)a->main.note<<1,a->speed);
+ a->main.keyoff=KEY_KICK;
+ }
+ }
+}
+
+/* Handles effects */
+static void pt_EffectsPass1(MODULE *mod)
+{
+ SWORD channel;
+ MP_CONTROL *a;
+ MP_VOICE *aout;
+ int explicitslides;
+
+ for (channel=0;channel<mod->numchn;channel++) {
+ a=&mod->control[channel];
+
+ if ((aout=a->slave) != NULL) {
+ a->main.fadevol=aout->main.fadevol;
+ a->main.period=aout->main.period;
+ if (a->main.kick==KICK_KEYOFF)
+ a->main.keyoff=aout->main.keyoff;
+ }
+
+ if (!a->row) continue;
+ UniSetRow(a->row);
+
+ a->ownper=a->ownvol=0;
+ explicitslides = pt_playeffects(mod, channel, a);
+
+ /* continue volume slide if necessary for XM and IT */
+ if (mod->flags&UF_BGSLIDES) {
+ if (!explicitslides && a->sliding)
+ DoS3MVolSlide(mod->vbtick, mod->flags, a, 0);
+ else if (a->tmpvolume)
+ a->sliding = explicitslides;
+ }
+
+ if (!a->ownper)
+ a->main.period=a->tmpperiod;
+ if (!a->ownvol)
+ a->volume=a->tmpvolume;
+
+ if (a->main.s) {
+ if (a->main.i)
+ a->main.outvolume=
+ (a->volume*a->main.s->globvol*a->main.i->globvol)>>10;
+ else
+ a->main.outvolume=(a->volume*a->main.s->globvol)>>4;
+ if (a->main.outvolume>256)
+ a->main.outvolume=256;
+ else if (a->main.outvolume<0)
+ a->main.outvolume=0;
+ }
+ }
+}
+
+/* NNA management */
+static void pt_NNA(MODULE *mod)
+{
+ SWORD channel;
+ MP_CONTROL *a;
+
+ for (channel=0;channel<mod->numchn;channel++) {
+ a=&mod->control[channel];
+
+ if (a->main.kick==KICK_NOTE) {
+ BOOL kill=0;
+
+ if (a->slave) {
+ MP_VOICE *aout;
+
+ aout=a->slave;
+ if (aout->main.nna & NNA_MASK) {
+ /* Make sure the old MP_VOICE channel knows it has no
+ master now ! */
+ a->slave=NULL;
+ /* assume the channel is taken by NNA */
+ aout->mflag=0;
+
+ switch (aout->main.nna) {
+ case NNA_CONTINUE: /* continue note, do nothing */
+ break;
+ case NNA_OFF: /* note off */
+ aout->main.keyoff|=KEY_OFF;
+ if ((!(aout->main.volflg & EF_ON))||
+ (aout->main.volflg & EF_LOOP))
+ aout->main.keyoff=KEY_KILL;
+ break;
+ case NNA_FADE:
+ aout->main.keyoff |= KEY_FADE;
+ break;
+ }
+ }
+ }
+
+ if (a->dct!=DCT_OFF) {
+ int t;
+
+ for (t=0;t<NUMVOICES(mod);t++)
+ if ((!Voice_Stopped_internal(t))&&
+ (mod->voice[t].masterchn==channel)&&
+ (a->main.sample==mod->voice[t].main.sample)) {
+ kill=0;
+ switch (a->dct) {
+ case DCT_NOTE:
+ if (a->main.note==mod->voice[t].main.note)
+ kill=1;
+ break;
+ case DCT_SAMPLE:
+ if (a->main.handle==mod->voice[t].main.handle)
+ kill=1;
+ break;
+ case DCT_INST:
+ kill=1;
+ break;
+ }
+ if (kill)
+ switch (a->dca) {
+ case DCA_CUT:
+ mod->voice[t].main.fadevol=0;
+ break;
+ case DCA_OFF:
+ mod->voice[t].main.keyoff|=KEY_OFF;
+ if ((!(mod->voice[t].main.volflg&EF_ON))||
+ (mod->voice[t].main.volflg&EF_LOOP))
+ mod->voice[t].main.keyoff=KEY_KILL;
+ break;
+ case DCA_FADE:
+ mod->voice[t].main.keyoff|=KEY_FADE;
+ break;
+ }
+ }
+ }
+ } /* if (a->main.kick==KICK_NOTE) */
+ }
+}
+
+/* Setup module and NNA voices */
+static void pt_SetupVoices(MODULE *mod)
+{
+ SWORD channel;
+ MP_CONTROL *a;
+ MP_VOICE *aout;
+
+ for (channel=0;channel<mod->numchn;channel++) {
+ a=&mod->control[channel];
+
+ if (a->main.notedelay) continue;
+ if (a->main.kick==KICK_NOTE) {
+ /* if no channel was cut above, find an empty or quiet channel
+ here */
+ if (mod->flags&UF_NNA) {
+ if (!a->slave) {
+ int newchn;
+
+ if ((newchn=MP_FindEmptyChannel(mod))!=-1)
+ a->slave=&mod->voice[a->slavechn=newchn];
+ }
+ } else
+ a->slave=&mod->voice[a->slavechn=channel];
+
+ /* assign parts of MP_VOICE only done for a KICK_NOTE */
+ if ((aout=a->slave) != NULL) {
+ if (aout->mflag && aout->master) aout->master->slave=NULL;
+ aout->master=a;
+ a->slave=aout;
+ aout->masterchn=channel;
+ aout->mflag=1;
+ }
+ } else
+ aout=a->slave;
+
+ if (aout)
+ aout->main=a->main;
+ a->main.kick=KICK_ABSENT;
+ }
+}
+
+/* second effect pass */
+static void pt_EffectsPass2(MODULE *mod)
+{
+ SWORD channel;
+ MP_CONTROL *a;
+ UBYTE c;
+
+ for (channel=0;channel<mod->numchn;channel++) {
+ a=&mod->control[channel];
+
+ if (!a->row) continue;
+ UniSetRow(a->row);
+
+ while((c=UniGetByte()) != 0)
+ if (c==UNI_ITEFFECTS0) {
+ c=UniGetByte();
+ if ((c>>4)==SS_S7EFFECTS)
+ DoNNAEffects(mod, a, c&0xf);
+ } else
+ UniSkipOpcode();
+ }
+}
+
+void Player_HandleTick(void)
+{
+ SWORD channel;
+ int max_volume;
+
+#if 0
+ /* don't handle the very first ticks, this allows the other hardware to
+ settle down so we don't loose any starting notes */
+ if (isfirst) {
+ isfirst--;
+ return;
+ }
+#endif
+
+ if ((!pf)||(pf->forbid)||(pf->sngpos>=pf->numpos)) return;
+
+ /* update time counter (sngtime is in milliseconds (in fact 2^-10)) */
+ pf->sngremainder+=(1<<9)*5; /* thus 2.5*(1<<10), since fps=0.4xtempo */
+ pf->sngtime+=pf->sngremainder/pf->bpm;
+ pf->sngremainder%=pf->bpm;
+
+ if (++pf->vbtick>=pf->sngspd) {
+ if (pf->pat_repcrazy)
+ pf->pat_repcrazy=0; /* play 2 times row 0 */
+ else
+ pf->patpos++;
+ pf->vbtick=0;
+
+ /* process pattern-delay. pf->patdly2 is the counter and pf->patdly is
+ the command memory. */
+ if (pf->patdly)
+ pf->patdly2=pf->patdly,pf->patdly=0;
+ if (pf->patdly2) {
+ /* patterndelay active */
+ if (--pf->patdly2)
+ /* so turn back pf->patpos by 1 */
+ if (pf->patpos) pf->patpos--;
+ }
+
+ /* do we have to get a new patternpointer ? (when pf->patpos reaches the
+ pattern size, or when a patternbreak is active) */
+ if (((pf->patpos>=pf->numrow)&&(pf->numrow>0))&&(!pf->posjmp))
+ pf->posjmp=3;
+
+ if (pf->posjmp) {
+ pf->patpos=pf->numrow?(pf->patbrk%pf->numrow):0;
+ pf->pat_repcrazy=0;
+ pf->sngpos+=(pf->posjmp-2);
+ for (channel=0;channel<pf->numchn;channel++)
+ pf->control[channel].pat_reppos=-1;
+
+ pf->patbrk=pf->posjmp=0;
+
+ if (pf->sngpos<0) pf->sngpos=(SWORD)(pf->numpos-1);
+
+ /* handle the "---" (end of song) pattern since it can occur
+ *inside* the module in some formats */
+ if ((pf->sngpos>=pf->numpos)||
+ (pf->positions[pf->sngpos]==LAST_PATTERN)) {
+ if (!pf->wrap) return;
+ if (!(pf->sngpos=pf->reppos)) {
+ pf->volume=pf->initvolume>128?128:pf->initvolume;
+ if(pf->initspeed!=0)
+ pf->sngspd=pf->initspeed<32?pf->initspeed:32;
+ else
+ pf->sngspd=6;
+ pf->bpm=pf->inittempo<32?32:pf->inittempo;
+ }
+ }
+ }
+
+ if (!pf->patdly2)
+ pt_Notes(pf);
+ }
+
+ /* Fade global volume if enabled and we're playing the last pattern */
+ if (((pf->sngpos==pf->numpos-1)||
+ (pf->positions[pf->sngpos+1]==LAST_PATTERN))&&
+ (pf->fadeout))
+ max_volume=pf->numrow?((pf->numrow-pf->patpos)*128)/pf->numrow:0;
+ else
+ max_volume=128;
+
+ pt_EffectsPass1(pf);
+ if (pf->flags&UF_NNA)
+ pt_NNA(pf);
+ pt_SetupVoices(pf);
+ pt_EffectsPass2(pf);
+
+ /* now set up the actual hardware channel playback information */
+ pt_UpdateVoices(pf, max_volume);
+}
+
+static void Player_Init_internal(MODULE* mod)
+{
+ int t;
+
+ for (t=0;t<mod->numchn;t++) {
+ mod->control[t].main.chanvol=mod->chanvol[t];
+ mod->control[t].main.panning=mod->panning[t];
+ }
+
+ mod->sngtime=0;
+ mod->sngremainder=0;
+
+ mod->pat_repcrazy=0;
+ mod->sngpos=0;
+ if(mod->initspeed!=0)
+ mod->sngspd=mod->initspeed<32?mod->initspeed:32;
+ else
+ mod->sngspd=6;
+ mod->volume=mod->initvolume>128?128:mod->initvolume;
+
+ mod->vbtick=mod->sngspd;
+ mod->patdly=0;
+ mod->patdly2=0;
+ mod->bpm=mod->inittempo<32?32:mod->inittempo;
+ mod->realchn=0;
+
+ mod->patpos=0;
+ mod->posjmp=2; /* make sure the player fetches the first note */
+ mod->numrow=-1;
+ mod->patbrk=0;
+}
+
+int Player_Init(MODULE* mod)
+{
+ mod->extspd=1;
+ mod->panflag=1;
+ mod->wrap=0;
+ mod->loop=1;
+ mod->fadeout=0;
+
+ mod->relspd=0;
+
+ /* make sure the player doesn't start with garbage */
+ if (!(mod->control=(MP_CONTROL*)MikMod_calloc(mod->numchn,sizeof(MP_CONTROL))))
+ return 1;
+ if (!(mod->voice=(MP_VOICE*)MikMod_calloc(md_sngchn,sizeof(MP_VOICE))))
+ return 1;
+
+ /* mod->numvoices was used during loading to clamp md_sngchn.
+ After loading it's used to remember how big mod->voice is.
+ */
+ mod->numvoices = md_sngchn;
+
+ Player_Init_internal(mod);
+ return 0;
+}
+
+void Player_Exit_internal(MODULE* mod)
+{
+ if (!mod)
+ return;
+
+ /* Stop playback if necessary */
+ if (mod==pf) {
+ Player_Stop_internal();
+ pf=NULL;
+ }
+
+ MikMod_free(mod->control);
+ MikMod_free(mod->voice);
+ mod->control=NULL;
+ mod->voice=NULL;
+}
+
+void Player_Exit(MODULE* mod)
+{
+ MUTEX_LOCK(vars);
+ Player_Exit_internal(mod);
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void Player_SetVolume(SWORD volume)
+{
+ MUTEX_LOCK(vars);
+ if (pf) {
+ pf->volume=(volume<0)?0:(volume>128)?128:volume;
+ pf->initvolume=pf->volume;
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI MODULE* Player_GetModule(void)
+{
+ MODULE* result;
+
+ MUTEX_LOCK(vars);
+ result=pf;
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI void Player_Start(MODULE *mod)
+{
+ int t;
+
+ if (!mod)
+ return;
+
+ if (!MikMod_Active())
+ MikMod_EnableOutput();
+
+ mod->forbid=0;
+
+ MUTEX_LOCK(vars);
+ if (pf!=mod) {
+ /* new song is being started, so completely stop out the old one. */
+ if (pf) pf->forbid=1;
+ for (t=0;t<md_sngchn;t++) Voice_Stop_internal(t);
+ }
+ pf=mod;
+ MUTEX_UNLOCK(vars);
+}
+
+void Player_Stop_internal(void)
+{
+ if (!md_sfxchn) MikMod_DisableOutput_internal();
+ if (pf) pf->forbid=1;
+ pf=NULL;
+}
+
+MIKMODAPI void Player_Stop(void)
+{
+ MUTEX_LOCK(vars);
+ Player_Stop_internal();
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI BOOL Player_Active(void)
+{
+ BOOL result=0;
+
+ MUTEX_LOCK(vars);
+ if (pf)
+ result=(!(pf->sngpos>=pf->numpos));
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI void Player_NextPosition(void)
+{
+ MUTEX_LOCK(vars);
+ if (pf) {
+ int t;
+
+ pf->forbid=1;
+ pf->posjmp=3;
+ pf->patbrk=0;
+ pf->vbtick=pf->sngspd;
+
+ for (t=0;t<NUMVOICES(pf);t++) {
+ Voice_Stop_internal(t);
+ pf->voice[t].main.i=NULL;
+ pf->voice[t].main.s=NULL;
+ }
+ for (t=0;t<pf->numchn;t++) {
+ pf->control[t].main.i=NULL;
+ pf->control[t].main.s=NULL;
+ }
+ pf->forbid=0;
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void Player_PrevPosition(void)
+{
+ MUTEX_LOCK(vars);
+ if (pf) {
+ int t;
+
+ pf->forbid=1;
+ pf->posjmp=1;
+ pf->patbrk=0;
+ pf->vbtick=pf->sngspd;
+
+ for (t=0;t<NUMVOICES(pf);t++) {
+ Voice_Stop_internal(t);
+ pf->voice[t].main.i=NULL;
+ pf->voice[t].main.s=NULL;
+ }
+ for (t=0;t<pf->numchn;t++) {
+ pf->control[t].main.i=NULL;
+ pf->control[t].main.s=NULL;
+ }
+ pf->forbid=0;
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void Player_SetPosition(UWORD pos)
+{
+ MUTEX_LOCK(vars);
+ if (pf) {
+ int t;
+
+ pf->forbid=1;
+ if (pos>=pf->numpos) pos=pf->numpos;
+ pf->posjmp=2;
+ pf->patbrk=0;
+ pf->sngpos=pos;
+ pf->vbtick=pf->sngspd;
+
+ for (t=0;t<NUMVOICES(pf);t++) {
+ Voice_Stop_internal(t);
+ pf->voice[t].main.i=NULL;
+ pf->voice[t].main.s=NULL;
+ }
+ for (t=0;t<pf->numchn;t++) {
+ pf->control[t].main.i=NULL;
+ pf->control[t].main.s=NULL;
+ }
+ pf->forbid=0;
+
+ if (!pos)
+ Player_Init_internal(pf);
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+static void Player_Unmute_internal(SLONG arg1,va_list ap)
+{
+ SLONG t,arg2,arg3=0;
+
+ if (pf) {
+ switch (arg1) {
+ case MUTE_INCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (;arg2<pf->numchn && arg2<=arg3;arg2++)
+ pf->control[arg2].muted=0;
+ break;
+ case MUTE_EXCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (t=0;t<pf->numchn;t++) {
+ if ((t>=arg2) && (t<=arg3))
+ continue;
+ pf->control[t].muted=0;
+ }
+ break;
+ default:
+ if (arg1<pf->numchn) pf->control[arg1].muted=0;
+ break;
+ }
+ }
+}
+
+MIKMODAPI void Player_Unmute(SLONG arg1, ...)
+{
+ va_list args;
+
+ va_start(args,arg1);
+ MUTEX_LOCK(vars);
+ Player_Unmute_internal(arg1,args);
+ MUTEX_UNLOCK(vars);
+ va_end(args);
+}
+
+static void Player_Mute_internal(SLONG arg1,va_list ap)
+{
+ SLONG t,arg2,arg3=0;
+
+ if (pf) {
+ switch (arg1) {
+ case MUTE_INCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (;arg2<pf->numchn && arg2<=arg3;arg2++)
+ pf->control[arg2].muted=1;
+ break;
+ case MUTE_EXCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (t=0;t<pf->numchn;t++) {
+ if ((t>=arg2) && (t<=arg3))
+ continue;
+ pf->control[t].muted=1;
+ }
+ break;
+ default:
+ if (arg1<pf->numchn)
+ pf->control[arg1].muted=1;
+ break;
+ }
+ }
+}
+
+MIKMODAPI void Player_Mute(SLONG arg1,...)
+{
+ va_list args;
+
+ va_start(args,arg1);
+ MUTEX_LOCK(vars);
+ Player_Mute_internal(arg1,args);
+ MUTEX_UNLOCK(vars);
+ va_end(args);
+}
+
+static void Player_ToggleMute_internal(SLONG arg1,va_list ap)
+{
+ SLONG arg2,arg3=0;
+ ULONG t;
+
+ if (pf) {
+ switch (arg1) {
+ case MUTE_INCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (;arg2<pf->numchn && arg2<=arg3;arg2++)
+ pf->control[arg2].muted=1-pf->control[arg2].muted;
+ break;
+ case MUTE_EXCLUSIVE:
+ if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
+ (arg2>arg3)||(arg3>=pf->numchn))
+ return;
+ for (t=0;t<pf->numchn;t++) {
+ if ((t>=arg2) && (t<=arg3))
+ continue;
+ pf->control[t].muted=1-pf->control[t].muted;
+ }
+ break;
+ default:
+ if (arg1<pf->numchn)
+ pf->control[arg1].muted=1-pf->control[arg1].muted;
+ break;
+ }
+ }
+}
+
+MIKMODAPI void Player_ToggleMute(SLONG arg1,...)
+{
+ va_list args;
+
+ va_start(args,arg1);
+ MUTEX_LOCK(vars);
+ Player_ToggleMute_internal(arg1,args);
+ MUTEX_UNLOCK(vars);
+ va_end(args);
+}
+
+MIKMODAPI BOOL Player_Muted(UBYTE chan)
+{
+ BOOL result=1;
+
+ MUTEX_LOCK(vars);
+ if (pf)
+ result=(chan<pf->numchn)?pf->control[chan].muted:1;
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI int Player_GetChannelVoice(UBYTE chan)
+{
+ int result=0;
+
+ MUTEX_LOCK(vars);
+ if (pf)
+ result=(chan<pf->numchn)?pf->control[chan].slavechn:-1;
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI UWORD Player_GetChannelPeriod(UBYTE chan)
+{
+ UWORD result=0;
+
+ MUTEX_LOCK(vars);
+ if (pf)
+ result=(chan<pf->numchn)?pf->control[chan].main.period:0;
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+BOOL Player_Paused_internal(void)
+{
+ return pf?pf->forbid:1;
+}
+
+MIKMODAPI BOOL Player_Paused(void)
+{
+ BOOL result;
+
+ MUTEX_LOCK(vars);
+ result=Player_Paused_internal();
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI void Player_TogglePause(void)
+{
+ MUTEX_LOCK(vars);
+ if (pf)
+ pf->forbid=1-pf->forbid;
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void Player_SetSpeed(UWORD speed)
+{
+ MUTEX_LOCK(vars);
+ if (pf)
+ pf->sngspd=speed?(speed<32?speed:32):1;
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI void Player_SetTempo(UWORD tempo)
+{
+ if (tempo<32) tempo=32;
+ MUTEX_LOCK(vars);
+ if (pf) {
+ if ((!(pf->flags&UF_HIGHBPM))&&(tempo>255)) tempo=255;
+ pf->bpm=tempo;
+ }
+ MUTEX_UNLOCK(vars);
+}
+
+MIKMODAPI int Player_QueryVoices(UWORD numvoices, VOICEINFO *vinfo)
+{
+ int i;
+
+ if (numvoices > md_sngchn)
+ numvoices = md_sngchn;
+
+ MUTEX_LOCK(vars);
+ if (pf)
+ for (i = 0; i < md_sngchn; i++) {
+ vinfo [i].i = pf->voice[i].main.i;
+ vinfo [i].s = pf->voice[i].main.s;
+ vinfo [i].panning = pf->voice [i].main.panning;
+ vinfo [i].volume = pf->voice [i].main.chanvol;
+ vinfo [i].period = pf->voice [i].main.period;
+ vinfo [i].kick = pf->voice [i].main.kick_flag;
+ pf->voice [i].main.kick_flag = 0;
+ }
+ MUTEX_UNLOCK(vars);
+
+ return numvoices;
+}
+
+/* Get current module order */
+MIKMODAPI int Player_GetOrder(void)
+{
+ int ret;
+ MUTEX_LOCK(vars);
+ ret = pf ? pf->sngpos :0; /* pf->positions[pf->sngpos ? pf->sngpos-1 : 0]: 0; */
+ MUTEX_UNLOCK(vars);
+ return ret;
+}
+
+/* Get current module row */
+MIKMODAPI int Player_GetRow(void)
+{
+ int ret;
+ MUTEX_LOCK(vars);
+ ret = pf ? pf->patpos : 0;
+ MUTEX_UNLOCK(vars);
+ return ret;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ All routines dealing with the manipulation of UNITRK streams
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+#include <string.h>
+
+/* Unibuffer chunk size */
+#define BUFPAGE 128
+
+const UWORD unioperands[UNI_LAST] = {
+ 0, /* not used */
+ 1, /* UNI_NOTE */
+ 1, /* UNI_INSTRUMENT */
+ 1, /* UNI_PTEFFECT0 */
+ 1, /* UNI_PTEFFECT1 */
+ 1, /* UNI_PTEFFECT2 */
+ 1, /* UNI_PTEFFECT3 */
+ 1, /* UNI_PTEFFECT4 */
+ 1, /* UNI_PTEFFECT5 */
+ 1, /* UNI_PTEFFECT6 */
+ 1, /* UNI_PTEFFECT7 */
+ 1, /* UNI_PTEFFECT8 */
+ 1, /* UNI_PTEFFECT9 */
+ 1, /* UNI_PTEFFECTA */
+ 1, /* UNI_PTEFFECTB */
+ 1, /* UNI_PTEFFECTC */
+ 1, /* UNI_PTEFFECTD */
+ 1, /* UNI_PTEFFECTE */
+ 1, /* UNI_PTEFFECTF */
+ 1, /* UNI_S3MEFFECTA */
+ 1, /* UNI_S3MEFFECTD */
+ 1, /* UNI_S3MEFFECTE */
+ 1, /* UNI_S3MEFFECTF */
+ 1, /* UNI_S3MEFFECTI */
+ 1, /* UNI_S3MEFFECTQ */
+ 1, /* UNI_S3MEFFECTR */
+ 1, /* UNI_S3MEFFECTT */
+ 1, /* UNI_S3MEFFECTU */
+ 0, /* UNI_KEYOFF */
+ 1, /* UNI_KEYFADE */
+ 2, /* UNI_VOLEFFECTS */
+ 1, /* UNI_XMEFFECT4 */
+ 1, /* UNI_XMEFFECT6 */
+ 1, /* UNI_XMEFFECTA */
+ 1, /* UNI_XMEFFECTE1 */
+ 1, /* UNI_XMEFFECTE2 */
+ 1, /* UNI_XMEFFECTEA */
+ 1, /* UNI_XMEFFECTEB */
+ 1, /* UNI_XMEFFECTG */
+ 1, /* UNI_XMEFFECTH */
+ 1, /* UNI_XMEFFECTL */
+ 1, /* UNI_XMEFFECTP */
+ 1, /* UNI_XMEFFECTX1 */
+ 1, /* UNI_XMEFFECTX2 */
+ 1, /* UNI_ITEFFECTG */
+ 1, /* UNI_ITEFFECTH */
+ 1, /* UNI_ITEFFECTI */
+ 1, /* UNI_ITEFFECTM */
+ 1, /* UNI_ITEFFECTN */
+ 1, /* UNI_ITEFFECTP */
+ 1, /* UNI_ITEFFECTT */
+ 1, /* UNI_ITEFFECTU */
+ 1, /* UNI_ITEFFECTW */
+ 1, /* UNI_ITEFFECTY */
+ 2, /* UNI_ITEFFECTZ */
+ 1, /* UNI_ITEFFECTS0 */
+ 2, /* UNI_ULTEFFECT9 */
+ 2, /* UNI_MEDSPEED */
+ 0, /* UNI_MEDEFFECTF1 */
+ 0, /* UNI_MEDEFFECTF2 */
+ 0, /* UNI_MEDEFFECTF3 */
+ 2, /* UNI_OKTARP */
+};
+
+/* Sparse description of the internal module format
+ ------------------------------------------------
+
+ A UNITRK stream is an array of bytes representing a single track of a pattern.
+It's made up of 'repeat/length' bytes, opcodes and operands (sort of a assembly
+language):
+
+rrrlllll
+[REP/LEN][OPCODE][OPERAND][OPCODE][OPERAND] [REP/LEN][OPCODE][OPERAND]..
+^ ^ ^
+|-------ROWS 0 - 0+REP of a track---------| |-------ROWS xx - xx+REP of a track...
+
+ The rep/len byte contains the number of bytes in the current row, _including_
+the length byte itself (So the LENGTH byte of row 0 in the previous example
+would have a value of 5). This makes it easy to search through a stream for a
+particular row. A track is concluded by a 0-value length byte.
+
+ The upper 3 bits of the rep/len byte contain the number of times -1 this row
+is repeated for this track. (so a value of 7 means this row is repeated 8 times)
+
+ Opcodes can range from 1 to 255 but currently only opcodes 1 to 62 are being
+used. Each opcode can have a different number of operands. You can find the
+number of operands to a particular opcode by using the opcode as an index into
+the 'unioperands' table.
+
+*/
+
+/*========== Reading routines */
+
+static UBYTE *rowstart; /* startadress of a row */
+static UBYTE *rowend; /* endaddress of a row (exclusive) */
+static UBYTE *rowpc; /* current unimod(tm) programcounter */
+
+static UBYTE lastbyte; /* for UniSkipOpcode() */
+
+void UniSetRow(UBYTE* t)
+{
+ rowstart = t;
+ rowpc = rowstart;
+ rowend = t?rowstart+(*(rowpc++)&0x1f):t;
+}
+
+UBYTE UniGetByte(void)
+{
+ return lastbyte = (rowpc<rowend)?*(rowpc++):0;
+}
+
+UWORD UniGetWord(void)
+{
+ return ((UWORD)UniGetByte()<<8)|UniGetByte();
+}
+
+void UniSkipOpcode(void)
+{
+ if (lastbyte < UNI_LAST) {
+ UWORD t = unioperands[lastbyte];
+
+ while (t--)
+ UniGetByte();
+ }
+}
+
+/* Finds the address of row number 'row' in the UniMod(tm) stream 't' returns
+ NULL if the row can't be found. */
+UBYTE *UniFindRow(UBYTE* t,UWORD row)
+{
+ UBYTE c,l;
+
+ if(t)
+ while(1) {
+ c = *t; /* get rep/len byte */
+ if(!c) return NULL; /* zero ? -> end of track.. */
+ l = (c>>5)+1; /* extract repeat value */
+ if(l>row) break; /* reached wanted row? -> return pointer */
+ row -= l; /* haven't reached row yet.. update row */
+ t += c&0x1f; /* point t to the next row */
+ }
+ return t;
+}
+
+/*========== Writing routines */
+
+static UBYTE *unibuf; /* pointer to the temporary unitrk buffer */
+static UWORD unimax; /* buffer size */
+
+static UWORD unipc; /* buffer cursor */
+static UWORD unitt; /* current row index */
+static UWORD lastp; /* previous row index */
+
+/* Resets index-pointers to create a new track. */
+void UniReset(void)
+{
+ unitt = 0; /* reset index to rep/len byte */
+ unipc = 1; /* first opcode will be written to index 1 */
+ lastp = 0; /* no previous row yet */
+ unibuf[0] = 0; /* clear rep/len byte */
+}
+
+/* Expands the buffer */
+static BOOL UniExpand(int wanted)
+{
+ if ((unipc+wanted)>=unimax) {
+ UBYTE *newbuf;
+
+ /* Expand the buffer by BUFPAGE bytes */
+ newbuf=(UBYTE*)MikMod_realloc(unibuf,(unimax+BUFPAGE)*sizeof(UBYTE));
+
+ /* Check if MikMod_realloc succeeded */
+ if(newbuf) {
+ unibuf = newbuf;
+ unimax+=BUFPAGE;
+ return 1;
+ } else
+ return 0;
+ }
+ return 1;
+}
+
+/* Appends one byte of data to the current row of a track. */
+void UniWriteByte(UBYTE data)
+{
+ if (UniExpand(1))
+ /* write byte to current position and update */
+ unibuf[unipc++]=data;
+}
+
+void UniWriteWord(UWORD data)
+{
+ if (UniExpand(2)) {
+ unibuf[unipc++]=data>>8;
+ unibuf[unipc++]=data&0xff;
+ }
+}
+
+static BOOL MyCmp(const UBYTE* a,const UBYTE* b,UWORD l)
+{
+ UWORD t;
+
+ for(t=0;t<l;t++)
+ if(*(a++)!=*(b++)) return 0;
+ return 1;
+}
+
+/* Closes the current row of a unitrk stream (updates the rep/len byte) and sets
+ pointers to start a new row. */
+void UniNewline(void)
+{
+ UWORD n,l,len;
+
+ n = (unibuf[lastp]>>5)+1; /* repeat of previous row */
+ l = (unibuf[lastp]&0x1f); /* length of previous row */
+
+ len = unipc-unitt; /* length of current row */
+
+ /* Now, check if the previous and the current row are identical.. when they
+ are, just increase the repeat field of the previous row */
+ if(n<8 && len==l && MyCmp(&unibuf[lastp+1],&unibuf[unitt+1],len-1)) {
+ unibuf[lastp]+=0x20;
+ unipc = unitt+1;
+ } else {
+ if (UniExpand(unitt-unipc)) {
+ /* current and previous row aren't equal... update the pointers */
+ unibuf[unitt] = len;
+ lastp = unitt;
+ unitt = unipc++;
+ }
+ }
+}
+
+/* Terminates the current unitrk stream and returns a pointer to a copy of the
+ stream. */
+UBYTE* UniDup(void)
+{
+ void *d;
+
+ if (!UniExpand(unipc-unitt)) return NULL;
+ unibuf[unitt] = 0;
+
+ if(!(d=MikMod_malloc(unipc))) return NULL;
+ memcpy(d,unibuf,unipc);
+
+ return (UBYTE *)d;
+}
+
+BOOL UniInit(void)
+{
+ unimax = BUFPAGE;
+
+ if(!(unibuf=(UBYTE*)MikMod_malloc(unimax*sizeof(UBYTE)))) return 0;
+ return 1;
+}
+
+void UniCleanup(void)
+{
+ MikMod_free(unibuf);
+ unibuf = NULL;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 2004, Raphael Assenat
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ WAV sample loader
+
+==============================================================================*/
+
+/*
+ FIXME: Stereo .WAV files are not yet supported as samples.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+#ifdef SUNOS
+extern int fprintf(FILE *, const char *, ...);
+#endif
+
+static void extract_channel(const char *src, char *dst, int num_chan, int num_samples, int samp_size, int channel);
+
+
+typedef struct WAV {
+ CHAR rID[4];
+ ULONG rLen;
+ CHAR wID[4];
+ CHAR fID[4];
+ ULONG fLen;
+ UWORD wFormatTag;
+ UWORD nChannels;
+ ULONG nSamplesPerSec;
+ ULONG nAvgBytesPerSec;
+ UWORD nBlockAlign;
+ UWORD nFormatSpecific;
+} WAV;
+
+static BOOL isWaveFile(MREADER* reader)
+{
+ WAV wh;
+
+ _mm_fseek(reader, SEEK_SET, 0);
+
+ /* read wav header */
+ _mm_read_string(wh.rID,4,reader);
+ wh.rLen = _mm_read_I_ULONG(reader);
+ _mm_read_string(wh.wID,4,reader);
+
+ /* check for correct header */
+ if(_mm_eof(reader)|| memcmp(wh.rID,"RIFF",4) || memcmp(wh.wID,"WAVE",4)) {
+ return 0;
+ }
+ return 1;
+}
+
+static SAMPLE* Sample_LoadGeneric_internal_wav(MREADER* reader)
+{
+ SAMPLE *si=NULL;
+ WAV wh;
+ BOOL have_fmt=0;
+
+ _mm_fseek(reader, SEEK_SET, 0);
+
+ /* read wav header */
+ _mm_read_string(wh.rID,4,reader);
+ wh.rLen = _mm_read_I_ULONG(reader);
+ _mm_read_string(wh.wID,4,reader);
+
+ /* check for correct header */
+ if(_mm_eof(reader)|| memcmp(wh.rID,"RIFF",4) || memcmp(wh.wID,"WAVE",4)) {
+ _mm_errno = MMERR_UNKNOWN_WAVE_TYPE;
+ return NULL;
+ }
+
+ /* scan all RIFF blocks until we find the sample data */
+ for(;;) {
+ CHAR dID[4];
+ ULONG len,start;
+
+ _mm_read_string(dID,4,reader);
+ len = _mm_read_I_ULONG(reader);
+ /* truncated file ? */
+ if (_mm_eof(reader)) {
+ _mm_errno=MMERR_UNKNOWN_WAVE_TYPE;
+ return NULL;
+ }
+ start = _mm_ftell(reader);
+
+ /* sample format block
+ should be present only once and before a data block */
+ if(!memcmp(dID,"fmt ",4)) {
+ wh.wFormatTag = _mm_read_I_UWORD(reader);
+ wh.nChannels = _mm_read_I_UWORD(reader);
+ wh.nSamplesPerSec = _mm_read_I_ULONG(reader);
+ wh.nAvgBytesPerSec = _mm_read_I_ULONG(reader);
+ wh.nBlockAlign = _mm_read_I_UWORD(reader);
+ wh.nFormatSpecific = _mm_read_I_UWORD(reader);
+
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr,"\rwavloader : wFormatTag=%04x blockalign=%04x nFormatSpc=%04x\n",
+ wh.wFormatTag,wh.nBlockAlign,wh.nFormatSpecific);
+#endif
+
+ if((have_fmt)||(wh.nChannels>1)) {
+ _mm_errno=MMERR_UNKNOWN_WAVE_TYPE;
+ return NULL;
+ }
+ have_fmt=1;
+ } else
+ /* sample data block
+ should be present only once and after a format block */
+ if(!memcmp(dID,"data",4)) {
+ if(!have_fmt) {
+ _mm_errno=MMERR_UNKNOWN_WAVE_TYPE;
+ return NULL;
+ }
+ if(!(si=(SAMPLE*)MikMod_malloc(sizeof(SAMPLE)))) return NULL;
+ si->speed = wh.nSamplesPerSec/wh.nChannels;
+ si->volume = 64;
+ si->length = len;
+ if(wh.nBlockAlign == 2) {
+ si->flags = SF_16BITS | SF_SIGNED;
+ si->length >>= 1;
+ }
+ si->inflags = si->flags;
+ SL_RegisterSample(si,MD_SNDFX,reader);
+ SL_LoadSamples();
+
+ /* skip any other remaining blocks - so in case of repeated sample
+ fragments, we'll return the first anyway instead of an error */
+ break;
+ }
+ /* onto next block */
+ _mm_fseek(reader,start+len,SEEK_SET);
+ if (_mm_eof(reader))
+ break;
+ }
+
+ return si;
+}
+
+static SAMPLE* Sample_LoadRawGeneric_internal(MREADER* reader, ULONG rate, ULONG channel, ULONG flags)
+{
+ SAMPLE *si;
+ long len;
+ int samp_size=1;
+
+ if(!(si=(SAMPLE*)MikMod_malloc(sizeof(SAMPLE)))) return NULL;
+
+ /* length */
+ _mm_fseek(reader, 0, SEEK_END);
+ len = _mm_ftell(reader);
+
+ si->panning = PAN_CENTER;
+ si->speed = rate/1;
+ si->volume = 64;
+ si->length = len;
+ si->loopstart=0;
+ si->loopend = len;
+ si->susbegin = 0;
+ si->susend = 0;
+ si->inflags = si->flags = flags;
+ if (si->flags & SF_16BITS) {
+ si->length >>= 1;
+ si->loopstart >>= 1;
+ si->loopend >>= 1;
+ samp_size = 2;
+ }
+
+ if (si->flags & SF_STEREO)
+ {
+ char *data, *channel_data;
+ int num_samp = si->length/samp_size/2;
+ MREADER *chn_reader;
+
+ data = (char*)MikMod_malloc(si->length);
+ if (!data) { MikMod_free(si); return NULL; }
+
+ channel_data = (char*)MikMod_malloc(si->length/2);
+ if (!channel_data) { MikMod_free(data); MikMod_free(si); return NULL; }
+
+ /* load the raw samples completely, and fully extract the
+ * requested channel. Create a memory reader pointing to
+ * the channel data. */
+ _mm_fseek(reader, 0, SEEK_SET);
+ reader->Read(reader, data, si->length);
+
+ extract_channel(data, channel_data, 2, num_samp, samp_size, channel);
+ chn_reader = _mm_new_mem_reader(channel_data, num_samp * samp_size);
+ if (!chn_reader) {
+ MikMod_free(channel_data);
+ MikMod_free(data);
+ MikMod_free(si);
+ return NULL;
+ }
+
+ /* half of the samples were in the other channel */
+ si->loopstart=0;
+ si->length=num_samp;
+ si->loopend=num_samp;
+
+ SL_RegisterSample(si, MD_SNDFX, chn_reader);
+ SL_LoadSamples();
+
+ _mm_delete_mem_reader(chn_reader);
+ MikMod_free(channel_data);
+ MikMod_free(data);
+
+ return si;
+ }
+
+ _mm_fseek(reader, 0, SEEK_SET);
+ SL_RegisterSample(si, MD_SNDFX, reader);
+ SL_LoadSamples();
+
+ return si;
+}
+
+static SAMPLE* Sample_LoadGeneric_internal(MREADER* reader, const char *options)
+{
+ if (isWaveFile(reader)) {
+ return Sample_LoadGeneric_internal_wav(reader);
+ }
+
+ return NULL;
+}
+
+MIKMODAPI SAMPLE* Sample_LoadRawGeneric(MREADER* reader, ULONG rate, ULONG channel, ULONG flags)
+{
+ SAMPLE* result;
+
+ MUTEX_LOCK(vars);
+ result = Sample_LoadRawGeneric_internal(reader, rate, channel, flags);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI SAMPLE *Sample_LoadRawMem(const char *buf, int len, ULONG rate, ULONG channel, ULONG flags)
+{
+ SAMPLE *result=NULL;
+ MREADER *reader;
+
+ if (!buf || len <= 0) return NULL;
+ if ((reader=_mm_new_mem_reader(buf, len)) != NULL) {
+ result=Sample_LoadRawGeneric(reader, rate, channel, flags);
+ _mm_delete_mem_reader(reader);
+ }
+ return result;
+}
+
+MIKMODAPI SAMPLE* Sample_LoadRawFP(FILE *fp, ULONG rate, ULONG channel, ULONG flags)
+{
+ SAMPLE* result=NULL;
+ MREADER* reader;
+
+ if(fp && (reader=_mm_new_file_reader(fp)) != NULL) {
+ result=Sample_LoadRawGeneric(reader, rate, channel, flags);
+ _mm_delete_file_reader(reader);
+ }
+ return result;
+}
+
+MIKMODAPI SAMPLE* Sample_LoadRaw(const CHAR* filename, ULONG rate, ULONG channel, ULONG flags)
+{
+ FILE *fp;
+ SAMPLE *si=NULL;
+
+ if(!(md_mode & DMODE_SOFT_SNDFX)) return NULL;
+ if((fp=_mm_fopen(filename,"rb")) != NULL) {
+ si = Sample_LoadRawFP(fp, rate, channel, flags);
+ _mm_fclose(fp);
+ }
+ return si;
+}
+
+MIKMODAPI SAMPLE* Sample_LoadGeneric(MREADER* reader)
+{
+ SAMPLE* result;
+
+ MUTEX_LOCK(vars);
+ result=Sample_LoadGeneric_internal(reader, NULL);
+ MUTEX_UNLOCK(vars);
+
+ return result;
+}
+
+MIKMODAPI SAMPLE *Sample_LoadMem(const char *buf, int len)
+{
+ SAMPLE* result=NULL;
+ MREADER* reader;
+
+ if (!buf || len <= 0) return NULL;
+ if ((reader=_mm_new_mem_reader(buf, len)) != NULL) {
+ result=Sample_LoadGeneric(reader);
+ _mm_delete_mem_reader(reader);
+ }
+ return result;
+}
+
+MIKMODAPI SAMPLE* Sample_LoadFP(FILE *fp)
+{
+ SAMPLE* result=NULL;
+ MREADER* reader;
+
+ if(fp && (reader=_mm_new_file_reader(fp)) != NULL) {
+ result=Sample_LoadGeneric(reader);
+ _mm_delete_file_reader(reader);
+ }
+ return result;
+}
+
+MIKMODAPI SAMPLE* Sample_Load(const CHAR* filename)
+{
+ FILE *fp;
+ SAMPLE *si=NULL;
+
+ if(!(md_mode & DMODE_SOFT_SNDFX)) return NULL;
+ if((fp=_mm_fopen(filename,"rb")) != NULL) {
+ si = Sample_LoadFP(fp);
+ _mm_fclose(fp);
+ }
+ return si;
+}
+
+MIKMODAPI void Sample_Free(SAMPLE* si)
+{
+ if(si) {
+ if (si->onfree) si->onfree(si->ctx);
+ MD_SampleUnload(si->handle);
+ MikMod_free(si);
+ }
+}
+
+void Sample_Free_internal(SAMPLE *si)
+{
+ MUTEX_LOCK(vars);
+ Sample_Free(si);
+ MUTEX_UNLOCK(vars);
+}
+
+static void extract_channel(const char *src, char *dst, int num_chan, int num_samples, int samp_size, int channel)
+{
+ int i;
+#ifdef MIKMOD_DEBUG
+ fprintf(stderr,"Extract channel: %p %p, num_chan=%d, num_samples=%d, samp_size=%d, channel=%d\n",
+ src,dst,num_chan,num_samples,samp_size,channel);
+#endif
+ src += channel * samp_size;
+
+ while (num_samples--)
+ {
+ for (i=0; i<samp_size; i++) {
+ dst[i] = src[i];
+ }
+ src += samp_size * num_chan;
+ dst += samp_size;
+ }
+}
+
+/* ex:set ts=8: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ MOD format period table. Used by both the MOD and M15 (15-inst mod) Loaders.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+
+const UWORD npertab[7 * OCTAVE] = {
+ /* Octaves 6 -> 0 */
+ /* C C# D D# E F F# G G# A A# B */
+ 0x6b0,0x650,0x5f4,0x5a0,0x54c,0x500,0x4b8,0x474,0x434,0x3f8,0x3c0,0x38a,
+ 0x358,0x328,0x2fa,0x2d0,0x2a6,0x280,0x25c,0x23a,0x21a,0x1fc,0x1e0,0x1c5,
+ 0x1ac,0x194,0x17d,0x168,0x153,0x140,0x12e,0x11d,0x10d,0x0fe,0x0f0,0x0e2,
+ 0x0d6,0x0ca,0x0be,0x0b4,0x0aa,0x0a0,0x097,0x08f,0x087,0x07f,0x078,0x071,
+ 0x06b,0x065,0x05f,0x05a,0x055,0x050,0x04b,0x047,0x043,0x03f,0x03c,0x038,
+ 0x035,0x032,0x02f,0x02d,0x02a,0x028,0x025,0x023,0x021,0x01f,0x01e,0x01c,
+ 0x01b,0x019,0x018,0x016,0x015,0x014,0x013,0x012,0x011,0x010,0x00f,0x00e
+};
+
+/* ex:set ts=4: */
+
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Routines for loading samples. The sample loader utilizes the routines
+ provided by the "registered" sample loader.
+
+==============================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "mikmod_internals.h"
+
+static int sl_rlength;
+static SWORD sl_old;
+static SWORD *sl_buffer=NULL;
+static SAMPLOAD *musiclist=NULL,*sndfxlist=NULL;
+
+/* size of the loader buffer in words */
+#define SLBUFSIZE 2048
+
+/* IT-Compressed status structure */
+typedef struct ITPACK {
+ UWORD bits; /* current number of bits */
+ UWORD bufbits; /* bits in buffer */
+ SWORD last; /* last output */
+ UBYTE buf; /* bit buffer */
+} ITPACK;
+
+BOOL SL_Init(SAMPLOAD* s)
+{
+ if(!sl_buffer)
+ if(!(sl_buffer=(SWORD*)MikMod_malloc(SLBUFSIZE*sizeof(SWORD)))) return 0;
+
+ sl_rlength = s->length;
+ if(s->infmt & SF_16BITS) sl_rlength>>=1;
+ sl_old = 0;
+
+ return 1;
+}
+
+void SL_Exit(SAMPLOAD *s)
+{
+ if(sl_rlength>0) _mm_fseek(s->reader,sl_rlength,SEEK_CUR);
+
+ MikMod_free(sl_buffer);
+ sl_buffer=NULL;
+}
+
+/* unpack a 8bit IT packed sample */
+static int read_itcompr8(ITPACK* status,MREADER *reader,SWORD *out,UWORD count,UWORD* incnt)
+{
+ SWORD *dest=out,*end=out+count;
+ UWORD x,y,needbits,havebits,new_count=0;
+ UWORD bits = status->bits;
+ UWORD bufbits = status->bufbits;
+ SBYTE last = status->last;
+ UBYTE buf = status->buf;
+
+ while (dest<end) {
+ needbits=new_count?3:bits;
+ x=havebits=0;
+ while (needbits) {
+ /* feed buffer */
+ if (!bufbits) {
+ if((*incnt)--)
+ buf=_mm_read_UBYTE(reader);
+ else
+ buf=0;
+ bufbits=8;
+ }
+ /* get as many bits as necessary */
+ y = needbits<bufbits?needbits:bufbits;
+ x|= (buf & ((1<<y)- 1))<<havebits;
+ buf>>=y;
+ bufbits-=y;
+ needbits-=y;
+ havebits+=y;
+ }
+ if (new_count) {
+ new_count = 0;
+ if (++x >= bits)
+ x++;
+ bits = x;
+ continue;
+ }
+ if (bits<7) {
+ if (x==(1<<(bits-1))) {
+ new_count = 1;
+ continue;
+ }
+ }
+ else if (bits<9) {
+ y = (0xff >> (9-bits)) - 4;
+ if ((x>y)&&(x<=y+8)) {
+ if ((x-=y)>=bits)
+ x++;
+ bits = x;
+ continue;
+ }
+ }
+ else if (bits<10) {
+ if (x>=0x100) {
+ bits=x-0x100+1;
+ continue;
+ }
+ } else {
+ /* error in compressed data... */
+ _mm_errno=MMERR_ITPACK_INVALID_DATA;
+ return 0;
+ }
+
+ if (bits<8) /* extend sign */
+ x = ((SBYTE)(x <<(8-bits))) >> (8-bits);
+ *(dest++)= (last+=x) << 8; /* convert to 16 bit */
+ }
+ status->bits = bits;
+ status->bufbits = bufbits;
+ status->last = last;
+ status->buf = buf;
+ return (dest-out);
+}
+
+/* unpack a 16bit IT packed sample */
+static int read_itcompr16(ITPACK *status,MREADER *reader,SWORD *out,UWORD count,UWORD* incnt)
+{
+ SWORD *dest=out,*end=out+count;
+ SLONG x,y,needbits,havebits,new_count=0;
+ UWORD bits = status->bits;
+ UWORD bufbits = status->bufbits;
+ SWORD last = status->last;
+ UBYTE buf = status->buf;
+
+ while (dest<end) {
+ needbits=new_count?4:bits;
+ x=havebits=0;
+ while (needbits) {
+ /* feed buffer */
+ if (!bufbits) {
+ if((*incnt)--)
+ buf=_mm_read_UBYTE(reader);
+ else
+ buf=0;
+ bufbits=8;
+ }
+ /* get as many bits as necessary */
+ y=needbits<bufbits?needbits:bufbits;
+ x|=(buf &((1<<y)-1))<<havebits;
+ buf>>=y;
+ bufbits-=(UWORD)y;
+ needbits-=(UWORD)y;
+ havebits+=(UWORD)y;
+ }
+ if (new_count) {
+ new_count = 0;
+ if (++x >= bits)
+ x++;
+ bits = (UWORD)x;
+ continue;
+ }
+ if (bits<7) {
+ if (x==(1<<(bits-1))) {
+ new_count=1;
+ continue;
+ }
+ }
+ else if (bits<17) {
+ y=(0xffff>>(17-bits))-8;
+ if ((x>y)&&(x<=y+16)) {
+ if ((x-=y)>=bits)
+ x++;
+ bits = (UWORD)x;
+ continue;
+ }
+ }
+ else if (bits<18) {
+ if (x>=0x10000) {
+ bits=(UWORD)(x-0x10000+1);
+ continue;
+ }
+ } else {
+ /* error in compressed data... */
+ _mm_errno=MMERR_ITPACK_INVALID_DATA;
+ return 0;
+ }
+
+ if (bits<16) /* extend sign */
+ x = ((SWORD)(x<<(16-bits)))>>(16-bits);
+ *(dest++)=(last+=x);
+ }
+ status->bits = bits;
+ status->bufbits = bufbits;
+ status->last = last;
+ status->buf = buf;
+ return (dest-out);
+}
+
+static int SL_LoadInternal(void* buffer,UWORD infmt,UWORD outfmt,int scalefactor,ULONG length,MREADER* reader,BOOL dither)
+{
+ SBYTE *bptr = (SBYTE*)buffer;
+ SWORD *wptr = (SWORD*)buffer;
+ int stodo,t,u;
+
+ int result,c_block=0; /* compression bytes until next block */
+ ITPACK status;
+ UWORD incnt = 0;
+
+ status.buf = 0;
+ status.last = 0;
+ status.bufbits = 0;
+ status.bits = 0;
+
+ while(length) {
+ stodo=(length<SLBUFSIZE)?length:SLBUFSIZE;
+
+ if(infmt&SF_ITPACKED) {
+ sl_rlength=0;
+ if (!c_block) {
+ status.bits = (infmt & SF_16BITS) ? 17 : 9;
+ status.last = status.bufbits = 0;
+ incnt=_mm_read_I_UWORD(reader);
+ c_block = (infmt & SF_16BITS) ? 0x4000 : 0x8000;
+ if(infmt&SF_DELTA) sl_old=0;
+ }
+ if (infmt & SF_16BITS) {
+ if(!(result=read_itcompr16(&status,reader,sl_buffer,stodo,&incnt)))
+ return 1;
+ } else {
+ if(!(result=read_itcompr8(&status,reader,sl_buffer,stodo,&incnt)))
+ return 1;
+ }
+ if(result!=stodo) {
+ _mm_errno=MMERR_ITPACK_INVALID_DATA;
+ return 1;
+ }
+ c_block -= stodo;
+ } else {
+ if(infmt&SF_16BITS) {
+ if(infmt&SF_BIG_ENDIAN)
+ _mm_read_M_SWORDS(sl_buffer,stodo,reader);
+ else
+ _mm_read_I_SWORDS(sl_buffer,stodo,reader);
+ } else {
+ SBYTE *src;
+ SWORD *dest;
+
+ reader->Read(reader,sl_buffer,sizeof(SBYTE)*stodo);
+ src = (SBYTE*)sl_buffer;
+ dest = sl_buffer;
+ src += stodo;dest += stodo;
+
+ for(t=0;t<stodo;t++) {
+ src--;dest--;
+ *dest = (*src)<<8;
+ }
+ }
+ sl_rlength-=stodo;
+ }
+
+ if(infmt & SF_DELTA)
+ for(t=0;t<stodo;t++) {
+ sl_buffer[t] += sl_old;
+ sl_old = sl_buffer[t];
+ }
+
+ if((infmt^outfmt) & SF_SIGNED)
+ for(t=0;t<stodo;t++)
+ sl_buffer[t]^= 0x8000;
+
+ if(scalefactor) {
+ int idx = 0;
+ SLONG scaleval;
+
+ /* Sample Scaling... average values for better results. */
+ t= 0;
+ while(t<stodo && length) {
+ scaleval = 0;
+ for(u=scalefactor;u && t<stodo;u--,t++)
+ scaleval+=sl_buffer[t];
+ sl_buffer[idx++]=(UWORD)(scaleval/(scalefactor-u));
+ length--;
+ }
+ stodo = idx;
+ } else
+ length -= stodo;
+
+ if (dither) {
+ if((infmt & SF_STEREO) && !(outfmt & SF_STEREO)) {
+ /* dither stereo to mono, average together every two samples */
+ SLONG avgval;
+ int idx = 0;
+
+ t=0;
+ while(t<stodo && length) {
+ avgval=sl_buffer[t++];
+ avgval+=sl_buffer[t++];
+ sl_buffer[idx++]=(SWORD)(avgval>>1);
+ length-=2;
+ }
+ stodo = idx;
+ }
+ }
+
+ if(outfmt & SF_16BITS) {
+ for(t=0;t<stodo;t++)
+ *(wptr++)=sl_buffer[t];
+ } else {
+ for(t=0;t<stodo;t++)
+ *(bptr++)=sl_buffer[t]>>8;
+ }
+ }
+ return 0;
+}
+
+int SL_Load(void* buffer,SAMPLOAD *smp,ULONG length)
+{
+ return SL_LoadInternal(buffer,smp->infmt,smp->outfmt,smp->scalefactor,
+ length,smp->reader,0);
+}
+
+/* Registers a sample for loading when SL_LoadSamples() is called. */
+SAMPLOAD* SL_RegisterSample(SAMPLE* s,int type,MREADER* reader)
+{
+ SAMPLOAD *news,**samplist,*cruise;
+
+ if(type==MD_MUSIC) {
+ samplist = &musiclist;
+ cruise = musiclist;
+ } else
+ if (type==MD_SNDFX) {
+ samplist = &sndfxlist;
+ cruise = sndfxlist;
+ } else
+ return NULL;
+
+ /* Allocate and add structure to the END of the list */
+ if(!(news=(SAMPLOAD*)MikMod_malloc(sizeof(SAMPLOAD)))) return NULL;
+
+ if(cruise) {
+ while(cruise->next) cruise=cruise->next;
+ cruise->next = news;
+ } else
+ *samplist = news;
+
+ news->infmt = s->flags & SF_FORMATMASK;
+ news->outfmt = news->infmt;
+ news->reader = reader;
+ news->sample = s;
+ news->length = s->length;
+ news->loopstart = s->loopstart;
+ news->loopend = s->loopend;
+
+ return news;
+}
+
+static void FreeSampleList(SAMPLOAD* s)
+{
+ SAMPLOAD *old;
+
+ while(s) {
+ old = s;
+ s = s->next;
+ MikMod_free(old);
+ }
+}
+
+/* Returns the total amount of memory required by the samplelist queue. */
+static ULONG SampleTotal(SAMPLOAD* samplist,int type)
+{
+ int total = 0;
+
+ while(samplist) {
+ samplist->sample->flags=
+ (samplist->sample->flags&~SF_FORMATMASK)|samplist->outfmt;
+ total += MD_SampleLength(type,samplist->sample);
+ samplist=samplist->next;
+ }
+
+ return total;
+}
+
+static ULONG RealSpeed(SAMPLOAD *s)
+{
+ return(s->sample->speed/(s->scalefactor?s->scalefactor:1));
+}
+
+static int DitherSamples(SAMPLOAD* samplist,int type)
+{
+ SAMPLOAD *c2smp=NULL;
+ ULONG maxsize, speed;
+ SAMPLOAD *s;
+
+ if(!samplist) return 0;
+
+ if((maxsize=MD_SampleSpace(type)*1024) != 0)
+ while(SampleTotal(samplist,type)>maxsize) {
+ /* First Pass - check for any 16 bit samples */
+ s = samplist;
+ while(s) {
+ if(s->outfmt & SF_16BITS) {
+ SL_Sample16to8(s);
+ break;
+ }
+ s=s->next;
+ }
+ /* Second pass (if no 16bits found above) is to take the sample with
+ the highest speed and dither it by half. */
+ if(!s) {
+ s = samplist;
+ speed = 0;
+ while(s) {
+ if((s->sample->length) && (RealSpeed(s)>speed)) {
+ speed=RealSpeed(s);
+ c2smp=s;
+ }
+ s=s->next;
+ }
+ if (c2smp)
+ SL_HalveSample(c2smp,2);
+ }
+ }
+
+ /* Samples dithered, now load them ! */
+ s = samplist;
+ while(s) {
+ /* sample has to be loaded ? -> increase number of samples, allocate
+ memory and load sample. */
+ if(s->sample->length) {
+ if(s->sample->seekpos)
+ _mm_fseek(s->reader, s->sample->seekpos, SEEK_SET);
+
+ /* Call the sample load routine of the driver module. It has to
+ return a 'handle' (>=0) that identifies the sample. */
+ s->sample->handle = MD_SampleLoad(s, type);
+ s->sample->flags = (s->sample->flags & ~SF_FORMATMASK) | s->outfmt;
+ if(s->sample->handle<0) {
+ FreeSampleList(samplist);
+ if(_mm_errorhandler) _mm_errorhandler();
+ return 1;
+ }
+ }
+ s = s->next;
+ }
+
+ FreeSampleList(samplist);
+ return 0;
+}
+
+int SL_LoadSamples(void)
+{
+ int rc;
+
+ _mm_critical = 0;
+
+ if((!musiclist)&&(!sndfxlist)) return 0;
+ rc=DitherSamples(musiclist,MD_MUSIC)||DitherSamples(sndfxlist,MD_SNDFX);
+ musiclist=sndfxlist=NULL;
+
+ return rc;
+}
+
+void SL_Sample16to8(SAMPLOAD* s)
+{
+ s->outfmt &= ~SF_16BITS;
+ s->sample->flags = (s->sample->flags&~SF_FORMATMASK) | s->outfmt;
+}
+
+void SL_Sample8to16(SAMPLOAD* s)
+{
+ s->outfmt |= SF_16BITS;
+ s->sample->flags = (s->sample->flags&~SF_FORMATMASK) | s->outfmt;
+}
+
+void SL_SampleSigned(SAMPLOAD* s)
+{
+ s->outfmt |= SF_SIGNED;
+ s->sample->flags = (s->sample->flags&~SF_FORMATMASK) | s->outfmt;
+}
+
+void SL_SampleUnsigned(SAMPLOAD* s)
+{
+ s->outfmt &= ~SF_SIGNED;
+ s->sample->flags = (s->sample->flags&~SF_FORMATMASK) | s->outfmt;
+}
+
+void SL_HalveSample(SAMPLOAD* s,int factor)
+{
+ s->scalefactor=factor>0?factor:2;
+
+ s->sample->divfactor = s->scalefactor;
+ s->sample->length = s->length / s->scalefactor;
+ s->sample->loopstart = s->loopstart / s->scalefactor;
+ s->sample->loopend = s->loopend / s->scalefactor;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
+ AUTHORS for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Sample mixing routines, using a 32 bits mixing buffer.
+
+==============================================================================*/
+
+/*
+
+ Optional features include:
+ (a) 4-step reverb (for 16 bit output only)
+ (b) Interpolation of sample data during mixing
+ (c) Dolby Surround Sound
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+/*
+ Constant definitions
+ ====================
+
+ BITSHIFT
+ Controls the maximum volume of the sound output. All data is shifted
+ right by BITSHIFT after being mixed. Higher values result in quieter
+ sound and less chance of distortion.
+
+ REVERBERATION
+ Controls the duration of the reverb. Larger values represent a shorter
+ reverb loop. Smaller values extend the reverb but can result in more of
+ an echo-ish sound.
+
+*/
+
+#define BITSHIFT 9
+#define REVERBERATION 110000L
+
+#define FRACBITS 11
+#define FRACMASK ((1L<<FRACBITS)-1L)
+
+#define TICKLSIZE 8192
+#define TICKWSIZE (TICKLSIZE<<1)
+#define TICKBSIZE (TICKWSIZE<<1)
+
+#define CLICK_SHIFT 6
+#define CLICK_BUFFER (1L<<CLICK_SHIFT)
+
+#ifndef MIN
+#define MIN(a,b) (((a)<(b)) ? (a) : (b))
+#endif
+
+typedef struct VINFO {
+ UBYTE kick; /* =1 -> sample has to be restarted */
+ UBYTE active; /* =1 -> sample is playing */
+ UWORD flags; /* 16/8 bits looping/one-shot */
+ SWORD handle; /* identifies the sample */
+ ULONG start; /* start index */
+ ULONG size; /* samplesize */
+ ULONG reppos; /* loop start */
+ ULONG repend; /* loop end */
+ ULONG frq; /* current frequency */
+ int vol; /* current volume */
+ int pan; /* current panning position */
+
+ int rampvol;
+ int lvolsel,rvolsel; /* Volume factor in range 0-255 */
+ int oldlvol,oldrvol;
+
+ SLONGLONG current; /* current index in the sample */
+ SLONGLONG increment; /* increment value */
+} VINFO;
+
+static SWORD **Samples;
+static VINFO *vinf=NULL,*vnf;
+static long tickleft,samplesthatfit,vc_memory=0;
+static int vc_softchn;
+static SLONGLONG idxsize,idxlpos,idxlend;
+static SLONG *vc_tickbuf=NULL;
+static UWORD vc_mode;
+
+/* Reverb control variables */
+
+static int RVc1, RVc2, RVc3, RVc4, RVc5, RVc6, RVc7, RVc8;
+static ULONG RVRindex;
+
+/* For Mono or Left Channel */
+static SLONG *RVbufL1=NULL,*RVbufL2=NULL,*RVbufL3=NULL,*RVbufL4=NULL,
+ *RVbufL5=NULL,*RVbufL6=NULL,*RVbufL7=NULL,*RVbufL8=NULL;
+
+/* For Stereo only (Right Channel) */
+static SLONG *RVbufR1=NULL,*RVbufR2=NULL,*RVbufR3=NULL,*RVbufR4=NULL,
+ *RVbufR5=NULL,*RVbufR6=NULL,*RVbufR7=NULL,*RVbufR8=NULL;
+
+#ifdef NATIVE_64BIT_INT
+#define NATIVE SLONGLONG
+#else
+#define NATIVE SLONG
+#endif
+
+#if defined HAVE_SSE2 || defined HAVE_ALTIVEC
+
+# if !defined(NATIVE_64BIT_INT)
+static SINTPTR_T MixSIMDMonoNormal(const SWORD* srce,SLONG* dest,SINTPTR_T idx,SINTPTR_T increment,SINTPTR_T todo)
+{
+ /* TODO: */
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ }
+ return idx;
+}
+# endif /* !NATIVE_64BIT_INT */
+
+static SINTPTR_T MixSIMDStereoNormal(const SWORD* srce,SLONG* dest,SINTPTR_T idx,SINTPTR_T increment,SINTPTR_T todo)
+{
+ SWORD vol[8] = {vnf->lvolsel, vnf->rvolsel};
+ SWORD sample;
+ SLONG remain = todo;
+
+ /* Dest can be misaligned */
+ while(!IS_ALIGNED_16(dest)) {
+ sample=srce[idx >> FRACBITS];
+ idx += increment;
+ *dest++ += vol[0] * sample;
+ *dest++ += vol[1] * sample;
+ todo--;
+ if(!todo) return idx;
+ }
+
+ /* Srce is always aligned */
+
+#if defined HAVE_SSE2
+ remain = todo&3;
+ {
+ __m128i v0 = _mm_set_epi16(0, vol[1],
+ 0, vol[0],
+ 0, vol[1],
+ 0, vol[0]);
+ for(todo>>=2;todo; todo--)
+ {
+ SWORD s0 = srce[idx >> FRACBITS];
+ SWORD s1 = srce[(idx += increment) >> FRACBITS];
+ SWORD s2 = srce[(idx += increment) >> FRACBITS];
+ SWORD s3 = srce[(idx += increment) >> FRACBITS];
+ __m128i v1 = _mm_set_epi16(0, s1, 0, s1, 0, s0, 0, s0);
+ __m128i v2 = _mm_set_epi16(0, s3, 0, s3, 0, s2, 0, s2);
+ __m128i v3 = _mm_load_si128((__m128i*)(dest+0));
+ __m128i v4 = _mm_load_si128((__m128i*)(dest+4));
+ _mm_store_si128((__m128i*)(dest+0), _mm_add_epi32(v3, _mm_madd_epi16(v0, v1)));
+ _mm_store_si128((__m128i*)(dest+4), _mm_add_epi32(v4, _mm_madd_epi16(v0, v2)));
+ dest+=8;
+ idx += increment;
+ }
+ }
+
+#elif defined HAVE_ALTIVEC
+ remain = todo&3;
+ {
+ SWORD s[8];
+ vector signed short r0 = vec_ld(0, vol);
+ vector signed short v0 = vec_perm(r0, r0, (vector unsigned char)(0, 1, /* l */
+ 0, 1, /* l */
+ 2, 3, /* r */
+ 2, 1, /* r */
+ 0, 1, /* l */
+ 0, 1, /* l */
+ 2, 3, /* r */
+ 2, 3 /* r */
+ ));
+
+ for(todo>>=2;todo; todo--)
+ {
+ vector short int r1;
+ vector signed short v1, v2;
+ vector signed int v3, v4, v5, v6;
+
+ /* Load constants */
+ s[0] = srce[idx >> FRACBITS];
+ s[1] = srce[(idx += increment) >> FRACBITS];
+ s[2] = srce[(idx += increment) >> FRACBITS];
+ s[3] = srce[(idx += increment) >> FRACBITS];
+ s[4] = 0;
+
+ r1 = vec_ld(0, s);
+ v1 = vec_perm(r1, r1, (vector unsigned char)
+ (0*2, 0*2+1, /* s0 */
+ 4*2, 4*2+1, /* 0 */
+ 0*2, 0*2+1, /* s0 */
+ 4*2, 4*2+1, /* 0 */
+ 1*2, 1*2+1, /* s1 */
+ 4*2, 4*2+1, /* 0 */
+ 1*2, 1*2+1, /* s1 */
+ 4*2, 4*2+1 /* 0 */
+ ) );
+ v2 = vec_perm(r1, r1, (vector unsigned char)
+ (2*2, 2*2+1, /* s2 */
+ 4*2, 4*2+1, /* 0 */
+ 2*2, 2*2+1, /* s2 */
+ 4*2, 4*2+1, /* 0 */
+ 3*2, 3*2+1, /* s3 */
+ 4*2, 4*2+1, /* 0 */
+ 3*2, 3*2+1, /* s3 */
+ 4*2, 4*2+1 /* 0 */
+ ) );
+
+ v3 = vec_ld(0, dest);
+ v4 = vec_ld(0, dest + 4);
+ v5 = vec_mule(v0, v1);
+ v6 = vec_mule(v0, v2);
+
+ vec_st(vec_add(v3, v5), 0, dest);
+ vec_st(vec_add(v4, v6), 0x10, dest);
+
+ dest+=8;
+ idx += increment;
+ }
+ }
+#endif /* HAVE_ALTIVEC */
+
+ /* Remaining bits */
+ while(remain--) {
+ sample=srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += vol[0] * sample;
+ *dest++ += vol[1] * sample;
+ }
+ return idx;
+}
+#endif
+
+/*========== 32 bit sample mixers - only for 32 bit platforms */
+#ifndef NATIVE_64BIT_INT
+
+static SLONG Mix32MonoNormal(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+ if (md_mode & DMODE_SIMDMIXER) {
+ return MixSIMDMonoNormal(srce, dest, idx, increment, todo);
+ }
+ else
+#endif
+ {
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ }
+ }
+ return idx;
+}
+
+/* FIXME: This mixer should works also on 64-bit platform */
+/* Hint : changes SLONG / SLONGLONG mess with intptr */
+static SLONG Mix32StereoNormal(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+ if (md_mode & DMODE_SIMDMIXER) {
+ return MixSIMDStereoNormal(srce, dest, idx, increment, todo);
+ }
+ else
+#endif
+ {
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+
+ while(todo--) {
+ sample=srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ *dest++ += rvolsel * sample;
+ }
+ }
+ return idx;
+}
+
+static SLONG Mix32SurroundNormal(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+
+ if (lvolsel>=rvolsel) {
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel*sample;
+ *dest++ -= lvolsel*sample;
+ }
+ }
+ else {
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ -= rvolsel*sample;
+ *dest++ += rvolsel*sample;
+ }
+ }
+ return idx;
+}
+
+static SLONG Mix32MonoInterp(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rampvol = vnf->rampvol;
+
+ if (rampvol) {
+ SLONG oldlvol = vnf->oldlvol - lvolsel;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += ((lvolsel << CLICK_SHIFT) + oldlvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONG Mix32StereoInterp(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+ SLONG rampvol = vnf->rampvol;
+
+ if (rampvol) {
+ SLONG oldlvol = vnf->oldlvol - lvolsel;
+ SLONG oldrvol = vnf->oldrvol - rvolsel;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += ((lvolsel << CLICK_SHIFT) + oldlvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ *dest++ += ((rvolsel << CLICK_SHIFT) + oldrvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ *dest++ += rvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONG Mix32SurroundInterp(const SWORD* srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+ SLONG rampvol = vnf->rampvol;
+ SLONG oldvol, vol;
+
+ if (lvolsel >= rvolsel) {
+ vol = lvolsel;
+ oldvol = vnf->oldlvol;
+ } else {
+ vol = rvolsel;
+ oldvol = vnf->oldrvol;
+ }
+
+ if (rampvol) {
+ oldvol -= vol;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ sample=((vol << CLICK_SHIFT) + oldvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ *dest++ += sample;
+ *dest++ -= sample;
+
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += vol*sample;
+ *dest++ -= vol*sample;
+ }
+ return idx;
+}
+#endif
+
+/*========== 64 bit sample mixers - all platforms */
+
+static SLONGLONG MixMonoNormal(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONGLONG MixStereoNormal(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+
+ while(todo--) {
+ sample=srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ *dest++ += rvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONGLONG MixSurroundNormal(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SWORD sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+
+ if(vnf->lvolsel>=vnf->rvolsel) {
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ += lvolsel*sample;
+ *dest++ -= lvolsel*sample;
+ }
+ }
+ else {
+ while(todo--) {
+ sample = srce[idx >> FRACBITS];
+ idx += increment;
+
+ *dest++ -= rvolsel*sample;
+ *dest++ += rvolsel*sample;
+ }
+ }
+ return idx;
+}
+
+static SLONGLONG MixMonoInterp(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rampvol = vnf->rampvol;
+
+ if (rampvol) {
+ SLONG oldlvol = vnf->oldlvol - lvolsel;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += ((lvolsel << CLICK_SHIFT) + oldlvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONGLONG MixStereoInterp(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+ SLONG rampvol = vnf->rampvol;
+
+ if (rampvol) {
+ SLONG oldlvol = vnf->oldlvol - lvolsel;
+ SLONG oldrvol = vnf->oldrvol - rvolsel;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ +=((lvolsel << CLICK_SHIFT) + oldlvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ *dest++ +=((rvolsel << CLICK_SHIFT) + oldrvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += lvolsel * sample;
+ *dest++ += rvolsel * sample;
+ }
+ return idx;
+}
+
+static SLONGLONG MixSurroundInterp(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SLONG sample;
+ SLONG lvolsel = vnf->lvolsel;
+ SLONG rvolsel = vnf->rvolsel;
+ SLONG rampvol = vnf->rampvol;
+ SLONG oldvol, vol;
+
+ if (lvolsel >= rvolsel) {
+ vol = lvolsel;
+ oldvol = vnf->oldlvol;
+ } else {
+ vol = rvolsel;
+ oldvol = vnf->oldrvol;
+ }
+
+ if (rampvol) {
+ oldvol -= vol;
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ sample=((vol << CLICK_SHIFT) + oldvol * rampvol)
+ * sample >> CLICK_SHIFT;
+ *dest++ += sample;
+ *dest++ -= sample;
+ if (!--rampvol)
+ break;
+ }
+ vnf->rampvol = rampvol;
+ if (todo < 0)
+ return idx;
+ }
+
+ while(todo--) {
+ sample=(SLONG)srce[idx>>FRACBITS]+
+ ((SLONG)(srce[(idx>>FRACBITS)+1]-srce[idx>>FRACBITS])
+ *(idx&FRACMASK)>>FRACBITS);
+ idx += increment;
+
+ *dest++ += vol*sample;
+ *dest++ -= vol*sample;
+ }
+ return idx;
+}
+
+static void (*MixReverb)(SLONG* srce,NATIVE count);
+
+/* Reverb macros */
+#define COMPUTE_LOC(n) loc##n = RVRindex % RVc##n
+#define COMPUTE_LECHO(n) RVbufL##n [loc##n ]=speedup+((ReverbPct*RVbufL##n [loc##n ])>>7)
+#define COMPUTE_RECHO(n) RVbufR##n [loc##n ]=speedup+((ReverbPct*RVbufR##n [loc##n ])>>7)
+
+static void MixReverb_Normal(SLONG* srce,NATIVE count)
+{
+ unsigned int speedup;
+ int ReverbPct;
+ unsigned int loc1,loc2,loc3,loc4;
+ unsigned int loc5,loc6,loc7,loc8;
+
+ ReverbPct=58+(md_reverb<<2);
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ while(count--) {
+ /* Compute the left channel echo buffers */
+ speedup = *srce >> 3;
+
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);
+
+ /* Prepare to compute actual finalized data */
+ RVRindex++;
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ /* left channel */
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];
+ }
+}
+
+static void MixReverb_Stereo(SLONG* srce,NATIVE count)
+{
+ unsigned int speedup;
+ int ReverbPct;
+ unsigned int loc1, loc2, loc3, loc4;
+ unsigned int loc5, loc6, loc7, loc8;
+
+ ReverbPct = 92+(md_reverb<<1);
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ while(count--) {
+ /* Compute the left channel echo buffers */
+ speedup = *srce >> 3;
+
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);
+
+ /* Compute the right channel echo buffers */
+ speedup = srce[1] >> 3;
+
+ COMPUTE_RECHO(1); COMPUTE_RECHO(2); COMPUTE_RECHO(3); COMPUTE_RECHO(4);
+ COMPUTE_RECHO(5); COMPUTE_RECHO(6); COMPUTE_RECHO(7); COMPUTE_RECHO(8);
+
+ /* Prepare to compute actual finalized data */
+ RVRindex++;
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ /* left channel then right channel */
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];
+
+ *srce++ +=RVbufR1[loc1]-RVbufR2[loc2]+RVbufR3[loc3]-RVbufR4[loc4]+
+ RVbufR5[loc5]-RVbufR6[loc6]+RVbufR7[loc7]-RVbufR8[loc8];
+ }
+}
+
+static void (*MixLowPass)(SLONG* srce,NATIVE count);
+
+static int nLeftNR, nRightNR;
+
+static void MixLowPass_Stereo(SLONG* srce,NATIVE count)
+{
+ int n1 = nLeftNR, n2 = nRightNR;
+ SLONG *pnr = srce;
+ int nr=count;
+ for (; nr; nr--)
+ {
+ int vnr = pnr[0] >> 1;
+ pnr[0] = vnr + n1;
+ n1 = vnr;
+ vnr = pnr[1] >> 1;
+ pnr[1] = vnr + n2;
+ n2 = vnr;
+ pnr += 2;
+ }
+ nLeftNR = n1;
+ nRightNR = n2;
+}
+
+static void MixLowPass_Normal(SLONG* srce,NATIVE count)
+{
+ int n1 = nLeftNR;
+ SLONG *pnr = srce;
+ int nr=count;
+ for (; nr; nr--)
+ {
+ int vnr = pnr[0] >> 1;
+ pnr[0] = vnr + n1;
+ n1 = vnr;
+ pnr ++;
+ }
+ nLeftNR = n1;
+}
+
+/* shifting fudge factor for FP scaling, should be 0 < FP_SHIFT < BITSHIFT */
+#define FP_SHIFT 4
+
+/* Mixing macros */
+#define EXTRACT_SAMPLE_FP(var,size) var=(*srce++>>(BITSHIFT-size)) * ((1.0f / 32768.0f) / (1 << size))
+#define CHECK_SAMPLE_FP(var,bound) var=(var>bound)?bound:(var<-bound)?-bound:var
+#define PUT_SAMPLE_FP(var) *dste++=var
+
+static void Mix32ToFP(float* dste,const SLONG *srce,NATIVE count)
+{
+ float x1,x2,x3,x4;
+ int remain;
+
+ remain=count&3;
+ for(count>>=2;count;count--) {
+ EXTRACT_SAMPLE_FP(x1,FP_SHIFT); EXTRACT_SAMPLE_FP(x2,FP_SHIFT);
+ EXTRACT_SAMPLE_FP(x3,FP_SHIFT); EXTRACT_SAMPLE_FP(x4,FP_SHIFT);
+
+ CHECK_SAMPLE_FP(x1,1.0f); CHECK_SAMPLE_FP(x2,1.0f);
+ CHECK_SAMPLE_FP(x3,1.0f); CHECK_SAMPLE_FP(x4,1.0f);
+
+ PUT_SAMPLE_FP(x1); PUT_SAMPLE_FP(x2);
+ PUT_SAMPLE_FP(x3); PUT_SAMPLE_FP(x4);
+ }
+ while(remain--) {
+ EXTRACT_SAMPLE_FP(x1,FP_SHIFT);
+ CHECK_SAMPLE_FP(x1,1.0f);
+ PUT_SAMPLE_FP(x1);
+ }
+}
+
+
+/* Mixing macros */
+#define EXTRACT_SAMPLE(var,size) var=*srce++>>(BITSHIFT+16-size)
+#define CHECK_SAMPLE(var,bound) var=(var>=bound)?bound-1:(var<-bound)?-bound:var
+#define PUT_SAMPLE(var) *dste++=var
+
+static void Mix32To16(SWORD* dste,const SLONG *srce,NATIVE count)
+{
+ SLONG x1,x2,x3,x4;
+ int remain;
+
+ remain=count&3;
+ for(count>>=2;count;count--) {
+ EXTRACT_SAMPLE(x1,16); EXTRACT_SAMPLE(x2,16);
+ EXTRACT_SAMPLE(x3,16); EXTRACT_SAMPLE(x4,16);
+
+ CHECK_SAMPLE(x1,32768); CHECK_SAMPLE(x2,32768);
+ CHECK_SAMPLE(x3,32768); CHECK_SAMPLE(x4,32768);
+
+ PUT_SAMPLE(x1); PUT_SAMPLE(x2); PUT_SAMPLE(x3); PUT_SAMPLE(x4);
+ }
+ while(remain--) {
+ EXTRACT_SAMPLE(x1,16);
+ CHECK_SAMPLE(x1,32768);
+ PUT_SAMPLE(x1);
+ }
+}
+
+static void Mix32To8(SBYTE* dste,const SLONG *srce,NATIVE count)
+{
+ SWORD x1,x2,x3,x4;
+ int remain;
+
+ remain=count&3;
+ for(count>>=2;count;count--) {
+ EXTRACT_SAMPLE(x1,8); EXTRACT_SAMPLE(x2,8);
+ EXTRACT_SAMPLE(x3,8); EXTRACT_SAMPLE(x4,8);
+
+ CHECK_SAMPLE(x1,128); CHECK_SAMPLE(x2,128);
+ CHECK_SAMPLE(x3,128); CHECK_SAMPLE(x4,128);
+
+ PUT_SAMPLE(x1+128); PUT_SAMPLE(x2+128);
+ PUT_SAMPLE(x3+128); PUT_SAMPLE(x4+128);
+ }
+ while(remain--) {
+ EXTRACT_SAMPLE(x1,8);
+ CHECK_SAMPLE(x1,128);
+ PUT_SAMPLE(x1+128);
+ }
+}
+
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+
+/* Mix 32bit input to floating point. 32 samples per iteration */
+/* PC: ?, Mac OK */
+static void Mix32ToFP_SIMD(float* dste,const SLONG* srce,NATIVE count)
+{
+ const float k = ((1.0f / 32768.0f) / (1 << FP_SHIFT));
+ int remain=count;
+ simd_m128 x1, x2, xk;
+
+ while(!IS_ALIGNED_16(dste) || !IS_ALIGNED_16(srce))
+ {
+ float xf;
+ EXTRACT_SAMPLE_FP(xf,FP_SHIFT);
+ CHECK_SAMPLE_FP(xf,1.0f);
+ PUT_SAMPLE_FP(xf);
+ count--;
+ if (!count) return;
+ }
+
+ remain = count&7;
+
+ xk = LOAD_PS1_SIMD(&k); /* Scale factor */
+
+ for(count>>=3;count;count--) {
+ EXTRACT_SAMPLE_SIMD_F(srce, x1, FP_SHIFT, xk); /* Load 4 samples */
+ EXTRACT_SAMPLE_SIMD_F(srce+4, x2, FP_SHIFT, xk); /* Load 4 samples */
+ PUT_SAMPLE_SIMD_F(dste, x1); /* Store 4 samples */
+ PUT_SAMPLE_SIMD_F(dste+4, x2); /* Store 4 samples */
+ srce+=8;
+ dste+=8;
+ }
+
+ if (remain&4) {
+ EXTRACT_SAMPLE_SIMD_F(srce, x1, FP_SHIFT, xk); /* Load 4 samples */
+ PUT_SAMPLE_SIMD_F(dste, x1); /* Store 4 samples */
+ srce+=4;
+ dste+=4;
+ remain &= 3;
+ }
+
+ while(remain--) {
+ float xf;
+ EXTRACT_SAMPLE_FP(xf,FP_SHIFT);
+ CHECK_SAMPLE_FP(xf,1.0f);
+ PUT_SAMPLE_FP(xf);
+ }
+}
+
+/* PC: Ok, Mac Ok */
+static void Mix32To16_SIMD(SWORD* dste,const SLONG* srce,NATIVE count)
+{
+ int remain = count;
+
+ while(!IS_ALIGNED_16(dste) || !IS_ALIGNED_16(srce))
+ {
+ SLONG x1;
+ EXTRACT_SAMPLE(x1,16);
+ CHECK_SAMPLE(x1,32768);
+ PUT_SAMPLE(x1);
+ count--;
+ if (!count) return;
+ }
+
+ remain = count&7;
+
+ for(count>>=3;count;count--)
+ {
+ simd_m128i x1,x2;
+ EXTRACT_SAMPLE_SIMD_16(srce, x1); /* Load 4 samples */
+ EXTRACT_SAMPLE_SIMD_16(srce+4, x2); /* Load 4 samples */
+ PUT_SAMPLE_SIMD_W(dste, x1, x2); /* Store 8 samples */
+ srce+=8;
+ dste+=8;
+ }
+
+ if (remain)
+ Mix32To16(dste, srce, remain);
+}
+
+/* Mix 32bit input to 8bit. 128 samples per iteration */
+/* PC:OK, Mac: Ok */
+static void Mix32To8_SIMD(SBYTE* dste,const SLONG* srce,NATIVE count)
+{
+ int remain=count;
+
+ while(!IS_ALIGNED_16(dste) || !IS_ALIGNED_16(srce))
+ {
+ SWORD x1;
+ EXTRACT_SAMPLE(x1,8);
+ CHECK_SAMPLE(x1,128);
+ PUT_SAMPLE(x1+128);
+ count--;
+ if (!count) return;
+ }
+
+ remain = count&15;
+
+ for(count>>=4;count;count--) {
+ simd_m128i x1,x2,x3,x4;
+ EXTRACT_SAMPLE_SIMD_8(srce, x1); /* Load 4 samples */
+ EXTRACT_SAMPLE_SIMD_8(srce+4, x2); /* Load 4 samples */
+ EXTRACT_SAMPLE_SIMD_8(srce+8, x3); /* Load 4 samples */
+ EXTRACT_SAMPLE_SIMD_8(srce+12, x4); /* Load 4 samples */
+ PUT_SAMPLE_SIMD_B(dste, x1, x2, x3, x4); /* Store 16 samples */
+ srce+=16;
+ dste+=16;
+ }
+
+ if (remain)
+ Mix32To8(dste, srce, remain);
+}
+
+#endif
+
+
+static void AddChannel(SLONG* ptr,NATIVE todo)
+{
+ SLONGLONG end,done;
+ SWORD *s;
+
+ if(!(s=Samples[vnf->handle])) {
+ vnf->current = vnf->active = 0;
+ return;
+ }
+
+ /* update the 'current' index so the sample loops, or stops playing if it
+ reached the end of the sample */
+ while(todo>0) {
+ SLONGLONG endpos;
+
+ if(vnf->flags & SF_REVERSE) {
+ /* The sample is playing in reverse */
+ if((vnf->flags&SF_LOOP)&&(vnf->current<idxlpos)) {
+ /* the sample is looping and has reached the loopstart index */
+ if(vnf->flags & SF_BIDI) {
+ /* sample is doing bidirectional loops, so 'bounce' the
+ current index against the idxlpos */
+ vnf->current = idxlpos+(idxlpos-vnf->current);
+ vnf->flags &= ~SF_REVERSE;
+ vnf->increment = -vnf->increment;
+ } else
+ /* normal backwards looping, so set the current position to
+ loopend index */
+ vnf->current=idxlend-(idxlpos-vnf->current);
+ } else {
+ /* the sample is not looping, so check if it reached index 0 */
+ if(vnf->current < 0) {
+ /* playing index reached 0, so stop playing this sample */
+ vnf->current = vnf->active = 0;
+ break;
+ }
+ }
+ } else {
+ /* The sample is playing forward */
+ if((vnf->flags & SF_LOOP) &&
+ (vnf->current >= idxlend)) {
+ /* the sample is looping, check the loopend index */
+ if(vnf->flags & SF_BIDI) {
+ /* sample is doing bidirectional loops, so 'bounce' the
+ current index against the idxlend */
+ vnf->flags |= SF_REVERSE;
+ vnf->increment = -vnf->increment;
+ vnf->current = idxlend-(vnf->current-idxlend);
+ } else
+ /* normal backwards looping, so set the current position
+ to loopend index */
+ vnf->current=idxlpos+(vnf->current-idxlend);
+ } else {
+ /* sample is not looping, so check if it reached the last
+ position */
+ if(vnf->current >= idxsize) {
+ /* yes, so stop playing this sample */
+ vnf->current = vnf->active = 0;
+ break;
+ }
+ }
+ }
+
+ end=(vnf->flags&SF_REVERSE)?(vnf->flags&SF_LOOP)?idxlpos:0:
+ (vnf->flags&SF_LOOP)?idxlend:idxsize;
+
+ /* if the sample is not blocked... */
+ if((end==vnf->current)||(!vnf->increment))
+ done=0;
+ else {
+ done=MIN((end-vnf->current)/vnf->increment+1,todo);
+ if(done<0) done=0;
+ }
+
+ if(!done) {
+ vnf->active = 0;
+ break;
+ }
+
+ endpos=vnf->current+done*vnf->increment;
+
+ if(vnf->vol) {
+#ifndef NATIVE_64BIT_INT
+ /* use the 32 bit mixers as often as we can (they're much faster) */
+ if((vnf->current<0x7fffffff)&&(endpos<0x7fffffff)) {
+ if((md_mode & DMODE_INTERP)) {
+ if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(md_mode&DMODE_SURROUND))
+ vnf->current=Mix32SurroundInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ vnf->current=Mix32StereoInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else
+ vnf->current=Mix32MonoInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(md_mode&DMODE_SURROUND))
+ vnf->current=Mix32SurroundNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ {
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+ if (md_mode & DMODE_SIMDMIXER)
+ vnf->current=MixSIMDStereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+#endif
+ vnf->current=Mix32StereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ } else
+ vnf->current=Mix32MonoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ else
+#endif
+ {
+ if((md_mode & DMODE_INTERP)) {
+ if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(md_mode&DMODE_SURROUND))
+ vnf->current=MixSurroundInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ vnf->current=MixStereoInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else
+ vnf->current=MixMonoInterp
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(md_mode&DMODE_SURROUND))
+ vnf->current=MixSurroundNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ {
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+ if (md_mode & DMODE_SIMDMIXER)
+ vnf->current=MixSIMDStereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+#endif
+ vnf->current=MixStereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ } else
+ vnf->current=MixMonoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ } else
+ /* update sample position */
+ vnf->current=endpos;
+
+ todo-=done;
+ ptr +=(vc_mode & DMODE_STEREO)?(done<<1):done;
+ }
+}
+
+#ifdef NO_HQMIXER
+#define VC_SetupPointers() do{}while(0)
+#define VC1_Init VC_Init
+#define VC1_Exit VC_Exit
+#define VC1_PlayStart VC_PlayStart
+#define VC1_PlayStop VC_PlayStop
+#define VC1_SampleLength VC_SampleLength
+#define VC1_SampleSpace VC_SampleSpace
+#define VC1_SampleLoad VC_SampleLoad
+#define VC1_SampleUnload VC_SampleUnload
+#define VC1_SetNumVoices VC_SetNumVoices
+#define VC1_SilenceBytes VC_SilenceBytes
+#define VC1_VoicePlay VC_VoicePlay
+#define VC1_VoiceStop VC_VoiceStop
+#define VC1_VoiceGetFrequency VC_VoiceGetFrequency
+#define VC1_VoiceGetPanning VC_VoiceGetPanning
+#define VC1_VoiceGetPosition VC_VoiceGetPosition
+#define VC1_VoiceGetVolume VC_VoiceGetVolume
+#define VC1_VoiceRealVolume VC_VoiceRealVolume
+#define VC1_VoiceSetFrequency VC_VoiceSetFrequency
+#define VC1_VoiceSetPanning VC_VoiceSetPanning
+#define VC1_VoiceSetVolume VC_VoiceSetVolume
+#define VC1_VoiceStopped VC_VoiceStopped
+#define VC1_WriteBytes VC_WriteBytes
+#define VC1_WriteSamples VC_WriteSamples
+#endif
+
+#define _IN_VIRTCH_
+#include "virtch_common.c"
+#undef _IN_VIRTCH_
+
+void VC1_WriteSamples(SBYTE* buf,ULONG todo)
+{
+ int left,portion=0,count;
+ SBYTE *buffer;
+ int t, pan, vol;
+
+ while(todo) {
+ if(!tickleft) {
+ if(vc_mode & DMODE_SOFT_MUSIC) md_player();
+ tickleft=(md_mixfreq*125L)/(md_bpm*50L);
+ }
+ left = MIN(tickleft, (long)todo);
+ buffer = buf;
+ tickleft -= left;
+ todo -= left;
+ buf += samples2bytes(left);
+
+ while(left) {
+ portion = MIN(left, samplesthatfit);
+ count = (vc_mode & DMODE_STEREO)?(portion<<1):portion;
+ memset(vc_tickbuf, 0, count<<2);
+ for(t=0;t<vc_softchn;t++) {
+ vnf = &vinf[t];
+
+ if(vnf->kick) {
+ vnf->current=((SLONGLONG)vnf->start)<<FRACBITS;
+ vnf->kick =0;
+ vnf->active =1;
+ }
+
+ if(!vnf->frq) vnf->active = 0;
+
+ if(vnf->active) {
+ vnf->increment=((SLONGLONG)(vnf->frq<<FRACBITS))/md_mixfreq;
+ if(vnf->flags&SF_REVERSE) vnf->increment=-vnf->increment;
+ vol = vnf->vol; pan = vnf->pan;
+
+ vnf->oldlvol=vnf->lvolsel;vnf->oldrvol=vnf->rvolsel;
+ if(vc_mode & DMODE_STEREO) {
+ if(pan != PAN_SURROUND) {
+ vnf->lvolsel=(vol*(PAN_RIGHT-pan))>>8;
+ vnf->rvolsel=(vol*pan)>>8;
+ } else
+ vnf->lvolsel=vnf->rvolsel=vol/2;
+ } else
+ vnf->lvolsel=vol;
+
+ idxsize = (vnf->size)? ((SLONGLONG)vnf->size << FRACBITS)-1 : 0;
+ idxlend = (vnf->repend)? ((SLONGLONG)vnf->repend << FRACBITS)-1 : 0;
+ idxlpos = (SLONGLONG)vnf->reppos << FRACBITS;
+ AddChannel(vc_tickbuf, portion);
+ }
+ }
+
+ if(md_mode & DMODE_NOISEREDUCTION) {
+ MixLowPass(vc_tickbuf, portion);
+ }
+
+ if(md_reverb) {
+ if(md_reverb>15) md_reverb=15;
+ MixReverb(vc_tickbuf, portion);
+ }
+
+ if (vc_callback) {
+ vc_callback((unsigned char*)vc_tickbuf, portion);
+ }
+
+#if defined HAVE_ALTIVEC || defined HAVE_SSE2
+ if (md_mode & DMODE_SIMDMIXER)
+ {
+ if(vc_mode & DMODE_FLOAT)
+ Mix32ToFP_SIMD((float*) buffer, vc_tickbuf, count);
+ else if(vc_mode & DMODE_16BITS)
+ Mix32To16_SIMD((SWORD*) buffer, vc_tickbuf, count);
+ else
+ Mix32To8_SIMD((SBYTE*) buffer, vc_tickbuf, count);
+ }
+ else
+#endif
+ {
+ if(vc_mode & DMODE_FLOAT)
+ Mix32ToFP((float*) buffer, vc_tickbuf, count);
+ else if(vc_mode & DMODE_16BITS)
+ Mix32To16((SWORD*) buffer, vc_tickbuf, count);
+ else
+ Mix32To8((SBYTE*) buffer, vc_tickbuf, count);
+ }
+ buffer += samples2bytes(portion);
+ left -= portion;
+ }
+ }
+}
+
+int VC1_Init(void)
+{
+#ifndef NO_HQMIXER
+ VC_SetupPointers();
+
+ if (md_mode&DMODE_HQMIXER)
+ return VC2_Init();
+#endif
+
+ if(!(Samples=(SWORD**)MikMod_amalloc(MAXSAMPLEHANDLES*sizeof(SWORD*)))) {
+ _mm_errno = MMERR_INITIALIZING_MIXER;
+ return 1;
+ }
+ if(!vc_tickbuf) {
+ if(!(vc_tickbuf=(SLONG*)MikMod_amalloc((TICKLSIZE+32)*sizeof(SLONG)))) {
+ _mm_errno = MMERR_INITIALIZING_MIXER;
+ return 1;
+ }
+ }
+
+ MixReverb=(md_mode&DMODE_STEREO)?MixReverb_Stereo:MixReverb_Normal;
+ MixLowPass=(md_mode&DMODE_STEREO)?MixLowPass_Stereo:MixLowPass_Normal;
+ vc_mode = md_mode;
+ return 0;
+}
+
+int VC1_PlayStart(void)
+{
+ samplesthatfit=TICKLSIZE;
+ if(vc_mode & DMODE_STEREO) samplesthatfit >>= 1;
+ tickleft = 0;
+
+ RVc1 = (5000L * md_mixfreq) / REVERBERATION;
+ RVc2 = (5078L * md_mixfreq) / REVERBERATION;
+ RVc3 = (5313L * md_mixfreq) / REVERBERATION;
+ RVc4 = (5703L * md_mixfreq) / REVERBERATION;
+ RVc5 = (6250L * md_mixfreq) / REVERBERATION;
+ RVc6 = (6953L * md_mixfreq) / REVERBERATION;
+ RVc7 = (7813L * md_mixfreq) / REVERBERATION;
+ RVc8 = (8828L * md_mixfreq) / REVERBERATION;
+
+ if(!(RVbufL1=(SLONG*)MikMod_calloc((RVc1+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL2=(SLONG*)MikMod_calloc((RVc2+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL3=(SLONG*)MikMod_calloc((RVc3+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL4=(SLONG*)MikMod_calloc((RVc4+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL5=(SLONG*)MikMod_calloc((RVc5+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL6=(SLONG*)MikMod_calloc((RVc6+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL7=(SLONG*)MikMod_calloc((RVc7+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL8=(SLONG*)MikMod_calloc((RVc8+1),sizeof(SLONG)))) return 1;
+
+ /* allocate reverb buffers for the right channel if in stereo mode only. */
+ if (vc_mode & DMODE_STEREO) {
+ if(!(RVbufR1=(SLONG*)MikMod_calloc((RVc1+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR2=(SLONG*)MikMod_calloc((RVc2+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR3=(SLONG*)MikMod_calloc((RVc3+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR4=(SLONG*)MikMod_calloc((RVc4+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR5=(SLONG*)MikMod_calloc((RVc5+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR6=(SLONG*)MikMod_calloc((RVc6+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR7=(SLONG*)MikMod_calloc((RVc7+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR8=(SLONG*)MikMod_calloc((RVc8+1),sizeof(SLONG)))) return 1;
+ }
+
+ RVRindex = 0;
+ return 0;
+}
+
+void VC1_PlayStop(void)
+{
+ MikMod_free(RVbufL1);
+ MikMod_free(RVbufL2);
+ MikMod_free(RVbufL3);
+ MikMod_free(RVbufL4);
+ MikMod_free(RVbufL5);
+ MikMod_free(RVbufL6);
+ MikMod_free(RVbufL7);
+ MikMod_free(RVbufL8);
+ RVbufL1=RVbufL2=RVbufL3=RVbufL4=RVbufL5=RVbufL6=RVbufL7=RVbufL8=NULL;
+ MikMod_free(RVbufR1);
+ MikMod_free(RVbufR2);
+ MikMod_free(RVbufR3);
+ MikMod_free(RVbufR4);
+ MikMod_free(RVbufR5);
+ MikMod_free(RVbufR6);
+ MikMod_free(RVbufR7);
+ MikMod_free(RVbufR8);
+ RVbufR1=RVbufR2=RVbufR3=RVbufR4=RVbufR5=RVbufR6=RVbufR7=RVbufR8=NULL;
+}
+
+int VC1_SetNumVoices(void)
+{
+ int t;
+
+ if(!(vc_softchn=md_softchn)) return 0;
+
+ MikMod_free(vinf);
+ if(!(vinf=(VINFO*)MikMod_calloc(vc_softchn,sizeof(VINFO)))) return 1;
+
+ for(t=0;t<vc_softchn;t++) {
+ vinf[t].frq=10000;
+ vinf[t].pan=(t&1)?PAN_LEFT:PAN_RIGHT;
+ }
+
+ return 0;
+}
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000 Miodrag Vallat and others - see file AUTHORS for
+ complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ High-quality sample mixing routines, using a 32 bits mixing buffer,
+ interpolation, and sample smoothing to improve sound quality and remove
+ clicks.
+
+==============================================================================*/
+
+/*
+
+ Future Additions:
+ Low-Pass filter to remove annoying staticy buzz.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifndef NO_HQMIXER
+
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif
+#include <string.h>
+
+#include "mikmod_internals.h"
+
+/*
+ Constant Definitions
+ ====================
+
+ MAXVOL_FACTOR (was BITSHIFT in virtch.c)
+ Controls the maximum volume of the output data. All mixed data is
+ divided by this number after mixing, so larger numbers result in
+ quieter mixing. Smaller numbers will increase the likeliness of
+ distortion on loud modules.
+
+ REVERBERATION
+ Larger numbers result in shorter reverb duration. Longer reverb
+ durations can cause unwanted static and make the reverb sound more
+ like a crappy echo.
+
+ SAMPLING_SHIFT
+ Specified the shift multiplier which controls by how much the mixing
+ rate is multiplied while mixing. Higher values can improve quality by
+ smoothing the sound and reducing pops and clicks. Note, this is a shift
+ value, so a value of 2 becomes a mixing-rate multiplier of 4, and a
+ value of 3 = 8, etc.
+
+ FRACBITS
+ The number of bits per integer devoted to the fractional part of the
+ number. Generally, this number should not be changed for any reason.
+
+ !!! IMPORTANT !!! All values below MUST ALWAYS be greater than 0
+
+*/
+
+#define BITSHIFT 9
+#define MAXVOL_FACTOR (1<<BITSHIFT)
+#define REVERBERATION 11000L
+
+#define SAMPLING_SHIFT 2
+#define SAMPLING_FACTOR (1UL<<SAMPLING_SHIFT)
+
+#define FRACBITS 28
+#define FRACMASK ((1UL<<FRACBITS)-1UL)
+
+#define TICKLSIZE 8192
+#define TICKWSIZE (TICKLSIZE * 2)
+#define TICKBSIZE (TICKWSIZE * 2)
+
+#define CLICK_SHIFT_BASE 6
+#define CLICK_SHIFT (CLICK_SHIFT_BASE + SAMPLING_SHIFT)
+#define CLICK_BUFFER (1L << CLICK_SHIFT)
+
+#ifndef MIN
+#define MIN(a,b) (((a)<(b)) ? (a) : (b))
+#endif
+
+typedef struct VINFO {
+ UBYTE kick; /* =1 -> sample has to be restarted */
+ UBYTE active; /* =1 -> sample is playing */
+ UWORD flags; /* 16/8 bits looping/one-shot */
+ SWORD handle; /* identifies the sample */
+ ULONG start; /* start index */
+ ULONG size; /* samplesize */
+ ULONG reppos; /* loop start */
+ ULONG repend; /* loop end */
+ ULONG frq; /* current frequency */
+ int vol; /* current volume */
+ int pan; /* current panning position */
+
+ int click;
+ int rampvol;
+ SLONG lastvalL,lastvalR;
+ int lvolsel,rvolsel; /* Volume factor in range 0-255 */
+ int oldlvol,oldrvol;
+
+ SLONGLONG current; /* current index in the sample */
+ SLONGLONG increment; /* increment value */
+} VINFO;
+
+static SWORD **Samples;
+static VINFO *vinf=NULL,*vnf;
+static long tickleft,samplesthatfit,vc_memory=0;
+static int vc_softchn;
+static SLONGLONG idxsize,idxlpos,idxlend;
+static SLONG *vc_tickbuf=NULL;
+static UWORD vc_mode;
+
+#ifdef _MSC_VER
+/* Weird bug in compiler */ /* FIXME is this still needed? */
+typedef void (*MikMod_callback_t)(unsigned char *data, size_t len);
+#endif
+
+/* Reverb control variables */
+
+static int RVc1, RVc2, RVc3, RVc4, RVc5, RVc6, RVc7, RVc8;
+static ULONG RVRindex;
+
+/* For Mono or Left Channel */
+static SLONG *RVbufL1=NULL,*RVbufL2=NULL,*RVbufL3=NULL,*RVbufL4=NULL,
+ *RVbufL5=NULL,*RVbufL6=NULL,*RVbufL7=NULL,*RVbufL8=NULL;
+
+/* For Stereo only (Right Channel) */
+static SLONG *RVbufR1=NULL,*RVbufR2=NULL,*RVbufR3=NULL,*RVbufR4=NULL,
+ *RVbufR5=NULL,*RVbufR6=NULL,*RVbufR7=NULL,*RVbufR8=NULL;
+
+#ifdef NATIVE_64BIT_INT
+#define NATIVE SLONGLONG
+#else
+#define NATIVE SLONG
+#endif
+
+/*========== 32 bit sample mixers - only for 32 bit platforms */
+#ifndef NATIVE_64BIT_INT
+
+static SLONG Mix32MonoNormal(const SWORD* const srce,SLONG* dest,SLONG idx,SLONG increment,SLONG todo)
+{
+ SWORD sample=0;
+ SLONG i,f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)( (((SLONG)(srce[i]*(FRACMASK+1L-f)) +
+ ((SLONG)srce[i+1]*f)) >> FRACBITS));
+ idx+=increment;
+
+ if(vnf->rampvol) {
+ *dest++ += (long)(
+ ( ( (SLONG)(vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *
+ (SLONG)sample ) >> CLICK_SHIFT );
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ *dest++ += (long)(
+ ( ( ((SLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONG)sample ) +
+ (vnf->lastvalL*vnf->click) ) >> CLICK_SHIFT );
+ vnf->click--;
+ } else
+ *dest++ +=vnf->lvolsel*sample;
+ }
+ vnf->lastvalL=vnf->lvolsel * sample;
+
+ return idx;
+}
+
+static SLONG Mix32StereoNormal(const SWORD* const srce,SLONG* dest,SLONG idx,SLONG increment,ULONG todo)
+{
+ SWORD sample=0;
+ SLONG i,f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONG)srce[i+1] * f)) >> FRACBITS));
+ idx += increment;
+
+ if(vnf->rampvol) {
+ *dest++ += (long)(
+ ( ( ((SLONG)vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONG)sample ) >> CLICK_SHIFT );
+ *dest++ += (long)(
+ ( ( ((SLONG)vnf->oldrvol*vnf->rampvol) +
+ (vnf->rvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONG)sample ) >> CLICK_SHIFT );
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ *dest++ += (long)(
+ ( ( (SLONG)(vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONG)sample ) + (vnf->lastvalL * vnf->click) )
+ >> CLICK_SHIFT );
+ *dest++ += (long)(
+ ( ( ((SLONG)vnf->rvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONG)sample ) + (vnf->lastvalR * vnf->click) )
+ >> CLICK_SHIFT );
+ vnf->click--;
+ } else {
+ *dest++ +=vnf->lvolsel*sample;
+ *dest++ +=vnf->rvolsel*sample;
+ }
+ }
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->rvolsel*sample;
+
+ return idx;
+}
+
+static SLONG Mix32StereoSurround(const SWORD* const srce,SLONG* dest,SLONG idx,SLONG increment,ULONG todo)
+{
+ SWORD sample=0;
+ long whoop;
+ SLONG i, f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONG)srce[i+1]*f)) >> FRACBITS));
+ idx+=increment;
+
+ if(vnf->rampvol) {
+ whoop=(long)(
+ ( ( (SLONG)(vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *
+ (SLONG)sample) >> CLICK_SHIFT );
+ *dest++ +=whoop;
+ *dest++ -=whoop;
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ whoop = (long)(
+ ( ( ((SLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONG)sample) +
+ (vnf->lastvalL * vnf->click) ) >> CLICK_SHIFT );
+ *dest++ +=whoop;
+ *dest++ -=whoop;
+ vnf->click--;
+ } else {
+ *dest++ +=vnf->lvolsel*sample;
+ *dest++ -=vnf->lvolsel*sample;
+ }
+ }
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->lvolsel*sample;
+
+ return idx;
+}
+#endif
+
+/*========== 64 bit mixers */
+
+static SLONGLONG MixMonoNormal(const SWORD* const srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,SLONG todo)
+{
+ SWORD sample=0;
+ SLONGLONG i,f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)((((SLONGLONG)(srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1]*f)) >> FRACBITS));
+ idx+=increment;
+
+ if(vnf->rampvol) {
+ *dest++ += (long)(
+ ( ( (SLONGLONG)(vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *
+ (SLONGLONG)sample ) >> CLICK_SHIFT );
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample ) +
+ (vnf->lastvalL*vnf->click) ) >> CLICK_SHIFT );
+ vnf->click--;
+ } else
+ *dest++ +=vnf->lvolsel*sample;
+ }
+ vnf->lastvalL=vnf->lvolsel * sample;
+
+ return idx;
+}
+
+/* Slowest part... */
+
+#if defined HAVE_SSE2 || defined HAVE_ALTIVEC
+
+static __inline SWORD GetSample(const SWORD* const srce, SLONGLONG idx)
+{
+ SLONGLONG i=idx>>FRACBITS;
+ SLONGLONG f=idx&FRACMASK;
+ return (SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS));
+}
+
+static SLONGLONG MixSIMDStereoNormal(const SWORD* const srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,ULONG todo)
+{
+ SWORD vol[8] = {vnf->lvolsel, vnf->rvolsel};
+ SWORD sample=0;
+ SLONG remain = todo;
+
+ /* Dest can be misaligned */
+ while(!IS_ALIGNED_16(dest)) {
+ sample=srce[idx >> FRACBITS];
+ idx += increment;
+ *dest++ += vol[0] * sample;
+ *dest++ += vol[1] * sample;
+ todo--;
+ if(!todo) goto end;
+ }
+
+ /* Srce is always aligned */
+
+#if defined HAVE_SSE2
+ remain = todo&3;
+ {
+ __m128i v0 = _mm_set_epi16(0, vol[1],
+ 0, vol[0],
+ 0, vol[1],
+ 0, vol[0]);
+ for(todo>>=2;todo; todo--)
+ {
+ SWORD s0 = GetSample(srce, idx);
+ SWORD s1 = GetSample(srce, idx += increment);
+ SWORD s2 = GetSample(srce, idx += increment);
+ SWORD s3 = GetSample(srce, idx += increment);
+ __m128i v1 = _mm_set_epi16(0, s1, 0, s1, 0, s0, 0, s0);
+ __m128i v2 = _mm_set_epi16(0, s3, 0, s3, 0, s2, 0, s2);
+ __m128i v3 = _mm_load_si128((__m128i*)(dest+0));
+ __m128i v4 = _mm_load_si128((__m128i*)(dest+4));
+ _mm_store_si128((__m128i*)(dest+0), _mm_add_epi32(v3, _mm_madd_epi16(v0, v1)));
+ _mm_store_si128((__m128i*)(dest+4), _mm_add_epi32(v4, _mm_madd_epi16(v0, v2)));
+ dest+=8;
+ idx += increment;
+ }
+ }
+
+#elif defined HAVE_ALTIVEC
+ remain = todo&3;
+ {
+ SWORD s[8];
+ vector signed short r0 = vec_ld(0, vol);
+ vector signed short v0 = vec_perm(r0, r0, (vector unsigned char)(0, 1, /* l */
+ 0, 1, /* l */
+ 2, 3, /* r */
+ 2, 1, /* r */
+ 0, 1, /* l */
+ 0, 1, /* l */
+ 2, 3, /* r */
+ 2, 3 /* r */
+ ));
+
+ for(todo>>=2;todo; todo--)
+ {
+ vector short int r1;
+ vector signed short v1, v2;
+ vector signed int v3, v4, v5, v6;
+
+ /* Load constants */
+ s[0] = GetSample(srce, idx);
+ s[1] = GetSample(srce, idx += increment);
+ s[2] = GetSample(srce, idx += increment);
+ s[3] = GetSample(srce, idx += increment);
+ s[4] = 0;
+
+ r1 = vec_ld(0, s);
+ v1 = vec_perm(r1, r1, (vector unsigned char)
+ (0*2, 0*2+1, /* s0 */
+ 4*2, 4*2+1, /* 0 */
+ 0*2, 0*2+1, /* s0 */
+ 4*2, 4*2+1, /* 0 */
+ 1*2, 1*2+1, /* s1 */
+ 4*2, 4*2+1, /* 0 */
+ 1*2, 1*2+1, /* s1 */
+ 4*2, 4*2+1 /* 0 */
+ ) );
+ v2 = vec_perm(r1, r1, (vector unsigned char)
+ (2*2, 2*2+1, /* s2 */
+ 4*2, 4*2+1, /* 0 */
+ 2*2, 2*2+1, /* s2 */
+ 4*2, 4*2+1, /* 0 */
+ 3*2, 3*2+1, /* s3 */
+ 4*2, 4*2+1, /* 0 */
+ 3*2, 3*2+1, /* s3 */
+ 4*2, 4*2+1 /* 0 */
+ ) );
+
+ v3 = vec_ld(0, dest);
+ v4 = vec_ld(0x10, dest);
+ v5 = vec_mule(v0, v1);
+ v6 = vec_mule(v0, v2);
+
+ vec_st(vec_add(v3, v5), 0, dest);
+ vec_st(vec_add(v4, v6), 0x10, dest);
+
+ dest+=8;
+ idx += increment;
+ }
+ }
+#endif /* HAVE_ALTIVEC */
+
+ /* Remaining bits */
+ while(remain--) {
+ sample=GetSample(srce, idx);
+ idx+= increment;
+ *dest++ += vol[0] * sample;
+ *dest++ += vol[1] * sample;
+ }
+end:
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->rvolsel*sample;
+ return idx;
+}
+
+static SLONGLONG MixStereoNormal(const SWORD* const srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,ULONG todo)
+{
+ SWORD sample=0;
+ SLONGLONG i,f;
+
+ if (vnf->rampvol)
+ while(todo) {
+ todo--;
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS));
+ idx += increment;
+
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->oldrvol*vnf->rampvol) +
+ (vnf->rvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );
+ vnf->rampvol--;
+
+ if (!vnf->rampvol)
+ break;
+ }
+
+ if (vnf->click)
+ while(todo) {
+ todo--;
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS));
+ idx += increment;
+
+ *dest++ += (long)(
+ ( ( (SLONGLONG)(vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample ) + (vnf->lastvalL * vnf->click) )
+ >> CLICK_SHIFT );
+
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->rvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample ) + (vnf->lastvalR * vnf->click) )
+ >> CLICK_SHIFT );
+ vnf->click--;
+
+ if (!vnf->click)
+ break;
+ }
+
+ if (todo)
+ {
+ if (md_mode & DMODE_SIMDMIXER) {
+ return MixSIMDStereoNormal(srce, dest, idx, increment, todo);
+ }
+ while(todo)
+ {
+ i=idx>>FRACBITS,
+ f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS));
+ idx += increment;
+
+ *dest++ +=vnf->lvolsel*sample;
+ *dest++ +=vnf->rvolsel*sample;
+ todo--;
+ }
+ }
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->rvolsel*sample;
+
+ return idx;
+}
+
+#else /* HAVE_SSE2 || HAVE_ALTIVEC */
+static SLONGLONG MixStereoNormal(const SWORD* const srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,ULONG todo)
+{
+ SWORD sample=0;
+ SLONGLONG i,f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1] * f)) >> FRACBITS));
+ idx += increment;
+
+ if(vnf->rampvol) {
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->oldrvol*vnf->rampvol) +
+ (vnf->rvolsel*(CLICK_BUFFER-vnf->rampvol))
+ ) * (SLONGLONG)sample ) >> CLICK_SHIFT );
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ *dest++ += (long)(
+ ( ( (SLONGLONG)(vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample ) + (vnf->lastvalL * vnf->click) )
+ >> CLICK_SHIFT );
+ *dest++ += (long)(
+ ( ( ((SLONGLONG)vnf->rvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample ) + (vnf->lastvalR * vnf->click) )
+ >> CLICK_SHIFT );
+ vnf->click--;
+ } else {
+ *dest++ +=vnf->lvolsel*sample;
+ *dest++ +=vnf->rvolsel*sample;
+ }
+ }
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->rvolsel*sample;
+
+ return idx;
+}
+#endif /* HAVE_SSE2 || HAVE_ALTIVEC */
+
+
+static SLONGLONG MixStereoSurround(const SWORD* srce,SLONG* dest,SLONGLONG idx,SLONGLONG increment,ULONG todo)
+{
+ SWORD sample=0;
+ long whoop;
+ SLONGLONG i, f;
+
+ while(todo--) {
+ i=idx>>FRACBITS,f=idx&FRACMASK;
+ sample=(SWORD)(((((SLONGLONG)srce[i]*(FRACMASK+1L-f)) +
+ ((SLONGLONG)srce[i+1]*f)) >> FRACBITS));
+ idx+=increment;
+
+ if(vnf->rampvol) {
+ whoop=(long)(
+ ( ( (SLONGLONG)(vnf->oldlvol*vnf->rampvol) +
+ (vnf->lvolsel*(CLICK_BUFFER-vnf->rampvol)) ) *
+ (SLONGLONG)sample) >> CLICK_SHIFT );
+ *dest++ +=whoop;
+ *dest++ -=whoop;
+ vnf->rampvol--;
+ } else
+ if(vnf->click) {
+ whoop = (long)(
+ ( ( ((SLONGLONG)vnf->lvolsel*(CLICK_BUFFER-vnf->click)) *
+ (SLONGLONG)sample) +
+ (vnf->lastvalL * vnf->click) ) >> CLICK_SHIFT );
+ *dest++ +=whoop;
+ *dest++ -=whoop;
+ vnf->click--;
+ } else {
+ *dest++ +=vnf->lvolsel*sample;
+ *dest++ -=vnf->lvolsel*sample;
+ }
+ }
+ vnf->lastvalL=vnf->lvolsel*sample;
+ vnf->lastvalR=vnf->lvolsel*sample;
+
+ return idx;
+}
+
+static void(*Mix32toFP)(float* dste,const SLONG *srce,NATIVE count);
+static void(*Mix32to16)(SWORD* dste,const SLONG *srce,NATIVE count);
+static void(*Mix32to8)(SBYTE* dste,const SLONG *srce,NATIVE count);
+static void(*MixReverb)(SLONG *srce,NATIVE count);
+
+/* Reverb macros */
+#define COMPUTE_LOC(n) loc##n = RVRindex % RVc##n
+#define COMPUTE_LECHO(n) RVbufL##n [loc##n ]=speedup+((ReverbPct*RVbufL##n [loc##n ])>>7)
+#define COMPUTE_RECHO(n) RVbufR##n [loc##n ]=speedup+((ReverbPct*RVbufR##n [loc##n ])>>7)
+
+static void MixReverb_Normal(SLONG *srce,NATIVE count)
+{
+ NATIVE speedup;
+ int ReverbPct;
+ unsigned int loc1,loc2,loc3,loc4,loc5,loc6,loc7,loc8;
+
+ ReverbPct=58+(md_reverb*4);
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ while(count--) {
+ /* Compute the left channel echo buffers */
+ speedup = *srce >> 3;
+
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);
+
+ /* Prepare to compute actual finalized data */
+ RVRindex++;
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ /* left channel */
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];
+ }
+}
+
+static void MixReverb_Stereo(SLONG *srce,NATIVE count)
+{
+ NATIVE speedup;
+ int ReverbPct;
+ unsigned int loc1,loc2,loc3,loc4,loc5,loc6,loc7,loc8;
+
+ ReverbPct=58+(md_reverb*4);
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ while(count--) {
+ /* Compute the left channel echo buffers */
+ speedup = *srce >> 3;
+
+ COMPUTE_LECHO(1); COMPUTE_LECHO(2); COMPUTE_LECHO(3); COMPUTE_LECHO(4);
+ COMPUTE_LECHO(5); COMPUTE_LECHO(6); COMPUTE_LECHO(7); COMPUTE_LECHO(8);
+
+ /* Compute the right channel echo buffers */
+ speedup = srce[1] >> 3;
+
+ COMPUTE_RECHO(1); COMPUTE_RECHO(2); COMPUTE_RECHO(3); COMPUTE_RECHO(4);
+ COMPUTE_RECHO(5); COMPUTE_RECHO(6); COMPUTE_RECHO(7); COMPUTE_RECHO(8);
+
+ /* Prepare to compute actual finalized data */
+ RVRindex++;
+
+ COMPUTE_LOC(1); COMPUTE_LOC(2); COMPUTE_LOC(3); COMPUTE_LOC(4);
+ COMPUTE_LOC(5); COMPUTE_LOC(6); COMPUTE_LOC(7); COMPUTE_LOC(8);
+
+ /* left channel */
+ *srce++ +=RVbufL1[loc1]-RVbufL2[loc2]+RVbufL3[loc3]-RVbufL4[loc4]+
+ RVbufL5[loc5]-RVbufL6[loc6]+RVbufL7[loc7]-RVbufL8[loc8];
+
+ /* right channel */
+ *srce++ +=RVbufR1[loc1]-RVbufR2[loc2]+RVbufR3[loc3]-RVbufR4[loc4]+
+ RVbufR5[loc5]-RVbufR6[loc6]+RVbufR7[loc7]-RVbufR8[loc8];
+ }
+}
+
+static void (*MixLowPass)(SLONG* srce,NATIVE count);
+
+static int nLeftNR, nRightNR;
+
+static void MixLowPass_Stereo(SLONG* srce,NATIVE count)
+{
+ int n1 = nLeftNR, n2 = nRightNR;
+ SLONG *pnr = srce;
+ int nr=count;
+ for (; nr; nr--)
+ {
+ int vnr = pnr[0] >> 1;
+ pnr[0] = vnr + n1;
+ n1 = vnr;
+ vnr = pnr[1] >> 1;
+ pnr[1] = vnr + n2;
+ n2 = vnr;
+ pnr += 2;
+ }
+ nLeftNR = n1;
+ nRightNR = n2;
+}
+
+static void MixLowPass_Normal(SLONG* srce,NATIVE count)
+{
+ int n1 = nLeftNR;
+ SLONG *pnr = srce;
+ int nr=count;
+ for (; nr; nr--)
+ {
+ int vnr = pnr[0] >> 1;
+ pnr[0] = vnr + n1;
+ n1 = vnr;
+ pnr ++;
+ }
+ nLeftNR = n1;
+}
+
+/* Mixing macros */
+#define EXTRACT_SAMPLE_FP(var,attenuation) var=*srce++*((1.0f / 32768.0f) / (MAXVOL_FACTOR*attenuation))
+#define CHECK_SAMPLE_FP(var,bound) var=(var>bound)?bound:(var<-bound)?-bound:var
+
+static void Mix32ToFP_Normal(float* dste,const SLONG *srce,NATIVE count)
+{
+ float x1,x2,tmpx;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx=0.0f;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE_FP(x1,1.0f); EXTRACT_SAMPLE_FP(x2,1.0f);
+
+ CHECK_SAMPLE_FP(x1,1.0f); CHECK_SAMPLE_FP(x2,1.0f);
+
+ tmpx+=x1+x2;
+ }
+ *dste++ =tmpx*(1.0f/SAMPLING_FACTOR);
+ }
+}
+
+static void Mix32ToFP_Stereo(float* dste,const SLONG *srce,NATIVE count)
+{
+ float x1,x2,x3,x4,tmpx,tmpy;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx=tmpy=0.0f;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE_FP(x1,1.0f); EXTRACT_SAMPLE_FP(x2,1.0f);
+ EXTRACT_SAMPLE_FP(x3,1.0f); EXTRACT_SAMPLE_FP(x4,1.0f);
+
+ CHECK_SAMPLE_FP(x1,1.0f); CHECK_SAMPLE_FP(x2,1.0f);
+ CHECK_SAMPLE_FP(x3,1.0f); CHECK_SAMPLE_FP(x4,1.0f);
+
+ tmpx+=x1+x3;
+ tmpy+=x2+x4;
+ }
+ *dste++ =tmpx*(1.0f/SAMPLING_FACTOR);
+ *dste++ =tmpy*(1.0f/SAMPLING_FACTOR);
+ }
+}
+
+/* Mixing macros */
+#define EXTRACT_SAMPLE(var,attenuation) var=*srce++/(MAXVOL_FACTOR*attenuation)
+#define CHECK_SAMPLE(var,bound) var=(var>=bound)?bound-1:(var<-bound)?-bound:var
+
+static void Mix32To16_Normal(SWORD* dste,const SLONG *srce,NATIVE count)
+{
+ NATIVE x1,x2,tmpx;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx=0;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE(x1,1); EXTRACT_SAMPLE(x2,1);
+
+ CHECK_SAMPLE(x1,32768); CHECK_SAMPLE(x2,32768);
+
+ tmpx+=x1+x2;
+ }
+ *dste++ =(SWORD)(tmpx/SAMPLING_FACTOR);
+ }
+}
+
+
+static void Mix32To16_Stereo(SWORD* dste,const SLONG *srce,NATIVE count)
+{
+ NATIVE x1,x2,x3,x4,tmpx,tmpy;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx=tmpy=0;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE(x1,1); EXTRACT_SAMPLE(x2,1);
+ EXTRACT_SAMPLE(x3,1); EXTRACT_SAMPLE(x4,1);
+
+ CHECK_SAMPLE(x1,32768); CHECK_SAMPLE(x2,32768);
+ CHECK_SAMPLE(x3,32768); CHECK_SAMPLE(x4,32768);
+
+ tmpx+=x1+x3;
+ tmpy+=x2+x4;
+ }
+ *dste++ =(SWORD)(tmpx/SAMPLING_FACTOR);
+ *dste++ =(SWORD)(tmpy/SAMPLING_FACTOR);
+ }
+}
+
+static void Mix32To8_Normal(SBYTE* dste,const SLONG *srce,NATIVE count)
+{
+ NATIVE x1,x2,tmpx;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx = 0;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE(x1,256); EXTRACT_SAMPLE(x2,256);
+
+ CHECK_SAMPLE(x1,128); CHECK_SAMPLE(x2,128);
+
+ tmpx+=x1+x2;
+ }
+ *dste++ = (SBYTE)((tmpx/SAMPLING_FACTOR)+128);
+ }
+}
+
+static void Mix32To8_Stereo(SBYTE* dste,const SLONG *srce,NATIVE count)
+{
+ NATIVE x1,x2,x3,x4,tmpx,tmpy;
+ int i;
+
+ for(count/=SAMPLING_FACTOR;count;count--) {
+ tmpx=tmpy=0;
+
+ for(i=SAMPLING_FACTOR/2;i;i--) {
+ EXTRACT_SAMPLE(x1,256); EXTRACT_SAMPLE(x2,256);
+ EXTRACT_SAMPLE(x3,256); EXTRACT_SAMPLE(x4,256);
+
+ CHECK_SAMPLE(x1,128); CHECK_SAMPLE(x2,128);
+ CHECK_SAMPLE(x3,128); CHECK_SAMPLE(x4,128);
+
+ tmpx+=x1+x3;
+ tmpy+=x2+x4;
+ }
+ *dste++ =(SBYTE)((tmpx/SAMPLING_FACTOR)+128);
+ *dste++ =(SBYTE)((tmpy/SAMPLING_FACTOR)+128);
+ }
+}
+
+#if defined HAVE_SSE2
+#define SHIFT_MIX_TO_16 (BITSHIFT + 16 - 16)
+/* TEST: Ok */
+static void Mix32To16_Stereo_SIMD_4Tap(SWORD* dste, const SLONG* srce, NATIVE count)
+{
+ int remain = count;
+
+ /* Check unaligned dste buffer. srce is always aligned. */
+ while(!IS_ALIGNED_16(dste))
+ {
+ Mix32To16_Stereo(dste, srce, SAMPLING_FACTOR);
+ dste+=2;
+ srce+=8;
+ count--;
+ if(!count) return;
+ }
+
+ /* dste and srce aligned. srce is always aligned. */
+ remain = count & 15;
+ /* count / 2 for 1 sample */
+
+ for(count>>=4;count;count--)
+ {
+ /* Load 32bit sample. 1st average */
+ __m128i v0 = _mm_add_epi32(
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+0)), SHIFT_MIX_TO_16),
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+4)), SHIFT_MIX_TO_16)
+ ); /* v0: s0.l+s2.l | s0.r+s2.r | s1.l+s3.l | s1.r+s3.r */
+
+ /* 2nd average (s0.l+s2.l+s1.l+s3.l / 4, s0.r+s2.r+s1.r+s3.r / 4). Upper 64bit is unused (1 stereo sample) */
+ __m128i v1 = _mm_srai_epi32(_mm_add_epi32(v0, mm_hiqq(v0)), 2);
+ /* v1: s0.l+s2.l / 4 | s0.r+s2.r / 4 | s1.l+s3.l+s0.l+s2.l / 4 | s1.r+s3.r+s0.r+s2.r / 4 */
+
+ __m128i v2 = _mm_add_epi32(
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+8)), SHIFT_MIX_TO_16),
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+12)), SHIFT_MIX_TO_16)
+ ); /* v2: s4.l+s6.l | s4.r+s6.r | s5.l+s7.l | s5.r+s7.r */
+
+ __m128i v3 = _mm_srai_epi32(_mm_add_epi32(v2, mm_hiqq(v2)), 2); /* Upper 64bit is unused */
+ /* v3: s4.l+s6.l /4 | s4.r+s6.r / 4| s5.l+s7.l+s4.l+s6.l / 4 | s5.r+s7.r+s4.r+s6.l / 4 */
+
+ /* pack two stereo samples in one */
+ __m128i v4 = _mm_unpacklo_epi64(v1, v3); /* v4 = avg(s0,s1,s2,s3) | avg(s4,s5,s6,s7) */
+
+ __m128i v6;
+
+ /* Load 32bit sample. 1st average (s0.l+s2.l, s0.r+s2.r, s1.l+s3.l, s1.r+s3.r) */
+ v0 = _mm_add_epi32(
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+16)), SHIFT_MIX_TO_16),
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+20)), SHIFT_MIX_TO_16)
+ ); /* 128bit = 2 stereo samples */
+
+ /* 2nd average (s0.l+s2.l+s1.l+s3.l / 4, s0.r+s2.r+s1.r+s3.r / 4). Upper 64bit is unused (1 stereo sample) */
+ v1 = _mm_srai_epi32(_mm_add_epi32(v0, mm_hiqq(v0)), 2);
+
+ v2 = _mm_add_epi32(
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+24)), SHIFT_MIX_TO_16),
+ _mm_srai_epi32(_mm_loadu_si128((__m128i const *)(srce+28)), SHIFT_MIX_TO_16)
+ );
+
+ v3 = _mm_srai_epi32(_mm_add_epi32(v2, mm_hiqq(v2)), 2); /* Upper 64bit is unused */
+
+ /* pack two stereo samples in one */
+ v6 = _mm_unpacklo_epi64(v1, v3); /* v6 = avg(s8,s9,s10,s11) | avg(s12,s13,s14,s15) */
+
+ _mm_store_si128((__m128i*)dste, _mm_packs_epi32(v4, v6)); /* 4 interpolated stereo sample 32bit to 4 */
+
+ dste+=8;
+ srce+=32; /* 32 = 4 * 8 */
+ }
+
+ /* FIXME: THIS PART WRITES PAST DST !! */
+ if (remain)
+ {
+ Mix32To16_Stereo(dste, srce, remain);
+ }
+}
+
+#elif defined HAVE_ALTIVEC
+#define SHIFT_MIX_TO_16 vec_splat_u32(BITSHIFT + 16 - 16)
+/* TEST: Ok */
+static void Mix32To16_Stereo_SIMD_4Tap(SWORD* dste, const SLONG* srce, NATIVE count)
+{
+ int remain = count;
+
+ /* Check unaligned dste buffer. srce is always aligned. */
+ while(!IS_ALIGNED_16(dste))
+ {
+ Mix32To16_Stereo(dste, srce, SAMPLING_FACTOR);
+ dste+=2;
+ srce+=8;
+ count--;
+ if(!count) return;
+ }
+
+ /* dste and srce aligned. srce is always aligned. */
+ remain = count & 15;
+ for(count>>=4;count;count--)
+ {
+ /* Load 32bit sample. 1st average (s0.l+s2.l, s0.r+s2.r, s1.l+s3.l, s1.r+s3.r) */
+ vector signed int v0 = vec_add(
+ vec_sra(vec_ld(0, srce), SHIFT_MIX_TO_16), /* 128bit = 2 stereo samples */
+ vec_sra(vec_ld(0x10, srce), SHIFT_MIX_TO_16)
+ ); /* 128bit = 2 stereo samples */
+
+ /* 2nd average (s0.l+s2.l+s1.l+s3.l / 4, s0.r+s2.r+s1.r+s3.r / 4). Upper 64bit is unused (1 stereo sample) */
+ vector signed int v1 = vec_sra(vec_add(v0, vec_hiqq(v0)), vec_splat_u32(2));
+
+ vector signed int v2 = vec_add(
+ vec_sra(vec_ld(0x20, srce), SHIFT_MIX_TO_16),
+ vec_sra(vec_ld(0x30, srce), SHIFT_MIX_TO_16)
+ );
+
+ vector signed int v3 = vec_sra(vec_add(v2, vec_hiqq(v2)), vec_splat_u32(2)); /* Upper 64bit is unused */
+
+ /* pack two stereo samples in one */
+ vector signed int v6, v4 = vec_unpacklo(v1, v3); /* v4 = lo64(v1) | lo64(v3) */
+
+ /* Load 32bit sample. 1st average (s0.l+s2.l, s0.r+s2.r, s1.l+s3.l, s1.r+s3.r) */
+ v0 = vec_add(
+ vec_sra(vec_ld(0x40, srce), SHIFT_MIX_TO_16), /* 128bit = 2 stereo samples */
+ vec_sra(vec_ld(0x50, srce), SHIFT_MIX_TO_16)
+ ); /* 128bit = 2 stereo samples */
+
+ /* 2nd average (s0.l+s2.l+s1.l+s3.l / 4, s0.r+s2.r+s1.r+s3.r / 4). Upper 64bit is unused (1 stereo sample) */
+ v1 = vec_sra(vec_add(v0, vec_hiqq(v0)), vec_splat_u32(2));
+
+ v2 = vec_add(
+ vec_sra(vec_ld(0x60, srce), SHIFT_MIX_TO_16),
+ vec_sra(vec_ld(0x70, srce), SHIFT_MIX_TO_16)
+ );
+
+ v3 = vec_sra(vec_add(v2, vec_hiqq(v2)), vec_splat_u32(2)); /* Upper 64bit is unused */
+
+ /* pack two stereo samples in one */
+ v6 = vec_unpacklo(v1, v3);
+
+ vec_st(vec_packs(v4, v6), 0, dste); /* 4 interpolated stereo sample 32bit to 4 interpolated stereo sample 16bit + saturation */
+
+ dste+=8;
+ srce+=32; /* 32 = 4 * 8 */
+ }
+
+ if (remain)
+ {
+ Mix32To16_Stereo(dste, srce, remain);
+ }
+}
+
+#endif
+
+
+static void AddChannel(SLONG* ptr,NATIVE todo)
+{
+ SLONGLONG end,done;
+ SWORD *s;
+
+ if(!(s=Samples[vnf->handle])) {
+ vnf->current = vnf->active = 0;
+ vnf->lastvalL = vnf->lastvalR = 0;
+ return;
+ }
+
+ /* update the 'current' index so the sample loops, or stops playing if it
+ reached the end of the sample */
+ while(todo>0) {
+ SLONGLONG endpos;
+
+ if(vnf->flags & SF_REVERSE) {
+ /* The sample is playing in reverse */
+ if((vnf->flags&SF_LOOP)&&(vnf->current<idxlpos)) {
+ /* the sample is looping and has reached the loopstart index */
+ if(vnf->flags & SF_BIDI) {
+ /* sample is doing bidirectional loops, so 'bounce' the
+ current index against the idxlpos */
+ vnf->current = idxlpos+(idxlpos-vnf->current);
+ vnf->flags &= ~SF_REVERSE;
+ vnf->increment = -vnf->increment;
+ } else
+ /* normal backwards looping, so set the current position to
+ loopend index */
+ vnf->current=idxlend-(idxlpos-vnf->current);
+ } else {
+ /* the sample is not looping, so check if it reached index 0 */
+ if(vnf->current < 0) {
+ /* playing index reached 0, so stop playing this sample */
+ vnf->current = vnf->active = 0;
+ break;
+ }
+ }
+ } else {
+ /* The sample is playing forward */
+ if((vnf->flags & SF_LOOP) &&
+ (vnf->current >= idxlend)) {
+ /* the sample is looping, check the loopend index */
+ if(vnf->flags & SF_BIDI) {
+ /* sample is doing bidirectional loops, so 'bounce' the
+ current index against the idxlend */
+ vnf->flags |= SF_REVERSE;
+ vnf->increment = -vnf->increment;
+ vnf->current = idxlend-(vnf->current-idxlend);
+ } else
+ /* normal backwards looping, so set the current position
+ to loopend index */
+ vnf->current=idxlpos+(vnf->current-idxlend);
+ } else {
+ /* sample is not looping, so check if it reached the last
+ position */
+ if(vnf->current >= idxsize) {
+ /* yes, so stop playing this sample */
+ vnf->current = vnf->active = 0;
+ break;
+ }
+ }
+ }
+
+ end=(vnf->flags&SF_REVERSE)?(vnf->flags&SF_LOOP)?idxlpos:0:
+ (vnf->flags&SF_LOOP)?idxlend:idxsize;
+
+ /* if the sample is not blocked... */
+ if((end==vnf->current)||(!vnf->increment))
+ done=0;
+ else {
+ done=MIN((end-vnf->current)/vnf->increment+1,todo);
+ if(done<0) done=0;
+ }
+
+ if(!done) {
+ vnf->active = 0;
+ break;
+ }
+
+ endpos=vnf->current+done*vnf->increment;
+
+ if(vnf->vol || vnf->rampvol) {
+#ifndef NATIVE_64BIT_INT
+ /* use the 32 bit mixers as often as we can (they're much faster) */
+ if((vnf->current<0x7fffffff)&&(endpos<0x7fffffff)) {
+ if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(vc_mode&DMODE_SURROUND))
+ vnf->current=(SLONGLONG)Mix32StereoSurround
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ vnf->current=Mix32StereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else
+ vnf->current=Mix32MonoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ else
+#endif
+ {
+ if(vc_mode & DMODE_STEREO) {
+ if((vnf->pan==PAN_SURROUND)&&(vc_mode&DMODE_SURROUND))
+ vnf->current=MixStereoSurround
+ (s,ptr,vnf->current,vnf->increment,done);
+ else
+ vnf->current=MixStereoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ } else
+ vnf->current=MixMonoNormal
+ (s,ptr,vnf->current,vnf->increment,done);
+ }
+ } else {
+ vnf->lastvalL = vnf->lastvalR = 0;
+ /* update sample position */
+ vnf->current=endpos;
+ }
+
+ todo -= done;
+ ptr += (vc_mode & DMODE_STEREO)?(done<<1):done;
+ }
+}
+
+#define _IN_VIRTCH_
+
+#define VC1_SilenceBytes VC2_SilenceBytes
+#define VC1_WriteSamples VC2_WriteSamples
+#define VC1_WriteBytes VC2_WriteBytes
+#define VC1_Exit VC2_Exit
+#define VC1_VoiceSetVolume VC2_VoiceSetVolume
+#define VC1_VoiceGetVolume VC2_VoiceGetVolume
+#define VC1_VoiceSetPanning VC2_VoiceSetPanning
+#define VC1_VoiceGetPanning VC2_VoiceGetPanning
+#define VC1_VoiceSetFrequency VC2_VoiceSetFrequency
+#define VC1_VoiceGetFrequency VC2_VoiceGetFrequency
+#define VC1_VoicePlay VC2_VoicePlay
+#define VC1_VoiceStop VC2_VoiceStop
+#define VC1_VoiceStopped VC2_VoiceStopped
+#define VC1_VoiceGetPosition VC2_VoiceGetPosition
+#define VC1_SampleUnload VC2_SampleUnload
+#define VC1_SampleLoad VC2_SampleLoad
+#define VC1_SampleSpace VC2_SampleSpace
+#define VC1_SampleLength VC2_SampleLength
+#define VC1_VoiceRealVolume VC2_VoiceRealVolume
+
+#include "virtch_common.c"
+#undef _IN_VIRTCH_
+
+void VC2_WriteSamples(SBYTE* buf,ULONG todo)
+{
+ int left,portion=0;
+ SBYTE *buffer;
+ int t,pan,vol;
+
+ todo*=SAMPLING_FACTOR;
+
+ while(todo) {
+ if(!tickleft) {
+ if(vc_mode & DMODE_SOFT_MUSIC) md_player();
+ tickleft=(md_mixfreq*125L*SAMPLING_FACTOR)/(md_bpm*50L);
+ tickleft&=~(SAMPLING_FACTOR-1);
+ }
+ left = MIN(tickleft, (long)todo);
+ buffer = buf;
+ tickleft -= left;
+ todo -= left;
+ buf += samples2bytes(left)/SAMPLING_FACTOR;
+
+ while(left) {
+ portion = MIN(left, samplesthatfit);
+ memset(vc_tickbuf,0,portion<<((vc_mode&DMODE_STEREO)?3:2));
+ for(t=0;t<vc_softchn;t++) {
+ vnf = &vinf[t];
+
+ if(vnf->kick) {
+ vnf->current=((SLONGLONG)(vnf->start))<<FRACBITS;
+ vnf->kick = 0;
+ vnf->active = 1;
+ vnf->click = CLICK_BUFFER;
+ vnf->rampvol = 0;
+ }
+
+ if(!vnf->frq) vnf->active = 0;
+
+ if(vnf->active) {
+ vnf->increment=((SLONGLONG)(vnf->frq)<<(FRACBITS-SAMPLING_SHIFT))
+ /md_mixfreq;
+ if(vnf->flags&SF_REVERSE) vnf->increment=-vnf->increment;
+ vol = vnf->vol; pan = vnf->pan;
+
+ vnf->oldlvol=vnf->lvolsel;vnf->oldrvol=vnf->rvolsel;
+ if(vc_mode & DMODE_STEREO) {
+ if(pan!=PAN_SURROUND) {
+ vnf->lvolsel=(vol*(PAN_RIGHT-pan))>>8;
+ vnf->rvolsel=(vol*pan)>>8;
+ } else {
+ vnf->lvolsel=vnf->rvolsel=(vol * 256L) / 480;
+ }
+ } else
+ vnf->lvolsel=vol;
+
+ idxsize=(vnf->size)?((SLONGLONG)(vnf->size)<<FRACBITS)-1:0;
+ idxlend=(vnf->repend)?((SLONGLONG)(vnf->repend)<<FRACBITS)-1:0;
+ idxlpos=(SLONGLONG)(vnf->reppos)<<FRACBITS;
+ AddChannel(vc_tickbuf,portion);
+ }
+ }
+
+ if(md_mode & DMODE_NOISEREDUCTION) {
+ MixLowPass(vc_tickbuf, portion);
+ }
+
+ if(md_reverb) {
+ if(md_reverb>15) md_reverb=15;
+ MixReverb(vc_tickbuf,portion);
+ }
+
+ if (vc_callback) {
+ vc_callback((unsigned char*)vc_tickbuf, portion);
+ }
+
+ if(vc_mode & DMODE_FLOAT)
+ Mix32toFP((float*)buffer,vc_tickbuf,portion);
+ else if(vc_mode & DMODE_16BITS)
+ Mix32to16((SWORD*)buffer,vc_tickbuf,portion);
+ else
+ Mix32to8((SBYTE*)buffer,vc_tickbuf,portion);
+
+ buffer += samples2bytes(portion) / SAMPLING_FACTOR;
+ left -= portion;
+ }
+ }
+}
+
+int VC2_Init(void)
+{
+ VC_SetupPointers();
+
+ if (!(md_mode&DMODE_HQMIXER))
+ return VC1_Init();
+
+ if(!(Samples=(SWORD**)MikMod_amalloc(MAXSAMPLEHANDLES*sizeof(SWORD*)))) {
+ _mm_errno = MMERR_INITIALIZING_MIXER;
+ return 1;
+ }
+ if(!vc_tickbuf) {
+ if(!(vc_tickbuf=(SLONG*)MikMod_amalloc((TICKLSIZE+32)*sizeof(SLONG)))) {
+ _mm_errno = MMERR_INITIALIZING_MIXER;
+ return 1;
+ }
+ }
+
+ if(md_mode & DMODE_STEREO) {
+ Mix32toFP = Mix32ToFP_Stereo;
+#if ((defined HAVE_ALTIVEC || defined HAVE_SSE2) && (SAMPLING_FACTOR == 4))
+ if (md_mode & DMODE_SIMDMIXER)
+ Mix32to16 = Mix32To16_Stereo_SIMD_4Tap;
+ else
+#endif
+ Mix32to16 = Mix32To16_Stereo;
+ Mix32to8 = Mix32To8_Stereo;
+ MixReverb = MixReverb_Stereo;
+ MixLowPass = MixLowPass_Stereo;
+ } else {
+ Mix32toFP = Mix32ToFP_Normal;
+ Mix32to16 = Mix32To16_Normal;
+ Mix32to8 = Mix32To8_Normal;
+ MixReverb = MixReverb_Normal;
+ MixLowPass = MixLowPass_Normal;
+ }
+
+ md_mode |= DMODE_INTERP;
+ vc_mode = md_mode;
+ return 0;
+}
+
+int VC2_PlayStart(void)
+{
+ md_mode|=DMODE_INTERP;
+
+ samplesthatfit = TICKLSIZE;
+ if(vc_mode & DMODE_STEREO) samplesthatfit >>= 1;
+ tickleft = 0;
+
+ RVc1 = (5000L * md_mixfreq) / (REVERBERATION * 10);
+ RVc2 = (5078L * md_mixfreq) / (REVERBERATION * 10);
+ RVc3 = (5313L * md_mixfreq) / (REVERBERATION * 10);
+ RVc4 = (5703L * md_mixfreq) / (REVERBERATION * 10);
+ RVc5 = (6250L * md_mixfreq) / (REVERBERATION * 10);
+ RVc6 = (6953L * md_mixfreq) / (REVERBERATION * 10);
+ RVc7 = (7813L * md_mixfreq) / (REVERBERATION * 10);
+ RVc8 = (8828L * md_mixfreq) / (REVERBERATION * 10);
+
+ if(!(RVbufL1=(SLONG*)MikMod_calloc((RVc1+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL2=(SLONG*)MikMod_calloc((RVc2+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL3=(SLONG*)MikMod_calloc((RVc3+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL4=(SLONG*)MikMod_calloc((RVc4+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL5=(SLONG*)MikMod_calloc((RVc5+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL6=(SLONG*)MikMod_calloc((RVc6+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL7=(SLONG*)MikMod_calloc((RVc7+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufL8=(SLONG*)MikMod_calloc((RVc8+1),sizeof(SLONG)))) return 1;
+
+ /* allocate reverb buffers for the right channel if in stereo mode only. */
+ if (vc_mode & DMODE_STEREO) {
+ if(!(RVbufR1=(SLONG*)MikMod_calloc((RVc1+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR2=(SLONG*)MikMod_calloc((RVc2+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR3=(SLONG*)MikMod_calloc((RVc3+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR4=(SLONG*)MikMod_calloc((RVc4+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR5=(SLONG*)MikMod_calloc((RVc5+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR6=(SLONG*)MikMod_calloc((RVc6+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR7=(SLONG*)MikMod_calloc((RVc7+1),sizeof(SLONG)))) return 1;
+ if(!(RVbufR8=(SLONG*)MikMod_calloc((RVc8+1),sizeof(SLONG)))) return 1;
+ }
+
+ RVRindex = 0;
+ return 0;
+}
+
+void VC2_PlayStop(void)
+{
+ MikMod_free(RVbufL1);
+ MikMod_free(RVbufL2);
+ MikMod_free(RVbufL3);
+ MikMod_free(RVbufL4);
+ MikMod_free(RVbufL5);
+ MikMod_free(RVbufL6);
+ MikMod_free(RVbufL7);
+ MikMod_free(RVbufL8);
+ MikMod_free(RVbufR1);
+ MikMod_free(RVbufR2);
+ MikMod_free(RVbufR3);
+ MikMod_free(RVbufR4);
+ MikMod_free(RVbufR5);
+ MikMod_free(RVbufR6);
+ MikMod_free(RVbufR7);
+ MikMod_free(RVbufR8);
+
+ RVbufL1=RVbufL2=RVbufL3=RVbufL4=RVbufL5=RVbufL6=RVbufL7=RVbufL8=NULL;
+ RVbufR1=RVbufR2=RVbufR3=RVbufR4=RVbufR5=RVbufR6=RVbufR7=RVbufR8=NULL;
+}
+
+int VC2_SetNumVoices(void)
+{
+ int t;
+
+ md_mode|=DMODE_INTERP;
+
+ if(!(vc_softchn=md_softchn)) return 0;
+
+ MikMod_free(vinf);
+ if(!(vinf=(VINFO*)MikMod_calloc(vc_softchn,sizeof(VINFO)))) return 1;
+
+ for(t=0;t<vc_softchn;t++) {
+ vinf[t].frq=10000;
+ vinf[t].pan=(t&1)?PAN_LEFT:PAN_RIGHT;
+ }
+
+ return 0;
+}
+
+#endif /* ! NO_HQMIXER */
+
+/* ex:set ts=4: */
--- /dev/null
+/* MikMod sound library
+ (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
+ for complete list.
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA.
+*/
+
+/*==============================================================================
+
+ $Id$
+
+ Common source parts between the two software mixers.
+ This file is probably the ugliest part of libmikmod...
+
+==============================================================================*/
+
+#if defined(HAVE_CONFIG_H) && !defined(_IN_VIRTCH_) /* config.h isn't guarded */
+#include "config.h"
+#endif
+#include "mikmod_internals.h"
+
+#ifndef NO_HQMIXER
+extern ULONG VC1_SilenceBytes(SBYTE*,ULONG);
+extern ULONG VC2_SilenceBytes(SBYTE*,ULONG);
+extern ULONG VC1_WriteBytes(SBYTE*,ULONG);
+extern ULONG VC2_WriteBytes(SBYTE*,ULONG);
+extern void VC1_Exit(void);
+extern void VC2_Exit(void);
+extern UWORD VC1_VoiceGetVolume(UBYTE);
+extern UWORD VC2_VoiceGetVolume(UBYTE);
+extern ULONG VC1_VoiceGetPanning(UBYTE);
+extern ULONG VC2_VoiceGetPanning(UBYTE);
+extern void VC1_VoiceSetFrequency(UBYTE,ULONG);
+extern void VC2_VoiceSetFrequency(UBYTE,ULONG);
+extern ULONG VC1_VoiceGetFrequency(UBYTE);
+extern ULONG VC2_VoiceGetFrequency(UBYTE);
+extern void VC1_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
+extern void VC2_VoicePlay(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
+extern void VC1_VoiceStop(UBYTE);
+extern void VC2_VoiceStop(UBYTE);
+extern BOOL VC1_VoiceStopped(UBYTE);
+extern BOOL VC2_VoiceStopped(UBYTE);
+extern SLONG VC1_VoiceGetPosition(UBYTE);
+extern SLONG VC2_VoiceGetPosition(UBYTE);
+extern void VC1_VoiceSetVolume(UBYTE,UWORD);
+extern void VC2_VoiceSetVolume(UBYTE,UWORD);
+extern void VC1_VoiceSetPanning(UBYTE,ULONG);
+extern void VC2_VoiceSetPanning(UBYTE,ULONG);
+extern void VC1_SampleUnload(SWORD);
+extern void VC2_SampleUnload(SWORD);
+extern SWORD VC1_SampleLoad(struct SAMPLOAD*,int);
+extern SWORD VC2_SampleLoad(struct SAMPLOAD*,int);
+extern ULONG VC1_SampleSpace(int);
+extern ULONG VC2_SampleSpace(int);
+extern ULONG VC1_SampleLength(int,SAMPLE*);
+extern ULONG VC2_SampleLength(int,SAMPLE*);
+extern ULONG VC1_VoiceRealVolume(UBYTE);
+extern ULONG VC2_VoiceRealVolume(UBYTE);
+#endif
+
+
+#ifndef _IN_VIRTCH_
+
+#ifndef NO_HQMIXER
+extern int VC1_Init(void);
+extern int VC2_Init(void);
+static int (*VC_Init_ptr)(void)=VC1_Init;
+static void (*VC_Exit_ptr)(void)=VC1_Exit;
+extern int VC1_SetNumVoices(void);
+extern int VC2_SetNumVoices(void);
+static int (*VC_SetNumVoices_ptr)(void);
+static ULONG (*VC_SampleSpace_ptr)(int);
+static ULONG (*VC_SampleLength_ptr)(int,SAMPLE*);
+
+extern int VC2_PlayStart(void);
+static int (*VC_PlayStart_ptr)(void);
+extern void VC2_PlayStop(void);
+static void (*VC_PlayStop_ptr)(void);
+
+static SWORD (*VC_SampleLoad_ptr)(struct SAMPLOAD*,int);
+static void (*VC_SampleUnload_ptr)(SWORD);
+
+static ULONG (*VC_WriteBytes_ptr)(SBYTE*,ULONG);
+static ULONG (*VC_SilenceBytes_ptr)(SBYTE*,ULONG);
+
+static void (*VC_VoiceSetVolume_ptr)(UBYTE,UWORD);
+static UWORD (*VC_VoiceGetVolume_ptr)(UBYTE);
+static void (*VC_VoiceSetFrequency_ptr)(UBYTE,ULONG);
+static ULONG (*VC_VoiceGetFrequency_ptr)(UBYTE);
+static void (*VC_VoiceSetPanning_ptr)(UBYTE,ULONG);
+static ULONG (*VC_VoiceGetPanning_ptr)(UBYTE);
+static void (*VC_VoicePlay_ptr)(UBYTE,SWORD,ULONG,ULONG,ULONG,ULONG,UWORD);
+
+static void (*VC_VoiceStop_ptr)(UBYTE);
+static BOOL (*VC_VoiceStopped_ptr)(UBYTE);
+static SLONG (*VC_VoiceGetPosition_ptr)(UBYTE);
+static ULONG (*VC_VoiceRealVolume_ptr)(UBYTE);
+
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C
+#define VC_PROC0(suffix) \
+MIKMODAPI void VC_##suffix (void) { VC_##suffix##_ptr(); }
+
+#define VC_FUNC0(suffix,ret) \
+MIKMODAPI ret VC_##suffix (void) { return VC_##suffix##_ptr(); }
+
+#define VC_PROC1(suffix,typ1) \
+MIKMODAPI void VC_##suffix (typ1 a) { VC_##suffix##_ptr(a); }
+
+#define VC_FUNC1(suffix,ret,typ1) \
+MIKMODAPI ret VC_##suffix (typ1 a) { return VC_##suffix##_ptr(a); }
+
+#define VC_PROC2(suffix,typ1,typ2) \
+MIKMODAPI void VC_##suffix (typ1 a,typ2 b) { VC_##suffix##_ptr(a,b); }
+
+#define VC_FUNC2(suffix,ret,typ1,typ2) \
+MIKMODAPI ret VC_##suffix (typ1 a,typ2 b) { return VC_##suffix##_ptr(a,b); }
+
+#else
+
+#define VC_PROC0(suffix) \
+MIKMODAPI void VC_/**/suffix (void) { VC_/**/suffix/**/_ptr(); }
+
+#define VC_FUNC0(suffix,ret) \
+MIKMODAPI ret VC_/**/suffix (void) { return VC_/**/suffix/**/_ptr(); }
+
+#define VC_PROC1(suffix,typ1) \
+MIKMODAPI void VC_/**/suffix (typ1 a) { VC_/**/suffix/**/_ptr(a); }
+
+#define VC_FUNC1(suffix,ret,typ1) \
+MIKMODAPI ret VC_/**/suffix (typ1 a) { return VC_/**/suffix/**/_ptr(a); }
+
+#define VC_PROC2(suffix,typ1,typ2) \
+MIKMODAPI void VC_/**/suffix (typ1 a,typ2 b) { VC_/**/suffix/**/_ptr(a,b); }
+
+#define VC_FUNC2(suffix,ret,typ1,typ2) \
+MIKMODAPI ret VC_/**/suffix (typ1 a,typ2 b) { return VC_/**/suffix/**/_ptr(a,b); }
+#endif
+
+VC_FUNC0(Init,int)
+VC_PROC0(Exit)
+VC_FUNC0(SetNumVoices,int)
+VC_FUNC1(SampleSpace,ULONG,int)
+VC_FUNC2(SampleLength,ULONG,int,SAMPLE*)
+VC_FUNC0(PlayStart,int)
+VC_PROC0(PlayStop)
+VC_FUNC2(SampleLoad,SWORD,struct SAMPLOAD*,int)
+VC_PROC1(SampleUnload,SWORD)
+VC_FUNC2(WriteBytes,ULONG,SBYTE*,ULONG)
+VC_FUNC2(SilenceBytes,ULONG,SBYTE*,ULONG)
+VC_PROC2(VoiceSetVolume,UBYTE,UWORD)
+VC_FUNC1(VoiceGetVolume,UWORD,UBYTE)
+VC_PROC2(VoiceSetFrequency,UBYTE,ULONG)
+VC_FUNC1(VoiceGetFrequency,ULONG,UBYTE)
+VC_PROC2(VoiceSetPanning,UBYTE,ULONG)
+VC_FUNC1(VoiceGetPanning,ULONG,UBYTE)
+
+void VC_VoicePlay(UBYTE a,SWORD b,ULONG c,ULONG d,ULONG e,ULONG f,UWORD g) {
+ VC_VoicePlay_ptr(a,b,c,d,e,f,g);
+}
+
+VC_PROC1(VoiceStop,UBYTE)
+VC_FUNC1(VoiceStopped,BOOL,UBYTE)
+VC_FUNC1(VoiceGetPosition,SLONG,UBYTE)
+VC_FUNC1(VoiceRealVolume,ULONG,UBYTE)
+
+void VC_SetupPointers(void)
+{
+ if (md_mode&DMODE_HQMIXER) {
+ VC_Init_ptr=VC2_Init;
+ VC_Exit_ptr=VC2_Exit;
+ VC_SetNumVoices_ptr=VC2_SetNumVoices;
+ VC_SampleSpace_ptr=VC2_SampleSpace;
+ VC_SampleLength_ptr=VC2_SampleLength;
+ VC_PlayStart_ptr=VC2_PlayStart;
+ VC_PlayStop_ptr=VC2_PlayStop;
+ VC_SampleLoad_ptr=VC2_SampleLoad;
+ VC_SampleUnload_ptr=VC2_SampleUnload;
+ VC_WriteBytes_ptr=VC2_WriteBytes;
+ VC_SilenceBytes_ptr=VC2_SilenceBytes;
+ VC_VoiceSetVolume_ptr=VC2_VoiceSetVolume;
+ VC_VoiceGetVolume_ptr=VC2_VoiceGetVolume;
+ VC_VoiceSetFrequency_ptr=VC2_VoiceSetFrequency;
+ VC_VoiceGetFrequency_ptr=VC2_VoiceGetFrequency;
+ VC_VoiceSetPanning_ptr=VC2_VoiceSetPanning;
+ VC_VoiceGetPanning_ptr=VC2_VoiceGetPanning;
+ VC_VoicePlay_ptr=VC2_VoicePlay;
+ VC_VoiceStop_ptr=VC2_VoiceStop;
+ VC_VoiceStopped_ptr=VC2_VoiceStopped;
+ VC_VoiceGetPosition_ptr=VC2_VoiceGetPosition;
+ VC_VoiceRealVolume_ptr=VC2_VoiceRealVolume;
+ } else {
+ VC_Init_ptr=VC1_Init;
+ VC_Exit_ptr=VC1_Exit;
+ VC_SetNumVoices_ptr=VC1_SetNumVoices;
+ VC_SampleSpace_ptr=VC1_SampleSpace;
+ VC_SampleLength_ptr=VC1_SampleLength;
+ VC_PlayStart_ptr=VC1_PlayStart;
+ VC_PlayStop_ptr=VC1_PlayStop;
+ VC_SampleLoad_ptr=VC1_SampleLoad;
+ VC_SampleUnload_ptr=VC1_SampleUnload;
+ VC_WriteBytes_ptr=VC1_WriteBytes;
+ VC_SilenceBytes_ptr=VC1_SilenceBytes;
+ VC_VoiceSetVolume_ptr=VC1_VoiceSetVolume;
+ VC_VoiceGetVolume_ptr=VC1_VoiceGetVolume;
+ VC_VoiceSetFrequency_ptr=VC1_VoiceSetFrequency;
+ VC_VoiceGetFrequency_ptr=VC1_VoiceGetFrequency;
+ VC_VoiceSetPanning_ptr=VC1_VoiceSetPanning;
+ VC_VoiceGetPanning_ptr=VC1_VoiceGetPanning;
+ VC_VoicePlay_ptr=VC1_VoicePlay;
+ VC_VoiceStop_ptr=VC1_VoiceStop;
+ VC_VoiceStopped_ptr=VC1_VoiceStopped;
+ VC_VoiceGetPosition_ptr=VC1_VoiceGetPosition;
+ VC_VoiceRealVolume_ptr=VC1_VoiceRealVolume;
+ }
+}
+#endif/* !NO_HQMIXER */
+
+#else /* _IN_VIRTCH_ */
+
+#ifndef _VIRTCH_COMMON_
+#define _VIRTCH_COMMON_
+
+static ULONG samples2bytes(ULONG samples)
+{
+ if(vc_mode & DMODE_FLOAT) samples <<= 2;
+ else if(vc_mode & DMODE_16BITS) samples <<= 1;
+ if(vc_mode & DMODE_STEREO) samples <<= 1;
+ return samples;
+}
+
+static ULONG bytes2samples(ULONG bytes)
+{
+ if(vc_mode & DMODE_FLOAT) bytes >>= 2;
+ else if(vc_mode & DMODE_16BITS) bytes >>= 1;
+ if(vc_mode & DMODE_STEREO) bytes >>= 1;
+ return bytes;
+}
+
+/* Fill the buffer with 'todo' bytes of silence (it depends on the mixing mode
+ how the buffer is filled) */
+ULONG VC1_SilenceBytes(SBYTE* buf,ULONG todo)
+{
+ todo=samples2bytes(bytes2samples(todo));
+
+ /* clear the buffer to zero (16 bits signed) or 0x80 (8 bits unsigned) */
+ if(vc_mode &(DMODE_16BITS|DMODE_FLOAT))
+ memset(buf,0,todo);
+ else
+ memset(buf,0x80,todo);
+
+ return todo;
+}
+
+void VC1_WriteSamples(SBYTE*,ULONG);
+
+/* Writes 'todo' mixed SBYTES (!!) to 'buf'. It returns the number of SBYTES
+ actually written to 'buf' (which is rounded to number of samples that fit
+ into 'todo' bytes). */
+ULONG VC1_WriteBytes(SBYTE* buf,ULONG todo)
+{
+ if(!vc_softchn)
+ return VC1_SilenceBytes(buf,todo);
+
+ todo = bytes2samples(todo);
+ VC1_WriteSamples(buf,todo);
+
+ return samples2bytes(todo);
+}
+
+void VC1_Exit(void)
+{
+ MikMod_free(vinf);
+ MikMod_afree(vc_tickbuf);
+ MikMod_afree(Samples);
+
+ vc_tickbuf = NULL;
+ vinf = NULL;
+ Samples = NULL;
+
+ VC_SetupPointers();
+}
+
+UWORD VC1_VoiceGetVolume(UBYTE voice)
+{
+ return vinf[voice].vol;
+}
+
+ULONG VC1_VoiceGetPanning(UBYTE voice)
+{
+ return vinf[voice].pan;
+}
+
+void VC1_VoiceSetFrequency(UBYTE voice,ULONG frq)
+{
+ vinf[voice].frq=frq;
+}
+
+ULONG VC1_VoiceGetFrequency(UBYTE voice)
+{
+ return vinf[voice].frq;
+}
+
+void VC1_VoicePlay(UBYTE voice,SWORD handle,ULONG start,ULONG size,ULONG reppos,ULONG repend,UWORD flags)
+{
+ vinf[voice].flags = flags;
+ vinf[voice].handle = handle;
+ vinf[voice].start = start;
+ vinf[voice].size = size;
+ vinf[voice].reppos = reppos;
+ vinf[voice].repend = repend;
+ vinf[voice].kick = 1;
+}
+
+void VC1_VoiceStop(UBYTE voice)
+{
+ vinf[voice].active = 0;
+}
+
+BOOL VC1_VoiceStopped(UBYTE voice)
+{
+ return(vinf[voice].active==0);
+}
+
+SLONG VC1_VoiceGetPosition(UBYTE voice)
+{
+ return (SLONG)(vinf[voice].current>>FRACBITS);
+}
+
+void VC1_VoiceSetVolume(UBYTE voice,UWORD vol)
+{
+ /* protect against clicks if volume variation is too high */
+ if(abs((int)vinf[voice].vol-(int)vol)>32)
+ vinf[voice].rampvol=CLICK_BUFFER;
+ vinf[voice].vol=vol;
+}
+
+void VC1_VoiceSetPanning(UBYTE voice,ULONG pan)
+{
+ /* protect against clicks if panning variation is too high */
+ if(abs((int)vinf[voice].pan-(int)pan)>48)
+ vinf[voice].rampvol=CLICK_BUFFER;
+ vinf[voice].pan=pan;
+}
+
+/*========== External mixer interface */
+
+void VC1_SampleUnload(SWORD handle)
+{
+ if (Samples && (handle < MAXSAMPLEHANDLES)) {
+ MikMod_afree(Samples[handle]);
+ Samples[handle]=NULL;
+ }
+}
+
+SWORD VC1_SampleLoad(struct SAMPLOAD* sload,int type)
+{
+ SAMPLE *s = sload->sample;
+ int handle;
+ ULONG t, length,loopstart,loopend,looplen;
+
+ if(type==MD_HARDWARE) return -1;
+
+ /* Find empty slot to put sample address in */
+ for(handle=0;handle<MAXSAMPLEHANDLES;handle++)
+ if(!Samples[handle]) break;
+
+ if(handle==MAXSAMPLEHANDLES) {
+ _mm_errno = MMERR_OUT_OF_HANDLES;
+ return -1;
+ }
+
+ /* Reality check for loop settings */
+ if (s->loopend > s->length)
+ s->loopend = s->length;
+ if (s->loopstart >= s->loopend)
+ s->flags &= ~SF_LOOP;
+
+ length = s->length;
+ loopstart = s->loopstart;
+ loopend = s->loopend;
+
+ SL_SampleSigned(sload);
+ SL_Sample8to16(sload);
+
+ if(!(Samples[handle]=(SWORD*)MikMod_amalloc((length+20)<<1))) {
+ _mm_errno = MMERR_SAMPLE_TOO_BIG;
+ return -1;
+ }
+
+ /* read sample into buffer */
+ if (SL_Load(Samples[handle],sload,length))
+ return -1;
+
+ /* Unclick sample */
+ if(s->flags & SF_LOOP) {
+ looplen = loopend - loopstart;/* handle short samples */
+ if(s->flags & SF_BIDI)
+ for(t=0;t<16 && t<looplen;t++)
+ Samples[handle][loopend+t]=Samples[handle][(loopend-t)-1];
+ else
+ for(t=0;t<16 && t<looplen;t++)
+ Samples[handle][loopend+t]=Samples[handle][t+loopstart];
+ } else
+ for(t=0;t<16;t++)
+ Samples[handle][t+length]=0;
+
+ return handle;
+}
+
+ULONG VC1_SampleSpace(int type)
+{
+ return vc_memory;
+}
+
+ULONG VC1_SampleLength(int type,SAMPLE* s)
+{
+ if (!s) return 0;
+
+ return (s->length*((s->flags&SF_16BITS)?2:1))+16;
+}
+
+ULONG VC1_VoiceRealVolume(UBYTE voice)
+{
+ ULONG i,s,size;
+ int k,j;
+ SWORD *smp;
+ SLONG t;
+
+ t = (SLONG)(vinf[voice].current>>FRACBITS);
+ if(!vinf[voice].active) return 0;
+
+ s = vinf[voice].handle;
+ size = vinf[voice].size;
+
+ i=64; t-=64; k=0; j=0;
+ if(i>size) i = size;
+ if(t<0) t = 0;
+ if(t+i > size) t = size-i;
+
+ i &= ~1; /* make sure it's EVEN. */
+
+ smp = &Samples[s][t];
+ for(;i;i--,smp++) {
+ if(k<*smp) k = *smp;
+ if(j>*smp) j = *smp;
+ }
+ return abs(k-j);
+}
+
+#endif /* _VIRTCH_COMMON_ */
+
+#endif /* _IN_VIRTCH_ */
+
+/* ex:set ts=4: */
--- /dev/null
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+
+int memcmp(const void *__s1, const void *__s2, size_t __n)
+{
+ const char *scan1, *scan2;
+ size_t n;
+
+ scan1 = __s1;
+ scan2 = __s2;
+ for (n = __n; n > 0; n--)
+ if (*scan1 == *scan2) {
+ scan1++;
+ scan2++;
+ } else
+ return *scan1 - *scan2;
+
+ return 0;
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "mikmod_internals.h"
+#include "mikmod_ctype.h"
+
+int _mm_strcasecmp(const char *__s1, const char *__s2)
+{
+ const char *p1 = __s1;
+ const char *p2 = __s2;
+ char c1, c2;
+
+ if (p1 == p2) return 0;
+
+ do {
+ c1 = mik_tolower(*p1++);
+ c2 = mik_tolower(*p2++);
+ if (c1 == '\0') break;
+ } while (c1 == c2);
+
+ return (int)(c1 - c2);
+}
--- /dev/null
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+
+char *strstr(const char *haystack, const char *needle)
+{
+ const char *scan;
+ size_t len;
+ char firstc;
+
+ firstc = *needle;
+ len = strlen(needle);
+ for (scan = haystack; *scan != firstc || strncmp(scan, needle, len); )
+ if (!*scan++)
+ return NULL;
+ return (char *)scan;
+}
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#if defined(__WATCOMC__) || defined(_MSC_VER) || defined(__DJGPP__)
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include "3dgfx.h"
+#include "gfxutil.h"
+#include "polyfill.h"
+#include "polyclip.h"
+#include "inttypes.h"
+#include "demo.h"
+#include "util.h"
+
+#define STACK_SIZE 8
+typedef float g3d_matrix[16];
+
+#define MAX_LIGHTS 4
+
+#define IMM_VBUF_SIZE 256
+
+struct light {
+ float x, y, z;
+ float r, g, b;
+};
+
+struct material {
+ float kd[3];
+ float ks[3];
+ float shin;
+};
+
+struct g3d_state {
+ unsigned int opt;
+ int frontface;
+ int fill_mode;
+
+ g3d_matrix mat[G3D_NUM_MATRICES][STACK_SIZE];
+ int mtop[G3D_NUM_MATRICES];
+ int mmode;
+
+ g3d_matrix norm_mat;
+
+ float ambient[3];
+ struct light lt[MAX_LIGHTS];
+ struct material mtl;
+
+ int width, height;
+ uint16_t *pixels;
+
+ int vport[4];
+
+ /* immediate mode */
+ int imm_prim;
+ int imm_numv, imm_pcount;
+ struct g3d_vertex imm_curv;
+ struct g3d_vertex imm_vbuf[IMM_VBUF_SIZE];
+};
+
+static void imm_flush(void);
+static void xform4_vec3(const float *mat, float *vec);
+static void xform3_vec3(const float *mat, float *vec);
+static void shade(struct g3d_vertex *v);
+
+static struct g3d_state *st;
+static const float idmat[] = {
+ 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1
+};
+
+int g3d_init(void)
+{
+ int i;
+
+ if(!(st = calloc(1, sizeof *st))) {
+ fprintf(stderr, "failed to allocate G3D context\n");
+ return -1;
+ }
+ st->fill_mode = POLYFILL_FLAT;
+
+ for(i=0; i<G3D_NUM_MATRICES; i++) {
+ g3d_matrix_mode(i);
+ g3d_load_identity();
+ }
+
+ for(i=0; i<MAX_LIGHTS; i++) {
+ g3d_light_color(i, 1, 1, 1);
+ }
+ g3d_light_ambient(0.1, 0.1, 0.1);
+
+ g3d_mtl_diffuse(1, 1, 1);
+ return 0;
+}
+
+void g3d_destroy(void)
+{
+ free(st);
+}
+
+void g3d_framebuffer(int width, int height, void *pixels)
+{
+ st->width = width;
+ st->height = height;
+ st->pixels = pixels;
+
+ pfill_fb.pixels = pixels;
+ pfill_fb.width = width;
+ pfill_fb.height = height;
+
+ g3d_viewport(0, 0, width, height);
+}
+
+void g3d_viewport(int x, int y, int w, int h)
+{
+ st->vport[0] = x;
+ st->vport[1] = y;
+ st->vport[2] = w;
+ st->vport[3] = h;
+}
+
+void g3d_enable(unsigned int opt)
+{
+ st->opt |= opt;
+}
+
+void g3d_disable(unsigned int opt)
+{
+ st->opt &= ~opt;
+}
+
+void g3d_setopt(unsigned int opt, unsigned int mask)
+{
+ st->opt = (st->opt & ~mask) | (opt & mask);
+}
+
+unsigned int g3d_getopt(unsigned int mask)
+{
+ return st->opt & mask;
+}
+
+void g3d_front_face(unsigned int order)
+{
+ st->frontface = order;
+}
+
+void g3d_polygon_mode(int pmode)
+{
+ st->fill_mode = pmode;
+}
+
+void g3d_matrix_mode(int mmode)
+{
+ st->mmode = mmode;
+}
+
+void g3d_load_identity(void)
+{
+ int top = st->mtop[st->mmode];
+ memcpy(st->mat[st->mmode][top], idmat, 16 * sizeof(float));
+}
+
+void g3d_load_matrix(const float *m)
+{
+ int top = st->mtop[st->mmode];
+ memcpy(st->mat[st->mmode][top], m, 16 * sizeof(float));
+}
+
+#define M(i,j) (((i) << 2) + (j))
+void g3d_mult_matrix(const float *m2)
+{
+ int i, j, top = st->mtop[st->mmode];
+ float m1[16];
+ float *dest = st->mat[st->mmode][top];
+
+ memcpy(m1, dest, sizeof m1);
+
+ for(i=0; i<4; i++) {
+ for(j=0; j<4; j++) {
+ *dest++ = m1[M(0,j)] * m2[M(i,0)] +
+ m1[M(1,j)] * m2[M(i,1)] +
+ m1[M(2,j)] * m2[M(i,2)] +
+ m1[M(3,j)] * m2[M(i,3)];
+ }
+ }
+}
+
+void g3d_push_matrix(void)
+{
+ int top = st->mtop[st->mmode];
+ if(top >= G3D_NUM_MATRICES) {
+ fprintf(stderr, "g3d_push_matrix overflow\n");
+ return;
+ }
+ memcpy(st->mat[st->mmode][top + 1], st->mat[st->mmode][top], 16 * sizeof(float));
+ st->mtop[st->mmode] = top + 1;
+}
+
+void g3d_pop_matrix(void)
+{
+ if(st->mtop[st->mmode] <= 0) {
+ fprintf(stderr, "g3d_pop_matrix underflow\n");
+ return;
+ }
+ --st->mtop[st->mmode];
+}
+
+void g3d_translate(float x, float y, float z)
+{
+ float m[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
+ m[12] = x;
+ m[13] = y;
+ m[14] = z;
+ g3d_mult_matrix(m);
+}
+
+void g3d_rotate(float deg, float x, float y, float z)
+{
+ float m[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+ float angle = M_PI * deg / 180.0f;
+ float sina = sin(angle);
+ float cosa = cos(angle);
+ float one_minus_cosa = 1.0f - cosa;
+ float nxsq = x * x;
+ float nysq = y * y;
+ float nzsq = z * z;
+
+ m[0] = nxsq + (1.0f - nxsq) * cosa;
+ m[4] = x * y * one_minus_cosa - z * sina;
+ m[8] = x * z * one_minus_cosa + y * sina;
+ m[1] = x * y * one_minus_cosa + z * sina;
+ m[5] = nysq + (1.0 - nysq) * cosa;
+ m[9] = y * z * one_minus_cosa - x * sina;
+ m[2] = x * z * one_minus_cosa - y * sina;
+ m[6] = y * z * one_minus_cosa + x * sina;
+ m[10] = nzsq + (1.0 - nzsq) * cosa;
+ m[15] = 1.0f;
+
+ g3d_mult_matrix(m);
+}
+
+void g3d_scale(float x, float y, float z)
+{
+ float m[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ m[0] = x;
+ m[5] = y;
+ m[10] = z;
+ m[15] = 1.0f;
+ g3d_mult_matrix(m);
+}
+
+void g3d_ortho(float left, float right, float bottom, float top, float znear, float zfar)
+{
+ float m[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+ float dx = right - left;
+ float dy = top - bottom;
+ float dz = zfar - znear;
+
+ m[0] = 2.0 / dx;
+ m[5] = 2.0 / dy;
+ m[10] = -2.0 / dz;
+ m[12] = -(right + left) / dx;
+ m[13] = -(top + bottom) / dy;
+ m[14] = -(zfar + znear) / dz;
+
+ g3d_mult_matrix(m);
+}
+
+void g3d_frustum(float left, float right, float bottom, float top, float nr, float fr)
+{
+ float m[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+ float dx = right - left;
+ float dy = top - bottom;
+ float dz = fr - nr;
+
+ float a = (right + left) / dx;
+ float b = (top + bottom) / dy;
+ float c = -(fr + nr) / dz;
+ float d = -2.0 * fr * nr / dz;
+
+ m[0] = 2.0 * nr / dx;
+ m[5] = 2.0 * nr / dy;
+ m[8] = a;
+ m[9] = b;
+ m[10] = c;
+ m[11] = -1.0f;
+ m[14] = d;
+
+ g3d_mult_matrix(m);
+}
+
+void g3d_perspective(float vfov_deg, float aspect, float znear, float zfar)
+{
+ float m[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+ float vfov = M_PI * vfov_deg / 180.0f;
+ float s = 1.0f / tan(vfov * 0.5f);
+ float range = znear - zfar;
+
+ m[0] = s / aspect;
+ m[5] = s;
+ m[10] = (znear + zfar) / range;
+ m[11] = -1.0f;
+ m[14] = 2.0f * znear * zfar / range;
+
+ g3d_mult_matrix(m);
+}
+
+const float *g3d_get_matrix(int which, float *m)
+{
+ int top = st->mtop[which];
+
+ if(m) {
+ memcpy(m, st->mat[which][top], 16 * sizeof(float));
+ }
+ return st->mat[which][top];
+}
+
+void g3d_light_pos(int idx, float x, float y, float z)
+{
+ int mvtop = st->mtop[G3D_MODELVIEW];
+
+ st->lt[idx].x = x;
+ st->lt[idx].y = y;
+ st->lt[idx].z = z;
+
+ xform4_vec3(st->mat[G3D_MODELVIEW][mvtop], &st->lt[idx].x);
+}
+
+void g3d_light_color(int idx, float r, float g, float b)
+{
+ st->lt[idx].r = r;
+ st->lt[idx].g = g;
+ st->lt[idx].b = b;
+}
+
+void g3d_light_ambient(float r, float g, float b)
+{
+ st->ambient[0] = r;
+ st->ambient[1] = g;
+ st->ambient[2] = b;
+}
+
+void g3d_mtl_diffuse(float r, float g, float b)
+{
+ st->mtl.kd[0] = r;
+ st->mtl.kd[1] = g;
+ st->mtl.kd[2] = b;
+}
+
+void g3d_mtl_specular(float r, float g, float b)
+{
+ st->mtl.ks[0] = r;
+ st->mtl.ks[1] = g;
+ st->mtl.ks[2] = b;
+}
+
+void g3d_mtl_shininess(float shin)
+{
+ st->mtl.shin = shin;
+}
+
+static INLINE int calc_shift(unsigned int x)
+{
+ int res = -1;
+ while(x) {
+ x >>= 1;
+ ++res;
+ }
+ return res;
+}
+
+static INLINE int calc_mask(unsigned int x)
+{
+ return x - 1;
+}
+
+void g3d_set_texture(int xsz, int ysz, void *pixels)
+{
+ pfill_tex.pixels = pixels;
+ pfill_tex.width = xsz;
+ pfill_tex.height = ysz;
+
+ pfill_tex.xshift = calc_shift(xsz);
+ pfill_tex.yshift = calc_shift(ysz);
+ pfill_tex.xmask = calc_mask(xsz);
+ pfill_tex.ymask = calc_mask(ysz);
+}
+
+void g3d_draw(int prim, const struct g3d_vertex *varr, int varr_size)
+{
+ g3d_draw_indexed(prim, varr, varr_size, 0, 0);
+}
+
+void g3d_draw_indexed(int prim, const struct g3d_vertex *varr, int varr_size,
+ const uint16_t *iarr, int iarr_size)
+{
+ int i, j, vnum, nfaces;
+ struct pvertex pv[16];
+ struct g3d_vertex v[16];
+ int mvtop = st->mtop[G3D_MODELVIEW];
+ int ptop = st->mtop[G3D_PROJECTION];
+ struct g3d_vertex *tmpv;
+
+ tmpv = alloca(prim * 6 * sizeof *tmpv);
+
+ /* calc the normal matrix */
+ memcpy(st->norm_mat, st->mat[G3D_MODELVIEW][mvtop], 16 * sizeof(float));
+ st->norm_mat[12] = st->norm_mat[13] = st->norm_mat[14] = 0.0f;
+
+ nfaces = (iarr ? iarr_size : varr_size) / prim;
+
+ for(j=0; j<nfaces; j++) {
+ vnum = prim; /* reset vnum for each iteration */
+
+ for(i=0; i<vnum; i++) {
+ v[i] = iarr ? varr[*iarr++] : *varr++;
+
+ xform4_vec3(st->mat[G3D_MODELVIEW][mvtop], &v[i].x);
+ xform3_vec3(st->norm_mat, &v[i].nx);
+
+ if(st->opt & G3D_LIGHTING) {
+ shade(v + i);
+ }
+ if(st->opt & G3D_TEXTURE_GEN) {
+ v[i].u = v[i].nx * 0.5 + 0.5;
+ v[i].v = v[i].ny * 0.5 + 0.5;
+ }
+ xform4_vec3(st->mat[G3D_PROJECTION][ptop], &v[i].x);
+ }
+
+ /* clipping */
+ for(i=0; i<6; i++) {
+ memcpy(tmpv, v, vnum * sizeof *v);
+
+ if(clip_frustum(v, &vnum, tmpv, vnum, i) < 0) {
+ /* polygon completely outside of view volume. discard */
+ vnum = 0;
+ break;
+ }
+ }
+
+ if(!vnum) continue;
+
+ for(i=0; i<vnum; i++) {
+ if(v[i].w != 0.0f) {
+ v[i].x /= v[i].w;
+ v[i].y /= v[i].w;
+ /*v[i].z /= v[i].w;*/
+ }
+
+ /* viewport transformation */
+ v[i].x = (v[i].x * 0.5f + 0.5f) * (float)st->vport[2] + st->vport[0];
+ v[i].y = (0.5f - v[i].y * 0.5f) * (float)st->vport[3] + st->vport[1];
+
+ /* convert pos to 24.8 fixed point */
+ pv[i].x = cround64(v[i].x * 256.0f);
+ pv[i].y = cround64(v[i].y * 256.0f);
+ /* convert tex coords to 16.16 fixed point */
+ pv[i].u = cround64(v[i].u * 65536.0f);
+ pv[i].v = cround64(v[i].v * 65536.0f);
+ /* pass the color through as is */
+ pv[i].r = v[i].r;
+ pv[i].g = v[i].g;
+ pv[i].b = v[i].b;
+ pv[i].a = v[i].a;
+ }
+
+ /* backface culling */
+ if(vnum > 2 && st->opt & G3D_CULL_FACE) {
+ int32_t ax = pv[1].x - pv[0].x;
+ int32_t ay = pv[1].y - pv[0].y;
+ int32_t bx = pv[2].x - pv[0].x;
+ int32_t by = pv[2].y - pv[0].y;
+ int32_t cross_z = (ax >> 4) * (by >> 4) - (ay >> 4) * (bx >> 4);
+ int sign = (cross_z >> 31) & 1;
+
+ if(!(sign ^ st->frontface)) {
+ continue; /* back-facing */
+ }
+ }
+
+ switch(vnum) {
+ case 1:
+ if(st->opt & G3D_BLEND) {
+ int r, g, b;
+ int inv_alpha = 255 - pv[0].a;
+ uint16_t *dest = st->pixels + (pv[0].y >> 8) * st->width + (pv[0].x >> 8);
+ r = ((int)pv[0].r * pv[0].a + UNPACK_R16(*dest) * inv_alpha) >> 8;
+ g = ((int)pv[0].g * pv[0].a + UNPACK_G16(*dest) * inv_alpha) >> 8;
+ b = ((int)pv[0].b * pv[0].a + UNPACK_B16(*dest) * inv_alpha) >> 8;
+ *dest++ = PACK_RGB16(r, g, b);
+ } else {
+ uint16_t *dest = st->pixels + (pv[0].y >> 8) * st->width + (pv[0].x >> 8);
+ *dest = PACK_RGB16(pv[0].r, pv[0].g, pv[0].b);
+ }
+ break;
+
+ case 2:
+ /* TODO: draw line */
+ break;
+
+ default:
+ polyfill(st->fill_mode, pv, vnum);
+ }
+ }
+}
+
+void g3d_begin(int prim)
+{
+ st->imm_prim = prim;
+ st->imm_pcount = prim;
+ st->imm_numv = 0;
+}
+
+void g3d_end(void)
+{
+ imm_flush();
+}
+
+static void imm_flush(void)
+{
+ int numv = st->imm_numv;
+ st->imm_numv = 0;
+ g3d_draw_indexed(st->imm_prim, st->imm_vbuf, numv, 0, 0);
+}
+
+void g3d_vertex(float x, float y, float z)
+{
+ struct g3d_vertex *vptr = st->imm_vbuf + st->imm_numv++;
+ *vptr = st->imm_curv;
+ vptr->x = x;
+ vptr->y = y;
+ vptr->z = z;
+ vptr->w = 1.0f;
+
+ if(!--st->imm_pcount) {
+ if(st->imm_numv >= IMM_VBUF_SIZE - st->imm_prim) {
+ imm_flush();
+ }
+ st->imm_pcount = st->imm_prim;
+ }
+}
+
+void g3d_normal(float x, float y, float z)
+{
+ st->imm_curv.nx = x;
+ st->imm_curv.ny = y;
+ st->imm_curv.nz = z;
+}
+
+void g3d_color3b(unsigned char r, unsigned char g, unsigned char b)
+{
+ st->imm_curv.r = r;
+ st->imm_curv.g = g;
+ st->imm_curv.b = b;
+ st->imm_curv.a = 255;
+}
+
+void g3d_color4b(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+ st->imm_curv.r = r;
+ st->imm_curv.g = g;
+ st->imm_curv.b = b;
+ st->imm_curv.a = a;
+}
+
+void g3d_color3f(float r, float g, float b)
+{
+ int ir = r * 255.0f;
+ int ig = g * 255.0f;
+ int ib = b * 255.0f;
+ st->imm_curv.r = ir > 255 ? 255 : ir;
+ st->imm_curv.g = ig > 255 ? 255 : ig;
+ st->imm_curv.b = ib > 255 ? 255 : ib;
+ st->imm_curv.a = 255;
+}
+
+void g3d_color4f(float r, float g, float b, float a)
+{
+ int ir = r * 255.0f;
+ int ig = g * 255.0f;
+ int ib = b * 255.0f;
+ int ia = a * 255.0f;
+ st->imm_curv.r = ir > 255 ? 255 : ir;
+ st->imm_curv.g = ig > 255 ? 255 : ig;
+ st->imm_curv.b = ib > 255 ? 255 : ib;
+ st->imm_curv.a = ia > 255 ? 255 : ia;
+}
+
+void g3d_texcoord(float u, float v)
+{
+ st->imm_curv.u = u;
+ st->imm_curv.v = v;
+}
+
+static void xform4_vec3(const float *mat, float *vec)
+{
+ float x = mat[0] * vec[0] + mat[4] * vec[1] + mat[8] * vec[2] + mat[12];
+ float y = mat[1] * vec[0] + mat[5] * vec[1] + mat[9] * vec[2] + mat[13];
+ float z = mat[2] * vec[0] + mat[6] * vec[1] + mat[10] * vec[2] + mat[14];
+ float w = mat[3] * vec[0] + mat[7] * vec[1] + mat[11] * vec[2] + mat[15];
+
+ vec[0] = x;
+ vec[1] = y;
+ vec[2] = z;
+ vec[3] = w;
+}
+
+static void xform3_vec3(const float *mat, float *vec)
+{
+ float x = mat[0] * vec[0] + mat[4] * vec[1] + mat[8] * vec[2];
+ float y = mat[1] * vec[0] + mat[5] * vec[1] + mat[9] * vec[2];
+ float z = mat[2] * vec[0] + mat[6] * vec[1] + mat[10] * vec[2];
+
+ vec[0] = x;
+ vec[1] = y;
+ vec[2] = z;
+}
+
+#define NORMALIZE(v) \
+ do { \
+ float len = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); \
+ if(len != 0.0) { \
+ float s = 1.0 / len; \
+ v[0] *= s; \
+ v[1] *= s; \
+ v[2] *= s; \
+ } \
+ } while(0)
+
+static void shade(struct g3d_vertex *v)
+{
+ int i, r, g, b;
+ float color[3];
+
+ color[0] = st->ambient[0] * st->mtl.kd[0];
+ color[1] = st->ambient[1] * st->mtl.kd[1];
+ color[2] = st->ambient[2] * st->mtl.kd[2];
+
+ for(i=0; i<MAX_LIGHTS; i++) {
+ float ldir[3];
+ float ndotl;
+
+ if(!(st->opt & (G3D_LIGHT0 << i))) {
+ continue;
+ }
+
+ ldir[0] = st->lt[i].x - v->x;
+ ldir[1] = st->lt[i].y - v->y;
+ ldir[2] = st->lt[i].z - v->z;
+ NORMALIZE(ldir);
+
+ if((ndotl = v->nx * ldir[0] + v->ny * ldir[1] + v->nz * ldir[2]) < 0.0f) {
+ ndotl = 0.0f;
+ }
+
+ color[0] += st->mtl.kd[0] * st->lt[i].r * ndotl;
+ color[1] += st->mtl.kd[1] * st->lt[i].g * ndotl;
+ color[2] += st->mtl.kd[2] * st->lt[i].b * ndotl;
+ }
+
+ r = cround64(color[0] * 255.0);
+ g = cround64(color[1] * 255.0);
+ b = cround64(color[2] * 255.0);
+
+ v->r = r > 255 ? 255 : r;
+ v->g = g > 255 ? 255 : g;
+ v->b = b > 255 ? 255 : b;
+}
--- /dev/null
+#ifndef THREEDGFX_H_
+#define THREEDGFX_H_
+
+#include "inttypes.h"
+
+struct g3d_vertex {
+ float x, y, z, w;
+ float nx, ny, nz;
+ float u, v;
+ unsigned char r, g, b, a;
+};
+
+enum {
+ G3D_POINTS = 1,
+ G3D_LINES = 2,
+ G3D_TRIANGLES = 3,
+ G3D_QUADS = 4
+};
+
+/* g3d_enable/g3d_disable bits */
+enum {
+ G3D_CULL_FACE = 0x0001,
+ G3D_DEPTH_TEST = 0x0002, /* XXX not implemented */
+ G3D_LIGHTING = 0x0004,
+ G3D_LIGHT0 = 0x0008,
+ G3D_LIGHT1 = 0x0010,
+ G3D_LIGHT2 = 0x0020,
+ G3D_LIGHT3 = 0x0040,
+ G3D_TEXTURE = 0x0080,
+ G3D_BLEND = 0x0100,
+ G3D_TEXTURE_GEN = 0x0200,
+
+ G3D_ALL = 0x7fffffff
+};
+
+/* arg to g3d_front_face */
+enum { G3D_CCW, G3D_CW };
+
+/* arg to g3d_polygon_mode */
+enum {
+ G3D_WIRE,
+ G3D_FLAT,
+ G3D_GOURAUD,
+ G3D_TEX,
+ G3D_TEX_GOURAUD
+};
+
+/* matrix stacks */
+enum {
+ G3D_MODELVIEW,
+ G3D_PROJECTION,
+
+ G3D_NUM_MATRICES
+};
+
+int g3d_init(void);
+void g3d_destroy(void);
+
+void g3d_framebuffer(int width, int height, void *pixels);
+void g3d_viewport(int x, int y, int w, int h);
+
+void g3d_enable(unsigned int opt);
+void g3d_disable(unsigned int opt);
+void g3d_setopt(unsigned int opt, unsigned int mask);
+unsigned int g3d_getopt(unsigned int mask);
+
+void g3d_front_face(unsigned int order);
+void g3d_polygon_mode(int pmode);
+
+void g3d_matrix_mode(int mmode);
+
+void g3d_load_identity(void);
+void g3d_load_matrix(const float *m);
+void g3d_mult_matrix(const float *m);
+void g3d_push_matrix(void);
+void g3d_pop_matrix(void);
+
+void g3d_translate(float x, float y, float z);
+void g3d_rotate(float angle, float x, float y, float z);
+void g3d_scale(float x, float y, float z);
+void g3d_ortho(float left, float right, float bottom, float top, float znear, float zfar);
+void g3d_frustum(float left, float right, float bottom, float top, float znear, float zfar);
+void g3d_perspective(float vfov, float aspect, float znear, float zfar);
+
+/* returns pointer to the *internal* matrix, and if argument m is not null,
+ * also copies the internal matrix there. */
+const float *g3d_get_matrix(int which, float *m);
+
+void g3d_light_pos(int idx, float x, float y, float z);
+void g3d_light_color(int idx, float r, float g, float b);
+
+void g3d_light_ambient(float r, float g, float b);
+
+void g3d_mtl_diffuse(float r, float g, float b);
+void g3d_mtl_specular(float r, float g, float b);
+void g3d_mtl_shininess(float shin);
+
+void g3d_set_texture(int xsz, int ysz, void *pixels);
+
+void g3d_draw(int prim, const struct g3d_vertex *varr, int varr_size);
+void g3d_draw_indexed(int prim, const struct g3d_vertex *varr, int varr_size,
+ const uint16_t *iarr, int iarr_size);
+
+void g3d_begin(int prim);
+void g3d_end(void);
+void g3d_vertex(float x, float y, float z);
+void g3d_normal(float x, float y, float z);
+void g3d_color3b(unsigned char r, unsigned char g, unsigned char b);
+void g3d_color4b(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
+void g3d_color3f(float r, float g, float b);
+void g3d_color4f(float r, float g, float b, float a);
+void g3d_texcoord(float u, float v);
+
+#endif /* THREEDGFX_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include "cfgopt.h"
+
+struct options opt = {
+ 0, /* start_scr */
+ 0, /* music */
+ 0, /* sball */
+ 1 /* vsync */
+};
+
+int parse_args(int argc, char **argv)
+{
+ int i;
+ char *scrname = 0;
+
+ for(i=1; i<argc; i++) {
+ if(argv[i][0] == '-') {
+ if(strcmp(argv[i], "-music") == 0) {
+ opt.music = 1;
+ } else if(strcmp(argv[i], "-nomusic") == 0) {
+ opt.music = 0;
+ } else if(strcmp(argv[i], "-scr") == 0 || strcmp(argv[i], "-screen") == 0) {
+ scrname = argv[++i];
+ } else if(strcmp(argv[i], "-sball") == 0) {
+ opt.sball = !opt.sball;
+ } else if(strcmp(argv[i], "-vsync") == 0) {
+ opt.vsync = 1;
+ } else if(strcmp(argv[i], "-novsync") == 0) {
+ opt.vsync = 0;
+ } else {
+ fprintf(stderr, "invalid option: %s\n", argv[i]);
+ return -1;
+ }
+ } else {
+ if(scrname) {
+ fprintf(stderr, "unexpected option: %s\n", argv[i]);
+ return -1;
+ }
+ scrname = argv[i];
+ }
+ }
+
+ if(scrname) {
+ opt.start_scr = scrname;
+ }
+ return 0;
+}
+
+static char *strip_space(char *s)
+{
+ int len;
+ char *end;
+
+ while(*s && isspace(*s)) ++s;
+ if(!*s) return 0;
+
+ if((end = strrchr(s, '#'))) {
+ --end;
+ } else {
+ len = strlen(s);
+ end = s + len - 1;
+ }
+
+ while(end > s && isspace(*end)) *end-- = 0;
+ return end > s ? s : 0;
+}
+
+static int bool_value(char *s)
+{
+ char *ptr = s;
+ while(*ptr) {
+ *ptr = tolower(*ptr);
+ ++ptr;
+ }
+
+ return strcmp(s, "true") == 0 || strcmp(s, "yes") == 0 || strcmp(s, "1") == 0;
+}
+
+int load_config(const char *fname)
+{
+ FILE *fp;
+ char buf[256];
+ int nline = 0;
+
+ if(!(fp = fopen(fname, "rb"))) {
+ return 0; /* just ignore missing config files */
+ }
+
+ while(fgets(buf, sizeof buf, fp)) {
+ char *line, *key, *value;
+
+ ++nline;
+ if(!(line = strip_space(buf))) {
+ continue;
+ }
+
+ if(!(value = strchr(line, '='))) {
+ fprintf(stderr, "%s:%d invalid key/value pair\n", fname, nline);
+ return -1;
+ }
+ *value++ = 0;
+
+ if(!(key = strip_space(line)) || !(value = strip_space(value))) {
+ fprintf(stderr, "%s:%d invalid key/value pair\n", fname, nline);
+ return -1;
+ }
+
+ if(strcmp(line, "music") == 0) {
+ opt.music = bool_value(value);
+ } else if(strcmp(line, "screen") == 0) {
+ opt.start_scr = strdup(value);
+ } else if(strcmp(line, "sball") == 0) {
+ opt.sball = bool_value(value);
+ } else if(strcmp(line, "vsync") == 0) {
+ opt.vsync = bool_value(value);
+ } else {
+ fprintf(stderr, "%s:%d invalid option: %s\n", fname, nline, line);
+ return -1;
+ }
+ }
+ return 0;
+}
--- /dev/null
+#ifndef CFGOPT_H_
+#define CFGOPT_H_
+
+struct options {
+ const char *start_scr;
+ int music;
+ int sball;
+ int vsync;
+};
+
+extern struct options opt;
+
+int parse_args(int argc, char **argv);
+int load_config(const char *fname);
+
+#endif /* CFGOPT_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include "demo.h"
+#include "screen.h"
+#include "3dgfx.h"
+#include "music.h"
+#include "cfgopt.h"
+#include "tinyfps.h"
+#include "util.h"
+
+int fb_width = 320;
+int fb_height = 240;
+int fb_bpp = 16;
+uint16_t *fb_pixels, *vmem_back, *vmem_front;
+unsigned long time_msec;
+int mouse_x, mouse_y;
+unsigned int mouse_bmask;
+
+float sball_matrix[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
+
+static unsigned long nframes;
+static int console_active;
+
+int demo_init(int argc, char **argv)
+{
+ struct screen *scr;
+ char *env;
+
+ if(load_config("demo.cfg") == -1) {
+ return -1;
+ }
+ if((env = getenv("START_SCR"))) {
+ opt.start_scr = env;
+ }
+ if(parse_args(argc, argv) == -1) {
+ return -1;
+ }
+
+ initFpsFonts();
+
+ if(g3d_init() == -1) {
+ return -1;
+ }
+ g3d_framebuffer(fb_width, fb_height, fb_pixels);
+
+ if(opt.music) {
+ if(music_open("data/test.mod") == -1) {
+ return -1;
+ }
+ }
+
+ if(scr_init() == -1) {
+ return -1;
+ }
+ if(opt.start_scr) {
+ scr = scr_lookup(opt.start_scr);
+ } else {
+ scr = scr_screen(0);
+ }
+
+ if(!scr || scr_change(scr, 4000) == -1) {
+ fprintf(stderr, "screen %s not found\n", opt.start_scr ? opt.start_scr : "0");
+ return -1;
+ }
+
+ /* clear the framebuffer at least once */
+ memset(fb_pixels, 0, fb_width * fb_height * fb_bpp / CHAR_BIT);
+
+ if(opt.music) {
+ music_play();
+ }
+ return 0;
+}
+
+void demo_cleanup(void)
+{
+ if(opt.music) {
+ music_close();
+ }
+ scr_shutdown();
+ g3d_destroy();
+
+ if(time_msec) {
+ float fps = (float)nframes / ((float)time_msec / 1000.0f);
+ printf("average framerate: %.1f\n", fps);
+ }
+}
+
+void demo_draw(void)
+{
+ if(opt.music) {
+ music_update();
+ }
+ scr_update();
+ scr_draw();
+
+ ++nframes;
+}
+
+static void change_screen(int idx)
+{
+ printf("change screen %d\n", idx);
+ scr_change(scr_screen(idx), 4000);
+}
+
+#define CBUF_SIZE 64
+#define CBUF_MASK (CBUF_SIZE - 1)
+void demo_keyboard(int key, int press)
+{
+ static char cbuf[CBUF_SIZE];
+ static int rd, wr;
+ char inp[CBUF_SIZE + 1], *dptr;
+ int i, nscr;
+
+ if(press) {
+ switch(key) {
+ case 27:
+ demo_quit();
+ return;
+
+ case 127:
+ debug_break();
+ return;
+
+ case '`':
+ console_active = !console_active;
+ if(console_active) {
+ printf("> ");
+ fflush(stdout);
+ } else {
+ putchar('\n');
+ }
+ return;
+
+ case '\b':
+ if(console_active) {
+ if(wr != rd) {
+ printf("\b \b");
+ fflush(stdout);
+ wr = (wr + CBUF_SIZE - 1) & CBUF_MASK;
+ }
+ return;
+ }
+ break;
+
+ case '\n':
+ case '\r':
+ if(console_active) {
+ dptr = inp;
+ while(rd != wr) {
+ *dptr++ = cbuf[rd];
+ rd = (rd + 1) & CBUF_MASK;
+ }
+ *dptr = 0;
+ if(inp[0]) {
+ printf("\ntrying to match: %s\n", inp);
+ nscr = scr_num_screens();
+ for(i=0; i<nscr; i++) {
+ if(strstr(scr_screen(i)->name, inp)) {
+ change_screen(i);
+ break;
+ }
+ }
+ }
+ console_active = 0;
+ return;
+ }
+ break;
+
+ default:
+ if(key >= '1' && key <= '9' && key <= '1' + scr_num_screens()) {
+ change_screen(key - '1');
+ } else if(key == '0' && scr_num_screens() >= 10) {
+ change_screen(9);
+ }
+
+ if(console_active) {
+ if(key < 256 && isprint(key)) {
+ putchar(key);
+ fflush(stdout);
+
+ cbuf[wr] = key;
+ wr = (wr + 1) & CBUF_MASK;
+ if(wr == rd) { /* overflow */
+ rd = (rd + 1) & CBUF_MASK;
+ }
+ }
+ return;
+ }
+ break;
+ }
+
+ scr_keypress(key);
+ }
+}
+
+
+void mouse_orbit_update(float *theta, float *phi, float *dist)
+{
+ static int prev_mx, prev_my;
+ static unsigned int prev_bmask;
+
+ if(mouse_bmask) {
+ if((mouse_bmask ^ prev_bmask) == 0) {
+ int dx = mouse_x - prev_mx;
+ int dy = mouse_y - prev_my;
+
+ if(dx || dy) {
+ if(mouse_bmask & 1) {
+ float p = *phi;
+ *theta += dx * 1.0;
+ p += dy * 1.0;
+
+ if(p < -90) p = -90;
+ if(p > 90) p = 90;
+ *phi = p;
+ }
+ if(mouse_bmask & 4) {
+ *dist += dy * 0.5;
+
+ if(*dist < 0) *dist = 0;
+ }
+ }
+ }
+ }
+ prev_mx = mouse_x;
+ prev_my = mouse_y;
+ prev_bmask = mouse_bmask;
+}
--- /dev/null
+#ifndef DEMO_H_
+#define DEMO_H_
+
+#include "inttypes.h"
+
+extern int fb_width, fb_height, fb_bpp;
+extern uint16_t *fb_pixels; /* system-RAM pixel buffer: use swap_buffers(fb_pixels) */
+/* video memory pointers. might both point to the front buffer if there is not
+ * enough memory for page flipping. use swap_buffers(0) to flip. */
+extern uint16_t *vmem_back, *vmem_front;
+
+extern unsigned long time_msec;
+extern int mouse_x, mouse_y;
+extern unsigned int mouse_bmask;
+
+extern float sball_matrix[16];
+
+int demo_init(int argc, char **argv);
+void demo_cleanup(void);
+
+void demo_draw(void);
+
+void demo_keyboard(int key, int press);
+
+
+/* defined in main_*.c */
+void demo_quit(void);
+unsigned long get_msec(void);
+void set_palette(int idx, int r, int g, int b);
+
+/* pass 0 to just swap vmem_back/vmem_front with page flipping
+ * pass a pointer to a system-ram pixel buffer to copy it to vmem_front,
+ * instead of flipping.
+ */
+void swap_buffers(void *pixels);
+
+/* call each frame to get 3D viewing spherical coordinates */
+void mouse_orbit_update(float *theta, float *phi, float *dist);
+
+#endif /* DEMO_H_ */
--- /dev/null
+#ifndef DPMI_H_
+#define DPMI_H_
+
+#ifdef __DJGPP__
+#include <dpmi.h>
+#endif
+
+#include "inttypes.h"
+
+struct dpmi_real_regs {
+ uint32_t edi, esi, ebp;
+ uint32_t reserved;
+ uint32_t ebx, edx, ecx, eax;
+ uint16_t flags;
+ uint16_t es, ds, fs, gs;
+ uint16_t ip, cs, sp, ss;
+};
+
+uint16_t dpmi_alloc(unsigned int par, uint16_t *sel);
+void dpmi_free(uint16_t sel);
+
+#ifdef __WATCOMC__
+#pragma aux dpmi_alloc = \
+ "mov eax, 0x100" \
+ "int 0x31" \
+ "mov [edi], dx" \
+ value[ax] parm[ebx][edi];
+
+#pragma aux dpmi_free = \
+ "mov eax, 0x101" \
+ "int 0x31" \
+ parm[dx];
+
+void dpmi_real_int(int inum, struct dpmi_real_regs *regs);
+#endif /* __WATCOMC__ */
+
+#ifdef __DJGPP__
+#define dpmi_real_int(inum, regs) __dpmi_int((inum), (__dpmi_regs*)(regs))
+#endif
+
+void *dpmi_mmap(uint32_t phys_addr, unsigned int size);
+void dpmi_munmap(void *addr);
+
+#endif /* DPMI_H_ */
--- /dev/null
+#ifdef __DJGPP__
+#include <dpmi.h>
+#include <sys/nearptr.h>
+#include "cdpmi.h"
+#include "inttypes.h"
+
+uint16_t dpmi_alloc(unsigned int par, uint16_t *sel)
+{
+ int tmp;
+ uint16_t seg = __dpmi_allocate_dos_memory(par, &tmp);
+ *sel = tmp;
+ return seg;
+}
+
+void dpmi_free(uint16_t sel)
+{
+ __dpmi_free_dos_memory(sel);
+}
+
+void *dpmi_mmap(uint32_t phys_addr, unsigned int size)
+{
+ __dpmi_meminfo mem;
+ mem.address = phys_addr;
+ mem.size = size;
+ __dpmi_physical_address_mapping(&mem);
+ return (void*)(mem.address - __djgpp_base_address);
+}
+
+void dpmi_munmap(void *addr)
+{
+ __dpmi_meminfo mem;
+ mem.address = (uint32_t)addr + __djgpp_base_address;
+ __dpmi_free_physical_address_mapping(&mem);
+}
+#endif /* __DJGPP__ */
--- /dev/null
+#ifndef GFX_H_
+#define GFX_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "vbe.h"
+#include "cdpmi.h"
+
+#ifdef __DJGPP__
+#include <sys/nearptr.h>
+
+#define REALPTR(s, o) (void*)(((uint32_t)(s) << 4) - __djgpp_base_address + (uint32_t)(o))
+#else
+#define REALPTR(s, o) (void*)(((uint32_t)(s) << 4) + (uint32_t)(o))
+#endif
+
+#define VBEPTR(x) REALPTR(((x) & 0xffff0000) >> 16, (x) & 0xffff)
+#define VBEPTR_SEG(x) (((x) & 0xffff0000) >> 16)
+#define VBEPTR_OFF(x) ((x) & 0xffff)
+
+#define SAME_BPP(a, b) \
+ ((a) == (b) || ((a) == 16 && (b) == 15) || ((a) == 15 && (b) == 16) || \
+ ((a) == 32 && (b) == 24) || ((a) == 24 && (b) == 32))
+
+static unsigned int make_mask(int sz, int pos);
+
+static struct vbe_info *vbe_info;
+static struct vbe_mode_info *mode_info;
+static int pal_bits = 6;
+
+void *set_video_mode(int xsz, int ysz, int bpp)
+{
+ int i;
+ static uint16_t *modes;
+ uint16_t best = 0;
+ unsigned int fbsize;
+
+#ifdef __DJGPP__
+ __djgpp_nearptr_enable();
+#endif
+
+ /* check for VBE2 support and output some info */
+ if(!vbe_info) {
+ if(!(vbe_info = vbe_get_info())) {
+ fprintf(stderr, "VESA BIOS Extensions not available\n");
+ return 0;
+ }
+
+ printf("VBE Version: %x.%x\n", vbe_info->version >> 8, vbe_info->version & 0xff);
+ if(vbe_info->version < 0x200) {
+ fprintf(stderr, "This program requires VBE 2.0 or greater. Try running UniVBE\n");
+ return 0;
+ }
+
+ printf("Graphics adapter: %s, %s (%s)\n", (char*)VBEPTR(vbe_info->oem_vendor_name_ptr),
+ (char*)VBEPTR(vbe_info->oem_product_name_ptr), (char*)VBEPTR(vbe_info->oem_product_rev_ptr));
+ printf("Video memory: %dkb\n", vbe_info->total_mem << 6);
+
+ modes = VBEPTR(vbe_info->vid_mode_ptr);
+ }
+
+ for(i=0; i<1024; i++) { /* impose an upper limit to avoid inf-loops */
+ if(modes[i] == 0xffff) {
+ break; /* reached the end */
+ }
+
+ mode_info = vbe_get_mode_info(modes[i] | VBE_MODE_LFB);
+ if(!mode_info || mode_info->xres != xsz || mode_info->yres != ysz) {
+ continue;
+ }
+ if(SAME_BPP(mode_info->bpp, bpp)) {
+ best = modes[i];
+ }
+ }
+
+ if(best) {
+ mode_info = vbe_get_mode_info(best);
+ } else {
+ fprintf(stderr, "Requested video mode (%dx%d %dbpp) is unavailable\n", xsz, ysz, bpp);
+ return 0;
+ }
+
+ if(vbe_set_mode(best | VBE_MODE_LFB) == -1) {
+ fprintf(stderr, "Failed to set video mode %dx%d %dbpp\n", mode_info->xres, mode_info->yres, mode_info->bpp);
+ return 0;
+ }
+
+ /* attempt to set 8 bits of color per component in palettized modes */
+ /*if(bpp <= 8) {
+ pal_bits = vbe_set_palette_bits(8);
+ printf("palette bits per color primary: %d\n", pal_bits);
+ }
+ */
+
+ fbsize = xsz * ysz * mode_info->num_img_pages * (bpp / CHAR_BIT);
+ return (void*)dpmi_mmap(mode_info->fb_addr, fbsize);
+}
+
+int set_text_mode(void)
+{
+ vbe_set_mode(0x3);
+ return 0;
+}
+
+int get_color_depth(void)
+{
+ if(!mode_info) {
+ return -1;
+ }
+ return mode_info->bpp;
+}
+
+int get_color_bits(int *rbits, int *gbits, int *bbits)
+{
+ if(!mode_info) {
+ return -1;
+ }
+ *rbits = mode_info->rmask_size;
+ *gbits = mode_info->gmask_size;
+ *bbits = mode_info->bmask_size;
+ return 0;
+}
+
+int get_color_mask(unsigned int *rmask, unsigned int *gmask, unsigned int *bmask)
+{
+ if(!mode_info) {
+ return -1;
+ }
+ *rmask = make_mask(mode_info->rmask_size, mode_info->rpos);
+ *gmask = make_mask(mode_info->gmask_size, mode_info->gpos);
+ *bmask = make_mask(mode_info->bmask_size, mode_info->bpos);
+ return 0;
+}
+
+int get_color_shift(int *rshift, int *gshift, int *bshift)
+{
+ if(!mode_info) {
+ return -1;
+ }
+ *rshift = mode_info->rpos;
+ *gshift = mode_info->gpos;
+ *bshift = mode_info->bpos;
+ return 0;
+}
+
+void set_palette(int idx, int r, int g, int b)
+{
+ int col[3];
+ col[0] = r;
+ col[1] = g;
+ col[2] = b;
+ vbe_set_palette(idx, col, 1, pal_bits);
+}
+
+static unsigned int make_mask(int sz, int pos)
+{
+ unsigned int i, mask = 0;
+
+ for(i=0; i<sz; i++) {
+ mask |= 1 << i;
+ }
+ return mask << pos;
+}
+
+
+#endif /* GFX_H_ */
--- /dev/null
+#ifndef GFX_H_
+#define GFX_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *set_video_mode(int xsz, int ysz, int bpp);
+int set_text_mode(void);
+
+int get_color_depth(void);
+int get_color_bits(int *rbits, int *gbits, int *bbits);
+int get_color_shift(int *rshift, int *gshift, int *bshift);
+int get_color_mask(unsigned int *rmask, unsigned int *gmask, unsigned int *bmask);
+
+void set_palette(int idx, int r, int g, int b);
+
+#ifdef __WATCOMC__
+void wait_vsync(void);
+#pragma aux wait_vsync = \
+ "mov dx, 0x3da" \
+ "l1:" \
+ "in al, dx" \
+ "and al, 0x8" \
+ "jnz l1" \
+ "l2:" \
+ "in al, dx" \
+ "and al, 0x8" \
+ "jz l2" \
+ modify[al dx];
+#endif
+
+#ifdef __DJGPP__
+#define wait_vsync() asm volatile ( \
+ "mov $0x3da, %%dx\n\t" \
+ "0:\n\t" \
+ "in %%dx, %%al\n\t" \
+ "and $8, %%al\n\t" \
+ "jnz 0b\n\t" \
+ "0:\n\t" \
+ "in %%dx, %%al\n\t" \
+ "and $8, %%al\n\t" \
+ "jz 0b\n\t" \
+ :::"%eax","%edx")
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GFX_H_ */
--- /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(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
+/*
+DOS interrupt-based keyboard driver.
+Copyright (C) 2013 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 the program. If not, see <http://www.gnu.org/licenses/>
+*/
+#define KEYB_C_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <conio.h>
+#include <dos.h>
+
+#ifdef __WATCOMC__
+#include <i86.h>
+#endif
+#ifdef __DJGPP__
+#include <stdint.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <pc.h>
+#endif
+
+#include "keyb.h"
+#include "scancode.h"
+
+#define KB_INTR 0x9
+#define KB_PORT 0x60
+
+#define PIC1_CMD_PORT 0x20
+#define OCW2_EOI (1 << 5)
+
+#ifdef __WATCOMC__
+#define INTERRUPT __interrupt __far
+
+#define DONE_INIT (prev_handler)
+static void (INTERRUPT *prev_handler)();
+#endif
+
+#ifdef __DJGPP__
+#define INTERRUPT
+
+#define DONE_INIT prev_intr.pm_offset
+static _go32_dpmi_seginfo intr, prev_intr;
+
+#define outp(p, v) outportb(p, v)
+#define inp(p) inportb(p)
+#endif
+
+static void INTERRUPT kbintr();
+
+static int *buffer;
+static int buffer_size, buf_ridx, buf_widx;
+static int last_key;
+
+static unsigned int num_pressed;
+static unsigned char keystate[256];
+
+#define ADVANCE(x) ((x) = ((x) + 1) % buffer_size)
+
+int kb_init(int bufsz)
+{
+ if(DONE_INIT) {
+ fprintf(stderr, "keyboard driver already initialized!\n");
+ return 0;
+ }
+
+ buffer_size = bufsz;
+ if(buffer_size && !(buffer = malloc(buffer_size * sizeof *buffer))) {
+ fprintf(stderr, "failed to allocate input buffer, continuing without\n");
+ buffer_size = 0;
+ }
+ buf_ridx = buf_widx = 0;
+ last_key = -1;
+
+ memset(keystate, 0, sizeof keystate);
+ num_pressed = 0;
+
+ /* set our interrupt handler */
+ _disable();
+#ifdef __WATCOMC__
+ prev_handler = _dos_getvect(KB_INTR);
+ _dos_setvect(KB_INTR, kbintr);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_get_protected_mode_interrupt_vector(KB_INTR, &prev_intr);
+ intr.pm_offset = (intptr_t)kbintr;
+ intr.pm_selector = _go32_my_cs();
+ _go32_dpmi_allocate_iret_wrapper(&intr);
+ _go32_dpmi_set_protected_mode_interrupt_vector(KB_INTR, &intr);
+#endif
+ _enable();
+
+ return 0;
+}
+
+void kb_shutdown(void)
+{
+ if(!DONE_INIT) {
+ return;
+ }
+
+ /* restore the original interrupt handler */
+ _disable();
+#ifdef __WATCOMC__
+ _dos_setvect(KB_INTR, prev_handler);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_set_protected_mode_interrupt_vector(KB_INTR, &prev_intr);
+ _go32_dpmi_free_iret_wrapper(&intr);
+#endif
+ _enable();
+
+ free(buffer);
+}
+
+int kb_isdown(int key)
+{
+ switch(key) {
+ case KB_ANY:
+ return num_pressed;
+
+ case KB_ALT:
+ return keystate[KB_LALT] + keystate[KB_RALT];
+
+ case KB_CTRL:
+ return keystate[KB_LCTRL] + keystate[KB_RCTRL];
+ }
+ return keystate[key];
+}
+
+#ifdef __WATCOMC__
+void halt(void);
+#pragma aux halt = \
+ "sti" \
+ "hlt";
+#endif
+
+#ifdef __DJGPP__
+#define halt() asm volatile("sti\n\thlt\n\t")
+#endif
+
+void kb_wait(void)
+{
+ int key;
+ while((key = kb_getkey()) == -1) {
+ /* put the processor to sleep while waiting for keypresses, but first
+ * make sure interrupts are enabled, or we'll sleep forever
+ */
+ halt();
+ }
+ kb_putback(key);
+}
+
+int kb_getkey(void)
+{
+ int res;
+
+ if(buffer) {
+ if(buf_ridx == buf_widx) {
+ return -1;
+ }
+ res = buffer[buf_ridx];
+ ADVANCE(buf_ridx);
+ } else {
+ res = last_key;
+ last_key = -1;
+ }
+ return res;
+}
+
+void kb_putback(int key)
+{
+ if(buffer) {
+ /* go back a place */
+ if(--buf_ridx < 0) {
+ buf_ridx += buffer_size;
+ }
+
+ /* if the write end hasn't caught up with us, go back one place
+ * and put it there, otherwise just overwrite the oldest key which
+ * is right where we were.
+ */
+ if(buf_ridx == buf_widx) {
+ ADVANCE(buf_ridx);
+ }
+
+ buffer[buf_ridx] = key;
+ } else {
+ last_key = key;
+ }
+}
+
+static void INTERRUPT kbintr()
+{
+ unsigned char code;
+ int key, press;
+
+ code = inp(KB_PORT);
+
+ if(code >= 128) {
+ press = 0;
+ code -= 128;
+
+ if(num_pressed > 0) {
+ num_pressed--;
+ }
+ } else {
+ press = 1;
+
+ num_pressed++;
+ }
+
+ key = scantbl[code];
+
+ if(press) {
+ /* append to buffer */
+ last_key = key;
+ if(buffer_size > 0) {
+ buffer[buf_widx] = key;
+ ADVANCE(buf_widx);
+ /* if the write end overtook the read end, advance the read end
+ * too, to discard the oldest keypress from the buffer
+ */
+ if(buf_widx == buf_ridx) {
+ ADVANCE(buf_ridx);
+ }
+ }
+ }
+
+ /* and update keystate table */
+ keystate[key] = press;
+
+ outp(PIC1_CMD_PORT, OCW2_EOI); /* send end-of-interrupt */
+}
--- /dev/null
+/*
+DOS interrupt-based keyboard driver.
+Copyright (C) 2013 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 the program. If not, see <http://www.gnu.org/licenses/>
+*/
+#ifndef KEYB_H_
+#define KEYB_H_
+
+#define KB_ANY (-1)
+#define KB_ALT (-2)
+#define KB_CTRL (-3)
+#define KB_SHIFT (-4)
+
+/* special keys */
+enum {
+ KB_LALT, KB_RALT,
+ KB_LCTRL, KB_RCTRL,
+ KB_LSHIFT, KB_RSHIFT,
+ KB_F1, KB_F2, KB_F3, KB_F4, KB_F5, KB_F6,
+ KB_F7, KB_F8, KB_F9, KB_F10, KB_F11, KB_F12,
+ KB_CAPSLK, KB_NUMLK, KB_SCRLK, KB_SYSRQ,
+ KB_ESC = 27,
+ KB_INSERT, KB_DEL, KB_HOME, KB_END, KB_PGUP, KB_PGDN,
+ KB_LEFT, KB_RIGHT, KB_UP, KB_DOWN,
+ KB_NUM_DOT, KB_NUM_ENTER, KB_NUM_PLUS, KB_NUM_MINUS, KB_NUM_MUL, KB_NUM_DIV,
+ KB_NUM_0, KB_NUM_1, KB_NUM_2, KB_NUM_3, KB_NUM_4,
+ KB_NUM_5, KB_NUM_6, KB_NUM_7, KB_NUM_8, KB_NUM_9,
+ KB_BACKSP = 127
+};
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int kb_init(int bufsz); /* bufsz can be 0 for no buffered keys */
+void kb_shutdown(void); /* don't forget to call this at the end! */
+
+/* Boolean predicate for testing the current state of a particular key.
+ * You may also pass KB_ANY to test if any key is held down.
+ */
+int kb_isdown(int key);
+
+/* waits for any keypress */
+void kb_wait(void);
+
+/* removes and returns a single key from the input buffer.
+ * If buffering is disabled (initialized with kb_init(0)), then it always
+ * returns the last key pressed.
+ */
+int kb_getkey(void);
+
+void kb_putback(int key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* KEYB_H_ */
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "logger.h"
+
+int init_logger(const char *fname)
+{
+ int fd;
+ if((fd = open(fname, O_CREAT | O_WRONLY | O_TRUNC, 0644)) == -1) {
+ fprintf(stderr, "init_logger: failed to open %s: %s\n", fname, strerror(errno));
+ return -1;
+ }
+
+ close(1);
+ close(2);
+ dup(fd);
+ dup(fd);
+ return 0;
+}
--- /dev/null
+#ifndef LOGGER_H_
+#define LOGGER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int init_logger(const char *fname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOGGER_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <limits.h>
+#include <conio.h>
+#include "demo.h"
+#include "keyb.h"
+#include "mouse.h"
+#include "timer.h"
+#include "gfx.h"
+#include "vmath.h"
+#include "sball.h"
+#include "cfgopt.h"
+#include "logger.h"
+#include "tinyfps.h"
+
+#undef NOKEYB
+
+static int handle_sball_event(sball_event *ev);
+static void recalc_sball_matrix(float *xform);
+
+static int quit;
+static int use_mouse;
+static long fbsize;
+
+static int use_sball;
+static vec3_t pos = {0, 0, 0};
+static quat_t rot = {0, 0, 0, 1};
+
+int main(int argc, char **argv)
+{
+ fbsize = fb_width * fb_height * fb_bpp / CHAR_BIT;
+
+ init_logger("demo.log");
+
+ init_timer(100);
+#ifndef NOKEYB
+ kb_init(32);
+#endif
+
+ if((use_mouse = have_mouse())) {
+ printf("initializing mouse input\n");
+ set_mouse_limits(0, 0, fb_width, fb_height);
+ set_mouse(fb_width / 2, fb_height / 2);
+ }
+
+ if(!(fb_pixels = malloc(fbsize))) {
+ fprintf(stderr, "failed to allocate backbuffer\n");
+ return 1;
+ }
+
+ if(!(vmem_front = set_video_mode(fb_width, fb_height, fb_bpp))) {
+ return 1;
+ }
+ /* TODO implement multiple video memory pages for flipping */
+ vmem_back = vmem_front;
+
+ if(demo_init(argc, argv) == -1) {
+ set_text_mode();
+ return 1;
+ }
+
+ if(opt.sball && sball_init() == 0) {
+ use_sball = 1;
+ }
+
+ reset_timer();
+
+ while(!quit) {
+#ifndef NOKEYB
+ int key;
+ while((key = kb_getkey()) != -1) {
+ demo_keyboard(key, 1);
+ }
+#else
+ if(kbhit()) {
+ demo_keyboard(getch(), 1);
+ }
+#endif
+ if(quit) goto break_evloop;
+
+ if(use_mouse) {
+ mouse_bmask = read_mouse(&mouse_x, &mouse_y);
+ }
+ if(use_sball && sball_pending()) {
+ sball_event ev;
+ printf("got sball event\n");
+ while(sball_getevent(&ev)) {
+ handle_sball_event(&ev);
+ }
+ recalc_sball_matrix(sball_matrix);
+ }
+
+ time_msec = get_msec();
+ demo_draw();
+ }
+
+break_evloop:
+ set_text_mode();
+ demo_cleanup();
+#ifndef NOKEYB
+ kb_shutdown();
+#endif
+ if(use_sball) {
+ sball_shutdown();
+ }
+ return 0;
+}
+
+void demo_quit(void)
+{
+ quit = 1;
+}
+
+void swap_buffers(void *pixels)
+{
+ /* TODO implement page flipping */
+ if(pixels) {
+ if(opt.vsync) {
+ wait_vsync();
+ }
+ drawFps(pixels);
+ memcpy(vmem_front, pixels, fbsize);
+ } else {
+ drawFps(vmem_back);
+
+ if(opt.vsync) {
+ wait_vsync();
+ }
+ }
+}
+
+
+#define TX(ev) ((ev)->motion.motion[0])
+#define TY(ev) ((ev)->motion.motion[1])
+#define TZ(ev) ((ev)->motion.motion[2])
+#define RX(ev) ((ev)->motion.motion[3])
+#define RY(ev) ((ev)->motion.motion[4])
+#define RZ(ev) ((ev)->motion.motion[5])
+
+static int handle_sball_event(sball_event *ev)
+{
+ switch(ev->type) {
+ case SBALL_EV_MOTION:
+ if(RX(ev) | RY(ev) | RZ(ev)) {
+ float rx = (float)RX(ev);
+ float ry = (float)RY(ev);
+ float rz = (float)RZ(ev);
+ float axis_len = sqrt(rx * rx + ry * ry + rz * rz);
+ if(axis_len > 0.0) {
+ rot = quat_rotate(rot, axis_len * 0.001, -rx / axis_len,
+ -ry / axis_len, -rz / axis_len);
+ }
+ }
+
+ pos.x += TX(ev) * 0.001;
+ pos.y += TY(ev) * 0.001;
+ pos.z += TZ(ev) * 0.001;
+ break;
+
+ case SBALL_EV_BUTTON:
+ if(ev->button.pressed) {
+ pos = v3_cons(0, 0, 0);
+ rot = quat_cons(1, 0, 0, 0);
+ }
+ break;
+ }
+
+ return 0;
+}
+
+void recalc_sball_matrix(float *xform)
+{
+ quat_to_mat(xform, rot);
+ xform[12] = pos.x;
+ xform[13] = pos.y;
+ xform[14] = pos.z;
+}
--- /dev/null
+#ifndef MOUSE_H_
+#define MOUSE_H_
+
+enum {
+ MOUSE_LEFT = 1,
+ MOUSE_RIGHT = 2,
+ MOUSE_MIDDLE = 4
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int have_mouse(void);
+void show_mouse(int show);
+int read_mouse(int *xp, int *yp);
+void set_mouse(int x, int y);
+void set_mouse_limits(int xmin, int ymin, int xmax, int ymax);
+void set_mouse_rate(int xrate, int yrate);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MOUSE_H_ */
--- /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 PIT8254_H_
+#define PIT8254_H_
+
+/* frequency of the oscillator driving the 8254 timer */
+#define OSC_FREQ_HZ 1193182
+
+/* I/O ports connected to the 8254 */
+#define PORT_DATA0 0x40
+#define PORT_DATA1 0x41
+#define PORT_DATA2 0x42
+#define PORT_CMD 0x43
+
+/* command bits */
+#define CMD_CHAN0 0
+#define CMD_CHAN1 (1 << 6)
+#define CMD_CHAN2 (2 << 6)
+#define CMD_RDBACK (3 << 6)
+
+#define CMD_LATCH 0
+#define CMD_ACCESS_LOW (1 << 4)
+#define CMD_ACCESS_HIGH (2 << 4)
+#define CMD_ACCESS_BOTH (3 << 4)
+
+#define CMD_OP_INT_TERM 0
+#define CMD_OP_ONESHOT (1 << 1)
+#define CMD_OP_RATE (2 << 1)
+#define CMD_OP_SQWAVE (3 << 1)
+#define CMD_OP_SW_STROBE (4 << 1)
+#define CMD_OP_HW_STROBE (5 << 1)
+
+#define CMD_MODE_BIN 0
+#define CMD_MODE_BCD 1
+
+#endif /* PIT8254_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dos.h>
+#include <conio.h>
+
+#ifdef __WATCOMC__
+#include <i86.h>
+#endif
+
+#ifdef __DJGPP__
+#include <stdint.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <pc.h>
+#endif
+
+#include "sball.h"
+
+struct motion {
+ int x, y, z;
+ int rx, ry, rz;
+};
+
+#define UART1_BASE 0x3f8
+#define UART2_BASE 0x2f8
+#define UART1_IRQ 4
+#define UART2_IRQ 3
+
+#define UART_DATA 0
+#define UART_INTR 1
+#define UART_DIVLO 0
+#define UART_DIVHI 1
+#define UART_FIFO 2
+#define UART_IID 2
+#define UART_LCTL 3
+#define UART_MCTL 4
+#define UART_LSTAT 5
+#define UART_MSTAT 6
+
+/* interrupt enable register bits */
+#define INTR_RECV 1
+#define INTR_SEND 2
+#define INTR_LSTAT 4
+#define INTR_DELTA 8
+
+/* fifo control register bits */
+#define FIFO_ENABLE 0x01
+#define FIFO_RECV_CLEAR 0x02
+#define FIFO_SEND_CLEAR 0x04
+#define FIFO_DMA 0x08
+#define FIFO_TRIG_4 0x40
+#define FIFO_TRIG_8 0x80
+#define FIFO_TRIG_14 0xc0
+
+/* interrupt id register bits */
+#define IID_PENDING 0x01
+#define IID_ID0 0x02
+#define IID_ID1 0x04
+#define IID_ID2 0x08
+#define IID_FIFO_EN 0xc0
+
+#define IID_SOURCE 0xe
+
+#define IID_DELTA 0
+#define IID_SEND 0x2
+#define IID_RECV 0x4
+#define IID_FIFO 0xc
+#define IID_STATUS 0x6
+
+/* line control register bits */
+#define LCTL_BITS_8 0x03
+#define LCTL_STOP_2 0x04
+#define LCTL_DLAB 0x80
+#define LCTL_8N1 LCTL_BITS_8
+#define LCTL_8N2 (LCTL_BITS_8 | LCTL_STOP_2)
+
+/* modem control register bits */
+#define MCTL_DTR 0x01
+#define MCTL_RTS 0x02
+#define MCTL_OUT1 0x04
+#define MCTL_OUT2 0x08
+#define MCTL_LOOP 0x10
+
+/* line status register bits */
+#define LST_DRDY 0x01
+#define LST_ERR_OVER 0x02
+#define LST_ERR_PARITY 0x04
+#define LST_ERR_FRAME 0x08
+#define LST_ERR_BRK 0x10
+#define LST_TREG_EMPTY 0x20
+#define LST_TIDLE 0x40
+#define LST_ERROR 0x80
+
+/* modem status register bits */
+#define MST_DELTA_CTS 0x01
+#define MST_DELTA_DSR 0x02
+#define MST_TERI 0x04
+#define MST_DELTA_DCD 0x08
+#define MST_CTS 0x10
+#define MST_DSR 0x20
+#define MST_RING 0x40
+#define MST_DCD 0x80
+
+/* interrupt controller stuff */
+#define PIC1_CMD_PORT 0x20
+#define PIC1_DATA_PORT 0x21
+#define PIC2_CMD_PORT 0xa0
+#define PIC2_DATA_PORT 0xa1
+#define OCW2_EOI 0x20
+
+struct packet {
+ int id;
+ char data[80];
+};
+
+static int init_smouse(void);
+static void read_motion(int *m, const char *s);
+static void read_keystate(unsigned int *stptr, const char *s);
+static void procpkt(struct packet *p);
+static void enqueue_event(sball_event *ev);
+
+#define COM_FMT_8N1 LCTL_8N1
+#define COM_FMT_8N2 LCTL_8N2
+static void com_setup(int port, int baud, unsigned int fmt);
+static void com_close(void);
+
+static void com_putc(char c);
+static void com_puts(const char *s);
+static int com_getc(void);
+static char *com_gets(char *buf, int sz);
+
+static int com_have_recv(void);
+static int com_can_send(void);
+
+#ifdef __WATCOMC__
+#define INTERRUPT __interrupt __far
+static void (INTERRUPT *prev_recv_intr)(void);
+#endif
+
+#ifdef __DJGPP__
+#define INTERRUPT
+
+static _go32_dpmi_seginfo intr, prev_intr;
+
+#define outp(port, val) outportb(port, val)
+#define inp(port) inportb(port)
+#endif
+
+static void INTERRUPT recv_intr(void);
+
+static int uart_base, uart_intr_num;
+
+static struct packet pktbuf[16];
+static int pktbuf_ridx, pktbuf_widx;
+#define BNEXT(x) (((x) + 1) & 0xf)
+#define BEMPTY(b) (b##_ridx == b##_widx)
+
+static sball_event evbuf[16];
+static int evbuf_ridx, evbuf_widx;
+
+
+int sball_init(void)
+{
+ com_setup(0, 9600, COM_FMT_8N2);
+ init_smouse();
+ return 0;
+}
+
+void sball_shutdown(void)
+{
+ com_close();
+}
+
+int sball_getdev(void)
+{
+ return 0;
+}
+
+int sball_pending(void)
+{
+ _disable();
+ while(!BEMPTY(pktbuf)) {
+ procpkt(pktbuf + pktbuf_ridx);
+ pktbuf_ridx = BNEXT(pktbuf_ridx);
+ }
+ _enable();
+ return !BEMPTY(evbuf);
+}
+
+int sball_getevent(sball_event *ev)
+{
+ _disable();
+ while(!BEMPTY(pktbuf)) {
+ procpkt(pktbuf + pktbuf_ridx);
+ pktbuf_ridx = BNEXT(pktbuf_ridx);
+ }
+ _enable();
+
+ if(BEMPTY(evbuf)) {
+ return 0;
+ }
+ *ev = evbuf[evbuf_ridx];
+ evbuf_ridx = BNEXT(evbuf_ridx);
+ return 1;
+}
+
+static int init_smouse(void)
+{
+ /* try repeatedly zeroing the device until we get a response */
+ do {
+ delay(500);
+ com_puts("z\r");
+ } while(BEMPTY(pktbuf));
+
+ /* then ask for id string and request motion updates */
+ com_puts("vQ\r");
+ com_puts("m3\r");
+ return 0;
+}
+
+static void procpkt(struct packet *p)
+{
+ static unsigned int bnstate;
+ int i;
+ unsigned int st, delta, prev;
+ sball_event *ev;
+
+ switch(p->id) {
+ case 'd':
+ ev = evbuf + evbuf_widx;
+ read_motion(ev->motion.motion, p->data);
+ ev->type = SBALL_EV_MOTION;
+ enqueue_event(ev);
+ break;
+
+ case 'k':
+ read_keystate(&st, p->data);
+
+ delta = st ^ bnstate;
+ prev = bnstate;
+ bnstate = st;
+
+ for(i=0; i<32; i++) {
+ if(delta & 1) {
+ ev = evbuf + evbuf_widx;
+ ev->type = SBALL_EV_BUTTON;
+ ev->button.id = i;
+ ev->button.pressed = st & 1;
+ ev->button.state = prev ^ (1 << i);
+ enqueue_event(ev);
+ }
+ st >>= 1;
+ delta >>= 1;
+ }
+ break;
+
+ case 'v':
+ printf("Device: %s\n", p->data);
+ break;
+ /*
+ default:
+ printf("DBG %c -> %s\n", (char)p->id, p->data);
+ */
+ }
+}
+
+static void enqueue_event(sball_event *ev)
+{
+ if(ev != evbuf + evbuf_widx) {
+ evbuf[evbuf_widx] = *ev;
+ }
+
+ evbuf_widx = BNEXT(evbuf_widx);
+ if(evbuf_widx == evbuf_ridx) {
+ fprintf(stderr, "enqueue_event: overflow, dropping oldest\n");
+ evbuf_ridx = BNEXT(evbuf_ridx);
+ }
+}
+
+static void com_setup(int port, int baud, unsigned int fmt)
+{
+ unsigned char ctl;
+ unsigned short div = 115200 / baud;
+ static int base[] = {UART1_BASE, UART2_BASE};
+ static int irq[] = {UART1_IRQ, UART2_IRQ};
+
+ uart_base = base[port];
+ uart_intr_num = irq[port] | 8;
+
+ _disable();
+#ifdef __WATCOMC__
+ prev_recv_intr = _dos_getvect(uart_intr_num);
+ _dos_setvect(uart_intr_num, recv_intr);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_get_protected_mode_interrupt_vector(uart_intr_num, &prev_intr);
+ intr.pm_offset = (intptr_t)recv_intr;
+ intr.pm_selector = _go32_my_cs();
+ _go32_dpmi_allocate_iret_wrapper(&intr);
+ _go32_dpmi_set_protected_mode_interrupt_vector(uart_intr_num, &intr);
+#endif
+ /* unmask the appropriate interrupt */
+ outp(PIC1_DATA_PORT, inp(PIC1_DATA_PORT) & ~(1 << irq[port]));
+
+ outp(uart_base + UART_LCTL, LCTL_DLAB);
+ outp(uart_base + UART_DIVLO, div & 0xff);
+ outp(uart_base + UART_DIVHI, (div >> 8) & 0xff);
+ outp(uart_base + UART_LCTL, fmt); /* fmt should be LCTL_8N1, LCTL_8N2 etc */
+ outp(uart_base + UART_FIFO, FIFO_ENABLE | FIFO_SEND_CLEAR | FIFO_RECV_CLEAR);
+ outp(uart_base + UART_MCTL, MCTL_DTR | MCTL_RTS | MCTL_OUT2);
+ outp(uart_base + UART_INTR, INTR_RECV);
+
+ _enable();
+}
+
+static void com_close(void)
+{
+ _disable();
+ outp(uart_base + UART_INTR, 0);
+ outp(uart_base + UART_MCTL, 0);
+#ifdef __WATCOMC__
+ _dos_setvect(uart_intr_num, prev_recv_intr);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_set_protected_mode_interrupt_vector(uart_intr_num, &prev_intr);
+ _go32_dpmi_free_iret_wrapper(&intr);
+#endif
+ _enable();
+}
+
+static void com_putc(char c)
+{
+ while(!com_can_send());
+ while((inp(uart_base + UART_MSTAT) & MST_CTS) == 0);
+ outp(uart_base + UART_DATA, c);
+}
+
+static void com_puts(const char *s)
+{
+ while(*s) {
+ com_putc(*s++);
+ }
+}
+
+static int com_getc(void)
+{
+ int have;
+ while(!(have = com_have_recv()));
+ return inp(uart_base + UART_DATA);
+}
+
+static char *com_gets(char *buf, int sz)
+{
+ int c;
+ char *ptr = buf;
+
+ while(sz-- > 1 && (c = com_getc()) != -1) {
+ if(c == '\r') {
+ *ptr++ = '\n';
+ break;
+ }
+ *ptr++ = c;
+ }
+ if(c == -1) {
+ return 0;
+ }
+ *ptr = 0;
+ return buf;
+}
+
+static int com_have_recv(void)
+{
+ unsigned short stat = inp(uart_base + UART_LSTAT);
+ if(stat & LST_ERROR) {
+ fprintf(stderr, "receive error\n");
+ abort();
+ }
+ return stat & LST_DRDY;
+}
+
+static int com_can_send(void)
+{
+ return inp(uart_base + UART_LSTAT) & LST_TREG_EMPTY;
+}
+
+static void INTERRUPT recv_intr()
+{
+ static char buf[128];
+ static char *bptr = buf;
+ struct packet *pkt;
+ int idreg, c, datasz;
+
+ while(((idreg = inp(uart_base + UART_IID)) & IID_PENDING) == 0) {
+ while(com_have_recv()) {
+ if((c = inp(uart_base + UART_DATA)) == '\r') {
+ *bptr = 0;
+ datasz = bptr - buf;
+ bptr = buf;
+
+ pkt = pktbuf + pktbuf_widx;
+ pktbuf_widx = BNEXT(pktbuf_widx);
+
+ if(pktbuf_widx == pktbuf_ridx) {
+ /* we overflowed, drop the oldest packet */
+ pktbuf_ridx = BNEXT(pktbuf_ridx);
+ }
+
+ if(datasz > sizeof pkt->data) {
+ datasz = sizeof pkt->data; /* truncate */
+ }
+ pkt->id = buf[0];
+ memcpy(pkt->data, buf + 1, datasz);
+
+ } else if(bptr - buf < sizeof buf - 1) {
+ *bptr++ = c;
+ }
+ }
+ }
+
+ outp(PIC1_CMD_PORT, OCW2_EOI);
+}
+
+static void read_motion(int *m, const char *s)
+{
+ int i;
+
+ for(i=0; i<6; i++) {
+ long val = ((((long)s[0] & 0xf) << 12) |
+ (((long)s[1] & 0xf) << 8) |
+ (((long)s[2] & 0xf) << 4) |
+ ((long)s[3] & 0xf)) - 32768;
+ s += 4;
+ *m++ = (int)val;
+ }
+}
+
+static void read_keystate(unsigned int *stptr, const char *s)
+{
+ int i, bit = 0;
+ unsigned int st = 0;
+
+ for(i=0; i<3; i++) {
+ st |= ((unsigned int)*s++ & 0xf) << bit;
+ bit += 4;
+ }
+ *stptr = st;
+}
--- /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 KEYB_C_
+#error "do not include scancode.h anywhere..."
+#endif
+
+/* table with rough translations from set 1 scancodes to ASCII-ish */
+static int scantbl[] = {
+ 0, KB_ESC, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', '\b', /* 0 - e */
+ '\t', 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', /* f - 1c */
+ KB_LCTRL, 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', '\'', '`', /* 1d - 29 */
+ KB_LSHIFT, '\\', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.', '/', KB_RSHIFT, /* 2a - 36 */
+ KB_NUM_MUL, KB_LALT, ' ', KB_CAPSLK, KB_F1, KB_F2, KB_F3, KB_F4, KB_F5, KB_F6, KB_F7, KB_F8, KB_F9, KB_F10, /* 37 - 44 */
+ KB_NUMLK, KB_SCRLK, KB_NUM_7, KB_NUM_8, KB_NUM_9, KB_NUM_MINUS, KB_NUM_4, KB_NUM_5, KB_NUM_6, KB_NUM_PLUS, /* 45 - 4e */
+ KB_NUM_1, KB_NUM_2, KB_NUM_3, KB_NUM_0, KB_NUM_DOT, KB_SYSRQ, 0, 0, KB_F11, KB_F12, /* 4d - 58 */
+ 0, 0, 0, 0, 0, 0, 0, /* 59 - 5f */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60 - 6f */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 70 - 7f */
+};
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <conio.h>
+#include <dos.h>
+
+#ifdef __WATCOMC__
+#include <i86.h>
+#endif
+
+#ifdef __DJGPP__
+#include <stdint.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <pc.h>
+#endif
+
+#include "pit8254.h"
+
+#define PIT_TIMER_INTR 8
+#define DOS_TIMER_INTR 0x1c
+
+/* macro to divide and round to the nearest integer */
+#define DIV_ROUND(a, b) \
+ ((a) / (b) + ((a) % (b)) / ((b) / 2))
+
+static void set_timer_reload(int reload_val);
+static void cleanup(void);
+
+#ifdef __WATCOMC__
+#define INTERRUPT __interrupt __far
+
+static void INTERRUPT dos_timer_intr();
+
+static void (INTERRUPT *prev_timer_intr)();
+#endif
+
+#ifdef __DJGPP__
+#define INTERRUPT
+
+static _go32_dpmi_seginfo intr, prev_intr;
+
+#define outp(p, v) outportb(p, v)
+#endif
+
+static void INTERRUPT timer_irq();
+
+static unsigned long ticks;
+static unsigned long tick_interval, ticks_per_dos_intr;
+static int inum;
+
+void init_timer(int res_hz)
+{
+ _disable();
+
+ if(res_hz > 0) {
+ int reload_val = DIV_ROUND(OSC_FREQ_HZ, res_hz);
+ set_timer_reload(reload_val);
+
+ tick_interval = DIV_ROUND(1000, res_hz);
+ ticks_per_dos_intr = DIV_ROUND(65535L, reload_val);
+
+ inum = PIT_TIMER_INTR;
+#ifdef __WATCOMC__
+ prev_timer_intr = _dos_getvect(inum);
+ _dos_setvect(inum, timer_irq);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_get_protected_mode_interrupt_vector(inum, &prev_intr);
+ intr.pm_offset = (intptr_t)timer_irq;
+ intr.pm_selector = _go32_my_cs();
+ _go32_dpmi_allocate_iret_wrapper(&intr);
+ _go32_dpmi_set_protected_mode_interrupt_vector(inum, &intr);
+#endif
+ } else {
+ tick_interval = 55;
+
+ inum = DOS_TIMER_INTR;
+#ifdef __WATCOMC__
+ prev_timer_intr = _dos_getvect(inum);
+ _dos_setvect(inum, dos_timer_intr);
+#endif
+#ifdef __DJGPP__
+ assert(0);
+#endif
+ }
+ _enable();
+
+ atexit(cleanup);
+}
+
+static void cleanup(void)
+{
+ if(!inum) {
+ return; /* init hasn't ran, there's nothing to cleanup */
+ }
+
+ _disable();
+ if(inum == PIT_TIMER_INTR) {
+ /* restore the original timer frequency */
+ set_timer_reload(65535);
+ }
+
+ /* restore the original interrupt handler */
+#ifdef __WATCOMC__
+ _dos_setvect(inum, prev_timer_intr);
+#endif
+#ifdef __DJGPP__
+ _go32_dpmi_set_protected_mode_interrupt_vector(inum, &prev_intr);
+ _go32_dpmi_free_iret_wrapper(&intr);
+#endif
+
+ _enable();
+}
+
+void reset_timer(void)
+{
+ ticks = 0;
+}
+
+unsigned long get_msec(void)
+{
+ return ticks * tick_interval;
+}
+
+static void set_timer_reload(int reload_val)
+{
+ outp(PORT_CMD, CMD_CHAN0 | CMD_ACCESS_BOTH | CMD_OP_SQWAVE);
+ outp(PORT_DATA0, reload_val & 0xff);
+ outp(PORT_DATA0, (reload_val >> 8) & 0xff);
+}
+
+#ifdef __WATCOMC__
+static void INTERRUPT dos_timer_intr()
+{
+ ticks++;
+ _chain_intr(prev_timer_intr); /* DOES NOT RETURN */
+}
+#endif
+
+/* first PIC command port */
+#define PIC1_CMD 0x20
+/* end of interrupt control word */
+#define OCW2_EOI (1 << 5)
+
+static void INTERRUPT timer_irq()
+{
+ static unsigned long dos_ticks;
+
+ ticks++;
+
+#ifdef __WATCOMC__
+ if(++dos_ticks >= ticks_per_dos_intr) {
+ /* I suppose the dos irq handler does the EOI so I shouldn't
+ * do it if I am to call the previous function
+ */
+ dos_ticks = 0;
+ _chain_intr(prev_timer_intr); /* XXX DOES NOT RETURN */
+ return; /* just for clarity */
+ }
+#endif
+
+ /* send EOI to the PIC */
+ outp(PIC1_CMD, OCW2_EOI);
+}
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+#include <conio.h>
+#include "vbe.h"
+#include "cdpmi.h"
+#include "inttypes.h"
+
+#ifdef __DJGPP__
+#include <pc.h>
+#include <sys/nearptr.h>
+
+#define SEG_ADDR(s) (((uint32_t)(s) << 4) - __djgpp_base_address)
+
+#define outp(p, v) outportb(p, v)
+#else
+#define SEG_ADDR(s) ((uint32_t)(s) << 4)
+#endif
+
+/* VGA DAC registers used for palette setting in 8bpp modes */
+#define VGA_DAC_STATE 0x3c7
+#define VGA_DAC_ADDR_RD 0x3c7
+#define VGA_DAC_ADDR_WR 0x3c8
+#define VGA_DAC_DATA 0x3c9
+
+#define MODE_LFB (1 << 14)
+
+
+struct vbe_info *vbe_get_info(void)
+{
+ static uint16_t info_block_seg, info_block_selector;
+ static struct vbe_info *info;
+ struct dpmi_real_regs regs;
+
+ if(!info) {
+ /* allocate 32 paragraphs (512 bytes) */
+ info_block_seg = dpmi_alloc(32, &info_block_selector);
+ info = (struct vbe_info*)SEG_ADDR(info_block_seg);
+ }
+
+ memcpy(info->sig, "VBE2", 4);
+
+ memset(®s, 0, sizeof regs);
+ regs.es = info_block_seg;
+ regs.eax = 0x4f00;
+
+ dpmi_real_int(0x10, ®s);
+
+ return info;
+}
+
+struct vbe_mode_info *vbe_get_mode_info(int mode)
+{
+ static uint16_t mode_info_seg, mode_info_selector;
+ static struct vbe_mode_info *mi;
+ struct dpmi_real_regs regs;
+
+ if(!mi) {
+ /* allocate 16 paragraphs (256 bytes) */
+ mode_info_seg = dpmi_alloc(16, &mode_info_selector);
+ mi = (struct vbe_mode_info*)SEG_ADDR(mode_info_seg);
+ }
+
+ memset(®s, 0, sizeof regs);
+ regs.es = mode_info_seg;
+ regs.eax = 0x4f01;
+ regs.ecx = mode;
+ regs.es = mode_info_seg;
+
+ dpmi_real_int(0x10, ®s);
+ if(regs.eax & 0xff00) {
+ return 0;
+ }
+
+ return mi;
+}
+
+int vbe_set_mode(int mode)
+{
+ struct dpmi_real_regs regs;
+
+ memset(®s, 0, sizeof regs);
+ regs.eax = 0x4f02;
+ regs.ebx = mode;
+ dpmi_real_int(0x10, ®s);
+
+ if(regs.eax == 0x100) {
+ return -1;
+ }
+ return 0;
+}
+
+int vbe_set_palette_bits(int bits)
+{
+ struct dpmi_real_regs regs;
+
+ memset(®s, 0, sizeof regs);
+ regs.eax = 0x4f08;
+ regs.ebx = bits << 8; /* bits in bh */
+ dpmi_real_int(0x10, ®s);
+
+ if(((regs.eax >> 8) & 0xff) == 3) {
+ return -1;
+ }
+ return regs.ebx >> 8 & 0xff; /* new color bits in bh */
+}
+
+/* TODO: implement palette setting through the VBE2 interface for
+ * non-VGA displays (actually don't).
+ */
+void vbe_set_palette(int idx, int *col, int count, int bits)
+{
+ int i, shift = 8 - bits;
+
+ outp(VGA_DAC_ADDR_WR, idx);
+
+ for(i=0; i<count; i++) {
+ unsigned char r = *col++;
+ unsigned char g = *col++;
+ unsigned char b = *col++;
+
+ if(shift) {
+ r >>= shift;
+ g >>= shift;
+ b >>= shift;
+ }
+
+ outp(VGA_DAC_DATA, r);
+ outp(VGA_DAC_DATA, g);
+ outp(VGA_DAC_DATA, b);
+ }
+}
+
+static unsigned int get_mask(int sz, int pos)
+{
+ unsigned int i, mask = 0;
+
+ for(i=0; i<sz; i++) {
+ mask |= 1 << i;
+ }
+ return mask << pos;
+}
+
+void print_mode_info(FILE *fp, struct vbe_mode_info *mi)
+{
+ fprintf(fp, "resolution: %dx%d\n", mi->xres, mi->yres);
+ fprintf(fp, "color depth: %d\n", mi->bpp);
+ fprintf(fp, "mode attributes: %x\n", mi->mode_attr);
+ fprintf(fp, "bytes per scanline: %d\n", mi->scanline_bytes);
+ fprintf(fp, "number of planes: %d\n", (int)mi->num_planes);
+ fprintf(fp, "number of banks: %d\n", (int)mi->num_banks);
+ fprintf(fp, "mem model: %d\n", (int)mi->mem_model);
+ fprintf(fp, "red bits: %d (mask: %x)\n", (int)mi->rmask_size, get_mask(mi->rmask_size, mi->rpos));
+ fprintf(fp, "green bits: %d (mask: %x)\n", (int)mi->gmask_size, get_mask(mi->gmask_size, mi->gpos));
+ fprintf(fp, "blue bits: %d (mask: %x)\n", (int)mi->bmask_size, get_mask(mi->bmask_size, mi->bpos));
+ fprintf(fp, "framebuffer address: %x\n", (unsigned int)mi->fb_addr);
+}
--- /dev/null
+#ifndef VBE_H_
+#define VBE_H_
+
+#include "inttypes.h"
+
+#ifdef __GNUC__
+#define PACKED __attribute__((packed))
+#else
+#define PACKED
+#endif
+
+#define VBE_ATTR_LFB (1 << 7)
+#define VBE_MODE_LFB (1 << 14)
+
+#pragma pack (push, 0)
+struct vbe_info {
+ uint8_t sig[4];
+ uint16_t version;
+ uint32_t oem_str_ptr;
+ uint8_t caps[4]; /* capabilities */
+ uint32_t vid_mode_ptr; /* vbefarptr to video mode list */
+ uint16_t total_mem; /* num of 64k mem blocks */
+ uint16_t oem_sw_rev; /* VBE implementation software revision */
+ uint32_t oem_vendor_name_ptr;
+ uint32_t oem_product_name_ptr;
+ uint32_t oem_product_rev_ptr;
+ uint8_t reserved[222];
+ uint8_t oem_data[256];
+} PACKED;
+
+struct vbe_mode_info {
+ uint16_t mode_attr;
+ uint8_t wina_attr, winb_attr;
+ uint16_t win_gran, win_size;
+ uint16_t wina_seg, winb_seg;
+ uint32_t win_func;
+ uint16_t scanline_bytes;
+
+ /* VBE 1.2 and above */
+ uint16_t xres, yres;
+ uint8_t xcharsz, ycharsz;
+ uint8_t num_planes;
+ uint8_t bpp;
+ uint8_t num_banks;
+ uint8_t mem_model;
+ uint8_t bank_size; /* bank size in KB */
+ uint8_t num_img_pages;
+ uint8_t reserved1;
+
+ /* direct color fields */
+ uint8_t rmask_size, rpos;
+ uint8_t gmask_size, gpos;
+ uint8_t bmask_size, bpos;
+ uint8_t xmask_size, xpos;
+ uint8_t cmode_info; /* direct color mode attributes */
+
+ /* VBE 2.0 and above */
+ uint32_t fb_addr; /* physical address of the linear framebuffer */
+ uint32_t reserved2;
+ uint16_t reserved3;
+
+ uint8_t reserved4[206];
+} PACKED;
+#pragma pack (pop)
+
+struct vbe_info *vbe_get_info(void);
+struct vbe_mode_info *vbe_get_mode_info(int mode);
+
+int vbe_set_mode(int mode);
+
+int vbe_set_palette_bits(int bits);
+void vbe_set_palette(int idx, int *col, int count, int bits);
+
+void print_mode_info(FILE *fp, struct vbe_mode_info *modei);
+
+#endif /* VBE_H_ */
--- /dev/null
+#ifdef __WATCOMC__
+#include "cdpmi.h"
+
+void dpmi_real_int(int inum, struct dpmi_real_regs *regs)
+{
+ unsigned char int_num = (unsigned char)inum;
+ __asm {
+ mov eax, 0x300
+ mov edi, regs
+ mov bl, int_num
+ mov bh, 0
+ xor ecx, ecx
+ int 0x31
+ }
+}
+
+void *dpmi_mmap(uint32_t phys_addr, unsigned int size)
+{
+ uint16_t mem_high, mem_low;
+ uint16_t phys_high = phys_addr >> 16;
+ uint16_t phys_low = phys_addr & 0xffff;
+ uint16_t size_high = size >> 16;
+ uint16_t size_low = size & 0xffff;
+ unsigned int err, res = 0;
+
+ __asm {
+ mov eax, 0x800
+ mov bx, phys_high
+ mov cx, phys_low
+ mov si, size_high
+ mov di, size_low
+ int 0x31
+ add res, 1
+ mov err, eax
+ mov mem_high, bx
+ mov mem_low, cx
+ }
+
+ if(res == 2) {
+ return 0;
+ }
+ return (void*)(((uint32_t)mem_high << 16) | ((uint32_t)mem_low));
+}
+
+void dpmi_munmap(void *addr)
+{
+ uint16_t mem_high = (uint32_t)addr >> 16;
+ uint16_t mem_low = (uint16_t)addr;
+
+ __asm {
+ mov eax, 0x801
+ mov bx, mem_high
+ mov cx, mem_low
+ int 0x31
+ }
+}
+#else
+int stop_gcc_crying_about_empty_translation_units = 0;
+#endif /* __WATCOM__ */
--- /dev/null
+/* dynarr - dynamic resizable C array data structure
+ * author: John Tsiombikas <nuclear@member.fsf.org>
+ * license: public domain
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dynarr.h"
+
+/* The array descriptor keeps auxilliary information needed to manipulate
+ * the dynamic array. It's allocated adjacent to the array buffer.
+ */
+struct arrdesc {
+ int nelem, szelem;
+ int max_elem;
+ int bufsz; /* not including the descriptor */
+};
+
+#define DESC(x) ((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc)))
+
+void *dynarr_alloc(int elem, int szelem)
+{
+ struct arrdesc *desc;
+
+ if(!(desc = malloc(elem * szelem + sizeof *desc))) {
+ return 0;
+ }
+ desc->nelem = desc->max_elem = elem;
+ desc->szelem = szelem;
+ desc->bufsz = elem * szelem;
+ return (char*)desc + sizeof *desc;
+}
+
+void dynarr_free(void *da)
+{
+ if(da) {
+ free(DESC(da));
+ }
+}
+
+void *dynarr_resize(void *da, int elem)
+{
+ int newsz;
+ void *tmp;
+ struct arrdesc *desc;
+
+ if(!da) return 0;
+ desc = DESC(da);
+
+ newsz = desc->szelem * elem;
+
+ if(!(tmp = realloc(desc, newsz + sizeof *desc))) {
+ return 0;
+ }
+ desc = tmp;
+
+ desc->nelem = desc->max_elem = elem;
+ desc->bufsz = newsz;
+ return (char*)desc + sizeof *desc;
+}
+
+int dynarr_empty(void *da)
+{
+ return DESC(da)->nelem ? 0 : 1;
+}
+
+int dynarr_size(void *da)
+{
+ return DESC(da)->nelem;
+}
+
+
+void *dynarr_clear(void *da)
+{
+ return dynarr_resize(da, 0);
+}
+
+/* stack semantics */
+void *dynarr_push(void *da, void *item)
+{
+ struct arrdesc *desc;
+ int nelem;
+
+ desc = DESC(da);
+ nelem = desc->nelem;
+
+ if(nelem >= desc->max_elem) {
+ /* need to resize */
+ struct arrdesc *tmp;
+ int newsz = desc->max_elem ? desc->max_elem * 2 : 1;
+
+ if(!(tmp = dynarr_resize(da, newsz))) {
+ fprintf(stderr, "failed to resize\n");
+ return da;
+ }
+ da = tmp;
+ desc = DESC(da);
+ desc->nelem = nelem;
+ }
+
+ if(item) {
+ memcpy((char*)da + desc->nelem++ * desc->szelem, item, desc->szelem);
+ }
+ return da;
+}
+
+void *dynarr_pop(void *da)
+{
+ struct arrdesc *desc;
+ int nelem;
+
+ desc = DESC(da);
+ nelem = desc->nelem;
+
+ if(!nelem) return da;
+
+ if(nelem <= desc->max_elem / 3) {
+ /* reclaim space */
+ struct arrdesc *tmp;
+ int newsz = desc->max_elem / 2;
+
+ if(!(tmp = dynarr_resize(da, newsz))) {
+ fprintf(stderr, "failed to resize\n");
+ return da;
+ }
+ da = tmp;
+ desc = DESC(da);
+ desc->nelem = nelem;
+ }
+ desc->nelem--;
+
+ return da;
+}
+
+void *dynarr_finalize(void *da)
+{
+ struct arrdesc *desc = DESC(da);
+ memmove(desc, da, desc->bufsz);
+ return desc;
+}
--- /dev/null
+/* dynarr - dynamic resizable C array data structure
+ * author: John Tsiombikas <nuclear@member.fsf.org>
+ * license: public domain
+ */
+#ifndef DYNARR_H_
+#define DYNARR_H_
+
+/* usage example:
+ * -------------
+ * int *arr = dynarr_alloc(0, sizeof *arr);
+ *
+ * int x = 10;
+ * arr = dynarr_push(arr, &x);
+ * x = 5;
+ * arr = dynarr_push(arr, &x);
+ * x = 42;
+ * arr = dynarr_push(arr, &x);
+ *
+ * for(i=0; i<dynarr_size(arr); i++) {
+ * printf("%d\n", arr[i]);
+ * }
+ * dynarr_free(arr);
+ */
+
+void *dynarr_alloc(int elem, int szelem);
+void dynarr_free(void *da);
+void *dynarr_resize(void *da, int elem);
+
+/* dynarr_empty returns non-zero if the array is empty
+ * Complexity: O(1) */
+int dynarr_empty(void *da);
+/* dynarr_size returns the number of elements in the array
+ * Complexity: O(1) */
+int dynarr_size(void *da);
+
+void *dynarr_clear(void *da);
+
+/* stack semantics */
+void *dynarr_push(void *da, void *item);
+void *dynarr_pop(void *da);
+
+/* Finalize the array. No more resizing is possible after this call.
+ * Use free() instead of dynarr_free() to deallocate a finalized array.
+ * Returns pointer to the finalized array.
+ * dynarr_finalize can't fail.
+ * Complexity: O(n)
+ */
+void *dynarr_finalize(void *da);
+
+/* helper macros */
+#define DYNARR_RESIZE(da, n) \
+ do { (da) = dynarr_resize((da), (n)); } while(0)
+#define DYNARR_CLEAR(da) \
+ do { (da) = dynarr_clear(da); } while(0)
+#define DYNARR_PUSH(da, item) \
+ do { (da) = dynarr_push((da), (item)); } while(0)
+#define DYNARR_POP(da) \
+ do { (da) = dynarr_pop(da); } while(0)
+
+/* utility macros to push characters to a string. assumes and maintains
+ * the invariant that the last element is always a zero
+ */
+#define DYNARR_STRPUSH(da, c) \
+ do { \
+ char cnull = 0, ch = (char)(c); \
+ (da) = dynarr_pop(da); \
+ (da) = dynarr_push((da), &ch); \
+ (da) = dynarr_push((da), &cnull); \
+ } while(0)
+
+#define DYNARR_STRPOP(da) \
+ do { \
+ char cnull = 0; \
+ (da) = dynarr_pop(da); \
+ (da) = dynarr_pop(da); \
+ (da) = dynarr_push((da), &cnull); \
+ } while(0)
+
+
+#endif /* DYNARR_H_ */
--- /dev/null
+#include "gfxutil.h"
+#include "demo.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);
+ }
+}
--- /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))
+
+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);
+
+#endif /* GFXUTIL_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "mesh.h"
+#include "3dgfx.h"
+
+static struct {
+ int prim;
+ struct g3d_vertex *varr;
+ const float *xform;
+} zsort_cls;
+
+static int zsort_cmp(const void *aptr, const void *bptr)
+{
+ int i;
+ float za = 0.0f;
+ float zb = 0.0f;
+ const float *m = zsort_cls.xform;
+ const struct g3d_vertex *va = (const struct g3d_vertex*)aptr;
+ const struct g3d_vertex *vb = (const struct g3d_vertex*)bptr;
+
+ for(i=0; i<zsort_cls.prim; i++) {
+ za += m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
+ zb += m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
+ ++va;
+ ++vb;
+ }
+ return za - zb;
+}
+
+static int zsort_indexed_cmp(const void *aptr, const void *bptr)
+{
+ int i;
+ float za = 0.0f;
+ float zb = 0.0f;
+ const uint16_t *a = (const uint16_t*)aptr;
+ const uint16_t *b = (const uint16_t*)bptr;
+
+ const float *m = zsort_cls.xform;
+
+ for(i=0; i<zsort_cls.prim; i++) {
+ const struct g3d_vertex *va = zsort_cls.varr + a[i];
+ const struct g3d_vertex *vb = zsort_cls.varr + b[i];
+
+ za += m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
+ zb += m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
+ }
+ return za - zb;
+}
+
+
+void zsort_mesh(struct g3d_mesh *m)
+{
+ zsort_cls.varr = m->varr;
+ zsort_cls.xform = g3d_get_matrix(G3D_MODELVIEW, 0);
+ zsort_cls.prim = m->prim;
+
+ if(m->iarr) {
+ int nfaces = m->icount / m->prim;
+ qsort(m->iarr, nfaces, m->prim * sizeof *m->iarr, zsort_indexed_cmp);
+ } else {
+ int nfaces = m->vcount / m->prim;
+ qsort(m->varr, nfaces, m->prim * sizeof *m->varr, zsort_cmp);
+ }
+}
+
+
+void draw_mesh(struct g3d_mesh *mesh)
+{
+ if(mesh->iarr) {
+ g3d_draw_indexed(mesh->prim, mesh->varr, mesh->vcount, mesh->iarr, mesh->icount);
+ } else {
+ g3d_draw(mesh->prim, mesh->varr, mesh->vcount);
+ }
+}
+
+void apply_mesh_xform(struct g3d_mesh *mesh, const float *xform)
+{
+ int i;
+ struct g3d_vertex *v = mesh->varr;
+
+ for(i=0; i<mesh->vcount; i++) {
+ float x = xform[0] * v->x + xform[4] * v->y + xform[8] * v->z + xform[12];
+ float y = xform[1] * v->x + xform[5] * v->y + xform[9] * v->z + xform[13];
+ v->z = xform[2] * v->x + xform[6] * v->y + xform[10] * v->z + xform[14];
+ v->x = x;
+ v->y = y;
+ x = xform[0] * v->nx + xform[4] * v->ny + xform[8] * v->nz;
+ y = xform[1] * v->nx + xform[5] * v->ny + xform[9] * v->nz;
+ v->nz = xform[2] * v->nx + xform[6] * v->ny + xform[10] * v->nz;
+ v->nx = x;
+ v->ny = y;
+ ++v;
+ }
+}
+
+int append_mesh(struct g3d_mesh *ma, struct g3d_mesh *mb)
+{
+ int i, new_vcount, new_icount;
+ void *tmp;
+ uint16_t *iptr;
+
+ if(ma->prim != mb->prim) {
+ fprintf(stderr, "append_mesh failed, primitive mismatch\n");
+ return -1;
+ }
+
+ if(ma->iarr || mb->iarr) {
+ if(!ma->iarr) {
+ if(indexify_mesh(ma) == -1) {
+ return -1;
+ }
+ } else if(!mb->iarr) {
+ if(indexify_mesh(mb) == -1) {
+ return -1;
+ }
+ }
+
+ new_icount = ma->icount + mb->icount;
+ if(!(iptr = realloc(ma->iarr, new_icount * sizeof *iptr))) {
+ fprintf(stderr, "append_mesh: failed to allocate combined index buffer (%d indices)\n", new_icount);
+ return -1;
+ }
+ ma->iarr = iptr;
+
+ iptr += ma->icount;
+ for(i=0; i<mb->icount; i++) {
+ *iptr++ = mb->iarr[i] + ma->vcount;
+ }
+ ma->icount = new_icount;
+ }
+
+ new_vcount = ma->vcount + mb->vcount;
+ if(!(tmp = realloc(ma->varr, new_vcount * sizeof *ma->varr))) {
+ fprintf(stderr, "append_mesh: failed to allocate combined vertex buffer (%d verts)\n", new_vcount);
+ return -1;
+ }
+ ma->varr = tmp;
+ memcpy(ma->varr + ma->vcount, mb->varr, mb->vcount * sizeof *ma->varr);
+ ma->vcount = new_vcount;
+ return 0;
+}
+
+#define FEQ(a, b) ((a) - (b) < 1e-5 && (b) - (a) < 1e-5)
+static int cmp_vertex(struct g3d_vertex *a, struct g3d_vertex *b)
+{
+ if(!FEQ(a->x, b->x) || !FEQ(a->y, b->y) || !FEQ(a->z, b->z) || !FEQ(a->w, b->w))
+ return -1;
+ if(!FEQ(a->nx, b->nx) || !FEQ(a->ny, b->ny) || !FEQ(a->nz, b->nz))
+ return -1;
+ if(!FEQ(a->u, b->u) || !FEQ(a->v, b->v))
+ return -1;
+ if(a->r != b->r || a->g != b->g || a->b != b->b || a->a != b->a)
+ return -1;
+ return 0;
+}
+
+static int find_existing(struct g3d_vertex *v, struct g3d_vertex *varr, int vcount)
+{
+ int i;
+ for(i=0; i<vcount; i++) {
+ if(cmp_vertex(v, varr++) == 0) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+int indexify_mesh(struct g3d_mesh *mesh)
+{
+ int i, j, nfaces, max_icount, idx;
+ int out_vcount = 0;
+ struct g3d_vertex *vin, *vout;
+ uint16_t *iout;
+
+ if(mesh->iarr) {
+ fprintf(stderr, "indexify_mesh failed: already indexed\n");
+ return -1;
+ }
+
+ nfaces = mesh->vcount / mesh->prim;
+ max_icount = mesh->vcount;
+
+ if(!(mesh->iarr = malloc(max_icount * sizeof *mesh->iarr))) {
+ fprintf(stderr, "indexify_mesh failed to allocate index buffer of %d indices\n", max_icount);
+ return -1;
+ }
+
+ vin = vout = mesh->varr;
+ iout = mesh->iarr;
+
+ for(i=0; i<nfaces; i++) {
+ for(j=0; j<mesh->prim; j++) {
+ if((idx = find_existing(vin, mesh->varr, out_vcount)) >= 0) {
+ *iout++ = idx;
+ } else {
+ *iout++ = out_vcount++;
+ if(vin != vout) {
+ *vout++ = *vin;
+ }
+ }
+ ++vin;
+ }
+ }
+
+ /* XXX also shrink buffers? I'll just leave them to max size for now */
+ return 0;
+}
+
+void normalize_mesh_normals(struct g3d_mesh *mesh)
+{
+ int i;
+ struct g3d_vertex *v = mesh->varr;
+
+ for(i=0; i<mesh->vcount; i++) {
+ float mag = sqrt(v->nx * v->nx + v->ny * v->ny + v->nz * v->nz);
+ float s = (mag == 0.0f) ? 1.0f : 1.0f / mag;
+ v->nx *= s;
+ v->ny *= s;
+ v->nz *= s;
+ ++v;
+ }
+}
+
+int gen_plane_mesh(struct g3d_mesh *m, float width, float height, int usub, int vsub)
+{
+ int i, j;
+ int nfaces, nverts, nidx, uverts, vverts;
+ float x, y, u, v, du, dv;
+ struct g3d_vertex *vptr;
+ uint16_t *iptr;
+
+ if(usub < 1) usub = 1;
+ if(vsub < 1) vsub = 1;
+
+ nfaces = usub * vsub;
+ uverts = usub + 1;
+ vverts = vsub + 1;
+ du = (float)width / (float)usub;
+ dv = (float)height / (float)vsub;
+
+ nverts = uverts * vverts;
+ nidx = nfaces * 4;
+
+ if(!(m->varr = malloc(nverts * sizeof *m->varr))) {
+ fprintf(stderr, "gen_plane_mesh: failed to allocate vertex buffer (%d vertices)\n", nverts);
+ return -1;
+ }
+ if(!(m->iarr = malloc(nidx * sizeof *m->iarr))) {
+ fprintf(stderr, "gen_plane_mesh: failed to allocate index buffer (%d indices)\n", nidx);
+ free(m->varr);
+ m->varr = 0;
+ return -1;
+ }
+
+ m->prim = G3D_QUADS;
+ m->vcount = nverts;
+ m->icount = nidx;
+
+ vptr = m->varr;
+ iptr = m->iarr;
+
+ v = 0.0f;
+ for(i=0; i<vverts; i++) {
+ y = (v - 0.5) * height;
+ u = 0.0f;
+
+ for(j=0; j<uverts; j++) {
+ x = (u - 0.5) * width;
+
+ vptr->x = x;
+ vptr->y = y;
+ vptr->z = 0.0f;
+ vptr->w = 1.0f;
+ vptr->nx = 0.0f;
+ vptr->ny = 0.0f;
+ vptr->nz = 1.0f;
+ vptr->u = u;
+ vptr->v = v;
+ vptr->r = vptr->g = vptr->b = vptr->a = 255;
+ ++vptr;
+
+ u += du;
+ }
+ v += dv;
+ }
+
+ for(i=0; i<vsub; i++) {
+ for(j=0; j<usub; j++) {
+ int idx = i * uverts + j;
+ *iptr++ = idx;
+ *iptr++ = idx + 1;
+ *iptr++ = idx + uverts + 1;
+ *iptr++ = idx + uverts;
+ }
+ }
+ return 0;
+}
+
+int gen_cube_mesh(struct g3d_mesh *mesh, float sz, int sub)
+{
+ int i;
+ struct g3d_mesh *m;
+ struct g3d_mesh tmpmesh;
+ static float rotface[][4] = {
+ {0, 0, 1, 0},
+ {90, 0, 1, 0},
+ {180, 0, 1, 0},
+ {270, 0, 1, 0},
+ {90, 1, 0, 0},
+ {-90, 1, 0, 0}
+ };
+
+ g3d_matrix_mode(G3D_MODELVIEW);
+ g3d_push_matrix();
+
+ for(i=0; i<6; i++) {
+ m = i > 0 ? &tmpmesh : mesh;
+ if(gen_plane_mesh(m, sz, sz, sub, sub) == -1)
+ return -1;
+ g3d_load_identity();
+ g3d_rotate(rotface[i][0], rotface[i][1], rotface[i][2], rotface[i][3]);
+ g3d_translate(0, 0, sz / 2.0f);
+ apply_mesh_xform(m, g3d_get_matrix(G3D_MODELVIEW, 0));
+ if(i > 0) {
+ if(append_mesh(mesh, m) == -1) {
+ return -1;
+ }
+ }
+ }
+
+ g3d_pop_matrix();
+ return 0;
+}
+
+static void torusvec(float *res, float theta, float phi, float mr, float rr)
+{
+ float rx, ry, rz;
+ theta = -theta;
+
+ rx = -cos(phi) * rr + mr;
+ ry = sin(phi) * rr;
+ rz = 0.0f;
+
+ res[0] = rx * sin(theta) + rz * cos(theta);
+ res[1] = ry;
+ res[2] = -rx * cos(theta) + rz * sin(theta);
+}
+
+int gen_torus_mesh(struct g3d_mesh *mesh, float rad, float ringrad, int usub, int vsub)
+{
+ int i, j;
+ int nfaces, uverts, vverts;
+ struct g3d_vertex *vptr;
+ uint16_t *iptr;
+
+ mesh->prim = G3D_QUADS;
+
+ if(usub < 4) usub = 4;
+ if(vsub < 2) vsub = 2;
+
+ uverts = usub + 1;
+ vverts = vsub + 1;
+
+ mesh->vcount = uverts * vverts;
+ nfaces = usub * vsub;
+ mesh->icount = nfaces * 4;
+
+ printf("generating torus with %d faces (%d vertices)\n", nfaces, mesh->vcount);
+
+ if(!(mesh->varr = malloc(mesh->vcount * sizeof *mesh->varr))) {
+ return -1;
+ }
+ if(!(mesh->iarr = malloc(mesh->icount * sizeof *mesh->iarr))) {
+ return -1;
+ }
+ vptr = mesh->varr;
+ iptr = mesh->iarr;
+
+ for(i=0; i<uverts; i++) {
+ float u = (float)i / (float)(uverts - 1);
+ float theta = u * 2.0 * M_PI;
+ float rcent[3];
+
+ torusvec(rcent, theta, 0, rad, 0);
+
+ for(j=0; j<vverts; j++) {
+ float v = (float)j / (float)(vverts - 1);
+ float phi = v * 2.0 * M_PI;
+ int chess = (i & 1) == (j & 1);
+
+ torusvec(&vptr->x, theta, phi, rad, ringrad);
+ vptr->w = 1.0f;
+
+ vptr->nx = (vptr->x - rcent[0]) / ringrad;
+ vptr->ny = (vptr->y - rcent[1]) / ringrad;
+ vptr->nz = (vptr->z - rcent[2]) / ringrad;
+ vptr->u = u;
+ vptr->v = v;
+ vptr->r = chess ? 255 : 64;
+ vptr->g = 128;
+ vptr->b = chess ? 64 : 255;
+ ++vptr;
+
+ if(i < usub && j < vsub) {
+ int idx = i * vverts + j;
+ *iptr++ = idx;
+ *iptr++ = idx + 1;
+ *iptr++ = idx + vverts + 1;
+ *iptr++ = idx + vverts;
+ }
+ }
+ }
+ return 0;
+}
+
--- /dev/null
+#ifndef MESH_H_
+#define MESH_H_
+
+#include "inttypes.h"
+
+struct g3d_mesh {
+ int prim;
+ struct g3d_vertex *varr;
+ uint16_t *iarr;
+ int vcount, icount;
+};
+
+int load_mesh(struct g3d_mesh *mesh, const char *fname);
+int save_mesh(struct g3d_mesh *mesh, const char *fname);
+
+void zsort_mesh(struct g3d_mesh *mesh);
+void draw_mesh(struct g3d_mesh *mesh);
+
+void apply_mesh_xform(struct g3d_mesh *mesh, const float *xform);
+int append_mesh(struct g3d_mesh *ma, struct g3d_mesh *mb);
+int indexify_mesh(struct g3d_mesh *mesh);
+
+void normalize_mesh_normals(struct g3d_mesh *mesh);
+
+int gen_plane_mesh(struct g3d_mesh *mesh, float width, float height, int usub, int vsub);
+int gen_cube_mesh(struct g3d_mesh *mesh, float sz, int sub);
+int gen_torus_mesh(struct g3d_mesh *mesh, float rad, float ringrad, int usub, int vsub);
+
+#endif /* MESH_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <assert.h>
+#include "mesh.h"
+#include "dynarr.h"
+#include "rbtree.h"
+#include "vmath.h"
+#include "3dgfx.h"
+#include "util.h"
+
+struct vertex_pos_color {
+ float x, y, z;
+ float r, g, b, a;
+};
+
+struct facevertex {
+ int vidx, tidx, nidx;
+};
+
+static char *clean_line(char *s);
+static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn);
+static int cmp_facevert(const void *ap, const void *bp);
+static void free_rbnode_key(struct rbnode *n, void *cls);
+
+/* merge of different indices per attribute happens during face processing.
+ *
+ * A triplet of (vertex index/texcoord index/normal index) is used as the key
+ * to search in a balanced binary search tree for vertex buffer index assigned
+ * to the same triplet if it has been encountered before. That index is
+ * appended to the index buffer.
+ *
+ * If a particular triplet has not been encountered before, a new g3d_vertex is
+ * appended to the vertex buffer. The index of this new vertex is appended to
+ * the index buffer, and also inserted into the tree for future searches.
+ */
+int load_mesh(struct g3d_mesh *mesh, const char *fname)
+{
+ int i, line_num = 0, result = -1;
+ int found_quad = 0;
+ FILE *fp = 0;
+ char buf[256];
+ struct vertex_pos_color *varr = 0;
+ vec3_t *narr = 0;
+ vec2_t *tarr = 0;
+ struct rbtree *rbtree = 0;
+
+ if(!(fp = fopen(fname, "rb"))) {
+ fprintf(stderr, "load_mesh: failed to open file: %s\n", fname);
+ goto err;
+ }
+
+ if(!(rbtree = rb_create(cmp_facevert))) {
+ fprintf(stderr, "load_mesh: failed to create facevertex binary search tree\n");
+ goto err;
+ }
+ rb_set_delete_func(rbtree, free_rbnode_key, 0);
+
+ if(!(mesh->varr = dynarr_alloc(0, sizeof *mesh->varr)) ||
+ !(mesh->iarr = dynarr_alloc(0, sizeof *mesh->iarr))) {
+ fprintf(stderr, "load_mesh: failed to allocate resizable mesh arrays\n");
+ goto err;
+ }
+ if(!(varr = dynarr_alloc(0, sizeof *varr)) ||
+ !(narr = dynarr_alloc(0, sizeof *narr)) ||
+ !(tarr = dynarr_alloc(0, sizeof *tarr))) {
+ fprintf(stderr, "load_mesh: failed to allocate resizable vertex array\n");
+ goto err;
+ }
+
+ while(fgets(buf, sizeof buf, fp)) {
+ char *line = clean_line(buf);
+ ++line_num;
+
+ if(!*line) continue;
+
+ switch(line[0]) {
+ case 'v':
+ if(isspace(line[1])) {
+ /* vertex */
+ struct vertex_pos_color v;
+ int num;
+
+ num = sscanf(line + 2, "%f %f %f %f %f %f %f", &v.x, &v.y, &v.z, &v.x, &v.y, &v.z, &v.a);
+ if(num < 3) {
+ fprintf(stderr, "%s:%d: invalid vertex definition: \"%s\"\n", fname, line_num, line);
+ goto err;
+ }
+ switch(num) {
+ case 3:
+ v.r = 1.0f;
+ case 4:
+ v.g = 1.0f;
+ case 5:
+ v.b = 1.0f;
+ case 6:
+ v.a = 1.0f;
+ }
+ if(!(varr = dynarr_push(varr, &v))) {
+ fprintf(stderr, "load_mesh: failed to resize vertex buffer\n");
+ goto err;
+ }
+
+ } else if(line[1] == 't' && isspace(line[2])) {
+ /* texcoord */
+ vec2_t tc;
+ if(sscanf(line + 3, "%f %f", &tc.x, &tc.y) != 2) {
+ fprintf(stderr, "%s:%d: invalid texcoord definition: \"%s\"\n", fname, line_num, line);
+ goto err;
+ }
+ if(!(tarr = dynarr_push(tarr, &tc))) {
+ fprintf(stderr, "load_mesh: failed to resize texcoord buffer\n");
+ goto err;
+ }
+
+ } else if(line[1] == 'n' && isspace(line[2])) {
+ /* normal */
+ vec3_t norm;
+ if(sscanf(line + 3, "%f %f %f", &norm.x, &norm.y, &norm.z) != 3) {
+ fprintf(stderr, "%s:%d: invalid normal definition: \"%s\"\n", fname, line_num, line);
+ goto err;
+ }
+ if(!(narr = dynarr_push(narr, &norm))) {
+ fprintf(stderr, "load_mesh: failed to resize normal buffer\n");
+ goto err;
+ }
+ }
+ break;
+
+ case 'f':
+ if(isspace(line[1])) {
+ /* face */
+ char *ptr = line + 2;
+ struct facevertex fv;
+ struct rbnode *node;
+ int vsz = dynarr_size(varr);
+ int tsz = dynarr_size(tarr);
+ int nsz = dynarr_size(narr);
+
+ for(i=0; i<4; i++) {
+ if(!(ptr = parse_face_vert(ptr, &fv, vsz, tsz, nsz))) {
+ if(i < 3 || found_quad) {
+ fprintf(stderr, "%s:%d: invalid face definition: \"%s\"\n", fname, line_num, line);
+ goto err;
+ } else {
+ break;
+ }
+ }
+
+ if((node = rb_find(rbtree, &fv))) {
+ uint16_t idx = (int)(intptr_t)node->data;
+ if(!(mesh->iarr = dynarr_push(mesh->iarr, &idx))) {
+ fprintf(stderr, "load_mesh: failed to resize index array\n");
+ goto err;
+ }
+ } else {
+ uint16_t newidx = dynarr_size(mesh->varr);
+ struct g3d_vertex v;
+ struct facevertex *newfv;
+
+ v.x = varr[fv.vidx].x;
+ v.y = varr[fv.vidx].y;
+ v.z = varr[fv.vidx].z;
+ v.w = 1.0f;
+ v.r = cround64(varr[fv.vidx].r * 255.0);
+ v.g = cround64(varr[fv.vidx].g * 255.0);
+ v.b = cround64(varr[fv.vidx].b * 255.0);
+ v.a = cround64(varr[fv.vidx].a * 255.0);
+ if(fv.tidx >= 0) {
+ v.u = tarr[fv.tidx].x;
+ v.v = tarr[fv.tidx].y;
+ } else {
+ v.u = v.x;
+ v.v = v.y;
+ }
+ if(fv.nidx >= 0) {
+ v.nx = narr[fv.nidx].x;
+ v.ny = narr[fv.nidx].y;
+ v.nz = narr[fv.nidx].z;
+ } else {
+ v.nx = v.ny = 0.0f;
+ v.nz = 1.0f;
+ }
+
+ if(!(mesh->varr = dynarr_push(mesh->varr, &v))) {
+ fprintf(stderr, "load_mesh: failed to resize combined vertex array\n");
+ goto err;
+ }
+ if(!(mesh->iarr = dynarr_push(mesh->iarr, &newidx))) {
+ fprintf(stderr, "load_mesh: failed to resize index array\n");
+ goto err;
+ }
+
+ if((newfv = malloc(sizeof *newfv))) {
+ *newfv = fv;
+ }
+ if(!newfv || rb_insert(rbtree, newfv, (void*)(intptr_t)newidx) == -1) {
+ fprintf(stderr, "load_mesh: failed to insert facevertex to the binary search tree\n");
+ goto err;
+ }
+ }
+ }
+ if(i > 3) found_quad = 1;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ mesh->prim = found_quad ? G3D_QUADS : G3D_TRIANGLES;
+ mesh->vcount = dynarr_size(mesh->varr);
+ mesh->icount = dynarr_size(mesh->iarr);
+ mesh->varr = dynarr_finalize(mesh->varr);
+ mesh->iarr = dynarr_finalize(mesh->iarr);
+ result = 0; /* success */
+
+ printf("loaded %s mesh: %s: %d vertices, %d faces\n", found_quad ? "quad" : "triangle",
+ fname, mesh->vcount, mesh->icount / mesh->prim);
+
+err:
+ if(fp) fclose(fp);
+ dynarr_free(varr);
+ dynarr_free(narr);
+ dynarr_free(tarr);
+ if(result == -1) {
+ dynarr_free(mesh->varr);
+ dynarr_free(mesh->iarr);
+ }
+ rb_free(rbtree);
+ return result;
+}
+
+int save_mesh(struct g3d_mesh *mesh, const char *fname)
+{
+ int i, fvcount;
+ FILE *fp;
+
+ if(!(fp = fopen(fname, "wb"))) {
+ fprintf(stderr, "save_mesh: failed to open %s for writing\n", fname);
+ return -1;
+ }
+ fprintf(fp, "# Wavefront OBJ file shoved in your FACE by Mindlapse. Deal with it\n");
+
+ for(i=0; i<mesh->vcount; i++) {
+ struct g3d_vertex *v = mesh->varr + i;
+ fprintf(fp, "v %f %f %f %f %f %f %f\n", v->x, v->y, v->z, v->r / 255.0f, v->g / 255.0f,
+ v->b / 255.0f, v->a / 255.0f);
+ }
+ for(i=0; i<mesh->vcount; i++) {
+ fprintf(fp, "vn %f %f %f\n", mesh->varr[i].nx, mesh->varr[i].ny, mesh->varr[i].nz);
+ }
+ for(i=0; i<mesh->vcount; i++) {
+ fprintf(fp, "vt %f %f\n", mesh->varr[i].u, mesh->varr[i].v);
+ }
+
+ fvcount = mesh->prim;
+ for(i=0; i<mesh->icount; i++) {
+ int idx = mesh->iarr[i] + 1;
+
+ if(fvcount == mesh->prim) {
+ fprintf(fp, "\nf");
+ fvcount = 0;
+ }
+ fprintf(fp, " %d/%d/%d", idx, idx, idx);
+ ++fvcount;
+ }
+ fprintf(fp, "\n");
+
+ fclose(fp);
+ return 0;
+}
+
+static char *clean_line(char *s)
+{
+ char *end;
+
+ while(*s && isspace(*s)) ++s;
+ if(!*s) return 0;
+
+ end = s;
+ while(*end && *end != '#') ++end;
+ *end = 0;
+
+ while(end > s && isspace(*end)) --end;
+ *end = 0;
+
+ return s;
+}
+
+static char *parse_idx(char *ptr, int *idx, int arrsz)
+{
+ char *endp;
+ int val = strtol(ptr, &endp, 10);
+ if(endp == ptr) return 0;
+
+ if(val < 0) { /* convert negative indices */
+ *idx = arrsz + val;
+ } else {
+ *idx = val - 1; /* indices in obj are 1-based */
+ }
+ return endp;
+}
+
+/* possible face-vertex definitions:
+ * 1. vertex
+ * 2. vertex/texcoord
+ * 3. vertex//normal
+ * 4. vertex/texcoord/normal
+ */
+static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn)
+{
+ if(!(ptr = parse_idx(ptr, &fv->vidx, numv)))
+ return 0;
+ if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
+
+ if(*++ptr == '/') { /* no texcoord */
+ fv->tidx = -1;
+ ++ptr;
+ } else {
+ if(!(ptr = parse_idx(ptr, &fv->tidx, numt)))
+ return 0;
+ if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
+ ++ptr;
+ }
+
+ if(!(ptr = parse_idx(ptr, &fv->nidx, numn)))
+ return 0;
+ return (!*ptr || isspace(*ptr)) ? ptr : 0;
+}
+
+static int cmp_facevert(const void *ap, const void *bp)
+{
+ const struct facevertex *a = ap;
+ const struct facevertex *b = bp;
+
+ if(a->vidx == b->vidx) {
+ if(a->tidx == b->tidx) {
+ return a->nidx - b->nidx;
+ }
+ return a->tidx - b->tidx;
+ }
+ return a->vidx - b->vidx;
+}
+
+static void free_rbnode_key(struct rbnode *n, void *cls)
+{
+ free(n->key);
+}
--- /dev/null
+#include <stdlib.h>
+#include "music.h"
+#include "mikmod.h"
+
+#ifdef __WATCOMC__
+#define USE_OLDMIK
+typedef UNIMOD MODULE;
+
+static void update_callback(void);
+static void MikMod_RegisterAllDrivers(void);
+static void MikMod_RegisterAllLoaders(void);
+#else
+#define USE_NEWMIK
+#endif
+
+static MODULE *mod;
+static int initialized;
+
+static int init(void)
+{
+ MikMod_RegisterAllDrivers();
+ MikMod_RegisterAllLoaders();
+
+#ifdef USE_NEWMIK
+ md_mode |= DMODE_SOFT_MUSIC | DMODE_16BITS | DMODE_STEREO | DMODE_INTERP;
+ if(MikMod_Init("") != 0) {
+ fprintf(stderr, "mikmod init failed: %s\n",
+ MikMod_strerror(MikMod_errno));
+ return -1;
+ }
+
+#else
+ md_mixfreq = 44100;
+ md_dmabufsize = 20000;
+ md_mode = DMODE_STEREO | DMODE_16BITS | DMODE_INTERP;
+ md_device = 0;
+
+ MD_RegisterPlayer(update_callback);
+
+ if(!MD_Init()) {
+ fprintf(stderr, "mikmod init failed: %s\n", myerr);
+ return -1;
+ }
+ printf("using mikmod driver %s\n", md_driver->Name);
+ printf(" %d bits, %s, %s mixing at %d Hz\n", md_mode & DMODE_16BITS ? 16 : 8,
+ md_mode & DMODE_STEREO ? "stereo" : "mono",
+ md_mode & DMODE_INTERP ? "interpolated" : "normal",
+ md_mixfreq);
+
+ atexit(MD_Exit);
+#endif
+ return 0;
+}
+
+int music_open(const char *fname)
+{
+ if(!initialized) {
+ if(init() == -1) {
+ return -1;
+ }
+ initialized = 1;
+ }
+
+#ifdef USE_NEWMIK
+ if(!(mod = Player_Load(fname, 64, 0))) {
+ fprintf(stderr, "failed to load music: %s: %s\n", fname,
+ MikMod_strerror(MikMod_errno));
+ return -1;
+ }
+#else
+ if(!(mod = ML_LoadFN((char*)fname))) {
+ fprintf(stderr, "failed to load music: %s: %s\n", fname, myerr);
+ return -1;
+ }
+
+ MP_Init(mod);
+ md_numchn = mod->numchn;
+ printf("opened module %s (%d channels)\n", fname, md_numchn);
+#endif
+ return 0;
+}
+
+void music_close(void)
+{
+ if(mod) {
+ printf("shutting down music playback\n");
+ music_stop();
+#ifdef USE_NEWMIK
+ Player_Free(mod);
+#else
+ ML_Free(mod);
+#endif
+ mod = 0;
+ }
+}
+
+void music_play(void)
+{
+#ifdef USE_NEWMIK
+ Player_Start(mod);
+#else
+ MD_PlayStart();
+#endif
+}
+
+void music_stop(void)
+{
+#ifdef USE_NEWMIK
+ Player_Stop();
+#else
+ MD_PlayStop();
+#endif
+}
+
+void music_update(void)
+{
+#ifdef USE_NEWMIK
+ if(Player_Active()) {
+ MikMod_Update();
+ }
+#else
+ MD_Update();
+#endif
+}
+
+#ifdef USE_OLDMIK
+static void update_callback(void)
+{
+ MP_HandleTick();
+ MD_SetBPM(mp_bpm);
+}
+
+static void MikMod_RegisterAllDrivers(void)
+{
+ MD_RegisterDriver(&drv_nos);
+ MD_RegisterDriver(&drv_ss);
+ MD_RegisterDriver(&drv_sb);
+ MD_RegisterDriver(&drv_gus);
+}
+
+static void MikMod_RegisterAllLoaders(void)
+{
+ ML_RegisterLoader(&load_m15);
+ ML_RegisterLoader(&load_mod);
+ ML_RegisterLoader(&load_mtm);
+ ML_RegisterLoader(&load_s3m);
+ ML_RegisterLoader(&load_stm);
+ ML_RegisterLoader(&load_ult);
+ ML_RegisterLoader(&load_uni);
+ ML_RegisterLoader(&load_xm);
+}
+#endif
--- /dev/null
+#ifndef MUSIC_H_
+#define MUSIC_H_
+
+int music_open(const char *fname);
+void music_close(void);
+void music_play(void);
+void music_stop(void);
+void music_update(void);
+
+#endif /* MUSIC_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "demo.h"
+#include "3dgfx.h"
+#include "screen.h"
+#include "cfgopt.h"
+#include "polyfill.h"
+#include "imago2.h"
+#include "gfxutil.h"
+#include "mesh.h"
+
+static int init(void);
+static void destroy(void);
+static void start(long trans_time);
+static void draw(void);
+
+static struct screen scr = {
+ "rtxonoff",
+ init,
+ destroy,
+ start, 0,
+ draw
+};
+
+static float cam_theta = -29, cam_phi = 35;
+static float cam_dist = 6;
+
+static const char *car_fname[2] = {"data/ldiablo.obj", 0};
+static const char *cartex_fname[2] = {"data/ldiablo.png", 0};
+static struct g3d_mesh mesh_car[2];
+static struct pimage tex_car[2];
+
+struct screen *rtxonoff_screen(void)
+{
+ return &scr;
+}
+
+static int init(void)
+{
+ int i;
+
+ for(i=0; i<sizeof car_fname / sizeof car_fname[0]; i++) {
+ if(cartex_fname[i]) {
+ if(!(tex_car[i].pixels = img_load_pixels(cartex_fname[i],
+ &tex_car[i].width, &tex_car[i].height, IMG_FMT_RGB24))) {
+ fprintf(stderr, "failed to load car texture: %s\n", cartex_fname[i]);
+ }
+ convimg_rgb24_rgb16(tex_car[i].pixels, (unsigned char*)tex_car[i].pixels,
+ tex_car[i].width, tex_car[i].height);
+ }
+ if(car_fname[i]) {
+ if(load_mesh(&mesh_car[i], car_fname[i]) == -1) {
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+static void destroy(void)
+{
+}
+
+static void start(long trans_time)
+{
+ g3d_matrix_mode(G3D_PROJECTION);
+ g3d_load_identity();
+ g3d_perspective(60.0, 1.3333333, 0.5, 100.0);
+
+ g3d_enable(G3D_CULL_FACE);
+ g3d_enable(G3D_LIGHTING);
+ g3d_enable(G3D_LIGHT0);
+}
+
+static void update(void)
+{
+ mouse_orbit_update(&cam_theta, &cam_phi, &cam_dist);
+}
+
+static void draw(void)
+{
+ int i;
+ float t = (float)time_msec / 16.0f;
+
+ update();
+
+ memset(fb_pixels, 0, fb_width * fb_height * 2);
+
+ g3d_matrix_mode(G3D_MODELVIEW);
+ g3d_load_identity();
+ g3d_translate(0, 0, -cam_dist);
+ g3d_rotate(cam_phi, 1, 0, 0);
+ g3d_rotate(cam_theta, 0, 1, 0);
+
+ g3d_polygon_mode(G3D_TEX_GOURAUD);
+
+ for(i=0; i<sizeof mesh_car / sizeof mesh_car[0]; i++) {
+ if(mesh_car[i].varr) {
+ g3d_set_texture(tex_car[i].width, tex_car[i].height, tex_car[i].pixels);
+
+ zsort_mesh(&mesh_car[i]);
+ draw_mesh(&mesh_car[i]);
+ }
+ }
+
+ swap_buffers(fb_pixels);
+}
--- /dev/null
+#include <stdio.h>
+#include <math.h>
+#include <assert.h>
+#include "polyclip.h"
+
+struct ray {
+ float origin[3];
+ float dir[3];
+};
+
+static int clip_edge(struct g3d_vertex *poly, int *vnumptr,
+ const struct g3d_vertex *v0, const struct g3d_vertex *v1,
+ const struct cplane *plane);
+static int clip_edge_frustum(struct g3d_vertex *poly, int *vnumptr,
+ const struct g3d_vertex *v0, const struct g3d_vertex *v1, int fplane);
+static float distance_signed(float *pos, const struct cplane *plane);
+static int intersect(const struct ray *ray, const struct cplane *plane, float *t);
+static int inside_frustum_plane(const struct g3d_vertex *v, int fplane);
+
+
+int clip_poly(struct g3d_vertex *vout, int *voutnum,
+ const struct g3d_vertex *vin, int vnum, struct cplane *plane)
+{
+ int i, nextidx, res;
+ int edges_clipped = 0;
+
+ *voutnum = 0;
+
+ for(i=0; i<vnum; i++) {
+ nextidx = i + 1;
+ if(nextidx >= vnum) nextidx = 0;
+ res = clip_edge(vout, voutnum, vin + i, vin + nextidx, plane);
+ if(res == 0) {
+ ++edges_clipped;
+ }
+ }
+
+ if(*voutnum <= 0) {
+ assert(edges_clipped == 0);
+ return -1;
+ }
+
+ return edges_clipped > 0 ? 0 : 1;
+}
+
+
+int clip_frustum(struct g3d_vertex *vout, int *voutnum,
+ const struct g3d_vertex *vin, int vnum, int fplane)
+{
+ int i, nextidx, res;
+ int edges_clipped = 0;
+
+ if(vnum == 1) {
+ /* special case: point clipping */
+ return inside_frustum_plane(vin, fplane) ? 1 : -1;
+ }
+
+ *voutnum = 0;
+
+ for(i=0; i<vnum; i++) {
+ nextidx = i + 1;
+ if(nextidx >= vnum) nextidx = 0;
+ res = clip_edge_frustum(vout, voutnum, vin + i, vin + nextidx, fplane);
+ if(res == 0) {
+ ++edges_clipped;
+ }
+ }
+
+ if(*voutnum <= 0) {
+ assert(edges_clipped == 0);
+ return -1;
+ }
+
+ return edges_clipped > 0 ? 0 : 1;
+}
+
+#define LERP_VATTR(res, v0, v1, t) \
+ do { \
+ (res)->nx = (v0)->nx + ((v1)->nx - (v0)->nx) * (t); \
+ (res)->ny = (v0)->ny + ((v1)->ny - (v0)->ny) * (t); \
+ (res)->nz = (v0)->nz + ((v1)->nz - (v0)->nz) * (t); \
+ (res)->u = (v0)->u + ((v1)->u - (v0)->u) * (t); \
+ (res)->v = (v0)->v + ((v1)->v - (v0)->v) * (t); \
+ (res)->r = (v0)->r + ((v1)->r - (v0)->r) * (t); \
+ (res)->g = (v0)->g + ((v1)->g - (v0)->g) * (t); \
+ (res)->b = (v0)->b + ((v1)->b - (v0)->b) * (t); \
+ } while(0)
+
+
+/* returns:
+ * 1 -> both inside
+ * 0 -> straddling and clipped
+ * -1 -> both outside
+ *
+ * also returns the size of the polygon through vnumptr
+ */
+static int clip_edge(struct g3d_vertex *poly, int *vnumptr,
+ const struct g3d_vertex *v0, const struct g3d_vertex *v1,
+ const struct cplane *plane)
+{
+ float pos0[3], pos1[3];
+ float d0, d1, t;
+ struct ray ray;
+ int i, vnum = *vnumptr;
+
+ pos0[0] = v0->x; pos0[1] = v0->y; pos0[2] = v0->z;
+ pos1[0] = v1->x; pos1[1] = v1->y; pos1[2] = v1->z;
+
+ d0 = distance_signed(pos0, plane);
+ d1 = distance_signed(pos1, plane);
+
+ for(i=0; i<3; i++) {
+ ray.origin[i] = pos0[i];
+ ray.dir[i] = pos1[i] - pos0[i];
+ }
+
+ if(d0 >= 0.0) {
+ /* start inside */
+ if(d1 >= 0.0) {
+ /* all inside */
+ poly[vnum++] = *v1; /* append v1 */
+ *vnumptr = vnum;
+ return 1;
+ } else {
+ /* going out */
+ struct g3d_vertex *vptr = poly + vnum;
+
+ intersect(&ray, plane, &t);
+
+ vptr->x = ray.origin[0] + ray.dir[0] * t;
+ vptr->y = ray.origin[1] + ray.dir[1] * t;
+ vptr->z = ray.origin[2] + ray.dir[2] * t;
+ vptr->w = 1.0f;
+
+ LERP_VATTR(vptr, v0, v1, t);
+ vnum++; /* append new vertex on the intersection point */
+ }
+ } else {
+ /* start outside */
+ if(d1 >= 0) {
+ /* going in */
+ struct g3d_vertex *vptr = poly + vnum;
+
+ intersect(&ray, plane, &t);
+
+ vptr->x = ray.origin[0] + ray.dir[0] * t;
+ vptr->y = ray.origin[1] + ray.dir[1] * t;
+ vptr->z = ray.origin[2] + ray.dir[2] * t;
+ vptr->w = 1.0f;
+
+ LERP_VATTR(vptr, v0, v1, t);
+ vnum++; /* append new vertex on the intersection point */
+
+ /* then append v1 ... */
+ poly[vnum++] = *v1;
+ } else {
+ /* all outside */
+ return -1;
+ }
+ }
+
+ *vnumptr = vnum;
+ return 0;
+}
+
+
+static float distance_signed(float *pos, const struct cplane *plane)
+{
+ float dx = pos[0] - plane->x;
+ float dy = pos[1] - plane->y;
+ float dz = pos[2] - plane->z;
+ return dx * plane->nx + dy * plane->ny + dz * plane->nz;
+}
+
+static int intersect(const struct ray *ray, const struct cplane *plane, float *t)
+{
+ float orig_pt_dir[3];
+
+ float ndotdir = plane->nx * ray->dir[0] + plane->ny * ray->dir[1] + plane->nz * ray->dir[2];
+ if(fabs(ndotdir) < 1e-6) {
+ *t = 0.0f;
+ return 0;
+ }
+
+ orig_pt_dir[0] = plane->x - ray->origin[0];
+ orig_pt_dir[1] = plane->y - ray->origin[1];
+ orig_pt_dir[2] = plane->z - ray->origin[2];
+
+ *t = (plane->nx * orig_pt_dir[0] + plane->ny * orig_pt_dir[1] + plane->nz * orig_pt_dir[2]) / ndotdir;
+ return 1;
+}
+
+/* homogeneous frustum clipper helpers */
+
+static int inside_frustum_plane(const struct g3d_vertex *v, int fplane)
+{
+ switch(fplane) {
+ case CLIP_LEFT:
+ return v->x >= -v->w;
+ case CLIP_RIGHT:
+ return v->x <= v->w;
+ case CLIP_BOTTOM:
+ return v->y >= -v->w;
+ case CLIP_TOP:
+ return v->y <= v->w;
+ case CLIP_NEAR:
+ return v->z >= -v->w;
+ case CLIP_FAR:
+ return v->z <= v->w;
+ }
+ assert(0);
+ return 0;
+}
+
+static float intersect_frustum(const struct g3d_vertex *a, const struct g3d_vertex *b, int fplane)
+{
+ switch(fplane) {
+ case CLIP_LEFT:
+ return (-a->w - a->x) / (b->x - a->x + b->w - a->w);
+ case CLIP_RIGHT:
+ return (a->w - a->x) / (b->x - a->x - b->w + a->w);
+ case CLIP_BOTTOM:
+ return (-a->w - a->y) / (b->y - a->y + b->w - a->w);
+ case CLIP_TOP:
+ return (a->w - a->y) / (b->y - a->y - b->w + a->w);
+ case CLIP_NEAR:
+ return (-a->w - a->z) / (b->z - a->z + b->w - a->w);
+ case CLIP_FAR:
+ return (a->w - a->z) / (b->z - a->z - b->w + a->w);
+ }
+
+ assert(0);
+ return 0;
+}
+
+static int clip_edge_frustum(struct g3d_vertex *poly, int *vnumptr,
+ const struct g3d_vertex *v0, const struct g3d_vertex *v1, int fplane)
+{
+ int vnum = *vnumptr;
+ int in0, in1;
+ float t;
+
+ in0 = inside_frustum_plane(v0, fplane);
+ in1 = inside_frustum_plane(v1, fplane);
+
+ if(in0) {
+ /* start inside */
+ if(in1) {
+ /* all inside */
+ poly[vnum++] = *v1; /* append v1 */
+ *vnumptr = vnum;
+ return 1;
+ } else {
+ /* going out */
+ struct g3d_vertex *vptr = poly + vnum;
+
+ t = intersect_frustum(v0, v1, fplane);
+
+ vptr->x = v0->x + (v1->x - v0->x) * t;
+ vptr->y = v0->y + (v1->y - v0->y) * t;
+ vptr->z = v0->z + (v1->z - v0->z) * t;
+ vptr->w = v0->w + (v1->w - v0->w) * t;
+
+ LERP_VATTR(vptr, v0, v1, t);
+ ++vnum; /* append new vertex on the intersection point */
+ }
+ } else {
+ /* start outside */
+ if(in1) {
+ /* going in */
+ struct g3d_vertex *vptr = poly + vnum;
+
+ t = intersect_frustum(v0, v1, fplane);
+
+ vptr->x = v0->x + (v1->x - v0->x) * t;
+ vptr->y = v0->y + (v1->y - v0->y) * t;
+ vptr->z = v0->z + (v1->z - v0->z) * t;
+ vptr->w = v0->w + (v1->w - v0->w) * t;
+
+ LERP_VATTR(vptr, v0, v1, t);
+ ++vnum; /* append new vertex on the intersection point */
+
+ /* then append v1 ... */
+ poly[vnum++] = *v1;
+ } else {
+ /* all outside */
+ return -1;
+ }
+ }
+
+ *vnumptr = vnum;
+ return 0;
+}
--- /dev/null
+#ifndef POLYCLIP_H_
+#define POLYCLIP_H_
+
+#include "3dgfx.h"
+
+struct cplane {
+ float x, y, z;
+ float nx, ny, nz;
+};
+
+enum {
+ CLIP_LEFT, CLIP_RIGHT,
+ CLIP_BOTTOM, CLIP_TOP,
+ CLIP_NEAR, CLIP_FAR
+};
+
+/* Generic polygon clipper
+ * returns:
+ * 1 -> fully inside, not clipped
+ * 0 -> straddling the plane and clipped
+ * -1 -> fully outside, not clipped
+ * in all cases, vertices are copied to vout, and the vertex count is written
+ * to wherever voutnum is pointing
+ */
+int clip_poly(struct g3d_vertex *vout, int *voutnum,
+ const struct g3d_vertex *vin, int vnum, struct cplane *plane);
+
+/* Special-case frustum clipper (might be slightly faster) */
+int clip_frustum(struct g3d_vertex *vout, int *voutnum,
+ const struct g3d_vertex *vin, int vnum, int fplane);
+
+#endif /* POLYCLIP_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#if defined(__WATCOMC__) || defined(_MSC_VER) || defined(__DJGPP__)
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include "polyfill.h"
+#include "gfxutil.h"
+#include "demo.h"
+
+void (*fillfunc[])(struct pvertex*, int) = {
+ polyfill_wire,
+ polyfill_flat,
+ polyfill_gouraud,
+ polyfill_tex,
+ polyfill_tex_gouraud
+};
+
+struct pimage pfill_fb, pfill_tex;
+
+void polyfill(int mode, struct pvertex *verts, int nverts)
+{
+#ifndef NDEBUG
+ if(!fillfunc[mode]) {
+ fprintf(stderr, "polyfill mode %d not implemented\n", mode);
+ abort();
+ }
+#endif
+
+ fillfunc[mode](verts, nverts);
+}
+
+void polyfill_wire(struct pvertex *verts, int nverts)
+{
+ int i, x0, y0, x1, y1;
+ struct pvertex *v = verts;
+ unsigned short color = ((v->r << 8) & 0xf800) |
+ ((v->g << 3) & 0x7e0) | ((v->b >> 3) & 0x1f);
+
+ for(i=0; i<nverts - 1; i++) {
+ x0 = v->x >> 8;
+ y0 = v->y >> 8;
+ ++v;
+ x1 = v->x >> 8;
+ y1 = v->y >> 8;
+ if(clip_line(&x0, &y0, &x1, &y1, 0, 0, pfill_fb.width, pfill_fb.height)) {
+ draw_line(x0, y0, x1, y1, color);
+ }
+ }
+ x0 = verts[0].x >> 8;
+ y0 = verts[0].y >> 8;
+ if(clip_line(&x1, &y1, &x0, &y0, 0, 0, pfill_fb.width, pfill_fb.height)) {
+ draw_line(x1, y1, x0, y0, color);
+ }
+}
+
+#define NEXTIDX(x) (((x) - 1 + nverts) % nverts)
+#define PREVIDX(x) (((x) + 1) % nverts)
+
+/* XXX
+ * When HIGH_QUALITY is defined, the rasterizer calculates slopes for attribute
+ * interpolation on each scanline separately; otherwise the slope for each
+ * attribute would be calculated once for the whole polygon, which is faster,
+ * but produces some slight quantization artifacts, due to the limited precision
+ * of fixed-point calculations.
+ */
+#define HIGH_QUALITY
+
+/* extra bits of precision to use when interpolating colors.
+ * try tweaking this if you notice strange quantization artifacts.
+ */
+#define COLOR_SHIFT 12
+
+
+#define POLYFILL polyfill_flat
+#define SCANEDGE scanedge_flat
+#undef GOURAUD
+#undef TEXMAP
+#include "polytmpl.h"
+#undef POLYFILL
+#undef SCANEDGE
+
+#define POLYFILL polyfill_gouraud
+#define SCANEDGE scanedge_gouraud
+#define GOURAUD
+#undef TEXMAP
+#include "polytmpl.h"
+#undef POLYFILL
+#undef SCANEDGE
+
+#define POLYFILL polyfill_tex
+#define SCANEDGE scanedge_tex
+#undef GOURAUD
+#define TEXMAP
+#include "polytmpl.h"
+#undef POLYFILL
+#undef SCANEDGE
+
+#define POLYFILL polyfill_tex_gouraud
+#define SCANEDGE scanedge_tex_gouraud
+#define GOURAUD
+#define TEXMAP
+#include "polytmpl.h"
+#undef POLYFILL
+#undef SCANEDGE
--- /dev/null
+#ifndef POLYFILL_H_
+#define POLYFILL_H_
+
+#include "inttypes.h"
+
+enum {
+ POLYFILL_WIRE,
+ POLYFILL_FLAT,
+ POLYFILL_GOURAUD,
+ POLYFILL_TEX,
+ POLYFILL_TEX_GOURAUD
+};
+
+/* projected vertices for the rasterizer */
+struct pvertex {
+ int32_t x, y; /* 24.8 fixed point */
+ int32_t u, v; /* 16.16 fixed point */
+ int32_t r, g, b, a; /* int 0-255 */
+};
+
+struct pimage {
+ uint16_t *pixels;
+ int width, height;
+
+ int xshift, yshift;
+ unsigned int xmask, ymask;
+};
+
+extern struct pimage pfill_fb;
+extern struct pimage pfill_tex;
+
+void polyfill(int mode, struct pvertex *verts, int nverts);
+void polyfill_wire(struct pvertex *verts, int nverts);
+void polyfill_flat(struct pvertex *verts, int nverts);
+void polyfill_gouraud(struct pvertex *verts, int nverts);
+void polyfill_tex(struct pvertex *verts, int nverts);
+void polyfill_tex_gouraud(struct pvertex *verts, int nverts);
+
+#endif /* POLYFILL_H_ */
--- /dev/null
+static uint32_t SCANEDGE(struct pvertex *v0, struct pvertex *v1, struct pvertex *edge)
+{
+ int i;
+ int32_t x, dx, dy, slope;
+#ifdef GOURAUD
+ int r, g, b, dr, dg, db;
+ int32_t rslope, gslope, bslope;
+#endif
+#ifdef TEXMAP
+ int32_t u, v, du, dv, uslope, vslope;
+#endif
+ int32_t start_idx, end_idx;
+
+ if(v0->y > v1->y) {
+ struct pvertex *tmp = v0;
+ v0 = v1;
+ v1 = tmp;
+ }
+
+ x = v0->x;
+ dy = v1->y - v0->y;
+ dx = v1->x - v0->x;
+ slope = (dx << 8) / dy;
+#ifdef GOURAUD
+ r = (v0->r << COLOR_SHIFT);
+ g = (v0->g << COLOR_SHIFT);
+ b = (v0->b << COLOR_SHIFT);
+ dr = (v1->r << COLOR_SHIFT) - r;
+ dg = (v1->g << COLOR_SHIFT) - g;
+ db = (v1->b << COLOR_SHIFT) - b;
+ rslope = (dr << 8) / dy;
+ gslope = (dg << 8) / dy;
+ bslope = (db << 8) / dy;
+#endif
+#ifdef TEXMAP
+ u = v0->u;
+ v = v0->v;
+ du = v1->u - v0->u;
+ dv = v1->v - v0->v;
+ uslope = (du << 8) / dy;
+ vslope = (dv << 8) / dy;
+#endif
+
+ start_idx = v0->y >> 8;
+ end_idx = v1->y >> 8;
+
+ for(i=start_idx; i<end_idx; i++) {
+ edge[i].x = x;
+ x += slope;
+#ifdef GOURAUD
+ /* we'll store the color in the edge tables with COLOR_SHIFT extra bits of precision */
+ edge[i].r = r;
+ edge[i].g = g;
+ edge[i].b = b;
+ r += rslope;
+ g += gslope;
+ b += bslope;
+#endif
+#ifdef TEXMAP
+ edge[i].u = u;
+ edge[i].v = v;
+ u += uslope;
+ v += vslope;
+#endif
+ }
+
+ return (uint32_t)start_idx | ((uint32_t)(end_idx - 1) << 16);
+}
+
+void POLYFILL(struct pvertex *pv, int nverts)
+{
+ int i;
+ int topidx = 0, botidx = 0, sltop = pfill_fb.height, slbot = 0;
+ struct pvertex *left, *right;
+ uint16_t color;
+ /* the following variables are used for interpolating horizontally accros scanlines */
+#if defined(GOURAUD) || defined(TEXMAP)
+ int mid;
+ int32_t dx, tmp;
+#else
+ /* flat version, just pack the color now */
+ color = PACK_RGB16(pv[0].r, pv[0].g, pv[0].b);
+#endif
+#ifdef GOURAUD
+ int32_t r, g, b, dr, dg, db, rslope, gslope, bslope;
+#endif
+#ifdef TEXMAP
+ int32_t u, v, du, dv, uslope, vslope;
+#endif
+
+ for(i=1; i<nverts; i++) {
+ if(pv[i].y < pv[topidx].y) topidx = i;
+ if(pv[i].y > pv[botidx].y) botidx = i;
+ }
+
+ /* +1 to avoid crashing due to off-by-one rounding errors in the rasterization */
+ left = alloca((pfill_fb.height + 1) * sizeof *left);
+ right = alloca((pfill_fb.height + 1) * sizeof *right);
+
+ for(i=0; i<nverts; i++) {
+ int next = NEXTIDX(i);
+ int32_t y0 = pv[i].y;
+ int32_t y1 = pv[next].y;
+
+ if((y0 >> 8) == (y1 >> 8)) {
+ /*if(y0 > y1) {*/
+ int i0, i1;
+ int idx = y0 >> 8;
+ if(pv[i].x < pv[next].x) {
+ i0 = i;
+ i1 = next;
+ } else {
+ i0 = next;
+ i1 = i;
+ }
+ left[idx].x = pv[i0].x;
+ right[idx].x = pv[i1].x;
+#ifdef GOURAUD
+ left[idx].r = pv[i0].r << COLOR_SHIFT;
+ left[idx].g = pv[i0].g << COLOR_SHIFT;
+ left[idx].b = pv[i0].b << COLOR_SHIFT;
+ right[idx].r = pv[i1].r << COLOR_SHIFT;
+ right[idx].g = pv[i1].g << COLOR_SHIFT;
+ right[idx].b = pv[i1].b << COLOR_SHIFT;
+#endif
+#ifdef TEXMAP
+ left[idx].u = pv[i0].u;
+ left[idx].v = pv[i0].v;
+ right[idx].u = pv[i1].u;
+ right[idx].v = pv[i1].v;
+#endif
+ if(idx > slbot) slbot = idx;
+ if(idx < sltop) sltop = idx;
+ /*}*/
+ } else {
+ struct pvertex *edge = y0 > y1 ? left : right;
+ uint32_t res = SCANEDGE(pv + i, pv + next, edge);
+ uint32_t tmp = (res >> 16) & 0xffff;
+ if(tmp > slbot) slbot = tmp;
+ if((tmp = res & 0xffff) < sltop) {
+ sltop = tmp;
+ }
+ }
+ }
+
+ /* calculate the slopes of all attributes across the largest span out
+ * of the three: middle, top, or bottom.
+ */
+#ifndef HIGH_QUALITY
+#if defined(GOURAUD) || defined(TEXMAP)
+ mid = (sltop + slbot) >> 1;
+ dx = right[mid].x - left[mid].x;
+ if((tmp = right[sltop].x - left[sltop].x) > dx) {
+ dx = tmp;
+ mid = sltop;
+ }
+ if((tmp = right[slbot].x - left[slbot].x) > dx) {
+ dx = tmp;
+ mid = slbot;
+ }
+ if(!dx) dx = 256; /* avoid division by zero */
+#endif
+#ifdef GOURAUD
+ dr = right[mid].r - left[mid].r;
+ dg = right[mid].g - left[mid].g;
+ db = right[mid].b - left[mid].b;
+ rslope = (dr << 8) / dx;
+ gslope = (dg << 8) / dx;
+ bslope = (db << 8) / dx;
+#endif
+#ifdef TEXMAP
+ du = right[mid].u - left[mid].u;
+ dv = right[mid].v - left[mid].v;
+ uslope = (du << 8) / dx;
+ vslope = (dv << 8) / dx;
+#endif
+#endif /* !defined(HIGH_QUALITY) */
+
+ /* for each scanline ... */
+ for(i=sltop; i<=slbot; i++) {
+ uint16_t *pixptr;
+ int32_t x;
+
+ x = left[i].x;
+ pixptr = pfill_fb.pixels + i * pfill_fb.width + (x >> 8);
+
+#ifdef GOURAUD
+ r = left[i].r;
+ g = left[i].g;
+ b = left[i].b;
+#endif
+#ifdef TEXMAP
+ u = left[i].u;
+ v = left[i].v;
+#endif
+
+#if defined(HIGH_QUALITY) && (defined(GOURAUD) || defined(TEXMAP))
+ if(!(dx = right[i].x - left[i].x)) dx = 256;
+
+#ifdef GOURAUD
+ dr = right[i].r - left[i].r;
+ dg = right[i].g - left[i].g;
+ db = right[i].b - left[i].b;
+ rslope = (dr << 8) / dx;
+ gslope = (dg << 8) / dx;
+ bslope = (db << 8) / dx;
+#endif
+#ifdef TEXMAP
+ du = right[i].u - left[i].u;
+ dv = right[i].v - left[i].v;
+ uslope = (du << 8) / dx;
+ vslope = (dv << 8) / dx;
+#endif
+#endif /* HIGH_QUALITY */
+
+ /* go across the scanline interpolating if necessary */
+ while(x <= right[i].x) {
+#if defined(GOURAUD) || defined(TEXMAP)
+ int cr, cg, cb;
+#endif
+#ifdef GOURAUD
+ /* we upped the color precision to while interpolating the
+ * edges, now drop the extra bits before packing
+ */
+ cr = r < 0 ? 0 : (r >> COLOR_SHIFT);
+ cg = g < 0 ? 0 : (g >> COLOR_SHIFT);
+ cb = b < 0 ? 0 : (b >> COLOR_SHIFT);
+ if(cr > 255) cr = 255;
+ if(cg > 255) cg = 255;
+ if(cb > 255) cb = 255;
+ r += rslope;
+ g += gslope;
+ b += bslope;
+#endif
+#ifdef TEXMAP
+ {
+ int tx = (u >> (16 - pfill_tex.xshift)) & pfill_tex.xmask;
+ int ty = (v >> (16 - pfill_tex.yshift)) & pfill_tex.ymask;
+ uint16_t texel = pfill_tex.pixels[(ty << pfill_tex.xshift) + tx];
+#ifdef GOURAUD
+ /* This is not correct, should be /255, but it's much faster
+ * to shift by 8 (/256), and won't make a huge difference
+ */
+ cr = (cr * UNPACK_R16(texel)) >> 8;
+ cg = (cg * UNPACK_G16(texel)) >> 8;
+ cb = (cb * UNPACK_B16(texel)) >> 8;
+#else
+ cr = UNPACK_R16(texel);
+ cg = UNPACK_G16(texel);
+ cb = UNPACK_B16(texel);
+#endif
+ }
+ u += uslope;
+ v += vslope;
+#endif
+#if defined(GOURAUD) || defined(TEXMAP)
+ color = PACK_RGB16(cr, cg, cb);
+#endif
+
+#ifdef DEBUG_OVERDRAW
+ *pixptr++ += DEBUG_OVERDRAW;
+#else
+ *pixptr++ = color;
+#endif
+ x += 256;
+ }
+ }
+}
+
--- /dev/null
+/*
+rbtree - simple balanced binary search tree (red-black tree) library.
+Copyright (C) 2011-2014 John Tsiombikas <nuclear@member.fsf.org>
+
+rbtree is free software, feel free to use, modify, and redistribute it, under
+the terms of the 3-clause BSD license. See COPYING for details.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include "rbtree.h"
+
+#define INT2PTR(x) ((void*)(intptr_t)(x))
+#define PTR2INT(x) ((int)(intptr_t)(x))
+
+struct rbtree {
+ struct rbnode *root;
+
+ rb_alloc_func_t alloc;
+ rb_free_func_t free;
+
+ rb_cmp_func_t cmp;
+ rb_del_func_t del;
+ void *del_cls;
+
+ struct rbnode *rstack, *iter;
+};
+
+static int cmpaddr(const void *ap, const void *bp);
+static int cmpint(const void *ap, const void *bp);
+
+static int count_nodes(struct rbnode *node);
+static void del_tree(struct rbnode *node, void (*delfunc)(struct rbnode*, void*), void *cls);
+static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data);
+static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key);
+/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key);*/
+static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls);
+
+struct rbtree *rb_create(rb_cmp_func_t cmp_func)
+{
+ struct rbtree *rb;
+
+ if(!(rb = malloc(sizeof *rb))) {
+ return 0;
+ }
+ if(rb_init(rb, cmp_func) == -1) {
+ free(rb);
+ return 0;
+ }
+ return rb;
+}
+
+void rb_free(struct rbtree *rb)
+{
+ rb_destroy(rb);
+ free(rb);
+}
+
+
+int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func)
+{
+ memset(rb, 0, sizeof *rb);
+
+ if(!cmp_func) {
+ rb->cmp = cmpaddr;
+ } else if(cmp_func == RB_KEY_INT) {
+ rb->cmp = cmpint;
+ } else if(cmp_func == RB_KEY_STRING) {
+ rb->cmp = (rb_cmp_func_t)strcmp;
+ } else {
+ rb->cmp = cmp_func;
+ }
+
+ rb->alloc = malloc;
+ rb->free = free;
+ return 0;
+}
+
+void rb_destroy(struct rbtree *rb)
+{
+ del_tree(rb->root, rb->del, rb->del_cls);
+}
+
+void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free)
+{
+ rb->alloc = alloc;
+ rb->free = free;
+}
+
+
+void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func)
+{
+ rb->cmp = func;
+}
+
+void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls)
+{
+ rb->del = func;
+ rb->del_cls = cls;
+}
+
+
+void rb_clear(struct rbtree *rb)
+{
+ del_tree(rb->root, rb->del, rb->del_cls);
+ rb->root = 0;
+}
+
+int rb_copy(struct rbtree *dest, struct rbtree *src)
+{
+ struct rbnode *node;
+
+ rb_clear(dest);
+ rb_begin(src);
+ while((node = rb_next(src))) {
+ if(rb_insert(dest, node->key, node->data) == -1) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+int rb_size(struct rbtree *rb)
+{
+ return count_nodes(rb->root);
+}
+
+int rb_insert(struct rbtree *rb, void *key, void *data)
+{
+ rb->root = insert(rb, rb->root, key, data);
+ rb->root->red = 0;
+ return 0;
+}
+
+int rb_inserti(struct rbtree *rb, int key, void *data)
+{
+ rb->root = insert(rb, rb->root, INT2PTR(key), data);
+ rb->root->red = 0;
+ return 0;
+}
+
+
+int rb_delete(struct rbtree *rb, void *key)
+{
+ if((rb->root = delete(rb, rb->root, key))) {
+ rb->root->red = 0;
+ }
+ return 0;
+}
+
+int rb_deletei(struct rbtree *rb, int key)
+{
+ if((rb->root = delete(rb, rb->root, INT2PTR(key)))) {
+ rb->root->red = 0;
+ }
+ return 0;
+}
+
+
+struct rbnode *rb_find(struct rbtree *rb, void *key)
+{
+ struct rbnode *node = rb->root;
+
+ while(node) {
+ int cmp = rb->cmp(key, node->key);
+ if(cmp == 0) {
+ return node;
+ }
+ node = cmp < 0 ? node->left : node->right;
+ }
+ return 0;
+}
+
+struct rbnode *rb_findi(struct rbtree *rb, int key)
+{
+ return rb_find(rb, INT2PTR(key));
+}
+
+
+void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls)
+{
+ traverse(rb->root, func, cls);
+}
+
+
+struct rbnode *rb_root(struct rbtree *rb)
+{
+ return rb->root;
+}
+
+void rb_begin(struct rbtree *rb)
+{
+ rb->rstack = 0;
+ rb->iter = rb->root;
+}
+
+#define push(sp, x) ((x)->next = (sp), (sp) = (x))
+#define pop(sp) ((sp) = (sp)->next)
+#define top(sp) (sp)
+
+struct rbnode *rb_next(struct rbtree *rb)
+{
+ struct rbnode *res = 0;
+
+ while(rb->rstack || rb->iter) {
+ if(rb->iter) {
+ push(rb->rstack, rb->iter);
+ rb->iter = rb->iter->left;
+ } else {
+ rb->iter = top(rb->rstack);
+ pop(rb->rstack);
+ res = rb->iter;
+ rb->iter = rb->iter->right;
+ break;
+ }
+ }
+ return res;
+}
+
+void *rb_node_key(struct rbnode *node)
+{
+ return node ? node->key : 0;
+}
+
+int rb_node_keyi(struct rbnode *node)
+{
+ return node ? PTR2INT(node->key) : 0;
+}
+
+void *rb_node_data(struct rbnode *node)
+{
+ return node ? node->data : 0;
+}
+
+static int cmpaddr(const void *ap, const void *bp)
+{
+ return ap < bp ? -1 : (ap > bp ? 1 : 0);
+}
+
+static int cmpint(const void *ap, const void *bp)
+{
+ return PTR2INT(ap) - PTR2INT(bp);
+}
+
+
+/* ---- left-leaning 2-3 red-black implementation ---- */
+
+/* helper prototypes */
+static int is_red(struct rbnode *tree);
+static void color_flip(struct rbnode *tree);
+static struct rbnode *rot_left(struct rbnode *a);
+static struct rbnode *rot_right(struct rbnode *a);
+static struct rbnode *find_min(struct rbnode *tree);
+static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree);
+/*static struct rbnode *move_red_right(struct rbnode *tree);*/
+static struct rbnode *move_red_left(struct rbnode *tree);
+static struct rbnode *fix_up(struct rbnode *tree);
+
+static int count_nodes(struct rbnode *node)
+{
+ if(!node)
+ return 0;
+
+ return 1 + count_nodes(node->left) + count_nodes(node->right);
+}
+
+static void del_tree(struct rbnode *node, rb_del_func_t delfunc, void *cls)
+{
+ if(!node)
+ return;
+
+ del_tree(node->left, delfunc, cls);
+ del_tree(node->right, delfunc, cls);
+
+ if(delfunc) {
+ delfunc(node, cls);
+ }
+ free(node);
+}
+
+static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data)
+{
+ int cmp;
+
+ if(!tree) {
+ struct rbnode *node = rb->alloc(sizeof *node);
+ node->red = 1;
+ node->key = key;
+ node->data = data;
+ node->left = node->right = 0;
+ return node;
+ }
+
+ cmp = rb->cmp(key, tree->key);
+
+ if(cmp < 0) {
+ tree->left = insert(rb, tree->left, key, data);
+ } else if(cmp > 0) {
+ tree->right = insert(rb, tree->right, key, data);
+ } else {
+ tree->data = data;
+ }
+
+ /* fix right-leaning reds */
+ if(is_red(tree->right)) {
+ tree = rot_left(tree);
+ }
+ /* fix two reds in a row */
+ if(is_red(tree->left) && is_red(tree->left->left)) {
+ tree = rot_right(tree);
+ }
+
+ /* if 4-node, split it by color inversion */
+ if(is_red(tree->left) && is_red(tree->right)) {
+ color_flip(tree);
+ }
+
+ return tree;
+}
+
+static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key)
+{
+ int cmp;
+
+ if(!tree) {
+ return 0;
+ }
+
+ cmp = rb->cmp(key, tree->key);
+
+ if(cmp < 0) {
+ if(!is_red(tree->left) && !is_red(tree->left->left)) {
+ tree = move_red_left(tree);
+ }
+ tree->left = delete(rb, tree->left, key);
+ } else {
+ /* need reds on the right */
+ if(is_red(tree->left)) {
+ tree = rot_right(tree);
+ }
+
+ /* found it at the bottom (XXX what certifies left is null?) */
+ if(cmp == 0 && !tree->right) {
+ if(rb->del) {
+ rb->del(tree, rb->del_cls);
+ }
+ rb->free(tree);
+ return 0;
+ }
+
+ if(!is_red(tree->right) && !is_red(tree->right->left)) {
+ tree = move_red_left(tree);
+ }
+
+ if(key == tree->key) {
+ struct rbnode *rmin = find_min(tree->right);
+ tree->key = rmin->key;
+ tree->data = rmin->data;
+ tree->right = del_min(rb, tree->right);
+ } else {
+ tree->right = delete(rb, tree->right, key);
+ }
+ }
+
+ return fix_up(tree);
+}
+
+/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key)
+{
+ int cmp;
+
+ if(!node)
+ return 0;
+
+ if((cmp = rb->cmp(key, node->key)) == 0) {
+ return node;
+ }
+ return find(rb, cmp < 0 ? node->left : node->right, key);
+}*/
+
+static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls)
+{
+ if(!node)
+ return;
+
+ traverse(node->left, func, cls);
+ func(node, cls);
+ traverse(node->right, func, cls);
+}
+
+/* helpers */
+
+static int is_red(struct rbnode *tree)
+{
+ return tree && tree->red;
+}
+
+static void color_flip(struct rbnode *tree)
+{
+ tree->red = !tree->red;
+ tree->left->red = !tree->left->red;
+ tree->right->red = !tree->right->red;
+}
+
+static struct rbnode *rot_left(struct rbnode *a)
+{
+ struct rbnode *b = a->right;
+ a->right = b->left;
+ b->left = a;
+ b->red = a->red;
+ a->red = 1;
+ return b;
+}
+
+static struct rbnode *rot_right(struct rbnode *a)
+{
+ struct rbnode *b = a->left;
+ a->left = b->right;
+ b->right = a;
+ b->red = a->red;
+ a->red = 1;
+ return b;
+}
+
+static struct rbnode *find_min(struct rbnode *tree)
+{
+ if(!tree)
+ return 0;
+
+ while(tree->left) {
+ tree = tree->left;
+ }
+ return tree;
+}
+
+static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree)
+{
+ if(!tree->left) {
+ if(rb->del) {
+ rb->del(tree->left, rb->del_cls);
+ }
+ rb->free(tree->left);
+ return 0;
+ }
+
+ /* make sure we've got red (3/4-nodes) at the left side so we can delete at the bottom */
+ if(!is_red(tree->left) && !is_red(tree->left->left)) {
+ tree = move_red_left(tree);
+ }
+ tree->left = del_min(rb, tree->left);
+
+ /* fix right-reds, red-reds, and split 4-nodes on the way up */
+ return fix_up(tree);
+}
+
+#if 0
+/* push a red link on this node to the right */
+static struct rbnode *move_red_right(struct rbnode *tree)
+{
+ /* flipping it makes both children go red, so we have a red to the right */
+ color_flip(tree);
+
+ /* if after the flip we've got a red-red situation to the left, fix it */
+ if(is_red(tree->left->left)) {
+ tree = rot_right(tree);
+ color_flip(tree);
+ }
+ return tree;
+}
+#endif
+
+/* push a red link on this node to the left */
+static struct rbnode *move_red_left(struct rbnode *tree)
+{
+ /* flipping it makes both children go red, so we have a red to the left */
+ color_flip(tree);
+
+ /* if after the flip we've got a red-red on the right-left, fix it */
+ if(is_red(tree->right->left)) {
+ tree->right = rot_right(tree->right);
+ tree = rot_left(tree);
+ color_flip(tree);
+ }
+ return tree;
+}
+
+static struct rbnode *fix_up(struct rbnode *tree)
+{
+ /* fix right-leaning */
+ if(is_red(tree->right)) {
+ tree = rot_left(tree);
+ }
+ /* change invalid red-red pairs into a proper 4-node */
+ if(is_red(tree->left) && is_red(tree->left->left)) {
+ tree = rot_right(tree);
+ }
+ /* split 4-nodes */
+ if(is_red(tree->left) && is_red(tree->right)) {
+ color_flip(tree);
+ }
+ return tree;
+}
--- /dev/null
+/*
+rbtree - simple balanced binary search tree (red-black tree) library.
+Copyright (C) 2011-2014 John Tsiombikas <nuclear@member.fsf.org>
+
+rbtree is free software, feel free to use, modify, and redistribute it, under
+the terms of the 3-clause BSD license. See COPYING for details.
+ */
+#ifndef RBTREE_H_
+#define RBTREE_H_
+
+struct rbtree;
+
+
+struct rbnode {
+ void *key, *data;
+ int red;
+ struct rbnode *left, *right;
+ struct rbnode *next; /* for iterator stack */
+};
+
+
+typedef void *(*rb_alloc_func_t)(size_t);
+typedef void (*rb_free_func_t)(void*);
+
+typedef int (*rb_cmp_func_t)(const void*, const void*);
+typedef void (*rb_del_func_t)(struct rbnode*, void*);
+
+#define RB_KEY_ADDR (rb_cmp_func_t)(0)
+#define RB_KEY_INT (rb_cmp_func_t)(1)
+#define RB_KEY_STRING (rb_cmp_func_t)(3)
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct rbtree *rb_create(rb_cmp_func_t cmp_func);
+void rb_free(struct rbtree *rb);
+
+int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func);
+void rb_destroy(struct rbtree *rb);
+
+void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free);
+void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func);
+void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls);
+/* TODO add user deep copy function */
+
+void rb_clear(struct rbtree *rb);
+int rb_copy(struct rbtree *dest, struct rbtree *src);
+
+int rb_size(struct rbtree *rb);
+
+int rb_insert(struct rbtree *rb, void *key, void *data);
+int rb_inserti(struct rbtree *rb, int key, void *data);
+
+int rb_delete(struct rbtree *rb, void *key);
+int rb_deletei(struct rbtree *rb, int key);
+
+struct rbnode *rb_find(struct rbtree *rb, void *key);
+struct rbnode *rb_findi(struct rbtree *rb, int key);
+
+void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls);
+
+struct rbnode *rb_root(struct rbtree *rb);
+
+void rb_begin(struct rbtree *rb);
+struct rbnode *rb_next(struct rbtree *rb);
+
+void *rb_node_key(struct rbnode *node);
+int rb_node_keyi(struct rbnode *node);
+void *rb_node_data(struct rbnode *node);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* RBTREE_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "screen.h"
+#include "demo.h"
+
+struct screen *rtxonoff_screen(void);
+
+#define NUM_SCR 32
+static struct screen *scr[NUM_SCR];
+static int num_screens;
+
+static struct screen *cur, *prev, *next;
+static long trans_start, trans_dur;
+
+int scr_init(void)
+{
+ int i, idx = 0;
+
+ if(!(scr[idx++] = rtxonoff_screen())) {
+ return -1;
+ }
+ num_screens = idx;
+
+ assert(num_screens <= NUM_SCR);
+
+ for(i=0; i<num_screens; i++) {
+ if(scr[i]->init() == -1) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+void scr_shutdown(void)
+{
+ int i;
+ for(i=0; i<num_screens; i++) {
+ scr[i]->shutdown();
+ }
+}
+
+void scr_update(void)
+{
+ if(prev) { /* we're in the middle of a transition */
+ long interval = time_msec - trans_start;
+ if(interval >= trans_dur) {
+ if(next->start) {
+ next->start(trans_dur);
+ }
+ prev = 0;
+ cur = next;
+ next = 0;
+ }
+ }
+}
+
+void scr_draw(void)
+{
+ if(cur) cur->draw();
+}
+
+void scr_keypress(int key)
+{
+ if(cur && cur->keypress) {
+ cur->keypress(key);
+ }
+}
+
+struct screen *scr_lookup(const char *name)
+{
+ int i;
+ for(i=0; i<num_screens; i++) {
+ if(strcmp(scr[i]->name, name) == 0) {
+ return scr[i];
+ }
+ }
+ return 0;
+}
+
+struct screen *scr_screen(int idx)
+{
+ return scr[idx];
+}
+
+int scr_num_screens(void)
+{
+ return num_screens;
+}
+
+int scr_change(struct screen *s, long trans_time)
+{
+ if(!s) return -1;
+ if(s == cur) return 0;
+
+ if(trans_time) {
+ trans_dur = trans_time / 2; /* half for each part transition out then in */
+ trans_start = time_msec;
+ } else {
+ trans_dur = 0;
+ }
+
+ if(cur && cur->stop) {
+ cur->stop(trans_dur);
+ prev = cur;
+ next = s;
+ } else {
+ if(s->start) {
+ s->start(trans_dur);
+ }
+
+ cur = s;
+ prev = 0;
+ }
+ return 0;
+}
--- /dev/null
+#ifndef SCREEN_H_
+#define SCREEN_H_
+
+struct screen {
+ char *name;
+
+ int (*init)(void);
+ void (*shutdown)(void);
+
+ void (*start)(long trans_time);
+ void (*stop)(long trans_time);
+
+ void (*draw)(void);
+
+ void (*keypress)(int key);
+};
+
+int scr_init(void);
+void scr_shutdown(void);
+
+void scr_update(void);
+void scr_draw(void);
+void scr_keypress(int key);
+
+struct screen *scr_lookup(const char *name);
+struct screen *scr_screen(int idx);
+int scr_num_screens(void);
+int scr_change(struct screen *s, long trans_time);
+
+#endif /* SCREEN_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <SDL/SDL.h>
+#include "demo.h"
+#include "tinyfps.h"
+#include "timer.h"
+#include "cfgopt.h"
+
+static void handle_event(SDL_Event *ev);
+static void toggle_fullscreen(void);
+
+static int quit;
+static SDL_Surface *fbsurf;
+
+static int fbscale = 2;
+static int xsz, ysz;
+static unsigned int sdl_flags = SDL_SWSURFACE;
+
+int main(int argc, char **argv)
+{
+ int s, i, j;
+ char *env;
+ unsigned short *sptr, *dptr;
+
+ if((env = getenv("FBSCALE")) && (s = atoi(env))) {
+ fbscale = s;
+ printf("Framebuffer scaling x%d\n", fbscale);
+ }
+
+ xsz = fb_width * fbscale;
+ ysz = fb_height * fbscale;
+
+ /* allocate 1 extra row as a guard band, until we fucking fix the rasterizer */
+ if(!(fb_pixels = malloc(fb_width * (fb_height + 1) * fb_bpp / CHAR_BIT))) {
+ fprintf(stderr, "failed to allocate virtual framebuffer\n");
+ return 1;
+ }
+ vmem_front = vmem_back = fb_pixels;
+
+ SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
+ if(!(fbsurf = SDL_SetVideoMode(xsz, ysz, fb_bpp, sdl_flags))) {
+ fprintf(stderr, "failed to set video mode %dx%d %dbpp\n", fb_width, fb_height, fb_bpp);
+ free(fb_pixels);
+ SDL_Quit();
+ return 1;
+ }
+ SDL_WM_SetCaption("dosdemo/SDL", 0);
+
+ time_msec = 0;
+ if(demo_init(argc, argv) == -1) {
+ free(fb_pixels);
+ SDL_Quit();
+ return 1;
+ }
+ reset_timer();
+
+ while(!quit) {
+ SDL_Event ev;
+ while(SDL_PollEvent(&ev)) {
+ handle_event(&ev);
+ if(quit) goto break_evloop;
+ }
+
+ time_msec = get_msec();
+ demo_draw();
+ drawFps(fb_pixels);
+
+ if(SDL_MUSTLOCK(fbsurf)) {
+ SDL_LockSurface(fbsurf);
+ }
+
+ sptr = fb_pixels;
+ dptr = (unsigned short*)fbsurf->pixels + (fbsurf->w - xsz) / 2;
+ for(i=0; i<fb_height; i++) {
+ for(j=0; j<fb_width; j++) {
+ int x, y;
+ unsigned short pixel = *sptr++;
+
+ for(y=0; y<fbscale; y++) {
+ for(x=0; x<fbscale; x++) {
+ dptr[y * fbsurf->w + x] = pixel;
+ }
+ }
+ dptr += fbscale;
+ }
+ dptr += (fbsurf->w - fb_width) * fbscale;
+ }
+
+ if(SDL_MUSTLOCK(fbsurf)) {
+ SDL_UnlockSurface(fbsurf);
+ }
+ SDL_Flip(fbsurf);
+ }
+
+break_evloop:
+ demo_cleanup();
+ SDL_Quit();
+ return 0;
+}
+
+void demo_quit(void)
+{
+ quit = 1;
+}
+
+void wait_vsync(void)
+{
+ unsigned long start = SDL_GetTicks();
+ unsigned long until = (start | 0xf) + 1;
+ while(SDL_GetTicks() <= until);
+}
+
+void swap_buffers(void *pixels)
+{
+ /* do nothing, all pointers point to the same buffer */
+ if(opt.vsync) {
+ wait_vsync();
+ }
+}
+
+static void handle_event(SDL_Event *ev)
+{
+ switch(ev->type) {
+ case SDL_QUIT:
+ quit = 1;
+ break;
+
+ case SDL_KEYDOWN:
+ case SDL_KEYUP:
+ if(ev->key.keysym.sym == SDLK_RETURN && (SDL_GetModState() & KMOD_ALT) &&
+ ev->key.state == SDL_PRESSED) {
+ toggle_fullscreen();
+ break;
+ }
+ demo_keyboard(ev->key.keysym.sym, ev->key.state == SDL_PRESSED ? 1 : 0);
+ break;
+
+ case SDL_MOUSEMOTION:
+ mouse_x = ev->motion.x / fbscale;
+ mouse_y = ev->motion.y / fbscale;
+ break;
+
+ case SDL_MOUSEBUTTONDOWN:
+ mouse_bmask |= 1 << (ev->button.button - SDL_BUTTON_LEFT);
+ if(0) {
+ case SDL_MOUSEBUTTONUP:
+ mouse_bmask &= ~(1 << (ev->button.button - SDL_BUTTON_LEFT));
+ }
+ mouse_x = ev->button.x / fbscale;
+ mouse_y = ev->button.y / fbscale;
+ break;
+
+ default:
+ break;
+ }
+}
+
+static void toggle_fullscreen(void)
+{
+ SDL_Surface *newsurf;
+ unsigned int newflags = sdl_flags ^ SDL_FULLSCREEN;
+
+ if(!(newsurf = SDL_SetVideoMode(xsz, ysz, fb_bpp, newflags))) {
+ fprintf(stderr, "failed to go %s\n", newflags & SDL_FULLSCREEN ? "fullscreen" : "windowed");
+ return;
+ }
+
+ fbsurf = newsurf;
+ sdl_flags = newflags;
+}
--- /dev/null
+#include <SDL/SDL.h>
+#include "timer.h"
+
+static unsigned long start_time;
+
+void init_timer(int res_hz)
+{
+}
+
+void reset_timer(void)
+{
+ start_time = SDL_GetTicks();
+}
+
+unsigned long get_msec(void)
+{
+ return SDL_GetTicks() - start_time;
+}
--- /dev/null
+#ifndef TIMER_H_
+#define TIMER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* expects the required timer resolution in hertz
+ * if res_hz is 0, the current resolution is retained
+ */
+void init_timer(int res_hz);
+
+void reset_timer(void);
+unsigned long get_msec(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TIMER_H_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "tinyfps.h"
+#include "demo.h"
+
+// TinyFPS, just a minimal fraps like font to show FPS during the demo and not just after.
+// I'll be using it in my effects for my performance test purposes, just adding it here.
+// Maybe it would be nice if initFpsFonts would be called in demo.c once but I avoided touching that code.
+
+/*
+1110 0010 1110 1110 1010 1110 1110 1110 1110 1110
+1010 0010 0010 0010 1010 1000 1000 0010 1010 1010
+1010 0010 1110 0110 1110 1110 1110 0010 1110 1110
+1010 0010 1000 0010 0010 0010 1010 0010 1010 0010
+1110 0010 1110 1110 0010 1110 1110 0010 1110 1110
+*/
+
+static const unsigned char miniDecimalData[] = { 0xE2, 0xEE, 0xAE, 0xEE, 0xEE,
+0xA2, 0x22, 0xA8, 0x82, 0xAA,
+0xA2, 0xE6, 0xEE, 0xE2, 0xEE,
+0xA2, 0x82, 0x22, 0xA2, 0xA2,
+0xE2, 0xEE, 0x2E, 0xE2, 0xEE };
+
+static unsigned short miniDecimalFonts[FPS_FONT_NUM_PIXELS];
+
+static unsigned long startingFpsTime = 0;
+static int fpsFontsInit = 0;
+static int nFrames = 0;
+
+void initFpsFonts()
+{
+ if (fpsFontsInit == 0)
+ {
+ unsigned char miniDecimalPixels[FPS_FONT_NUM_PIXELS];
+ int i, j, k = 0;
+ int x, y, n;
+
+ for (i = 0; i < FPS_FONT_NUM_PIXELS / 8; i++)
+ {
+ unsigned char d = miniDecimalData[i];
+ for (j = 0; j < 8; j++)
+ {
+ unsigned char c = (d & 0x80) >> 7;
+ miniDecimalPixels[k++] = c;
+ d <<= 1;
+ }
+ }
+
+ i = 0;
+ for (n = 0; n < FPS_FONTS_NUM; n++)
+ {
+ for (y = 0; y < FPS_FONT_HEIGHT; y++)
+ {
+ for (x = 0; x < FPS_FONT_WIDTH; x++)
+ {
+ miniDecimalFonts[i++] = miniDecimalPixels[n * FPS_FONT_WIDTH + x + y * FPS_FONT_WIDTH * FPS_FONTS_NUM] * 0xFFFF;
+ }
+ }
+ }
+
+ fpsFontsInit = 1;
+ }
+}
+
+static void drawFont(unsigned char decimal, int posX, int posY, unsigned char zoom, unsigned short *vram)
+{
+ int x, y, j, k;
+ unsigned short c;
+
+ unsigned short *fontData = (unsigned short*)&miniDecimalFonts[decimal * FPS_FONT_WIDTH * FPS_FONT_HEIGHT];
+
+ vram += posY * fb_width + posX;
+
+ if (zoom < 1) zoom = 1;
+ if (zoom > 4) zoom = 4;
+
+ for (y = 0; y<FPS_FONT_HEIGHT; y++)
+ {
+ for (x = 0; x<FPS_FONT_WIDTH; x++)
+ {
+ c = *fontData++;
+
+ if (c!=0)
+ {
+ for (j=0; j<zoom; j++)
+ {
+ for (k=0; k<zoom; k++)
+ {
+ *(vram + j * fb_width + k) ^= c;
+ }
+ }
+ }
+ vram += zoom;
+ }
+ vram += (-FPS_FONT_WIDTH * zoom + fb_width * zoom);
+ }
+}
+
+static void drawDecimal(unsigned int number, int posX, int posY, unsigned char zoom, unsigned short *vram)
+{
+ int i = 0;
+ char buffer[8];
+
+ sprintf(buffer, "%d", number);
+
+ while(i < 8 && buffer[i] != 0)
+ {
+ drawFont(buffer[i] - 48, posX + i * zoom * FPS_FONT_WIDTH, posY, zoom, vram);
+ i++;
+ }
+}
+
+void drawFps(unsigned short *vram)
+{
+ unsigned long dt = time_msec - startingFpsTime;
+ static int fps = 0;
+
+ nFrames++;
+ if (dt >= 1000)
+ {
+ fps = (nFrames * 1000) / dt;
+ startingFpsTime = time_msec;
+ nFrames = 0;
+ }
+ //drawDecimal(fps, 4, 4, 2, vram);
+ // Moving this on the lower left side of screen for now, since the lack of double buffering generates flickering for this atm
+ drawDecimal(fps, 4, fb_height - 12, 2, vram);
+}
--- /dev/null
+#ifndef TINY_FPS_H
+#define TINY_FPS_H
+
+#define FPS_FONT_WIDTH 4
+#define FPS_FONT_HEIGHT 5
+#define FPS_FONTS_NUM 10
+#define FPS_FONT_NUM_PIXELS (FPS_FONTS_NUM * FPS_FONT_WIDTH * FPS_FONT_HEIGHT)
+
+void initFpsFonts();
+void drawFps(unsigned short *vram);
+
+#endif
--- /dev/null
+#include "util.h"
+
+uint32_t perf_start_count, perf_interval_count;
--- /dev/null
+#ifndef UTIL_H_
+#define UTIL_H_
+
+#include "inttypes.h"
+
+#ifdef __GNUC__
+#define INLINE __inline
+
+#elif defined(__WATCOMC__)
+#define INLINE __inline
+
+#else
+#define INLINE
+#endif
+
+/* fast conversion of double -> 32bit int
+ * for details see:
+ * - http://chrishecker.com/images/f/fb/Gdmfp.pdf
+ * - http://stereopsis.com/FPU.html#convert
+ */
+static INLINE int32_t cround64(double val)
+{
+ val += 6755399441055744.0;
+ return *(int32_t*)&val;
+}
+
+extern uint32_t perf_start_count, perf_interval_count;
+
+#ifdef __WATCOMC__
+void perf_start(void);
+#pragma aux perf_start = \
+ "xor eax, eax" \
+ "cpuid" \
+ "rdtsc" \
+ "mov [perf_start_count], eax" \
+ modify[eax ebx ecx edx];
+
+void perf_end(void);
+#pragma aux perf_end = \
+ "xor eax, eax" \
+ "cpuid" \
+ "rdtsc" \
+ "sub eax, [perf_start_count]" \
+ "mov [perf_interval_count], eax" \
+ modify [eax ebx ecx edx];
+
+void debug_break(void);
+#pragma aux debug_break = "int 3";
+#endif
+
+#ifdef __GNUC__
+#define perf_start() asm volatile ( \
+ "xor %%eax, %%eax\n" \
+ "cpuid\n" \
+ "rdtsc\n" \
+ "mov %%eax, %0\n" \
+ : "=m"(perf_start_count) \
+ :: "%eax", "%ebx", "%ecx", "%edx")
+
+#define perf_end() asm volatile ( \
+ "xor %%eax, %%eax\n" \
+ "cpuid\n" \
+ "rdtsc\n" \
+ "sub %1, %%eax\n" \
+ "mov %%eax, %0\n" \
+ : "=m"(perf_interval_count) \
+ : "m"(perf_start_count) \
+ : "%eax", "%ebx", "%ecx", "%edx")
+
+#define debug_break() \
+ asm volatile ("int $3")
+#endif
+
+#ifdef _MSC_VER
+#define perf_start() \
+ do { \
+ __asm { \
+ xor eax, eax \
+ cpuid \
+ rdtsc \
+ mov [perf_start_count], eax \
+ } \
+ } while(0)
+
+#define perf_end() \
+ do { \
+ __asm { \
+ xor eax, eax \
+ cpuid \
+ rdtsc \
+ sub eax, [perf_start_count] \
+ mov [perf_interval_count], eax \
+ } \
+ } while(0)
+
+#define debug_break() \
+ do { \
+ __asm { int 3 } \
+ } while(0)
+#endif
+
+#endif /* UTIL_H_ */
--- /dev/null
+#ifndef VMATH_H_
+#define VMATH_H_
+
+#include <math.h>
+
+#ifdef __GNUC__
+#define INLINE __inline
+
+#elif defined(__WATCOMC__)
+#define INLINE __inline
+
+#else
+#define INLINE
+#endif
+
+typedef struct { float x, y; } vec2_t;
+typedef struct { float x, y, z; } vec3_t;
+typedef struct { float x, y, z, w; } vec4_t;
+
+typedef vec4_t quat_t;
+
+/* vector functions */
+static INLINE vec3_t v3_cons(float x, float y, float z)
+{
+ vec3_t res;
+ res.x = x;
+ res.y = y;
+ res.z = z;
+ return res;
+}
+
+static INLINE void v3_negate(vec3_t *v)
+{
+ v->x = -v->x;
+ v->y = -v->y;
+ v->z = -v->z;
+}
+
+static INLINE float v3_dot(vec3_t v1, vec3_t v2)
+{
+ return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+}
+
+static INLINE vec3_t v3_cross(vec3_t v1, vec3_t v2)
+{
+ vec3_t res;
+ res.x = v1.y * v2.z - v1.z * v2.y;
+ res.y = v1.z * v2.x - v1.x * v2.z;
+ res.z = v1.x * v2.y - v1.y * v2.x;
+ return res;
+}
+
+static INLINE void v3_normalize(vec3_t *v)
+{
+ float mag = sqrt(v->x * v->x + v->y * v->y + v->z * v->z);
+ if(mag != 0.0f) {
+ float s = 1.0f / mag;
+ v->x *= s;
+ v->y *= s;
+ v->z *= s;
+ }
+}
+
+/* quaternion functions */
+static INLINE quat_t quat_cons(float s, float x, float y, float z)
+{
+ quat_t q;
+ q.x = x;
+ q.y = y;
+ q.z = z;
+ q.w = s;
+ return q;
+}
+
+static INLINE vec3_t quat_vec(quat_t q)
+{
+ vec3_t v;
+ v.x = q.x;
+ v.y = q.y;
+ v.z = q.z;
+ return v;
+}
+
+static INLINE quat_t quat_mul(quat_t q1, quat_t q2)
+{
+ quat_t res;
+ vec3_t v1 = quat_vec(q1);
+ vec3_t v2 = quat_vec(q2);
+
+ res.w = q1.w * q2.w - v3_dot(v1, v2);
+ res.x = v2.x * q1.w + v1.x * q2.w + (v1.y * v2.z - v1.z * v2.y);
+ res.y = v2.y * q1.w + v1.y * q2.w + (v1.z * v2.x - v1.x * v2.z);
+ res.z = v2.z * q1.w + v1.z * q2.w + (v1.x * v2.y - v1.y * v2.x);
+ return res;
+}
+
+static INLINE void quat_to_mat(float *res, quat_t q)
+{
+ res[0] = 1.0f - 2.0f * q.y*q.y - 2.0f * q.z*q.z;
+ res[1] = 2.0f * q.x * q.y - 2.0f * q.w * q.z;
+ res[2] = 2.0f * q.z * q.x + 2.0f * q.w * q.y;
+ res[3] = 0.0f;
+ res[4] = 2.0f * q.x * q.y + 2.0f * q.w * q.z;
+ res[5] = 1.0f - 2.0f * q.x*q.x - 2.0f * q.z*q.z;
+ res[6] = 2.0f * q.y * q.z - 2.0f * q.w * q.x;
+ res[7] = 0.0f;
+ res[8] = 2.0f * q.z * q.x - 2.0f * q.w * q.y;
+ res[9] = 2.0f * q.y * q.z + 2.0f * q.w * q.x;
+ res[10] = 1.0f - 2.0f * q.x*q.x - 2.0f * q.y*q.y;
+ res[11] = 0.0f;
+ res[12] = res[13] = res[14] = 0.0f;
+ res[15] = 1.0f;
+}
+
+static INLINE quat_t quat_rotate(quat_t q, float angle, float x, float y, float z)
+{
+ quat_t rq;
+ float half_angle = angle * 0.5;
+ float sin_half = sin(half_angle);
+
+ rq.w = cos(half_angle);
+ rq.x = x * sin_half;
+ rq.y = y * sin_half;
+ rq.z = z * sin_half;
+
+ return quat_mul(q, rq);
+}
+
+static INLINE void mat4_transpose(float *mat)
+{
+ int i, j;
+
+ for(i=0; i<4; i++) {
+ for(j=0; j<i; j++) {
+ int rowidx = i * 4 + j;
+ int colidx = j * 4 + i;
+ float tmp = mat[rowidx];
+ mat[rowidx] = mat[colidx];
+ mat[colidx] = tmp;
+ }
+ }
+}
+
+#endif /* VMATH_H_ */