diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..342ff35 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,15 @@ +root = true + +[*] +end_of_line = lf +insert_final_newline = true + +# Matches multiple files with brace expansion notation +[*.{c,h,ch}] +charset = utf-8 +indent_style = tab +indent_size = 3 +trim_trailing_whitespace = false + +[*.md] +trim_trailing_whitespace = false diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0b3a0ae --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +bin/ +o/ +test/ +z64decompress diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + 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. + + + Copyright (C) + + 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 . + +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: + + Copyright (C) + 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 +. + + 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 +. diff --git a/debug-linux.sh b/debug-linux.sh new file mode 100755 index 0000000..de37a9b --- /dev/null +++ b/debug-linux.sh @@ -0,0 +1,8 @@ +# build decoder functions +gcc -Og -g -lm -c -Wall -Wextra src/decoder/*.c +mkdir -p o +mv *.o o + +# build everything else +gcc -o z64decompress src/*.c o/*.o -Wall -Wextra -Og -g + diff --git a/release-linux.sh b/release-linux.sh new file mode 100755 index 0000000..7f54358 --- /dev/null +++ b/release-linux.sh @@ -0,0 +1,14 @@ +# build decoder functions +gcc -DNDEBUG -s -Ofast -flto -lm -c -Wall -Wextra src/decoder/*.c +mkdir -p o +mv *.o o + +# build everything else +gcc -o z64decompress -DNDEBUG src/*.c o/*.o -Wall -Wextra -s -Os -flto + +# move to bin directory +mkdir -p bin/linux64 +mv z64decompress bin/linux64 + + + diff --git a/release-linux32.sh b/release-linux32.sh new file mode 100755 index 0000000..9791d58 --- /dev/null +++ b/release-linux32.sh @@ -0,0 +1,14 @@ +# build decoder functions +gcc -m32 -DNDEBUG -s -Ofast -flto -lm -c -Wall src/decoder/*.c +mkdir -p o +mv *.o o + +# build everything else +gcc -m32 -o z64decompress -DNDEBUG src/*.c o/*.o -Wall -Wextra -s -Os -flto + +# move to bin directory +mkdir -p bin/linux32 +mv z64decompress bin/linux32 + + + diff --git a/release-win32.sh b/release-win32.sh new file mode 100755 index 0000000..763b7ae --- /dev/null +++ b/release-win32.sh @@ -0,0 +1,12 @@ +# build decoder functions +~/c/mxe/usr/bin/i686-w64-mingw32.static-gcc -DNDEBUG -s -Ofast -flto -lm -c -Wall src/decoder/*.c +mkdir -p o +mv *.o o + +# build everything else +~/c/mxe/usr/bin/i686-w64-mingw32.static-gcc -o z64decompress.exe -DNDEBUG src/*.c o/*.o -Wall -Wextra -s -Os -flto -mconsole -municode + +# move to bin directory +mkdir -p bin/win32 +mv z64decompress.exe bin/win32 + diff --git a/src/decoder/README b/src/decoder/README new file mode 100644 index 0000000..b887c4e --- /dev/null +++ b/src/decoder/README @@ -0,0 +1,4 @@ +these decoder functions were adapted from those in my z64enc repo + +https://github.com/z64me/z64enc + diff --git a/src/decoder/aplib.c b/src/decoder/aplib.c new file mode 100644 index 0000000..5160a84 --- /dev/null +++ b/src/decoder/aplib.c @@ -0,0 +1,229 @@ +/* adapted from aPLib's depack.c */ + +/* + * aPLib compression library - the smaller the better :) + * + * C depacker + * + * Copyright (c) 1998-2014 Joergen Ibsen + * All Rights Reserved + * + * http://www.ibsensoftware.com/ + */ + +#include "private.h" + +struct decoder +{ + unsigned char buf[1024]; /* intermediate buffer for loading */ + unsigned char *buf_end; /* pointer that exists for the sole * + * purpose of getting size of `buf` */ + unsigned char *pstart; /* offset of next read from rom */ + unsigned int remaining; /* remaining size of file */ + unsigned char *buf_limit; /* points to end of scannable area * + * of buf; this prevents yaz parser * + * from overflowing */ +#if MAJORA + unsigned char *dst_end; /* end of decompressed block */ +#endif +}; + +/* internal data structure */ +struct APDSTATE { + unsigned char *source; + unsigned char *destination; + unsigned int tag; + unsigned int bitcount; +}; + +static struct decoder dec; + +static void *refill(unsigned char *ip) +{ + unsigned offset; + unsigned size; + + /* intermediate buffer is not yet due for a refill */ + if (ip < dec.buf_end - 8) + return ip; + + /* the number 8 is used throughout to ensure * + * dma transfers are always 8 byte aligned */ + offset = dec.buf_end - ip; + size = sizeof(dec.buf) - 8; + + /* the last eight bytes wrap around */ + Bcopy(dec.buf_end - 8, dec.buf, 8); + + /* transfer data from rom */ + DMARomToRam(dec.pstart, dec.buf + 8, size); + dec.pstart += size; + + return dec.buf + (8 - offset); +} + +static unsigned int aP_getbit(struct APDSTATE *ud) +{ + unsigned int bit; + + /* check if tag is empty */ + if (!ud->bitcount--) { + /* load next tag */ + ud->tag = *ud->source++; + ud->bitcount = 7; + } + + /* shift bit out of tag */ + bit = (ud->tag >> 7) & 0x01; + ud->tag <<= 1; + + return bit; +} + +static unsigned int aP_getgamma(struct APDSTATE *ud) +{ + unsigned int result = 1; + + /* input gamma2-encoded bits */ + do { + result = (result << 1) + aP_getbit(ud); + } while (aP_getbit(ud)); + + return result; +} + +static inline void *aP_depack(void *source, unsigned char *destination) +{ + struct APDSTATE ud; + unsigned int offs, len, R0, LWM; + int done; + int i; + + ud.source = source; + ud.bitcount = 0; + + R0 = (unsigned int) -1; + LWM = 0; + done = 0; + + /* initial buffer fill */ + ud.source = refill(ud.source); + + /* skip header */ + ud.source += 8; + + /* first byte verbatim */ + *destination++ = *ud.source++; + + /* main decompression loop */ + while (!done) { + ud.source = refill(ud.source); + if (aP_getbit(&ud)) { + if (aP_getbit(&ud)) { + if (aP_getbit(&ud)) { + offs = 0; + + for (i = 4; i; i--) { + offs = (offs << 1) + aP_getbit(&ud); + } + + if (offs) { + *destination = *(destination - offs); + destination++; + } + else { + *destination++ = 0x00; + } + + LWM = 0; + } + else { + offs = *ud.source++; + + len = 2 + (offs & 0x0001); + + offs >>= 1; + + if (offs) { + for (; len; len--) { + *destination = *(destination - offs); + destination++; + } + } + else { + done = 1; + } + + R0 = offs; + LWM = 1; + } + } + else { + offs = aP_getgamma(&ud); + + if ((LWM == 0) && (offs == 2)) { + offs = R0; + + len = aP_getgamma(&ud); + + for (; len; len--) { + *destination = *(destination - offs); + destination++; + } + } + else { + if (LWM == 0) { + offs -= 3; + } + else { + offs -= 2; + } + + offs <<= 8; + offs += *ud.source++; + + len = aP_getgamma(&ud); + + if (offs >= 32000) { + len++; + } + if (offs >= 1280) { + len++; + } + if (offs < 128) { + len += 2; + } + + for (; len; len--) { + *destination = *(destination - offs); + destination++; + } + + R0 = offs; + } + + LWM = 1; + } + } + else { + *destination++ = *ud.source++; + LWM = 0; + } + } + + return destination; +} + +/* main driver */ +void apldec(void *src, void *dst, unsigned sz) +{ + dec.pstart = src; + dec.buf_end = dec.buf + sizeof(dec.buf); + dst = aP_depack(dec.buf_end, dst); + (void)sz; /* unused parameter */ +#if MAJORA + dec.dst_end = dst; + dec.buf_end = 0; +#endif +} + diff --git a/src/decoder/decoder.h b/src/decoder/decoder.h new file mode 100644 index 0000000..c34d772 --- /dev/null +++ b/src/decoder/decoder.h @@ -0,0 +1,10 @@ +#ifndef Z64DECOMPRESS_DECODER_H_INCLUDED +#define Z64DECOMPRESS_DECODER_H_INCLUDED + +void yazdec(void *src, void *dst, unsigned sz); +void lzodec(void *src, void *dst, unsigned sz); +void ucldec(void *src, void *dst, unsigned sz); +void apldec(void *src, void *dst, unsigned sz); + +#endif /* Z64DECOMPRESS_DECODER_H_INCLUDED */ + diff --git a/src/decoder/lzo.c b/src/decoder/lzo.c new file mode 100644 index 0000000..4a00c9e --- /dev/null +++ b/src/decoder/lzo.c @@ -0,0 +1,228 @@ +/* adapted from lzo1x_d.ch */ + +#include "private.h" + +/* negative indexing distance */ +#define NINDEX 2 + +/* lzo max negative offset */ +#define M2_MAX_OFFSET 0x0800 + +struct decoder +{ + unsigned char buf[1024]; /* intermediate buffer for loading */ + unsigned char *buf_end; /* pointer that exists for the sole * + * purpose of getting size of `buf` */ + unsigned char *pstart; /* offset of next read from rom */ + unsigned int remaining; /* remaining size of file */ + unsigned char *buf_limit; /* points to end of scannable area * + * of buf; this prevents yaz parser * + * from overflowing */ +#if MAJORA + unsigned char *dst_end; /* end of decompressed block */ +#endif +}; + +static struct decoder dec; + +/* block copy, with desired overlapping behavior */ +static void *ocopy(void *_src, void *_dst, unsigned n) +{ + unsigned char *src = _src; + unsigned char *dst = _dst; + + do *dst++ = *src++; while (--n); + + return dst; +} + +/* refill intermediate buffer if necessary */ +static unsigned char *refill(unsigned char *ip) +{ + unsigned offset; + unsigned size; + int align; + + /* intermediate buffer is not yet due for a refill */ + if (ip < dec.buf_end - 32) + return ip; + + ip -= NINDEX; + + /* the weird alignment stuff ensures dma * + * transfers are always 8 byte aligned */ + offset = dec.buf_end - ip; + align = 8 - (offset & 7); + offset += align; + size = sizeof(dec.buf) - offset; + + /* the last bytes wrap around */ + ocopy(dec.buf_end - offset, dec.buf, offset); + ip = dec.buf + align + NINDEX; + + /* transfer data from rom */ + DMARomToRam(dec.pstart, dec.buf + offset, size); + dec.pstart += size; + + return ip; +} + + +/* main driver */ +void lzodec(void *_src, void *_dst, unsigned sz) +{ + unsigned char *pstart = _src; + unsigned char *op = _dst; + unsigned char *m_pos; + unsigned char *ip; + int t; + (void)sz; /* unused parameter */ + + dec.pstart = pstart; + dec.buf_end = dec.buf + sizeof(dec.buf); + ip = dec.buf_end; + + /* initial buffer fill */ + ip = refill(ip); + + /* skip header */ + ip += 8; + + if (*ip > 17) + { + t = *ip++ - 17; + if (t < 4) + goto match_next; + op = ocopy(ip, op, t); + ip += t; + goto first_literal_run; + } + + for (;;) + { + t = *ip++; + if (t >= 16) + goto match; + /* a literal run */ + if (t == 0) + { + while (*ip == 0) + { + t += 255; + ip++; + } + t += 15 + *ip++; + } + /* copy literals */ + { + t += 3; + /* this loop can advance any number of bytes (4k+) */ + do + { + /* ensure buffer contains data */ + ip = refill(ip); + + *op++ = *ip++; + } while (--t); + } + +first_literal_run: + t = *ip++; + if (t >= 16) + goto match; + m_pos = op - (1 + M2_MAX_OFFSET); + m_pos -= t >> 2; + m_pos -= ip[0] << 2; + ip++; + + op = ocopy(m_pos, op, 3); + goto match_done; + + /* handle matches */ + for (;;) { +match: + m_pos = op - 1; + + if (t >= 64) /* M2 match */ + { + m_pos -= (t >> 2) & 7; + m_pos -= ip[0] << 3; + ip++; + t = (t >> 5) - 1; + } + else if (t >= 32) /* M3 match */ + { + t &= 31; + + /* this never advances more than 8 bytes */ + if (t == 0) + { + while (*ip == 0) + { + t += 255; + ip++; + } + t += 31 + *ip++; + } + m_pos -= (ip[0] >> 2) + (ip[1] << 6); + ip += 2; + } + else if (t >= 16) /* a M4 match */ + { + m_pos++; + m_pos -= (t & 8) << 11; + t &= 7; + + /* this never advances more than 8 bytes */ + if (t == 0) + { + while (*ip == 0) + { + t += 255; + ip++; + } + t += 7 + *ip++; + } + m_pos -= (ip[0] >> 2) + (ip[1] << 6); + /* end of compressed file */ + if (m_pos == op) + goto L_done; + m_pos -= 0x4000; + ip += 2; + } + else /* a M1 match */ + { + m_pos -= t >> 2; + m_pos -= ip[0] << 2; + ip += 1; + op = ocopy(m_pos, op, 2); + goto match_done; + } + + /* copy match */ + t += 2; + op = ocopy(m_pos, op, t); + + +match_done: + /* ensure buffer contains data */ + ip = refill(ip); + t = ip[-NINDEX] & 3; + if (t == 0) + break; + + /* copy literals */ + /* this never advances more than 4 bytes */ +match_next: + op = ocopy(ip, op, t); + ip += t; + t = *ip++; + } + } +L_done: do{}while(0); +#if MAJORA + dec.dst_end = op; + dec.buf_end = 0; +#endif +} + diff --git a/src/decoder/private.h b/src/decoder/private.h new file mode 100644 index 0000000..c359158 --- /dev/null +++ b/src/decoder/private.h @@ -0,0 +1,15 @@ +#ifndef Z64DECOMPRESS_DECODER_PRIVATE_H_INCLUDED +#define Z64DECOMPRESS_DECODER_PRIVATE_H_INCLUDED + +#include /* memcpy */ + +#define Bcopy(SRC, DST, LEN) memcpy(DST, SRC, LEN) +#define DMARomToRam(SRC, DST, LEN) memcpy(DST, SRC, LEN) + +/* XXX casting like *(unsigned int*) is used in n64 code but + * that assumes a big-endian build target; adapt to BE32() + */ +#define BE32(X) ( ((X)[0]<<24) | ((X)[1]<<16) | ((X)[2]<<8) | (X)[3] ) + +#endif /* Z64DECOMPRESS_DECODER_PRIVATE_H_INCLUDED */ + diff --git a/src/decoder/ucl.c b/src/decoder/ucl.c new file mode 100644 index 0000000..537e5fe --- /dev/null +++ b/src/decoder/ucl.c @@ -0,0 +1,194 @@ +/* ucl decompression using intermediate buffer */ + +#include "private.h" + +struct decoder +{ + unsigned char buf[1024]; /* intermediate buffer for loading */ + unsigned int bb; /* ucl: bit buffer */ + unsigned char *pstart; /* offset of next read from rom */ + unsigned int remaining; /* compressed bytes not yet read */ + unsigned int ilen; /* ucl: bytes processed in `buf` */ +#if MAJORA + unsigned char *dst_end; /* end of decompressed block */ +#endif +}; + +static struct decoder dec; + +/* these are used often, so shorten their names with a macro */ +#define ilen dec.ilen +#define bb dec.bb + +/* get next bit in bit buffer */ +#define getbit(bb) getbit_dma() + +/* unsafe, inline version of above, for speed */ +#define getbit_unsafe(bb) \ + (((bb = bb & 0x7f \ + ? (unsigned)(bb*2) \ + : (unsigned)(dec.buf[ilen++]*2+1) \ + ) >> 8) & 1) + +/* function version of above, for saving bytes in final binary */ +#define getbit_unsafe_F(bb) getbit_dma_unsafe() + +/* refill intermediate buffer if needed, and return new bit buffer */ +static inline unsigned int refill(void) +{ + /* if we have exceeded the intermediate buffer, refill it */ + if (ilen >= sizeof(dec.buf) - 32) + { + unsigned size = sizeof(dec.buf); + int offset = sizeof(dec.buf) - ilen; + int Nilen; + + /* bcopy src and dst must be aligned */ + Nilen = 8 - (offset & 7); + Nilen &= 7; + + /* the last block wraps around */ + if (offset) + { + size -= offset + Nilen; + Bcopy(dec.buf + ilen, dec.buf + Nilen, offset); + } + ilen = Nilen; + + /* if it exceeds remaining file size, use that */ + if (dec.remaining < size) + size = dec.remaining; + + /* read file from rom */ + if (size != 0) + { + DMARomToRam(dec.pstart, dec.buf + offset + Nilen, size); + + dec.pstart += size; + dec.remaining -= size; + } + } + + return dec.buf[(ilen)++]; +} + +/* get next bit in bit buffer */ +static int getbit_dma(void) +{ + if (bb & 0x7f) + { + bb *= 2; + /* NOTE return is faster than goto, but costs 8 bytes */ + return (bb >> 8) & 1; +// goto early; + } + + bb = refill() * 2 + 1; +//early: + return (bb >> 8) & 1; +} + +/* unsafe version of above, for speed */ +static int (getbit_dma_unsafe)(void) +{ + if (bb & 0x7f) + { + bb *= 2; + /* NOTE return is faster than goto, but costs 8 bytes */ + return (bb >> 8) & 1; +// goto early; + } + + bb = dec.buf[(ilen)++] * 2 + 1; +//early: + return (bb >> 8) & 1; +} + +/* adapted from ucl/n2b_d.c */ +void ucldec(void *_src, void *_dst, unsigned sz) +{ + unsigned char *pstart = _src; + unsigned char *dst = _dst; + int last_m_off = 1; + + /* skip the 8-byte header */ + pstart += 8; + sz -= 8; + + /* initialize decoder structure */ + dec.pstart = pstart; + dec.remaining = sz; + bb = 0; + ilen = sizeof(dec.buf); + + for (;;) + { + int m_off; + int m_len; + + while (getbit(bb)) + *dst++ = dec.buf[ilen++]; + + m_off = 1; + do { + m_off = m_off*2 + getbit(bb); + } while (!getbit(bb)); + if (m_off == 2) + m_off = last_m_off; + else + { + m_off = (m_off-3)*256 + dec.buf[ilen++]; + if (m_off == -1) + break; + last_m_off = ++m_off; + } + + m_len = getbit_unsafe(bb); + m_len = m_len*2 + getbit_unsafe_F(bb); + if (m_len == 0) + { + m_len++; + do { + m_len = m_len*2 + getbit_unsafe_F(bb); + } while (!getbit_unsafe_F(bb)); + m_len += 2; + } + m_len += (m_off > 0xd00); + { + unsigned char *m_pos; + m_pos = dst - m_off; + m_len += 1; + +#if 0 + do *dst++ = *m_pos++; while (--m_len); +#else + /* NOTE the unrolled variant below is 10% faster on Wii VC */ + + /* get remaining bytes to a multiple of 4 */ + while (m_len & 3) + { + *dst++ = *m_pos++; + m_len -= 1; + } + + /* transfer remaining block four bytes at a time */ + while (m_len) + { + dst[0] = m_pos[0]; + dst[1] = m_pos[1]; + dst[2] = m_pos[2]; + dst[3] = m_pos[3]; + m_pos += 4; + m_len -= 4; + dst += 4; + } +#endif /* unrolled variant */ + } + } + +#if MAJORA + dec.dst_end = dst; + bb = 0; +#endif +} + diff --git a/src/decoder/yaz.c b/src/decoder/yaz.c new file mode 100644 index 0000000..7b3d04c --- /dev/null +++ b/src/decoder/yaz.c @@ -0,0 +1,199 @@ +/* yaz decompression using intermediate buffer */ + +#include "private.h" + +struct decoder +{ + unsigned char buf[1024]; /* intermediate buffer for loading */ + unsigned char *buf_end; /* pointer that exists for the sole * + * purpose of getting size of `buf` */ + unsigned char *pstart; /* offset of next read from rom */ + unsigned int remaining; /* remaining size of file */ + unsigned char *buf_limit; /* points to end of scannable area * + * of buf; this prevents yaz parser * + * from overflowing */ +#if MAJORA + unsigned char *dst_end; /* end of decompressed block */ +#endif +}; + +static struct decoder dec; + +/* initialize yaz */ +static inline unsigned char *init(void) +{ + unsigned int size; + + dec.buf_limit = dec.buf_end - 25; + + /* default size = decompression buffer size */ + size = dec.buf_end - dec.buf; + + /* if remaining file size is less than default, use that */ + if (dec.remaining < size) + size = dec.remaining; + + DMARomToRam(dec.pstart, dec.buf, size); + + /* advance pstart */ + dec.pstart += size; + + /* decrease remaining sz */ + dec.remaining -= size; + + return dec.buf; +} + +/* request more yaz data */ +static inline unsigned char *refill(unsigned char *src) +{ + unsigned int size; + unsigned int length; + unsigned char *dst; + + /* length = bytes remaining in buffer */ + length = dec.buf_end - src; + + /* bcopy src and dst must be aligned */ + if ((length & 7) == 0) + dst = dec.buf; + else + dst = (dec.buf + 8) - (length & 7); + + /* copy remainder of current buffer back to beginning */ + Bcopy(src, dst, length); + + /* calculate size for next read */ + size = (dec.buf_end - dst) - length; + + /* if it exceeds remaining file size, use that */ + if (dec.remaining < size) + size = dec.remaining; + + /* read file from rom */ + if (size != 0) + { + DMARomToRam(dec.pstart, dst + length, size); + + dec.pstart += size; + dec.remaining -= size; + + if (dec.remaining == 0) + dec.buf_limit = dst + length + size; + } + + return dst; +} + +/* decompress yaz data */ +/* yaz0dec by thakis was referenced for this */ +static inline void decompress(unsigned char *src, unsigned char *_dst) +{ + unsigned char *dst = _dst; + unsigned int currCodeByte; + unsigned int nmult; + int validBitCount = 0; + int uncomp_sz; + + /* get decompressed size from header */ + uncomp_sz = BE32(src + 4); + + /* skip header */ + src += 16; + + /* infinite loop */ + do + { + if (validBitCount == 0) + { + /* refill intermediate buffer if needed */ + if (dec.buf_limit < src && dec.remaining != 0) + src = refill(src); + + currCodeByte = *src; + validBitCount = 8; + src++; + } + + /* is not uncompressed */ + if (!(currCodeByte & 0x80)) + { + unsigned char byte1 = src[0]; + unsigned char byte2 = src[1]; + + unsigned int dist = ((byte1 & 0xF) << 8) | byte2; + unsigned char *copySrc = dst - (dist + 1); + + unsigned int numBytes = byte1 >> 4; + + src += 2; + + if (numBytes == 0) + { + numBytes = *src + 0x12; + src++; + } + else + numBytes += 2; + + /* NOTE: this is unrolled to maximize performance */ + + /* get remaining bytes to a multiple of 4 */ + nmult = numBytes - (numBytes & 3); + if (numBytes & 3) + { + do + { + *dst = *copySrc; + dst++; + copySrc++; + numBytes -= 1; + } while (numBytes != nmult); + + if (numBytes == 0) + goto L_skip; + } + + /* transfer remaining block four bytes at a time */ + do + { + dst[0] = copySrc[0]; + dst[1] = copySrc[1]; + dst[2] = copySrc[2]; + dst[3] = copySrc[3]; + numBytes -= 4; + copySrc += 4; + dst += 4; + } while (numBytes != 0); + } + + /* straight copy */ + else + *dst++ = *src++; + +L_skip: + validBitCount -= 1; + currCodeByte <<= 1; + } while (dst != _dst + uncomp_sz); + +#if MAJORA + dec.dst_end = dst; +#endif +} + +/* main driver */ +void yazdec(void *src, void *dst, unsigned sz) +{ + /* initialize decoder structure */ + dec.buf_end = dec.buf + sizeof(dec.buf); + dec.pstart = src; + dec.remaining = sz; + + /* decompress file */ + decompress(init(), dst); + +#if MAJORA + dec.buf_end = 0; +#endif +} + diff --git a/src/file.c b/src/file.c new file mode 100644 index 0000000..d5b830d --- /dev/null +++ b/src/file.c @@ -0,0 +1,98 @@ +#include + +#include "wow.h" +#undef fopen +#undef fread +#undef fwrite +#undef remove +#define fopen wow_fopen +#define fread wow_fread +#define fwrite wow_fwrite +#define remove wow_remove + +/* get size of a file; returns 0 if fopen fails */ +unsigned file_size(const char *fn) +{ + FILE *fp; + unsigned sz; + + fp = fopen(fn, "rb"); + if (!fp) + return 0; + + fseek(fp, 0, SEEK_END); + sz = ftell(fp); + fclose(fp); + + return sz; +} + +/* load a file into an existing buffer */ +void *file_load_into(const char *fn, unsigned *sz, void *dst) +{ + FILE *fp; + + assert(fn); + assert(sz); + assert(dst); + + *sz = 0; + + fp = fopen(fn, "rb"); + if (!fp) + die("failed to open '%s' for reading", fn); + + fseek(fp, 0, SEEK_END); + *sz = ftell(fp); + + if (!*sz) + die("size of file '%s' is zero", fn); + + fseek(fp, 0, SEEK_SET); + + if (fread(dst, 1, *sz, fp) != *sz) + die("failed to read contents of '%s'", fn); + + fclose(fp); + + return dst; +} + +/* load a file */ +void *file_load(const char *fn, unsigned *sz) +{ + unsigned char *dst; + + assert(fn); + assert(sz); + + *sz = file_size(fn); + if (!*sz) + die("failed to get size of file '%s'", fn); + + dst = malloc_safe(*sz); + + return file_load_into(fn, sz, dst); +} + +/* write file */ +unsigned file_write(const char *fn, void *data, unsigned data_sz) +{ + FILE *fp; + + assert(fn); + assert(data); + assert(data_sz); + + fp = fopen(fn, "wb"); + if (!fp) + die("failed to open '%s' for writing", fn); + + if (fwrite(data, 1, data_sz, fp) != data_sz) + die("failed to write contents of '%s'", fn); + + fclose(fp); + + return data_sz; +} + diff --git a/src/file.h b/src/file.h new file mode 100644 index 0000000..70d329f --- /dev/null +++ b/src/file.h @@ -0,0 +1,17 @@ +#ifndef Z64DECOMPRESS_FILE_H_INCLUDED +#define Z64DECOMPRESS_FILE_H_INCLUDED + +/* get size of a file; returns 0 if fopen fails */ +unsigned file_size(const char *fn); + +/* load a file into an existing buffer */ +void *file_load_into(const char *fn, unsigned *sz, void *dst); + +/* load a file */ +void *file_load(const char *fn, unsigned *sz); + +/* write file */ +unsigned file_write(const char *fn, void *data, unsigned data_sz); + +#endif /* Z64DECOMPRESS_FILE_H_INCLUDED */ + diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..b40d679 --- /dev/null +++ b/src/main.c @@ -0,0 +1,269 @@ +/* + * z64decompress + * + * simple z64 ocarina/majora rom decompressor + * + */ + +#include +#include +#include +#include + +#include "decoder/decoder.h" +#include "n64crc.h" +#include "file.h" +#include "wow.h" + +#define STRIDE 16 /* bytes per dmadata entry */ +#define IDX 2 /* dmadata references itself at table[IDX] */ +#define STR32(X) (unsigned)((X[0]<<24)|(X[1]<<16)|(X[2]<<8)|X[3]) +#define DMA_DELETED 0xffffffff /* aka UINT32_MAX */ + +/* big-endian bytes to u32 */ +static inline unsigned beU32(void *bytes) +{ + unsigned char *b = bytes; + return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]; +} + +/* write u32 as big-endian bytes */ +static inline void wbeU32(void *bytes, unsigned v) +{ + unsigned char *b = bytes; + b[0] = v >> 24; + b[1] = v >> 16; + b[2] = v >> 8; + b[3] = v; +} + +/* decompress a file (returns non-zero if unknown codec) */ +static inline int decompress(void *dst, void *src, int sz) +{ + unsigned codec; + + assert(src); + assert(dst); + assert(sz); + + codec = beU32(src); + if (codec == STR32("Yaz0")) + yazdec(src, dst, sz); + else if (codec == STR32("LZO0")) + lzodec(src, dst, sz); + else if (codec == STR32("UCL0")) + ucldec(src, dst, sz); + else if (codec == STR32("APL0")) + apldec(src, dst, sz); + else + return 1; + + return 0; +} + +/* decompress rom (returns pointer to decompressed rom) */ +static inline void *romdec(void *rom, unsigned romSz, unsigned *dstSz) +{ + unsigned char *comp = rom; /* compressed rom */ + unsigned char *dec; + unsigned char *dma; + unsigned char *dmaStart; + unsigned char *dmaEnd = 0; + unsigned dmaNum = 0; + + /* find dmadata in rom */ + dmaStart = 0; + for (dma = comp; (unsigned)(dma - comp) < romSz - 32; dma += 16) + { + /* TODO iQue has the magic value x1050 instead of x1060 */ + const unsigned char magic[] = { /* table always starts like so */ + 0x00,0x00,0x00,0x00 /* Vstart */ + , 0x00,0x00,0x10,0x60 /* Vend */ + , 0x00,0x00,0x00,0x00 /* Pstart */ + , 0x00,0x00,0x00,0x00 /* Pend */ + , 0x00,0x00,0x10,0x60 /* Vstart (next) */ + }; + + /* data doesn't match */ + if (memcmp(dma, magic, sizeof(magic))) + continue; + + /* table[IDX].Vstart isn't current rom offset */ + if (beU32(dma + STRIDE * IDX) != (unsigned)(dma - comp)) + continue; + + /* all tests passed; this is dmadata */ + dmaStart = dma; + dmaNum = (beU32(dma + STRIDE * IDX + 4) - (dma - comp)) / STRIDE; + dmaEnd = dmaStart + dmaNum * STRIDE; + } + + /* failed to locate dmadata in rom */ + if (!dmaStart) + die("failed to locate dmadata in rom"); + + /* determine distal end of decompressed rom */ + *dstSz = romSz; + for (dma = dmaStart; dma < dmaEnd; dma += STRIDE) + { + unsigned Vend = beU32(dma + 4); + if (Vend > *dstSz) + *dstSz *= 2; + } + + /* allocate decompressed rom */ + dec = calloc_safe(*dstSz, 1); + + /* transfer files from comp to dec */ + for (dma = dmaStart; dma < dmaEnd; dma += STRIDE) + { + unsigned Vstart = beU32(dma + 0); /* virtual addresses */ + unsigned Vend = beU32(dma + 4); + unsigned Pstart = beU32(dma + 8); /* physical addresses */ + unsigned Pend = beU32(dma + 12); + + /* unused or invalid entry */ + if (Pstart == DMA_DELETED + || Vstart == DMA_DELETED + || Pend == DMA_DELETED + || Vend == DMA_DELETED + || Vend <= Vstart /* sizes must be > 0 */ + || (Pend && Pend == Pstart) + ) + continue; + + /* compressed */ + if (Pend) + { + int err = decompress( + dec + Vstart /* dst */ + , comp + Pstart /* src */ + , Pend - Pstart /* sz */ + ); + + if (err) + die("dma entry at %08x: compressed file, unknown encoding" + , (unsigned)(dma - comp) + ); + } + + /* not compressed */ + else + memcpy(dec + Vstart, comp + Pstart, Vend - Vstart); + + /* update dma entry */ + wbeU32(dma + 8, Vstart); + wbeU32(dma + 12, 0); + } + + /* copy modified dmadata to decompressed rom */ + memcpy(dec + (dmaStart - comp), dmaStart, dmaNum * STRIDE); + + /* update crc */ + n64crc(dec); + + return dec; +} + +/* take "infile.z64" and make "infile.decompressed.z64" */ +static char *quickOutname(char *in) +{ + const char *append = ".decompressed.z64"; + char *out; + char *ss; + char *slash; + + out = malloc_safe(strlen(in) + 1 + strlen(append)); + strcpy(out, in); + + /* find last directory character (if there are any) */ + slash = strrchr(out, '/'); + if (!slash) + slash = strrchr(out, '\\'); + if (!slash) + slash = out; + + /* eliminate extension, if there is one */ + if ((ss = strrchr(out, '.')) && ss > slash) + *ss = '\0'; + /* otherwise, so use end of string */ + ss = slash + strlen(slash); + + /* extension magic */ + strcpy(ss, append); + + return out; +} + +static void showargs(void) +{ +#define P(X) fprintf(stderr, X "\n") + P("args: z64decompress \"in-file.z64\" \"out-file.z64\""); + P(""); + P("The \"out-file.z64\" argument is optional. If not specified,"); + P("\"in-file.decompressed.z64\" will be generated."); +#ifdef _WIN32 /* helps users unfamiliar with command line */ + P(""); + P("Alternatively, Windows users can close this window and drop"); + P("a rom file directly onto the z64decompress executable."); + getchar(); +#endif +#undef P +} + +wow_main +{ + char *infile; + char *outfile; + void *dec = 0; + void *rom = 0; + unsigned romSz; + unsigned decSz; + int exitCode = EXIT_SUCCESS; + wow_main_argv; + + #define ARG_INFILE argv[1] + #define ARG_OUTFILE argv[2] + + fprintf(stderr, "welcome to z64decompress \n"); + if (argc < 2) + { + showargs(); + return EXIT_FAILURE; + } + + infile = ARG_INFILE; + if (argc < 3) + outfile = quickOutname(infile); + else + outfile = ARG_OUTFILE; + + /* attempt to load rom */ + rom = file_load(infile, &romSz); + + /* attempt to decompress rom */ + dec = romdec(rom, romSz, &decSz); + + /* write out rom */ + file_write(outfile, dec, decSz); + + fprintf( + stderr + , "decompressed rom '%s' written successfully\n" + , outfile + ); + + /* cleanup */ + free(rom); + free(dec); + if (outfile != ARG_OUTFILE) + { + free(outfile); +#ifdef _WIN32 /* assume user dropped file onto z64decompress.exe */ + getchar(); +#endif + } + + return exitCode; +} + diff --git a/src/n64crc.c b/src/n64crc.c new file mode 100644 index 0000000..a34d646 --- /dev/null +++ b/src/n64crc.c @@ -0,0 +1,197 @@ +/* snesrc - SNES Recompiler + * + * Mar 23, 2010: addition by spinout to actually fix CRC if it is incorrect + * + * Copyright notice for this file: + * Copyright (C) 2005 Parasyte + * + * Based on uCON64's N64 checksum algorithm by Andreas Sterbenz + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#define ROL(i, b) (((i) << (b)) | ((i) >> (32 - (b)))) +#define BYTES2LONG(b) ( (b)[0] << 24 | \ + (b)[1] << 16 | \ + (b)[2] << 8 | \ + (b)[3] ) + +#define N64_HEADER_SIZE 0x40 +#define N64_BC_SIZE (0x1000 - N64_HEADER_SIZE) + +#define N64_CRC1 0x10 +#define N64_CRC2 0x14 + +#define CHECKSUM_START 0x00001000 +#define CHECKSUM_LENGTH 0x00100000 +#define CHECKSUM_CIC6102 0xF8CA4DDC +#define CHECKSUM_CIC6103 0xA3886759 +#define CHECKSUM_CIC6105 0xDF26F436 +#define CHECKSUM_CIC6106 0x1FEA617A + + +static void gen_table(unsigned int crc_table[256]) +{ + unsigned int crc, poly; + int i, j; + + poly = 0xEDB88320; + for (i = 0; i < 256; i++) { + crc = i; + for (j = 8; j > 0; j--) { + if (crc & 1) crc = (crc >> 1) ^ poly; + else crc >>= 1; + } + crc_table[i] = crc; + } +} + + +static unsigned int crc32( + unsigned int crc_table[256] + , unsigned char *data + , int len +) +{ + unsigned int crc = ~0; + int i; + + for (i = 0; i < len; i++) { + crc = (crc >> 8) ^ crc_table[(crc ^ data[i]) & 0xFF]; + } + + return ~crc; +} + + +static int N64GetCIC(unsigned int crc_table[256], unsigned char *data) +{ + switch (crc32(crc_table, &data[N64_HEADER_SIZE], N64_BC_SIZE)) { + case 0x6170A4A1: return 6101; + case 0x90BB6CB5: return 6102; + case 0x0B050EE0: return 6103; + case 0x98BC2C86: return 6105; + case 0xACC8580A: return 6106; + } + + return 0; +} + + +static int N64CalcCRC( + unsigned int crc_table[256] + , unsigned int *crc + , unsigned char *data +) +{ + int bootcode, i; + unsigned int seed; + unsigned int t1, t2, t3; + unsigned int t4, t5, t6; + unsigned int r, d; + + switch ((bootcode = N64GetCIC(crc_table, data))) { + case 6101: + case 6102: + seed = CHECKSUM_CIC6102; + break; + case 6103: + seed = CHECKSUM_CIC6103; + break; + case 6105: + seed = CHECKSUM_CIC6105; + break; + case 6106: + seed = CHECKSUM_CIC6106; + break; + default: + return 1; + } + + t1 = t2 = t3 = t4 = t5 = t6 = seed; + + i = CHECKSUM_START; + while (i < (CHECKSUM_START + CHECKSUM_LENGTH)) { + d = BYTES2LONG(&data[i]); + if ((t6 + d) < t6) + t4++; + t6 += d; + t3 ^= d; + r = ROL(d, (d & 0x1F)); + t5 += r; + if (t2 > d) + t2 ^= r; + else + t2 ^= t6 ^ d; + + if (bootcode == 6105) + t1 += BYTES2LONG(&data[N64_HEADER_SIZE + 0x0710 + (i & 0xFF)]) ^ d; + else + t1 += t5 ^ d; + + i += 4; + } + if (bootcode == 6103) { + crc[0] = (t6 ^ t4) + t3; + crc[1] = (t5 ^ t2) + t1; + } + else if (bootcode == 6106) { + crc[0] = (t6 * t4) + t3; + crc[1] = (t5 * t2) + t1; + } + else { + crc[0] = t6 ^ t4 ^ t3; + crc[1] = t5 ^ t2 ^ t1; + } + + return 0; +} + + +/* recalculate rom crc */ +void n64crc(void *rom) +{ + unsigned int crc_table[256]; + unsigned char CRC1[4]; + unsigned char CRC2[4]; + unsigned int crc[2]; + unsigned char *rom8 = rom; + + assert(rom); + + gen_table(crc_table); + + if (!N64CalcCRC(crc_table, crc, rom)) + { + unsigned int kk1 = crc[0]; + unsigned int kk2 = crc[1]; + int i; + + for (i = 0; i < 4; ++i) + { + CRC1[i] = (kk1 >> (24-8*i))&0xFF; + CRC2[i] = (kk2 >> (24-8*i))&0xFF; + } + + for (i = 0; i < 4; ++i) + *(rom8 + N64_CRC1 + i) = CRC1[i]; + + for (i = 0; i < 4; ++i) + *(rom8 + N64_CRC2 + i) = CRC2[i]; + } +} + diff --git a/src/n64crc.h b/src/n64crc.h new file mode 100644 index 0000000..b5342da --- /dev/null +++ b/src/n64crc.h @@ -0,0 +1,32 @@ +/* snesrc - SNES Recompiler + * + * Mar 23, 2010: addition by spinout to actually fix CRC if it is incorrect + * + * Copyright notice for this file: + * Copyright (C) 2005 Parasyte + * + * Based on uCON64's N64 checksum algorithm by Andreas Sterbenz + * + * 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 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef N64CRC_H_INCLUDED +#define N64CRC_H_INCLUDED + +/* recalculate rom crc */ +void n64crc(void *rom); + +#endif /* N64CRC_H_INCLUDED */ + diff --git a/src/wow.c b/src/wow.c new file mode 100644 index 0000000..21b2c67 --- /dev/null +++ b/src/wow.c @@ -0,0 +1,3 @@ +#define WOW_IMPLEMENTATION +#include "wow.h" + diff --git a/src/wow.h b/src/wow.h new file mode 100644 index 0000000..cc2d88c --- /dev/null +++ b/src/wow.h @@ -0,0 +1,769 @@ +/* + * wow.h + * + * a small collection of functions + * to make writing software easier + * + * z64me + * + */ + +#ifndef WOW_H_INCLUDED +#define WOW_H_INCLUDED + +#include /* size_t */ +#include /* file ops */ +#include /* alloc */ +#include /* stat */ +#include /* strdup */ +#include /* chdir, getcwd */ +#include +#include + +#ifdef _WIN32 + #include + #undef near + #undef far +#endif + + +#if (_WIN32 && UNICODE) + #define wow_main int wmain(int argc, wchar_t *Wargv[]) + #define wow_main_argv char **argv = wow_conv_args(argc, (void*)Wargv) +#else + #define wow_main int main(int argc, char *argv[]) + #define wow_main_argv do{}while(0) +#endif + + +#ifndef WOW_API_PREFIX + #define WOW_API_PREFIX +#endif + +WOW_API_PREFIX +void * +wow_utf8_to_wchar(const char *str); + +WOW_API_PREFIX +char * +wow_wchar_to_utf8(void *wstr); + + +/* converts argv[] from wchar to char win32, in place */ +WOW_API_PREFIX +void * +wow_conv_args(int argc, void *argv[]); + + +/* returns non-zero if path is a directory */ +WOW_API_PREFIX +int +wow_is_dir_w(void const *path); + + +/* returns non-zero if path is a directory */ +WOW_API_PREFIX +int +wow_is_dir(char const *path); + + +/* fread abstraction that falls back to buffer-based fread * + * if a big fread fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fread_bytes(void *ptr, size_t bytes, FILE *stream); + + +/* fwrite abstraction that falls back to buffer-based fwrite * + * if a big fwrite fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fwrite_bytes(const void *ptr, size_t bytes, FILE *stream); + + +/* fread abstraction that falls back to buffer-based fread * + * if a big fread fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fread(void *ptr, size_t size, size_t nmemb, FILE *stream); + + +/* fwrite abstraction that falls back to buffer-based fwrite * + * if a big fwrite fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream); + + +/* fopen abstraction for utf8 support on windows win32 */ +WOW_API_PREFIX +FILE * +wow_fopen(char const *name, char const *mode); + + +/* remove abstraction for utf8 support on windows win32 */ +WOW_API_PREFIX +int +wow_remove(char const *path); + + +/* mkdir */ +WOW_API_PREFIX +int +wow_mkdir(char const *path); + + +/* chdir */ +WOW_API_PREFIX +int +wow_chdir(char const *path); + + +/* getcwd */ +WOW_API_PREFIX +char * +wow_getcwd(char *buf, size_t size); + + +/* getcwd_safe */ +WOW_API_PREFIX +char * +wow_getcwd_safe(char *buf, size_t size); + + +/* system */ +WOW_API_PREFIX +int +wow_system(char const *path); + +WOW_API_PREFIX void die(const char *fmt, ...) + __attribute__ ((format (printf, 1, 2))) +; +WOW_API_PREFIX void *calloc_safe(size_t nmemb, size_t size); +WOW_API_PREFIX void *malloc_safe(size_t size); +WOW_API_PREFIX void *realloc_safe(void *ptr, size_t size); +WOW_API_PREFIX char *strdup_safe(const char *s); +WOW_API_PREFIX void *memdup_safe(void *ptr, size_t size); + +#ifdef WOW_IMPLEMENTATION + +WOW_API_PREFIX void die(const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); +#ifdef UNICODE + char buf[4096]; + vsprintf(buf, fmt, args); + wchar_t *wc = wow_utf8_to_wchar(buf); + setlocale(LC_ALL, ""); + fwprintf(stderr, L"%ls", wc); + free(wc); +#else + vfprintf(stderr, fmt, args); +#endif + va_end(args); + fprintf(stderr, "\n"); + exit(EXIT_FAILURE); +} + +WOW_API_PREFIX void *calloc_safe(size_t nmemb, size_t size) +{ + void *result = calloc(nmemb, size); + + if (!result) + die("memory error"); + + return result; +} + +WOW_API_PREFIX void *malloc_safe(size_t size) +{ + void *result = malloc(size); + + if (!result) + die("memory error"); + + return result; +} + +WOW_API_PREFIX void *realloc_safe(void *ptr, size_t size) +{ + void *result = realloc(ptr, size); + + if (!result) + die("memory error"); + + return result; +} + +WOW_API_PREFIX char *strdup_safe(const char *s) +{ + char *result; + int n; + + if (!s) + return 0; + + n = strlen(s) + 1; + + result = malloc_safe(n); + + strcpy(result, s); + + return result; +} + +WOW_API_PREFIX void *memdup_safe(void *ptr, size_t size) +{ + void *result; + + if (!ptr || !size) + return 0; + + result = malloc_safe(size); + + memcpy(result, ptr, size); + + return result; +} + + +WOW_API_PREFIX +void * +wow_utf8_to_wchar(const char *str) +{ +#ifdef UNICODE +extern __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); + wchar_t *wstr; + int wstr_sz = (strlen(str) + 1) * 16;//sizeof(*wstr); + wstr = calloc_safe(1, wstr_sz); + MultiByteToWideChar(65001/*utf8*/, 0, str, -1, wstr, wstr_sz); + return wstr; +#else + return strdup(str); +#endif +} + +WOW_API_PREFIX +char * +wow_wchar_to_utf8_buf(void *wstr, void *dst, int dst_max) +{ +#ifdef UNICODE +extern __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + WideCharToMultiByte(65001/*utf8*/, 0, wstr, -1, dst, dst_max, NULL, NULL); + return dst; +#else + (void)dst_max; /* unused parameter */ + return strcpy(dst, wstr); +#endif +} + +WOW_API_PREFIX +char * +wow_wchar_to_utf8(void *wstr) +{ +#ifdef UNICODE +extern __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + char *str; + int str_sz = (wcslen(wstr) + 1) * sizeof(*str); + str = calloc_safe(1, str_sz); + WideCharToMultiByte(65001/*utf8*/, 0, wstr, -1, str, str_sz, NULL, NULL); + return str; +#else + return strdup(wstr); +#endif +} + +WOW_API_PREFIX +char * +wow_wchar_to_utf8_inplace(void *wstr) +{ +#ifdef UNICODE +extern __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); + char buf[4096]; + char *str; + int wstr_len = wcslen(wstr); + unsigned str_sz = (wstr_len + 1) * sizeof(*str); + if (str_sz >= sizeof(buf)) + str = malloc_safe(str_sz); + else + str = buf; + WideCharToMultiByte(65001/*utf8*/, 0, wstr, -1, str, str_sz, NULL, NULL); + memcpy(wstr, str, wstr_len + 1); + ((char*)wstr)[wstr_len+1] = '\0'; + if (str != buf) + free(str); + return wstr; +#else + return wstr; +#endif +} + + +/* argument abstraction: converts argv[] from wchar to char win32 */ +WOW_API_PREFIX +void * +wow_conv_args(int argc, void *argv[]) +{ +#ifdef UNICODE + int i; + for (i=0; i < argc; ++i) + { + //fprintf(stderr, "[%d]: %s\n", i, argv[i]); + //fwprintf(stderr, L"[%d]: %s\n", i, (wchar_t*)argv[i]); + argv[i] = wow_wchar_to_utf8_inplace(argv[i]); + //fwprintf(stderr, L"[%d]: %s\n", i, wow_utf8_to_wchar(argv[i])); + } +#else + (void)argc; /* unused parameter */ +#endif + return argv; +} + +/* returns non-zero if path is a directory */ +WOW_API_PREFIX +int +wow_is_dir_w(void const *path) +{ + struct stat s; +#if (_WIN32 && UNICODE) + if (wstat(path, &s) == 0) +#else + if (stat(path, &s) == 0) +#endif + { + if (s.st_mode & S_IFDIR) + return 1; + } + + return 0; +} + + +/* returns non-zero if path is a directory */ +WOW_API_PREFIX +int +wow_is_dir(char const *path) +{ + int rv; + void *wpath = 0; + +#if (_WIN32 && UNICODE) + wpath = wow_utf8_to_wchar(path); + rv = wow_is_dir_w(wpath); +#else + rv = wow_is_dir_w(path); +#endif + if (wpath) + free(wpath); + + return rv; +} + + +/* fread abstraction that falls back to buffer-based fread * + * if a big fread fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fread_bytes(void *ptr, size_t bytes, FILE *stream) +{ + if (!stream || !ptr || !bytes) + return 0; + + unsigned char *ptr8 = ptr; + size_t Oofs = ftell(stream); + size_t bufsz = 1024 * 1024; /* 1 mb at a time */ + size_t Obytes = bytes; + size_t rem; + + fseek(stream, 0, SEEK_END); + rem = ftell(stream) - Oofs; + fseek(stream, Oofs, SEEK_SET); + + if (bytes > rem) + bytes = rem; + + /* everything worked */ + if (fread(ptr, 1, bytes, stream) == bytes) + return Obytes; + + /* failed: try falling back to slower buffered read */ + fseek(stream, Oofs, SEEK_SET); + while (bytes) + { + /* don't read past end */ + if (bytes < bufsz) + bufsz = bytes; + if (bufsz > rem) + { + bytes = rem; + bufsz = rem; + } + + /* still failed */ + if (fread(ptr8, 1, bufsz, stream) != bufsz) + return 0; + + /* advance */ + ptr8 += bufsz; + bytes -= bufsz; + rem -= bufsz; + } + + /* success */ + return Obytes; +} + + +/* fwrite abstraction that falls back to buffer-based fwrite * + * if a big fwrite fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fwrite_bytes(const void *ptr, size_t bytes, FILE *stream) +{ + if (!stream || !ptr || !bytes) + return 0; + + const unsigned char *ptr8 = ptr; + size_t bufsz = 1024 * 1024; /* 1 mb at a time */ + size_t Obytes = bytes; + + /* everything worked */ + if (fwrite(ptr, 1, bytes, stream) == bytes) + return bytes; + + /* failed: try falling back to slower buffered read */ + while (bytes) + { + /* don't read past end */ + if (bytes < bufsz) + bufsz = bytes; + + /* still failed */ + if (fwrite(ptr8, 1, bufsz, stream) != bufsz) + return 0; + + /* advance */ + ptr8 += bufsz; + bytes -= bufsz; + } + + /* success */ + return Obytes; +} + + +/* fread abstraction that falls back to buffer-based fread * + * if a big fread fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fread(void *ptr, size_t size, size_t nmemb, FILE *stream) +{ + if (!stream || !ptr || !size || !nmemb) + return 0; + + if (wow_fread_bytes(ptr, size * nmemb, stream) == size * nmemb) + return nmemb; + + return 0; +} + + +/* fwrite abstraction that falls back to buffer-based fwrite * + * if a big fwrite fails; if that still fails, returns 0 */ +WOW_API_PREFIX +size_t +wow_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) +{ + if (!stream || !ptr || !size || !nmemb) + return 0; + + if (wow_fwrite_bytes(ptr, size * nmemb, stream) == size * nmemb) + return nmemb; + + return 0; +} + + +/* fopen abstraction for utf8 support on windows win32 */ +WOW_API_PREFIX +FILE * +wow_fopen(char const *name, char const *mode) +{ +#ifdef UNICODE + void *wname = 0; + void *wmode = 0; + FILE *fp = 0; + + wname = wow_utf8_to_wchar(name); + if (!wname) + goto L_cleanup; + + /* TODO eventually, an error message would be cool */ + if (wow_is_dir_w(wname)) + goto L_cleanup; + + wmode = wow_utf8_to_wchar(mode); + if (!wmode) + goto L_cleanup; + + fp = _wfopen(wname, wmode); + +L_cleanup: + if (wname) free(wname); + if (wmode) free(wmode); + if (fp) + return fp; + return 0; +#else + /* TODO eventually, an error message would be cool */ + if (wow_is_dir_w(name)) + return 0; + return fopen(name, mode); +#endif +} + + +/* remove abstraction for utf8 support on windows win32 */ +WOW_API_PREFIX +int +wow_remove(char const *path) +{ +#ifdef UNICODE + void *wpath = 0; + int rval; + + wpath = wow_utf8_to_wchar(path); + if (!wpath) + return -1; + + rval = _wremove(wpath); + free(wpath); + return rval; +#else + return remove(path); +#endif +} + + +/* mkdir */ +WOW_API_PREFIX +int +wow_mkdir(char const *path) +{ +#if defined(_WIN32) && defined(UNICODE) +extern int _wmkdir(const wchar_t *); + void *wname = 0; + int rval; + + wname = wow_utf8_to_wchar(path); + if (!wname) + return -1; + + rval = _wmkdir(wname); + + if (wname) + free(wname); + + return rval; +#elif defined(_WIN32) /* win32 no unicode */ +extern int _mkdir(const char *); + return _mkdir(path); +#else /* ! _WIN32 */ + return mkdir(path, 0777); +#endif +} + + +/* chdir */ +WOW_API_PREFIX +int +wow_chdir(char const *path) +{ +#if defined(_WIN32) && defined(UNICODE) +extern int _wchdir(const wchar_t *); + void *wname = 0; + int rval; + + wname = wow_utf8_to_wchar(path); + if (!wname) + return -1; + + rval = _wchdir(wname); + + if (wname) + free(wname); + + return rval; +#elif defined(_WIN32) /* win32 no unicode */ +extern int _chdir(const char *); + return _chdir(path); +#else /* ! _WIN32 */ + return chdir(path); +#endif +} + + +/* getcwd */ +WOW_API_PREFIX +char * +wow_getcwd(char *buf, size_t size) +{ +#if defined(_WIN32) && defined(UNICODE) +//extern int _wgetcwd(const wchar_t *, int); +extern _CRTIMP wchar_t *__cdecl _wgetcwd(wchar_t *_DstBuf,int _SizeInWords); + wchar_t wname[4096]; + + if (!buf || !size) + return 0; + + if (!_wgetcwd(wname, sizeof(wname) / sizeof(wname[0]))) + return 0; + + return wow_wchar_to_utf8_buf(wname, buf, size); +#elif defined(_WIN32) /* win32 no unicode */ +//extern char *_getcwd(char *, int); + return _getcwd(buf, size); +#else /* ! _WIN32 */ + return getcwd(buf, size); +#endif +} + + +/* getcwd_safe */ +WOW_API_PREFIX +char * +wow_getcwd_safe(char *buf, size_t size) +{ + char *result = wow_getcwd(buf, size); + + if (!result) + die("failed to get current working directory"); + + return result; +} + + +/* system */ +WOW_API_PREFIX +int +wow_system(char const *path) +{ +#if defined(_WIN32) && defined(UNICODE) + void *wname = 0; + int rval; + + wname = wow_utf8_to_wchar(path); + if (!wname) + return -1; + + rval = _wsystem(wname); + + if (wname) + free(wname); + + return rval; +#else /* not win32 unicode */ + return system(path); +#endif +} + + +/* system_gui */ +WOW_API_PREFIX +int +wow_system_gui(char const *name, const char *param) +{ +#if defined(_WIN32) + STARTUPINFOW si; + PROCESS_INFORMATION pi; + + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + ZeroMemory(&pi, sizeof(pi)); + int rval = 0 /*success */; +//extern int ShellExecuteA(void *hwnd, void *op, void *file, void *param, void *dir, int cmd); +//extern int ShellExecuteW(void *hwnd, void *op, void *file, void *param, void *dir, int cmd); +//const int SW_SHOWNORMAL = 1; + #if defined(UNICODE) + void *wname = 0; + void *wparam = 0; + + wname = wow_utf8_to_wchar(name); + if (!wname) + { + return -1; + } + wparam = wow_utf8_to_wchar(param); + if (!wparam) + { + free(wname); + return -1; + } + +#if 0 + if (CreateProcessW( + wname, wparam + , NULL, NULL + , FALSE + , CREATE_NO_WINDOW + , NULL + , NULL + , &si, &pi) + ) + { + //WaitForSingleObject(pi.hProcess, INFINITE); + //CloseHandle(pi.hProcess); + //CloseHandle(pi.hThread); + } + else + rval = 1; +#else + rval = (int)ShellExecuteW(NULL, L"open", wname, wparam, L".", SW_SHOWNORMAL); + rval = rval <= 32; +#endif + + free(wname); + free(wparam); + #else /* win32 non-unicode */ +#if 0 + if (CreateProcessA( + name, x + , NULL, NULL + , FALSE + , CREATE_NO_WINDOW + , NULL + , NULL + , &si, &pi) + ) + { + //WaitForSingleObject(pi.hProcess, INFINITE); + //CloseHandle(pi.hProcess); + //CloseHandle(pi.hThread); + } + else + rval = 1; +#else + rval = (int)ShellExecuteA(NULL, "open", name, param, ".", SW_SHOWNORMAL); + rval = rval <= 32; +#endif + #endif + return rval;//rval <= 32; +#else /* not win32 unicode */ + char *x = malloc_safe(strlen(name) + strlen(param) + 128); + if (!x) + return -1; + strcpy(x, "\""); + strcat(x, name); + strcat(x, "\" "); + strcat(x, param); + int rval = system(x); + free(x); + return rval; +#endif +} + +#endif /* WOW_IMPLEMENTATION */ + +#endif /* WOW_H_INCLUDED */ +