commit c91b3c50068224929cd4d3ddf36c5a10254cbd9c Author: Justine Tunney Date: Mon Jun 15 07:18:57 2020 -0700 Initial import diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..68a1584f --- /dev/null +++ b/.clang-format @@ -0,0 +1,12 @@ +--- +BasedOnStyle: Google +StatementMacros: + - INITIALIZER +AlignConsecutiveMacros: true +AlignConsecutiveDeclarations: false +AlwaysBreakBeforeMultilineStrings: false +AllowShortFunctionsOnASingleLine: false +KeepEmptyLinesAtTheStartOfBlocks: true +--- +Language: Proto +... diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..844d010c --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +/o + +*.tmp +/.bochs.log +/HTAGS +/TAGS +/bx_enh_dbg.ini +/tool/emacs/*.elc diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..c49192ae --- /dev/null +++ b/Makefile @@ -0,0 +1,259 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# SYNOPSIS +# +# Freestanding Hermetically-Sealed Monolithic Repository +# +# REQUIREMENTS +# +# You can run your programs on any operating system, but you have +# to build them on Linux 2.6+ (or WSL) using GNU Make. A modern C +# compiler that's statically-linked comes included as a courtesy. +# +# EXAMPLES +# +# # build and run everything +# make -j8 -O +# make -j8 -O MODE=dbg +# make -j8 -O MODE=opt +# make -j8 -O MODE=rel +# make -j8 -O MODE=tiny +# +# # build individual target +# make -j8 -O o//examples/hello.com +# o//examples/hello.com +# +# # view source +# less examples/hello.c +# +# # view binary +# o//tool/viz/bing.com o//examples/hello.com | +# o//tool/viz/fold.com +# +# # view transitive closure of legalese +# o//tool/viz/bing.com -n o//examples/hello.com | +# o//tool/viz/fold.com +# +# # basic debugging +# make -j8 -O MODE=dbg o/dbg/examples/crashreport.com +# o/dbg/examples/crashreport.com +# less examples/crashreport.c +# +# # extremely tiny binaries +# make -j8 -O MODE=tiny \ +# LDFLAGS=-s \ +# CPPFLAGS=-DSUPPORT_VECTOR=0b00000001 \ +# o/tiny/examples/hello4.elf +# ls -hal o/tiny/examples/hello4.elf +# o/tiny/examples/hello4.elf +# +# TROUBLESHOOTING +# +# make -j8 -O SILENT=0 o//examples/hello.com +# make o//examples/life.elf -pn |& less +# etc. +# +# SEE ALSO +# +# build/config.mk + +SHELL = dash +HOSTS ?= freebsd openbsd alpine + +.SUFFIXES: +.DELETE_ON_ERROR: +.FEATURES: output-sync +.PHONY: all o bins check test depend tags + +all: o +o: o/libc \ + o/$(MODE)/ape \ + o/$(MODE)/dsp \ + o/$(MODE)/net \ + o/$(MODE)/libc \ + o/$(MODE)/test \ + o/$(MODE)/tool \ + o/$(MODE)/examples \ + o/$(MODE)/third_party + +PKGS = + +include build/functions.mk #─┐ +include build/definitions.mk # ├──meta +include build/config.mk # │ +include build/rules.mk # │ +include build/online.mk # │ +include libc/stubs/stubs.mk #─┘ +include libc/nexgen32e/nexgen32e.mk #─┐ +include libc/intrin/intrin.mk # │ +include libc/math/math.mk # ├──metal +include libc/tinymath/tinymath.mk # │ +include third_party/compiler_rt/compiler_rt.mk # │ +include libc/bits/bits.mk # │ +include libc/str/str.mk # │ +include third_party/xed/xed.mk # │ +include third_party/zlib/zlib.mk # │ +include libc/elf/elf.mk # │ +include ape/lib/apelib.mk # │ +include ape/ape.mk #─┘ +include libc/sysv/sysv.mk #─┐ +include libc/nt/nt.mk # ├──system +include libc/conv/conv.mk # │ +include libc/fmt/fmt.mk # │ +include libc/rand/rand.mk #─┘ +include libc/calls/calls.mk #─┐ +include libc/runtime/runtime.mk # ├──systems +include libc/unicode/unicode.mk # │ +include third_party/dlmalloc/dlmalloc.mk # │ +include libc/mem/mem.mk # │ +include libc/zipos/zipos.mk # │ +include third_party/dtoa/dtoa.mk # │ +include libc/time/time.mk # │ +include libc/escape/escape.mk # │ +include libc/alg/alg.mk # │ +include libc/calls/hefty/hefty.mk # │ +include libc/stdio/stdio.mk # │ +include third_party/f2c/f2c.mk # │ +include third_party/blas/blas.mk # │ +include net/net.mk # │ +include libc/log/log.mk # │ +include dsp/core/core.mk # │ +include libc/x/x.mk # │ +include third_party/stb/stb.mk # │ +include dsp/scale/scale.mk # │ +include dsp/mpeg/mpeg.mk # │ +include dsp/dsp.mk # │ +include third_party/musl/musl.mk # │ +include third_party/getopt/getopt.mk # │ +include libc/libc.mk #─┘ +include libc/sock/sock.mk #─┐ +include dsp/tty/tty.mk # ├──online +include libc/dns/dns.mk # │ +include libc/crypto/crypto.mk # │ +include net/http/http.mk #─┘ +include third_party/linenoise/linenoise.mk +include third_party/editline/editline.mk +include third_party/duktape/duktape.mk +include third_party/regex/regex.mk +include third_party/avir/avir.mk +include third_party/third_party.mk +include libc/testlib/testlib.mk +include libc/crt/crt.mk +include tool/viz/lib/vizlib.mk +include examples/examples.mk +include third_party/lex/lex.mk +include third_party/m4/m4.mk +include third_party/lz4cli/lz4cli.mk +include third_party/bzip2/bzip2.mk +include tool/build/lib/buildlib.mk +include tool/build/build.mk +include tool/debug/debug.mk +include tool/decode/lib/decodelib.mk +include tool/decode/decode.mk +include tool/hash/hash.mk +include tool/net/net.mk +include tool/viz/viz.mk +include tool/cc/cc.mk +include tool/tool.mk +include test/libc/alg/test.mk +include test/libc/tinymath/test.mk +include test/libc/math/test.mk +include test/libc/intrin/test.mk +include test/libc/mem/test.mk +include test/libc/nexgen32e/test.mk +include test/libc/runtime/test.mk +include test/libc/sock/test.mk +include test/libc/bits/test.mk +include test/libc/crypto/test.mk +include test/libc/str/test.mk +include test/libc/unicode/test.mk +include test/libc/calls/test.mk +include test/libc/x/test.mk +include test/libc/xed/test.mk +include test/libc/fmt/test.mk +include test/libc/dns/test.mk +include test/libc/rand/test.mk +include test/libc/time/test.mk +include test/libc/stdio/test.mk +include test/libc/conv/test.mk +include test/libc/test.mk +include test/ape/lib/test.mk +include test/ape/test.mk +include test/net/http/test.mk +include test/net/test.mk +include test/tool/build/lib/test.mk +include test/tool/build/test.mk +include test/tool/viz/lib/test.mk +include test/tool/viz/test.mk +include test/tool/test.mk +include test/test.mk +include test/dsp/core/test.mk +include test/dsp/scale/test.mk +include test/dsp/tty/test.mk +include test/dsp/test.mk + +OBJS = $(foreach x,$(PKGS),$($(x)_OBJS)) +SRCS = $(foreach x,$(PKGS),$($(x)_SRCS)) +HDRS = $(foreach x,$(PKGS),$($(x)_HDRS)) +BINS = $(foreach x,$(PKGS),$($(x)_BINS)) +TESTS = $(foreach x,$(PKGS),$($(x)_TESTS)) +CHECKS = $(foreach x,$(PKGS),$($(x)_CHECKS)) + +bins: $(BINS) +check: $(CHECKS) +test: $(TESTS) +depend: o/$(MODE)/depend +tags: TAGS HTAGS + +o/$(MODE)/.x: + @mkdir -p $(dir $@) && touch $@ + +o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x)))) + $(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x))) + +o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS),$(dir $(x)))) + $(file >$@) $(foreach x,$(HDRS),$(file >>$@,$(x))) + +o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt $(SRCS) $(HDRS) + @build/mkdeps -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt + +TAGS: o/$(MODE)/srcs.txt $(SRCS) + @rm -f $@ + @ACTION=TAGS TARGET=$@ build/do $(TAGS) $(TAGSFLAGS) -L $< -o $@ + +HTAGS: o/$(MODE)/hdrs.txt $(HDRS) + @rm -f $@ + @ACTION=TAGS TARGET=$@ build/do build/htags -L $< -o $@ + +loc:; find -name \*.h -or -name \*.c -or -name \*.S | \ + $(XARGS) wc -l | grep total | awk '{print $$1}' | summy + +# UNSPECIFIED PREREQUISITES TUTORIAL +# +# A build rule must exist for all files that make needs to consider in +# order to build the requested goal. That includes input source files, +# even if the rule is empty and does nothing. Otherwise, the .DEFAULT +# rule gets triggered. +# +# This is a normal and neecssary behavior when source files get deleted. +# The build reacts automatically to this happening, by simply deleting +# and regenerating the dependency graph; so we can safely use wildcard. +# +# This is abnormal if it needs to keep doing that repeatedly. That can +# only mean the build config is broken. +# +# Also note that a suboptimal in-between state may exist, where running +# `make -pn` reveals rules being generated with the .DEFAULT target, but +# never get executed since they're not members of the transitive closure +# of `make all`. In that case the build config could be improved. +%.mk: +$(SRCS): +$(HDRS): +.DEFAULT: + @echo >&2 + @echo NOTE: deleting o/$(MODE)/depend due to unspecified prerequisite: $@ >&2 + @echo >&2 + rm -f o/$(MODE)/depend + +-include o/$(MODE)/depend diff --git a/NOTICE b/NOTICE new file mode 100644 index 00000000..5b1b10d7 --- /dev/null +++ b/NOTICE @@ -0,0 +1,354 @@ +Cosmopolitan is Free Software licensed under the GPLv2. The build config +**will embed all linked sources inside your binaries** so the compliance +is easy while facilitating trust and transparency similar to JavaScript. +You can audit your source filesystem using ZIP GUIs e.g. WIN10, InfoZip. + +If you want to be able to distribute binaries in binary form only, then +please send $1,000 to jtunney@gmail.com on PayPal for a license lasting +1 year. Please be sure to provide your contact information, and details +on whether or not the license is for an individual or a corporation. If +you want your license to last 5 years, send $10,000 to the author above +who is Justine Tunney . Reach out, for more details. + +──────────────────────────────────────────────────────────────────────── + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 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. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) 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 +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 software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. 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. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +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. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +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 Program, 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 Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) 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; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, 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 executable. 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. + +If distribution of executable or 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 counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program 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. + + 5. 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 Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program 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. + + 7. 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 Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program 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 Program. + +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. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program 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. + + 9. The Free Software Foundation may publish revised and/or new versions +of the 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 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 Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, 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 + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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. + + 12. 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 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. + + 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 +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. + + + 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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision 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, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This 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 Library General +Public License instead of this License. diff --git a/README.md b/README.md new file mode 100644 index 00000000..0c304d87 --- /dev/null +++ b/README.md @@ -0,0 +1,51 @@ +# Cosmopolitan + +Cosmopolitan builds run natively on most platforms without dependencies, +because it implements the subset of the C library, compiler runtimes and +system call interfaces that've achieved near universal consensus amongst +all major platforms, e.g. Linux/BSD/XNU/NT. Containerization is achieved +by having binaries also be ZIP files. Modern static stock GNU toolchains +are provided in a hermetic mono repo for maximum historical determinism. + +Here's how you can get started by printing cat videos inside a terminal: + + make -j8 o//tool/viz/printvideo.com + wget https://justine.storage.googleapis.com/cats.mpg + o//tool/viz/printvideo.com cats.mpg + unzip -vl o//tool/viz/printvideo.com + +Cosmopolitan provides a native development environment similar to those +currently being offered by RedHat, Google, Apple, Microsoft, etc. We're +different in two ways: (1) we're not a platform therefore we don't have +any commercial interest in making our tooling work better on one rather +than another; and (2) we're only focused on catering towards interfaces +all platforms agree upon. Goal is software that stands the test of time +without the costs and restrictions cross-platform distribution entails. +That makes Cosmopolitan an excellent fit for writing small CLI programs +that do things like heavyweight numerical computations as a subprocess. + +## Licensing + +Cosmopolitan is Free Software licensed under the GPLv2. The build config +**will embed all linked sources inside your binaries** so the compliance +is easy while facilitating trust and transparency similar to JavaScript. +You can audit your source filesystem using ZIP GUIs e.g. WIN10, InfoZip. + +### Commercial Support + +If you want to be able to distribute binaries in binary form only, then +please send $1,000 to jtunney@gmail.com on PayPal for a license lasting +1 year. Please be sure to provide your contact information, and details +on whether or not the license is for an individual or a corporation. If +you want your license to last 5 years, send $10,000 to the author above +who is Justine Tunney . This README will be updated, +if pricing and other details should change. Reach out for more details. + +## Contributing + +We'd love to accept your patches! Before we can take them, we have to +jump through one legal hurdle. Please write an email to Justine Tunney + saying you agree to give her copyright ownership to +any changes you contribute to Cosmopolitan. We need to do that in order +to dual license Cosmopolitan. Otherwise we can't tax corporations that +don't want to share their code with the community. diff --git a/ape/ape.S b/ape/ape.S new file mode 100644 index 00000000..3a27df99 --- /dev/null +++ b/ape/ape.S @@ -0,0 +1,1935 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╠──────────────────────────────────────────────────────────────────────────────╣ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│ +│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│ +│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│ +╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│ +│ αcτµαlly pδrταblε εxεcµταblε § program header │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/config.h" +#include "ape/lib/apm.h" +#include "ape/lib/pc.h" +#include "ape/macros.h" +#include "ape/notice.inc" +#include "ape/relocations.h" +#include "libc/elf/def.h" +#include "libc/macho.h" +#include "libc/nexgen32e/uart.h" +#include "libc/nexgen32e/vidya.h" +#include "libc/nt/pedef.h" +#include "libc/sysv/consts/prot.h" +.yoink __FILE__ +.yoink "NOTICE" +.section .head,"ax",@progbits + +/ Common Sections. + .section .text,"ax",@progbits + .align __SIZEOF_POINTER__ + .previous + .section .rodata,"a",@progbits + .align __SIZEOF_POINTER__ +__ro: .endobj __ro,globl,hidden # ←for gdb readibility + .previous + .section .data,"aw",@progbits + .align __SIZEOF_POINTER__ + .previous + .section .bss,"aw",@nobits + .align __SIZEOF_POINTER__ + .previous + .section .rodata.str1.1,"aMS",@progbits +cstr: .endobj cstr,globl,hidden # ←for gdb readibility + .previous + .section .sort.rodata.real.str1.1,"aMS",@progbits +rlstr: .endobj rlstr,globl,hidden # ←for gdb readibility + .previous + +/* ████████ ████████ ███████████ + ██░░░░▒▒██ ██░░░░▒▒██ ████░░░░░░░░░▒▒████ + ██░░░░░░██ ██░░░░▒▒██ ██░░░░▒▒███████░░░░▒▒██ + ██░░░░░░▒▒██ ░██░░░░░░▒▒██ ██░░▒▒██ ██░░▒▒██ + ██░░▒▒░░░░██ ░██░░░░░░▒▒██ ██░░▒▒██ ████████ + ██░░▒▒▒▒░░▒▒██ ██▓░░░░▒▒░░▒▒██ ██░░▒▒▒▒███████ + ██░░▒▒██░░░░██ ██▓░░░░██░░▒▒██ ████░░░░░░░▒▒████ + ██░░▒▒████░░▒▒██░░░░░████░░▒▒██ ███████░░░░▒▒██ + ██░░▒▒████░░░░██░░░░░████░░▒▒██ ██████ ██░░░░▒▒██ + ██░░▒▒██ ██░░▒▒░░▒██ ██░░▒▒██ ██░░░░██ ██░░▒▒██ + ██░░▒▒██ ██░░░░░░▒██ ██░░▒▒██ ██░░░░█████████░░░░▒▒██ + ██░░▒▒██ ▓▓▒▒░░▒▒▒▓▓ ██░░▒▒██ ▓▓▒▒░░▓▓▓▓▓▓▓▓▓░░░░▓▓▓▓ + ██░░▒▒██ ██░░██▓ ██░░▒▒██ ██░░░░░░░░░░░░░▒▒██ + ████████████████████▓ ██████████████ ███████████████ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████▓▓░░▓▓░░▓▓░░████░░░░░░░░░░░░░░░████ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓█████▓▓░░▓▓░░▓▓░░████░░░░░░░░░░░░░░░░░░░░░██ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▒░░▓▓░░▓▓░░▓▓██░░░░░░░░░░░░░░░░░░░░░░░░░██ + ██▓▓▓▓▓▓██████████░░▒▓▓▓▓██████▓▓██░░░░░░███████████▓▓░░░░▓▓██ + ██▓▓▓▓▓▓████████░░▓▓▓▓▓██▓▓▓▓██████░░░░████░░▒▓▓██ ██▓▓▓▓▓▓██ + ██▓▓▓▓▓▓████████▓▓░░▒████▓▓▓▓██████░░░░██▓▓▓▓▒░░██ ██████ + ██▓▓▓▓▓▓██ ██░░▓▓▓▓▓██▓▓▓▓██ ██▓▓░░████░░▒▓▓██████ + ██▓▓▓▓▓▓██ ██▓▓░░▒████▓▓▓▓██ ██▓▓██▓▓▓▓▒░░██░░░░████ + ██▓▓▓▓▓▓██ ██░░▓▓▓▓▓██▓▓▓▓██ ██████░░▒▓▓██░░░░░░░░██ + ██▓▓▓▓▓▓██ ██▓▓░░▒████▓▓▓▓██ ██▓▓▓▓▒░░██▓▓░░░░░░░░██ + ██▓▓▓▓▓▓██ ██░░▓▓▓████▓▓▓▓██ ████████░░▒▓▓████▓▓░░░░░░██ + ██▓▓▓▓▓▓██ ██░░▒██▓▓▓▓████ ██░░░░░░██▓▓███ ██░░░░░░██ + ██▓▓▓▓▓▓█████████████▓▓▓▓██████████▓▓░░░░░░█████████░░░░░░░░██ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓░░██▓▓░░░░░░░░░░░░░░░░░░░░░▓▓██ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓░░▓▓██▓▓▓▓░░░░░░░░░░░░░░░░░▓▓▓▓██ + ██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▓▓░░▓▓░░▓▓██▓▓▓▓▓▓░░░░░░░░░░░▓▓▓▓▓▓██ + ██▓▓█████████████████████▓▓██▓▓██▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██ + ███████████████████████████▓▓██▓▓██▓▓████▓▓▓▓▓▓▓▓▓▓▓▓▓████ + ██████████████████▓ ██████████████ █████████████ +╔──────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § the old technology │ +╚─────────────────────────────────────────────────────────────────────────────*/ + +/ MZ Literally Executable Header +/ +/ This is the beginning of the program file and it can serve as an +/ entrypoint too. It shouldn't matter if the program is running on +/ Linux, Windows, etc. Please note if the underlying machine isn't +/ a machine, this header may need to morph itself to say the magic +/ words, e.g. ⌂ELF, which also works fine as a generic entrypoint. +/ +/ @see www.delorie.com/djgpp/doc/exe/ +/ @noreturn +ape.mz: .ascii "MZ" # Mark 'Zibo' Joseph Zbikowski + jno 2f # MZ: bytes on last page + jo 2f # MZ: 512-byte pages in file + .ascii "='" # MZ: reloc table entry count + .ascii "\n\0" # MZ: data segment file offset / 16 + .short 0x1000 # MZ: lowers upper bound load / 16 + .short 0xf800 # MZ: roll greed on bss + .short 0 # MZ: lower bound on stack segment + .short 0 # MZ: initialize stack pointer + .short 0 # MZ: ∑bₙ checksum don't bother + .short 0x0100 # MZ: initial ip value + .short 0x0800 # MZ: increases cs load lower bound + .short 0x0040 # MZ: reloc table offset + .short 0 # MZ: overlay number + .org 0x24 # MZ: bytes reserved for you + .ascii "JT" # MZ: OEM identifier + .short 0 # MZ: OEM information + .org 0x40-4 # MZ: bytes reserved for you + .long RVA(ape.pe) # PE: the new technology + .endobj ape.mz,globl,hidden + +/ Disk Operating System Stub +/ @noreturn + .org 0x40 # mz/elf header length +stub: mov $0x40,%dl # *literally* dos + jmp 1f # good bios skips here +1: jmp pc + nop # system five bootpoint + .org 0x48,0x90 # ⌂ELF → JNLE 47 + jmp 3f +2: push %rdx # don't move or shell script breaks + xor %edx,%edx # Z in MZ ate BIOS drive letter :( +3: .byte 0xbd,0,0 # mov $0x????0000,%[e]bp + jmp pc + jmp ape.hop # already in userspace + .endfn stub + +/ Mitigate incidental quotation marks. + .real +ape.hop:pop %rdx + push %r10 # MZ → pop %r10 w/ NexGen32e + .weak __imp_GetStartupInfoW + ezlea __imp_GetStartupInfoW,ax + test %rax,%rax + jz 0f + .weak KernelBase.GetStartupInfo + test %rax,%rax +/ TODO(jart) +/ cmpq $RVA(KernelBase.GetStartupInfo),(%rax) + jz 0f + jmp WinMain +0: .weak _start + jmp _start + .endfn ape.hop + .previous + +/*─────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § ibm personal computer │ +╚──────────────────────────────────────────────────────────────────────────────┘ + IBM designed BIOS to run programs by handing over the computer + to a program as soon as its first sector is loaded. That gives + us control over user-facing latency, even though the next step + will generally be asking the BIOS to load more. + + The process is trivial enough that this entrypoint can support + handoffs from alternative program-loaders e.g. Grub and MS-DOS + so long as they either load our full program, or implement the + PC BIOS disk service API. + + Since so many different implementations of these APIs have been + built the last forty years these routines also canonicalize the + cpu and program state, as it is written in the System V ABI. */ + +/ Initializes program and jumps to long mode loader. +/ +/ @param dl drive number (use 0x40 to skip bios disk load) +/ @mode real +/ @noreturn + .code16 +pc: cld + mov $REAL_STACK_FRAME>>4,%di # we need a stack + xor %cx,%cx + rlstack %di,%cx + movpp %cs,%ax # memcpy() [relocate this page] + call 1f +1: pop %si + sub $RVA(1b),%si + mov $4,%cl +1: shr %si + loop 1b + mov $512,%cx + mov $IMAGE_BASE_REAL>>4,%di + mov %si,%ds + mov %di,%es + xor %si,%si + xor %di,%di + rep + movsb %ds:(%si),%es:(%di) + ljmp $0,$REAL(1f) # longjmp() +1: mov $-512,%cx # memcpy() [relocate this frame] + rep + movsb %ds:(%si),%es:(%di) + xor %bp,%bp + mov %bp,%ds # %ds and %cs are now zero + call 1f # setup frame pointers +1: push %bp + mov %sp,%bp + mov $XLM_SIZE,%cx # memset() [clear real bss] + mov $XLM_BASE_REAL>>4,%ax + mov %ax,%es + xor %ax,%ax + xor %di,%di + rep + stosb %al,%es:(%di) + cmp $0x40,%dl # statfs() [disk geometry] + je 6f + call dsknfo + mov $IMAGE_BASE_REAL>>4,%ax + mov %ax,%es + mov $v_ape_realsectors,%di # total sectors to read + xor %dh,%dh # current head state + xor %cx,%cx # current cylinder state +3: mov %di,%ax + call pcread + mov %es,%si +4: add $512>>4,%si + dec %di + jz 6f + dec %ax + jnz 4b + mov %si,%es + jmp 3b +6: mov %cx,XLM(LOADSTATE)+0 + mov %dx,XLM(LOADSTATE)+2 + ljmp $0,$REAL(realmodeloader) + .endfn pc,globl,hidden + +/ Be gentler on Unix line buffer impls. + .byte 0x0a + +/ Determines disk geometry. +/ +/ We use imperial measurements for storage systems so the software +/ can have an understanding of physical locality, which deeply +/ impacts the latency of operations. +/ +/ - 160KB: 1 head × 40 cylinders × 8 sectors × 512 = 163,840 +/ - 180KB: 1 head × 40 cylinders × 9 sectors × 512 = 184,320 +/ - 320KB: 2 heads × 40 cylinders × 8 sectors × 512 = 327,680 +/ - 360KB: 2 heads × 40 cylinders × 9 sectors × 512 = 368,640 +/ - 720KB: 2 heads × 80 cylinders × 9 sectors × 512 = 737,280 +/ - 1.2MB: 2 heads × 80 cylinders × 15 sectors × 512 = 1,228,800 +/ - 1.44MB: 2 heads × 80 cylinders × 18 sectors × 512 = 1,474,560 +/ +/ Terminology +/ +/ - Cylinder / Tracks should mean the same thing +/ - Heads / Sides / Spindles should mean the same thing +/ +/ Disk Base Table +/ +/ 0: specify byte 1, step-rate time, head unload time +/ 1: specify byte 2, head load time, DMA mode +/ 2: timer ticks to wait before disk motor shutoff +/ 3: bytes per sector code +/ 0: 128 bytes 2: 512 bytes +/ 1: 256 bytes 3: 1024 bytes +/ 4: sectors per track (last sector number) +/ 5: inter-block gap length/gap between sectors +/ 6: data length, if sector length not specified +/ 7: gap length between sectors for format +/ 8: fill byte for formatted sectors +/ 9: head settle time in milliseconds +/ 10: motor startup time in eighths of a second +/ +/ @param dl drive number +/ @return dl = pc_drive (corrected if clobbered by header) +/ pc_drive +/ pc_drive_type +/ pc_drive_heads +/ pc_drive_last_cylinder +/ pc_drive_last_sector +/ @clob ax, cx, dx, di, si, es, flags +/ @since IBM Personal Computer XT +dsknfo: push %bx +1: push %dx + mov $0x08,%ah # get disk params + int $0x13 + jc 9f + mov %cl,%bh + and $0b00111111,%bh + and $0b11000000,%cl + rol %cl + rol %cl + xchg %cl,%ch + push %ds # disk base table in es:di + movpp %es,%ds + xor %si,%si + mov %si,%es + mov $XLM(DRIVE_BASE_TABLE),%si + xchg %si,%di + movsw #→ headunloadtime, headloadtime + movsw #→ shutofftime, bytespersector + movsw #→ sectorspertrack, sectorgap + movsw #→ datalength, formatgap + movsw #→ formatfill, settletime + movsb #→ startuptime + pop %ds + xchg %bx,%ax + stosw #→ pc_drive_type, pc_drive_last_sector + xchg %cx,%ax + stosw #→ pc_drive_last_cylinder + xchg %dx,%ax + stosw #→ pc_drives_attached, pc_drive_last_head + pop %ax + stosb #→ pc_drive + xchg %ax,%dx + pop %bx + ret +9: pop %dx +8: xor $0x80,%dl # try cycling drive a/c + xor %ax,%ax # reset disk + int $0x13 + jc 8b + jmp 1b + .endfn dsknfo + +/ Reads disk sectors via BIOS. +/ +/ Each call to this function performs a single read. It has a +/ special ABI, where its parameters are preserved, and rolled +/ forward accordingly across calls. BIOS requirements on read +/ parameter validity are abstracted. If the requested size is +/ too large for one read, then it's tuned down appropriately. +/ +/ Please note that dskinfo() must be called beforehand. +/ +/ @param ax number sectors to read +/ @param es destination memory address >> 4 +/ @param cx cylinder number +/ @param dh head number +/ @param dl drive number +/ @return number of sectors actually read +pcread: push %bx + xor %bx,%bx + mov XLM(DRIVE_LAST_SECTOR),%bl + cmp %ax,%bx # ax = min(ax, pertrack) + ja 1f + mov %bx,%ax +1: push %cx # how many sectors until 64k + push %ax # boundary reads can't cross + mov $0x1000,%bx # canonicalizing the segment + mov %es,%ax # register is not sufficient + sub %ax,%bx + and $0x0fff,%bx + mov $5,%cx +0: shr %bx + loop 0b + pop %ax + pop %cx + test %bx,%bx # %es 64k-aligned edge case + jz 1f + cmp %ax,%bx # ax = min(ax, remain64k) + ja 1f + mov %bx,%ax +1: push %ax # setup int-13-2() params + push %cx + xchg %cl,%ch + ror %cl + ror %cl + or $1,%cl # one cylinder at a time + xor %bx,%bx # es:bx is destination addr + mov $0x02,%ah # read disk sectors ordinal + int $0x13 + pop %cx + pop %bx + jc 9f + mov $0,%ah + cmp %ax,%bx + jl 9f + inc %cx + cmp XLM(DRIVE_LAST_CYLINDER),%cx + jle 2f + xor %cx,%cx + inc %dh +2: pop %bx + ret +9: push %ax + xor %ax,%ax # try disk reset on error + int $0x13 + pop %ax + jmp 1b + .endfn pcread + +/*───────────────────────────────────────────────────────────────────────────│─╗ +│ αcτµαlly pδrταblε εxεcµταblε § partition table ─╬─│┼ +╚────────────────────────────────────────────────────────────────────────────│*/ + +/ Partition Table. +.Lape.mbrpad: + .org 0x1b4 + .endobj .Lape.mbrpad +ape_disk: + .stub .Lape.diskid,quad + .org 0x1be,0x00 + .macro .partn x + .stub .Lape.part\x\().status,byte # 0=absent / 0x80=present + .stub .Lape.part\x\().first.head,byte # in low 6 bits + .stub .Lape.part\x\().first.cylinder,byte + .stub .Lape.part\x\().first.sector,byte + .stub .Lape.part\x\().filesystem,byte + .stub .Lape.part\x\().last.head,byte + .stub .Lape.part\x\().last.cylinder,byte + .stub .Lape.part\x\().last.sector,byte + .stub .Lape.part\x\().lba,long # c₀*Cₙ + h₀*Hₙ + s₀*Sₙ + .stub .Lape.part\x\().sector.count,long # sectors are 512 bytes + .endm + .partn 1 + .partn 2 + .partn 3 + .partn 4 + .org 0x1fe + .short BOOTSIG + .endobj ape_disk + +/* ▄▄▄ + ▄▄▄ ▀▓▓▒▄ + ▄▓▒▒░ ▀▓▒▒▒▄ + ▄▓▓▓▒▀ ▄▄▄▄ ▒▓▒▒░▒▄ + ▄▓▓▓▒▓ ▄▄▓██▓▓▓▓▒▒▒▒▓▓▄▄▓▓▒▒▒░░▒ + ▓▓▓▓▒▒▒▄▄ ░▒█▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓▒░░▒░ + ██▓▓▓▒▒░░▒▒▒▒▓▓▓▓▓▓▒▓▒░▒▒░▀▒▒▒▒░▀░▒▒▒░▒ + ▓▓▓▓▓▓▓▒▒▒▒▒▒▓▓▒▓▓▒▒▒░▒▒░░ ░▒▒░ ░▒▒▒▒ + ▀▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░▒░░ ░▒▒ ░ ▀▒▒ + ▀▓▓█▓▓▓▓▓▓▓▓▓▓▒▒░░▒▒░░ ░░░▓░ ▓░░░▒ + ▀▀█▓███▓▓▓▓▓▒▒░░░▒░░ ░█▓░█▓░█▓▓▄▒░ + ░▓██▓▓▓▓▓▒▒░░░▒░░ ░████▓▒▓█▓▀░▀▄ + ░▓██▓▓▓▓▓▒▒▒░░░▒░░ ▒██▓▒▒▒▒▒▒░░░▒ + ████▓▓▓▓▓▒▒▒▒▒▒▒▒▒░░▒▓▓▒░░░░▒░░░▒░ ░░░░░ + ░▓███▓▓▓▓▓▒▒░░░░░░░▒▒▒▒▒▒▒▒▒▒▒░░░ ░░░░░ ░ + ▓███▓▓▓▓▓▒▓▒▒▒▒░░░░░░░░░▒▓▒▒░▀ ░░░ ░░░░░ + ▀▒██▓▓▓▓▒▒▒▓▓▓▓▒▒▒▒▒▒▒▓▀▀░ ░░░░░░░░░ ░ + ▓▓▓▓▓▓▓▒▓▒▒▒▒▓▓▓▒▀░ ░░░░░▄░░░ ░░░ ░░░░░░ + ▓▓▓▒▒▒▒▒▒▒▒▒▒▒▓ █▓▒░░▒░░░░ ░░░░░░░░ + ▄▓▓▓▒▒▒▒▒░░░░░░░▒▄▄▄░▒▓▓▒▒░▀░ + ░▓█▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒░░░▒ besiyata + ▓▓█▓▓▒▓▓▓▒▒▒░░░░░░▒▓▓▓▓▒▒▒▒▒░ dishmaya + ▓▓█▓▓▓▓▓▓▒▒▒░░░░░░░▒▓▓▒▀▀▀ + ▓▓██▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▀ + █▓▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▀ + ▒▓▓▓▓▀░░▒▓▓▓▓▓▓▓▓▒▒░░▒ + ▄▓▓▀░░░▄▓▓▓▓▒▒▒▒▒░░░░▄░ + ▄███▄▄▓▓▓▓▓▓▓▒▒▒▒▒░░▒▒░ + ▄▓▓▓█▓█▓▓███▓▓▓▓▓▓▓▓▓▓▓░ + ▄░▓▓▓▓▓▓▀▒▓▓▓▒▒▓▒░░░▒▓▒░░░▓ + ▄▄▄░▒▓▓▓▓▓▓░▀▀ ▓▓▒░▓▒▒▒▒▒▒▒▒▒▒▄░░▀▀░░ ▄▄▄▄ + ▄▄▄▒▒▓▓█▓▓▓▓▓▀▀▀▀▀ ▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▀░░▀░░▒▒▒░░░ ░░░░░ + ▄▓▓▓▒▀▀ ▓▒▓▓▓▓▓▒▒▒▒▒▒▒▒▓░░░ ▒▒▒░░░░░░░░▒ + █▓▓▒ ▄▄▄ ▀▓▒▓▒▒▒▓▓▓▓▓▓▒▒▒░░░░░░░░░▒▒░░░░░░░ + ▀▓▓▓▓▒▄▄▒▒▒▒▒▒▄▄ ▀▀▀▀░░▒▒▒▒░░░░░░ + ▀▀▀▓▓▓▓▒▒▒▒▒▓▓▄▄ +╔────────────────────────────────────────────────────────────────────────────│─╗ +│ αcτµαlly pδrταblε εxεcµταblε § bell system five ─╬─│┼ +╚────────────────────────────────────────────────────────────────────────────│─╝ + the bourne executable & linkable format */ + +apesh: .ascii "'\n#'\"\n" # sixth edition shebang + .ascii "o=\"$(command -v \"$0\")\"\n" + .ascii "set -- \"$o\" \"$@\"\n" + .ascii "if [ -d /Applications ]; then\n" + .ascii "dd if=\"$o\"" + .ascii " of=\"$o\"" + .ascii " bs=8" + .ascii " skip=\"" + .shstub .Lape.macho.dd.skip,2 + .ascii "\" count=\"" + .shstub .Lape.macho.dd.count,2 + .ascii "\" conv=notrunc 2>/dev/null\n" + .ascii "elif exec 7<> \"$o\"; then\n" + .ascii "printf '" + .ascii "\\177ELF" # 0x0: ⌂ELF + .ascii "\\2" # 4: long mode + .ascii "\\1" # 5: little endian + .ascii "\\1" # 6: elf v1.o + .ascii "\\011" # 7: FreeBSD + .ascii "\\0" # 8: os/abi ver. + .ascii "\\0\\0\\0" # 9: padding 3/7 + .ascii "\\0\\0\\0\\0" # padding 4/7 + .ascii "\\2\\0" # 10: εxεcµταblε + .ascii "\\076\\0" # 12: NexGen32e + .ascii "\\1\\0\\0\\0" # 14: elf v1.o + .shstub .Lape.elf.entry,8 # 18: e_entry + .shstub .Lape.elf.phoff,8 # 20: e_phoff + .shstub .Lape.elf.shoff,8 # 28: e_shoff + .ascii "\\0\\0\\0\\0" # 30: e_flags + .ascii "\\100\\0" # 34: e_ehsize + .ascii "\\070\\0" # 36: e_phentsize + .shstub .Lape.elf.phnum,2 # 38: e_phnum + .ascii "\\0\\0" # 3a: e_shentsize + .shstub .Lape.elf.shnum,2 # 3c: e_shnum + .shstub .Lape.elf.shstrndx,2 # 3e: e_shstrndx + .ascii "' >&7\n" + .ascii "exec 7<&-\n" + .ascii "fi\n" + .ascii "exec \"$@\"\n" # etxtbsy tail recursion + .ascii "R=$?\n" # architecture optimistic + .ascii "if [ $R -eq 126 ] && [ \"$(uname -m)\" != x86_64 ]; then\n" + .ascii "if Q=\"$(command -v qemu-x86_64)\"; then\n" + .ascii "exec \"$Q\" \"$@\"\n" + .ascii "else\n" + .ascii "echo error: need qemu-x86_64 >&2\n" + .ascii "fi\n" + .ascii "fi\n" + .ascii "exit $R\n" + .endobj apesh + + .section .elf.phdrs,"a",@progbits + .align __SIZEOF_POINTER__ + .type ape.phdrs,@object + .globl ape.phdrs +ape.phdrs: + .long PT_LOAD # text segment + .long PF_R|PF_X + .stub .Lape.rom.offset,quad + .stub .Lape.rom.vaddr,quad + .stub .Lape.rom.paddr,quad + .stub .Lape.rom.filesz,quad + .stub .Lape.rom.memsz,quad + .stub .Lape.rom.align,quad + .align __SIZEOF_POINTER__ + .long PT_LOAD # data segment + .long PF_R|PF_W + .stub .Lape.ram.offset,quad + .stub .Lape.ram.vaddr,quad + .stub .Lape.ram.paddr,quad + .stub .Lape.ram.filesz,quad + .stub .Lape.ram.memsz,quad + .stub .Lape.ram.align,quad +/ Linux ignores mprotect() and returns 0 without this lool +/ It has nothing to do with the stack, which is still exec + .align __SIZEOF_POINTER__ + .long PT_GNU_STACK # p_type + .long PF_R|PF_W # p_flags + .quad 0 # p_offset + .quad 0 # p_vaddr + .quad 0 # p_paddr + .quad 0 # p_filesz + .quad 0 # p_memsz + .quad 16 # p_align + .align __SIZEOF_POINTER__ + .long PT_NOTE # openbsd note + .long PF_R + .stub .Lape.note.offset,quad + .stub .Lape.note.vaddr,quad + .stub .Lape.note.paddr,quad + .stub .Lape.note.filesz,quad + .stub .Lape.note.memsz,quad + .stub .Lape.note.align,quad + .previous + + .section .note.openbsd.ident,"a",@progbits +.Lopenbsd.ident: + .long 8 + .long 4 + .long 0x1 + .asciz "OpenBSD" + .long 0 + .size .Lopenbsd.ident,.-.Lopenbsd.ident + .type .Lopenbsd.ident,@object + .previous + +/* ▄▄███▄ + ▄▄████████▄ + ▄█████████████▄ + ▄▄███▓▓▓▓▓▓▓▓▓▓▓███▄ + ▄▄█████▓▓▓█████████▓▓▓██▄ + ▄▄████████▓▓▓███████▓▓▓▓▓████▄ + ▄█████░░░████▓▓█████▓▓▓▓█████████▄ + ▄▄█████████░░░███▓▓█▓▓▓▓▒███████▓▓▒███▄ + ▄██████████████░░░██▓▓▓▓███████████▓▓█████▄ + ██████████████████░░░██▓▓▓█████████▓▓▓███████▄ + ███░░░░░░█████████▓░░███▓▓▓▓▓▓▓▓▓▓▓█████▒▒▒██▄ + █░███░░░██░░░░░░░░░██░░██████████████▒▒▒▒██████▄ + ███████░░░█████████░░░░░░█████████▒▒▒▒▒██████████▄ + █████ ██░░░███████████████████▒▒▒▒▒██░▒▒██████████▄ + ██████ ██░░░██████████████░███▒████████▒▒██████████▄ + ████████ ███░░█████████████░░████████████▒▒███████████ + █████████ ███░░███████████░░██████████████▒▒███████████ + ▄██████████ ██████████████ ░░███████████████▒▒███████████ + ████████████ ███░░░░░█████░░█████████████████▒▒██████ █ + █████████████ ██████░░░░░░░▒█████████████████████ ████▀ + █████████████ ██████████░░░░░░░░░███████████ ████████ + █████████████ ████████░░███████░░░██████ ▓██████████ + █████████████ ██████░░░████████████ █████████████ +╔────────────────────────────────────────────────────────────────────────────│─╗ +│ αcτµαlly pδrταblε εxεcµταblε § nexstep carnegie melon mach object format ─╬─│┼ +╚────────────────────────────────────────────────────────────────────────────│─╝ + @note hey xnu before we get upx'd email feedback jtunney@gmail.com + @see OS X ABI Mach-O File Format Reference, Apple Inc. 2009-02-04 + @see System V Application Binary Interface NexGen32e Architecture + Processor Supplement, Version 1.0, December 5th, 2018 */ + +.section .macho,"a",@progbits +.align __SIZEOF_POINTER__ + +ape.macho: + .long 0xFEEDFACE+1 + .long MAC_CPU_NEXGEN32E + .long MAC_CPU_NEXGEN32E_ALL + .long MAC_EXECUTE + .long 5 # number of load commands + .long 60f-10f # size of all load commands + .long MAC_NOUNDEFS # flags + .long 0 # reserved +10: .long MAC_LC_SEGMENT_64 + .long 20f-10b # unmaps first page dir + .ascin "__PAGEZERO",16 # consistent with linux + .quad 0,0x200000,0,0 # which forbids mem <2m + .long 0,0,0,0 +20: .long MAC_LC_SEGMENT_64 + .long 30f-20b + .ascin "__TEXT",16 + .stub .Lape.rom.vaddr,quad + .stub .Lape.rom.memsz,quad + .stub .Lape.rom.offset,quad + .stub .Lape.rom.filesz,quad + .long PROT_EXEC|PROT_READ|PROT_WRITE # maxprot + .long PROT_EXEC|PROT_READ # initprot + .long 1 # segment section count + .long 0 # flags +210: .ascin "__text",16 # section name (.text) + .ascin "__TEXT",16 + .stub .Lape.text.vaddr,quad + .stub .Lape.text.memsz,quad + .stub .Lape.text.offset,long + .long 12 # align 2**12 = 4096 + .long 0 # reloc table offset + .long 0 # relocation count + .long MAC_S_ATTR_SOME_INSTRUCTIONS # section type & attributes + .long 0,0,0 # reserved +30: .long MAC_LC_SEGMENT_64 + .long 40f-30b + .ascin "__DATA",16 + .stub .Lape.ram.vaddr,quad + .stub .Lape.ram.memsz,quad + .stub .Lape.ram.offset,quad + .stub .Lape.ram.filesz,quad + .long PROT_EXEC|PROT_READ|PROT_WRITE # maxprot + .long PROT_READ|PROT_WRITE # initprot + .long 2 # segment section count + .long 0 # flags +310: .ascin "__data",16 # section name (.data) + .ascin "__DATA",16 + .stub .Lape.data.vaddr,quad + .stub .Lape.data.memsz,quad + .stub .Lape.data.offset,long + .long 12 # align 2**12 = 4096 + .long 0 # reloc table offset + .long 0 # relocation count + .long 0 # section type & attributes + .long 0,0,0 # reserved +320: .ascin "__bss",16 # section name (.bss) + .ascin "__DATA",16 + .stub .Lape.bss.vaddr,quad # virtual address + .stub .Lape.bss.memsz,quad # memory size + .long 0 # file offset + .long 12 # align 2**12 = 4096 + .long 0 # reloc table offset + .long 0 # relocation count + .long MAC_S_ZEROFILL # section type & attributes + .long 0,0,0 # reserved +40: .long MAC_LC_UUID + .long 50f-40b + .stub uuid1_,quad + .stub uuid2_,quad +50: .long MAC_LC_UNIXTHREAD + .long 60f-50b # cmdsize + .long MAC_THREAD_NEXGEN32E # flavaflav + .long (520f-510f)/4 # count +510: .quad 0 # rax + .quad IMAGE_BASE_VIRTUAL # rbx + .quad 0 # rcx + .quad 0 # rdx + .quad 0 # rdi + .quad 0 # rsi + .quad 0 # rbp + .quad 0 # rsp + .quad 0 # r8 + .quad 0 # r9 + .quad 0 # r10 + .quad 0 # r11 + .quad 0 # r12 + .quad 0 # r13 + .quad 0 # r14 + .quad 0 # r15 + .quad _start_xnu # rip + .quad 0 # rflags + .quad 0 # cs + .quad 0 # fs + .quad 0 # gs +520: +60: + +.endobj ape.macho,globl,hidden +.previous /* .macho */ + +/* ░░░░ + ▒▒▒░░░▒▒▒▒▒▒▒▓▓▓░ + ▒▒▒▒░░░▒▒▒▒▒▒▓▓▓▓▓▓░ + ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓ ▒▓░ + ▒▒▒░░░░▒▒▒▒▒▒▓▓▓▓▓▓ ▓▓▓▓▓▓▒ ▒▒▒▓▓█ + ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓ ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓ + ░▒▒▒░░░░▒▒▒▒▒▒▓▓▓▓▓▓ █▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█ + ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓░ ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓ + ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓ ▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒ + ▒▒▒▒▓▓ ▓▒▒▓▓▓▓ ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█ + ▒▓ ▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓ + ░░░░░░░░░░░▒▒▒▒ ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█ + ▒▒░░░░░░░░░░▒▒▒▒▒▓▓▓ ▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓ + ░▒░░░░░░░░░░░▒▒▒▒▒▓▓ ▓░ ░▓███▓ + ▒▒░░░░░░░░░░▒▒▒▒▒▓▓░ ▒▓▓▓▒▒▒ ░▒▒▒▓ ████████████ + ▒▒░░░░░░░░░░░▒▒▒▒▒▓▓ ▒▓▓▓▓▒▒▒▒▒▒▒▒░░░▒▒▒▒▒░ ░███ + ▒░░░░░░░░░░░▒▒▒▒▒▓▓ ▓▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▓ ███ + ▒▒░░░░░░░░░░▒▒▒▒▒▒▓▓ ▒▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▒ ▓██ + ▒░░░░░░░░░░░▒▒▒▒▒▓▓ ▓▓▓▓▒▒▒▒▒▒▒▒░░░▒▒▒▒▒▓ ▓██ + ▒▒░░░▒▒▒░░░▒▒░▒▒▒▓▓▒ ▒▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▒ ███ + ░▒▓ ░▓▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▓ ▓██ +╔─────────────────────────────────────────────────────────────────▀▀▀────────│─╗ +│ αcτµαlly pδrταblε εxεcµταblε § the new technology ─╬─│┼ +╚────────────────────────────────────────────────────────────────────────────│─╝ + The Portable Executable Format + + @see https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format + @see "The Portable Executable File Format from Top to Bottom", + Randy Kath, Microsoft Developer Network Technology Group. */ + +/ ┌14:Uniprocessor Machine ┌─────────────────────────┐ +/ │┌13:DLL │ PE File Characteristics │ +/ ││┌12:System ├─────────────────────────┤ +/ │││┌11:If Net Run From Swap │ r │ reserved │ +/ ││││┌10:If Removable Run From Swap │ d │ deprecated │ +/ │││││┌9:Debug Stripped │ D │ deprecated with │ +/ ││││││┌8:32bit Machine │ │ extreme prejudice │ +/ │││││││ ┌5:Large Address Aware └───┴─────────────────────┘ +/ │││││││ │ ┌1:Executable +/ │││││││ │ │┌0:Relocs Stripped +/ d│││││││dr│Ddd││ +.LPEEXE = 0b0000001000100011 + +/ ┌15:TERMINAL_SERVER_AWARE ┌─────────────────────────┐ +/ │┌14:GUARD_CF │ PE DLL Characteristics │ +/ ││┌13:WDM_DRIVER ├─────────────────────────┤ +/ │││┌12:APPCONTAINER │ r │ reserved │ +/ ││││┌11:NO_BIND └───┴─────────────────────┘ +/ │││││┌10:NO_SEH +/ ││││││┌9:NO_ISOLATION +/ │││││││┌8:NX_COMPAT +/ ││││││││┌7:FORCE_INTEGRITY +/ │││││││││┌6:DYNAMIC_BASE +/ ││││││││││┌5:HIGH_ENTROPY_VA +/ │││││││││││rrrrr +.LDLLSTD = 0b0000000100100000 +.LDLLPIE = 0b0000000001000000 +.LDLLEXE = .LDLLSTD + +/ ┌31:Writeable ┌─────────────────────────┐ +/ │┌30:Readable │ PE Section Flags │ +/ ││┌29:Executable ├─────────────────────────┤ +/ │││┌28:Shareable │ o │ for object files │ +/ ││││┌27:Unpageable │ r │ reserved │ +/ │││││┌26:Uncacheable └───┴─────────────────────┘ +/ ││││││┌25:Discardable +/ │││││││┌24:Contains Extended Relocations +/ ││││││││ ┌15:Contains Global Pointer (GP) Relative Data +/ ││││││││ │ ┌7:Contains Uninitialized Data +/ ││││││││ │ │┌6:Contains Initialized Data +/ ││││││││ o │ ││┌5:Contains Code +/ ││││││││┌┴─┐rrrr│ ooror│││rorrr +.LPETEXT = 0b01110000000000000000000001100000 +.LPEDATA = 0b11000000000000000000000011000000 +.LPEIMPS = 0b11000000000000000000000001000000 + + .section .pe.header,"a",@progbits + .align __SIZEOF_POINTER__ +ape.pe: .ascin "PE",4 + .short kNtImageFileMachineNexgen32e + .stub .Lape.pe.shnum,short # NumberOfSections + .long 0x5c64126b # TimeDateStamp + .long 0 # PointerToSymbolTable + .long 0 # NumberOfSymbols + .stub .Lape.pe.optsz,short # SizeOfOptionalHeader + .short .LPEEXE # Characteristics + .short kNtPe64bit # Optional Header Magic + .byte 14 # MajorLinkerVersion + .byte 15 # MinorLinkerVersion + .long 0 # SizeOfCode + .long 0 # SizeOfInitializedData + .long 0 # SizeOfUninitializedData + .long RVA(WinMain) # EntryPoint + .long 0 # BaseOfCode + .quad IMAGE_BASE_VIRTUAL # ImageBase + .long 4096 # SectionAlignment + .long 4096 # FileAlignment + .short 6 # MajorOperatingSystemVersion + .short 0 # MinorOperatingSystemVersion + .short 0 # MajorImageVersion + .short 0 # MinorImageVersion + .short 6 # MajorSubsystemVersion + .short 0 # MinorSubsystemVersion + .long 0 # Win32VersionValue + .long RVA(_end) # SizeOfImage + .long RVA(_ehead) # SizeOfHeaders + .long 0 # Checksum + .short v_ntsubsystem # Subsystem: 0=Neutral,2=GUI,3=Console + .short .LDLLEXE # DllCharacteristics + .quad 0x0000000000100000 # StackReserve + .quad 0x0000000000030000 # StackCommit (64kb [goog] + arg + env) + .quad 0x0000000000080000 # HeapReserve + .quad 0x0000000000001000 # HeapCommit (we make our own heap) + .long 0x00000000 # LoaderFlags + .long 16 # NumberOfDirectoryEntries + .long 0,0 # ExportsDirectory + .long RVA(idata.idt) # ImportsDirectory + .stub .Lidata.idtsize,long # ImportsDirectorySize + .long 0,0 # ResourcesDirectory + .long 0,0 # ExceptionsDirectory + .long 0,0 # SecurityDirectory + .long 0,0 # BaseRelocationTable + .long 0,0 # DebugDirectory + .long 0,0 # DescriptionString + .long 0,0 # MachineSpecific + .long 0,0 # ThreadLocalStorage + .long 0,0 # LoadConfigurationDirectory + .long 0,0 # BoundImportDirectory + .long RVA(idata.iat) # ImportAddressDirectory + .stub .Lidata.iatsize,long # ImportAddressDirectorySize + .long 0,0 # DelayImportDescriptor + .long 0,0 # ComPlusRuntimeHeader + .long 0,0 # Reserved + .endobj ape.pe,globl + .previous + + .section .pe.sections,"a",@progbits + .ascin ".text",8 # Section Name + .stub .Lape.text.memsz,long # Virtual Size or Physical Address + .stub .Lape.text.rva,long # Relative Virtual Address + .stub .Lape.text.filesz,long # Physical Size + .stub .Lape.text.offset,long # Physical Offset + .long 0x00000000 # Relocation Table Offset + .long 0x00000000 # Line Number Table Offset + .short 0x0000 # Relocation Count + .short 0x0000 # Line Number Count + .long .LPETEXT # Flags + .previous + + .section .pe.sections,"a",@progbits + .ascin ".data",8 # Section Name + .stub .Lape.ram.memsz,long # Virtual Size or Physical Address + .stub .Lape.ram.rva,long # Relative Virtual Address + .stub .Lape.ram.filesz,long # Physical Size + .stub .Lape.ram.offset,long # Physical Offset + .long 0x00000000 # Relocation Table Offset + .long 0x00000000 # Line Number Table Offset + .short 0x0000 # Relocation Count + .short 0x0000 # Line Number Count + .long .LPEDATA # Flags + .previous + + .section .idata.ro.idt.1,"a",@progbits + .type idata.idtend,@object + .type idata.idt,@object + .globl idata.idt,idata.idtend + .hidden idata.idt,idata.idtend +idata.idt: + .previous/* + ... + decentralized content + ... + */.section .idata.ro.idt.3,"a",@progbits + .long 0,0,0,0,0 +idata.idtend: + .previous + + .section .piro.data.sort.iat.1,"aw",@progbits + .type idata.iatend,@object + .type idata.iat,@object + .globl idata.iat,idata.iatend + .hidden idata.iat,idata.iatend +idata.iat: + .previous/* + ... + decentralized content + ... + */.section .piro.data.sort.iat.3,"aw",@progbits +idata.iatend: + .previous + +/*─────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § early-stage read-only data │ +╚──────────────────────────────────────────────────────────────────────────────╝ + better code/data separation (.head is rwx[real] rx[long]) */ + +/ NUL-Terminated Strings. +ape.str: +.Lstr.ape: + .byte 0xe0,0x63,0xe7,0xe6,0xe0,0x6c,0x6c,0x79 #αcτµαlly + .byte 0x20,0x70,0xeb,0x72,0xe7,0xe0,0x62,0x6c # pδrταbl + .byte 0xee,0x20,0xee,0x78,0xee,0x63,0xe6,0xe7 #ε εxεcµτ + .byte 0xe0,0x62,0x6c,0xee,0x0d,0x0a,0x00 #αblε. + .endobj .Lstr.ape +.Lstr.error: + .asciz "error: " + .endobj .Lstr.error +.Lstr.crlf: + .asciz "\r\n" + .endobj .Lstr.crlf +.Lstr.cpuid: + .asciz "cpuid" + .endobj .Lstr.cpuid +.Lstr.oldskool: + .asciz "oldskool" + .endobj .Lstr.oldskool +.Lstr.dsknfo: + .asciz "dsknfo" + .endobj .Lstr.dsknfo +.Lstr.e820: + .asciz "e820" + .endobj .Lstr.e820 +.Lstr.memory: + .asciz "nomem" + .endobj .Lstr.memory +.Lstr.long: + .asciz "nolong" + .endobj .Lstr.long +.Lstr.hello: + .asciz "hello\n" + .endobj .Lstr.hello + .endobj ape.str + +/ Serial Line Configuration (8250 UART 16550) +/ If it's hacked, it'll at least get hacked very slowly. +sconf: .short 1843200/*hz*/ / 16/*wut*/ / 9600/*baud*/ +/ +/ ┌interrupt trigger level {1,4,8,14} +/ │ ┌enable 64 byte fifo (UART 16750+) +/ │ │ ┌select dma mode +/ │ │ │┌clear transmit fifo +/ │ │ ││┌clear receive fifo +/ ├┐│ │││┌enable fifos + .byte 0b00000000 +/ +/ ┌dlab: flips configuration mode state +/ │┌enable break signal +/ ││ ┌parity {none,odd,even,high,low} +/ ││ │ ┌extra stop bit +/ ││ │ │┌data word length (bits+5) +/ ││┌┴┐│├┐ + .byte 0b01000011 + .endobj sconf,global,hidden + +/ Global Descriptor Table +/ +/ @note address portion only concern legacy modes + .align 8 +gdt: .short 2f-1f # table byte length + .long REAL(1f),0 # table address + .align 8 +1: +/ ┌G:granularity (1 → limit *= 0x1000) +/ │┌D/B:default operation size (0 = 16|64bit, 1 = 32-bit) +/ ││┌L:long mode +/ │││┌AVL:this bit is thine (1<<52) +/ ││││ ┌P:present +/ ││││ │┌DPL:privilege +/ ││││ ││ ┌─────────data/code(1) +/ ││││ ││ │┌────data(0)──────code(1) +/ ││││ ││ ││┌───conforming───expand-down +/ ││││ ││ │││┌──writeable────readable +/ ││││ ││ ││││┌─accessed─────accessed +/ ││││ ││ │││││ +/ ││││ ┌──││─│││││───────────────────────────────┐ +/ ┌───││││─│──││─│││││───────────┐ │ +/ ┌───┴──┐││││┌┴─┐│├┐│││││┌──────────┴───────────┐┌──────┴───────┐ +/ │ ││││││ ││││││││││ base address││ segment limit│ +/ │ ││││││ ││││││││││ 32 bits││ 20 bits│ +/ │ ││││││ ││││││││││ ││ │ +/ 6666555555555544444444443333333333222222222211111111110000000000 +/ 3210987654321098765432109876543210987654321098765432109876543210 +/ │ ││││││ ││││││││││ ││ │ +.quad 0b0000000000000000000000000000000000000000000000000000000000000000 # 0 +.quad 0b0000000000001111100110100000000000000000000000001111111111111111 # 8 +.quad 0b0000000000001111100100100000000000000000000000001111111111111111 #16 +.quad 0b0000000011001111100110100000000000000000000000001111111111111111 #24 +.quad 0b0000000011001111100100100000000000000000000000001111111111111111 #32 +.quad 0b0000000010101111100110110000000000000000000000001111111111111111 #40 +.quad 0b0000000010101111100100110000000000000000000000001111111111111111 #48 +2: .endobj gdt,global,hidden + +/*─────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § multiboot stub │ +╚──────────────────────────────────────────────────────────────────────────────╝ + boot modernized for the nineties */ + +#define GRUB_MAGIC 0x1BADB002 +#define GRUB_EAX 0x2BADB002 +#define GRUB_AOUT (1 << 16) +#define GRUB_CHECKSUM(FLAGS) (-(GRUB_MAGIC + (FLAGS)) & 0xffffffff) + +/ Grub Header. + .align 4 +ape.grub: + .long GRUB_MAGIC # Magic + .long GRUB_AOUT # Flags + .long GRUB_CHECKSUM(GRUB_AOUT) # Checksum + .long RVA(ape.grub) # HeaderPhysicalAddress + .long IMAGE_BASE_PHYSICAL # TextPhysicalAddress + .long PHYSICAL(_edata) # LoadEndPhysicalAddress + .long PHYSICAL(_end) # BssEndPhysicalAddress + .long RVA(ape.grub.entry) # EntryPhysicalAddress + .endobj ape.grub,globl,hidden + +/ Grub Entrypoint. +/ Takes CPU out of legacy mode and jumps to normal entrypoint. +/ @noreturn + .align 4 +ape.grub.entry: + .code32 + cmp $GRUB_EAX,%eax + jne triplf + push $0 + popf + mov $0x40,%dl + mov %cr0,%eax + and $~CR0_PE,%eax + mov %eax,%cr0 + ljmpw $0,$REAL(pc) + .code16 + .endfn ape.grub.entry + +/*─────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § real mode │ +╚──────────────────────────────────────────────────────────────────────────────╝ + the default mode of operation on modern cpus */ + + nop + nop + nop + nop +realmodeloader: + push %bp + mov %sp,%bp + call rlinit + call sinit4 + mov $VIDYA_MODE,%di + mov %es,XLM(VIDEO_POSITION_FAR_POINTER) + mov %ax,XLM(VIDEO_POSITION_FAR_POINTER)+2 + call vinit + mov $REAL(.Lstr.ape),%di + call rvputs + .optfn _start16 + call _start16 + call longmodeloader + .endfn realmodeloader,globl,hidden + + .section .sort.text.real.init.1,"ax",@progbits + .type rrinit,@function +rlinit: push %bp + mov %sp,%bp + .previous/* + ... + decentralized function + ... + */.section .sort.text.real.init.3,"ax",@progbits + pop %bp + ret + .previous + +/ Initializes present PC serial lines. +sinit4: push %bp + mov %sp,%bp + movw $4,%cx + movw $kBiosDataAreaXlm+COM1,%si +0: lodsb + mov %al,%dl + lodsb + mov %al,%dh + test %dx,%dx + jz 1f + push %cx + push %si + mov %dx,%di + movw $REAL(sconf),%si + call sinit + pop %si + pop %cx +1: loop 0b + pop %bp + ret + .endfn sinit4,global,hidden + +/ Initializes Serial Line Communications 8250 UART 16550A +/ +/ @param word di tty port +/ @param char (*{es:,e,r}si)[4] register initial values +/ @mode long,legacy,real +/ @see www.lammertbies.nl/comm/info/serial-uart.html +sinit: push %bp + mov %sp,%bp + mov %di,%dx + test %dx,%dx + jz 2f + push %dx + push %si + xorw %cx,%cx + mov $UART_LCR,%cl + add %cx,%dx + lodsb %ds:(%si),%al + pop %si + or $UART_DLAB,%al + out %al,%dx + pop %dx +1: lodsb %ds:(%si),%al + out %al,%dx + add $1,%dx + sub $1,%cx + jns 1b +2: pop %bp + ret + .endfn sinit,global,hidden + +/ Abnormally exits program. +/ +/ @param di message +/ @mode real +/ @noreturn +rldie: push %bp + mov %sp,%bp + call rlpute + call rloff + .endfn rldie,globl,hidden + +/ Shuts down machine. +/ +/ @mode real +/ @noreturn +rloff: push %bp + mov %sp,%bp + mov $kBiosDataAreaXlm+COM1,%di + mov $4,%si + call sflush + call apmoff + .endfn rloff,globl,hidden + +/ Prints error message. +/ +/ @param di message +/ @mode real +rlpute: push %bp + mov %sp,%bp + mov kBiosDataAreaXlm+METAL_STDERR(%bx),%si + test %si,%si + jnz 1f + mov kBiosDataAreaXlm+METAL_STDOUT,%si +1: xor %ax,%ax + push %ax + push %si + mov $REAL(.Lstr.crlf),%ax + push %ax + push %si + push %di + push %si + mov $REAL(.Lstr.error),%ax + push %ax +1: pop %di + test %di,%di + jz 2f + pop %si + call rlput2 + jmp 1b +2: pop %bp + ret + .endfn rlpute,globl,hidden + +/ Prints string to both video and serial. +/ +/ @param di NUL-terminated string +/ @param si serial port +/ @mode real +rlput2: push %bp + mov %sp,%bp + push %di + push %si + call rvputs + pop %si + pop %di + test %si,%si + jz 1f + call sputs +1: pop %bp + ret + .endfn rlput2,globl,hidden + +/ Video put string. +/ +/ @param di is the string +/ @mode real +rvputs: push %bp + mov %sp,%bp + mov %di,%si + les XLM(VIDEO_POSITION_FAR_POINTER),%di + call vputs + mov %es,XLM(VIDEO_POSITION_FAR_POINTER) + mov %ax,XLM(VIDEO_POSITION_FAR_POINTER)+2 + pop %bp + ret + .endfn rvputs,globl,hidden + +/ Writes string to serial line. +/ +/ @param di NUL-terminated string +/ @param si serial port +/ @mode long,legacy,real +sputs: push %bp + mov %sp,%bp + push %bx + mov %di,%bx +1: xchg %bx,%si + lodsb + xchg %bx,%si + test %al,%al + jz 2f + mov %ax,%di + push %si + rlcall sputc + pop %si + jmp 1b +2: pop %bx + pop %bp + ret + .endfn sputs,globl + +/ Waits for serial lines to become idle. +/ +/ @param di short array of serial ports (0 means not present) +/ @param si number of items in array +/ @mode long,legacy,real +sflush: mov %si,%cx + mov %di,%si + xor %dx,%dx +0: lodsb + mov %al,%dl + lodsb + mov %al,%dh + test %ax,%ax + jz 2f + add $UART_LSR,%dx + mov $UART_TTYIDL,%ah +1: in %dx,%al + and %ah,%al + rep nop # todo(jart): interrupts are better + jz 1b + loop 0b +2: ret + .endfn sflush,globl + +/ Transmits byte over serial line. +/ +/ This is both blocking and asynchronous. +/ +/ @param di character to send +/ @param si serial port +/ @mode long,legacy,real +/ @see ttytxr +sputc: push %ax + push %cx + push %dx + mov %si,%dx + add $UART_LSR,%dx + mov $UART_TTYTXR,%ah +1: in %dx,%al + and %ah,%al + jnz 2f + rep nop # todo(jart): interrupts are better + jmp 1b +2: mov %di,%ax + mov %si,%dx + out %al,%dx + pop %dx + pop %cx + pop %ax + ret + .endfn sputc,globl + +/ Asks BIOS to initialize MDA/CGA display w/o cursor/blinking. +/ +/ @param dil video mode +/ @return es:ax start of video page +/ @mode real +vinit: push %bp + mov %sp,%bp + push %bx + bbmov VIDYA_ADDR_CGA>>4,%ax,%ah,%al + mov %ax,%es + mov %di,%ax + cmp $VIDYA_MODE_CGA,%al + je 1f + xor %ch,%ch # aka movesdi VIDYA_ADDR_MDA +1: xor %di,%di + bbmov VIDYA_SET_MODE,%ax,%ah,%al + int $VIDYA_SERVICE + bbmov VIDYA_SET_CURSOR,,%ah,%al + bbmov VIDYA_SET_CURSOR_NONE,,%ch,%cl # since we don't support it + int $VIDYA_SERVICE + bbmov VIDYA_SET_BLINKING,,%ah,%al # ← cargo culting (ega?) + bbmov VIDYA_SET_BLINKING_NONE,,%bh,%bl + int $VIDYA_SERVICE + xor %ax,%ax + pop %bx + pop %bp + ret + .endfn vinit,globl + +/ Prints byte to display w/ teletype emulation. +/ +/ @param es:di screen position +/ @param sil byte +/ @return es:ax new screen position +/ @mode long,legacy,real +vputc: push %bp + mov %sp,%bp + sub $16,%sp # goal is to turn sil into a buffer + xchg %si,%ax # modrm sooo different in real mode + mov %di,%cx + mov %sp,%si + mov %sp,%di + stosb + mov %cx,%di + pushpop 1,%dx + jmp 23f + +/ Prints string to display w/ teletype emulation. +/ +/ @param es:di screen position +/ @param si NUL-terminated string +/ @return es:ax new screen position +/ @mode long,legacy,real +vputs: push %si # inlined strlen +1: lodsb + test %al,%al + jnz 1b + mov %si,%dx + pop %si + sub %si,%dx +/ fallthrough + +/ Prints data to display w/ teletype emulation. +/ +/ @param es:di screen position +/ @param si data address +/ @param dx data size in bytes +/ @return es:ax new screen position +/ @mode long,legacy,real +vtput: push %bp + mov %sp,%bp +23: push %bx + mov %dx,%cx + mov %di,%dx + bband VIDYA_REWIND,%dh,%dl + bbadd VIDYA_SIZE,%dh,%dl + bbmov VIDYA_COLUMNS*2,%bx,%bh,%bl +0: cmp %di,%dx + je 6f + ja 3f + lodsb # todo: utf8 → cp437 + cmp $'\n,%al + je 4f + cmp $'\r,%al + je 5f +1: stosb + mov $VIDYA_ATTR_NORMAL,%al # todo: ansi color + stosb +2: loop 0b +3: mov %di,%ax + pop %bx + pop %bp + ret +4: add %bx,%di # line feed + jmp 2b +5: mov %di,%ax # carriage return + push %dx + xor %dx,%dx + idiv %bx # todo: division is deprecated + sub %dx,%di + pop %dx + jmp 2b +6: push %ax + push %cx + push %dx + push %si + mov %bx,%si + rlcall vscroll + mov %ax,%di + pop %si + pop %dx + pop %cx + pop %ax + jmp 2b + .endfn vtput,globl + .endfn vputs,globl + .endfn vputc,globl + +/ Scrolls up content in display page. +/ +/ @param es:di cursor address (bytes after aren't moved) +/ @param si byte difference, e.g. VIDYA_COLUMNS*2 +/ @return es:ax new cursor address (which is es:di-si) +/ @mode long,legacy,real +vscroll:not %dx + mov %di,%cx + bband VIDYA_REWIND,%ch,%cl + xchg %cx,%di # di is now page addr, i.e. top-left + sub %si,%cx # cx is now future cursor address + push %cx + sub %di,%cx # cx is now memcpy size + mov %di,%si + add %cx,%si + mov $0,%ax + movpp %ds,%es + rep movsb + pop %ax + ret + .endfn vscroll,globl + +/ Shuts down personal computer. +/ +/ @mode real +/ @noreturn +apmoff: push %bp + mov %sp,%bp + mov $0x5300,%ax # apm installation check + xor %bx,%bx # for the apm bios itself + int $APM_SERVICE + jc 1f + cmp $'P<<8|'M,%bx # did apm bios service interrupt? + jne 1f + mov $0x5301,%ax # real mode interface connect + xor %bx,%bx # to apm bios device + int $APM_SERVICE # ignore errors e.g. already connected + xor %bx,%bx + xor %cx,%cx + mov $0x5307,%ax # set power state + mov $1,%bl # for all devices within my dominion + mov $3,%cl # to off + int $APM_SERVICE +1: call panic + .endfn apmoff,globl + +/* █ █▒ + █ █ + █▓▄ █ █ + ▒▓ ░█░ ░▒▓▓███░ █▒ + ▒▓ ▒▓███▓▒░ ░▓ + █ ▓░ + ▄██░ █ + ▓▓ ▓██░ ▓█░▓█ ▒▓ + ▒█ ░█ █ ░▓ █ █ + █░ █ ░▓ ▀▒ █░ █ + █▒ ▀▒░ ▓▓ + ▄▄▄▓████▓▓▒░ █ ▄▄▄▄▓▓▓█▓▓▓▓▒░ ▒█ + ▄▓▓▀ ▒ ░█ ▄▓▀ ░███▒ + ▓▀ ░░ ▀▓▄▄▄▒▒ █ + █ ░░█▒ ▒█ ▒▓ █ + ▀█ ▄▄▄▄▄▄▄▄▄▄ ▀▀░▓██▓ █ + ▀■▄▄▄■▀ ▀▀█▄ █ + ▀▀█▄ █ + ▀█▄ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ + █▌ █ +╔──────────────────────────────────────────────────────────────────────────▀─│─╗ +│ αcτµαlly pδrταblε εxεcµταblε § long mode loader ─╬─│┼ +╚────────────────────────────────────────────────────────────────────────────│─╝ + long mode is long */ + +longmodeloader: + push %bp + mov %sp,%bp + call lcheck + call a20 + mov $XLM(E820),%di + mov $XLM_E820_SIZE,%si + call e820 + jc 9f + call unreal + call hiload + call golong +9: mov $REAL(.Lstr.e820),%ax + call rldie + .endfn longmodeloader,globl,hidden + +/ Long Mode Hardware Check +lcheck: push %bp + mov %sp,%bp + pushfw # check for i8086 / i8088 / i80186 + pop %ax + and $0b111<<12,%ax # see intel manual volume 1 §19.1.2 + jnz 9f + pushfl # now check for later model of 80486 + pop %eax # test ability to *change* cpuid bit + mov %eax,%ecx + mov $1<<21,%ebx + xor %ebx,%eax + push %eax + popfl + pushfl + pop %eax + cmp %eax,%ecx + je 12f + and %ebx,%eax # puts cpuid bit in the on position + push %eax + popfl + mov $0x80000000,%edi # get amd ext cpuid thingy length + mov %edi,%eax + inc %edi + cpuid # clobbers eax, ebx, ecx, and edx + cmp %edi,%eax + jl 10f + mov %edi,%eax + cpuid + mov $1<<29/*LM*/,%edi # check for nexgen32e support + and %edi,%edx + cmp %edi,%edx + jne 10f + xor %ax,%ax +1: pop %bp + ret +9: mov $REAL(.Lstr.oldskool),%ax + jmp 20f +10: mov $REAL(.Lstr.long),%ax + jmp 20f +12: mov $REAL(.Lstr.cpuid),%ax + jmp 20f +20: call rldie + .endfn lcheck + +/ Gets memory map from BIOS. +/ +/ @param di paragraph aligned buffer +/ @param si bytes in buffer to fill +/ @return number of bytes written or CF on error +/ @mode real +e820: push %bp + mov %sp,%bp + pushl $'S<<24|'M<<16|'A<<8|'P # magic @ -4(%bp) + push %bx + shr $4,%di + mov %di,%es + xor %edi,%edi # es:di is destination buffer + xor %ebx,%ebx # ebx is an api state tracker +1: mov $0xE820,%eax # magic + mov $8+8+4+4,%ecx # sizeof(struct SmapEntry) + mov -4(%bp),%edx # magic + int $0x15 # ax,bx,cx,dx,di → ax,bx,cx + jc 9f # cf = unsupported or abuse + cmp -4(%bp),%eax # more magic means success + jne 9f + test %cx,%cx # discard empty results + jz 5f + cmp $8+8+4+1,%cx # discard if ignore flag + jb 4f + testb $1/*ignore*/,8+8+4/*SmapEntry::__acpi3*/(%di) + jnz 5f +4: add $8+8+4+4,%di # keep entry +5: test %ebx,%ebx # last entry? + jz 7f + cmp %si,%di # out of buf? + jb 1b +7: mov %di,%ax +8: pop %bx + leave + ret +9: stc + jmp 8b + .endfn e820,globl,hidden + +/ Unreal Mode. +/ Makes 4gb of real memory accessible via %fs segment. +unreal: push %bp + mov %sp,%bp + cli + lgdt REAL(gdt) + mov %cr0,%eax + or $CR0_PE,%al + mov %eax,%cr0 + jmp 1f +1: mov $GDT_LEGACY_DATA,%cx + mov %cx,%fs + and $~CR0_PE,%al + mov %eax,%cr0 + ljmpl $0,$REAL(1f) +1: sti + pop %bp + ret + .endfn unreal + +/ Loads remainder of executable off disk. +hiload: push %bp + mov %sp,%bp + push %bx + mov $IMAGE_BASE_REAL,%esi # relocate, again + mov $IMAGE_BASE_PHYSICAL,%ebx + mov $v_ape_realsectors,%ecx + shl $9,%ecx + or $-4,%edx +0: add $4,%edx + cmp %edx,%ecx + je 1f + mov %fs:(%esi,%edx),%eax + mov %eax,%fs:(%ebx,%edx) + jmp 0b +1: lea (%ebx,%edx),%ebx + mov $v_ape_highsectors,%di # then copy rest off disk + mov $REAL_SCRATCH_AREA>>4,%ax # to real memory buffer + mov %ax,%es + mov XLM(LOADSTATE)+0,%cx + mov XLM(LOADSTATE)+2,%dx +0: test %di,%di + jz 9f + mov %di,%ax + push %bx + xor %bx,%bx + call pcread + pop %bx + sub %ax,%di + push %cx + mov %ax,%cx # copy real buffer to high + shl $9,%cx # no way bios loaded >64k + xor %si,%si +1: mov %es:(%si),%eax + mov %eax,%fs:(%ebx) + add $4,%ebx + add $4,%si + sub $4,%cx + jnz 1b + pop %cx + jmp 0b +9: pop %bx + pop %bp + ret + .endfn hiload + +/ Asks keyboard to grant system 65,519 more bytes of memory. +/ +/ Yup. +/ +/ @assume realmode && df=0 +/ @clob ax,di,si,es,flags +/ @mode real +/ @see wiki.osdev.org/A20_Line +a20: cli + push %ds + xor %ax,%ax + mov %ax,%es + dec %ax + mov %ax,%ds + mov $0x0500,%di + mov $0x0510,%si + mov %es:(%di),%al + push %ax + mov %ds:(%si),%al + push %ax + movb $0x00,%es:(%di) + movb $0xff,%ds:(%si) + cmpb $0xff,%es:(%di) + pop %ax + mov %al,%ds:(%si) + pop %ax + mov %al,%es:(%di) + pop %ds + jne 3f + mov $1,%ax + call 1f + mov $0xad,%al + out %al,$0x64 + call 1f + mov $0xd0,%al + out %al,$0x64 + call 2f + in $0x60,%al + push %ax + call 1f + mov $0xd1,%al + out %al,$0x64 + call 1f + pop %ax + or $2,%al + out %al,$0x60 + call 1f + mov $0xae,%al + out %al,$0x64 + call 1f + jmp a20 +1: in $0x64,%al + test $2,%al + jnz 1b + ret +2: in $0x64,%al + test $1,%al + jz 2b + ret +3: sti +5: ret + .endfn a20,globl,hidden # obj since waste of objdump space + +/ Initializes long mode paging. +/ +/ Modern computers access memory via four levels of indirection: +/ +/ register char (*(*(*(*ram)[512])[512])[512])[4096] asm(cr3) +/ +/ Your page tables grow down in memory, starting from the real +/ stack segment base. This function only defines enough tables +/ to get us started. +#define TIP REAL_STACK_FRAME +pinit: push %bp + mov %sp,%bp + push %ds + mov $(TIP-0x4000)>>4,%ax + mov %ax,%ds + movl $TIP-0x2000+PAGE_V+PAGE_RW,%ds:0x3000 # PML4T→PDPT + movl $TIP-0x3000+PAGE_V+PAGE_RW,%ds:0x2000 # PDPT→PDT + movl $TIP-0x4000+PAGE_V+PAGE_RW,%ds:0x1000 # PDT→PD + mov $0x100000/0x1000,%cx # PD→512kb + mov $PAGE_V+PAGE_RW,%eax + xor %si,%si +0: mov %eax,%ds:(%si) + add $0x1000,%eax + add $8,%si + loop 0b + pop %ds + movl $TIP-0x4000,XLM(PAGE_TABLE_STACK_POINTER) # STACK→XLM + mov $TIP-0x1000,%eax # PML4T→CR3 + mov %eax,%cr3 + pop %bp + ret + .endfn pinit,globl,hidden + +/ Switch from Real Mode → Long Mode +/ +/ @see Intel Manual V3A §4.1.2 +golong: cli + lidt XLM(BADIDT) + call pinit + mov %cr4,%eax + or $CR4_PAE|CR4_PGE|CR4_OSFXSR,%eax + mov %eax,%cr4 + movl $EFER,%ecx + rdmsr + or $EFER_LME|EFER_SCE,%eax + wrmsr + lgdt REAL(gdt) + mov %cr0,%eax + or $CR0_PE|CR0_PG|CR0_MP,%eax + and $~CR0_EM,%eax + mov %eax,%cr0 + ljmp $GDT_LONG_CODE,$REAL(1f) + .code64 +1: mov $GDT_LONG_DATA,%eax + mov %ax,%ds + mov %ax,%fs + mov %ax,%gs + xor %edx,%edx + jmp long + .endfn golong + +/ Long mode is long. +/ +/ @noreturn +long: .frame0 + xor %edi,%edi + call pageunmap + + mov $e820map_xlm,%edi + call smapsort + + mov $e820map_xlm,%edi + mov $g_pml4t,%esi + mov $g_ptsp_xlm,%edx + call flattenhighmemory + + mov $REAL(.Lstr.hello),%edi + mov kBiosDataAreaXlm+METAL_STDOUT,%esi + call sputs + mov $kBiosDataAreaXlm+METAL_STDOUT,%edi + mov $4,%esi + call sflush + + jmp triplf + lea triplf(%rip),%rdx + call _start + jmp triplf + .endfn long + +/ Avoid linker script variables appearing as code in objdump. + .macro .ldsvar name:req + .type \name,@object + .weak \name + .endm + .ldsvar _end + .ldsvar _etext + .ldsvar v_ape_realsectors + .ldsvar v_ape_highsectors + .ldsvar idata.ro + .ldsvar ape.pad.rodata + .ldsvar ape.piro + .ldsvar ape.piro.end + .type .Lape.macho.end,@object + .type .Lape.note,@object + .type .Lape.note.end,@object + .type .Lape.note.vaddr,@object + .type .Lape.pe.sections,@object + .type .Lape.pe.sections_end,@object + .type .Lape.text.nops,@object + .type __test_end,@object + + .section .commentprologue,"a",@progbits + .type kLegalNotices,@object + .hidden kLegalNotices +kLegalNotices:/* + ... + decentralized content + ... + */.previous + .section .commentepilogue,"a",@progbits + .byte 0 + .previous + + .section .ape.pad.head,"a",@progbits + .type ape.pad.head,@object + .hidden ape.pad.head +ape.pad.head: + .previous + + .section .ape.pad.text,"a",@progbits + .type ape.pad.text,@object + .hidden ape.pad.text +ape.pad.text: + .previous + + .section .ape.pad.privileged,"a",@progbits + .type ape.pad.privileged,@object + .hidden ape.pad.privileged +ape.pad.privileged: + .previous + + .section .ape.pad.test,"a",@progbits + .type ape.pad.test,@object + .hidden ape.pad.test +ape.pad.test: + .previous + + .section .ape.pad.test,"a",@progbits + .type ape.pad.test,@object + .hidden ape.pad.test +ape.pad.test: + .previous + + .section .ape.pad.rodata,"a",@progbits + .type ape.pad.rodata,@object + .hidden ape.pad.rodata +ape.pad.rodata: + .previous + + .section .ape.pad.data,"a",@progbits + .type ape.pad.data,@object + .hidden ape.pad.data +ape.pad.data: + .previous + + .section .idata.ro,"a",@progbits + .type idata.ro,@object + .hidden idata.ro +idata.ro: + .previous + + .section .dataprologue,"aw",@progbits + .type __data_start,@object + .globl __data_start + .hidden __data_start +__data_start: + .previous + + .type __piro_start,@object + .hidden __piro_start + +.end + \ No newline at end of file diff --git a/ape/ape.lds b/ape/ape.lds new file mode 100644 index 00000000..27bf5718 --- /dev/null +++ b/ape/ape.lds @@ -0,0 +1,660 @@ +/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8 -*-│ +│vi: set et sts=2 tw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╠──────────────────────────────────────────────────────────────────────────────╣ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│ +│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│ +│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│ +╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│ +│ αcτµαlly pδrταblε εxεcµταblε § linker │ +╚──────────────────────────────────────────────────────────────────────────────╝ + Having an executable run natively on stock Windows / Mac / Linux / BSD + entails two steps: (1) create a .com.dbg binary w/ Linux toolchain and + then (2) unwrap the .com binary embedded within: + + objcopy -SO binary input.com.dbg output.com + + Both executables will work fine, but only the .com format is portable. + + ───BUILDING───────────────────────────────────────────────────────────── + + LC_ALL=C ld -T ape/ape.lds ... + + ───RUNNING────────────────────────────────────────────────────────────── + + ./foo.com.dbg # works on host machine + ./foo.com # works on any os / arch + qemu-system-x86_64 -s foo.com # works on any os / arch + + ───BACKGROUND─────────────────────────────────────────────────────────── + + The purpose of this software is to help native programs have the same + level of consistency, in terms of user experience, that we enjoy with + web applications. It's basically like MeteorJS, except primarily CLI, + bootable, and more on the order of a few kilobytes than hundred megs. + + Rather than Isomorphic JavaScript it's built using Isomorphic Binary, + since it grants the fastest possible performance and can be trivially + emulated in the browser. System resource utilization is also a few kb + and GUIs are possible too since Cosmopolitan exports the Windows API, + but we recommend doing it with a CLI web server instead and embedding + files in your αcτµαlly pδrταblε εxεcµταblε as it's isomorphic to zip. + + Isomorphic Binary principles state that most platform differences are + just numbers, which we integrate easily into a unified business logic + through the use of a sufficiently powerful linker. System numbers are + otherwise known as ABIs and they're usually the most stable canonical + interfaces that platforms provide. This is how we are able to support + more versions of Linux than most Linux-only software, e.g. glibc FTMP + + ───DEBUGGING──────────────────────────────────────────────────────────── + + Can be done in a few ways: + + gdb --tui foo.com.dbg + gdb --tui foo.com -ex 'add-symbol-file foo.com.dbg 0x200000' + gdb --tui -ex 'add-symbol-file foo.com.dbg 0x7c00' \ + -ex 'add-symbol-file foo.com.dbg 0x200000' \ + -ex -target remote localhost:1234' + + ───TRANSPARENCY───────────────────────────────────────────────────────── + + αcτµαlly pδrταblε εxεcµταblε is designed to facilitate maximum + transparency to engender trust in this linker process. + + The headers and symbols can be viewed using readelf or objdump: + + readelf -Wa input.com.dbg # maximum transparency + objdump -wxd input.com.dbg # maximum transparency + + The disassembly can be viewed using objdump: + + readelf -Wa input.com.dbg # maximum transparency + objdump -d input.com.dbg # maximum transparency + objdump -dj.text input.com.dbg # skip αpε boilerplate + objdump -j.load -dMi8086 input.com.dbg # fixes real mode code + + Some commands for controlling the verbosity of binaries: + + strip -X input.com.dbg # remove ".L" symbols + strip input.com.dbg # remove all symbols + strip -S input.com.dbg # remove debug info only + make CPPFLAGS=-DNDEBUG # remove asserts (prod) + make CPPFLAGS=-DIM_FEELING_NAUGHTY # remove legal notices + + The Makefile build is also configured to always produce a .map file + when building each program, which provides further details. + + ───HACKABILITY────────────────────────────────────────────────────────── + + Your linker and assemblies were designed provide extensibility through + the use of link-time data structures we call "decentralized sections". + They allow functions like _init() to be comprised of many small pieces + defined throughout the codebase. The same applies to ELF / PE headers. + + Extending that content usually entails writing a .S file. The process + has more in common with JavaScript programming than contemporary C++ + development practices. It's the reason Cosmopolitan is able to build + the fast tiny multiplatform autonomous binaries that indie developers + love using a scalable development model that big businesses respect. + + ───SECURITY───────────────────────────────────────────────────────────── + + αcτµαlly pδrταblε εxεcµταblε is designed to be secure in untrustworthy + computing environments. Code and data are separated. Data structures + initialized at startup are automatically memory protected afterwards. + Code intended for platforms you don't use is automatically unmapped + too, minimizing any possible chance of impacting your system, while + still being there in case you ever need it. + + ───CONFIDENTIALITY────────────────────────────────────────────────────── + + αcτµαlly pδrταblε εxεcµταblε is also designed to not leak confidential + information by default. Details relating to the host build environment + such as system/library versions, user ids, home folder locations, etc. + are not taken into consideration at build time since it's hermetic. We + can't make speak for debug information, which is why it's put in other + files. We also provide the bing and fold programs for auditing binary. + + ───DESIGN─DETAILS─────────────────────────────────────────────────────── + + αcτµαlly pδrταblε εxεcµταblε is a non-reflective (a.k.a. flat) binary + format that includes ELF, PE, and Macho-O headers only to respect the + initialization rituals that supported platforms require. + + Binaries are sparse because Intel's six thousand page manual says: + + “Always put code and data on separate pages. [...] If code is + to be modified, try to do it all at once and make sure the + code that performs the modifications and the code being + modified are on separate 4KByte pages or on separate aligned + 1-KByte subpages. [...] If (hopefully read-only) data must + occur on the same page as code, avoid placing it immediately + after an indirect jump [...] or inserting an illegal opcode + [...] after the indirect branch [which] may degrade perf in + some circumstances.” ──Intel V.O §3.6.9 + + Support for linking dynamic shared objects is only implemented on + Windows NT for the reasons described by Ulrich Drepper in his DSO + tutorial. We've implemented this independently of the ld codebase + because authentic GNU tooling is powerful enough to generalize to + arbitrary formats without needing to add features to its codebase. + + Cosmopolitan core library functions may be converted to the COFF or + Mach-O object formats using objconv. That gives you some freedom to + choose to use the Microsoft or Apple linker instead of this one. We + otherwise can't use those formats, due to how they heavily restrict + naming, which basically makes everything we're doing impossible. In + the future an authentic GNU toolchain will be made available on the + Windows and Apple platforms, using canonical formats and behaviors. + Until then, we can build for those platforms using Linux or WSL. */ + +#ifdef __LINKER__ +#include "ape/macros.h" +#include "ape/config.h" +#include "libc/nt/pedef.h" +#include "libc/zip.h" + +ENTRY(_start) + +/* Plans real memory solution at linktime. */ +MEMORY { + PageZero : org = 0x0000000000000000, len = 0x0000000000001000 + RealBss : org = XLM_BASE_REAL, len = XLM_SIZE + RealProgram : org = IMAGE_BASE_REAL, len = 0x0000000000010000 - IMAGE_BASE_REAL + RealScratch : org = REAL_SCRATCH_AREA, len = REAL_STACK_FRAME - REAL_SCRATCH_AREA + RealStack : org = REAL_STACK_FRAME, len = 0x0000000000010000 + EbdaMemory : org = 0x0000000000080000, len = 0x0000000000020000 + VideoMemory : org = 0x00000000000a0000, len = 0x0000000000020000 + Romz : org = 0x00000000000c0000, len = 0x0000000000030000 + BiosMemory : org = 0x00000000000f0000, len = 0x0000000000010000 + SmallCode : org = IMAGE_BASE_PHYSICAL, len = 0x0000000040000000 - IMAGE_BASE_PHYSICAL + ZipData : org = 0x0000000040000000, len = 0x0000000040000000 +} + +PHDRS { + Head PT_LOAD FLAGS(5); + Rom PT_LOAD FLAGS(5); + Ram PT_LOAD FLAGS(6); + stack PT_GNU_STACK FLAGS(6); +} + +SECTIONS { + +/*BEGIN: realmode addressability guarantee */ +/*BEGIN: xnu addressability guarantee */ +/*BEGIN: linux addressability guarantee */ +/*BEGIN: bsd addressability guarantee */ + + .head SEGMENT_START("text-segment", IMAGE_BASE_VIRTUAL) : { + HIDDEN(_base = .); + + /* Real Mode */ + KEEP(*(.head)) + . += 1; + + /* Executable & Linkable Format */ + . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1); + KEEP(*(.elf.phdrs)) + HIDDEN(.Lape.phdrs.end = .); + . += 1; + + /* OpenBSD */ + . = ALIGN(. != 0 ? __SIZEOF_POINTER__ : 1); + HIDDEN(.Lape.note = .); + KEEP(*(.note.openbsd.ident)) + HIDDEN(.Lape.note.end = .); + . += 1; + + /* Portable Executable */ + KEEP(*(.pe.header)) + HIDDEN(.Lape.pe.sections = .); + KEEP(*(.pe.sections)) + HIDDEN(.Lape.pe.sections_end = .); + . += 1; + + /* Mach-O */ + KEEP(*(.macho)) + . = ALIGN(__SIZEOF_POINTER__); + HIDDEN(.Lape.macho.end = .); + . += 1; + + KEEP(*(.ape.pad.head)) + . = ALIGN(4096); /* alignments only mandatory when impossible otherwise */ + HIDDEN(_ehead = .); + } AT>SmallCode :Head + +/*BEGIN: nt addressability guarantee */ + + .text . : { + /* Code that needs to be addressable in Real Mode */ + *(.text.real) + KEEP(*(SORT_BY_NAME(.sort.text.real.*))) + *(.rodata.real) + KEEP(*(SORT_BY_NAME(.sort.rodata.real.*))) + HIDDEN(_ereal = .); + +/*END: realmode addressability guarantee */ + + /* Normal Code */ + *(.start) + KEEP(*(.initprologue)) + KEEP(*(SORT_BY_NAME(.init.*))) + KEEP(*(SORT_NONE(.init))) + KEEP(*(.initepilogue)) + KEEP(*(.pltprologue)) + *(.plt) + KEEP(*(.pltepilogue)) + KEEP(*(.pltgotprologue)) + *(.plt.got) + KEEP(*(.pltgotepilogue)) + *(.text.startup .text.startup.*) + *(.text.exit .text.exit.*) + *(.text.unlikely .text.*_unlikely .text.unlikely.*) + *(SORT_BY_ALIGNMENT(.text.antiquity)) + *(SORT_BY_ALIGNMENT(.text.antiquity.*)) + KEEP(*(.textwindowsprologue)) + *(.text.windows) + KEEP(*(.textwindowsepilogue)) + *(SORT_BY_ALIGNMENT(.text.modernity)) + *(SORT_BY_ALIGNMENT(.text.modernity.*)) + *(SORT_BY_ALIGNMENT(.text.hot)) + *(SORT_BY_ALIGNMENT(.text.hot.*)) + KEEP(*(.keep.text)) + *(.text .stub .text.*) + KEEP(*(SORT_BY_NAME(.sort.text.*))) + + /* Won't support NX bit DRM for tiny executables */ + HIDDEN(.Lape.piro.align = ABSOLUTE(. > APE_PIRO_THRESHOLD ? 0x1000 : 8)); + + /* Code that musn't be mapped in production */ + KEEP(*(.ape.pad.test)); + . = ALIGN(.Lape.piro.align); + HIDDEN(__test_start = .); + *(.test.unlikely) + *(.test .test.*) + + /* Privileged code invulnerable to magic */ + KEEP(*(.ape.pad.privileged)); + . = ALIGN(.Lape.piro.align); + HIDDEN(__privileged_start = .); + HIDDEN(__test_end = .); + . += 1; + *(.privileged) + +/*BEGIN: Read Only Data */ + + KEEP(*(.ape.pad.rodata)); + . = ALIGN(.Lape.piro.align); + . += 1; + + /* Nonspecific Read-Only Data */ + *(.rodata .rodata.*) + . += 1; + + /* Undefined Behavior Sanitizer Types */ + HIDDEN(__ubsan_types_start = .); + *(.ubsan.types) + HIDDEN(__ubsan_types_end = .); + . += 1; + + /* Undefined Behavior Sanitizer Data */ + HIDDEN(__ubsan_data_start = .); + *(.ubsan.data) + HIDDEN(__ubsan_data_end = .); + + /* Unit Test & Fixture Registry */ + +/*BEGIN: Read only data that needn't be mapped after initialization */ + + /* Legal Notices */ + KEEP(*(.commentprologue)) + KEEP(*(.comment)) + KEEP(*(.commentepilogue)) + + /* Windows DLL Import Directory */ + KEEP(*(.idata.ro)); + KEEP(*(SORT_BY_NAME(.idata.ro.*))) + . += 1; + + /* Encoded Data Structures w/ Linear Initialization Order */ + KEEP(*(.initroprologue)) + KEEP(*(SORT_BY_NAME(.initro.*))) + KEEP(*(.initroepilogue)) + KEEP(*(SORT_BY_NAME(.sort.rodata.*))) + + KEEP(*(.ape.pad.text)) + HIDDEN(.Lape.data.align = ABSOLUTE(PAGESIZE)); + . = ALIGN(.Lape.data.align); + HIDDEN(_etext = .); + PROVIDE_HIDDEN(etext = .); +/*END: Read Only Data (only needed for initialization) */ +/*END: Read Only Data */ + } AT>SmallCode :Rom + + .data . : { +/*BEGIN: Read/Write Data */ + KEEP(*(.dataprologue)) + *(.data .data.*) + KEEP(*(SORT_BY_NAME(.sort.data.*))) + . += . > 0 ? 1 : 0; + + KEEP(*(.gotprologue)) + *(.got) + KEEP(*(.gotepilogue)) + + KEEP(*(.gotpltprologue)) + *(.got.plt) + KEEP(*(.gotpltepilogue)) + +/*BEGIN: Post-Initialization Read-Only */ + . = ALIGN(.Lape.piro.align); + HIDDEN(__piro_start = .); + + QUAD(IMAGE_BASE_VIRTUAL); + + PROVIDE_HIDDEN(__init_array_start = .); + KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*) + SORT_BY_INIT_PRIORITY(.ctors.*))) + KEEP(*(SORT_NONE(.ctors))) + KEEP(*(SORT_NONE(.init_array))) + KEEP(*(SORT_NONE(.preinit_array))) + PROVIDE_HIDDEN(__init_array_end = .); + + . += 1; + . = ALIGN(__SIZEOF_POINTER__); + PROVIDE_HIDDEN(__fini_array_start = .); + KEEP(*(SORT_BY_INIT_PRIORITY(.fini_array.*) + SORT_BY_INIT_PRIORITY(.dtors.*))) + KEEP(*(SORT_NONE(.dtors))) + PROVIDE_HIDDEN(__fini_array_end = .); + + KEEP(*(SORT_BY_NAME(.piro.relo.sort.*))) + PROVIDE_HIDDEN(__relo_end = .); + KEEP(*(SORT_BY_NAME(.piro.data.sort.*))) + KEEP(*(.piro.pad.data)) + . = ALIGN(.Lape.data.align); + HIDDEN(_edata = .); + PROVIDE_HIDDEN(edata = .); + } AT>SmallCode :Ram + + .bss . : { + KEEP(*(SORT_BY_NAME(.piro.bss.init.*))) + *(.piro.bss) + KEEP(*(SORT_BY_NAME(.piro.bss.sort.*))) + . += 1; + . = ALIGN(.Lape.piro.align); + HIDDEN(__piro_end = .); +/*END: Post-Initialization Read-Only */ + + /* Statically Allocated Empty Space */ + *(SORT_BY_ALIGNMENT(.bss)) + *(SORT_BY_ALIGNMENT(.bss.*)) + *(COMMON) + + KEEP(*(SORT_BY_NAME(.sort.bss.*))) + + /* eXtreme Low Memory w/ Userspace Remapping */ + . = ALIGN(0x1000); + *(.xlm) + . = ALIGN(0x1000); + + HIDDEN(_end = .); + PROVIDE_HIDDEN(end = .); + } AT>SmallCode :Ram + +/*END: nt addressability guarantee */ +/*END: bsd addressability guarantee */ +/*END: linux addressability guarantee */ +/*END: xnu addressability guarantee */ + + .stab 0 : { *(.stab) } + .stabstr 0 : { *(.stabstr) } + .stab.excl 0 : { *(.stab.excl) } + .stab.exclstr 0 : { *(.stab.exclstr) } + .stab.index 0 : { *(.stab.index) } + .stab.indexstr 0 : { *(.stab.indexstr) } + .comment 0 : { *(.comment) } + .debug 0 : { *(.debug) } + .line 0 : { *(.line) } + .debug_srcinfo 0 : { *(.debug_srcinfo) } + .debug_sfnames 0 : { *(.debug_sfnames) } + .debug_aranges 0 : { *(.debug_aranges) } + .debug_pubnames 0 : { *(.debug_pubnames) } + .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) } + .debug_abbrev 0 : { *(.debug_abbrev) } + .debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) } + .debug_frame 0 : { *(.debug_frame) } + .debug_str 0 : { *(.debug_str) } + .debug_loc 0 : { *(.debug_loc) } + .debug_macinfo 0 : { *(.debug_macinfo) } + .debug_weaknames 0 : { *(.debug_weaknames) } + .debug_funcnames 0 : { *(.debug_funcnames) } + .debug_typenames 0 : { *(.debug_typenames) } + .debug_varnames 0 : { *(.debug_varnames) } + .debug_pubtypes 0 : { *(.debug_pubtypes) } + .debug_ranges 0 : { *(.debug_ranges) } + .debug_macro 0 : { *(.debug_macro) } + .debug_addr 0 : { *(.debug_addr) } + .gnu.attributes 0 : { KEEP(*(.gnu.attributes)) } + .GCC.command.line 0 : { *(.GCC.command.line) } + + /DISCARD/ : { + *(.discard) + *(.yoink) + *(.*) + } +} + +PFSTUB8(.Lape.elf.entry, _start); +PFSTUB8(.Lape.elf.phoff, RVA(ape.phdrs)); +PFSTUB8(.Lape.elf.shoff, 0); +PFSTUB4(.Lape.elf.phnum, (.Lape.phdrs.end - ape.phdrs) / 56); +PFSTUB4(.Lape.elf.shnum, 0); +PFSTUB4(.Lape.elf.shstrndx, 0); +SHSTUB2(.Lape.macho.dd.skip, RVA(ape.macho) / 8); +SHSTUB2(.Lape.macho.dd.count, (.Lape.macho.end - ape.macho) / 8); +PFSTUB4(.Lape.pe.offset, ape.pe - ape.mz); + +HIDDEN(.Lape.pe.optsz = .Lape.pe.sections - (ape.pe + 24)); +HIDDEN(.Lape.pe.shnum = (.Lape.pe.sections_end - .Lape.pe.sections) / 40); +HIDDEN(.Lidata.idtsize = idata.idtend - idata.idt); +HIDDEN(.Lidata.iatsize = idata.iatend - idata.iat); + +HIDDEN(.Lape.rom.offset = 0); +HIDDEN(.Lape.rom.vaddr = ADDR(.head)); +HIDDEN(.Lape.rom.paddr = LOADADDR(.head)); +HIDDEN(.Lape.rom.filesz = LOADADDR(.data) - .Lape.rom.paddr); +HIDDEN(.Lape.rom.memsz = ADDR(.data) - ADDR(.head)); +HIDDEN(.Lape.rom.align = 0x1000); +HIDDEN(.Lape.rom.rva = RVA(.Lape.rom.vaddr)); + +HIDDEN(.Lape.ram.offset = .Lape.rom.offset + .Lape.rom.filesz); +HIDDEN(.Lape.ram.vaddr = ADDR(.data)); +HIDDEN(.Lape.ram.paddr = LOADADDR(.data)); +HIDDEN(.Lape.ram.filesz = LOADADDR(.bss) - LOADADDR(.data)); +HIDDEN(.Lape.ram.memsz = ADDR(.bss) + SIZEOF(.bss) - .Lape.ram.vaddr); +HIDDEN(.Lape.ram.align = 0x1000); +HIDDEN(.Lape.ram.rva = RVA(.Lape.ram.vaddr)); + +HIDDEN(.Lape.note.offset = .Lape.rom.offset + (.Lape.note - .Lape.rom.vaddr)); +HIDDEN(.Lape.note.vaddr = .Lape.note); +HIDDEN(.Lape.note.paddr = .Lape.rom.paddr + .Lape.note.offset); +HIDDEN(.Lape.note.filesz = .Lape.note.end - .Lape.note); +HIDDEN(.Lape.note.memsz = .Lape.note.filesz); +HIDDEN(.Lape.note.align = __SIZEOF_POINTER__); + +HIDDEN(.Lape.text.offset = .Lape.rom.offset + LOADADDR(.text) - .Lape.rom.paddr); +HIDDEN(.Lape.text.paddr = LOADADDR(.text)); +HIDDEN(.Lape.text.vaddr = ADDR(.text)); +HIDDEN(.Lape.text.filesz = SIZEOF(.text)); +HIDDEN(.Lape.text.memsz = SIZEOF(.text)); +HIDDEN(.Lape.text.align = 4096); +HIDDEN(.Lape.text.rva = RVA(.Lape.text.vaddr)); + +HIDDEN(.Lape.data.offset = .Lape.ram.offset + LOADADDR(.data) - .Lape.ram.paddr); +HIDDEN(.Lape.data.paddr = LOADADDR(.data)); +HIDDEN(.Lape.data.vaddr = ADDR(.data)); +HIDDEN(.Lape.data.filesz = SIZEOF(.data)); +HIDDEN(.Lape.data.memsz = SIZEOF(.data)); +HIDDEN(.Lape.data.align = 0x1000); +HIDDEN(.Lape.data.rva = RVA(.Lape.data.vaddr)); + +HIDDEN(.Lape.bss.offset = .Lape.ram.offset + LOADADDR(.bss) - .Lape.ram.paddr); +HIDDEN(.Lape.bss.paddr = LOADADDR(.bss)); +HIDDEN(.Lape.bss.vaddr = ADDR(.bss)); +HIDDEN(.Lape.bss.filesz = 0); +HIDDEN(.Lape.bss.memsz = SIZEOF(.bss)); +HIDDEN(.Lape.bss.align = .Lape.data.align); + +/* Program Loader Auto-Tune */ +HIDDEN(v_ape_realsectors = + MIN(REAL_SCRATCH_AREA - IMAGE_BASE_REAL, + ROUNDUP(RVA(_edata), 512)) / 512); +HIDDEN(v_ape_highsectors = + (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors); + +/* Windows NT Auto-Subsystem Embedding */ +HIDDEN(v_ntsubsystem = (DEFINED(GetMessage) + ? kNtImageSubsystemWindowsGui + : kNtImageSubsystemWindowsCui)); + +/* ZIP End of Central Directory header */ +#define ZIPCONST(NAME, VAL) HIDDEN(NAME = DEFINED(__zip_start) ? VAL : 0); +ZIPCONST(v_zip_cdoffset, __zip_start - IMAGE_BASE_VIRTUAL); +ZIPCONST(v_zip_cdirsize, __zip_end - __zip_start); +ZIPCONST(v_zip_records, v_zip_cdirsize / kZipCdirHdrLinkableSize); +ZIPCONST(v_zip_commentsize, _edata - __zip_end - kZipCdirHdrMinSize); + +/* Generates deterministic ID for Mach-O. */ +#define PHI 0x9e3779b9925d4c17 +#define XOR(X,Y) ((X | Y) - (X & Y)) +#define XORSHIFT(X,Y) \ + X = XOR(X, (Y >> 12)); \ + X = XOR(X, (Y << 25)); \ + X = XOR(X, (Y >> 27)) +#define KMH(X,Y) \ + X = (X + (Y >> 000) & 0xFF) * PHI; \ + X = (X + (Y >> 010) & 0xFF) * PHI; \ + X = (X + (Y >> 020) & 0xFF) * PHI; \ + X = (X + (Y >> 030) & 0xFF) * PHI +#define BOOP(X) \ + XORSHIFT(uuid1_, X); \ + KMH(uuid1_, X); \ + XORSHIFT(uuid2_, X); \ + KMH(uuid2_, X) + +HIDDEN(uuid1_ = 88172645463325252); +HIDDEN(uuid2_ = 88172645463325252); + +BOOP(.Lape.bss.align); +BOOP(.Lape.bss.filesz); +BOOP(.Lape.bss.memsz); +BOOP(.Lape.bss.offset); +BOOP(.Lape.bss.paddr); +BOOP(.Lape.data.align); +BOOP(.Lape.data.filesz); +BOOP(.Lape.data.memsz); +BOOP(.Lape.data.offset); +BOOP(.Lape.data.paddr); +BOOP(.Lape.data.rva); +BOOP(.Lape.data.vaddr); +BOOP(.Lape.elf.entry); +BOOP(.Lape.elf.phnum); +BOOP(.Lape.elf.phoff); +BOOP(.Lape.elf.shnum); +BOOP(.Lape.elf.shoff); +BOOP(.Lape.elf.shstrndx); +BOOP(.Lape.macho.end); +BOOP(.Lape.note); +BOOP(.Lape.note.align); +BOOP(.Lape.note.end); +BOOP(.Lape.note.filesz); +BOOP(.Lape.note.memsz); +BOOP(.Lape.note.offset); +BOOP(.Lape.note.paddr); +BOOP(.Lape.note.vaddr); +BOOP(.Lape.pe.offset); +BOOP(.Lape.pe.optsz); +BOOP(.Lape.pe.sections); +BOOP(.Lape.pe.sections_end); +BOOP(.Lape.pe.shnum); +BOOP(.Lape.phdrs.end); +BOOP(.Lape.ram.align); +BOOP(.Lape.ram.filesz); +BOOP(.Lape.ram.memsz); +BOOP(.Lape.ram.offset); +BOOP(.Lape.ram.paddr); +BOOP(.Lape.ram.rva); +BOOP(.Lape.ram.vaddr); +BOOP(.Lape.rom.align); +BOOP(.Lape.rom.filesz); +BOOP(.Lape.rom.memsz); +BOOP(.Lape.rom.offset); +BOOP(.Lape.rom.paddr); +BOOP(.Lape.rom.rva); +BOOP(.Lape.rom.vaddr); +BOOP(.Lape.text.align); +BOOP(.Lape.text.filesz); +BOOP(.Lape.text.memsz); +BOOP(.Lape.text.offset); +BOOP(.Lape.text.paddr); +BOOP(.Lape.text.rva); +BOOP(.Lape.text.vaddr); +BOOP(ADDR(.bss)); +BOOP(WinMain); +BOOP(_start); +BOOP(ape.macho); +BOOP(ape.mz); +BOOP(ape.pe); +BOOP(ape.phdrs); +BOOP(v_ape_realsectors); + +ASSERT(ape.mz == IMAGE_BASE_VIRTUAL, "linker panic"); +ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0, + "__init_bss misalign"); +ASSERT(((DEFINED(__init_rodata_end) ? __init_rodata_end : 0) % + __SIZEOF_POINTER__ == 0), + "__init_rodata misalign"); + +ASSERT((!DEFINED(ape.grub) ? 1 : RVA(ape.grub) < 8192), + "grub stub needs to be in first 8kb of image"); + +ASSERT(DEFINED(_start) || DEFINED(_start16), + "please link a _start() or _start16() entrypoint"); + +ASSERT(!DEFINED(_start16) || REAL(_end) < 65536, + "ape won't support non-tiny real mode programs"); + +/* Let's not be like Knight Capital. */ +/* NOCROSSREFS_TO(.test .text) */ + +/* ASSERT(ape_sysv_start == .Lape.text.vaddr, */ +/* "ape_sysv_start() must be first in .text"); */ + +#endif /* __LINKER__ */ diff --git a/ape/ape.mk b/ape/ape.mk new file mode 100644 index 00000000..8f18dc80 --- /dev/null +++ b/ape/ape.mk @@ -0,0 +1,57 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# OVERVIEW +# +# αcτµαlly pδrταblε εxεcµταblε +# +# DESCRIPTION +# +# This file defines the libraries, runtimes, and build rules needed to +# create executables from your Linux workstation that'll run anywhere. +# Loading this package will make certain systemic modifications to the +# build like turning off the System V "Red Zone" optimization, because +# αcτµαlly pδrταblε εxεcµταblεs need to be able to run in kernelspace. + +PKGS += APE + +DEFAULT_COPTS += -mno-red-zone +DEFAULT_LDFLAGS += -z max-page-size=0x1000 + +APELINK = ACTION=LINK.ape $(LINK) $(LINKARGS) $(OUTPUT_OPTION) && $(STRIP) -X $@ && $(GZ) $(ZFLAGS) -f $@.map + +APE = $(APE_DEPS) \ + $(APE_OBJS) \ + o/$(MODE)/ape/ape.lds + +APE_FILES := \ + $(wildcard ape/*.*) + +APE_HDRS = \ + $(filter %.h,$(APE_FILES)) + +APE_SRCS = \ + $(filter %.S,$(APE_FILES)) + +APE_OBJS = \ + $(APE_SRCS:%=o/$(MODE)/%.zip.o) \ + $(APE_SRCS:%.S=o/$(MODE)/%.o) + +APE_DEPS = \ + $(APE_LIB) + +APE_CHECKS = \ + $(APE_HDRS:%=o/%.ok) + +o/%.com: o/%.com.dbg + @ACTION=OBJCOPY.ape TARGET=$@ build/do $(OBJCOPY) -SO binary $< $@ + +o/ape/idata.inc: ape/idata.h ape/relocations.h + +$(APE_OBJS): $(BUILD_FILES) \ + ape/ape.mk + +.PHONY: o/$(MODE)/ape +o/$(MODE)/ape: $(APE) \ + $(APE_CHECKS) \ + o/$(MODE)/ape/lib diff --git a/ape/config.h b/ape/config.h new file mode 100644 index 00000000..12e0eb5c --- /dev/null +++ b/ape/config.h @@ -0,0 +1,137 @@ +#ifndef APE_CONFIG_H_ +#define APE_CONFIG_H_ +#include "ape/relocations.h" +#include "libc/macros.h" + +/** + * @fileverview αcτµαlly pδrταblε εxεcµταblε configuration. + */ + +/** + * Post-Initialization Read-Only Code Size Threshold. + * + * An executable needs to have at least this much code, before the + * linker adds non-mandatory 4kb alignments. The benefit is better + * memory protection. The tradeoff is sparser binaries. + */ +#ifndef APE_PIRO_THRESHOLD +#ifdef CONFIG_DBG +#define APE_PIRO_THRESHOLD 0x1000 +#else +#define APE_PIRO_THRESHOLD 0x10000 +#endif +#endif + +/** + * PC Standard I/O Configuration. + */ +#ifndef METAL_STDIN +#define METAL_STDIN COM1 +#endif +#ifndef METAL_STDOUT +#define METAL_STDOUT COM1 +#endif +#ifndef METAL_STDERR +#define METAL_STDERR COM2 /* will fallback to stdout if COM2 not present */ +#endif + +/** + * PC Display Configuration (MDA/CGA) + * @see www.lammertbies.nl/comm/info/serial-uart.html + * @see ape/lib/vidya.h + */ +#ifndef VIDYA_MODE +#define VIDYA_MODE VIDYA_MODE_MDA +#endif + +/* FPU Control Word (x87) Exception Masks + @see Intel Manual V1 §8.1.5 + + IM: Invalid Operation ───────────────┐ + DM: Denormal Operand ───────────────┐│ + ZM: Zero Divide ───────────────────┐││ + OM: Overflow ─────────────────────┐│││ + UM: Underflow ───────────────────┐││││ + PM: Precision ──────────────────┐│││││ + PC: Precision Control ────────┐ ││││││ + {float,∅,double,long double} │ ││││││ + RC: Rounding Control ───────┐ │ ││││││ + {even, →-∞, →+∞, →0} │┌┤ ││││││ + ┌┤││ ││││││ + d││││rr││││││*/ +#define X87_NORMAL 0b000000000001101111111 +#define X87_DTOA 0b000000000001000000000 +#define X87_DTOA_MASK 0b000000000001100000000 +#ifndef X87_DEFAULT +#define X87_DEFAULT X87_NORMAL +#endif + +/** + * Serial Line Configuration (8250 UART 16550) + * @see ape/lib/uart.h + */ +#ifndef UART_BAUD_RATE +#define UART_BAUD_RATE 9600 /* bits per second ∈ [50,115200] */ +#endif +#define UART_CONF_DLR (1843200 /*hz*/ / 16 /*wut*/ / (UART_BAUD_RATE)) +#ifndef UART_CONF_IIR +/* ┌interrupt trigger level {1,4,8,14} + │ ┌enable 64 byte fifo (UART 16750+) + │ │ ┌select dma mode + │ │ │┌clear transmit fifo + │ │ ││┌clear receive fifo + ├┐│ │││┌enable fifos*/ +#define UART_CONF_IIR 0b00000000 +#endif +#ifndef UART_CONF_LCR +/* ┌dlab: flips configuration mode state + │┌enable break signal + ││ ┌parity {none,odd,even,high,low} + ││ │ ┌extra stop bit + ││ │ │┌data word length (bits+5) + ││┌┴┐│├┐*/ +#define UART_CONF_LCR 0b01000011 +#endif + +/** + * eXtreme Low Memory. + */ +#define XLM(VAR) (XLM_BASE_REAL + XLM_##VAR) +#define XLMV(VAR) (__xlm + XLM_##VAR) +#define XLM_BASE_REAL 0x1000 +#define XLM_E820 0 +#define XLM_E820_SIZE 0x2000 +#define XLM_BIOS_DATA_AREA 0x2000 +#define XLM_BIOS_DATA_AREA_SIZE 256 +#define XLM_DRIVE_BASE_TABLE 0x2200 /* drive values are contiguous */ +#define XLM_DRIVE_BASE_TABLE_SIZE 11 +#define XLM_DRIVE_TYPE 0x220b +#define XLM_DRIVE_TYPE_SIZE 1 +#define XLM_DRIVE_LAST_SECTOR 0x220c /* 1-based inclusive, e.g. 18 */ +#define XLM_DRIVE_LAST_SECTOR_SIZE 1 +#define XLM_DRIVE_LAST_CYLINDER 0x220d /* 0-based incl, e.g. 79 */ +#define XLM_DRIVE_LAST_CYLINDER_SIZE 2 +#define XLM_DRIVE_ATTACHED 0x220f +#define XLM_DRIVE_ATTACHED_SIZE 1 +#define XLM_DRIVE_LAST_HEAD 0x2210 /* 0-based inclusive, e.g. 1 */ +#define XLM_DRIVE_LAST_HEAD_SIZE 1 +#define XLM_DRIVE 0x2211 +#define XLM_DRIVE_SIZE 1 +#define XLM_HAVEEXTMEMKB 0x2212 +#define XLM_HAVEEXTMEMKB_SIZE 4 +#define XLM_VIDEO_POSITION_FAR_POINTER 0x2216 /* video cursor far pointer */ +#define XLM_VIDEO_POSITION_FAR_POINTER_SIZE 4 +#define XLM_PAGE_TABLE_STACK_POINTER 0x2220 +#define XLM_PAGE_TABLE_STACK_POINTER_SIZE 8 +#define XLM_BADIDT 0x2230 +#define XLM_BADIDT_SIZE 6 +#define XLM_LOADSTATE 0x2240 +#define XLM_LOADSTATE_SIZE 4 +#define XLM_SIZE ROUNDUP(XLM_LOADSTATE + XLM_LOADSTATE_SIZE, 0x1000) +#define IMAGE_BASE_REAL (XLM_BASE_REAL + XLM_SIZE) + +#if !defined(__LINKER__) && !defined(__ASSEMBLER__) +extern char __xlm[XLM_SIZE]; +#endif /* !defined(__LINKER__) && !defined(__ASSEMBLER__) */ + +#endif /* APE_CONFIG_H_ */ diff --git a/ape/etc/bochsrc.dbg b/ape/etc/bochsrc.dbg new file mode 100644 index 00000000..28a8d271 --- /dev/null +++ b/ape/etc/bochsrc.dbg @@ -0,0 +1,1279 @@ +# make boot.com +# bochs -q -f .bochsrc.dbg floppya:1_44=win64.exe,status=inserted + +#======================================================================= +# PLUGIN_CTRL: +# Controls the presence of optional device plugins. These plugins are loaded +# directly with this option and some of them install a config option that is +# only available when the plugin device is loaded. The value "1" means to load +# the plugin and "0" will unload it (if loaded before). +# +# These plugins will be loaded by default (if present): 'biosdev', 'extfpuirq', +# 'gameport', 'iodebug','parallel', 'serial', 'speaker' and 'unmapped'. +# +# These plugins are also supported, but they are usually loaded directly with +# their bochsrc option: 'e1000', 'es1370', 'ne2k', 'pcidev', 'pcipnic', 'sb16', +# 'usb_ehci', 'usb_ohci', 'usb_uhci', 'usb_xhci' and 'voodoo'. +#======================================================================= +#plugin_ctrl: unmapped=0, e1000=1 # unload 'unmapped' and load 'e1000' + +#======================================================================= +# CONFIG_INTERFACE +# +# The configuration interface is a series of menus or dialog boxes that +# allows you to change all the settings that control Bochs's behavior. +# Depending on the platform there are up to 3 choices of configuration +# interface: a text mode version called "textconfig" and two graphical versions +# called "win32config" and "wx". The text mode version uses stdin/stdout and +# is always compiled in, unless Bochs is compiled for wx only. The choice +# "win32config" is only available on win32 and it is the default there. +# The choice "wx" is only available when you use "--with-wx" on the configure +# command. If you do not write a config_interface line, Bochs will +# choose a default for you. +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +#======================================================================= +#config_interface: textconfig +#config_interface: win32config +#config_interface: wx + +#======================================================================= +# DISPLAY_LIBRARY +# +# The display library is the code that displays the Bochs VGA screen. Bochs +# has a selection of about 10 different display library implementations for +# different platforms. If you run configure with multiple --with-* options, +# the display_library command lets you choose which one you want to run with. +# If you do not write a display_library line, Bochs will choose a default for +# you. +# +# The choices are: +# x use X windows interface, cross platform +# win32 use native win32 libraries +# carbon use Carbon library (for MacOS X) +# macintosh use MacOS pre-10 +# amigaos use native AmigaOS libraries +# sdl use SDL 1.2.x library, cross platform +# sdl2 use SDL 2.x library, cross platform +# svga use SVGALIB library for Linux, allows graphics without X11 +# term text only, uses curses/ncurses library, cross platform +# rfb provides an interface to AT&T's VNC viewer, cross platform +# vncsrv use LibVNCServer for extended RFB(VNC) support +# wx use wxWidgets library, cross platform +# nogui no display at all +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +# +# Specific options: +# Some display libraries now support specific options to control their +# behaviour. These options are supported by more than one display library: +# +# "gui_debug" - use GTK debugger gui (sdl, sdl2, x) / Win32 debugger gui (sdl, +# sdl2, win32) +# "hideIPS" - disable IPS output in status bar (rfb, sdl, sdl2, vncsrv, +# win32, wx, x) +# "nokeyrepeat" - turn off host keyboard repeat (sdl, sdl2, win32, x) +# "timeout" - time (in seconds) to wait for client (rfb, vncsrv) +# +# See the examples below for other currently supported options. +#======================================================================= +#display_library: amigaos +#display_library: carbon +#display_library: macintosh +#display_library: nogui +#display_library: rfb +#display_library: sdl, options="fullscreen" # startup in fullscreen mode +#display_library: sdl2, options="fullscreen" # startup in fullscreen mode +#display_library: term +#display_library: vncsrv +# "traphotkeys" - system hotkeys not handled by host OS, but sent to guest +# (win32 in mouse capture and fullscreen mode: alt-tab, win, +# alt-space, alt-esc, ctrl-esc) +#display_library: win32, options="traphotkeys" +#display_library: wx +#display_library: x, gui_debug=1 +display_library: x, options="gui_debug" + +#======================================================================= +# CPU: +# This defines cpu-related parameters inside Bochs: +# +# MODEL: +# Selects CPU configuration to emulate from pre-defined list of all +# supported configurations. When this option is used and the value +# is different from 'bx_generic', the parameters of the CPUID option +# have no effect anymore. +# +# CPU configurations that can be selected: +# ----------------------------------------------------------------- +# pentium Intel Pentium (P54C) +# pentium_mmx Intel Pentium MMX +# amd_k6_2_chomper AMD-K6(tm) 3D processor (Chomper) +# p2_klamath Intel Pentium II (Klamath) +# p3_katmai Intel Pentium III (Katmai) +# p4_willamette Intel(R) Pentium(R) 4 (Willamette) +# core_duo_t2400_yonah Intel(R) Core(TM) Duo CPU T2400 (Yonah) +# atom_n270 Intel(R) Atom(TM) CPU N270 +# p4_prescott_celeron_336 Intel(R) Celeron(R) 336 (Prescott) +# athlon64_clawhammer AMD Athlon(tm) 64 Processor 2800+ (Clawhammer) +# athlon64_venice AMD Athlon(tm) 64 Processor 3000+ (Venice) +# turion64_tyler AMD Turion(tm) 64 X2 Mobile TL-60 (Tyler) +# phenom_8650_toliman AMD Phenom X3 8650 (Toliman) +# core2_penryn_t9600 Intel Mobile Core 2 Duo T9600 (Penryn) +# corei5_lynnfield_750 Intel(R) Core(TM) i5 750 (Lynnfield) +# corei5_arrandale_m520 Intel(R) Core(TM) i5 M 520 (Arrandale) +# corei7_sandy_bridge_2600k Intel(R) Core(TM) i7-2600K (Sandy Bridge) +# zambezi AMD FX(tm)-4100 Quad-Core Processor (Zambezi) +# trinity_apu AMD A8-5600K APU (Trinity) +# ryzen AMD Ryzen 7 1700 +# corei7_ivy_bridge_3770k Intel(R) Core(TM) i7-3770K CPU (Ivy Bridge) +# corei7_haswell_4770 Intel(R) Core(TM) i7-4770 CPU (Haswell) +# broadwell_ult Intel(R) Processor 5Y70 CPU (Broadwell) +# +# COUNT: +# Set the number of processors:cores per processor:threads per core when +# Bochs is compiled for SMP emulation. Bochs currently supports up to +# 14 threads (legacy APIC) or 254 threads (xAPIC or higher) running +# simultaniosly. If Bochs is compiled without SMP support, it won't accept +# values different from 1. +# +# QUANTUM: +# Maximum amount of instructions allowed to execute by processor before +# returning control to another cpu. This option exists only in Bochs +# binary compiled with SMP support. +# +# RESET_ON_TRIPLE_FAULT: +# Reset the CPU when triple fault occur (highly recommended) rather than +# PANIC. Remember that if you trying to continue after triple fault the +# simulation will be completely bogus ! +# +# CPUID_LIMIT_WINNT: +# Determine whether to limit maximum CPUID function to 2. This mode is +# required to workaround WinNT installation and boot issues. +# +# MSRS: +# Define path to user CPU Model Specific Registers (MSRs) specification. +# See example in msrs.def. +# +# IGNORE_BAD_MSRS: +# Ignore MSR references that Bochs does not understand; print a warning +# message instead of generating #GP exception. This option is enabled +# by default but will not be avaiable if configurable MSRs are enabled. +# +# MWAIT_IS_NOP: +# When this option is enabled MWAIT will not put the CPU into a sleep state. +# This option exists only if Bochs compiled with --enable-monitor-mwait. +# +# IPS: +# Emulated Instructions Per Second. This is the number of IPS that bochs +# is capable of running on your machine. You can recompile Bochs with +# --enable-show-ips option enabled, to find your host's capability. +# Measured IPS value will then be logged into your log file or shown +# in the status bar (if supported by the gui). +# +# IPS is used to calibrate many time-dependent events within the bochs +# simulation. For example, changing IPS affects the frequency of VGA +# updates, the duration of time before a key starts to autorepeat, and +# the measurement of BogoMips and other benchmarks. +# +# Examples: +# +# Bochs Machine/Compiler Mips +# ______________________________________________________________________ +# 2.4.6 3.4Ghz Intel Core i7 2600 with Win7x64/g++ 4.5.2 85 to 95 Mips +# 2.3.7 3.2Ghz Intel Core 2 Q9770 with WinXP/g++ 3.4 50 to 55 Mips +# 2.3.7 2.6Ghz Intel Core 2 Duo with WinXP/g++ 3.4 38 to 43 Mips +# 2.2.6 2.6Ghz Intel Core 2 Duo with WinXP/g++ 3.4 21 to 25 Mips +# 2.2.6 2.1Ghz Athlon XP with Linux 2.6/g++ 3.4 12 to 15 Mips +#======================================================================= +#cpu: model=core2_penryn_t9600, count=1, ips=50000000, reset_on_triple_fault=1, ignore_bad_msrs=1, msrs="msrs.def" +#cpu: cpuid_limit_winnt=0 +cpu: model=corei7_haswell_4770 + +#======================================================================= +# CPUID: +# +# This defines features and functionality supported by Bochs emulated CPU. +# The option has no offect if CPU model was selected in CPU option. +# +# MMX: +# Select MMX instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 5. +# +# APIC: +# Select APIC configuration (LEGACY/XAPIC/XAPIC_EXT/X2APIC). +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 5. +# +# SEP: +# Select SYSENTER/SYSEXIT instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SIMD: +# Select SIMD instructions support. +# Any of NONE/SSE/SSE2/SSE3/SSSE3/SSE4_1/SSE4_2/AVX/AVX2/AVX512 +# could be selected. +# +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# The AVX choises exists only if Bochs compiled with --enable-avx option. +# +# SSE4A: +# Select AMD SSE4A instructions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MISALIGNED_SSE: +# Select AMD Misaligned SSE mode support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# AES: +# Select AES instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SHA: +# Select SHA instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MOVBE: +# Select MOVBE Intel(R) Atom instruction support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# ADX: +# Select ADCX/ADOX instructions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# XSAVE: +# Select XSAVE extensions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# XSAVEOPT: +# Select XSAVEOPT instruction support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# AVX_F16C: +# Select AVX float16 convert instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# AVX_FMA: +# Select AVX fused multiply add (FMA) instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# BMI: +# Select BMI1/BMI2 instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# XOP: +# Select AMD XOP instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# FMA4: +# Select AMD four operand FMA instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# TBM: +# Select AMD Trailing Bit Manipulation (TBM) instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# X86-64: +# Enable x86-64 and long mode support. +# This option exists only if Bochs compiled with x86-64 support. +# +# 1G_PAGES: +# Enable 1G page size support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# PCID: +# Enable Process-Context Identifiers (PCID) support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# FSGSBASE: +# Enable GS/GS BASE access instructions support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# SMEP: +# Enable Supervisor Mode Execution Protection (SMEP) support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SMAP: +# Enable Supervisor Mode Access Prevention (SMAP) support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MWAIT: +# Select MONITOR/MWAIT instructions support. +# This option exists only if Bochs compiled with --enable-monitor-mwait. +# +# VMX: +# Select VMX extensions emulation support. +# This option exists only if Bochs compiled with --enable-vmx option. +# +# SVM: +# Select AMD SVM (Secure Virtual Machine) extensions emulation support. +# This option exists only if Bochs compiled with --enable-svm option. +# +# VENDOR_STRING: +# Set the CPUID vendor string returned by CPUID(0x0). This should be a +# twelve-character ASCII string. +# +# BRAND_STRING: +# Set the CPUID vendor string returned by CPUID(0x80000002 .. 0x80000004). +# This should be at most a forty-eight-character ASCII string. +# +# LEVEL: +# Set emulated CPU level information returned by CPUID. Default value is +# determined by configure option --enable-cpu-level. Currently supported +# values are 5 (for Pentium and similar processors) and 6 (for P6 and +# later processors). +# +# FAMILY: +# Set model information returned by CPUID. Default family value determined +# by configure option --enable-cpu-level. +# +# MODEL: +# Set model information returned by CPUID. Default model value is 3. +# +# STEPPING: +# Set stepping information returned by CPUID. Default stepping value is 3. +#======================================================================= +#cpuid: x86_64=1, mmx=1, sep=1, simd=sse4_2, apic=xapic, aes=1, movbe=1, xsave=1 +#cpuid: family=6, model=0x1a, stepping=5 + +#======================================================================= +# MEMORY +# Set the amount of physical memory you want to emulate. +# +# GUEST: +# Set amount of guest physical memory to emulate. The default is 32MB, +# the maximum amount limited only by physical address space limitations. +# +# HOST: +# Set amount of host memory you want to allocate for guest RAM emulation. +# It is possible to allocate less memory than you want to emulate in guest +# system. This will fake guest to see the non-existing memory. Once guest +# system touches new memory block it will be dynamically taken from the +# memory pool. You will be warned (by FATAL PANIC) in case guest already +# used all allocated host memory and wants more. +# +#======================================================================= +#memory: guest=512, host=256 + +#======================================================================= +# ROMIMAGE: +# The ROM BIOS controls what the PC does when it first powers on. +# Normally, you can use a precompiled BIOS in the source or binary +# distribution called BIOS-bochs-latest. The default ROM BIOS is usually loaded +# starting at address 0xfffe0000, and it is exactly 128k long. The legacy +# version of the Bochs BIOS is usually loaded starting at address 0xffff0000, +# and it is exactly 64k long. +# You can use the environment variable $BXSHARE to specify the location +# of the BIOS. +# The usage of external large BIOS images (up to 512k) at memory top is +# now supported, but we still recommend to use the BIOS distributed with Bochs. +# The start address is optional, since it can be calculated from image size. +# The Bochs BIOS currently supports only the option "fastboot" to skip the +# boot menu delay. +#======================================================================= +romimage: file=$BXSHARE/BIOS-bochs-latest, options=fastboot +#romimage: file=$BXSHARE/bios.bin-1.7.5 # http://www.seabios.org/SeaBIOS +#romimage: file=mybios.bin, address=0xfff80000 # 512k at memory top +#romimage: file=BIOS-bochs-latest, options=fastboot + +#======================================================================= +# VGAROMIMAGE +# You now need to load a VGA ROM BIOS into C0000. +#======================================================================= +#vgaromimage: file=$BXSHARE/VGABIOS-elpin-2.40 +vgaromimage: file=$BXSHARE/VGABIOS-lgpl-latest +#vgaromimage: file=bios/VGABIOS-lgpl-latest-cirrus + +#======================================================================= +# OPTROMIMAGE[1-4]: +# You may now load up to 4 optional ROM images. Be sure to use a +# read-only area, typically between C8000 and EFFFF. These optional +# ROM images should not overwrite the rombios (located at +# F0000-FFFFF) and the videobios (located at C0000-C7FFF). +# Those ROM images will be initialized by the bios if they contain +# the right signature (0x55AA) and a valid checksum. +# It can also be a convenient way to upload some arbitrary code/data +# in the simulation, that can be retrieved by the boot loader +#======================================================================= +#optromimage1: file=optionalrom.bin, address=0xd0000 +#optromimage2: file=optionalrom.bin, address=0xd1000 +#optromimage3: file=optionalrom.bin, address=0xd2000 +#optromimage4: file=optionalrom.bin, address=0xd3000 + +#optramimage1: file=/path/file1.img, address=0x0010000 +#optramimage2: file=/path/file2.img, address=0x0020000 +#optramimage3: file=/path/file3.img, address=0x0030000 +#optramimage4: file=/path/file4.img, address=0x0040000 + +#======================================================================= +# VGA: +# This defines parameters related to the VGA display +# +# EXTENSION +# Here you can specify the display extension to be used. With the value +# 'none' you can use standard VGA with no extension. Other supported +# values are 'vbe' for Bochs VBE, 'cirrus' for Cirrus SVGA support and +# 'voodoo' for Voodoo Graphics support (see 'voodoo' option). +# +# UPDATE_FREQ +# This parameter specifies the number of display updates per second. +# The VGA update timer by default uses the realtime engine with a value +# of 5. This parameter can be changed at runtime. +# +# REALTIME +# If set to 1 (default), the VGA timer is based on realtime, otherwise it +# is driven by the cpu and depends on the ips setting. If the host is slow +# (low ips, update_freq) and the guest uses HLT appropriately, setting this +# to 0 and "clock: sync=none" may improve the responsiveness of the guest +# GUI when the guest is otherwise idle. +# +# Examples: +# vga: extension=cirrus, update_freq=10 +#======================================================================= +vga: extension=vbe, update_freq=5, realtime=1 + +#======================================================================= +# VOODOO: +# This defines the Voodoo Graphics emulation (experimental). Currently +# supported models are 'voodoo1', 'voodoo2', 'banshee' and 'voodoo3'. The +# Voodoo2 support is not yet complete, but almost usable. The Banshee and +# Voodoo3 support is under construction, but basicly usable. The 2D/3D cards +# require an external VGA BIOS the vga extension option to be set to 'voodoo'. +# If the i440BX PCI chipset is selected, they can be assigned to AGP (slot #5). +# The gui screen update timing for all models is controlled by the related 'vga' +# options. +# +# Examples: +# voodoo: enabled=1, model=voodoo2 +#======================================================================= +#voodoo: enabled=1, model=voodoo1 + +#======================================================================= +# KEYBOARD: +# This defines parameters related to the emulated keyboard +# +# TYPE: +# Type of keyboard return by a "identify keyboard" command to the +# keyboard controller. It must be one of "xt", "at" or "mf". +# Defaults to "mf". It should be ok for almost everybody. A known +# exception is french macs, that do have a "at"-like keyboard. +# +# SERIAL_DELAY: +# Approximate time in microseconds that it takes one character to +# be transferred from the keyboard to controller over the serial path. +# +# PASTE_DELAY: +# Approximate time in microseconds between attempts to paste +# characters to the keyboard controller. This leaves time for the +# guest os to deal with the flow of characters. The ideal setting +# depends on how your operating system processes characters. The +# default of 100000 usec (.1 seconds) was chosen because it works +# consistently in Windows. +# If your OS is losing characters during a paste, increase the paste +# delay until it stops losing characters. +# +# KEYMAP: +# This enables a remap of a physical localized keyboard to a +# virtualized us keyboard, as the PC architecture expects. +# +# USER_SHORTCUT: +# This defines the keyboard shortcut to be sent when you press the "user" +# button in the headerbar. The shortcut string is a combination of maximum +# 3 key names (listed below) separated with a '-' character. +# Valid key names: +# "alt", "bksl", "bksp", "ctrl", "del", "down", "end", "enter", "esc", +# "f1", ... "f12", "home", "ins", "left", "menu", "minus", "pgdwn", "pgup", +# "plus", "power", "print", "right", "scrlck", "shift", "space", "tab", "up" +# and "win". + +# Examples: +# keyboard: type=mf, serial_delay=200, paste_delay=100000 +# keyboard: keymap=gui/keymaps/x11-pc-de.map +# keyboard: user_shortcut=ctrl-alt-del +#======================================================================= +keyboard: type=mf, serial_delay=250 + +#======================================================================= +# MOUSE: +# This defines parameters for the emulated mouse type, the initial status +# of the mouse capture and the runtime method to toggle it. +# +# TYPE: +# With the mouse type option you can select the type of mouse to emulate. +# The default value is 'ps2'. The other choices are 'imps2' (wheel mouse +# on PS/2), 'serial', 'serial_wheel', 'serial_msys' (one com port requires +# setting 'mode=mouse') 'inport' and 'bus' (if present). To connect a mouse +# to a USB port, see the 'usb_uhci', 'usb_ohci', 'usb_ehci' or 'usb_xhci' +# options (requires PCI and USB support). +# +# ENABLED: +# The Bochs gui creates mouse "events" unless the 'enabled' option is +# set to 0. The hardware emulation itself is not disabled by this. +# Unless you have a particular reason for enabling the mouse by default, +# it is recommended that you leave it off. You can also toggle the mouse +# usage at runtime (RFB, SDL, Win32, wxWidgets and X11 - see below). +# +# TOGGLE: +# The default method to toggle the mouse capture at runtime is to press the +# CTRL key and the middle mouse button ('ctrl+mbutton'). This option allows +# to change the method to 'ctrl+f10' (like DOSBox), 'ctrl+alt' (like QEMU) +# or 'f12'. +# +# Examples: +# mouse: enabled=1 +# mouse: type=imps2, enabled=1 +# mouse: type=serial, enabled=1 +# mouse: enabled=0, toggle=ctrl+f10 +#======================================================================= +mouse: enabled=1 + +#======================================================================= +# PCI: +# This option controls the presence of a PCI chipset in Bochs. Currently it +# supports the i430FX, i440FX and i440BX chipsets. You can also specify the +# devices connected to PCI slots. Up to 5 slots are available. For these +# combined PCI/ISA devices assigning to slot is mandatory if you want to emulate +# the PCI model: cirrus, ne2k and pcivga. These PCI-only devices are also +# supported, but they are auto-assigned if you don't use the slot configuration: +# e1000, es1370, pcidev, pcipnic, usb_ehci, usb_ohci, usb_xhci and voodoo. +# In case of the i440BX chipset, slot #5 is the AGP slot. Currently only the +# 'voodoo' device can be assigned to AGP. +# +# Example: +# pci: enabled=1, chipset=i440fx, slot1=pcivga, slot2=ne2k +#======================================================================= +pci: enabled=1, chipset=i440fx + +#======================================================================= +# CLOCK: +# This defines the parameters of the clock inside Bochs: +# +# SYNC: +# This defines the method how to synchronize the Bochs internal time +# with realtime. With the value 'none' the Bochs time relies on the IPS +# value and no host time synchronization is used. The 'slowdown' method +# sacrifices performance to preserve reproducibility while allowing host +# time correlation. The 'realtime' method sacrifices reproducibility to +# preserve performance and host-time correlation. +# It is possible to enable both synchronization methods. +# +# RTC_SYNC: +# If this option is enabled together with the realtime synchronization, +# the RTC runs at realtime speed. This feature is disabled by default. +# +# TIME0: +# Specifies the start (boot) time of the virtual machine. Use a time +# value as returned by the time(2) system call or a string as returned +# by the ctime(3) system call. If no time0 value is set or if time0 +# equal to 1 (special case) or if time0 equal 'local', the simulation +# will be started at the current local host time. If time0 equal to 2 +# (special case) or if time0 equal 'utc', the simulation will be started +# at the current utc time. +# +# Syntax: +# clock: sync=[none|slowdown|realtime|both], time0=[timeValue|local|utc] +# +# Example: +# clock: sync=none, time0=local # Now (localtime) +# clock: sync=slowdown, time0=315529200 # Tue Jan 1 00:00:00 1980 +# clock: sync=none, time0="Mon Jan 1 00:00:00 1990" # 631148400 +# clock: sync=realtime, time0=938581955 # Wed Sep 29 07:12:35 1999 +# clock: sync=realtime, time0="Sat Jan 1 00:00:00 2000" # 946681200 +# clock: sync=none, time0=1 # Now (localtime) +# clock: sync=none, time0=utc # Now (utc/gmt) +# +# Default value are sync=none, rtc_sync=0, time0=local +#======================================================================= +clock: sync=slowdown, time0=315529200 + +#======================================================================= +# CMOSIMAGE: +# This defines a binary image file with size 128 bytes that can be loaded into +# the CMOS RAM at startup. The rtc_init parameter controls whether initialize +# the RTC with values stored in the image. By default the time0 argument given +# to the clock option is used. With 'rtc_init=image' the image is the source +# for the initial time. +# +# Example: +# cmosimage: file=cmos.img, rtc_init=image +#======================================================================= +#cmosimage: file=cmos.img, rtc_init=time0 + +#======================================================================= +# private_colormap: Request that the GUI create and use it's own +# non-shared colormap. This colormap will be used +# when in the bochs window. If not enabled, a +# shared colormap scheme may be used. Not implemented +# on all GUI's. +# +# Examples: +# private_colormap: enabled=1 +# private_colormap: enabled=0 +#======================================================================= +private_colormap: enabled=0 + +#======================================================================= +# FLOPPYA: +# Point this to pathname of floppy image file or device +# This should be of a bootable floppy(image/device) if you're +# booting from 'a' (or 'floppy'). +# +# You can set the initial status of the media to 'ejected' or 'inserted'. +# floppya: 2_88=path, status=ejected (2.88M 3.5" media) +# floppya: 1_44=path, status=inserted (1.44M 3.5" media) +# floppya: 1_2=path, status=ejected (1.2M 5.25" media) +# floppya: 720k=path, status=inserted (720K 3.5" media) +# floppya: 360k=path, status=inserted (360K 5.25" media) +# floppya: 320k=path, status=inserted (320K 5.25" media) +# floppya: 180k=path, status=inserted (180K 5.25" media) +# floppya: 160k=path, status=inserted (160K 5.25" media) +# floppya: image=path, status=inserted (guess media type from image size) +# floppya: 1_44=vvfat:path, status=inserted (use directory as VFAT media) +# floppya: type=1_44 (1.44M 3.5" floppy drive, no media) +# +# The path should be the name of a disk image file. On Unix, you can use a raw +# device name such as /dev/fd0 on Linux. On win32 platforms, use drive letters +# such as a: or b: as the path. The parameter 'image' works with image files +# only. In that case the size must match one of the supported types. +# The parameter 'type' can be used to enable the floppy drive without media +# and status specified. Usually the drive type is set up based on the media type. +# The optional parameter 'write_protected' can be used to control the media +# write protect switch. By default it is turned off. +#======================================================================= +#floppya: 1_44=, status=inserted +#floppya: image=../1.44, status=inserted +#floppya: 1_44=/dev/fd0H1440, status=inserted +#floppya: 1_2=../1_2, status=inserted +#floppya: 1_44=a:, status=inserted +#floppya: 1_44=a.img, status=inserted, write_protected=1 +#floppya: 1_44=/dev/rfd0a, status=inserted +#floppya: 1_44=boot.img, status=inserted, write_protected=1 + +#======================================================================= +# FLOPPYB: +# See FLOPPYA above for syntax +#======================================================================= +#floppyb: 1_44=b:, status=inserted +#floppyb: 1_44=b.img, status=inserted + +#======================================================================= +# ATA0, ATA1, ATA2, ATA3 +# ATA controller for hard disks and cdroms +# +# ata[0-3]: enabled=[0|1], ioaddr1=addr, ioaddr2=addr, irq=number +# +# These options enables up to 4 ata channels. For each channel +# the two base io addresses and the irq must be specified. +# +# ata0 and ata1 are enabled by default with the values shown below +# +# Examples: +# ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +# ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15 +# ata2: enabled=1, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +# ata3: enabled=1, ioaddr1=0x168, ioaddr2=0x360, irq=9 +#======================================================================= +ata0: enabled=0, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +ata1: enabled=0, ioaddr1=0x170, ioaddr2=0x370, irq=15 +ata2: enabled=0, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +ata3: enabled=0, ioaddr1=0x168, ioaddr2=0x360, irq=9 + +#======================================================================= +# ATA[0-3]-MASTER, ATA[0-3]-SLAVE +# +# This defines the type and characteristics of all attached ata devices: +# type= type of attached device [disk|cdrom] +# mode= only valid for disks [flat|concat|external|dll|sparse|vmware3] +# [vmware4|undoable|growing|volatile|vpc] +# [vbox|vvfat] +# path= path of the image / directory +# cylinders= only valid for disks +# heads= only valid for disks +# spt= only valid for disks +# status= only valid for cdroms [inserted|ejected] +# biosdetect= type of biosdetection [auto|cmos|none] +# translation=type of translation of the bios, only for disks [none|lba|large|rechs|auto] +# model= string returned by identify device command +# journal= optional filename of the redolog for undoable, volatile and vvfat disks +# +# Point this at a hard disk image file, cdrom iso file, or physical cdrom +# device. To create a hard disk image, try running bximage. It will help you +# choose the size and then suggest a line that works with it. +# +# In UNIX it may be possible to use a raw device as a Bochs hard disk, +# but WE DON'T RECOMMEND IT. In Windows there is no easy way. +# +# In windows, the drive letter + colon notation should be used for cdroms. +# Depending on versions of windows and drivers, you may only be able to +# access the "first" cdrom in the system. On MacOSX, use path="drive" +# to access the physical drive. +# +# The path is mandatory for hard disks. Disk geometry autodetection works with +# images created by bximage if CHS is set to 0/0/0 (cylinders are calculated +# using heads=16 and spt=63). For other hard disk images and modes the +# cylinders, heads, and spt are mandatory. In all cases the disk size reported +# from the image must be exactly C*H*S*512. +# +# Default values are: +# mode=flat, biosdetect=auto, translation=auto, model="Generic 1234" +# +# The biosdetect option has currently no effect on the bios +# +# Examples: +# ata0-master: type=disk, mode=flat, path=10M.sample, cylinders=306, heads=4, spt=17 +# ata0-slave: type=disk, mode=flat, path=20M.sample, cylinders=615, heads=4, spt=17 +# ata1-master: type=disk, mode=flat, path=30M.sample, cylinders=615, heads=6, spt=17 +# ata1-slave: type=disk, mode=flat, path=46M.sample, cylinders=940, heads=6, spt=17 +# ata2-master: type=disk, mode=flat, path=62M.sample, cylinders=940, heads=8, spt=17 +# ata2-slave: type=disk, mode=flat, path=112M.sample, cylinders=900, heads=15, spt=17 +# ata3-master: type=disk, mode=flat, path=483M.sample, cylinders=1024, heads=15, spt=63 +# ata3-slave: type=cdrom, path=iso.sample, status=inserted +#======================================================================= +#ata0-master: type=disk, mode=flat, path="30M.sample" +#ata0-master: type=disk, mode=flat, path="30M.sample", cylinders=615, heads=6, spt=17 +#ata0-master: type=disk, mode=flat, path="c.img", cylinders=0 # autodetect +#ata0-slave: type=disk, mode=vvfat, path=/bochs/images/vvfat, journal=vvfat.redolog +#ata0-slave: type=cdrom, path=D:, status=inserted +#ata0-slave: type=cdrom, path=/dev/cdrom, status=inserted +#ata0-slave: type=cdrom, path="drive", status=inserted +#ata0-slave: type=cdrom, path=/dev/rcd0d, status=inserted + +#======================================================================= +# BOOT: +# This defines the boot sequence. Now you can specify up to 3 boot drives, +# which can be 'floppy', 'disk', 'cdrom' or 'network' (boot ROM). +# Legacy 'a' and 'c' are also supported. +# Examples: +# boot: floppy +# boot: cdrom, disk +# boot: network, disk +# boot: cdrom, floppy, disk +#======================================================================= +boot: floppy +#boot: disk + +#======================================================================= +# FLOPPY_BOOTSIG_CHECK: disabled=[0|1] +# Enables or disables the 0xaa55 signature check on boot floppies +# Defaults to disabled=0 +# Examples: +# floppy_bootsig_check: disabled=0 +# floppy_bootsig_check: disabled=1 +#======================================================================= +floppy_bootsig_check: disabled=0 + +#======================================================================= +# LOG: +# Give the path of the log file you'd like Bochs debug and misc. verbiage +# to be written to. If you don't use this option or set the filename to +# '-' the output is written to the console. If you really don't want it, +# make it "/dev/null" (Unix) or "nul" (win32). :^( +# +# Examples: +# log: ./bochs.out +# log: /dev/tty +#======================================================================= +#log: /dev/null +log: .bochs.log + +#======================================================================= +# LOGPREFIX: +# This handles the format of the string prepended to each log line. +# You may use those special tokens : +# %t : 11 decimal digits timer tick +# %i : 8 hexadecimal digits of cpu current eip (ignored in SMP configuration) +# %e : 1 character event type ('i'nfo, 'd'ebug, 'p'anic, 'e'rror) +# %d : 5 characters string of the device, between brackets +# +# Default : %t%e%d +# Examples: +# logprefix: %t-%e-@%i-%d +# logprefix: %i%e%d +#======================================================================= +logprefix: %t%e%d + +#======================================================================= +# LOG CONTROLS +# +# Bochs has four severity levels for event logging. +# panic: cannot proceed. If you choose to continue after a panic, +# don't be surprised if you get strange behavior or crashes. +# error: something went wrong, but it is probably safe to continue the +# simulation. +# info: interesting or useful messages. +# debug: messages useful only when debugging the code. This may +# spit out thousands per second. +# +# For events of each level, you can choose to exit Bochs ('fatal'), 'ask', +# 'warn', 'report' or 'ignore'. The choices 'ask' and 'warn' are not supported +# by all guis, since they should bring up a dialog box. The 'warn' dialog is +# designed to confirm errors and the 'ask' dialog is usually used for panics +# and asks the user how to proceed. +# +# It is also possible to specify the 'action' to do for each Bochs facility +# separately (e.g. crash on panics from everything except the cdrom, and only +# report those). See the 'log function' module list in the user documentation. +# +# If you are experiencing many panics, it can be helpful to change +# the panic action to report instead of fatal. However, be aware +# that anything executed after a panic is uncharted territory and can +# cause bochs to become unstable. The panic is a "graceful exit," so +# if you disable it you may get a spectacular disaster instead. +#======================================================================= +panic: action=ask +error: action=report +info: action=report +debug: action=ignore #, pci=report # report BX_DEBUG from module 'pci' + +#======================================================================= +# DEBUGGER_LOG: +# Give the path of the log file you'd like Bochs to log debugger output. +# If you really don't want it, make it /dev/null or '-'. :^( +# +# Examples: +# debugger_log: ./debugger.out +#======================================================================= +#debugger_log: /dev/null +#debugger_log: debugger.out +debugger_log: - + +#======================================================================= +# COM1, COM2, COM3, COM4: +# This defines a serial port (UART type 16550A). In the 'term' mode you can +# specify a device to use as com1. This can be a real serial line, or a pty. +# To use a pty (under X/Unix), create two windows (xterms, usually). One of +# them will run bochs, and the other will act as com1. Find out the tty the com1 +# window using the `tty' command, and use that as the `dev' parameter. +# Then do `sleep 1000000' in the com1 window to keep the shell from +# messing with things, and run bochs in the other window. Serial I/O to +# com1 (port 0x3f8) will all go to the other window. +# In socket* and pipe* (win32 only) modes Bochs becomes either socket/named pipe +# client or server. In client mode it connects to an already running server (if +# connection fails Bochs treats com port as not connected). In server mode it +# opens socket/named pipe and waits until a client application connects to it +# before starting simulation. This mode is useful for remote debugging (e.g. +# with gdb's "target remote host:port" command or windbg's command line option +# -k com:pipe,port=\\.\pipe\pipename). Socket modes use simple TCP communication, +# pipe modes use duplex byte mode pipes. +# Other serial modes are 'null' (no input/output), 'file' (output to a file +# specified as the 'dev' parameter and changeable at runtime), 'raw' (use the +# real serial port - partly implemented on win32), 'mouse' (standard serial +# mouse - requires mouse option setting 'type=serial', 'type=serial_wheel' or +# 'type=serial_msys'). +# +# Examples: +# com1: enabled=1, mode=null +# com1: enabled=1, mode=mouse +# com2: enabled=1, mode=file, dev=serial.out +# com3: enabled=1, mode=raw, dev=com1 +# com3: enabled=1, mode=socket-client, dev=localhost:8888 +# com3: enabled=1, mode=socket-server, dev=localhost:8888 +# com4: enabled=1, mode=pipe-client, dev=\\.\pipe\mypipe +# com4: enabled=1, mode=pipe-server, dev=\\.\pipe\mypipe +#======================================================================= +com1: enabled=1, mode=file, dev=/dev/stdout + +#======================================================================= +# PARPORT1, PARPORT2: +# This defines a parallel (printer) port. When turned on and an output file is +# defined the emulated printer port sends characters printed by the guest OS +# into the output file. On some platforms a device filename can be used to +# send the data to the real parallel port (e.g. "/dev/lp0" on Linux, "lpt1" on +# win32 platforms). The output file can be changed at runtime. +# +# Examples: +# parport1: enabled=1, file="parport.out" +# parport2: enabled=1, file="/dev/lp0" +# parport1: enabled=0 +#======================================================================= +#parport1: enabled=1, file="parport.out" + +#======================================================================= +# SOUND: +# This defines the lowlevel sound driver(s) for the wave (PCM) input / output +# and the MIDI output feature and (if necessary) the devices to be used. +# It can have several of the following properties. +# All properties are in the format sound: property=value +# +# waveoutdrv: +# This defines the driver to be used for the waveout feature. +# Possible values are 'file' (all wave data sent to file), 'dummy' (no +# output) and the platform-dependant drivers 'alsa', 'oss', 'osx', 'sdl' +# and 'win'. +# waveout: +# This defines the device to be used for wave output (if necessary) or +# the output file for the 'file' driver. +# waveindrv: +# This defines the driver to be used for the wavein feature. +# Possible values are 'dummy' (recording silence) and platform-dependent +# drivers 'alsa', 'oss', 'sdl' and 'win'. +# wavein: +# This defines the device to be used for wave input (if necessary). +# midioutdrv: +# This defines the driver to be used for the MIDI output feature. +# Possible values are 'file' (all MIDI data sent to file), 'dummy' (no +# output) and platform-dependent drivers 'alsa', 'oss', 'osx' and 'win'. +# midiout: +# This defines the device to be used for MIDI output (if necessary). +# driver: +# This defines the driver to be used for all sound features with one +# property. Possible values are 'default' (platform default) and all +# other choices described above. Overriding one or more settings with +# the specific driver parameter is possible. +# +# Example for different drivers: +# sound: waveoutdrv=sdl, waveindrv=alsa, midioutdrv=dummy +#======================================================================= +#sound: driver=default, waveout=/dev/dsp. wavein=, midiout= + +#======================================================================= +# SPEAKER: +# This defines the PC speaker output mode. In the 'sound' mode the beep +# is generated by the square wave generator which is a part of the +# lowlevel sound support. The 'system' mode is only available on Linux +# and Windows. On Linux /dev/console is used for output and on Windows +# the Beep() function. The 'gui' mode forwards the beep to the related +# gui methods (currently only used by the Carbon gui). +#======================================================================= +#speaker: enabled=0, mode=sound + +#======================================================================= +# SB16: +# This defines the SB16 sound emulation. It can have several of the +# following properties. +# All properties are in the format sb16: property=value +# +# enabled: +# This optional property controls the presence of the SB16 emulation. +# The emulation is turned on unless this property is used and set to 0. +# midimode: This parameter specifies what to do with the MIDI output. +# 0 = no output +# 1 = output to device specified with the sound option (system dependent) +# 2 = MIDI or raw data output to file (depends on file name extension) +# 3 = dual output (mode 1 and 2 at the same time) +# midifile: This is the file where the midi output is stored (midimode 2 or 3). +# wavemode: This parameter specifies what to do with the PCM output. +# 0 = no output +# 1 = output to device specified with the sound option (system dependent) +# 2 = VOC, WAV or raw data output to file (depends on file name extension) +# 3 = dual output (mode 1 and 2 at the same time) +# wavefile: This is the file where the wave output is stored (wavemode 2 or 3). +# loglevel: +# 0=no log +# 1=resource changes, midi program and bank changes +# 2=severe errors +# 3=all errors +# 4=all errors plus all port accesses +# 5=all errors and port accesses plus a lot of extra info +# log: The file to write the sb16 emulator messages to. +# dmatimer: +# microseconds per second for a DMA cycle. Make it smaller to fix +# non-continuous sound. 750000 is usually a good value. This needs a +# reasonably correct setting for the IPS parameter of the CPU option. +# +# Examples for output modes: +# sb16: midimode=2, midifile="output.mid", wavemode=1 # MIDI to file +# sb16: midimode=1, wavemode=3, wavefile="output.wav" # wave to file and device +#======================================================================= +#sb16: midimode=1, wavemode=1, loglevel=2, log=sb16.log, dmatimer=600000 + +#======================================================================= +# ES1370: +# This defines the ES1370 sound emulation (recording and playback - except +# DAC1+DAC2 output at the same time). The parameter 'enabled' controls the +# presence of the device. The wave and MIDI output can be sent to device, file +# or both using the parameters 'wavemode', 'wavefile', 'midimode' and +# 'midifile'. See the description of these parameters at the SB16 directive. +# +# Examples: +# es1370: enabled=1, wavemode=1 # use 'sound' parameters +# es1370: enabled=1, wavemode=2, wavefile=output.voc # send output to file +#======================================================================= +#es1370: enabled=1, wavemode=1 + +#======================================================================= +# ne2k: NE2000 compatible ethernet adapter +# +# Format: +# ne2k: enabled=1, ioaddr=IOADDR, irq=IRQ, mac=MACADDR, ethmod=MODULE, +# ethdev=DEVICE, script=SCRIPT, bootrom=BOOTROM +# +# IOADDR, IRQ: You probably won't need to change ioaddr and irq, unless there +# are IRQ conflicts. These arguments are ignored when assign the ne2k to a +# PCI slot. +# +# MAC: The MAC address MUST NOT match the address of any machine on the net. +# Also, the first byte must be an even number (bit 0 set means a multicast +# address), and you cannot use ff:ff:ff:ff:ff:ff because that's the broadcast +# address. For the ethertap module, you must use fe:fd:00:00:00:01. There may +# be other restrictions too. To be safe, just use the b0:c4... address. +# +# ETHDEV: The ethdev value is the name of the network interface on your host +# platform. On UNIX machines, you can get the name by running ifconfig. On +# Windows machines, you must run niclist to get the name of the ethdev. +# Niclist source code is in misc/niclist.c and it is included in Windows +# binary releases. +# The 'socket' module uses this parameter to specify the UDP port for +# receiving packets and (optional) the host to connect. +# +# SCRIPT: The script value is optional, and is the name of a script that +# is executed after bochs initialize the network interface. You can use +# this script to configure this network interface, or enable masquerading. +# This is mainly useful for the tun/tap devices that only exist during +# Bochs execution. The network interface name is supplied to the script +# as first parameter. +# The 'slirp' module uses this parameter to specify a config file for +# setting up an alternative IP configuration or additional features. +# The 'vnet' module uses this parameter to specify an alternative +# log file name. +# +# BOOTROM: The bootrom value is optional, and is the name of the ROM image +# to load. Note that this feature is only implemented for the PCI version of +# the NE2000. +# +# If you don't want to make connections to any physical networks, +# you can use the following 'ethmod's to simulate a virtual network. +# null: All packets are discarded, but logged to a few files. +# vde: Virtual Distributed Ethernet +# vnet: ARP, ICMP-echo(ping), DHCP and read/write TFTP are simulated. +# The virtual host uses 192.168.10.1. +# DHCP assigns 192.168.10.2 to the guest. +# TFTP uses the 'ethdev' value for the root directory and doesn't +# overwrite files. +# socket: Connect up to 6 Bochs instances with external program 'bxhub' +# (simulating an ethernet hub). It provides the same services as the +# 'vnet' module and assigns IP addresses like 'slirp' (10.0.2.x). +# +#======================================================================= +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=fbsd, ethdev=en0 #macosx +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:00, ethmod=fbsd, ethdev=xl0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:00, ethmod=linux, ethdev=eth0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=win32, ethdev=MYCARD +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=tap, ethdev=tap0 +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=tuntap, ethdev=/dev/net/tun0, script=./tunconfig +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=null, ethdev=eth0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=vde, ethdev="/tmp/vde.ctl" +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=vnet, ethdev="c:/temp" +# ne2k: mac=b0:c4:20:00:00:01, ethmod=socket, ethdev=40000 # use localhost +# ne2k: mac=b0:c4:20:00:00:01, ethmod=socket, ethdev=mymachine:40000 +# ne2k: mac=b0:c4:20:00:00:01, ethmod=slirp, script=slirp.conf, bootrom=ne2k_pci.rom + +#======================================================================= +# pcipnic: Bochs/Etherboot pseudo-NIC +# +# Format: +# pcipnic: enabled=1, mac=MACADDR, ethmod=MODULE, ethdev=DEVICE, script=SCRIPT, +# bootrom=BOOTROM +# +# The pseudo-NIC accepts the same syntax (for mac, ethmod, ethdev, script, +# bootrom) and supports the same networking modules as the NE2000 adapter. +#======================================================================= +#pcipnic: enabled=1, mac=b0:c4:20:00:00:00, ethmod=vnet + +#======================================================================= +# e1000: Intel(R) 82540EM Gigabit Ethernet adapter +# +# Format: +# e1000: enabled=1, mac=MACADDR, ethmod=MODULE, ethdev=DEVICE, script=SCRIPT +# bootrom=BOOTROM +# +# The E1000 accepts the same syntax (for mac, ethmod, ethdev, script, bootrom) +# and supports the same networking modules as the NE2000 adapter. +#======================================================================= +#e1000: enabled=1, mac=52:54:00:12:34:56, ethmod=slirp, script=slirp.conf + +#======================================================================= +# USB_UHCI: +# This option controls the presence of the USB root hub which is a part +# of the i440FX PCI chipset. With the portX parameter you can connect devices +# to the hub (currently supported: 'mouse', 'tablet', 'keypad', 'disk', 'cdrom', +# 'floppy', 'hub' and 'printer'). +# +# If you connect the mouse or tablet to one of the ports, Bochs forwards the +# mouse movement data to the USB device instead of the selected mouse type. +# When connecting the keypad to one of the ports, Bochs forwards the input of +# the numeric keypad to the USB device instead of the PS/2 keyboard. +# +# To connect a 'flat' mode image as a USB hardisk you can use the 'disk' device +# with the path to the image separated with a colon. To use other disk image modes +# similar to ATA disks the syntax 'disk:mode:filename' must be used (see below). +# +# To emulate a USB cdrom you can use the 'cdrom' device name and the path to +# an ISO image or raw device name also separated with a colon. An option to +# insert/eject media is available in the runtime configuration. +# +# To emulate a USB floppy you can use the 'floppy' device with the path to the +# image separated with a colon. To use the VVFAT image mode similar to the +# legacy floppy the syntax 'floppy:vvfat:directory' must be used (see below). +# An option to insert/eject media is available in the runtime configuration. +# +# The device name 'hub' connects an external hub with max. 8 ports (default: 4) +# to the root hub. To specify the number of ports you have to add the value +# separated with a colon. Connecting devices to the external hub ports is only +# available in the runtime configuration. +# +# The device 'printer' emulates the HP Deskjet 920C printer. The PCL data is +# sent to a file specified in bochsrc.txt. The current code appends the PCL +# code to the file if the file already existed. The output file can be +# changed at runtime. +# +# The optionsX parameter can be used to assign specific options to the device +# connected to the corresponding USB port. Currently this feature is used to +# set the speed reported by device ('low', 'full', 'high' or 'super'). The +# availabe speed choices depend on both HC and device. The option 'debug' turns +# on debug output for the device at connection time. +# For the USB 'disk' device the optionsX parameter can be used to specify an +# alternative redolog file (journal) of some image modes. For 'vvfat' mode USB +# disks the optionsX parameter can be used to specify the disk size (range +# 128M ... 128G). If the size is not specified, it defaults to 504M. +# For the USB 'floppy' device the optionsX parameter can be used to specify an +# alternative device ID to be reported. Currently only the model "teac" is +# supported (can fix hw detection in some guest OS). The USB floppy also +# accepts the parameter "write_protected" with valid values 0 and 1 to select +# the access mode (default is 0). +#======================================================================= +#usb_uhci: enabled=1 +#usb_uhci: enabled=1, port1=mouse, port2=disk:usbstick.img +#usb_uhci: enabled=1, port1=hub:7, port2=disk:growing:usbdisk.img +#usb_uhci: enabled=1, port2=disk:undoable:usbdisk.img, options2=journal:redo.log +#usb_uhci: enabled=1, port2=disk:usbdisk2.img, options2=sect_size:1024 +#usb_uhci: enabled=1, port2=disk:vvfat:vvfat, options2="debug,speed:full" +#usb_uhci: enabled=1, port1=printer:printdata.bin, port2=cdrom:image.iso +#usb_uhci: enabled=1, port2=floppy:vvfat:diskette, options2="model:teac" + +#======================================================================= +# USB_OHCI: +# This option controls the presence of the USB OHCI host controller with a +# 2-port hub. The portX parameter accepts the same device types with the same +# syntax as the UHCI controller (see above). The optionsX parameter is also +# available on OHCI. +#======================================================================= +#usb_ohci: enabled=1 +#usb_ohci: enabled=1, port1=printer:usbprinter.bin + +#======================================================================= +# USB_EHCI: +# This option controls the presence of the USB EHCI host controller with a +# 6-port hub. The portX parameter accepts the same device types with the +# same syntax as the UHCI controller (see above). The optionsX parameter is +# also available on EHCI. +#======================================================================= +#usb_ehci: enabled=1 + +#======================================================================= +# USB_XHCI: +# This option controls the presence of the USB xHCI host controller with a +# 4-port hub. The portX parameter accepts the same device types with the +# same syntax as the UHCI controller (see above). The optionsX parameter is +# also available on xHCI. NOTE: port 1 and 2 are USB3 and only support +# super-speed devices, but port 3 and 4 are USB2 and support speed settings +# low, full and high. +#======================================================================= +#usb_xhci: enabled=1 + +#======================================================================= +# PCIDEV: +# PCI host device mapping +# WARNING: This Bochs feature is not maintained yet and may fail. +#======================================================================= +#pcidev: vendor=0x1234, device=0x5678 + +#======================================================================= +# GDBSTUB: +# Enable GDB stub. See user documentation for details. +# Default value is enabled=0. +# WARNING: This Bochs feature is not maintained yet and may fail. +#======================================================================= +#gdbstub: enabled=0, port=1234, text_base=0, data_base=0, bss_base=0 + +#======================================================================= +# MAGIC_BREAK: +# This enables the "magic breakpoint" feature when using the debugger. +# The useless cpu instruction XCHG BX, BX causes Bochs to enter the +# debugger mode. This might be useful for software development. +# +# Example: +# magic_break: enabled=1 +#======================================================================= +magic_break: enabled=1 + +#======================================================================= +# DEBUG_SYMBOLS: +# This loads symbols from the specified file for use in Bochs' internal +# debugger. Symbols are loaded into global context. This is equivalent to +# issuing ldsym debugger command at start up. +# +# Example: +# debug_symbols: file="kernel.sym" +# debug_symbols: file="kernel.sym", offset=0x80000000 +#======================================================================= +#debug_symbols: file="kernel.sym" + +#print_timestamps: enabled=1 + +#======================================================================= +# PORT_E9_HACK: +# The 0xE9 port doesn't exists in normal ISA architecture. However, we +# define a convention here, to display on the console of the system running +# Bochs anything that is written to it. The idea is to provide debug output +# very early when writing BIOS or OS code for example, without having to +# bother with setting up a serial port or etc. Reading from port 0xE9 will +# will return 0xe9 to let you know if the feature is available. +# Leave this 0 unless you have a reason to use it. +# +# Example: +# port_e9_hack: enabled=1 +#======================================================================= +#port_e9_hack: enabled=1 + +#======================================================================= +# other stuff +#======================================================================= +# WARNING: This Bochs feature is not maintained yet. Is it still used ? +# To use it, set BX_LOAD32BITOSHACK in config.h to 1 and recompile Bochs. +#load32bitOSImage: os=nullkernel, path=../kernel.img, iolog=../vga_io.log +#load32bitOSImage: os=linux, path=../linux.img, iolog=../vga_io.log, initrd=../initrd.img + +#======================================================================= +# fullscreen: ONLY IMPLEMENTED ON AMIGA +# Request that Bochs occupy the entire screen instead of a +# window. +# +# Examples: +# fullscreen: enabled=0 +# fullscreen: enabled=1 +#======================================================================= +#fullscreen: enabled=0 +#screenmode: name="sample" + +#======================================================================= +# USER_PLUGIN: +# Load user-defined plugin. This option is available only if Bochs is +# compiled with plugin support. Maximum 8 different plugins are supported. +# See the example in the Bochs sources how to write a plugin device. +#======================================================================= +#user_plugin: name=testdev + +#======================================================================= +# for Macintosh, use the style of pathnames in the following +# examples. +# +# vgaromimage: :bios:VGABIOS-elpin-2.40 +# romimage: file=:bios:BIOS-bochs-latest, address=0xf0000 +# floppya: 1_44=[fd:], status=inserted +#======================================================================= + +#======================================================================= +# MEGS +# Set the number of Megabytes of physical memory you want to emulate. +# The default is 32MB, most OS's won't need more than that. +# The maximum amount of memory supported is 2048Mb. +# The 'MEGS' option is deprecated. Use 'MEMORY' option instead. +#======================================================================= +#megs: 256 +#megs: 128 +#megs: 64 +#megs: 32 +#megs: 16 +#megs: 8 diff --git a/ape/etc/bochsrc.ffs b/ape/etc/bochsrc.ffs new file mode 100644 index 00000000..3467144e --- /dev/null +++ b/ape/etc/bochsrc.ffs @@ -0,0 +1,1294 @@ +# The default state is the unsafest state with Bochs, which makes it nearly +# impossible to script. Here we'll attempt to turn off as much of its +# functionality as possible, so we can have a non-interactive mode. + +#======================================================================= +# PLUGIN_CTRL: +# Controls the presence of optional device plugins. These plugins are loaded +# directly with this option and some of them install a config option that is +# only available when the plugin device is loaded. The value "1" means to load +# the plugin and "0" will unload it (if loaded before). +# +# These plugins will be loaded by default (if present): 'biosdev', 'extfpuirq', +# 'gameport', 'iodebug','parallel', 'serial', 'speaker' and 'unmapped'. +# +# These plugins are also supported, but they are usually loaded directly with +# their bochsrc option: 'e1000', 'es1370', 'ne2k', 'pcidev', 'pcipnic', 'sb16', +# 'usb_ehci', 'usb_ohci', 'usb_uhci', 'usb_xhci' and 'voodoo'. +#======================================================================= +#plugin_ctrl: unmapped=0, e1000=1 # unload 'unmapped' and load 'e1000' +plugin_ctrl: biosdev=0, iodebug=0 + +#======================================================================= +# CONFIG_INTERFACE +# +# The configuration interface is a series of menus or dialog boxes that +# allows you to change all the settings that control Bochs's behavior. +# Depending on the platform there are up to 3 choices of configuration +# interface: a text mode version called "textconfig" and two graphical versions +# called "win32config" and "wx". The text mode version uses stdin/stdout and +# is always compiled in, unless Bochs is compiled for wx only. The choice +# "win32config" is only available on win32 and it is the default there. +# The choice "wx" is only available when you use "--with-wx" on the configure +# command. If you do not write a config_interface line, Bochs will +# choose a default for you. +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +#======================================================================= +#config_interface: textconfig +#config_interface: win32config +#config_interface: wx + +#======================================================================= +# DISPLAY_LIBRARY +# +# The display library is the code that displays the Bochs VGA screen. Bochs +# has a selection of about 10 different display library implementations for +# different platforms. If you run configure with multiple --with-* options, +# the display_library command lets you choose which one you want to run with. +# If you do not write a display_library line, Bochs will choose a default for +# you. +# +# The choices are: +# x use X windows interface, cross platform +# win32 use native win32 libraries +# carbon use Carbon library (for MacOS X) +# macintosh use MacOS pre-10 +# amigaos use native AmigaOS libraries +# sdl use SDL 1.2.x library, cross platform +# sdl2 use SDL 2.x library, cross platform +# svga use SVGALIB library for Linux, allows graphics without X11 +# term text only, uses curses/ncurses library, cross platform +# rfb provides an interface to AT&T's VNC viewer, cross platform +# vncsrv use LibVNCServer for extended RFB(VNC) support +# wx use wxWidgets library, cross platform +# nogui no display at all +# +# NOTE: if you use the "wx" configuration interface, you must also use +# the "wx" display library. +# +# Specific options: +# Some display libraries now support specific options to control their +# behaviour. These options are supported by more than one display library: +# +# "gui_debug" - use GTK debugger gui (sdl, sdl2, x) / Win32 debugger gui (sdl, +# sdl2, win32) +# "hideIPS" - disable IPS output in status bar (rfb, sdl, sdl2, vncsrv, +# win32, wx, x) +# "nokeyrepeat" - turn off host keyboard repeat (sdl, sdl2, win32, x) +# "timeout" - time (in seconds) to wait for client (rfb, vncsrv) +# +# See the examples below for other currently supported options. +#======================================================================= +#display_library: amigaos +#display_library: carbon +#display_library: macintosh +display_library: nogui +#display_library: rfb +#display_library: sdl, options="fullscreen" # startup in fullscreen mode +#display_library: sdl2, options="fullscreen" # startup in fullscreen mode +#display_library: term +#display_library: vncsrv +# "traphotkeys" - system hotkeys not handled by host OS, but sent to guest +# (win32 in mouse capture and fullscreen mode: alt-tab, win, +# alt-space, alt-esc, ctrl-esc) +#display_library: win32, options="traphotkeys" +#display_library: wx +#display_library: x, gui_debug=1 +#display_library: x, options="gui_debug" + +#======================================================================= +# CPU: +# This defines cpu-related parameters inside Bochs: +# +# MODEL: +# Selects CPU configuration to emulate from pre-defined list of all +# supported configurations. When this option is used and the value +# is different from 'bx_generic', the parameters of the CPUID option +# have no effect anymore. +# +# CPU configurations that can be selected: +# ----------------------------------------------------------------- +# pentium Intel Pentium (P54C) +# pentium_mmx Intel Pentium MMX +# amd_k6_2_chomper AMD-K6(tm) 3D processor (Chomper) +# p2_klamath Intel Pentium II (Klamath) +# p3_katmai Intel Pentium III (Katmai) +# p4_willamette Intel(R) Pentium(R) 4 (Willamette) +# core_duo_t2400_yonah Intel(R) Core(TM) Duo CPU T2400 (Yonah) +# atom_n270 Intel(R) Atom(TM) CPU N270 +# p4_prescott_celeron_336 Intel(R) Celeron(R) 336 (Prescott) +# athlon64_clawhammer AMD Athlon(tm) 64 Processor 2800+ (Clawhammer) +# athlon64_venice AMD Athlon(tm) 64 Processor 3000+ (Venice) +# turion64_tyler AMD Turion(tm) 64 X2 Mobile TL-60 (Tyler) +# phenom_8650_toliman AMD Phenom X3 8650 (Toliman) +# core2_penryn_t9600 Intel Mobile Core 2 Duo T9600 (Penryn) +# corei5_lynnfield_750 Intel(R) Core(TM) i5 750 (Lynnfield) +# corei5_arrandale_m520 Intel(R) Core(TM) i5 M 520 (Arrandale) +# corei7_sandy_bridge_2600k Intel(R) Core(TM) i7-2600K (Sandy Bridge) +# zambezi AMD FX(tm)-4100 Quad-Core Processor (Zambezi) +# trinity_apu AMD A8-5600K APU (Trinity) +# ryzen AMD Ryzen 7 1700 +# corei7_ivy_bridge_3770k Intel(R) Core(TM) i7-3770K CPU (Ivy Bridge) +# corei7_haswell_4770 Intel(R) Core(TM) i7-4770 CPU (Haswell) +# broadwell_ult Intel(R) Processor 5Y70 CPU (Broadwell) +# +# COUNT: +# Set the number of processors:cores per processor:threads per core when +# Bochs is compiled for SMP emulation. Bochs currently supports up to +# 14 threads (legacy APIC) or 254 threads (xAPIC or higher) running +# simultaniosly. If Bochs is compiled without SMP support, it won't accept +# values different from 1. +# +# QUANTUM: +# Maximum amount of instructions allowed to execute by processor before +# returning control to another cpu. This option exists only in Bochs +# binary compiled with SMP support. +# +# RESET_ON_TRIPLE_FAULT: +# Reset the CPU when triple fault occur (highly recommended) rather than +# PANIC. Remember that if you trying to continue after triple fault the +# simulation will be completely bogus ! +# +# CPUID_LIMIT_WINNT: +# Determine whether to limit maximum CPUID function to 2. This mode is +# required to workaround WinNT installation and boot issues. +# +# MSRS: +# Define path to user CPU Model Specific Registers (MSRs) specification. +# See example in msrs.def. +# +# IGNORE_BAD_MSRS: +# Ignore MSR references that Bochs does not understand; print a warning +# message instead of generating #GP exception. This option is enabled +# by default but will not be avaiable if configurable MSRs are enabled. +# +# MWAIT_IS_NOP: +# When this option is enabled MWAIT will not put the CPU into a sleep state. +# This option exists only if Bochs compiled with --enable-monitor-mwait. +# +# IPS: +# Emulated Instructions Per Second. This is the number of IPS that bochs +# is capable of running on your machine. You can recompile Bochs with +# --enable-show-ips option enabled, to find your host's capability. +# Measured IPS value will then be logged into your log file or shown +# in the status bar (if supported by the gui). +# +# IPS is used to calibrate many time-dependent events within the bochs +# simulation. For example, changing IPS affects the frequency of VGA +# updates, the duration of time before a key starts to autorepeat, and +# the measurement of BogoMips and other benchmarks. +# +# Examples: +# +# Bochs Machine/Compiler Mips +# ______________________________________________________________________ +# 2.4.6 3.4Ghz Intel Core i7 2600 with Win7x64/g++ 4.5.2 85 to 95 Mips +# 2.3.7 3.2Ghz Intel Core 2 Q9770 with WinXP/g++ 3.4 50 to 55 Mips +# 2.3.7 2.6Ghz Intel Core 2 Duo with WinXP/g++ 3.4 38 to 43 Mips +# 2.2.6 2.6Ghz Intel Core 2 Duo with WinXP/g++ 3.4 21 to 25 Mips +# 2.2.6 2.1Ghz Athlon XP with Linux 2.6/g++ 3.4 12 to 15 Mips +#======================================================================= +#cpu: model=core2_penryn_t9600, count=1, ips=50000000, reset_on_triple_fault=1, ignore_bad_msrs=1, msrs="msrs.def" +#cpu: model=core2_penryn_t9600, count=1, ips=50000000, reset_on_triple_fault=0 cpuid_limit_winnt=1 +#cpu: model=corei7_haswell_4770, count=1, ips=50000000, reset_on_triple_fault=0 +#cpu: model=broadwell_ult, count=1, ips=50000000, reset_on_triple_fault=0 +#cpu: model=corei7_ivy_bridge_3770k, count=1, ips=50000000, reset_on_triple_fault=0 +#cpu: model=corei5_lynnfield_750, count=1, ips=50000000, reset_on_triple_fault=0 + +#======================================================================= +# CPUID: +# +# This defines features and functionality supported by Bochs emulated CPU. +# The option has no offect if CPU model was selected in CPU option. +# +# MMX: +# Select MMX instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 5. +# +# APIC: +# Select APIC configuration (LEGACY/XAPIC/XAPIC_EXT/X2APIC). +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 5. +# +# SEP: +# Select SYSENTER/SYSEXIT instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SIMD: +# Select SIMD instructions support. +# Any of NONE/SSE/SSE2/SSE3/SSSE3/SSE4_1/SSE4_2/AVX/AVX2/AVX512 +# could be selected. +# +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# The AVX choises exists only if Bochs compiled with --enable-avx option. +# +# SSE4A: +# Select AMD SSE4A instructions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MISALIGNED_SSE: +# Select AMD Misaligned SSE mode support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# AES: +# Select AES instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SHA: +# Select SHA instruction set support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MOVBE: +# Select MOVBE Intel(R) Atom instruction support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# ADX: +# Select ADCX/ADOX instructions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# XSAVE: +# Select XSAVE extensions support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# XSAVEOPT: +# Select XSAVEOPT instruction support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# AVX_F16C: +# Select AVX float16 convert instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# AVX_FMA: +# Select AVX fused multiply add (FMA) instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# BMI: +# Select BMI1/BMI2 instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# XOP: +# Select AMD XOP instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# FMA4: +# Select AMD four operand FMA instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# TBM: +# Select AMD Trailing Bit Manipulation (TBM) instructions support. +# This option exists only if Bochs compiled with --enable-avx option. +# +# X86-64: +# Enable x86-64 and long mode support. +# This option exists only if Bochs compiled with x86-64 support. +# +# 1G_PAGES: +# Enable 1G page size support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# PCID: +# Enable Process-Context Identifiers (PCID) support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# FSGSBASE: +# Enable GS/GS BASE access instructions support in long mode. +# This option exists only if Bochs compiled with x86-64 support. +# +# SMEP: +# Enable Supervisor Mode Execution Protection (SMEP) support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# SMAP: +# Enable Supervisor Mode Access Prevention (SMAP) support. +# This option exists only if Bochs compiled with BX_CPU_LEVEL >= 6. +# +# MWAIT: +# Select MONITOR/MWAIT instructions support. +# This option exists only if Bochs compiled with --enable-monitor-mwait. +# +# VMX: +# Select VMX extensions emulation support. +# This option exists only if Bochs compiled with --enable-vmx option. +# +# SVM: +# Select AMD SVM (Secure Virtual Machine) extensions emulation support. +# This option exists only if Bochs compiled with --enable-svm option. +# +# VENDOR_STRING: +# Set the CPUID vendor string returned by CPUID(0x0). This should be a +# twelve-character ASCII string. +# +# BRAND_STRING: +# Set the CPUID vendor string returned by CPUID(0x80000002 .. 0x80000004). +# This should be at most a forty-eight-character ASCII string. +# +# LEVEL: +# Set emulated CPU level information returned by CPUID. Default value is +# determined by configure option --enable-cpu-level. Currently supported +# values are 5 (for Pentium and similar processors) and 6 (for P6 and +# later processors). +# +# FAMILY: +# Set model information returned by CPUID. Default family value determined +# by configure option --enable-cpu-level. +# +# MODEL: +# Set model information returned by CPUID. Default model value is 3. +# +# STEPPING: +# Set stepping information returned by CPUID. Default stepping value is 3. +#======================================================================= +#cpuid: x86_64=1, mmx=1, sep=1, simd=sse4_2, apic=xapic, aes=1, movbe=1, xsave=1 +#cpuid: family=6, model=0x1a, stepping=5 + +#======================================================================= +# MEMORY +# Set the amount of physical memory you want to emulate. +# +# GUEST: +# Set amount of guest physical memory to emulate. The default is 32MB, +# the maximum amount limited only by physical address space limitations. +# +# HOST: +# Set amount of host memory you want to allocate for guest RAM emulation. +# It is possible to allocate less memory than you want to emulate in guest +# system. This will fake guest to see the non-existing memory. Once guest +# system touches new memory block it will be dynamically taken from the +# memory pool. You will be warned (by FATAL PANIC) in case guest already +# used all allocated host memory and wants more. +# +#======================================================================= +memory: guest=32, host=32 + +#======================================================================= +# ROMIMAGE: +# The ROM BIOS controls what the PC does when it first powers on. +# Normally, you can use a precompiled BIOS in the source or binary +# distribution called BIOS-bochs-latest. The default ROM BIOS is usually loaded +# starting at address 0xfffe0000, and it is exactly 128k long. The legacy +# version of the Bochs BIOS is usually loaded starting at address 0xffff0000, +# and it is exactly 64k long. +# You can use the environment variable $BXSHARE to specify the location +# of the BIOS. +# The usage of external large BIOS images (up to 512k) at memory top is +# now supported, but we still recommend to use the BIOS distributed with Bochs. +# The start address is optional, since it can be calculated from image size. +# The Bochs BIOS currently supports only the option "fastboot" to skip the +# boot menu delay. +#======================================================================= +#romimage: file=$BXSHARE/BIOS-bochs-latest, options=fastboot +romimage: file=$BXSHARE/BIOS-bochs-legacy, options=fastboot +#romimage: file=$BXSHARE/bios.bin-1.7.5 # http://www.seabios.org/SeaBIOS +#romimage: file=mybios.bin, address=0xfff80000 # 512k at memory top +#romimage: file=BIOS-bochs-latest, options=fastboot + +#======================================================================= +# VGAROMIMAGE +# You now need to load a VGA ROM BIOS into C0000. +#======================================================================= +#vgaromimage: file=$BXSHARE/VGABIOS-elpin-2.40 +#vgaromimage: file=$BXSHARE/VGABIOS-lgpl-latest +#vgaromimage: file=$BXSHARE/VGABIOS-lgpl-latest-cirrus +#vgaromimage: file=/usr/local/share/qemu/sgabios.bin + +#======================================================================= +# OPTROMIMAGE[1-4]: +# You may now load up to 4 optional ROM images. Be sure to use a +# read-only area, typically between C8000 and EFFFF. These optional +# ROM images should not overwrite the rombios (located at +# F0000-FFFFF) and the videobios (located at C0000-C7FFF). +# Those ROM images will be initialized by the bios if they contain +# the right signature (0x55AA) and a valid checksum. +# It can also be a convenient way to upload some arbitrary code/data +# in the simulation, that can be retrieved by the boot loader +#======================================================================= +#optromimage1: file=optionalrom.bin, address=0xd0000 +#optromimage2: file=optionalrom.bin, address=0xd1000 +#optromimage3: file=optionalrom.bin, address=0xd2000 +#optromimage4: file=optionalrom.bin, address=0xd3000 + +#optramimage1: file=/path/file1.img, address=0x0010000 +#optramimage2: file=/path/file2.img, address=0x0020000 +#optramimage3: file=/path/file3.img, address=0x0030000 +#optramimage4: file=/path/file4.img, address=0x0040000 + +#======================================================================= +# VGA: +# This defines parameters related to the VGA display +# +# EXTENSION +# Here you can specify the display extension to be used. With the value +# 'none' you can use standard VGA with no extension. Other supported +# values are 'vbe' for Bochs VBE, 'cirrus' for Cirrus SVGA support and +# 'voodoo' for Voodoo Graphics support (see 'voodoo' option). +# +# UPDATE_FREQ +# This parameter specifies the number of display updates per second. +# The VGA update timer by default uses the realtime engine with a value +# of 5. This parameter can be changed at runtime. +# +# REALTIME +# If set to 1 (default), the VGA timer is based on realtime, otherwise it +# is driven by the cpu and depends on the ips setting. If the host is slow +# (low ips, update_freq) and the guest uses HLT appropriately, setting this +# to 0 and "clock: sync=none" may improve the responsiveness of the guest +# GUI when the guest is otherwise idle. +# +# Examples: +# vga: extension=cirrus, update_freq=10 +#======================================================================= +vga: extension=none, update_freq=5, realtime=1 + +#======================================================================= +# VOODOO: +# This defines the Voodoo Graphics emulation (experimental). Currently +# supported models are 'voodoo1', 'voodoo2', 'banshee' and 'voodoo3'. The +# Voodoo2 support is not yet complete, but almost usable. The Banshee and +# Voodoo3 support is under construction, but basicly usable. The 2D/3D cards +# require an external VGA BIOS the vga extension option to be set to 'voodoo'. +# If the i440BX PCI chipset is selected, they can be assigned to AGP (slot #5). +# The gui screen update timing for all models is controlled by the related 'vga' +# options. +# +# Examples: +# voodoo: enabled=1, model=voodoo2 +#======================================================================= +#voodoo: enabled=1, model=voodoo1 + +#======================================================================= +# KEYBOARD: +# This defines parameters related to the emulated keyboard +# +# TYPE: +# Type of keyboard return by a "identify keyboard" command to the +# keyboard controller. It must be one of "xt", "at" or "mf". +# Defaults to "mf". It should be ok for almost everybody. A known +# exception is french macs, that do have a "at"-like keyboard. +# +# SERIAL_DELAY: +# Approximate time in microseconds that it takes one character to +# be transferred from the keyboard to controller over the serial path. +# +# PASTE_DELAY: +# Approximate time in microseconds between attempts to paste +# characters to the keyboard controller. This leaves time for the +# guest os to deal with the flow of characters. The ideal setting +# depends on how your operating system processes characters. The +# default of 100000 usec (.1 seconds) was chosen because it works +# consistently in Windows. +# If your OS is losing characters during a paste, increase the paste +# delay until it stops losing characters. +# +# KEYMAP: +# This enables a remap of a physical localized keyboard to a +# virtualized us keyboard, as the PC architecture expects. +# +# USER_SHORTCUT: +# This defines the keyboard shortcut to be sent when you press the "user" +# button in the headerbar. The shortcut string is a combination of maximum +# 3 key names (listed below) separated with a '-' character. +# Valid key names: +# "alt", "bksl", "bksp", "ctrl", "del", "down", "end", "enter", "esc", +# "f1", ... "f12", "home", "ins", "left", "menu", "minus", "pgdwn", "pgup", +# "plus", "power", "print", "right", "scrlck", "shift", "space", "tab", "up" +# and "win". +# +# Examples: +# keyboard: type=mf, serial_delay=200, paste_delay=100000 +# keyboard: keymap=gui/keymaps/x11-pc-de.map +# keyboard: user_shortcut=ctrl-alt-del +#======================================================================= +keyboard: type=mf, serial_delay=250 + +#======================================================================= +# MOUSE: +# This defines parameters for the emulated mouse type, the initial status +# of the mouse capture and the runtime method to toggle it. +# +# TYPE: +# With the mouse type option you can select the type of mouse to emulate. +# The default value is 'ps2'. The other choices are 'imps2' (wheel mouse +# on PS/2), 'serial', 'serial_wheel', 'serial_msys' (one com port requires +# setting 'mode=mouse') 'inport' and 'bus' (if present). To connect a mouse +# to a USB port, see the 'usb_uhci', 'usb_ohci', 'usb_ehci' or 'usb_xhci' +# options (requires PCI and USB support). +# +# ENABLED: +# The Bochs gui creates mouse "events" unless the 'enabled' option is +# set to 0. The hardware emulation itself is not disabled by this. +# Unless you have a particular reason for enabling the mouse by default, +# it is recommended that you leave it off. You can also toggle the mouse +# usage at runtime (RFB, SDL, Win32, wxWidgets and X11 - see below). +# +# TOGGLE: +# The default method to toggle the mouse capture at runtime is to press the +# CTRL key and the middle mouse button ('ctrl+mbutton'). This option allows +# to change the method to 'ctrl+f10' (like DOSBox), 'ctrl+alt' (like QEMU) +# or 'f12'. +# +# Examples: +# mouse: enabled=1 +# mouse: type=imps2, enabled=1 +# mouse: type=serial, enabled=1 +# mouse: enabled=0, toggle=ctrl+f10 +#======================================================================= +mouse: enabled=0 + +#======================================================================= +# PCI: +# This option controls the presence of a PCI chipset in Bochs. Currently it +# supports the i430FX, i440FX and i440BX chipsets. You can also specify the +# devices connected to PCI slots. Up to 5 slots are available. For these +# combined PCI/ISA devices assigning to slot is mandatory if you want to emulate +# the PCI model: cirrus, ne2k and pcivga. These PCI-only devices are also +# supported, but they are auto-assigned if you don't use the slot configuration: +# e1000, es1370, pcidev, pcipnic, usb_ehci, usb_ohci, usb_xhci and voodoo. +# In case of the i440BX chipset, slot #5 is the AGP slot. Currently only the +# 'voodoo' device can be assigned to AGP. +# +# Example: +# pci: enabled=1, chipset=i440fx, slot1=pcivga, slot2=ne2k +#======================================================================= +pci: enabled=1, chipset=i440fx + +#======================================================================= +# CLOCK: +# This defines the parameters of the clock inside Bochs: +# +# SYNC: +# This defines the method how to synchronize the Bochs internal time +# with realtime. With the value 'none' the Bochs time relies on the IPS +# value and no host time synchronization is used. The 'slowdown' method +# sacrifices performance to preserve reproducibility while allowing host +# time correlation. The 'realtime' method sacrifices reproducibility to +# preserve performance and host-time correlation. +# It is possible to enable both synchronization methods. +# +# RTC_SYNC: +# If this option is enabled together with the realtime synchronization, +# the RTC runs at realtime speed. This feature is disabled by default. +# +# TIME0: +# Specifies the start (boot) time of the virtual machine. Use a time +# value as returned by the time(2) system call or a string as returned +# by the ctime(3) system call. If no time0 value is set or if time0 +# equal to 1 (special case) or if time0 equal 'local', the simulation +# will be started at the current local host time. If time0 equal to 2 +# (special case) or if time0 equal 'utc', the simulation will be started +# at the current utc time. +# +# Syntax: +# clock: sync=[none|slowdown|realtime|both], time0=[timeValue|local|utc] +# +# Example: +# clock: sync=none, time0=local # Now (localtime) +# clock: sync=slowdown, time0=315529200 # Tue Jan 1 00:00:00 1980 +# clock: sync=none, time0="Mon Jan 1 00:00:00 1990" # 631148400 +# clock: sync=realtime, time0=938581955 # Wed Sep 29 07:12:35 1999 +# clock: sync=realtime, time0="Sat Jan 1 00:00:00 2000" # 946681200 +# clock: sync=none, time0=1 # Now (localtime) +# clock: sync=none, time0=utc # Now (utc/gmt) +# +# Default value are sync=none, rtc_sync=0, time0=local +#======================================================================= +clock: sync=none, time0=local + +#======================================================================= +# CMOSIMAGE: +# This defines a binary image file with size 128 bytes that can be loaded into +# the CMOS RAM at startup. The rtc_init parameter controls whether initialize +# the RTC with values stored in the image. By default the time0 argument given +# to the clock option is used. With 'rtc_init=image' the image is the source +# for the initial time. +# +# Example: +# cmosimage: file=cmos.img, rtc_init=image +#======================================================================= +#cmosimage: file=cmos.img, rtc_init=time0 + +#======================================================================= +# private_colormap: Request that the GUI create and use it's own +# non-shared colormap. This colormap will be used +# when in the bochs window. If not enabled, a +# shared colormap scheme may be used. Not implemented +# on all GUI's. +# +# Examples: +# private_colormap: enabled=1 +# private_colormap: enabled=0 +#======================================================================= +private_colormap: enabled=0 + +#======================================================================= +# FLOPPYA: +# Point this to pathname of floppy image file or device +# This should be of a bootable floppy(image/device) if you're +# booting from 'a' (or 'floppy'). +# +# You can set the initial status of the media to 'ejected' or 'inserted'. +# floppya: 2_88=path, status=ejected (2.88M 3.5" media) +# floppya: 1_44=path, status=inserted (1.44M 3.5" media) +# floppya: 1_2=path, status=ejected (1.2M 5.25" media) +# floppya: 720k=path, status=inserted (720K 3.5" media) +# floppya: 360k=path, status=inserted (360K 5.25" media) +# floppya: 320k=path, status=inserted (320K 5.25" media) +# floppya: 180k=path, status=inserted (180K 5.25" media) +# floppya: 160k=path, status=inserted (160K 5.25" media) +# floppya: image=path, status=inserted (guess media type from image size) +# floppya: 1_44=vvfat:path, status=inserted (use directory as VFAT media) +# floppya: type=1_44 (1.44M 3.5" floppy drive, no media) +# +# The path should be the name of a disk image file. On Unix, you can use a raw +# device name such as /dev/fd0 on Linux. On win32 platforms, use drive letters +# such as a: or b: as the path. The parameter 'image' works with image files +# only. In that case the size must match one of the supported types. +# The parameter 'type' can be used to enable the floppy drive without media +# and status specified. Usually the drive type is set up based on the media type. +# The optional parameter 'write_protected' can be used to control the media +# write protect switch. By default it is turned off. +#======================================================================= +#floppya: 1_44=, status=inserted +#floppya: image=../1.44, status=inserted +#floppya: 1_44=/dev/fd0H1440, status=inserted +#floppya: 1_2=../1_2, status=inserted +#floppya: 1_44=a:, status=inserted +#floppya: 1_44=a.img, status=inserted, write_protected=1 +#floppya: 1_44=/dev/rfd0a, status=inserted +#floppya: 1_44=boot.img, status=inserted, write_protected=1 + +#======================================================================= +# FLOPPYB: +# See FLOPPYA above for syntax +#======================================================================= +#floppyb: 1_44=b:, status=inserted +#floppyb: 1_44=b.img, status=inserted + +#======================================================================= +# ATA0, ATA1, ATA2, ATA3 +# ATA controller for hard disks and cdroms +# +# ata[0-3]: enabled=[0|1], ioaddr1=addr, ioaddr2=addr, irq=number +# +# These options enables up to 4 ata channels. For each channel +# the two base io addresses and the irq must be specified. +# +# ata0 and ata1 are enabled by default with the values shown below +# +# Examples: +# ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +# ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15 +# ata2: enabled=1, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +# ata3: enabled=1, ioaddr1=0x168, ioaddr2=0x360, irq=9 +#======================================================================= +ata0: enabled=0, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14 +ata1: enabled=0, ioaddr1=0x170, ioaddr2=0x370, irq=15 +ata2: enabled=0, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11 +ata3: enabled=0, ioaddr1=0x168, ioaddr2=0x360, irq=9 + +#======================================================================= +# ATA[0-3]-MASTER, ATA[0-3]-SLAVE +# +# This defines the type and characteristics of all attached ata devices: +# type= type of attached device [disk|cdrom] +# mode= only valid for disks [flat|concat|external|dll|sparse|vmware3] +# [vmware4|undoable|growing|volatile|vpc] +# [vbox|vvfat] +# path= path of the image / directory +# cylinders= only valid for disks +# heads= only valid for disks +# spt= only valid for disks +# status= only valid for cdroms [inserted|ejected] +# biosdetect= type of biosdetection [auto|cmos|none] +# translation=type of translation of the bios, only for disks [none|lba|large|rechs|auto] +# model= string returned by identify device command +# journal= optional filename of the redolog for undoable, volatile and vvfat disks +# +# Point this at a hard disk image file, cdrom iso file, or physical cdrom +# device. To create a hard disk image, try running bximage. It will help you +# choose the size and then suggest a line that works with it. +# +# In UNIX it may be possible to use a raw device as a Bochs hard disk, +# but WE DON'T RECOMMEND IT. In Windows there is no easy way. +# +# In windows, the drive letter + colon notation should be used for cdroms. +# Depending on versions of windows and drivers, you may only be able to +# access the "first" cdrom in the system. On MacOSX, use path="drive" +# to access the physical drive. +# +# The path is mandatory for hard disks. Disk geometry autodetection works with +# images created by bximage if CHS is set to 0/0/0 (cylinders are calculated +# using heads=16 and spt=63). For other hard disk images and modes the +# cylinders, heads, and spt are mandatory. In all cases the disk size reported +# from the image must be exactly C*H*S*512. +# +# Default values are: +# mode=flat, biosdetect=auto, translation=auto, model="Generic 1234" +# +# The biosdetect option has currently no effect on the bios +# +# Examples: +# ata0-master: type=disk, mode=flat, path=10M.sample, cylinders=306, heads=4, spt=17 +# ata0-slave: type=disk, mode=flat, path=20M.sample, cylinders=615, heads=4, spt=17 +# ata1-master: type=disk, mode=flat, path=30M.sample, cylinders=615, heads=6, spt=17 +# ata1-slave: type=disk, mode=flat, path=46M.sample, cylinders=940, heads=6, spt=17 +# ata2-master: type=disk, mode=flat, path=62M.sample, cylinders=940, heads=8, spt=17 +# ata2-slave: type=disk, mode=flat, path=112M.sample, cylinders=900, heads=15, spt=17 +# ata3-master: type=disk, mode=flat, path=483M.sample, cylinders=1024, heads=15, spt=63 +# ata3-slave: type=cdrom, path=iso.sample, status=inserted +#======================================================================= +#ata0-master: type=disk, mode=flat, path="30M.sample" +#ata0-master: type=disk, mode=flat, path="30M.sample", cylinders=615, heads=6, spt=17 +#ata0-master: type=disk, mode=flat, path="c.img", cylinders=0 # autodetect +#ata0-slave: type=disk, mode=vvfat, path=/bochs/images/vvfat, journal=vvfat.redolog +#ata0-slave: type=cdrom, path=D:, status=inserted +#ata0-slave: type=cdrom, path=/dev/cdrom, status=inserted +#ata0-slave: type=cdrom, path="drive", status=inserted +#ata0-slave: type=cdrom, path=/dev/rcd0d, status=inserted + +#======================================================================= +# BOOT: +# This defines the boot sequence. Now you can specify up to 3 boot drives, +# which can be 'floppy', 'disk', 'cdrom' or 'network' (boot ROM). +# Legacy 'a' and 'c' are also supported. +# Examples: +# boot: floppy +# boot: cdrom, disk +# boot: network, disk +# boot: cdrom, floppy, disk +#======================================================================= +boot: floppy +#boot: disk + +#======================================================================= +# FLOPPY_BOOTSIG_CHECK: disabled=[0|1] +# Enables or disables the 0xaa55 signature check on boot floppies +# Defaults to disabled=0 +# Examples: +# floppy_bootsig_check: disabled=0 +# floppy_bootsig_check: disabled=1 +#======================================================================= +floppy_bootsig_check: disabled=0 + +#======================================================================= +# LOG: +# Give the path of the log file you'd like Bochs debug and misc. verbiage +# to be written to. If you don't use this option or set the filename to +# '-' the output is written to the console. If you really don't want it, +# make it "/dev/null" (Unix) or "nul" (win32). :^( +# +# Examples: +# log: ./bochs.out +# log: /dev/tty +#======================================================================= +#log: /dev/null +#log: .bochs.log +#log: - +log: /dev/stderr + +#======================================================================= +# LOGPREFIX: +# This handles the format of the string prepended to each log line. +# You may use those special tokens : +# %t : 11 decimal digits timer tick +# %i : 8 hexadecimal digits of cpu current eip (ignored in SMP configuration) +# %e : 1 character event type ('i'nfo, 'd'ebug, 'p'anic, 'e'rror) +# %d : 5 characters string of the device, between brackets +# +# Default : %t%e%d +# Examples: +# logprefix: %t-%e-@%i-%d +# logprefix: %i%e%d +#======================================================================= +logprefix: %t%e%d + +#======================================================================= +# LOG CONTROLS +# +# Bochs has four severity levels for event logging. +# panic: cannot proceed. If you choose to continue after a panic, +# don't be surprised if you get strange behavior or crashes. +# error: something went wrong, but it is probably safe to continue the +# simulation. +# info: interesting or useful messages. +# debug: messages useful only when debugging the code. This may +# spit out thousands per second. +# +# For events of each level, you can choose to exit Bochs ('fatal'), 'ask', +# 'warn', 'report' or 'ignore'. The choices 'ask' and 'warn' are not supported +# by all guis, since they should bring up a dialog box. The 'warn' dialog is +# designed to confirm errors and the 'ask' dialog is usually used for panics +# and asks the user how to proceed. +# +# It is also possible to specify the 'action' to do for each Bochs facility +# separately (e.g. crash on panics from everything except the cdrom, and only +# report those). See the 'log function' module list in the user documentation. +# +# If you are experiencing many panics, it can be helpful to change +# the panic action to report instead of fatal. However, be aware +# that anything executed after a panic is uncharted territory and can +# cause bochs to become unstable. The panic is a "graceful exit," so +# if you disable it you may get a spectacular disaster instead. +#======================================================================= +panic: action=fatal +error: action=ignore +info: action=ignore +debug: action=ignore #, pci=report # report BX_DEBUG from module 'pci' + +#======================================================================= +# DEBUGGER_LOG: +# Give the path of the log file you'd like Bochs to log debugger output. +# If you really don't want it, make it /dev/null or '-'. :^( +# +# Examples: +# debugger_log: ./debugger.out +#======================================================================= +#debugger_log: /dev/null +#debugger_log: debugger.out +#debugger_log: - +debugger_log: /dev/null + +#======================================================================= +# COM1, COM2, COM3, COM4: +# This defines a serial port (UART type 16550A). In the 'term' mode you can +# specify a device to use as com1. This can be a real serial line, or a pty. +# To use a pty (under X/Unix), create two windows (xterms, usually). One of +# them will run bochs, and the other will act as com1. Find out the tty the com1 +# window using the `tty' command, and use that as the `dev' parameter. +# Then do `sleep 1000000' in the com1 window to keep the shell from +# messing with things, and run bochs in the other window. Serial I/O to +# com1 (port 0x3f8) will all go to the other window. +# In socket* and pipe* (win32 only) modes Bochs becomes either socket/named pipe +# client or server. In client mode it connects to an already running server (if +# connection fails Bochs treats com port as not connected). In server mode it +# opens socket/named pipe and waits until a client application connects to it +# before starting simulation. This mode is useful for remote debugging (e.g. +# with gdb's "target remote host:port" command or windbg's command line option +# -k com:pipe,port=\\.\pipe\pipename). Socket modes use simple TCP communication, +# pipe modes use duplex byte mode pipes. +# Other serial modes are 'null' (no input/output), 'file' (output to a file +# specified as the 'dev' parameter and changeable at runtime), 'raw' (use the +# real serial port - partly implemented on win32), 'mouse' (standard serial +# mouse - requires mouse option setting 'type=serial', 'type=serial_wheel' or +# 'type=serial_msys'). +# +# Examples: +# com1: enabled=1, mode=null +# com1: enabled=1, mode=mouse +# com2: enabled=1, mode=file, dev=serial.out +# com3: enabled=1, mode=raw, dev=com1 +# com3: enabled=1, mode=socket-client, dev=localhost:8888 +# com3: enabled=1, mode=socket-server, dev=localhost:8888 +# com4: enabled=1, mode=pipe-client, dev=\\.\pipe\mypipe +# com4: enabled=1, mode=pipe-server, dev=\\.\pipe\mypipe +#======================================================================= +com1: enabled=1, mode=file, dev=/proc/self/fd/4 + +#======================================================================= +# PARPORT1, PARPORT2: +# This defines a parallel (printer) port. When turned on and an output file is +# defined the emulated printer port sends characters printed by the guest OS +# into the output file. On some platforms a device filename can be used to +# send the data to the real parallel port (e.g. "/dev/lp0" on Linux, "lpt1" on +# win32 platforms). The output file can be changed at runtime. +# +# Examples: +# parport1: enabled=1, file="parport.out" +# parport2: enabled=1, file="/dev/lp0" +# parport1: enabled=0 +#======================================================================= +#parport1: enabled=1, file="parport.out" +parport1: enabled=0 + +#======================================================================= +# SOUND: +# This defines the lowlevel sound driver(s) for the wave (PCM) input / output +# and the MIDI output feature and (if necessary) the devices to be used. +# It can have several of the following properties. +# All properties are in the format sound: property=value +# +# waveoutdrv: +# This defines the driver to be used for the waveout feature. +# Possible values are 'file' (all wave data sent to file), 'dummy' (no +# output) and the platform-dependant drivers 'alsa', 'oss', 'osx', 'sdl' +# and 'win'. +# waveout: +# This defines the device to be used for wave output (if necessary) or +# the output file for the 'file' driver. +# waveindrv: +# This defines the driver to be used for the wavein feature. +# Possible values are 'dummy' (recording silence) and platform-dependent +# drivers 'alsa', 'oss', 'sdl' and 'win'. +# wavein: +# This defines the device to be used for wave input (if necessary). +# midioutdrv: +# This defines the driver to be used for the MIDI output feature. +# Possible values are 'file' (all MIDI data sent to file), 'dummy' (no +# output) and platform-dependent drivers 'alsa', 'oss', 'osx' and 'win'. +# midiout: +# This defines the device to be used for MIDI output (if necessary). +# driver: +# This defines the driver to be used for all sound features with one +# property. Possible values are 'default' (platform default) and all +# other choices described above. Overriding one or more settings with +# the specific driver parameter is possible. +# +# Example for different drivers: +# sound: waveoutdrv=sdl, waveindrv=alsa, midioutdrv=dummy +#======================================================================= +#sound: driver=default, waveout=/dev/dsp. wavein=, midiout= + +#======================================================================= +# SPEAKER: +# This defines the PC speaker output mode. In the 'sound' mode the beep +# is generated by the square wave generator which is a part of the +# lowlevel sound support. The 'system' mode is only available on Linux +# and Windows. On Linux /dev/console is used for output and on Windows +# the Beep() function. The 'gui' mode forwards the beep to the related +# gui methods (currently only used by the Carbon gui). +#======================================================================= +#speaker: enabled=0, mode=sound +speaker: enabled=0 + +#======================================================================= +# SB16: +# This defines the SB16 sound emulation. It can have several of the +# following properties. +# All properties are in the format sb16: property=value +# +# enabled: +# This optional property controls the presence of the SB16 emulation. +# The emulation is turned on unless this property is used and set to 0. +# midimode: This parameter specifies what to do with the MIDI output. +# 0 = no output +# 1 = output to device specified with the sound option (system dependent) +# 2 = MIDI or raw data output to file (depends on file name extension) +# 3 = dual output (mode 1 and 2 at the same time) +# midifile: This is the file where the midi output is stored (midimode 2 or 3). +# wavemode: This parameter specifies what to do with the PCM output. +# 0 = no output +# 1 = output to device specified with the sound option (system dependent) +# 2 = VOC, WAV or raw data output to file (depends on file name extension) +# 3 = dual output (mode 1 and 2 at the same time) +# wavefile: This is the file where the wave output is stored (wavemode 2 or 3). +# loglevel: +# 0=no log +# 1=resource changes, midi program and bank changes +# 2=severe errors +# 3=all errors +# 4=all errors plus all port accesses +# 5=all errors and port accesses plus a lot of extra info +# log: The file to write the sb16 emulator messages to. +# dmatimer: +# microseconds per second for a DMA cycle. Make it smaller to fix +# non-continuous sound. 750000 is usually a good value. This needs a +# reasonably correct setting for the IPS parameter of the CPU option. +# +# Examples for output modes: +# sb16: midimode=2, midifile="output.mid", wavemode=1 # MIDI to file +# sb16: midimode=1, wavemode=3, wavefile="output.wav" # wave to file and device +#======================================================================= +#sb16: midimode=1, wavemode=1, loglevel=2, log=sb16.log, dmatimer=600000 +#sb16: enabled=0 + +#======================================================================= +# ES1370: +# This defines the ES1370 sound emulation (recording and playback - except +# DAC1+DAC2 output at the same time). The parameter 'enabled' controls the +# presence of the device. The wave and MIDI output can be sent to device, file +# or both using the parameters 'wavemode', 'wavefile', 'midimode' and +# 'midifile'. See the description of these parameters at the SB16 directive. +# +# Examples: +# es1370: enabled=1, wavemode=1 # use 'sound' parameters +# es1370: enabled=1, wavemode=2, wavefile=output.voc # send output to file +#======================================================================= +#es1370: enabled=1, wavemode=1 +#es1370: enabled=0 + +#======================================================================= +# ne2k: NE2000 compatible ethernet adapter +# +# Format: +# ne2k: enabled=1, ioaddr=IOADDR, irq=IRQ, mac=MACADDR, ethmod=MODULE, +# ethdev=DEVICE, script=SCRIPT, bootrom=BOOTROM +# +# IOADDR, IRQ: You probably won't need to change ioaddr and irq, unless there +# are IRQ conflicts. These arguments are ignored when assign the ne2k to a +# PCI slot. +# +# MAC: The MAC address MUST NOT match the address of any machine on the net. +# Also, the first byte must be an even number (bit 0 set means a multicast +# address), and you cannot use ff:ff:ff:ff:ff:ff because that's the broadcast +# address. For the ethertap module, you must use fe:fd:00:00:00:01. There may +# be other restrictions too. To be safe, just use the b0:c4... address. +# +# ETHDEV: The ethdev value is the name of the network interface on your host +# platform. On UNIX machines, you can get the name by running ifconfig. On +# Windows machines, you must run niclist to get the name of the ethdev. +# Niclist source code is in misc/niclist.c and it is included in Windows +# binary releases. +# The 'socket' module uses this parameter to specify the UDP port for +# receiving packets and (optional) the host to connect. +# +# SCRIPT: The script value is optional, and is the name of a script that +# is executed after bochs initialize the network interface. You can use +# this script to configure this network interface, or enable masquerading. +# This is mainly useful for the tun/tap devices that only exist during +# Bochs execution. The network interface name is supplied to the script +# as first parameter. +# The 'slirp' module uses this parameter to specify a config file for +# setting up an alternative IP configuration or additional features. +# The 'vnet' module uses this parameter to specify an alternative +# log file name. +# +# BOOTROM: The bootrom value is optional, and is the name of the ROM image +# to load. Note that this feature is only implemented for the PCI version of +# the NE2000. +# +# If you don't want to make connections to any physical networks, +# you can use the following 'ethmod's to simulate a virtual network. +# null: All packets are discarded, but logged to a few files. +# vde: Virtual Distributed Ethernet +# vnet: ARP, ICMP-echo(ping), DHCP and read/write TFTP are simulated. +# The virtual host uses 192.168.10.1. +# DHCP assigns 192.168.10.2 to the guest. +# TFTP uses the 'ethdev' value for the root directory and doesn't +# overwrite files. +# socket: Connect up to 6 Bochs instances with external program 'bxhub' +# (simulating an ethernet hub). It provides the same services as the +# 'vnet' module and assigns IP addresses like 'slirp' (10.0.2.x). +# +#======================================================================= +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=fbsd, ethdev=en0 #macosx +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:00, ethmod=fbsd, ethdev=xl0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:00, ethmod=linux, ethdev=eth0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=win32, ethdev=MYCARD +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=tap, ethdev=tap0 +# ne2k: ioaddr=0x300, irq=9, mac=fe:fd:00:00:00:01, ethmod=tuntap, ethdev=/dev/net/tun0, script=./tunconfig +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=null, ethdev=eth0 +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=vde, ethdev="/tmp/vde.ctl" +# ne2k: ioaddr=0x300, irq=9, mac=b0:c4:20:00:00:01, ethmod=vnet, ethdev="c:/temp" +# ne2k: mac=b0:c4:20:00:00:01, ethmod=socket, ethdev=40000 # use localhost +# ne2k: mac=b0:c4:20:00:00:01, ethmod=socket, ethdev=mymachine:40000 +# ne2k: mac=b0:c4:20:00:00:01, ethmod=slirp, script=slirp.conf, bootrom=ne2k_pci.rom + +#======================================================================= +# pcipnic: Bochs/Etherboot pseudo-NIC +# +# Format: +# pcipnic: enabled=1, mac=MACADDR, ethmod=MODULE, ethdev=DEVICE, script=SCRIPT, +# bootrom=BOOTROM +# +# The pseudo-NIC accepts the same syntax (for mac, ethmod, ethdev, script, +# bootrom) and supports the same networking modules as the NE2000 adapter. +#======================================================================= +#pcipnic: enabled=1, mac=b0:c4:20:00:00:00, ethmod=vnet + +#======================================================================= +# e1000: Intel(R) 82540EM Gigabit Ethernet adapter +# +# Format: +# e1000: enabled=1, mac=MACADDR, ethmod=MODULE, ethdev=DEVICE, script=SCRIPT +# bootrom=BOOTROM +# +# The E1000 accepts the same syntax (for mac, ethmod, ethdev, script, bootrom) +# and supports the same networking modules as the NE2000 adapter. +#======================================================================= +#e1000: enabled=1, mac=52:54:00:12:34:56, ethmod=slirp, script=slirp.conf + +#======================================================================= +# USB_UHCI: +# This option controls the presence of the USB root hub which is a part +# of the i440FX PCI chipset. With the portX parameter you can connect devices +# to the hub (currently supported: 'mouse', 'tablet', 'keypad', 'disk', 'cdrom', +# 'floppy', 'hub' and 'printer'). +# +# If you connect the mouse or tablet to one of the ports, Bochs forwards the +# mouse movement data to the USB device instead of the selected mouse type. +# When connecting the keypad to one of the ports, Bochs forwards the input of +# the numeric keypad to the USB device instead of the PS/2 keyboard. +# +# To connect a 'flat' mode image as a USB hardisk you can use the 'disk' device +# with the path to the image separated with a colon. To use other disk image modes +# similar to ATA disks the syntax 'disk:mode:filename' must be used (see below). +# +# To emulate a USB cdrom you can use the 'cdrom' device name and the path to +# an ISO image or raw device name also separated with a colon. An option to +# insert/eject media is available in the runtime configuration. +# +# To emulate a USB floppy you can use the 'floppy' device with the path to the +# image separated with a colon. To use the VVFAT image mode similar to the +# legacy floppy the syntax 'floppy:vvfat:directory' must be used (see below). +# An option to insert/eject media is available in the runtime configuration. +# +# The device name 'hub' connects an external hub with max. 8 ports (default: 4) +# to the root hub. To specify the number of ports you have to add the value +# separated with a colon. Connecting devices to the external hub ports is only +# available in the runtime configuration. +# +# The device 'printer' emulates the HP Deskjet 920C printer. The PCL data is +# sent to a file specified in bochsrc.txt. The current code appends the PCL +# code to the file if the file already existed. The output file can be +# changed at runtime. +# +# The optionsX parameter can be used to assign specific options to the device +# connected to the corresponding USB port. Currently this feature is used to +# set the speed reported by device ('low', 'full', 'high' or 'super'). The +# availabe speed choices depend on both HC and device. The option 'debug' turns +# on debug output for the device at connection time. +# For the USB 'disk' device the optionsX parameter can be used to specify an +# alternative redolog file (journal) of some image modes. For 'vvfat' mode USB +# disks the optionsX parameter can be used to specify the disk size (range +# 128M ... 128G). If the size is not specified, it defaults to 504M. +# For the USB 'floppy' device the optionsX parameter can be used to specify an +# alternative device ID to be reported. Currently only the model "teac" is +# supported (can fix hw detection in some guest OS). The USB floppy also +# accepts the parameter "write_protected" with valid values 0 and 1 to select +# the access mode (default is 0). +#======================================================================= +#usb_uhci: enabled=1 +#usb_uhci: enabled=1, port1=mouse, port2=disk:usbstick.img +#usb_uhci: enabled=1, port1=hub:7, port2=disk:growing:usbdisk.img +#usb_uhci: enabled=1, port2=disk:undoable:usbdisk.img, options2=journal:redo.log +#usb_uhci: enabled=1, port2=disk:usbdisk2.img, options2=sect_size:1024 +#usb_uhci: enabled=1, port2=disk:vvfat:vvfat, options2="debug,speed:full" +#usb_uhci: enabled=1, port1=printer:printdata.bin, port2=cdrom:image.iso +#usb_uhci: enabled=1, port2=floppy:vvfat:diskette, options2="model:teac" + +#======================================================================= +# USB_OHCI: +# This option controls the presence of the USB OHCI host controller with a +# 2-port hub. The portX parameter accepts the same device types with the same +# syntax as the UHCI controller (see above). The optionsX parameter is also +# available on OHCI. +#======================================================================= +#usb_ohci: enabled=1 +#usb_ohci: enabled=1, port1=printer:usbprinter.bin + +#======================================================================= +# USB_EHCI: +# This option controls the presence of the USB EHCI host controller with a +# 6-port hub. The portX parameter accepts the same device types with the +# same syntax as the UHCI controller (see above). The optionsX parameter is +# also available on EHCI. +#======================================================================= +#usb_ehci: enabled=1 + +#======================================================================= +# USB_XHCI: +# This option controls the presence of the USB xHCI host controller with a +# 4-port hub. The portX parameter accepts the same device types with the +# same syntax as the UHCI controller (see above). The optionsX parameter is +# also available on xHCI. NOTE: port 1 and 2 are USB3 and only support +# super-speed devices, but port 3 and 4 are USB2 and support speed settings +# low, full and high. +#======================================================================= +#usb_xhci: enabled=1 + +#======================================================================= +# PCIDEV: +# PCI host device mapping +# WARNING: This Bochs feature is not maintained yet and may fail. +#======================================================================= +#pcidev: vendor=0x1234, device=0x5678 + +#======================================================================= +# GDBSTUB: +# Enable GDB stub. See user documentation for details. +# Default value is enabled=0. +# WARNING: This Bochs feature is not maintained yet and may fail. +#======================================================================= +#gdbstub: enabled=0, port=1234, text_base=0, data_base=0, bss_base=0 + +#======================================================================= +# MAGIC_BREAK: +# This enables the "magic breakpoint" feature when using the debugger. +# The useless cpu instruction XCHG BX, BX causes Bochs to enter the +# debugger mode. This might be useful for software development. +# +# Example: +# magic_break: enabled=1 +#======================================================================= +magic_break: enabled=0 + +#======================================================================= +# DEBUG_SYMBOLS: +# This loads symbols from the specified file for use in Bochs' internal +# debugger. Symbols are loaded into global context. This is equivalent to +# issuing ldsym debugger command at start up. +# +# Example: +# debug_symbols: file="kernel.sym" +# debug_symbols: file="kernel.sym", offset=0x80000000 +#======================================================================= +#debug_symbols: file="kernel.sym" + +print_timestamps: enabled=1 + +#======================================================================= +# PORT_E9_HACK: +# The 0xE9 port doesn't exists in normal ISA architecture. However, we +# define a convention here, to display on the console of the system running +# Bochs anything that is written to it. The idea is to provide debug output +# very early when writing BIOS or OS code for example, without having to +# bother with setting up a serial port or etc. Reading from port 0xE9 will +# will return 0xe9 to let you know if the feature is available. +# Leave this 0 unless you have a reason to use it. +# +# Example: +# port_e9_hack: enabled=1 +#======================================================================= +#port_e9_hack: enabled=1 + +#======================================================================= +# other stuff +#======================================================================= +# WARNING: This Bochs feature is not maintained yet. Is it still used ? +# To use it, set BX_LOAD32BITOSHACK in config.h to 1 and recompile Bochs. +#load32bitOSImage: os=nullkernel, path=../kernel.img, iolog=../vga_io.log +#load32bitOSImage: os=linux, path=../linux.img, iolog=../vga_io.log, initrd=../initrd.img + +#======================================================================= +# fullscreen: ONLY IMPLEMENTED ON AMIGA +# Request that Bochs occupy the entire screen instead of a +# window. +# +# Examples: +# fullscreen: enabled=0 +# fullscreen: enabled=1 +#======================================================================= +#fullscreen: enabled=0 +#screenmode: name="sample" + +#======================================================================= +# USER_PLUGIN: +# Load user-defined plugin. This option is available only if Bochs is +# compiled with plugin support. Maximum 8 different plugins are supported. +# See the example in the Bochs sources how to write a plugin device. +#======================================================================= +#user_plugin: name=testdev + +#======================================================================= +# for Macintosh, use the style of pathnames in the following +# examples. +# +# vgaromimage: :bios:VGABIOS-elpin-2.40 +# romimage: file=:bios:BIOS-bochs-latest, address=0xf0000 +# floppya: 1_44=[fd:], status=inserted +#======================================================================= +#:bios:VGABIOS-elpin-2.40 + +#======================================================================= +# MEGS +# Set the number of Megabytes of physical memory you want to emulate. +# The default is 32MB, most OS's won't need more than that. +# The maximum amount of memory supported is 2048Mb. +# The 'MEGS' option is deprecated. Use 'MEMORY' option instead. +#======================================================================= +#megs: 256 +#megs: 128 +#megs: 64 +#megs: 32 +#megs: 16 +#megs: 8 diff --git a/ape/idata.h b/ape/idata.h new file mode 100644 index 00000000..e69a6c79 --- /dev/null +++ b/ape/idata.h @@ -0,0 +1,119 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#ifndef APE_IDATA_H_ +#define APE_IDATA_H_ +#ifdef __ASSEMBLER__ +#include "ape/relocations.h" +/* clang-format off */ + +/ Links function from external DLL. +/ +/ This embeds a function pointer in the binary. The NT Executive +/ fills its value before control is handed off to the program. +/ +/ @note only ELF toolchains are powerful enough to use this +/ @see libc/nt/master.sh +/ @see ape/ape.lds +/ @see winimp +.macro .imp dll:req fn:req actual hint + .dll \dll + .section .piro.data.sort.iat.2.\dll\().2.\fn,"aw",@progbits + .type \fn,@object + .align __SIZEOF_POINTER__ +\fn: .quad RVA((.L\dll\().\fn)) + .size \fn,.-\fn + .globl \fn + .hidden \fn + .previous + .section .idata.ro.ilt.\dll\().2.\fn,"a",@progbits +.Lidata.ilt.\dll\().\fn: + .quad RVA((.L\dll\().\fn)) + .type .Lidata.ilt..L\dll\().\fn,@object + .size .Lidata.ilt..L\dll\().\fn,.-.Lidata.ilt.\dll\().\fn + .previous + .section .idata.ro.hnt.\dll\().2.\fn,"a",@progbits +.L\dll\().\fn: + .ifnb \hint # hint i.e. guess function ordinal + .short \hint + .else + .short 0 + .endif + .ifnb \actual # name + .asciz "\actual" + .else + .asciz "\fn" + .endif + .align 2 # documented requirement +/ .globl .L\dll\().\fn +/ .hidden .L\dll\().\fn + .type .L\dll\().\fn,@object + .size .L\dll\().\fn,.-.L\dll\().\fn + .previous +.endm + +/ Defines DLL import. +/ @note this is an implementation detail of .imp +.macro .dll name:req + .section .idata.ro.idt.2.\name,"aG",\name,comdat + .equ .Lidata.idt.\name,. + .long RVA(idata.ilt.\name) # ImportLookupTable + .long 0 # TimeDateStamp + .long 0 # ForwarderChain + .long RVA(.Lidata.str.\name) # DllNameRva + .long RVA(idata.iat.\name) # ImportAddressTable + .type .Lidata.idt.\name,@object + .size .Lidata.idt.\name,.-.Lidata.idt.\name + .previous + .section .idata.ro.ilt.\name\().1,"aG",\name,comdat + .align __SIZEOF_POINTER__ + .type idata.ilt.\name,@object +idata.ilt.\name: + .previous/* + ... + decentralized content + ... + */.section .idata.ro.ilt.\name\().3,"aG",\name,comdat + .quad 0 + .previous + .section .idata.ro.hnt.\name\().1,"aG",\name,comdat + .align __SIZEOF_POINTER__ + .type idata.hnt.\name,@object + .equ idata.hnt.\name,. + .previous + .section .piro.data.sort.iat.2.\name\().1,"awG",\name,comdat + .align __SIZEOF_POINTER__ + .type idata.iat.\name,@object +idata.iat.\name: + .previous/* + ... + decentralized content + ... + */.section .piro.data.sort.iat.2.\name\().3,"awG",\name,comdat + .quad 0 + .previous + .pushsection .rodata.str1.1,"aSM",@progbits,1 +.Lidata.str.\name: + .asciz "\name\().dll" + .popsection +.endm + +/* clang-format on */ +#endif /* __ASSEMBLER__ */ +#endif /* APE_IDATA_H_ */ diff --git a/ape/lib/apelib.mk b/ape/lib/apelib.mk new file mode 100644 index 00000000..1b885dfc --- /dev/null +++ b/ape/lib/apelib.mk @@ -0,0 +1,42 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += APE_LIB + +APE_LIB_ARTIFACTS += APE_LIB_A +APE_LIB = $(APE_LIB_A_DEPS) $(APE_LIB_A) +APE_LIB_A = o/$(MODE)/ape/lib/apelib.a +APE_LIB_A_FILES := $(wildcard ape/lib/*) +APE_LIB_A_HDRS = $(filter %.h,$(APE_LIB_A_FILES)) +APE_LIB_A_SRCS_S = $(filter %.S,$(APE_LIB_A_FILES)) +APE_LIB_A_SRCS_C = $(filter %.c,$(APE_LIB_A_FILES)) + +APE_LIB_A_SRCS = \ + $(APE_LIB_A_SRCS_S) \ + $(APE_LIB_A_SRCS_C) + +APE_LIB_A_OBJS = \ + $(APE_LIB_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(APE_LIB_A_SRCS_C:%.c=o/$(MODE)/%.o) \ + $(APE_LIB_A_SRCS:%=o/$(MODE)/%.zip.o) \ + o/$(MODE)/NOTICE.zip.o + +APE_LIB_A_CHECKS = $(APE_LIB_A_HDRS:%=o/$(MODE)/%.ok) +APE_LIB_A_DIRECTDEPS = LIBC_STR LIBC_STUBS +APE_LIB_A_DEPS = $(call uniq,$(foreach x,$(APE_LIB_A_DIRECTDEPS),$($(x)))) + +$(APE_LIB_A): ape/lib/ $(APE_LIB_A).pkg $(APE_LIB_A_OBJS) +$(APE_LIB_A).pkg: $(APE_LIB_A_OBJS) $(foreach x,$(APE_LIB_A_DIRECTDEPS),$($(x)_A).pkg) + +APE_LIB_LIBS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x))) +APE_LIB_SRCS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x)_SRCS)) +APE_LIB_HDRS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x)_HDRS)) +APE_LIB_BINS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x)_BINS)) +APE_LIB_CHECKS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x)_CHECKS)) +APE_LIB_OBJS = $(foreach x,$(APE_LIB_ARTIFACTS),$($(x)_OBJS)) +$(APE_LIB_OBJS): $(BUILD_FILES) libc/str/str.mk + +.PHONY: o/$(MODE)/ape/lib +o/$(MODE)/ape/lib: \ + $(APE_LIB_CHECKS) \ + $(APE_LIB_A) diff --git a/ape/lib/apm.h b/ape/lib/apm.h new file mode 100644 index 00000000..544e23b2 --- /dev/null +++ b/ape/lib/apm.h @@ -0,0 +1,59 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=8 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╠──────────────────────────────────────────────────────────────────────────────╣ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│ +│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│ +│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│ +╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│ +│ αcτµαlly pδrταblε εxεcµταblε § green energy │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#ifndef APE_LIB_APM_H_ +#define APE_LIB_APM_H_ + +/** + * @fileoverview Advanced Power Management. + * + *

APM is useful for exiting programs, without needing to ask the + * human to flip a physical switch or pass QEMU's -no-reboot flag. + * + *

Implementation Detail: Supporting ACPI would literally + * require implementing a programming language. + * + * @see APM BIOS Interface Specification v1.2 + * @since IBM PC/AT + */ + +#define APM_SERVICE 0x15 + +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +void apmoff(void) noreturn; + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* APE_LIB_APM_H_ */ diff --git a/ape/lib/bootdr.S b/ape/lib/bootdr.S new file mode 100644 index 00000000..eecd59ae --- /dev/null +++ b/ape/lib/bootdr.S @@ -0,0 +1,36 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 sw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/macros.h" +#include "ape/notice.inc" +.section .real,"ax",@progbits +.yoink __FILE__ +.code16 + +/ Resets personal computer. +/ +/ @param di drive number, e.g. A:\ is 0x00, C:\ is 0x80 +/ @mode real +/ @noreturn +bootdr: push %bp + mov %sp,%bp + mov %di,%dx + int $0x19 + ljmp $0xf000,$0xfff0 + .endfn bootdr,globl diff --git a/ape/lib/e820map.S b/ape/lib/e820map.S new file mode 100644 index 00000000..c3990965 --- /dev/null +++ b/ape/lib/e820map.S @@ -0,0 +1,38 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "ape/config.h" +#include "ape/macros.h" +#include "ape/notice.inc" +.section .real,"ax",@progbits +.yoink __FILE__ +.code16 + + .globl e820map + .hidden e820map + .type e820map,@object + .size e820map,XLM_E820_SIZE + e820map = ape.xlm + XLM_E820 + + .globl e820map_xlm + .hidden e820map_xlm + .type e820map_xlm,@object + .size e820map_xlm,XLM_E820_SIZE + e820map_xlm = XLM(E820) diff --git a/ape/lib/flattenhighmemory.c b/ape/lib/flattenhighmemory.c new file mode 100644 index 00000000..8c0d8416 --- /dev/null +++ b/ape/lib/flattenhighmemory.c @@ -0,0 +1,59 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/config.h" +#include "ape/lib/pc.h" +#include "libc/bits/bits.h" +#include "libc/bits/safemacros.h" + +/** + * Virtualizes physical memory. + * + * This function removes memory holes (discovered by e820() earlier) and + * creates the illusion of flat contiguous memory for as much RAM as the + * BIOS reports usable. Memory is safe to use and remap afterwards. + * + * @see ape/ape.S + */ +textreal void flattenhighmemory(struct SmapEntry *e820, struct PageTable *pml4t, + uint64_t *ptsp) { + struct SmapEntry *smap = e820; + struct SmapEntry *hole = e820; + uint64_t paddr = IMAGE_BASE_PHYSICAL; + uint64_t vaddr = IMAGE_BASE_VIRTUAL; + while (smap->size) { + while (smap->size && smap->type != kMemoryUsable) smap++; + paddr = roundup(max(paddr, smap->addr), PAGESIZE); + while (paddr < rounddown(smap->addr + smap->size, PAGESIZE)) { + while (hole->size && + (hole->type == kMemoryUsable || hole->addr + hole->size < paddr)) { + hole++; + } + if (paddr >= hole->addr && paddr < hole->addr + hole->size) { + paddr = roundup(hole->addr + hole->size, PAGESIZE); + } else { + uint64_t *entry = getpagetableentry(vaddr, 3, pml4t, ptsp); + *entry = paddr | PAGE_V | PAGE_RW; + vaddr += 0x1000; + paddr += 0x1000; + } + } + smap++; + } +} diff --git a/ape/lib/g_pml4t.S b/ape/lib/g_pml4t.S new file mode 100644 index 00000000..7c9d8e83 --- /dev/null +++ b/ape/lib/g_pml4t.S @@ -0,0 +1,32 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "ape/config.h" +#include "ape/macros.h" +#include "ape/notice.inc" +.section .real,"ax",@progbits +.yoink __FILE__ +.code16 + + .globl g_pml4t + .hidden g_pml4t + .type g_pml4t,@object + .size g_pml4t,0x1000 + g_pml4t = REAL_STACK_FRAME - 0x1000 diff --git a/ape/lib/g_ptsp.S b/ape/lib/g_ptsp.S new file mode 100644 index 00000000..b7cc8db1 --- /dev/null +++ b/ape/lib/g_ptsp.S @@ -0,0 +1,38 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "ape/config.h" +#include "ape/macros.h" +#include "ape/notice.inc" +.section .real,"ax",@progbits +.yoink __FILE__ +.code16 + + .globl g_ptsp + .hidden g_ptsp + .type g_ptsp,@object + .size g_ptsp,XLM_PAGE_TABLE_STACK_POINTER_SIZE + g_ptsp = ape.xlm + XLM_PAGE_TABLE_STACK_POINTER + + .globl g_ptsp_xlm + .hidden g_ptsp_xlm + .type g_ptsp_xlm,@object + .size g_ptsp_xlm,XLM_PAGE_TABLE_STACK_POINTER_SIZE + g_ptsp_xlm = XLM(PAGE_TABLE_STACK_POINTER) diff --git a/ape/lib/getpagetableentry.c b/ape/lib/getpagetableentry.c new file mode 100644 index 00000000..1e3b6438 --- /dev/null +++ b/ape/lib/getpagetableentry.c @@ -0,0 +1,40 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "libc/assert.h" + +textreal static uint64_t pushpagetable(uint64_t *ptsp) { + return (*ptsp -= PAGESIZE) | PAGE_V | PAGE_RW; +} + +textreal uint64_t *getpagetableentry(uint64_t vaddr, unsigned depth, + struct PageTable *pml4t, uint64_t *ptsp) { + assert(depth <= 3); + assert(*ptsp % PAGESIZE == 0); + assert((intptr_t)pml4t % PAGESIZE == 0); + unsigned char shift = 39; + for (;;) { + uint64_t *entry = &pml4t->p[(vaddr >> shift) & 511]; + if (!depth--) return entry; + shift -= 9; + if (!*entry) *entry = pushpagetable(ptsp); + pml4t = (void *)(*entry & PAGE_TA); + } +} diff --git a/ape/lib/kbiosdataarea.S b/ape/lib/kbiosdataarea.S new file mode 100644 index 00000000..4088616e --- /dev/null +++ b/ape/lib/kbiosdataarea.S @@ -0,0 +1,46 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "ape/config.h" +#include "ape/macros.h" +#include "ape/notice.inc" +.section .real,"ax",@progbits +.yoink __FILE__ +.code16 + + .globl kBiosDataArea + .hidden kBiosDataArea + .type kBiosDataArea,@object + .size kBiosDataArea,XLM_BIOS_DATA_AREA_SIZE + kBiosDataArea = ape.xlm + XLM_BIOS_DATA_AREA + + .globl kBiosDataAreaXlm + .hidden kBiosDataAreaXlm + .type kBiosDataAreaXlm,@object + .size kBiosDataAreaXlm,XLM_BIOS_DATA_AREA_SIZE + kBiosDataAreaXlm = XLM(BIOS_DATA_AREA) + + .section .sort.real.init.2.kBiosDataArea,"ax",@progbits + movpp %ds,%es # copy bios data to valid page + mov $PC_BIOS_DATA_AREA,%si + mov $XLM(BIOS_DATA_AREA),%di + mov $XLM_BIOS_DATA_AREA_SIZE,%cx + rep movsb + .previous diff --git a/ape/lib/pageunmap.c b/ape/lib/pageunmap.c new file mode 100644 index 00000000..d09bf2c8 --- /dev/null +++ b/ape/lib/pageunmap.c @@ -0,0 +1,27 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" +#include "libc/bits/bits.h" + +textreal void pageunmap(uint64_t vaddr) { + uint64_t *entry = getpagetableentry(vaddr, 3, &g_pml4t, &g_ptsp_xlm); + *entry &= ~PAGE_V; + invlpg(vaddr); +} diff --git a/ape/lib/pc.h b/ape/lib/pc.h new file mode 100644 index 00000000..fd1adeaa --- /dev/null +++ b/ape/lib/pc.h @@ -0,0 +1,239 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=8 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╠──────────────────────────────────────────────────────────────────────────────╣ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│ +│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│ +│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│ +╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│ +│ αcτµαlly pδrταblε εxεcµταblε § ibm personal computer │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#ifndef APE_LIB_PC_H_ +#define APE_LIB_PC_H_ + +#define BOOTSIG 0xaa55 /* master boot record signature */ +#define PC_BIOS_DATA_AREA 0x400 + +#define kInterruptFlag (1u << 9) + +/* FPU Status Word (x87) + @see Intel Manual V1 §8.1.3 + IE: Invalid Operation ────────────────┐ + DE: Denormalized Operand ────────────┐│ + ZE: Zero Divide ────────────────────┐││ + OE: Overflow Flag ─────────────────┐│││ + UE: Underflow Flag ───────────────┐││││ + PE: Precision Flag ──────────────┐│││││ + SF: Stack Fault ────────────────┐││││││ + ES: Exception Summary Status ──┐│││││││ + C0-3: Condition Codes ──┬────┐ ││││││││ + Top of Stack Pointer ─────┐ │ ││││││││ + B: FPU Busy ───────────┐│ │ │ ││││││││ + ││┌┴┐┌┼┐││││││││ + │↓│ │↓↓↓││││││││*/ +#define FPU_ZE 0b0000000000100000000000100 +#define FPU_C0 0b0000000000000000100000000 +#define FPU_C1 0b0000000000000001000000000 +#define FPU_C2 0b0000000000000010000000000 +#define FPU_C3 0b0000000000100000000000000 + +#define CR0_PE (1u << 0) /* protected mode enabled */ +#define CR0_MP (1u << 1) /* monitor coprocessor */ +#define CR0_EM (1u << 2) /* no x87 fpu present if set */ +#define CR0_TS (1u << 3) /* task switched x87 */ +#define CR0_ET (1u << 4) /* extension type 287 or 387 */ +#define CR0_NE (1u << 5) /* enable x87 error reporting */ +#define CR0_WP (1u << 16) /* write protect read-only pages @pl0 */ +#define CR0_AM (1u << 18) /* alignment mask */ +#define CR0_NW (1u << 29) /* global write-through cache disable */ +#define CR0_CD (1u << 30) /* global cache disable */ +#define CR0_PG (1u << 31) /* paging enabled */ + +#define CR4_VME (1u << 0) /* virtual 8086 mode extension */ +#define CR4_PVI (1u << 1) /* protected mode virtual interrupts */ +#define CR4_TSD (1u << 2) /* time stamp disable (rdtsc) */ +#define CR4_DE (1u << 3) /* debugging extensions */ +#define CR4_PSE (1u << 4) /* page size extension */ +#define CR4_PAE (1u << 5) /* physical address extension */ +#define CR4_MCE (1u << 6) /* machine check exception */ +#define CR4_PGE (1u << 7) /* page global enabled */ +#define CR4_OSFXSR (1u << 9) /* enable SSE and fxsave/fxrestor */ +#define CR4_OSXMMEXCPT (1u << 10) /* enable unmasked SSE exceptions */ +#define CR4_LA57 (1u << 12) /* enable level-5 paging */ +#define CR4_VMXE (1u << 13) /* enable VMX operations */ +#define CR4_SMXE (1u << 14) /* enable SMX operations */ +#define CR4_FSGSBASE (1u << 16) /* enable *FSBASE and *GSBASE instructions */ +#define CR4_PCIDE (1u << 17) /* enable process-context identifiers */ +#define CR4_OSXSAVE (1u << 18) /* enable XSAVE */ + +#define XCR0_X87 (1u << 0) +#define XCR0_SSE (1u << 1) +#define XCR0_AVX (1u << 2) +#define XCR0_BNDREG (1u << 3) +#define XCR0_BNDCSR (1u << 4) +#define XCR0_OPMASK (1u << 5) +#define XCR0_ZMM_HI256 (1u << 6) +#define XCR0_HI16_ZMM (1u << 7) + +#define EFER 0xC0000080 /* extended feature enable register */ +#define EFER_SCE (1u << 0) /* system call extensions */ +#define EFER_LME (1u << 8) /* long mode enable */ +#define EFER_LMA (1u << 10) /* long mode active */ +#define EFER_NXE (1u << 11) /* no-execute enable */ + +#define GDT_REAL_CODE 8 +#define GDT_REAL_DATA 16 +#define GDT_LEGACY_CODE 24 +#define GDT_LEGACY_DATA 32 +#define GDT_LONG_CODE 40 +#define GDT_LONG_DATA 48 + +#define PIC1 0x20 /* IO base address for master PIC */ +#define PIC2 0xA0 /* IO base address for slave PIC */ +#define PIC1_CMD PIC1 +#define PIC1_DATA (PIC1 + 1) +#define PIC2_CMD PIC2 +#define PIC2_DATA (PIC2 + 1) +#define PIC_EOI 0x20 /* End-of-interrupt command code */ +#define PIC_READ_IRR 0x0a /* OCW3 irq ready next CMD read */ +#define PIC_READ_ISR 0x0b /* OCW3 irq service next CMD read */ + +/* Long Mode Paging + @see Intel Manual V.3A §4.1 §4.5 + IsValid (ignored on CR3) V┐ + ┌Block Instr. Fetches (if NXE) IsWritable (ignored on CR3) RW┐│ + │ Permit User-Mode Access - u┐││ + │ Page-level Write-Through - PWT┐│││ + │ Page-level Cache Disable - PCD┐││││ + │ Set if has been read - Accessed┐│││││ + │ Set if has been written - Dirty┐││││││ + │ IsPage (if PDPTE/PDE) or PAT (if PT)┐│││││││ + │ (If this maps 2MB/1GB page and CR4.PGE) Global┐││││││││ + │ (If IsPage 2MB/1GB, see Intel V3A § 11.12) PAT │││││││││ + │ │ │││││││││ + │ ┌────────────────────────────────────┤ │││││││││ + │ Must Be 0┐│ Next Page Table Address (!IsPage) │ │││││││││ + │ │├────────────────────────────────────┤ │││││││││ + │ ││ Physical Address 4KB │ │││││││││ + │┌───┐┌─────┐│├───────────────────────────┐ │ign│││││││││ + ││PKE││ ign │││ Physical Address 2MB │ │┌┴┐│││││││││ + ││ ││ ││├──────────────────┐ │ ││ ││││││││││ + ││ ││ │││ Phys. Addr. 1GB │ │ ││ ││││││││││ + ││ ││ │││ │ │ ││ ││││││││││ + 0b00000000000011111111111111111111111111111111111111000000000000 + 6666555555555544444444443333333333222222222211111111110000000000 + 3210987654321098765432109876543210987654321098765432109876543210*/ +#define PAGE_V /* */ 0b000000001 +#define PAGE_RW /* */ 0b000000010 +#define PAGE_U /* */ 0b000000100 +#define PAGE_2MB /* */ 0b110000000 +#define PAGE_1GB /* */ 0b110000000 +#define PAGE_TA 0b011111111111111111111111111111111111111000000000000 +#define PAGE_PA2 0b11111111111111111111111111111000000000000000000000 + +#if !(__ASSEMBLER__ + __LINKER__ + 0) +#include "ape/config.h" + +struct thatispacked GlobalDescriptorTable { + uint16_t size; + uint64_t *entries; +}; + +/** + * Memory hole map. + * @see wiki.osdev.org/Detecting_Memory_(x86) + * @since 2002 + */ +struct SmapEntry { + uint64_t addr; + uint64_t size; + enum { + kMemoryUsable = 1, + kMemoryUnusable = 2, + kMemoryAcpiReclaimable = 3, + kMemoryAcpiNvs = 4, + kMemoryBad = 5 + } type; + uint32_t __acpi3; /* is abstracted */ +}; + +struct IdtDescriptor { + uint16_t offset_1; /* offset bits 0..15 */ + uint16_t selector; /* a code segment selector in GDT or LDT */ + uint8_t ist; /* bits 0..2 hold stack table offset, rest are zero */ + uint8_t type_attr; /* type and attributes */ + uint16_t offset_2; /* offset bits 16..31 */ + uint32_t offset_3; /* offset bits 32..63 */ + uint32_t zero; /* reserved */ +}; + +struct thatispacked PageTable { + uint64_t p[512]; +} aligned(PAGESIZE); + +extern struct PageTable g_pml4t; +extern struct GlobalDescriptorTable gdt; + +extern const unsigned char kBiosDataArea[256]; +extern const unsigned char kBiosDataAreaXlm[256]; + +extern struct SmapEntry e820map[XLM_E820_SIZE / sizeof(struct SmapEntry)]; +extern struct SmapEntry e820map_xlm[XLM_E820_SIZE / sizeof(struct SmapEntry)]; + +extern uint64_t g_ptsp; +extern uint64_t g_ptsp_xlm; + +void bootdr(char drive) noreturn; + +void smapsort(struct SmapEntry *); +uint64_t *getpagetableentry(uint64_t, unsigned, struct PageTable *, uint64_t *); +void flattenhighmemory(struct SmapEntry *, struct PageTable *, uint64_t *); +void pageunmap(uint64_t); + +forceinline unsigned long eflags(void) { + unsigned long res; + asm("pushf\n\t" + "pop\t%0" + : "=rm"(res)); + return res; +} + +forceinline unsigned char inb(unsigned short port) { + unsigned char al; + asm volatile("inb\t%1,%0" : "=a"(al) : "dN"(port)); + return al; +} + +forceinline void outb(unsigned short port, unsigned char byte) { + asm volatile("outb\t%0,%1" + : /* no inputs */ + : "a"(byte), "dN"(port)); +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* APE_LIB_PC_H_ */ diff --git a/ape/lib/pic.c b/ape/lib/pic.c new file mode 100644 index 00000000..2ca33fdb --- /dev/null +++ b/ape/lib/pic.c @@ -0,0 +1,140 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" + +#define ICW1_ICW4 0x01 /* ICW4 (not) needed */ +#define ICW1_SINGLE 0x02 /* Single (cascade) mode */ +#define ICW1_INTERVAL4 0x04 /* Call address interval 4 (8) */ +#define ICW1_LEVEL 0x08 /* Level triggered (edge) mode */ +#define ICW1_INIT 0x10 /* Initialization - required! */ + +#define ICW4_8086 0x01 /* 8086/88 (MCS-80/85) mode */ +#define ICW4_AUTO 0x02 /* Auto (normal) EOI */ +#define ICW4_BUF_SLAVE 0x08 /* Buffered mode/slave */ +#define ICW4_BUF_MASTER 0x0C /* Buffered mode/master */ +#define ICW4_SFNM 0x10 /* Special fully nested (not) */ + +static inline void io_wait(void) { + /* Magic technique from Linux, according to: + * wiki.osdev.org/index.php?title=Inline_Assembly/Examples&oldid=23541 + */ + outb(0x80, 0); +} + +void PIC_sendEOI(unsigned char irq) { + if (irq >= 8) outb(PIC2_CMD, PIC_EOI); + outb(PIC1_CMD, PIC_EOI); +} + +bool AreInterruptsEnabled() { + return (eflags() & kInterruptFlag) == kInterruptFlag; +} + +nodiscard forceinline unsigned long irqdisable(void) { + unsigned long eflags; + asm("pushf\n\t" + "cli\n\t" + "pop\t%0" + : "=r"(eflags) + : /* no inputs */ + : "cc"); + return eflags; +} + +forceinline void irqrestore(unsigned long eflags) { + asm volatile( + "push\t%0\n\t" + "popf" + : /* no outputs */ + : "rm"(eflags) + : "cc"); +} + +/** + * @param offset1 is vector offset for master PIC + * vectors on the master become offset1..offset1+7 + * @param offset2 is same for slave PIC: offset2..offset2+7 + **/ +void PIC_remap(int offset1, int offset2) { + unsigned char a1, a2; + a1 = inb(PIC1_DATA); // save masks + a2 = inb(PIC2_DATA); + outb(PIC1_CMD, + ICW1_INIT | + ICW1_ICW4); // starts the initialization sequence (in cascade mode) + io_wait(); + outb(PIC2_CMD, ICW1_INIT | ICW1_ICW4); + io_wait(); + outb(PIC1_DATA, offset1); // ICW2: Master PIC vector offset + io_wait(); + outb(PIC2_DATA, offset2); // ICW2: Slave PIC vector offset + io_wait(); + outb(PIC1_DATA, 4); // ICW3: tell Master PIC that there is a slave PIC at + // IRQ2 (0000 0100) + io_wait(); + outb(PIC2_DATA, 2); // ICW3: tell Slave PIC its cascade identity (0000 0010) + io_wait(); + outb(PIC1_DATA, ICW4_8086); + io_wait(); + outb(PIC2_DATA, ICW4_8086); + io_wait(); + outb(PIC1_DATA, a1); // restore saved masks. + outb(PIC2_DATA, a2); +} + +void IRQ_set_mask(unsigned char IRQline) { + uint16_t port; + uint8_t value; + if (IRQline < 8) { + port = PIC1_DATA; + } else { + port = PIC2_DATA; + IRQline -= 8; + } + value = inb(port) | (1 << IRQline); + outb(port, value); +} + +void IRQ_clear_mask(unsigned char IRQline) { + uint16_t port; + uint8_t value; + if (IRQline < 8) { + port = PIC1_DATA; + } else { + port = PIC2_DATA; + IRQline -= 8; + } + value = inb(port) & ~(1 << IRQline); + outb(port, value); +} + +static uint16_t __pic_get_irq_reg(int ocw3) { + /* OCW3 to PIC CMD to get the register values. PIC2 is chained, and + * represents IRQs 8-15. PIC1 is IRQs 0-7, with 2 being the chain */ + outb(PIC1_CMD, ocw3); + outb(PIC2_CMD, ocw3); + return (inb(PIC2_CMD) << 8) | inb(PIC1_CMD); +} + +/* Returns the combined value of the cascaded PICs irq request register */ +uint16_t pic_get_irr(void) { return __pic_get_irq_reg(PIC_READ_IRR); } + +/* Returns the combined value of the cascaded PICs in-service register */ +uint16_t pic_get_isr(void) { return __pic_get_irq_reg(PIC_READ_ISR); } diff --git a/ape/lib/smapsort.c b/ape/lib/smapsort.c new file mode 100644 index 00000000..c8b160ad --- /dev/null +++ b/ape/lib/smapsort.c @@ -0,0 +1,47 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "ape/lib/pc.h" + +textreal static unsigned smapcount(const struct SmapEntry *se) { + unsigned i = 0; + while (se[i].size) ++i; + return i; +} + +textreal static void smapsorter(size_t n, struct SmapEntry a[n]) { + struct SmapEntry t; + unsigned i, j; + for (i = 1; i < n; ++i) { + j = i; + t = a[i]; + while (j > 0 && (intptr_t)t.addr - (intptr_t)a[j - 1].addr) { + a[j] = a[j - 1]; + --j; + } + a[j] = t; + } +} + +/** + * Sorts BIOS e820 memory map. + */ +textreal void smapsort(struct SmapEntry *smap) { + smapsorter(smapcount(smap), smap); +} diff --git a/ape/macros.h b/ape/macros.h new file mode 100644 index 00000000..1439fe29 --- /dev/null +++ b/ape/macros.h @@ -0,0 +1,281 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╠──────────────────────────────────────────────────────────────────────────────╣ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░▀█▀░█░█░█▀█░█░░░█░░░█░█░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█░▄░░█░░█░█░█▀█░█░░░█░░░▀█▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░▀▀▀░░▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀█░█▀█░█▀█░▀█▀░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█ █░██▀░░█░░█▀█░█▀█░█░░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░▀░░░▀▀▀░▀░▀░░▀░░▀░▀░▀▀▀░▀▀▀░▀▀▀░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│ +│░░░░░░░█▀▀░█░█░█▀▀░█▀█░█░█░▀█▀░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░░░░░░░░░░░░░▄▄░░░▐█░░│ +│░░░░░░░█▀▀░▄▀▄░█▀▀░█░▄░█░█░░█░░█▀█░█▀█░█░░█▀▀░░░░░░░░░░░░▄▄▄░░░▄██▄░░█▀░░░█░▄░│ +│░░░░░░░▀▀▀░▀░▀░▀▀▀░▀▀▀░▀▀▀░░▀░░▀░▀░▀▀▀░▀▀░▀▀▀░░░░░░░░░░▄██▀█▌░██▄▄░░▐█▀▄░▐█▀░░│ +│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▐█▀▀▌░░░▄▀▌░▌░█░▌░░▌░▌░░│ +╠──────────────────────────────────────────────────────▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄─│ +│ αcτµαlly pδrταblε εxεcµταblε § macros │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#ifndef APE_MACROS_H_ +#define APE_MACROS_H_ +#include "libc/macros.h" +#ifdef __ASSEMBLER__ +/* clang-format off */ + +/** + * @fileoverview Macros relevant to αcτµαlly pδrταblε εxεcµταblε. + */ + +/ Calls near (i.e. pc+pcrel<64kB) FUNCTION. +/ @mode long,legacy,real +/ @cost 9 bytes overhead +.macro rlcall function:req + .byte 0x50 # push %[er]ax + .byte 0xb8,0,0 # mov $?,%[e]ax + jmp 911f + .byte 0x58 # pop %[er]ax + .byte 0xe8 # call Jvds + .long \function\()-.-4 + jmp 912f +911: .byte 0x58 # pop %[er]ax + .byte 0xe8 # call Jvds + .short \function\()-.-2 +912: +.endm + +/ Loads far (i.e. <1mb) abs constexpr ADDRESS into ES:DI+EDX+RDX. +/ @mode long,legacy,real +.macro movesdi address:req + .byte 0xbf # mov $0x????xxxx,%[e]di + .short \address>>4 + .byte 0x8e,0xc7 # mov %di,%es + .byte 0xbf # mov $0x????xxxx,%[e]di + .short \address&0xf + jmp 297f + .byte 0xbf # mov $0x????xxxx,%edi + .long \address +297: +.endm + +/ Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend. +/ @mode long,legacy,real +.macro bbmov constexpr:req abcd abcd.hi:req abcd.lo:req + .ifnb \abcd + .if (\constexpr)<128 && (\constexpr)>=0 + pushpop \constexpr,\abcd + .exitm + .endif + .endif + movb $(\constexpr)>>8&0xff,\abcd.hi + movb $(\constexpr)&0xff,\abcd.lo +.endm + +/ Compares 16-bit CONSTEXPR with Qw-register. +/ @mode long,legacy,real +.macro bbcmp constexpr:req abcd.hi:req abcd.lo:req + cmpb $(\constexpr)>>8&0xff,\abcd.hi + jnz 387f + cmpb $(\constexpr)&0xff,\abcd.lo +387: +.endm + +/ Adds 16-bit CONSTEXPR to Qw-register. +/ @mode long,legacy,real +.macro bbadd constexpr:req abcd.hi:req abcd.lo:req + addb $(\constexpr)&0xff,\abcd.lo + .if (\constexpr) != 0 + adcb $(\constexpr)>>8&0xff,\abcd.hi + .endif +.endm + +/ Subtracts 16-bit CONSTEXPR from Qw-register. +/ @mode long,legacy,real +.macro bbsub constexpr:req abcd.hi:req abcd.lo:req + subb $(\constexpr)&0xff,\abcd.lo + .if (\constexpr) != 0 + sbbb $(\constexpr)>>8&0xff,\abcd.hi + .endif +.endm + +/ Ands Qw-register with 16-bit CONSTEXPR. +/ @mode long,legacy,real +.macro bband constexpr:req abcd.hi:req abcd.lo:req + .if ((\constexpr)&0xff) != 0xff || ((\constexpr)>>8&0xff) == 0xff + andb $(\constexpr)&0xff,\abcd.lo + .endif + .if ((\constexpr)>>8&0xff) != 0xff + andb $(\constexpr)>>8&0xff,\abcd.hi + .endif +.endm + +/ Ors Qw-register with 16-bit CONSTEXPR. +/ @mode long,legacy,real +.macro bbor constexpr:req abcd.hi:req abcd.lo:req + .if ((\constexpr)&0xff) != 0 || ((\constexpr)>>8&0xff) != 0 + orb $(\constexpr)&0xff,\abcd.lo + .endif + .if ((\constexpr)>>8&0xff) != 0 + orb $(\constexpr)>>8&0xff,\abcd.hi + .endif +.endm + +/ Performs ACTION only if in real mode. +/ @mode long,legacy,real +.macro rlo clobber:req action:vararg +990: mov $0,\clobber + .if .-990b!=3 + .error "bad clobber or assembler mode" + .endif +991: \action + .rept 2-(.-991b) + nop + .endr + .if .-991b!=2 + .error "ACTION must be 1-2 bytes" + .endif +.endm + +/ Initializes real mode stack. +/ The most holiest of holy code. +/ @mode real +/ @see www.pcjs.org/pubs/pc/reference/intel/8086/ +.macro rlstack seg:req addr:req + cli + mov \seg,%ss + mov \addr,%sp + sti +.endm + +/ Symbolic Linker-Defined Binary Content. +.macro .stub name:req kind:req default type=@object + .ifnb \default + .equ \name,\default + .endif + .\kind \name + .type \name,\type + .weak \name +.hidden \name +.endm + +/ Symbolic Linker-Defined Binary-Encoded-Bourne Content. +/ @param units is the number of encoded 32-bit values to insert, +/ e.g. \000 can be encoded as 0x3030305c. +.macro .shstub name:req units:req + ss \name,0 + .if \units>1 + ss \name,1 + .if \units>2 + ss \name,2 + ss \name,3 + .if \units>4 + ss \name,4 + ss \name,5 + ss \name,6 + ss \name,7 + .endif + .endif + .endif +.endm +.macro ss name n + .stub \name\()_bcs\n,long +.endm + +/* clang-format on */ +#elif defined(__LINKER__) + +#define BCX_NIBBLE(X) ((((X)&0xf) > 0x9) ? ((X)&0xf) + 0x37 : ((X)&0xf) + 0x30) +#define BCX_OCTET(X) ((BCX_NIBBLE((X) >> 4) << 8) | (BCX_NIBBLE((X) >> 0) << 0)) +#define BCX_INT16(X) ((BCX_OCTET((X) >> 8) << 16) | (BCX_OCTET((X) >> 0) << 0)) +#define BCXSTUB(SYM, X) \ + HIDDEN(SYM##_bcx0 = BCX_INT16((X) >> 48)); \ + HIDDEN(SYM##_bcx1 = BCX_INT16((X) >> 32)); \ + HIDDEN(SYM##_bcx2 = BCX_INT16((X) >> 16)); \ + HIDDEN(SYM##_bcx3 = BCX_INT16((X) >> 0)) + +/** + * Binary coded backslash octet support. + * + *

This allows linker scripts to generate printf commands. + */ +#define BCO_OCTET(X) (((X)&0x7) + 0x30) +#define BCOB_UNIT(X) \ + ((BCO_OCTET((X) >> 0) << 24) | (BCO_OCTET((X) >> 3) << 16) | \ + (BCO_OCTET(((X)&0xff) >> 6) << 8) | 0x5c) + +#define PFBYTE(SYM, X, I) HIDDEN(SYM##_bcs##I = BCOB_UNIT((X) >> ((I)*8))) +#define PFSTUB2(SYM, X) \ + HIDDEN(SYM = (X)); \ + PFBYTE(SYM, X, 0); \ + PFBYTE(SYM, X, 1) +#define PFSTUB4(SYM, X) \ + PFSTUB2(SYM, X); \ + PFBYTE(SYM, X, 2); \ + PFBYTE(SYM, X, 3) +#define PFSTUB8(SYM, X) \ + PFSTUB4(SYM, X); \ + PFBYTE(SYM, X, 4); \ + PFBYTE(SYM, X, 5); \ + PFBYTE(SYM, X, 6); \ + PFBYTE(SYM, X, 7) + +/** + * Binary coded decimal support. + * + *

This allows linker scripts to generate dd commands. Leading spaces + * need to be inserted so Mac doesn't consider them octal; therefore, + * parameters must be quoted; and eight digits should be good enough. + */ +#define SHSTUB2(SYM, X) \ + HIDDEN(SYM##_bcs0 = BCD10K(X)); \ + HIDDEN(SYM##_bcs1 = BCD(X)) +#define BCD(X) \ + ((X) == 0 \ + ? 0x20202030 \ + : (X) < 10 ? 0x30202020 + (((X) % 10) << 24) \ + : (X) < 100 ? 0x30302020 + (((X) % 10) << 24) + \ + (((X) / 10 % 10) << 16) \ + : (X) < 1000 ? 0x30303020 + (((X) % 10) << 24) + \ + (((X) / 10 % 10) << 16) + \ + (((X) / 100 % 10) << 8) \ + : 0x30303030 + (((X) % 10) << 24) + \ + (((X) / 10 % 10) << 16) + \ + (((X) / 100 % 10) << 8) + \ + (((X) / 1000 % 10) << 0)) +#define BCD10K(X) \ + ((X) < 10000 \ + ? 0x20202020 \ + : (X) < 100000 \ + ? 0x30202020 + (((X) / 10000 % 10) << 24) \ + : (X) < 1000000 \ + ? 0x30302020 + (((X) / 10000 % 10) << 24) + \ + (((X) / 100000 % 10) << 16) \ + : (X) < 10000000 \ + ? 0x30303020 + (((X) / 10000 % 10) << 24) + \ + (((X) / 100000 % 10) << 16) + \ + (((X) / 1000000 % 10) << 8) \ + : (X) < 100000000 \ + ? 0x30303030 + (((X) / 10000 % 10) << 24) + \ + (((X) / 100000 % 10) << 16) + \ + (((X) / 1000000 % 10) << 8) + \ + (((X) / 10000000 % 10) << 0) \ + : 0xffffffffffffffff) + +#endif /* __ASSEMBLER__ */ +#endif /* APE_MACROS_H_ */ diff --git a/ape/mtime.h b/ape/mtime.h new file mode 100644 index 00000000..181a2e0c --- /dev/null +++ b/ape/mtime.h @@ -0,0 +1,41 @@ +#ifndef COSMOPOLITAN_APE_MTIME_H_ +#define COSMOPOLITAN_APE_MTIME_H_ +#include "libc/dos.h" + +/** + * @fileoverview Deterministic last modified timestamp embedding. + */ + +#ifndef MTIME_YEAR +#define MTIME_YEAR 2019 +#endif + +#ifndef MTIME_MONTH +#define MTIME_MONTH 1 +#endif + +#ifndef MTIME_DAY +#define MTIME_DAY 1 +#endif + +#ifndef MTIME_HOUR +#define MTIME_HOUR 0 +#endif + +#ifndef MTIME_MINUTES +#define MTIME_MINUTES 0 +#endif + +#ifndef MTIME_SECONDS +#define MTIME_SECONDS 0 +#endif + +#ifndef ZIP_MTIME_DATE +#define ZIP_MTIME_DATE DOS_DATE(MTIME_YEAR, MTIME_MONTH, MTIME_DAY) +#endif + +#ifndef ZIP_MTIME_TIME +#define ZIP_MTIME_TIME DOS_TIME(MTIME_HOUR, MTIME_MINUTES, MTIME_SECONDS) +#endif + +#endif /* COSMOPOLITAN_APE_MTIME_H_ */ diff --git a/ape/mz.ansi b/ape/mz.ansi new file mode 100644 index 00000000..29efb1d0 --- /dev/null +++ b/ape/mz.ansi @@ -0,0 +1,69 @@ +ProTip: cat ape/mz.ansi + +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ +▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ + +The αcτµαlly pδrταblε εxεcµταblε software is dedicated to: + + Mark "Zibo" Joseph Zbikowski + Architect @ Microsoft Corporation & Early Computer Hacker + Whose Initials Grace Every Executable + diff --git a/ape/notice.inc b/ape/notice.inc new file mode 100644 index 00000000..e69de29b diff --git a/ape/relocations.h b/ape/relocations.h new file mode 100644 index 00000000..6dc3ad38 --- /dev/null +++ b/ape/relocations.h @@ -0,0 +1,67 @@ +#ifndef COSMOPOLITAN_APE_RELOCATIONS_H_ +#define COSMOPOLITAN_APE_RELOCATIONS_H_ +/*─────────────────────────────────────────────────────────────────────────────╗ +│ αcτµαlly pδrταblε εxεcµταblε § relocations │ +╚──────────────────────────────────────────────────────────────────────────────╝ + One of the things αcτµαlly pδrταblε εxεcµταblε does a good job + abstracting, is how a program needs to exist at three addresses + simultaneously during the early stages of the loading process. + + By default, the linker calculates all symbols using virtual addresses. + In some cases it's necessary to use addend macros that change virtual + addresses into the other two types: physical and real. */ + +#ifndef IMAGE_BASE_VIRTUAL +#define IMAGE_BASE_VIRTUAL 0x400000 +#endif + +#ifndef IMAGE_BASE_PHYSICAL +#define IMAGE_BASE_PHYSICAL 0x100000 +#endif + +/** + * Location of anything goes memory for real mode. + * + * The MBR won't load program content beyond this address, so we have + * room for buffers, page tables, etc. before we reach the stack frame. + */ +#ifndef REAL_SCRATCH_AREA +#define REAL_SCRATCH_AREA 0x40000 +#endif + +/** + * Location of real mode 64kb stack frame. + * + * This address was chosen because memory beyond 0x80000 can't be + * accessed safely without consulting e820. + */ +#ifndef REAL_STACK_FRAME +#define REAL_STACK_FRAME 0x70000 +#endif + +/** + * Returns Relative Virtual Address. + */ +#define RVA(x) ((x) - (IMAGE_BASE_VIRTUAL)) + +/** + * Adjusts virtual address so it's relative to load address. + */ +#define PHYSICAL(x) ((x) - (IMAGE_BASE_VIRTUAL - IMAGE_BASE_PHYSICAL)) + +/** + * Makes high-entropy read-only addresses relocatable in real mode. + */ +#define REAL(x) ((x) - (IMAGE_BASE_VIRTUAL - IMAGE_BASE_REAL)) + +#if IMAGE_BASE_VIRTUAL % 0x200000 != 0 +#error "IMAGE_BASE_VIRTUAL must be 2mb aligned" +#endif +#if IMAGE_BASE_PHYSICAL % 0x1000 != 0 +#error "IMAGE_BASE_PHYSICAL must be 4kb aligned" +#endif +#if IMAGE_BASE_REAL % 0x1000 != 0 +#error "IMAGE_BASE_REAL must be 4kb aligned" +#endif + +#endif /* COSMOPOLITAN_APE_RELOCATIONS_H_ */ diff --git a/build/actuallynice b/build/actuallynice new file mode 100755 index 00000000..e68dcc2d --- /dev/null +++ b/build/actuallynice @@ -0,0 +1,28 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# SYNOPSIS +# +# Program Deprioritizer +# +# OVERVIEW +# +# This is a drop-in replacement for the traditional Unix `nice` +# command that also invokes `ionice`, which is important, since +# network and traffic is usually what clobber the system. + +if [ -z "$IONICE" ]; then + if IONICE=$(command -v ionice 2>/dev/null); then + IONICE="$IONICE -c3" + fi +fi + +if [ -z "$NICE" ]; then + NICE=$(command -v nice 2>/dev/null) +fi + +if [ -z "$IONICE$NICE" ]; then + echo "error: can't be nice" >&2 +fi + +exec $IONICE $NICE "$@" diff --git a/build/archive b/build/archive new file mode 100755 index 00000000..663b6bf7 --- /dev/null +++ b/build/archive @@ -0,0 +1,80 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# GNU Archiver Veneer +# +# DESCRIPTION +# +# This script wraps normal archive commands that're transparently +# passed-through. It adds value too, by addressing difficulties +# that would normally cause a developer to need `make clean`. +# +# EXAMPLE +# +# build/archive ar rcsD library.a foo.o ... + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +export LC_ALL=C +RM=${RM:-$(command -v rm) -f} || exit +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +AR=$1 +ARFLAGS=$2 +OUT=$3 +shift 3 + +# remove directory arguments (having .a targets depend on dirs is what +# lets them be invalidated by deleted files) +FIRST=1 +for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + fi + if [ -d "$x" ]; then + if [ -f "$OUT" ] && [ "$x" -nt "$OUT" ]; then + $RM "$OUT" + fi + continue + fi + if [ "$x" != "${x%.o}" ]; then + set -- "$@" "$x" + fi +done + +set -- "$AR" "$ARFLAGS" "$OUT" "$@" + +OUTDIR="${OUT%/*}" +if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then + $MKDIR "$OUTDIR" || exit 2 +fi + +printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2 +# if [ "$SILENT" = "0" ]; then +# # some of these windows nt archives are quite huge +# COLUMNS=${COLUMNS:-80} +# COLUMNS=$((COLUMNS - 4)) +# printf "%s\n" "$*" | +# /usr/bin/fold -s -w $COLUMNS | +# sed -e '1bb' -e 's/^/ /' -e ':b' -e '$b' -e 's/$/ \\/' >&2 +# else +# printf "$LOGFMT" "${ACTION:-ARCHIVE.a}" "$OUT" >&2 +# fi + +REASON=failed +trap REASON=interrupted INT + +"$@" >/dev/null && exit + +if [ "$TERM" = "dumb" ]; then + f='%s %s\r\n\r\n' +else + f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n' +fi +printf "$f" "archive $REASON:" "$*" >&2 +exit 1 diff --git a/build/assemble b/build/assemble new file mode 100755 index 00000000..27e92a3b --- /dev/null +++ b/build/assemble @@ -0,0 +1,49 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# GNU Assembler Veneer +# +# DESCRIPTION +# +# This script wraps normal assembler commands that're transparently +# passed-through. It adds ephemeral logging and directory creation. +# +# EXAMPLE +# +# TARGET=program build/assemble as -o program program.o +# +# SEE ALSO +# +# https://justine.storage.googleapis.com/perm/as.pdf + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +export LC_ALL=C +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +if [ "$SILENT" = "0" ]; then + printf "%s\n" "$*" >&2 +else + printf "$LOGFMT" "${ACTION:-OBJECTIFY.s}" "$TARGET" >&2 +fi + +if [ "$TARGET" ]; then + TARGETDIR="${TARGET%/*}" + if [ "$TARGETDIR" != "$TARGET" ] && [ ! -d "$TARGETDIR" ]; then + $MKDIR "$TARGETDIR" || exit 2 + fi +fi + +"$@" && exit + +if [ "$TERM" = "dumb" ]; then + f='%s %s\r\n\r\n' +else + f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n' +fi +printf "$f" "assemble failed:" "$*" >&2 +exit 1 diff --git a/build/bochs-debugger b/build/bochs-debugger new file mode 100755 index 00000000..37c11d8f --- /dev/null +++ b/build/bochs-debugger @@ -0,0 +1,8 @@ +# -*- mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8 -*- +# vi: set net ft=sh ts=2 sts=2 sw=2 fenc=utf-8 :vi + +echo c | + bochs \ + -q \ + -f ape/etc/bochsrc.dbg \ + floppya:1_44=$1,status=inserted diff --git a/build/bochs-scriptable b/build/bochs-scriptable new file mode 100755 index 00000000..6e657500 --- /dev/null +++ b/build/bochs-scriptable @@ -0,0 +1,51 @@ +#!/bin/sh +# -*- mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8 -*- +# vi: set net ft=sh ts=2 sts=2 sw=2 fenc=utf-8 :vi +# +# bochs-scriptable executes a disk with serial uart stdio. +# +# USAGE +# +# build/bochs-scriptable IMAGE... +# +# DESCRIPTION +# +# This script is useful for end-to-end testing metal apps in <100ms. +# +# SEE ALSO +# +# build/boot(1) + +while getopts h X; do + case $X in + h) exec less "$0" ;; + \?) echo "$0: bad arg" >&2; exit 1 ;; + esac +done +shift $((OPTIND - 1)) + +trap '' INT + +IMG=$1 +OUT=/tmp/$USER.$$.bochs.stdout +ERR=/tmp/$USER.$$.bochs.stderr + +mkfifo $OUT || exit + +cat <$OUT & +CAT=$! +exec 4>$OUT +rm -f $OUT + +echo c | + bochs \ + -q \ + -f ape/etc/bochsrc.ffs \ + display_library:nogui \ + floppya:1_44=$1,status=inserted \ + >>$ERR 2>>$ERR +RC=$? + +kill $CAT +exec 4>&- +rm -f $ERR diff --git a/build/bootstrap/mkdeps.com b/build/bootstrap/mkdeps.com new file mode 100755 index 00000000..00b8bc39 Binary files /dev/null and b/build/bootstrap/mkdeps.com differ diff --git a/build/bootstrap/net/http/uricspn.c.gz b/build/bootstrap/net/http/uricspn.c.gz new file mode 100644 index 00000000..75e0fb90 Binary files /dev/null and b/build/bootstrap/net/http/uricspn.c.gz differ diff --git a/build/bootstrap/net/http/uriparse.c.gz b/build/bootstrap/net/http/uriparse.c.gz new file mode 100644 index 00000000..9234d6b6 Binary files /dev/null and b/build/bootstrap/net/http/uriparse.c.gz differ diff --git a/build/bootstrap/package.com b/build/bootstrap/package.com new file mode 100755 index 00000000..bf8771aa Binary files /dev/null and b/build/bootstrap/package.com differ diff --git a/build/bootstrap/zipobj.com b/build/bootstrap/zipobj.com new file mode 100755 index 00000000..954167aa Binary files /dev/null and b/build/bootstrap/zipobj.com differ diff --git a/build/catcode b/build/catcode new file mode 100755 index 00000000..e957f841 --- /dev/null +++ b/build/catcode @@ -0,0 +1,20 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Source File Concatenation Tool +# +# DESCRIPTION +# +# This program is the same as cat, but inserts preprocessor directives +# that allow compiler errors to point back to the original lines. + +if [ $# -eq 0 ]; then + cat +else + for x; do + printf '# 1 "%s"\n' "$x" + cat "$x" + done +fi diff --git a/build/compile b/build/compile new file mode 100755 index 00000000..a40cf8f5 --- /dev/null +++ b/build/compile @@ -0,0 +1,279 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# GNU/LLVM Compiler Frontend Frontend +# +# DESCRIPTION +# +# This wrapper script filters out certain flags so the compiler won't +# whine, and passes extra information to the preprocessor. +# +# EXAMPLE +# +# build/compile cc -o program program.c + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +if [ "$1" = "clang-10" ]; then + if ! command -v clang-10 >/dev/null; then + shift + set -- o/third_party/gcc/bin/x86_64-linux-musl-gcc "$@" + fi +fi + +if [ "$1" = "clang++-10" ]; then + if ! command -v clang++-10 >/dev/null; then + shift + set -- o/third_party/gcc/bin/x86_64-linux-musl-g++ "$@" + fi +fi + +export LC_ALL=C +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +GZME= +PLAT="${1%% *}" +FDIAGNOSTIC_COLOR= +CCNAME=${CCNAME:-gcc} +CCVERSION=${CCVERSION:-4} +COUNTERMAND= + +# The GNU Compiler Collection passes a lot of CFLAGS to the preprocessor +# (which we call CCFLAGS) but it should pass more; and we do just that. +FIRST=1 +OUTARG=0 +INVISIBLE=0 +for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + fi + if [ $OUTARG -eq 1 ]; then + OUTARG=0 + OUT="$x" + fi + case "$x" in + -o) + set -- "$@" "$x" + OUTARG=1 + ;; + -w) + set -- "$@" "$x" -D__W__ + ;; + -pg) + if [ $INVISIBLE -eq 0 ]; then + set -- "$@" "$x" -D__PG__ # @see libc/macros.h + fi + ;; + -mfentry) + if [ $INVISIBLE -eq 0 ]; then + set -- "$@" "$x" -D__MFENTRY__ + fi + ;; + -fomit-frame-pointer) + INVISIBLE=1 + set -- "$@" "$x" + ;; + -mno-vzeroupper) + set -- "$@" "$x" -Wa,-msse2avx -D__MNO_VZEROUPPER__ + ;; + -fsanitize=undefined) + set -- "$@" "$x" -D__FSANITIZE_UNDEFINED__ + COUNTERMAND="$COUNTERMAND -fno-data-sections" # sqlite.o + ;; + -mnop-mcount) + if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then + set -- "$@" "$x" -D__MNOP_MCOUNT__ + fi + ;; + -mrecord-mcount) + if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then + set -- "$@" "$x" -D__MRECORD_MCOUNT__ + fi + ;; + -fsanitize=implicit*integer*) + if ! [ "$CCNAME" = "gcc" ]; then + set -- "$@" "$x" + fi + ;; + -f*sanitize*|-gz*|-*stack-protector*|-fvect-cost*|-mstringop*) + if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 6 ]; then + set -- "$@" "$x" + fi + ;; + -freorder-blocks-and-partition|-fstack-clash-protection) + if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 8 ]; then + set -- "$@" "$x" + fi + ;; + -fdiagnostic-color=*) + FDIAGNOSTIC_COLOR=$x + ;; + -fopt-info*=*.optinfo) + if [ "$CCNAME" = "gcc" ] && [ "$CCVERSION" -ge 9 ]; then + GZME="$GZME ${x##*=}" + set -- "$@" "$x" + fi + ;; + -R*) # e.g. clang's -Rpass-missed=all + if [ "${PLAT#*clang}" != "${PLAT}" ]; then + set -- "$@" "$x" + fi + ;; + -fsave-optimization-record) # clang only + if [ "${PLAT#*clang}" != "${PLAT}" ]; then + set -- "$@" "$x" + fi + ;; + *) + set -- "$@" "$x" + ;; + esac +done +if [ -z "$FDIAGNOSTIC_COLOR" ] && [ "$TERM" != "dumb" ]; then + FDIAGNOSTIC_COLOR=-fdiagnostics-color=always +fi + +if [ "${PLAT#*clang}" != "${PLAT}" ]; then + FIRST=1 + for x; do + # clang's assembler isn't complete yet + if [ $FIRST -eq 1 ]; then + set -- \ + "$x" \ + -fno-integrated-as \ + -Wno-unused-command-line-argument \ + -Wno-incompatible-pointer-types-discards-qualifiers + FIRST=0 + continue + fi + # removes flags clang whines about + case "$x" in + -gstabs) ;; + -ffixed-*) ;; + -fcall-saved*) ;; + -fsignaling-nans) ;; + -fcx-limited-range) ;; + -fno-fp-int-builtin-inexact) ;; + -Wno-unused-but-set-variable) ;; + -Wunsafe-loop-optimizations) ;; + -ftracer) ;; + -frounding-math) ;; + -fmerge-constants) ;; + -fmodulo-sched) ;; + -msse2avx) + set -- "$@" -Wa,-msse2avx + ;; + -fopt-info-vec) ;; + -fopt-info-vec-missed) ;; + -fmodulo-sched-allow-regmoves) ;; + -fgcse-*) ;; + -freschedule-modulo-scheduled-loops) ;; + -freschedule-modulo-scheduled-loops) ;; + -fipa-pta) ;; + -fsched2-use-superblocks) ;; + -fbranch-target-load-optimize) ;; + -fdelete-dead-exceptions) ;; + -funsafe-loop-optimizations) ;; + -fcall-used*) ;; + -mmitigate-rop) ;; + -mnop-mcount) ;; + -fno-align-jumps) ;; + -fno-align-labels) ;; + -fno-align-loops) ;; + -fivopts) ;; + -fschedule-insns) ;; + -fno-semantic-interposition) ;; + -mno-fentry) ;; + -f*schedule-insns2) ;; + -fvect-cost-model=*) ;; + -fsimd-cost-model=*) ;; + -fversion-loops-for-strides) ;; + -fopt-info*) ;; + -f*var-tracking-assignments) ;; + -femit-struct-debug-baseonly) ;; + -ftree-loop-vectorize) ;; + -gdescribe-dies) ;; + -flimit-function-alignment) ;; + -ftree-loop-im) ;; + -fno-instrument-functions) ;; + -fstack-clash-protection) ;; + -mstringop-strategy=*) ;; + -mpreferred-stack-boundary=*) ;; + -*stack-protector*) ;; # clang requires segmented memory for this + -f*gnu-unique) ;; + -Wframe-larger-than=*) ;; + -f*whole-program) ;; + -Wa,--size-check=*) ;; + -Wa,--listing*) ;; + -mfpmath=sse+387) ;; + -Wa,--noexecstack) ;; + -freg-struct-return) ;; + -mcall-ms2sysv-xlogues) ;; + -mno-vzeroupper) + set -- "$@" -mllvm -x86-use-vzeroupper=0 + ;; + -Wa,-a*) + x="${x#*=}" + if [ "$x" ] && [ -p "$x" ]; then + printf '' >"$x" + fi + ;; + *) + set -- "$@" "$x" + ;; + esac + done +else + # removes flags only clang supports + FIRST=1 + for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + fi + case "$x" in + -Oz) set -- "$@" -Os ;; + *) set -- "$@" "$x" ;; + esac + done +fi + +set -- "$@" -no-canonical-prefixes $FDIAGNOSTIC_COLOR $COUNTERMAND + +if [ "$SILENT" = "0" ]; then + printf "%s\n" "$*" >&2 +else + printf "$LOGFMT" "${ACTION:-COMPILE}" "${TARGET:-$OUT}" >&2 +fi + +OUTDIR="${OUT%/*}" +if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then + $MKDIR "$OUTDIR" || exit 2 +fi + +REASON=failed +trap REASON=interrupted INT + +if "$@"; then + for f in $GZME; do + if GZ=${GZ:-$(command -v gzip)}; then + if [ -f "$f" ]; then + build/actuallynice $GZ $ZFLAGS -qf $f & + fi + fi + done + exit 0 +fi + +if [ "$TERM" = "dumb" ]; then + f='%s %s\r\n\r\n' +else + f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n' +fi +printf "$f" "$CCNAME $CCVERSION: compile $REASON:" "$*" >&2 +exit 1 diff --git a/build/config.mk b/build/config.mk new file mode 100644 index 00000000..d1603ce0 --- /dev/null +++ b/build/config.mk @@ -0,0 +1,152 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +# Default Mode +# +# - `make` +# - Backtraces +# - Function tracing +# - Reasonably small +# - Reasonably optimized +# - Reasonably debuggable + +ifeq ($(MODE),) + +CONFIG_CCFLAGS += \ + $(BACKTRACES) \ + $(FTRACE) \ + -Og + +TARGET_ARCH ?= \ + -msse3 + +RAGELFLAGS ?= -G2 + +endif + +# Optimized Mode +# +# - `make MODE=opt` +# - Backtraces +# - More optimized +# - Reasonably small +# - No memory corruption detection +# - assert() / CHECK_xx() may leak code into binary for debuggability +# - GCC 8+ hoists check fails into .text.cold, thus minimizing impact + +ifeq ($(MODE), opt) + +CONFIG_CPPFLAGS += \ + -DNDEBUG \ + -msse2avx \ + -Wa,-msse2avx + +CONFIG_CCFLAGS += \ + $(BACKTRACES) \ + -O3 + +TARGET_ARCH ?= \ + -march=native + +RAGELFLAGS ?= -G2 + +endif + +# Release Mode +# +# - `make MODE=rel` +# - More optimized +# - Reasonably small +# - Numeric backtraces +# - Toilsome debuggability +# - assert() statements removed +# - DCHECK_xx() statements removed +# - No memory corruption detection +# - CHECK_xx() won't leak strings into binary + +ifeq ($(MODE), rel) + +CONFIG_CPPFLAGS += \ + -DNDEBUG + +CONFIG_CCFLAGS += \ + $(BACKTRACES) \ + -O3 + +#TARGET_ARCH ?= \ + -msse3 + +RAGELFLAGS = -G2 + +endif + +# Debug Mode +# +# - `make MODE=dbg` +# - Backtraces +# - Zero optimization +# - Enables sanitization +# - Enables stack canaries +# - Enormous binaries (b/c ubsan suboptimalities) + +ifeq ($(MODE), dbg) + +CONFIG_CPPFLAGS += \ + -DMODE_DBG + +CONFIG_CCFLAGS += \ + $(BACKTRACES) \ + $(FTRACE) \ + -fno-inline + +CONFIG_COPTS += \ + $(SECURITY_BLANKETS) \ + $(SANITIZER) + +OVERRIDE_CCFLAGS += \ + -fno-pie + +endif + +# Tiny Mode +# +# - `make MODE=tiny` +# - No checks +# - No asserts +# - No canaries +# - No paranoia +# - No avx hooks +# - No backtraces +# - No algorithmics +# - YOLO + +ifeq ($(MODE), tiny) + +CONFIG_CPPFLAGS += \ + -DTINY \ + -DNDEBUG \ + -DTRUSTWORTHY + +CONFIG_CCFLAGS += \ + -Os \ + -fno-align-functions \ + -fno-align-jumps \ + -fno-align-labels \ + -fno-align-loops + +TARGET_ARCH ?= \ + -msse3 + +endif + +# ANSI Mode +# +# Folks who want it deserve to get it, good and hard. + +ifeq ($(MODE), ansi) + +CONFIG_CCFLAGS += \ + -std=c11 \ + -Og + +endif diff --git a/build/definitions.mk b/build/definitions.mk new file mode 100644 index 00000000..3e6f875d --- /dev/null +++ b/build/definitions.mk @@ -0,0 +1,357 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# SYNOPSIS +# +# Cosmopolitan Core Build Definitions +# +# DESCRIPTION +# +# Nearly all compiler flag tuning is done within this one file. Flags +# may be customized with environment variables. We also use this file +# to compute expensive values once per build. +# +# When tuning the variables below, please note they're interpreted in +# the strictest sense. For example, we don't pass CFLAGS to gcc if we +# know it's compiling a .S file. This allows our `make SILENT=0` logs +# to be succinct and informative, at the cost of being less forgiving. +# +# Further note that link order is equally unforgiving in repositories +# of this scale. We approach that by over-specifying dependencies, in +# packages that're broken down usually on a per-directory basis. This +# is aided by the checkdeps and functional programming tools which in +# most cases should be able to deduce correct ordering automatically. +# +# Concerning our approach to flag tuning, most of it is non-essential +# and largely serves to turn features off. Particularly features that +# would otherwise lock us in to a particular platform or legal terms. +# Other flags will usually be the ones that provide us marginal gains +# in terms of performance and code size, but the world won't end when +# they aren't used. Flags that play a critical role in source working +# correctly will usually be specified on a target-by-target basis, in +# their respective packages. +# +# NOTE might have gotten the per-target override flag flow wrong since +# flags defined that way might flow quadratically opposite blaze. +# +# VARIABLES +# +# CCFLAGS gcc frontend flags (.i, .c, .cc, .f, .S, .lds, etc.) +# CPPFLAGS preprocessor flags (.h, .c, .cc, .S, .inc, .lds, etc.) +# CFLAGS c flags (.c only) +# CXXFLAGS c++ flags (.cc only) +# COPTS c/c++ flags (.c, .cc) +# LDFLAGS linker flags (don't use -Wl, frontend prefix) +# ASFLAGS assembler flags (don't use -Wa, frontend prefix) +# TARGET_ARCH microarchitecture flags (e.g. -march=native) + +SHELL = /bin/sh +DD ?= /bin/dd +CP ?= /bin/cp -f +RM ?= /bin/rm -f +SED ?= /bin/sed +MKDIR ?= /bin/mkdir -p +TAGS ?= ctags +ARFLAGS = rcsD +TAGSFLAGS ?= -e -a --if0=no --langmap=c:.c.h.i --line-directives=yes +SILENT ?= 1 +ZFLAGS ?= -4 --rsyncable +XARGS ?= xargs -P4 -rs8000 +NICE ?= build/actuallynice +RAGEL ?= ragel +DOT ?= dot +GZ ?= gzip +CLANG = clang-11 +FC = gfortran #/opt/cross9f/bin/x86_64-linux-musl-gfortran + +# see build/compile, etc. which run third_party/gcc/unbundle.sh +AS = o/third_party/gcc/bin/x86_64-linux-musl-as +CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc +CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++ +LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd +AR = o/third_party/gcc/bin/x86_64-linux-musl-ar +NM = o/third_party/gcc/bin/x86_64-linux-musl-nm +GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc +STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip +OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy +ADDR2LINE = o/third_party/gcc/bin/x86_64-linux-musl-addr2line + +COMMA := , +PWD := $(shell pwd) +IMAGE_BASE_VIRTUAL ?= 0x400000 +TMPDIR := $(shell build/findtmp) +LOGFMT := $(shell build/getlogfmt) +CCNAME := $(shell build/getccname $(CC)) +CCVERSION := $(shell build/getccversion $(CC)) +BLAH1 := $(shell build/zipobj 2>/dev/null) +BLAH2 := $(shell build/package 2>/dev/null) + +export ADDR2LINE +export CCNAME +export CCVERSION +export CP +export DD +export GZ +export IMAGE_BASE_VIRTUAL +export LOGFMT +export MKDIR +export MODE +export RM +export SED +export SILENT +export TMPDIR +export ZFLAGS + +FTRACE = \ + -pg + +SANITIZER = \ + -fsanitize=undefined \ + -fsanitize=leak \ + -fsanitize=implicit-signed-integer-truncation \ + -fsanitize=implicit-integer-sign-change + +NO_MAGIC = \ + -mno-fentry \ + -fno-stack-protector \ + -fno-sanitize=all + +OLD_CODE = \ + -fno-strict-aliasing \ + -fno-strict-overflow + +TRADITIONAL = \ + -Wno-implicit-int \ + -Wno-return-type \ + -Wno-pointer-sign + +DEFAULT_CCFLAGS = \ + -Wall \ + -Werror \ + -fmerge-all-constants \ + -fdebug-prefix-map="$(PWD)"= \ + -frecord-gcc-switches + +DEFAULT_OFLAGS = \ + -g \ + -gdescribe-dies + +DEFAULT_COPTS = \ + -fno-math-errno \ + -fno-trapping-math \ + -fno-fp-int-builtin-inexact \ + -fno-ident \ + -fno-common \ + -fno-gnu-unique \ + -fmerge-constants \ + -fstrict-aliasing \ + -fstrict-overflow \ + -fno-omit-frame-pointer \ + -fno-optimize-sibling-calls \ + -mno-omit-leaf-frame-pointer + +DEFAULT_CPPFLAGS = \ + -DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL) \ + -nostdinc \ + -iquote . \ + -include libc/integral/normalize.inc + +DEFAULT_CFLAGS = \ + -std=gnu2x + +DEFAULT_CXXFLAGS = \ + -std=gnu++11 \ + -fno-rtti \ + -fno-exceptions \ + -fuse-cxa-atexit \ + -fno-threadsafe-statics + +DEFAULT_ASFLAGS = \ + -W \ + -I. \ + --noexecstack + +DEFAULT_LDFLAGS = \ + -h \ + -static \ + --relax \ + -nostdlib \ + -m elf_x86_64 \ + --gc-sections \ + --build-id=none \ + --cref -Map=$@.map \ + --no-dynamic-linker \ + -Ttext-segment=$(IMAGE_BASE_VIRTUAL) + +ASONLYFLAGS = \ + -g \ + --debug-prefix-map="$(PWD)"= + +DEFAULT_LDLIBS = + +MCA = llvm-mca-10 \ + -mtriple=x86_64-pc-linux-gnu \ + -iterations=3 \ + -instruction-info \ + -iterations=3 \ + -all-stats \ + -all-views \ + -timeline + +cc.flags = \ + $(DEFAULT_CCFLAGS) \ + $(CONFIG_CCFLAGS) \ + $(CCFLAGS) \ + $(OVERRIDE_CCFLAGS) \ + -D__SAUCE__=\"$<\" + +o.flags = \ + $(DEFAULT_OFLAGS) \ + $(CONFIG_OFLAGS) \ + $(OFLAGS) \ + $(OVERRIDE_OFLAGS) + +cpp.flags = \ + $(DEFAULT_CPPFLAGS) \ + $(CONFIG_CPPFLAGS) \ + $(CPPFLAGS) \ + $(OVERRIDE_CPPFLAGS) + +copt.flags = \ + $(TARGET_ARCH) \ + $(DEFAULT_COPTS) \ + $(CONFIG_COPTS) \ + $(COPTS) \ + $(OVERRIDE_COPTS) + +f.flags = \ + $(DEFAULT_FFLAGS) \ + $(CONFIG_FFLAGS) \ + $(FFLAGS) \ + $(OVERRIDE_FFLAGS) + +c.flags = \ + $(DEFAULT_CFLAGS) \ + $(CONFIG_CFLAGS) \ + $(CFLAGS) \ + $(OVERRIDE_CFLAGS) + +cxx.flags = \ + $(DEFAULT_CXXFLAGS) \ + $(CONFIG_CXXFLAGS) \ + $(CXXFLAGS) \ + $(OVERRIDE_CXXFLAGS) + +s.flags = \ + $(DEFAULT_ASFLAGS) \ + $(CONFIG_ASFLAGS) \ + $(ASFLAGS) \ + $(OVERRIDE_ASFLAGS) + +S.flags = $(addprefix -Wa$(COMMA),$(s.flags)) + +LD.libs = \ + $(LDLIBS) \ + $(LOADLIBES) \ + $(DEFAULT_LDLIBS) \ + $(CONFIG_LDLIBS) \ + $(LDLIBS) \ + $(DEFAULT_LIBS) \ + $(CONFIG_LIBS) \ + $(LIBS) + +COMPILE.c.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(c.flags) +COMPILE.cxx.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(cxx.flags) +COMPILE.f.flags = $(cc.flags) $(copt.flags) $(f.flags) +COMPILE.F.flags = $(cc.flags) $(cpp.flags) $(copt.flags) $(f.flags) +COMPILE.i.flags = $(cc.flags) $(copt.flags) $(c.flags) +COMPILE.ii.flags = $(cc.flags) $(copt.flags) $(cxx.flags) +LINK.flags = $(DEFAULT_LDFLAGS) $(CONFIG_LDFLAGS) $(LDFLAGS) +OBJECTIFY.c.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(c.flags) +OBJECTIFY.cxx.flags = $(OBJECTIFY.S.flags) $(copt.flags) $(cxx.flags) +OBJECTIFY.s.flags = $(ASONLYFLAGS) $(s.flags) +OBJECTIFY.S.flags = $(copt.flags) $(cc.flags) $(o.flags) $(cpp.flags) $(S.flags) +OBJECTIFY.f.flags = $(copt.flags) $(cc.flags) $(o.flags) $(copt.flags) $(S.flags) $(f.flags) +OBJECTIFY.F.flags = $(OBJECTIFY.f.flags) $(cpp.flags) +PREPROCESS.flags = -E $(copt.flags) $(cc.flags) $(cpp.flags) +PREPROCESS.lds.flags = -D__LINKER__ $(filter-out -g%,$(PREPROCESS.flags)) -P -xc + +COMPILE.c = $(CC) -S $(COMPILE.c.flags) +COMPILE.i = $(CC) -S $(COMPILE.i.flags) +COMPILE.f = $(FC) -S $(COMPILE.f.flags) +COMPILE.F = $(FC) -S $(COMPILE.F.flags) +OBJECTIFY.s = $(AS) $(OBJECTIFY.s.flags) +OBJECTIFY.S = $(CC) $(OBJECTIFY.S.flags) -c +OBJECTIFY.f = $(FC) $(OBJECTIFY.f.flags) -c +OBJECTIFY.F = $(FC) $(OBJECTIFY.F.flags) -c +OBJECTIFY.c = $(CC) $(OBJECTIFY.c.flags) -c +OBJECTIFY.cxx = $(CXX) $(OBJECTIFY.cxx.flags) -c +PREPROCESS = $(CC) $(PREPROCESS.flags) +PREPROCESS.lds = $(CC) $(PREPROCESS.lds.flags) +LINK = build/link $(LD) $(LINK.flags) +ELF = o/libc/elf/elf.lds +ELFLINK = ACTION=LINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION) +ARCHIVE = build/archive $(AR) $(ARFLAGS) +LINKARGS = $(patsubst %.lds,-T %.lds,$(call uniqr,$(LD.libs) $(filter-out %.pkg,$^))) +LOLSAN = build/lolsan -b $(IMAGE_BASE_VIRTUAL) + +# The compiler won't generate %xmm code for sources extensioned .greg.c, +# which is needed for C modules wanting to run at the executive level or +# during privileged runtime states, e.g. code morphing. +OBJECTIFY.greg.c = \ + $(CC) \ + $(filter-out -pg,$(OBJECTIFY.c.flags)) \ + -D__MGENERAL_REGS_ONLY__ \ + -mgeneral-regs-only \ + -fno-stack-protector \ + -fno-instrument-functions \ + -fno-optimize-sibling-calls \ + -fno-sanitize=all \ + -c + +OBJECTIFY.ansi.c = $(CC) $(OBJECTIFY.c.flags) -ansi -Wextra -Werror -pedantic-errors -c +OBJECTIFY.c99.c = $(CC) $(OBJECTIFY.c.flags) -std=c99 -Wextra -Werror -pedantic-errors -c +OBJECTIFY.c11.c = $(CC) $(OBJECTIFY.c.flags) -std=c11 -Wextra -Werror -pedantic-errors -c +OBJECTIFY.c2x.c = $(CC) $(OBJECTIFY.c.flags) -std=c2x -Wextra -Werror -pedantic-errors -c + +# No-Clobber ABI (clobbers nothing, except rax and flags) +# +# This ABI is intended for core library functions that're frequently +# called by just about everything, e.g. memcpy, malloc, etc. By offering +# this guarantee, callers can optionally call these functions via asm(), +# which reduces register allocator pressure at call sites. +# +# This makes unrelated caller code faster, but the NCABI functions +# themselves a tiny bit slower. That's OK, since modern NexGen-32e CPUs +# seem to have one fifth of their execution engines devoted to pushing +# and popping, probably so legacy IA-32 code keeps going fast; so we use +# it to our advantage. +OBJECTIFY.ncabi.c = \ + $(GCC) \ + $(OBJECTIFY.c.flags) \ + -mno-sse \ + -mfpmath=387 \ + -mno-fentry \ + -fno-stack-protector \ + -fno-instrument-functions \ + -fno-optimize-sibling-calls \ + -mpreferred-stack-boundary=3 \ + -fno-sanitize=all \ + -fcall-saved-rcx \ + -fcall-saved-rdx \ + -fcall-saved-rdi \ + -fcall-saved-rsi \ + -fcall-saved-r8 \ + -fcall-saved-r9 \ + -fcall-saved-r10 \ + -fcall-saved-r11 \ + -c \ + -xc + +BUILD_SRCS = \ + build/definitions.mk \ + build/rules.mk \ + build/compile \ + build/link \ + build/lolsan \ + build/remote diff --git a/build/do b/build/do new file mode 100755 index 00000000..30b79fe9 --- /dev/null +++ b/build/do @@ -0,0 +1,54 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Generic Command Runner +# +# DESCRIPTION +# +# This does auto mkdir and ephemeral logging. +# +# EXAMPLE +# +# build/do PROG [ARGS...] + +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +# Ensure directory creation if -o PATH flag is passed. +OUT= +FIRST=1 +OUTARG=0 +for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + elif [ $OUTARG -eq 1 ]; then + OUTARG=0 + OUT="$x" + fi + case "$x" in + -o) + OUTARG=1 + ;; + -o*) + OUT=${x#-o} + ;; + esac + set -- "$@" "$x" +done +if [ "$OUT" ]; then + OUTDIR="${OUT%/*}" + if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then + $MKDIR "$OUTDIR" || exit 2 + fi +fi + +# Log command. +if [ "$SILENT" = "0" ]; then + printf "%s\n" "$*" >&2 +else + printf "$LOGFMT" "${ACTION:-BUILD}" "$TARGET" >&2 +fi + +exec "$@" diff --git a/build/findtmp b/build/findtmp new file mode 100755 index 00000000..60218326 --- /dev/null +++ b/build/findtmp @@ -0,0 +1,19 @@ +#!/usr/bin/env bash +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Temporary Directory Discovery +# +# DESCRIPTION +# +# We call this script once per build to ideally find a folder that's +# backed by an in-memory file system. We then export it to the TMPDIR +# environment variable. Many programs use it under the hood, e.g. gcc, +# so it grants many small performance improvements. + +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +$MKDIR o/tmp +echo o/tmp diff --git a/build/functions.mk b/build/functions.mk new file mode 100644 index 00000000..6196802e --- /dev/null +++ b/build/functions.mk @@ -0,0 +1,16 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# SYNOPSIS +# +# Cosmopolitan Functional Programming Build System +# +# OVERVIEW +# +# It's basically Blaze except a few lines of code, made possible due +# to the power and the glory of variables that're secretly lambdas. + +tail = $(wordlist 2,$(words $1),$1) +reverse = $(if $1,$(call reverse,$(call tail,$1)) $(firstword $1)) +uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1))) +uniqr = $(if $1,$(call uniqr,$(filter-out $(firstword $1),$1)) $(firstword $1)) diff --git a/build/getccname b/build/getccname new file mode 100755 index 00000000..83f6210e --- /dev/null +++ b/build/getccname @@ -0,0 +1,40 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Compiler Name Discovery +# +# DESCRIPTION +# +# Cosmopolitan itself may be built using either GCC and Clang, and our +# build irons out many of the differences between the two. This script +# determines which one's in play, which is nontrivial, since they tend +# to call themselves so many different names. + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +set -e + +SPECIAL_TEXT=$( + $1 --version | + sed -n ' + /Free Software/ { + i\ +gcc + q + } + /clang/ { + i\ +clang + q + } + ') + +if [ -z "$SPECIAL_TEXT" ]; then + echo gcc +else + printf '%s\n' "$SPECIAL_TEXT" +fi diff --git a/build/getccversion b/build/getccversion new file mode 100755 index 00000000..0024e3db --- /dev/null +++ b/build/getccversion @@ -0,0 +1,38 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Compiler Version Discovery +# +# DESCRIPTION +# +# Cosmopolitan itself may be built using either GCC and Clang, and our +# build irons out many of the differences between the two. This script +# is used by build/definitions.mk alongside build/getccname to support +# the different versions folks use. +# +# Our aim is to support GCC 4.2.1+ since that's the last GPLv2 version +# with any sort of industry consensus. Please note, Cosmopolitan never +# links GCC runtimes when using later versions, so some concerns might +# not apply. + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +set -e + +MAJOR_VERSION=$( + $1 --version | + head -n1 | + sed -n ' + s!^[^(]*([^)]*) \([[:digit:]][[:digit:]]*\).*!\1!p + s!^.*clang.*version \([[:digit:]][[:digit:]]*\).*!\1!p + ') + +if [ -z "$MAJOR_VERSION" ]; then + echo 6 +else + printf '%s\n' "$MAJOR_VERSION" +fi diff --git a/build/getlogfmt b/build/getlogfmt new file mode 100755 index 00000000..d168d42b --- /dev/null +++ b/build/getlogfmt @@ -0,0 +1,32 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Printf Logger Initializer +# +# DESCRIPTION +# +# This program is invoked once by build/definitions.mk to choose the +# most appropriate format string when logging command invocations. + +if [ "$SILENT" = "0" ]; then + printf "''" +else + W1=15 + if [ "$TERM" = "dumb" ]; then # e.g. emacs' dismal tty + if [ "$COLUMNS" = "" ]; then + if TPUT=$(command -v tput); then + COLUMNS=$("$TPUT" cols) + else + COLUMNS=80 + fi + fi + COLUMNS=$((COLUMNS - 1)) + W2=$((COLUMNS - W1)) + printf '%%-%ds%%-%ds\\r' "$W1" "$W2" + else + echo ♥cosmo >&2 + printf '\\033[F\\033[K%%-%ds%%s\\r\\n' "$W1" + fi +fi diff --git a/build/htags b/build/htags new file mode 100755 index 00000000..8b68d613 --- /dev/null +++ b/build/htags @@ -0,0 +1,57 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# Header Symbol Index Generator +# +# DESCRIPTION +# +# This is a static source analyzer that lets us configure Emacs +# keybindings to insert #include lines. +# +# EXAMPLES +# +# build/htags -o HTAGS $(find . -name \*.h) +# +# (defun jart-add-include () +# (interactive) +# (let* ((tag-file "HTAGS") +# (case-fold-search nil) +# (search (thing-at-point 'symbol)) +# (buffer (find-file-noselect (format "%s/%s" +# (locate-dominating-file +# (buffer-name) tag-file) +# tag-file))) +# (header (with-current-buffer buffer +# (save-excursion +# (goto-char 0) +# (when (re-search-forward +# (concat "\177" search "\001") nil t) +# (when (re-search-backward "\f\n\\([^,]*\\)," nil t) +# (match-string 1))))))) +# (when header +# (save-excursion +# (goto-char 0) +# (re-search-forward "#include") +# (re-search-forward "^$") +# (insert (concat "#include \"" header "\"\n")))))) +# (defun jart-c-mode-common-hook () +# (define-key c-mode-base-map (kbd "C-c C-h") 'jart-add-include)) +# (eval-after-load 'markdown-mode +# '(progn +# (add-hook 'c-mode-common-hook 'jart-c-mode-common-hook))) + +# ctags doesn't understand variable prototypes, e.g. +# extern char **environ; +set -- --regex-c='/^\(\(hidden\|extern\|const\) \)*[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)/\4/b' "$@" + +# ctags doesn't understand function prototypes, e.g. +# bool isheap(void *p) nothrow nocallback; +set -- --regex-c='/^[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)(.*/\2/b' "$@" + +# ctags doesn't understand function pointers, e.g. +# extern int32_t (*const SetEvent)(int64_t hEvent) wincall; +set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@" + +exec ${TAGS:-ctags} -e --langmap=c:.c.h "$@" diff --git a/build/includeall b/build/includeall new file mode 100755 index 00000000..c9882a7e --- /dev/null +++ b/build/includeall @@ -0,0 +1,6 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ + +for x; do + printf '#include "%s"\n' "$x" +done diff --git a/build/link b/build/link new file mode 100755 index 00000000..42e50cb9 --- /dev/null +++ b/build/link @@ -0,0 +1,65 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# GNU Linker Veneer +# +# DESCRIPTION +# +# This script wraps normal linker commands that're transparently +# passed-through. It adds ephemeral logging and directory creation. +# +# EXAMPLE +# +# build/linker ld -o program program.o + +if [ ! -d o/third_party/gcc ]; then + third_party/gcc/unbundle.sh +fi + +export LC_ALL=C # very important for ld +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + +OUT= +FIRST=1 +OUTARG=0 +for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + elif [ $OUTARG -eq 1 ]; then + OUTARG=0 + OUT="$x" + fi + case "$x" in + -o) + OUTARG=1 + ;; + esac + set -- "$@" "$x" +done + +if [ "$SILENT" = "0" ]; then + printf "%s\n" "$*" >&2 +else + printf "$LOGFMT" "${ACTION:-LINK.elf}" "$OUT" >&2 +fi + +OUTDIR="${OUT%/*}" +if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then + $MKDIR "$OUTDIR" || exit 2 +fi + +REASON=failed +trap REASON=interrupted INT + +"$@" && exit + +if [ "$TERM" = "dumb" ]; then + f='%s %s\r\n\r\n' +else + f='\033[91m%s\033[39m \033[94m%s\033[39m\r\n\r\n' +fi +printf "$f" "link $REASON:" "$*" >&2 +exit 1 diff --git a/build/mkdeps b/build/mkdeps new file mode 100755 index 00000000..28be7065 --- /dev/null +++ b/build/mkdeps @@ -0,0 +1,21 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ + +if [ -x "o/$MODE/tool/build/mkdeps.com" ]; then + set -- "o/$MODE/tool/build/mkdeps.com" "$@" +else + if [ ! -x o/build/bootstrap/mkdeps.com ]; then + mkdir -p o/build/bootstrap && + cp -a build/bootstrap/mkdeps.com \ + o/build/bootstrap/mkdeps.com || exit + fi + set -- o/build/bootstrap/mkdeps.com "$@" +fi + +if [ "$SILENT" = "0" ]; then + printf "%s\n" "$*" >&2 +else + printf "$LOGFMT" "${ACTION:-MKDEPS}" "$3" >&2 +fi + +exec "$@" diff --git a/build/online.mk b/build/online.mk new file mode 100644 index 00000000..6e891771 --- /dev/null +++ b/build/online.mk @@ -0,0 +1,31 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# SYNOPSIS +# +# Cosmopolitan Online Testing +# +# OVERVIEW +# +# make test HOSTS="rhel5 windows mac freebsd openbsd wsl" +# +# DESCRIPTION +# +# This code deploys and spawns testing infrastructure to a fleet of +# virtual machines running the various supported platforms. This is +# super trivial since αcτµαlly pδrταblε εxεcµταblε is an autonomous +# format requiring one simple file copy. Latencies are outstanding. +# Configuration is trivial using /etc/hosts and ~/.ssh/config. +# +# SEE ALSO +# +# - tool/build/runit.c +# - tool/build/runitd.c + +.PRECIOUS: o/$(MODE)/%.com.ok +o/$(MODE)/%.com.ok: \ + o/$(MODE)/tool/build/runit.com.dbg \ + o/$(MODE)/tool/build/runitd.com \ + o/$(MODE)/%.com + @ACTION=TEST TARGET=$@ build/do $^ $(HOSTS) + @touch $@ diff --git a/build/package b/build/package new file mode 100755 index 00000000..dcbcf95b --- /dev/null +++ b/build/package @@ -0,0 +1,31 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ + +if [ "$TOOL_BUILD_PACKAGE" ]; then + set -- "$TOOL_BUILD_PACKAGE" "$@" +else + if [ -x "o/tool/build/package.com" ]; then + set -- "o/tool/build/package.com" "$@" + else + MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit + CP=${CP:-$(command -v cp) -f} || exit + if [ ! -x o/build/bootstrap/package.com ]; then + $MKDIR o/build/bootstrap && + $CP -a build/bootstrap/package.com \ + o/build/bootstrap/package.com || exit + fi + set -- o/build/bootstrap/package.com "$@" + fi +fi + +if [ "$SILENT" = "0" ]; then + COLUMNS=${COLUMNS:-80} + COLUMNS=$((COLUMNS - 4)) + printf "%s\n" "$*" | + /usr/bin/fold -s -w $COLUMNS | + sed -e '1bb' -e 's/^/ /' -e ':b' -e '$b' -e 's/$/ \\/' >&2 +else + printf "$LOGFMT" "${ACTION:-PACKAGE}" "$3" >&2 +fi + +exec "$@" diff --git a/build/rle.py b/build/rle.py new file mode 100644 index 00000000..5c484886 --- /dev/null +++ b/build/rle.py @@ -0,0 +1,2186 @@ +# OVERVIEW +# +# Run Length Decoder Scratch Pad +# +# DESCRIPTION +# +# The Cosmopolitan library includes many compressed lookup tables that +# are easy to edit by hand. The toilsome part is usually just creating +# them. This script should provide some insight on how it can be done. + +C = ['\xe2\x88\x85', '\xe2\x98\xba', '\xe2\x98\xbb', '\xe2\x99\xa5', + '\xe2\x99\xa6', '\xe2\x99\xa3', '\xe2\x99\xa0', '\xe2\x80\xa2', + '\xe2\x97\x98', '\xe2\x97\x8b', '\xe2\x97\x99', '\xe2\x99\x82', + '\xe2\x99\x80', '\xe2\x99\xaa', '\xe2\x99\xab', '\xe2\x98\xbc', + '\xe2\x96\xba', '\xe2\x97\x84', '\xe2\x86\x95', '\xe2\x80\xbc', + '\xc2\xb6', '\xc2\xa7', '\xe2\x96\xac', '\xe2\x86\xa8', + '\xe2\x86\x91', '\xe2\x86\x93', '\xe2\x86\x92', '\xe2\x86\x90', + '\xe2\x88\x9f', '\xe2\x86\x94', '\xe2\x96\xb2', '\xe2\x96\xbc', + ' ', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', + ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', + 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', + '\xE2\x88\x96', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', + 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', + '|', '}', '~', '\xe2\x8c\x82', + '\xc3\x87', '\xc3\xbc', '\xc3\xa9', '\xc3\xa2', + '\xc3\xa4', '\xc3\xa0', '\xc3\xa5', '\xc3\xa7', + '\xc3\xaa', '\xc3\xab', '\xc3\xa8', '\xc3\xaf', + '\xc3\xae', '\xc3\xac', '\xc3\x84', '\xc3\x85', + '\xc3\x89', '\xc3\xa6', '\xc3\x86', '\xc3\xb4', + '\xc3\xb6', '\xc3\xb2', '\xc3\xbb', '\xc3\xb9', + '\xc3\xbf', '\xc3\x96', '\xc3\x9c', '\xc2\xa2', + '\xc2\xa3', '\xc2\xa5', '\xe2\x82\xac', '\xc6\x92', + '\xc3\xa1', '\xc2\xa1', '\xc3\xb3', '\xc3\xba', + '\xc3\xb1', '\xc3\x91', '\xc2\xaa', '\xc2\xba', + '\xc2\xbf', '\xe2\x8c\x90', '\xc2\xac', '\xc2\xbd', + '\xc2\xbc', '\xc2\xa1', '\xc2\xab', '\xc2\xbb', + '\xe2\x96\x91', '\xe2\x96\x92', '\xe2\x96\x93', '\xe2\x94\x82', + '\xe2\x94\xa4', '\xe2\x95\xa1', '\xe2\x95\xa2', '\xe2\x95\x96', + '\xe2\x95\x95', '\xe2\x95\xa3', '\xe2\x95\x91', '\xe2\x95\x97', + '\xe2\x95\x9d', '\xe2\x95\x9c', '\xe2\x95\x9b', '\xe2\x94\x90', + '\xe2\x94\x94', '\xe2\x94\xb4', '\xe2\x94\xac', '\xe2\x94\x9c', + '\xe2\x94\x80', '\xe2\x94\xbc', '\xe2\x95\x9e', '\xe2\x95\x9f', + '\xe2\x95\x9a', '\xe2\x95\x94', '\xe2\x95\xa9', '\xe2\x95\xa6', + '\xe2\x95\xa0', '\xe2\x95\x90', '\xe2\x95\xac', '\xe2\x95\xa7', + '\xe2\x95\xa8', '\xe2\x95\xa4', '\xe2\x95\xa5', '\xe2\x95\x99', + '\xe2\x95\x98', '\xe2\x95\x92', '\xe2\x95\x93', '\xe2\x95\xab', + '\xe2\x95\xaa', '\xe2\x94\x98', '\xe2\x94\x8c', '\xe2\x96\x88', + '\xe2\x96\x84', '\xe2\x96\x8c', '\xe2\x96\x90', '\xe2\x96\x80', + '\xce\xb1', '\xc3\x9f', '\xce\x93', '\xcf\x80', + '\xce\xa3', '\xcf\x83', '\xce\xbc', '\xcf\x84', + '\xce\xa6', '\xce\x98', '\xce\xa9', '\xce\xb4', + '\xe2\x88\x9e', '\xcf\x86', '\xce\xb5', '\xe2\x88\xa9', + '\xe2\x89\xa1', '\xc2\xb1', '\xe2\x89\xa5', '\xe2\x89\xa4', + '\xe2\x8c\xa0', '\xe2\x8c\xa1', '\xc3\xb7', '\xe2\x89\x88', + '\xc2\xb0', '\xe2\x88\x99', '\xc2\xb7', '\xe2\x88\x9a', + '\xe2\x81\xbf', '\xc2\xb2', '\xe2\x96\xa0', '\xce\xbb'] + +A = [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x01,0x00,0x80,0x00,0x40,0x00,0x00,0x80, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, + 0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x0a,0x0a,0x0a,0x0a,0x0a,0x0a,0x02, + 0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02, + 0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02, + 0x02,0x02,0x02,0x80,0x00,0x00,0x00,0x40, + 0x80,0x2a,0x2a,0x2a,0x2a,0x2a,0x2a,0x22, + 0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, + 0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, + 0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x00, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40, + 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40] + +xed_prefix_table_bit = [ + 0x00, 0x00, 0x00, 0x00, + 0x40, 0x40, 0x40, 0x40, + 0xff, 0xff, 0x00, 0x00, + 0xf0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x0d, 0x00, +] + +# please rise for the x86 national flag +xed_has_modrm_2d = [ +# 0x00 + 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 3, + 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 3, 0, 1, 1, 1, 1, 0, 0, 3, 0, + 1, 1, 1, 1, 0, 0, 3, 0, 1, 1, 1, 1, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 3, 3, 3, 3, 0, 1, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 3, 3, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, +# 0x0f + 1, 1, 1, 1, 3, 0, 0, 0, 0, 0, 3, 0, 3, 1, 0, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 1, 1, 1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +] + +def tabify(s): + res = [] + for line in s.split("\n"): + if not line: + continue + directive, number = line.split() + number = int(number) + if directive == ".zero": + res = res + [0] * number + elif directive == ".byte": + res.append(number) + else: + assert False + return res + +kHasSib = tabify("""\ + .zero 32 + .zero 4 + .byte 1 + .zero 3 + .zero 4 + .byte 1 + .zero 3 + .zero 4 + .byte 1 + .zero 3 + .zero 8 + .zero 4 + .byte 1 + .zero 3 + .zero 4 + .byte 1 + .zero 3 + .zero 4 + .byte 1 + .zero 3 + .zero 8 +""") +assert len(kHasSib) == 96, len(kHasSib) + +kHasDisp = tabify("""\ + .zero 6 + .byte 2 + .zero 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 2 + .byte 2 + .byte 2 + .byte 2 + .byte 2 + .byte 2 + .byte 2 + .byte 2 + .zero 8 + .zero 5 + .byte 4 + .zero 2 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .zero 8 + .zero 5 + .byte 4 + .zero 2 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .zero 8 +""") +assert len(kHasDisp) == 96, len(kHasDisp) + +xed_disp_bits_2d = tabify("""\ + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 2 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 5 + .byte 5 + .byte 5 + .byte 5 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 6 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 3 + .byte 3 + .byte 2 + .byte 1 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 0 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 4 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 3 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 0 + .byte 0 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 + .byte 4 +""") +assert len(xed_disp_bits_2d) == 512 + +xed_imm_bits_2d = tabify("""\ + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 7 + .byte 1 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 7 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 6 + .byte 7 + .byte 5 + .byte 5 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 5 + .byte 5 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 8 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 5 + .byte 7 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 10 + .byte 10 + .byte 10 + .byte 10 + .byte 10 + .byte 10 + .byte 10 + .byte 10 + .byte 9 + .byte 9 + .byte 8 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 2 + .byte 11 + .byte 1 + .byte 8 + .byte 1 + .byte 1 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 1 + .byte 1 + .byte 8 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 1 + .byte 0 + .byte 0 + .byte 1 + .byte 1 + .byte 3 + .byte 4 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 1 + .byte 0 + .byte 1 + .byte 1 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 0 + .byte 1 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 9 + .byte 9 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 12 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 1 + .byte 0 + .byte 0 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 9 + .byte 1 + .byte 9 + .byte 9 + .byte 9 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1 + .byte 1""") + +tables = [('xed_prefix_table_bit', xed_prefix_table_bit), + ('xed_has_modrm_2d', xed_has_modrm_2d), + ('xed_has_disp_regular', kHasDisp), + ('xed_has_sib_table', kHasSib), + ('xed_disp_bits_2d', xed_disp_bits_2d), + ('xed_imm_bits_2d', xed_imm_bits_2d)] + +# int main(int argc, char *argv[]) { +# int l = 0; +# for (unsigned i = 0; i < 256; ++i) { +# int t = 0; +# if (isspace(i)) t |= 0x01; +# if (isalpha(i)) t |= 0x02; +# if (isdigit(i)) t |= 0x04; +# if (isxdigit(i)) t |= 0x08; +# if (isprint(i)) t |= 0x10; +# if (islower(i)) t |= 0x20; +# if (isupper(i)) t |= 0x40; +# if (isblank(i)) t |= 0x80; +# printf("0x%02x,", t); +# if (++l % 8 == 0) printf("\n"); +# } +# return 0; +# } + +kCtype = [ +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x81,0x01,0x01,0x01,0x01,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x91,0x10,0x10,0x10,0x10,0x10,0x10,0x10, +0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10, +0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, +0x1c,0x1c,0x10,0x10,0x10,0x10,0x10,0x10, +0x10,0x5a,0x5a,0x5a,0x5a,0x5a,0x5a,0x52, +0x52,0x52,0x52,0x52,0x52,0x52,0x52,0x52, +0x52,0x52,0x52,0x52,0x52,0x52,0x52,0x52, +0x52,0x52,0x52,0x10,0x10,0x10,0x10,0x10, +0x10,0x3a,0x3a,0x3a,0x3a,0x3a,0x3a,0x32, +0x32,0x32,0x32,0x32,0x32,0x32,0x32,0x32, +0x32,0x32,0x32,0x32,0x32,0x32,0x32,0x32, +0x32,0x32,0x32,0x10,0x10,0x10,0x10,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +] +tables = [('kCtype', kCtype)] + + +kWidthTab1 = [ + 16, 16, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 16, 16, 32, 16, 16, 16, 33, 34, 35, 36, 37, 38, 39, + 16, 16, 40, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 41, + 42, 16, 16, 43, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 44, 16, 45, 46, 47, 48, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 49, 16, 16, 50, + 51, 16, 52, 53, 54, 16, 16, 16, 16, 16, 16, 55, 16, 16, 16, + 16, 16, 56, 57, 58, 59, 60, 61, 62, 63, 16, 16, 64, 16, 65, + 66, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 67, 68, 16, 16, 16, 69, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 70, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 71, 72, 16, 16, 16, 16, 16, 16, 16, 73, 16, 16, 16, 16, 16, + 74, 16, 16, 16, 16, 16, 16, 16, 75, 76, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, + 255, 255, 255, 191, 182, 0, 0, 0, 0, 0, 0, 0, 63, 0, 255, + 23, 0, 0, 0, 0, 0, 248, 255, 255, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 192, 191, 159, 61, 0, 0, 0, + 128, 2, 0, 0, 0, 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 192, 255, 1, 0, 0, 0, 0, 0, 0, 248, 15, + 0, 0, 0, 192, 251, 239, 62, 0, 0, 0, 0, 0, 14, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 255, + 255, 255, 255, 7, 0, 0, 0, 0, 0, 0, 20, 254, 33, 254, 0, + 12, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 16, 30, 32, 0, + 0, 12, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 16, 134, 57, + 2, 0, 0, 0, 35, 0, 6, 0, 0, 0, 0, 0, 0, 16, 190, + 33, 0, 0, 12, 0, 0, 252, 2, 0, 0, 0, 0, 0, 0, 144, + 30, 32, 64, 0, 12, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, + 0, 1, 32, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 192, 193, 61, 96, 0, 12, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 144, 64, 48, 0, 0, 12, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 24, 30, 32, 0, 0, 12, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 4, 92, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 242, 7, 128, 127, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 242, 27, 0, 63, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 0, 0, 160, 2, 0, 0, 0, 0, 0, 0, 254, + 127, 223, 224, 255, 254, 255, 255, 255, 31, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 224, 253, 102, 0, 0, 0, 195, 1, + 0, 30, 0, 100, 32, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 224, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 28, 0, 0, + 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 176, 63, + 64, 254, 15, 32, 0, 0, 0, 0, 0, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 135, + 1, 4, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, + 9, 0, 0, 0, 0, 0, 0, 64, 127, 229, 31, 248, 159, 0, 0, + 0, 0, 0, 0, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 15, + 0, 0, 0, 0, 0, 208, 23, 4, 0, 0, 0, 0, 248, 15, 0, + 3, 0, 0, 0, 60, 59, 0, 0, 0, 0, 0, 0, 64, 163, 3, + 0, 0, 0, 0, 0, 0, 240, 207, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 247, 255, 253, + 33, 16, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, + 255, 255, 255, 255, 251, 0, 248, 0, 0, 0, 124, 0, 0, 0, 0, + 0, 0, 223, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, + 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 247, 63, 0, + 0, 0, 192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, + 68, 8, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 255, 255, + 3, 0, 0, 0, 0, 0, 192, 63, 0, 0, 128, 255, 3, 0, 0, + 0, 0, 0, 7, 0, 0, 0, 0, 0, 200, 19, 0, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 126, 102, 0, 8, 16, 0, + 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 157, 193, 2, 0, + 0, 0, 0, 48, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 32, 33, 0, 0, 0, 0, 0, 64, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 255, + 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 192, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 110, 240, 0, 0, 0, 0, 0, 135, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 96, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 255, + 127, 0, 0, 0, 0, 0, 0, 128, 3, 0, 0, 0, 0, 0, 120, + 38, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 128, 239, + 31, 0, 0, 0, 0, 0, 0, 0, 8, 0, 3, 0, 0, 0, 0, + 0, 192, 127, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 128, 211, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 128, 248, 7, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 16, 1, 0, 0, 0, 192, 31, 31, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 255, 92, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 248, 133, 13, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 176, 1, 0, 0, 48, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 167, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 191, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 188, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 126, 6, 0, 0, 0, 0, 248, + 121, 128, 0, 126, 14, 0, 0, 0, 0, 0, 252, 127, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 127, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252, 255, + 255, 252, 109, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 126, 180, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 128, 7, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 15, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 128, 3, 248, 255, 231, 15, 0, 0, 0, 60, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, + 255, 255, 127, 248, 255, 255, 255, 255, 255, 31, 32, 0, 16, 0, 0, + 248, 254, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 255, + 255, 249, 219, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, +] +kWidthTab2 = [ + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 19, 16, 20, 21, 22, 16, 16, 16, 23, 16, + 16, 24, 25, 26, 27, 28, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 29, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 30, + 16, 16, 16, 16, 31, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 32, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 16, 16, 16, 33, + 34, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 35, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 36, 17, 17, 37, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 38, 39, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 40, 41, 42, 43, 44, 45, 46, 16, 16, 47, 16, 16, 16, 16, + 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 30, 9, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 48, + 0, 0, 0, 0, 0, 0, 255, 15, 0, 0, 0, 0, 128, 0, 0, + 8, 0, 2, 12, 0, 96, 48, 64, 16, 0, 0, 4, 44, 36, 32, + 12, 0, 0, 0, 1, 0, 0, 0, 80, 184, 0, 0, 0, 0, 0, + 0, 0, 224, 0, 0, 0, 1, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 63, 0, 0, 0, 255, 15, 255, 255, 255, 255, 255, 255, 255, 127, + 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 254, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 255, 255, 255, 255, 127, + 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, 255, + 255, 255, 7, 255, 255, 255, 255, 15, 0, 255, 255, 255, 255, 255, 127, + 255, 255, 255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 31, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, + 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 255, 3, 0, 0, 255, 255, 255, + 255, 247, 255, 127, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 31, 0, 0, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, + 0, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 15, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 254, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 255, 255, 255, 255, + 255, 15, 255, 1, 3, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, + 1, 224, 191, 255, 255, 255, 255, 255, 255, 255, 255, 223, 255, 255, 15, + 0, 255, 255, 255, 255, 255, 135, 15, 0, 255, 255, 17, 255, 255, 255, + 255, 255, 255, 255, 255, 127, 253, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 159, + 255, 255, 255, 255, 255, 255, 255, 63, 0, 120, 255, 255, 255, 0, 0, + 4, 0, 0, 96, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 248, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, + 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 63, 16, 7, 0, + 0, 24, 240, 1, 0, 0, 255, 255, 255, 255, 255, 127, 255, 31, 255, + 255, 255, 15, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 1, 0, + 255, 255, 127, 0, 0, 0, +] + +kZlibDistCode = [ + 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] + +# kZlibLengthCode = [ +# 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] + +# duk_hex_dectab = [ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x00-0x0f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x10-0x1f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x20-0x2f */ +# 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,0xff,0xff,0xff,0xff,0xff,0xff, # 0x30-0x3f */ +# 0xff, 10, 11, 12, 13, 14, 15,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x40-0x4f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x50-0x5f */ +# 0xff, 10, 11, 12, 13, 14, 15,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x60-0x6f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x70-0x7f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x80-0x8f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0x90-0x9f */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0xa0-0xaf */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0xb0-0xbf */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0xc0-0xcf */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0xd0-0xdf */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, # 0xe0-0xef */ +# 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff # 0xf0-0xff */ +# ] + +# tables = [('duk__base64_dectab_fast', duk__base64_dectab_fast)] + +def kXtermXlat1(c): + if c >= 3: + return (c - 3) / 10 + return 0 +def kXtermXlat2(c): + if c <= 52: return 0 + if c <= 115: return 1 + if c <= 155: return 2 + if c <= 195: return 3 + if c <= 235: return 4 + return 5 +tables = [('kXtermXlat', ([kXtermXlat1(i) for i in range(256)] + + [kXtermXlat2(i) for i in range(256)]))] + +kBoop = [int(s,16) for s in """ + 00 00 00 00 00 00 00 00 00 00 01 01 01 01 01 01 + 01 00 00 00 00 00 00 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 00 00 00 00 00 00 01 02 02 02 02 02 02 02 02 + 02 02 01 01 01 01 01 01 01 02 02 02 02 02 02 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 02 02 02 02 02 02 01 + 03 03 03 03 03 03 03 03 03 03 01 01 01 01 01 01 + 01 03 03 03 03 03 03 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 03 03 03 03 03 03 01 04 04 04 04 04 04 04 04 + 04 04 01 01 01 01 01 01 01 04 04 04 04 04 04 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 04 04 04 04 04 04 01 + 05 05 05 05 05 05 05 05 05 05 01 01 01 01 01 01 + 01 05 05 05 05 05 05 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 05 05 05 05 05 05 01 06 06 06 06 06 06 06 06 + 06 06 01 01 01 01 01 01 01 06 06 06 06 06 06 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 06 06 06 06 06 06 01 + 07 01 01 07 08 07 07 07 07 07 07 01 07 07 01 07 + 07 07 07 07 07 07 07 07 07 07 01 01 01 01 01 01 + 07 07 07 07 07 07 07 07 07 07 07 07 07 07 07 07 + 07 07 07 07 07 07 07 07 07 07 07 01 07 01 07 01 + 07 07 07 07 07 07 07 07 07 07 07 07 07 07 07 07 + 07 07 07 07 07 07 07 07 07 07 01 01 01 07 01 09 + 09 09 09 09 09 09 09 09 09 01 01 01 01 01 01 01 + 09 09 09 09 09 09 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 09 09 09 09 09 09 01 0a 0a 0a 0a 0a 0a 0a 0a 0a + 0a 01 01 01 01 01 01 01 0a 0a 0a 0a 0a 0a 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 0a 0a 0a 0a 0a 0a 01 0b + 01 01 0b 0c 0b 0b 0b 0b 0b 0b 01 0b 0b 01 0b 0b + 0b 0b 0b 0b 0b 0b 0b 0b 0b 01 01 01 01 01 01 0b + 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b + 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 01 0b 01 0b 01 0b + 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b 0b + 0b 0b 0b 0b 0b 0b 0b 0b 0b 01 01 01 0b 01 0d 0d + 0d 0d 0d 0d 0d 0d 0d 0d 01 01 01 01 01 01 01 0d + 0d 0d 0d 0d 0d 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 0d + 0d 0d 0d 0d 0d 01 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e + 01 01 01 01 01 01 01 0e 0e 0e 0e 0e 0e 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 0e 0e 0e 0e 0e 0e 01 0f 01 + 01 0f 10 01 0f 0f 0f 0f 0f 01 0f 0f 0f 0f 0f 0f + 0f 0f 0f 0f 0f 0f 0f 0f 01 01 01 01 0f 01 0f 0f + 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f + 0f 0f 0f 0f 0f 0f 0f 0f 0f 01 0f 01 0f 01 0f 0f + 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f 0f + 0f 0f 0f 0f 0f 0f 0f 0f 01 01 01 0f 01 11 11 11 + 11 11 11 11 11 11 11 01 01 01 01 01 01 01 11 11 + 11 11 11 11 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 11 11 + 11 11 11 11 01 12 12 12 12 12 12 12 12 12 12 01 + 01 01 01 01 01 01 12 12 12 12 12 12 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 12 12 12 12 12 12 01 13 01 01 + 13 14 01 13 13 13 13 13 01 13 13 13 13 13 13 13 + 13 13 13 13 13 13 13 01 01 01 01 13 01 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 01 13 01 13 01 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 01 01 01 13 01 15 15 15 15 + 15 15 15 15 15 15 01 01 01 01 01 01 01 15 15 15 + 15 15 15 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 15 15 15 + 15 15 15 01 16 16 16 16 16 16 16 16 16 16 01 01 + 01 01 01 01 01 16 16 16 16 16 16 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 16 16 16 16 16 16 01 17 17 17 17 + 17 17 17 17 17 17 01 01 01 01 01 01 01 17 17 17 + 17 17 17 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 17 17 17 + 17 17 17 01 18 18 18 18 18 18 18 18 18 18 01 01 + 01 01 01 01 01 18 18 18 18 18 18 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 18 18 18 18 18 18 01 19 01 01 19 + 1a 1b 19 19 19 19 19 1b 19 19 0f 19 19 19 19 19 + 19 19 19 19 19 19 01 01 1b 01 19 1c 19 19 19 19 + 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 + 19 19 19 19 19 19 0f 01 0f 01 19 01 19 19 19 19 + 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 19 + 19 19 19 19 19 19 01 01 01 19 01 1d 1d 1d 1d 1d + 1d 1d 1d 1d 1d 01 01 01 01 01 01 01 1d 1d 1d 1d + 1d 1d 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 1d 1d 1d 1d + 1d 1d 01 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 01 01 01 + 01 01 01 01 1e 1e 1e 1e 1e 1e 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 1e 1e 1e 1e 1e 1e 01 1b 01 01 1b 1f + 1b 1b 1b 1b 1b 1b 1b 1b 1b 01 1b 1b 1b 1b 1b 1b + 1b 1b 1b 1b 1b 01 01 1b 01 1b 1c 1b 1b 1b 1b 1b + 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b + 1b 1b 1b 1b 1b 01 01 01 01 1b 01 1b 1b 1b 1b 1b + 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b + 1b 1b 1b 1b 1b 01 01 01 1b 01 20 20 20 20 20 20 + 20 20 20 20 01 01 01 01 01 01 01 20 20 20 20 20 + 20 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 20 20 20 20 20 + 20 01 1b 1b 1b 1b 1b 1b 1b 1b 1b 1b 01 01 01 01 + 01 01 01 1b 1b 1b 1b 1b 1b 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 1b 1b 1b 1b 1b 1b 01 21 01 21 21 01 21 + 21 21 21 21 21 21 21 21 21 01 01 01 01 01 01 01 + 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 + 21 21 21 21 21 21 21 21 21 21 22 01 01 01 01 01 + 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 + 21 21 21 21 21 21 21 21 21 21 01 23 23 23 23 23 + 23 23 23 23 23 01 24 01 24 24 24 24 24 24 24 24 + 24 24 24 01 01 01 01 01 01 24 24 24 24 24 24 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 24 24 24 24 24 24 01 + 25 01 25 25 25 25 25 25 25 25 25 25 25 01 01 01 + 01 01 01 25 25 25 25 25 25 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 26 + 01 01 01 25 25 25 25 25 25 01 27 01 01 27 28 1b + 27 27 27 27 27 1b 27 27 13 27 27 27 27 27 27 27 + 27 27 27 27 01 01 1b 01 27 1c 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 13 01 13 01 27 01 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 01 01 01 27 01 29 29 29 29 29 29 29 + 29 29 29 01 01 01 01 01 01 01 29 29 29 29 29 29 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 29 29 29 29 29 29 + 01 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 01 01 01 01 01 + 01 01 2a 2a 2a 2a 2a 2a 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 2a 2a 2a 2a 2a 2a 01 2b 01 01 2b 2c 2b 2b + 2b 2b 2b 2d 2b 2d 2d 2e 2d 2d 2d 2d 2d 2d 2d 2d + 2d 2d 2b 2f 01 2b 01 2b 2f 2d 2d 2d 2d 2d 2d 2d + 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d + 2d 2d 2d 30 01 01 01 2b 01 2d 2d 2d 2d 2d 2d 2d + 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d 2d + 2d 2d 2d 01 01 01 2b 01 31 31 31 31 31 31 31 31 + 31 31 01 01 01 01 01 01 01 31 31 31 31 31 31 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 31 31 31 31 31 31 01 + 32 32 32 32 32 32 32 32 32 32 01 01 01 01 01 01 + 01 32 32 32 32 32 32 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 32 32 32 32 32 32 01 33 33 33 33 33 33 33 33 + 33 33 01 01 01 01 01 01 01 33 33 33 33 33 33 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 33 33 33 33 33 33 01 + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 01 01 01 01 01 + 01 2f 2f 2f 2f 2f 2f 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 2f 2f 2f 2f 2f 2f 01 34 34 34 34 34 34 34 34 + 34 34 01 01 01 01 01 01 01 34 34 34 34 34 34 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 34 34 34 34 34 34 01 + 35 35 35 35 35 35 35 35 35 35 01 01 01 01 01 01 + 01 35 35 35 35 35 35 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 35 35 35 35 35 35 01 36 36 36 36 36 36 36 36 + 36 36 01 01 01 01 01 01 01 36 36 36 36 36 36 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 36 36 36 36 36 36 01 + 37 37 37 37 37 37 37 37 37 37 01 01 01 01 01 01 + 01 37 37 37 37 37 37 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 37 37 37 37 37 37 01 38 38 38 38 38 38 38 38 + 38 38 01 01 01 01 01 01 01 38 38 38 38 38 38 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 38 38 38 38 38 38 01 + 39 39 39 39 39 39 39 39 39 39 01 01 01 01 01 01 + 01 39 39 39 39 39 39 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 39 39 39 39 39 39 01 3a 01 01 3a 3b 3a 3a 3a + 3a 3a 3a 01 3a 3a 01 3a 3a 3a 3a 3a 3a 3a 3a 3a + 3a 3a 01 01 01 01 01 01 3a 3a 3a 3a 3a 3a 3a 3a + 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a + 3a 3a 3a 01 3a 01 3a 01 3a 3a 3a 3a 3a 3a 3a 3a + 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a 3a + 3a 3a 01 01 01 3a 01 3c 3c 3c 3c 3c 3c 3c 3c 3c + 3c 01 01 01 01 01 01 01 3c 3c 3c 3c 3c 3c 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 3c 3c 3c 3c 3c 3c 01 3d + 3d 3d 3d 3d 3d 3d 3d 3d 3d 01 01 01 01 01 01 01 + 3d 3d 3d 3d 3d 3d 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 3d 3d 3d 3d 3d 3d 01 3e 01 01 3e 3f 3e 3e 3e 3e + 3e 3e 01 3e 3e 01 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e + 3e 01 01 01 01 01 01 3e 3e 3e 3e 3e 3e 3e 3e 3e + 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e + 3e 3e 01 3e 01 3e 01 3e 3e 3e 3e 3e 3e 3e 3e 3e + 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e 3e + 3e 01 01 01 3e 01 40 01 40 40 40 40 40 40 40 40 + 40 40 40 01 01 01 01 01 01 40 40 40 40 40 40 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 40 40 40 40 40 40 01 + 41 01 41 41 41 41 41 41 41 41 41 41 41 01 01 01 + 01 01 01 41 41 41 41 41 41 01 01 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 42 + 01 01 01 41 41 41 41 41 41 01 43 43 43 43 43 43 + 43 43 43 43 01 44 01 45 44 46 44 44 44 44 44 44 + 44 44 44 2e 44 44 44 44 44 44 44 44 44 44 01 44 + 01 44 01 01 44 47 47 47 47 47 47 47 47 47 47 47 + 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 01 + 01 01 01 44 01 47 47 47 47 47 47 47 47 47 47 47 + 47 47 47 47 47 47 47 47 47 47 47 47 47 47 47 01 + 01 01 44 01 04 01 48 04 49 04 04 04 04 04 04 04 + 04 04 4a 04 04 04 04 04 04 04 04 04 04 01 04 01 + 04 01 4b 04 04 04 04 04 04 04 04 04 04 04 04 04 + 04 04 04 04 04 04 04 04 04 04 04 04 04 04 01 01 + 01 01 04 01 04 04 04 04 04 04 04 04 04 04 04 04 + 04 04 04 04 04 04 04 04 04 04 04 04 04 04 01 01 + 01 04 01 4c 01 01 4c 4d 4c 4c 4c 4c 4c 4c 4c 4c + 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 01 4c + 01 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c + 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 01 01 01 + 01 4c 01 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c + 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 4c 01 01 01 + 4c 01 02 01 01 02 4e 02 02 02 02 02 02 02 02 02 + 02 02 02 02 02 02 02 02 02 02 02 02 02 01 02 01 + 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 02 + 02 02 02 02 02 02 02 02 02 02 02 02 01 01 01 01 + 02 01 02 02 02 02 02 02 02 02 02 02 02 02 02 02 + 02 02 02 02 02 02 02 02 02 02 02 02 01 01 01 02 + 01 06 01 48 06 4f 06 06 06 06 06 06 06 06 06 4a + 06 06 06 06 06 06 06 06 06 06 06 50 01 06 01 4b + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 01 01 01 01 06 + 01 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 01 01 01 06 01 + 0a 01 51 0a 52 0a 0a 0a 0a 0a 0a 01 0a 0a 53 0a + 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 54 01 55 01 56 01 + 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a + 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 01 0a 01 0a 01 + 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a + 0a 0a 0a 0a 0a 0a 0a 0a 0a 0a 01 01 01 0a 01 0e + 01 57 0e 58 0e 0e 0e 0e 0e 0e 01 0e 0e 59 0e 0e + 0e 0e 0e 0e 0e 0e 0e 0e 0e 5a 01 01 01 5b 01 0e + 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e + 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 01 0e 01 0e 01 0e + 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e 0e + 0e 0e 0e 0e 0e 0e 0e 0e 0e 01 01 01 0e 01 12 01 + 5c 12 5d 5e 12 12 12 12 12 01 12 12 12 12 12 12 + 12 12 12 12 12 12 12 12 01 01 5f 01 12 01 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 01 12 01 12 01 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 01 01 01 12 01 16 01 60 + 16 61 62 16 16 16 16 16 01 16 16 16 16 16 16 16 + 16 16 16 16 16 16 16 01 01 01 01 16 01 16 16 16 + 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 + 16 16 16 16 16 16 16 16 01 16 01 16 01 16 16 16 + 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 + 16 16 16 16 16 16 16 01 01 01 16 01 06 01 48 06 + 4f 06 06 06 06 06 06 06 06 06 63 06 06 06 06 06 + 06 06 06 06 06 06 50 01 06 01 4b 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 06 06 01 01 01 01 06 01 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 06 06 01 01 01 06 01 64 01 48 64 65 + 64 64 64 64 64 66 64 66 66 4a 66 66 66 66 66 66 + 66 66 66 66 64 50 01 64 01 67 06 66 66 66 66 66 + 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 + 66 66 66 66 66 22 01 01 01 64 01 66 66 66 66 66 + 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 66 + 66 66 66 66 66 01 01 01 64 01 18 01 48 18 68 18 + 18 18 18 18 18 18 18 18 4a 18 18 18 18 18 18 18 + 18 18 18 18 50 01 18 01 69 6a 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 18 18 18 18 01 01 01 01 18 01 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 18 18 18 18 01 01 01 18 01 1e 01 5c 1e 6b 6c 1e + 1e 1e 1e 1e 1b 1e 1e 12 1e 1e 1e 1e 1e 1e 1e 1e + 1e 1e 1e 01 01 6d 01 1e 1c 1e 1e 1e 1e 1e 1e 1e + 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e + 1e 1e 1e 12 01 12 01 1e 01 1e 1e 1e 1e 1e 1e 1e + 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e 1e + 1e 1e 1e 01 01 01 1e 01 6e 01 01 01 01 01 01 01 + 6f 01 6f 6f 70 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 71 + 01 01 01 01 72 01 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f + 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f + 01 01 01 01 01 01 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f + 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f 6f + 01 73 01 01 01 01 01 01 01 01 01 01 01 74 75 75 + 75 75 75 75 75 75 75 75 01 01 01 01 01 76 01 45 + 01 01 01 01 01 01 01 01 01 01 01 77 01 01 01 01 + 01 01 01 01 01 01 78 01 01 01 01 79 01 2a 01 60 + 2a 7a 7b 2a 2a 2a 2a 2a 1b 2a 2a 16 2a 2a 2a 2a + 2a 2a 2a 2a 2a 2a 2a 01 01 1b 01 2a 1c 2a 2a 2a + 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a + 2a 2a 2a 2a 2a 2a 2a 16 01 16 01 2a 01 2a 2a 2a + 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a 2a + 2a 2a 2a 2a 2a 2a 2a 01 01 01 2a 01 06 01 48 06 + 4f 06 06 06 06 06 7c 06 7c 7c 4a 7c 7c 7c 7c 7c + 7c 7c 7c 7c 7c 06 50 01 06 01 4b 06 7c 7c 7c 7c + 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c + 7c 7c 7c 7c 7c 7c 22 01 01 01 06 01 7c 7c 7c 7c + 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c 7c + 7c 7c 7c 7c 7c 7c 01 01 01 06 01 06 01 7d 06 4f + 06 06 06 06 06 7e 06 7e 7e 7f 7e 7e 7e 7e 7e 7e + 7e 7e 7e 7e 80 50 01 06 01 81 06 7e 7e 7e 7e 7e + 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e + 7e 7e 7e 7e 7e 01 01 01 01 06 01 7e 7e 7e 7e 7e + 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e 7e + 7e 7e 7e 7e 7e 01 01 01 06 01 06 01 48 06 4f 06 + 06 06 06 06 06 06 06 06 4a 82 82 82 82 82 82 82 + 82 82 82 06 50 01 06 01 4b 06 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 01 01 01 01 06 01 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 06 01 01 01 06 01 06 01 83 06 4f 06 06 + 06 06 06 06 06 06 06 84 85 85 85 85 85 85 85 85 + 85 85 06 50 01 06 01 86 06 06 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 01 01 01 01 06 01 06 06 06 06 06 06 06 + 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 06 + 06 06 06 01 01 01 06 01 18 01 7d 18 68 18 18 18 + 18 18 87 18 87 87 7f 87 87 87 87 87 87 87 87 87 + 87 88 50 01 18 01 89 6a 87 87 87 87 87 87 87 87 + 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 + 87 87 01 01 01 01 18 01 87 87 87 87 87 87 87 87 + 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 87 + 87 87 01 01 01 18 01 18 01 48 18 68 18 18 18 18 + 18 18 18 18 18 4a 8a 8a 8a 8a 8a 8a 8a 8a 8a 8a + 18 50 01 18 01 69 6a 18 18 18 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 18 01 01 01 01 18 01 18 18 18 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 18 01 01 01 18 01 18 01 83 18 68 18 18 18 18 18 + 18 18 18 18 84 8b 8b 8b 8b 8b 8b 8b 8b 8b 8b 18 + 50 01 18 01 8c 6a 18 18 18 18 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 01 01 01 01 18 01 18 18 18 18 18 18 18 18 18 18 + 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 18 + 01 01 01 18 01 04 01 48 04 49 04 04 04 04 04 8d + 04 8d 8d 4a 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8e 04 + 01 04 01 4b 04 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d + 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 01 + 01 01 01 04 01 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d + 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 8d 01 + 01 01 04 01 32 01 45 32 8f 32 32 32 32 32 32 32 + 32 32 90 32 32 32 32 32 32 32 32 32 32 32 2f 01 + 32 01 32 91 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 01 01 + 01 01 32 01 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 01 01 + 01 32 01 45 01 2f 01 45 2f 92 2f 2f 2f 2f 2f 2f + 2f 2f 2f 90 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 01 2f 01 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 + 01 01 01 2f 01 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 + 01 01 2f 01 2f 01 45 2f 92 2f 2f 2f 2f 2f 93 2f + 93 93 90 93 93 93 93 93 93 93 93 93 93 2f 2f 01 + 2f 01 2f 2f 93 93 93 93 93 93 93 93 93 93 93 93 + 93 93 93 93 93 93 93 93 93 93 93 93 93 93 30 01 + 01 01 2f 01 93 93 93 93 93 93 93 93 93 93 93 93 + 93 93 93 93 93 93 93 93 93 93 93 93 93 93 01 01 + 01 2f 01 2f 01 6e 2f 92 2f 2f 2f 2f 2f 94 2f 94 + 94 90 94 94 94 94 94 94 94 94 94 94 95 96 01 2f + 01 2f 2f 94 94 94 94 94 94 94 94 94 94 94 94 94 + 94 94 94 94 94 94 94 94 94 94 94 94 94 01 01 01 + 01 2f 01 94 94 94 94 94 94 94 94 94 94 94 94 94 + 94 94 94 94 94 94 94 94 94 94 94 94 94 01 01 01 + 2f 01 2f 01 45 2f 92 2f 2f 2f 2f 2f 2f 2f 2f 2f + 90 97 97 97 97 97 97 97 97 97 97 2f 2f 01 2f 01 + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 01 01 01 + 2f 01 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 01 01 2f + 01 2f 01 73 2f 92 2f 2f 2f 2f 2f 2f 2f 2f 2f 90 + 98 98 98 98 98 98 98 98 98 98 2f 99 01 2f 01 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 01 01 01 2f + 01 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f + 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 2f 01 01 01 2f 01 + 9a 01 45 9a 9b 9a 9a 9a 9a 9a 9a 2f 9a 9a 90 9a + 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 2f 01 2f 01 2f 2f + 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a + 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 3a 01 3a 01 9a 01 + 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a + 9a 9a 9a 9a 9a 9a 9a 9a 9a 9a 01 01 01 9a 01 35 + 01 51 35 9c 35 35 35 35 35 35 2f 35 35 90 35 35 + 35 35 35 35 35 35 35 35 35 9d 01 9e 01 2f 2f 35 + 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 + 35 35 35 35 35 35 35 35 35 3d 01 3d 01 35 01 35 + 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 + 35 35 35 35 35 35 35 35 35 01 01 01 35 01 9f 01 + 45 9f a0 9f 9f 9f 9f 9f 9f 2f 9f 9f 90 9f 9f 9f + 9f 9f 9f 9f 9f 9f 9f 9f 2f 01 2f 01 2f 2f 9f 9f + 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f + 9f 9f 9f 9f 9f 9f 9f 9f 3e 01 3e 01 9f 01 9f 9f + 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f 9f + 9f 9f 9f 9f 9f 9f 9f 9f 01 01 01 9f 01 37 01 57 + 37 a1 37 37 37 37 37 37 2f 37 37 90 37 37 37 37 + 37 37 37 37 37 37 37 a2 01 2f 01 2f 2f 37 37 37 + 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 + 37 37 37 37 37 37 37 39 01 39 01 37 01 37 37 37 + 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 + 37 37 37 37 37 37 37 01 01 01 37 01 39 01 57 39 + a3 39 39 39 39 39 39 01 39 39 01 39 39 39 39 39 + 39 39 39 39 39 39 a4 01 01 01 01 01 39 39 39 39 + 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 + 39 39 39 39 39 39 39 01 39 01 39 01 39 39 39 39 + 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 + 39 39 39 39 39 39 01 01 01 39 01 3d 01 51 3d a5 + 3d 3d 3d 3d 3d 3d 01 3d 3d 01 3d 3d 3d 3d 3d 3d + 3d 3d 3d 3d 3d a6 01 a7 01 01 01 3d 3d 3d 3d 3d + 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d + 3d 3d 3d 3d 3d 3d 01 3d 01 3d 01 3d 3d 3d 3d 3d + 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d 3d + 3d 3d 3d 3d 3d 01 01 01 3d 01 45 01 01 01 01 01 + 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 + 01 a8 a9 01 73 01 01 01 01 01 01 01 01 01 01 01 + 01 aa aa aa aa aa aa aa aa aa aa 01 ab 01 32 01 + 6e 32 8f 32 32 32 32 32 ac 32 ac ac 90 ac ac ac + ac ac ac ac ac ac ac ad 96 01 32 01 32 91 ac ac + ac ac ac ac ac ac ac ac ac ac ac ac ac ac ac ac + ac ac ac ac ac ac ac ac 01 01 01 01 32 01 ac ac + ac ac ac ac ac ac ac ac ac ac ac ac ac ac ac ac + ac ac ac ac ac ac ac ac 01 01 01 32 01 32 01 45 + 32 8f 32 32 32 32 32 32 32 32 32 90 ae ae ae ae + ae ae ae ae ae ae 32 2f 01 32 01 32 91 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 32 01 01 01 01 32 01 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 32 01 01 01 32 01 32 01 73 32 + 8f 32 32 32 32 32 32 32 32 32 90 af af af af af + af af af af af 32 99 01 32 01 32 91 32 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 01 01 01 01 32 01 32 32 32 32 + 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 + 32 32 32 32 32 32 01 01 01 32 01 00 +""".split()] + +tables = [('kBoop', kBoop)] + + +lines = [] +def put(l): + lines.append(l) +oc = 0 +toto = 0 +for name, table in tables: + toto += len(table) + it = iter(table) + c2 = next(it) + i2 = 0 + put(".L%s.rodata:" % (name)) + while c2 is not None: + c1, i1, run = c2, i2, 0 + while c1 == c2: + run += 1 + i2 += 1 + c2 = next(it, None) + s = ' ' + if 0 <= i1 < 256 and 0 <= i2 <= 256: + s = "%s " % C[i1] if i2 - i1 == 1 else "%s-%s" % (C[i1], C[i2-1]) + put("\t.byte\t%d,0x%02x\t\t# %02x-%02x %s" % (run, c1, i1, i2-1, s)) + oc += 2 + put("\t.endobj\t.L%s.rodata" % (name)) +put("\t.byte\t0,0\t\t# terminator") +oc += 2 +align = 8 +pad = align - oc % align +if pad != align: + put("\t.byte\t%s\t\t# padding" % (",".join(["0"] * pad))) + oc += pad + +print "\t.initbss 300,_init_%s" % (name) +for name, table in tables: + print "%s:" % (name) + print "\t.zero\t%d" % (len(table)) + print "\t.endobj\t%s,globl,hidden" % (name) +print "\t.previous" +print + +print "\t.initro 300,_init_%s\t# %d bytes (%d%%)" % ( + name, oc, int(round((oc / float(toto)) * 100))) +print "\n".join(lines) +print "\t.previous" +print + +print "\t.init.start 300,_init_%s" % tables[0][0] +print "\tcall\trldecode" +if pad != align: + while pad: + for op, add in (("lodsq", 8), + ("lodsl", 4), + ("lodsw", 2), + ("lodsb", 1)): + if pad >= add: + print "\t%s" % (op) + pad -= add +print "\t.init.end 300,_init_%s" % tables[0][0] diff --git a/build/rules.mk b/build/rules.mk new file mode 100644 index 00000000..84c74bce --- /dev/null +++ b/build/rules.mk @@ -0,0 +1,99 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ +# +# SYNOPSIS +# +# Cosmopolitan Core Build Rules +# +# DESCRIPTION +# +# This file shows GNU Make how to convert between file types, based on +# their extensions. We use everyday, ordinary, boring, and ubiquitous +# system commands for everything, e.g. as, cc, ld, etc. with plain and +# simple shell-script wrappers, e.g. build/assemble and build/compile. +# Those veneers abstract away most of the boring trivialities, to keep +# our makefiles pristine and readable. + +MAKEFLAGS += --no-builtin-rules + +o/%.a:; @$(ARCHIVE) $@ $^ +o/%.o: %.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $< +o/%.o: o/%.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $< +o/%.s: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/%.s: o/%.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/%.i: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/%.o: %.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $< +o/%.o: o/%.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $< +o/%.s: %.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $< +o/%.s: o/%.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $< +o/%.o: %.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $< +o/%.o: o/%.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $< +o/%.lds: %.lds; @ACTION=PREPROCESS build/compile $(PREPROCESS.lds) $(OUTPUT_OPTION) $< +o/%.inc: %.h; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $< +o/%.pkg:; @build/package $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^) +o/%.h.ok: %.h; @ACTION=CHECK.h build/compile $(COMPILE.c) -x c -g0 -o $@ $< +o/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $< +o/%.zip.o: %; @build/zipobj $(OUTPUT_OPTION) $< + +o/$(MODE)/%.a:; @$(ARCHIVE) $@ $^ +o/$(MODE)/%.o: %.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: o/$(MODE)/%.s; @TARGET=$@ build/assemble $(OBJECTIFY.s) $(OUTPUT_OPTION) $< +o/$(MODE)/%.s: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.s: o/$(MODE)/%.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: %.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: %.f; @ACTION=OBJECTIFY.f build/compile $(OBJECTIFY.f) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: %.F; @ACTION=OBJECTIFY.F build/compile $(OBJECTIFY.F) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: o/$(MODE)/%.c; @ACTION=OBJECTIFY.c build/compile $(OBJECTIFY.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.ss: %.c; @ACTION=COMPILE.c build/compile $(COMPILE.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.ss: o/$(MODE)/%.c; @ACTION=OBJECTIFY.s build/compile $(COMPILE.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.i: %.S; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.i: %.c; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.i: %.cc; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.i: o/$(MODE)/%.c; @ACTION=PREPROCESS build/compile $(PREPROCESS) $(OUTPUT_OPTION) $< +o/$(MODE)/%.h: %.c; @ACTION=AMALGAMATE build/compile $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $< +o/$(MODE)/%.h: o/$(MODE)/%.c; @ACTION=AMALGAMATE build/compile $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $< +o/$(MODE)/%.o: %.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: o/$(MODE)/%.S; @ACTION=OBJECTIFY.S build/compile $(OBJECTIFY.S) $(OUTPUT_OPTION) $< +o/$(MODE)/%.s: %.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $< +o/$(MODE)/%.s: o/$(MODE)/%.i; @ACTION=COMPILE.i build/compile $(COMPILE.i) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: %.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $< +o/$(MODE)/%.o: o/$(MODE)/%.cc; @ACTION=OBJECTIFY.cxx build/compile $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $< +o/$(MODE)/%.lds: %.lds; @ACTION=PREPROCESS build/compile $(PREPROCESS.lds) $(OUTPUT_OPTION) $< +o/$(MODE)/%.h.ok: %.h; @ACTION=CHECK.h build/compile $(COMPILE.c) -x c -g0 -o $@ $< +o/$(MODE)/%.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.greg.o: %.greg.c; @ACTION=OBJECTIFY.greg build/compile $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.ansi.o: %.ansi.c; @ACTION=OBJECTIFY.ansi build/compile $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.ansi.o: %.c; @ACTION=OBJECTIFY.ansi build/compile $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.c99.o: %.c99.c; @ACTION=OBJECTIFY.c99 build/compile $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.c11.o: %.c11.c; @ACTION=OBJECTIFY.c11 build/compile $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.c2x.o: %.c2x.c; @ACTION=OBJECTIFY.c2x build/compile $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.initabi.o: %.initabi.c; @ACTION=OBJECTIFY.init build/compile $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.ncabi.o: %.ncabi.c; @ACTION=OBJECTIFY.nc build/compile $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%.runs: o/$(MODE)/%; @ACTION=CHECK.runs TARGET=$< build/runcom $< $(TESTARGS) && touch $@ +o/$(MODE)/%.pkg:; @build/package $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^) +o/$(MODE)/%.zip.o: %; @build/zipobj $(OUTPUT_OPTION) $< + +o/$(MODE)/%-gcc.asm: %.c; @ACTION=COMPILE.c build/compile $(COMPILE.c) $(OUTPUT_OPTION) $< +o/$(MODE)/%-clang.asm: CC = $(CLANG) +o/$(MODE)/%-clang.asm: %.c; @ACTION=COMPILE.c build/compile $(COMPILE.c) $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@ +o/$(MODE)/%-gcc.asm: %.f; @ACTION=COMPILE.f build/compile $(COMPILE.f) $(OUTPUT_OPTION) $< +o/$(MODE)/%-clang.asm: CC = $(CLANG) +o/$(MODE)/%-clang.asm: %.f; @ACTION=COMPILE.f build/compile $(COMPILE.f) $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@ +o/$(MODE)/%-gcc.asm: %.F; @ACTION=COMPILE.F build/compile $(COMPILE.F) $(OUTPUT_OPTION) $< +o/$(MODE)/%-clang.asm: CC = $(CLANG) +o/$(MODE)/%-clang.asm: %.F; @ACTION=COMPILE.F build/compile $(COMPILE.F) $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@ + +# ragel state machine compiler +.PRECIOUS: build/bootstrap/%.c.gz +o/$(MODE)/%.c: %.rl build/bootstrap/%.c.gz + @mkdir -p $(dir $@) + @$(GZ) $(ZFLAGS) -dc $(<:%.rl=build/bootstrap/%.c.gz) >$@ + -@ACTION=RAGEL build/do $(RAGEL) $(RAGELFLAGS) $(OUTPUT_OPTION) $< +build/bootstrap/%.c.gz: %.rl + @mkdir -p $(dir $@) + @$(RAGEL) -o $(@:%.gz=%) $< + @$(GZ) $(ZFLAGS) -f $(@:%.gz=%) +%.svgz: %.rl + @$(RAGEL) -V -p $< | $(DOT) -Tsvg | $(GZ) $(ZFLAGS) >$@ + + $(LIBC__A_SRCS:%=o/$(MODE)/%.zip.o) \ diff --git a/build/runcom b/build/runcom new file mode 100755 index 00000000..71ea44ff --- /dev/null +++ b/build/runcom @@ -0,0 +1,9 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ + +DD=${DD:-$(command -v dd)} || exit +$DD if="$1" of="$1.bak" bs=4096 count=1 conv=notrunc 2>/dev/null +"$@" +rc=$? +$DD if="$1.bak" of="$1" bs=4096 count=1 conv=notrunc 2>/dev/null +exit $rc diff --git a/build/ssh b/build/ssh new file mode 100755 index 00000000..17a09fb6 --- /dev/null +++ b/build/ssh @@ -0,0 +1,13 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ +# +# OVERVIEW +# +# SSH Command Wrapper +# +# DESCRIPTION +# +# This script, like most of our wrappers, asks the tooling to whine +# less often. + +exec ${SSH:-ssh} -o LogLevel=QUIET "$@" diff --git a/build/zipobj b/build/zipobj new file mode 100755 index 00000000..54f9b200 --- /dev/null +++ b/build/zipobj @@ -0,0 +1,54 @@ +#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐ +#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘ + +MKDIR=${MKDIR:-$(command -v mkdir) -p} || exit +CP=${CP:-$(command -v cp) -f} || exit +SED=${SED:-$(command -v sed)} || exit + +MODE= + +OUT= +FIRST=1 +OUTARG=0 +for x; do + if [ $FIRST -eq 1 ]; then + set -- + FIRST=0 + elif [ $OUTARG -eq 1 ]; then + OUTARG=0 + OUT="$x" + fi + case "$x" in + -o) + OUTARG=1 + ;; + esac + set -- "$@" "$x" +done +OUTDIR="${OUT%/*}" +if [ "$OUTDIR" != "$OUT" ] && [ ! -d "$OUTDIR" ]; then + $MKDIR "$OUTDIR" || exit 2 +fi + +if [ -x "o/$MODE/tool/build/zipobj.com.dbg" ]; then + set -- "o/$MODE/tool/build/zipobj.com.dbg" "$@" +else + if [ ! -x o/build/bootstrap/zipobj.com ]; then + $MKDIR o/build/bootstrap && + $CP -a build/bootstrap/zipobj.com \ + o/build/bootstrap/zipobj.com || exit + fi + set -- o/build/bootstrap/zipobj.com "$@" +fi + +if [ "$SILENT" = "0" ]; then + COLUMNS=${COLUMNS:-80} + COLUMNS=$((COLUMNS - 4)) + printf "%s\n" "$*" | + /usr/bin/fold -s -w $COLUMNS | + $SED -e '1bb' -e 's/^/ /' -e ':b' -e '$b' -e 's/$/ \\/' >&2 +else + printf "$LOGFMT" "${ACTION:-ZIPOBJ}" "$3" >&2 +fi + +exec "$@" diff --git a/dsp/bmp/bmp.mk b/dsp/bmp/bmp.mk new file mode 100644 index 00000000..600bca60 --- /dev/null +++ b/dsp/bmp/bmp.mk @@ -0,0 +1,60 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += DSP_BMP + +DSP_BMP_ARTIFACTS += DSP_BMP_A +DSP_BMP = $(DSP_BMP_A_DEPS) $(DSP_BMP_A) +DSP_BMP_A = o/$(MODE)/dsp/bmp/bmp.a +DSP_BMP_A_FILES := $(wildcard dsp/bmp/*) +DSP_BMP_A_HDRS = $(filter %.h,$(DSP_BMP_A_FILES)) +DSP_BMP_A_SRCS_S = $(filter %.S,$(DSP_BMP_A_FILES)) +DSP_BMP_A_SRCS_C = $(filter %.c,$(DSP_BMP_A_FILES)) + +DSP_BMP_A_SRCS = \ + $(DSP_BMP_A_SRCS_S) \ + $(DSP_BMP_A_SRCS_C) + +DSP_BMP_A_OBJS = \ + $(DSP_BMP_A_SRCS:%=o/$(MODE)/%.zip.o) \ + $(DSP_BMP_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(DSP_BMP_A_SRCS_C:%.c=o/$(MODE)/%.o) + +DSP_BMP_A_CHECKS = \ + $(DSP_BMP_A).pkg \ + $(DSP_BMP_A_HDRS:%=o/$(MODE)/%.ok) + +DSP_BMP_A_DIRECTDEPS = \ + LIBC_NEXGEN32E \ + LIBC_TINYMATH \ + LIBC_STUBS + +DSP_BMP_A_DEPS := \ + $(call uniq,$(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x)))) + +$(DSP_BMP_A): dsp/bmp/ \ + $(DSP_BMP_A).pkg \ + $(DSP_BMP_A_OBJS) + +$(DSP_BMP_A).pkg: \ + $(DSP_BMP_A_OBJS) \ + $(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x)_A).pkg) + +o/$(MODE)/dsp/bmp/float2short.o \ +o/$(MODE)/dsp/bmp/scalevolume.o: \ + OVERRIDE_CFLAGS += \ + $(MATHEMATICAL) + +o/tiny/dsp/bmp/scalevolume.o: \ + OVERRIDE_CFLAGS += \ + -Os + +DSP_BMP_LIBS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x))) +DSP_BMP_SRCS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x)_SRCS)) +DSP_BMP_HDRS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x)_HDRS)) +DSP_BMP_CHECKS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x)_CHECKS)) +DSP_BMP_OBJS = $(foreach x,$(DSP_BMP_ARTIFACTS),$($(x)_OBJS)) +$(DSP_BMP_OBJS): $(BUILD_FILES) dsp/bmp/bmp.mk + +.PHONY: o/$(MODE)/dsp/bmp +o/$(MODE)/dsp/bmp: $(DSP_BMP_CHECKS) diff --git a/dsp/core/byte2double.c b/dsp/core/byte2double.c new file mode 100644 index 00000000..7be44e0f --- /dev/null +++ b/dsp/core/byte2double.c @@ -0,0 +1,36 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "libc/mem/mem.h" + +void *byte2double(long n, const void *p, double weight, double bias) { + long i; + double f, *dst; + unsigned char *src; + if ((dst = valloc(n * sizeof(double)))) { + for (src = p, i = 0; i < n; ++i) { + f = src[i]; + f -= bias; + f *= 1 / weight; + dst[i] = f; + } + } + return dst; +} diff --git a/dsp/core/c11.h b/dsp/core/c11.h new file mode 100644 index 00000000..ee83867f --- /dev/null +++ b/dsp/core/c11.h @@ -0,0 +1,22 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C11_H_ +#define COSMOPOLITAN_DSP_CORE_C11_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Fixed-point 8-bit rounded mean kernel. + * + * @define (a + b) / 2 + */ +static inline pureconst artificial unsigned char C11(unsigned char al, + unsigned char bl) { + short ax; + ax = al; + ax += bl; + ax += 1; + ax /= 2; + al = ax; + return al; +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C11_H_ */ diff --git a/dsp/core/c121.h b/dsp/core/c121.h new file mode 100644 index 00000000..71ef3cd4 --- /dev/null +++ b/dsp/core/c121.h @@ -0,0 +1,21 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C121_H_ +#define COSMOPOLITAN_DSP_CORE_C121_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +forceinline pureconst artificial unsigned char C121(unsigned char al, + unsigned char bl, + unsigned char cl) { + unsigned short ax, bx; + ax = al; + ax += bl; + ax += bl; + ax += cl; + ax += 2; + ax >>= 2; + return ax; +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C121_H_ */ diff --git a/dsp/core/c121s.h b/dsp/core/c121s.h new file mode 100644 index 00000000..d7f036e6 --- /dev/null +++ b/dsp/core/c121s.h @@ -0,0 +1,19 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C121S_H_ +#define COSMOPOLITAN_DSP_CORE_C121S_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +forceinline pureconst artificial signed char C121S(signed char al, + signed char bl, + signed char cl) { + short ax, bx; + ax = al; + ax += bl; + ax += bl; + ax += cl; + ax += 2; + ax >>= 2; + return ax; +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C121S_H_ */ diff --git a/dsp/core/c1331.h b/dsp/core/c1331.h new file mode 100644 index 00000000..f1f8d115 --- /dev/null +++ b/dsp/core/c1331.h @@ -0,0 +1,30 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C1331_H_ +#define COSMOPOLITAN_DSP_CORE_C1331_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Byte sized kernel for resampling memory in half. + * + * @define (1*𝑎 + 3*𝑏 + 3*𝑐 + 1*𝑑) / (1 + 3 + 3 + 1) + * @see C161() afterward for superior sin(𝑥)/𝑥 + * @limit [0,255] → [0..2,044] → [0..255] + */ +forceinline pureconst artificial unsigned char C1331(unsigned char al, + unsigned char bl, + unsigned char cl, + unsigned char dl) { + short ax, bx; + bx = bl; + bx += cl; + bx *= 3; + ax = al; + ax += dl; + ax += bx; + ax += 4; + ax >>= 3; + al = ax; + return al; +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C1331_H_ */ diff --git a/dsp/core/c1331s.h b/dsp/core/c1331s.h new file mode 100644 index 00000000..ef5a37f1 --- /dev/null +++ b/dsp/core/c1331s.h @@ -0,0 +1,28 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C1331S_H_ +#define COSMOPOLITAN_DSP_CORE_C1331S_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Byte sized kernel for resampling difference samples in half. + * + * @define (1*(a-128)+3*(a-128)+3*(a-128)+1*(a-128))/(1+3+3+1)+128 + * @see C1331(), Y420CbCr2RgbScale() + */ +forceinline pureconst artificial signed char C1331S(signed char al, + signed char bl, + signed char cl, + signed char dl) { + short ax, bx; + bx = bl; + bx += cl; + bx *= 3; + ax = al; + ax += dl; + ax += bx; + ax += 4; + ax >>= 3; + return ax; +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C1331S_H_ */ diff --git a/dsp/core/c161.h b/dsp/core/c161.h new file mode 100644 index 00000000..b6ea6097 --- /dev/null +++ b/dsp/core/c161.h @@ -0,0 +1,33 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C161_H_ +#define COSMOPOLITAN_DSP_CORE_C161_H_ +#include "libc/macros.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +#define EXTRA_SHARP 2 + +/** + * Byte sized kernel for restoring sharpness of resampled memory. + * + * @define CLAMP[(-1*𝑎 + 6*𝑏 + -1*𝑐) / (-1 + 6 + -1)] + * @limit [0..255] → [-510..1,532] → [-127..383] → [0..255] + * @see C1331() + */ +forceinline pureconst artificial unsigned char C161(unsigned char al, + unsigned char bl, + unsigned char cl) { + short ax, bx, cx; + ax = al; + bx = bl; + cx = cl; + ax *= -1; + bx *= +6; + cx *= -1; + ax += bx; + ax += cx; + ax += 2; + ax >>= 2; + return MIN(255, MAX(0, ax)); +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C161_H_ */ diff --git a/dsp/core/c161s.h b/dsp/core/c161s.h new file mode 100644 index 00000000..201b4544 --- /dev/null +++ b/dsp/core/c161s.h @@ -0,0 +1,26 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C161S_H_ +#define COSMOPOLITAN_DSP_CORE_C161S_H_ +#include "dsp/core/c161.h" +#include "libc/macros.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +forceinline pureconst artificial signed char C161S(signed char al, + signed char bl, + signed char cl) { + short ax, bx, cx; + ax = al; + bx = bl; + cx = cl; + ax *= -1 * EXTRA_SHARP; + bx *= 6 * EXTRA_SHARP; + cx *= -1 * EXTRA_SHARP; + ax += bx; + ax += cx; + ax += 2 * EXTRA_SHARP; + ax /= 4 * EXTRA_SHARP; + al = MIN(112, MAX(-112, ax)); + return al; +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C161S_H_ */ diff --git a/dsp/core/c331.h b/dsp/core/c331.h new file mode 100644 index 00000000..5b537d21 --- /dev/null +++ b/dsp/core/c331.h @@ -0,0 +1,30 @@ +#ifndef COSMOPOLITAN_DSP_CORE_C331_H_ +#define COSMOPOLITAN_DSP_CORE_C331_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +/** + * Fixed-point 8-bit magic edge resampling kernel. + * + * @define (3*a + 3*b + 1*c) / 7 + * @see C1331() + */ +static inline pureconst artificial unsigned char C331(unsigned char al, + unsigned char bl, + unsigned char cl) { + unsigned eax, ebx, ecx; + eax = al; + ebx = bl; + ecx = cl; + eax += ebx; + eax *= 3 * 2350; + ecx *= 1 * 2350; + eax += ecx; + eax >>= 14; + al = eax; + return al; +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_C331_H_ */ diff --git a/dsp/core/core.h b/dsp/core/core.h new file mode 100644 index 00000000..5c43547e --- /dev/null +++ b/dsp/core/core.h @@ -0,0 +1,37 @@ +#ifndef COSMOPOLITAN_DSP_CORE_CORE_H_ +#define COSMOPOLITAN_DSP_CORE_CORE_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +/** + * @fileoverview Cosmopolitan Digital Signal Processing. + */ + +int mulaw(int); +void *double2byte(long, const void *, double, double) vallocesque; +void *byte2double(long, const void *, double, double) vallocesque; + +void *dct(float[8][8], float, float, float, float, float); +void *dctjpeg(float[8][8]); + +double det3(const double[3][3]) nosideeffect; +void *inv3(double[restrict 3][3], const double[restrict 3][3], double); +void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]); +void *vmatmul3(double[restrict 3], const double[3], const double[3][3]); +void *matvmul3(double[restrict 3], const double[3][3], const double[3]); + +double rgb2stdtv(double) pureconst; +double rgb2lintv(double) pureconst; +double rgb2stdpc(double, double) pureconst; +double rgb2linpc(double, double) pureconst; +double tv2pcgamma(double, double) pureconst; + +#ifndef __cplusplus +void sad16x8n(size_t n, short[n][8], const short[n][8]); +void float2short(size_t n, short[n][8], const float[n][8]); +void scalevolume(size_t n, int16_t[n][8], int); +#endif + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_CORE_H_ */ diff --git a/dsp/core/core.mk b/dsp/core/core.mk new file mode 100644 index 00000000..10872e75 --- /dev/null +++ b/dsp/core/core.mk @@ -0,0 +1,69 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += DSP_CORE + +DSP_CORE_ARTIFACTS += DSP_CORE_A +DSP_CORE = $(DSP_CORE_A_DEPS) $(DSP_CORE_A) +DSP_CORE_A = o/$(MODE)/dsp/core/core.a +DSP_CORE_A_FILES := $(wildcard dsp/core/*) +DSP_CORE_A_HDRS = $(filter %.h,$(DSP_CORE_A_FILES)) +DSP_CORE_A_SRCS_S = $(filter %.S,$(DSP_CORE_A_FILES)) +DSP_CORE_A_SRCS_C = $(filter %.c,$(DSP_CORE_A_FILES)) + +DSP_CORE_A_SRCS = \ + $(DSP_CORE_A_SRCS_S) \ + $(DSP_CORE_A_SRCS_C) + +DSP_CORE_A_OBJS = \ + $(DSP_CORE_A_SRCS:%=o/$(MODE)/%.zip.o) \ + $(DSP_CORE_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(DSP_CORE_A_SRCS_C:%.c=o/$(MODE)/%.o) + +DSP_CORE_A_CHECKS = \ + $(DSP_CORE_A).pkg \ + $(DSP_CORE_A_HDRS:%=o/$(MODE)/%.ok) + +DSP_CORE_A_DIRECTDEPS = \ + LIBC_NEXGEN32E \ + LIBC_MEM \ + LIBC_TINYMATH \ + LIBC_STUBS + +DSP_CORE_A_DEPS := \ + $(call uniq,$(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x)))) + +$(DSP_CORE_A): dsp/core/ \ + $(DSP_CORE_A).pkg \ + $(DSP_CORE_A_OBJS) + +$(DSP_CORE_A).pkg: \ + $(DSP_CORE_A_OBJS) \ + $(foreach x,$(DSP_CORE_A_DIRECTDEPS),$($(x)_A).pkg) + +o/$(MODE)/dsp/core/dct.o \ +o/$(MODE)/dsp/core/c1331.o \ +o/$(MODE)/dsp/core/magikarp.o \ +o/$(MODE)/dsp/core/c93654369.o \ +o/$(MODE)/dsp/core/float2short.o \ +o/$(MODE)/dsp/core/scalevolume.o: \ + OVERRIDE_CFLAGS += \ + $(MATHEMATICAL) + +o/tiny/dsp/core/scalevolume.o: \ + OVERRIDE_CFLAGS += \ + -Os + +o/$(MODE)/dsp/core/det3.o: \ + OVERRIDE_CFLAGS += \ + -ffast-math + +DSP_CORE_LIBS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x))) +DSP_CORE_SRCS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_SRCS)) +DSP_CORE_HDRS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_HDRS)) +DSP_CORE_CHECKS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_CHECKS)) +DSP_CORE_OBJS = $(foreach x,$(DSP_CORE_ARTIFACTS),$($(x)_OBJS)) +$(DSP_CORE_OBJS): $(BUILD_FILES) dsp/core/core.mk + +.PHONY: o/$(MODE)/dsp/core +o/$(MODE)/dsp/core: $(DSP_CORE_CHECKS) diff --git a/dsp/core/dct.c b/dsp/core/dct.c new file mode 100644 index 00000000..43231757 --- /dev/null +++ b/dsp/core/dct.c @@ -0,0 +1,85 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" + +#define DCT(A, B, C, D, E, F, G, H, T, C0, C1, C2, C3, C4) \ + do { \ + T z1, z2, z3, z4, z5, z11, z13; \ + T t0, t1, t2, t3, t4, t5, t6, t7, t8, t10, t11, t12, t13; \ + t0 = A + H; \ + t7 = A - H; \ + t1 = B + G; \ + t6 = B - G; \ + t2 = C + F; \ + t5 = C - F; \ + t3 = D + E; \ + t4 = D - E; \ + t10 = t0 + t3; \ + t13 = t0 - t3; \ + t11 = t1 + t2; \ + t12 = t1 - t2; \ + A = t10 + t11; \ + E = t10 - t11; \ + z1 = (t12 + t13) * C0; \ + C = t13 + z1; \ + G = t13 - z1; \ + t10 = t4 + t5; \ + t11 = t5 + t6; \ + t12 = t6 + t7; \ + z5 = (t10 - t12) * C1; \ + z2 = t10 * C2 + z5; \ + z4 = t12 * C3 + z5; \ + z3 = t11 * C4; \ + z11 = t7 + z3; \ + z13 = t7 - z3; \ + F = z13 + z2; \ + D = z13 - z2; \ + B = z11 + z4; \ + H = z11 - z4; \ + } while (0) + +/** + * Performs float forward discrete cosine transform. + * + * This takes a tiny block of image data and shoves the information it + * represents into the top left corner. It can be reversed using idct(). + * It matters because iterating the result in a serpentine pattern makes + * run-length delta encoding super effective. Furthermore, data downward + * rightly may be divided away for lossy compression. + * + * @cost ~100ns + */ +void *dct(float M[8][8], float c0, float c1, float c2, float c3, float c4) { + unsigned y, x; + for (y = 0; y < 8; ++y) { + DCT(M[y][0], M[y][1], M[y][2], M[y][3], M[y][4], M[y][5], M[y][6], M[y][7], + float, c0, c1, c2, c3, c4); + } + for (x = 0; x < 8; ++x) { + DCT(M[0][x], M[1][x], M[2][x], M[3][x], M[4][x], M[5][x], M[6][x], M[7][x], + float, c0, c1, c2, c3, c4); + } + return M; +} + +void *dctjpeg(float M[8][8]) { + return dct(M, .707106781f, .382683433f, .541196100f, 1.306562965f, + .707106781f); +} diff --git a/dsp/core/det3.c b/dsp/core/det3.c new file mode 100644 index 00000000..5db5b159 --- /dev/null +++ b/dsp/core/det3.c @@ -0,0 +1,36 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" + +#define LEIBNIZ_FORMULA(a, b, c, d, e, f, g, h, i) \ + (a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h) + +/** + * Computes determinant of 3×3 matrix. + * i.e. how much space is inside the cube + * + * @param 𝐀 is input matrix + * @param 𝑑 is det(𝐀) + * @return |𝐀| or 0 if degenerate + */ +double det3(const double A[3][3]) { + return LEIBNIZ_FORMULA(A[0][0], A[0][1], A[0][2], A[1][0], A[1][1], A[1][2], + A[2][0], A[2][1], A[2][2]); +} diff --git a/dsp/core/differsumsq.c b/dsp/core/differsumsq.c new file mode 100644 index 00000000..bac10d57 --- /dev/null +++ b/dsp/core/differsumsq.c @@ -0,0 +1,67 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" + +/** + * Computes Σ𝑥ᵢΣ𝑥ⱼΣ𝑥ₖΣ𝑥ₗΣ𝑥ₘΣ𝑥ₙ(δ₁𝑥ᵢ+δ₂𝑥ⱼ+δ₃𝑥ₖ+δ₄𝑥ₗ+δ₅𝑥ₘ+δ₆𝑥ₙ)² over 𝐿..𝐻 + * + * “As soon as an Analytical Engine exists, it will necessarily + * guide the future course of the science. Whenever any result + * is sought by its aid, the question will then arise — by what + * course of calculation can these results be arrived at by the + * machine in the shortest time? + * + * — Charles Babbage (Life of a Philosopher, 1864) + * + * @see itu.int/rec/R-REC-BT.601/ + */ +double DifferSumSq(const double D[static 6], double L, double H) { + double T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T2, T20, T21, T22, + T23, T24, T25, T26, T27, T3, T4, T5, T6, T7, T8, T9; + T2 = H * H, T3 = (H * H * H), T4 = (H * H * H * H), T5 = (H * H * H * H * H), + T6 = (H * H * H * H * H * H), T7 = -10 * H, T8 = (H * H * H * H * H * H * H), + T9 = (L * L * L * L * L * L * L * L), T10 = (L * L * L * L * L * L * L), + T11 = (L * L * L * L * L * L), T12 = (L * L * L * L * L), T13 = -45 * T2, + T14 = (L * L * L * L), T15 = 180 * T3, T16 = 120 * T2, T17 = (L * L * L), + T18 = L * L, T19 = 18 * T2, T20 = (H * H * H * H * H * H * H * H); + T21 = 45 * T4; + T22 = 3 * T9 + (-12 * H - 18) * T10 + (12 * T2 + 54 * H + 45) * T11 + + (12 * T3 - T19 - 90 * H - 60) * T12 + + (-30 * T4 - 90 * T3 + T13 + 60 * H + 45) * T14 + + (12 * T5 + 90 * T4 + T15 + T16 - 18) * T17 + + (12 * T6 + 18 * T5 - T21 - 120 * T3 - 90 * T2 - 18 * H + 3) * T18 + + (-12 * T8 - 54 * T6 - 90 * T5 - 60 * T4 + T19 + 6 * H) * L + 3 * T20 + + 18 * T8 + 45 * T6 + 60 * T5 + T21 + 18 * T3 + 3 * T2; + T23 = + 2 * T9 + (T7 - 13) * T10 + (20 * T2 + 55 * H + 36) * T11 + + (-22 * T3 - 93 * T2 - 126 * H - 55) * T12 + + (20 * T4 + 95 * T3 + 180 * T2 + 155 * H + 50) * T14 + + (-22 * T5 - 95 * T4 - T15 - 190 * T2 - 110 * H - 27) * T17 + + (20 * T6 + 93 * T5 + 180 * T4 + 190 * T3 + T16 + 45 * H + 8) * T18 + + (-10 * T8 - 55 * T6 - 126 * T5 - 155 * T4 - 110 * T3 + T13 + T7 - 1) * L + + 2 * T20 + 13 * T8 + 36 * T6 + 55 * T5 + 50 * T4 + 27 * T3 + 8 * T2 + H; + T24 = T22 * D[3], T25 = T22 * D[2], T26 = T22 * D[1], T27 = T22 * D[0]; + return (T23 * D[5] * D[5] + (T22 * D[4] + T24 + T25 + T26 + T27) * D[5] + + T23 * D[4] * D[4] + (T24 + T25 + T26 + T27) * D[4] + + T23 * D[3] * D[3] + (T25 + T26 + T27) * D[3] + T23 * D[2] * D[2] + + (T26 + T27) * D[2] + T23 * D[1] * D[1] + T22 * D[0] * D[1] + + T23 * D[0] * D[0]) / + 6; +} diff --git a/dsp/core/differsumsq8.c b/dsp/core/differsumsq8.c new file mode 100644 index 00000000..92fb8c6e --- /dev/null +++ b/dsp/core/differsumsq8.c @@ -0,0 +1,463 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "dsp/core/q.h" + +/** + * Computes Σ𝑥ᵢΣ𝑥ⱼΣ𝑥ₖΣ𝑥ₗΣ𝑥ₘΣ𝑥ₙΣ𝑥ₚΣ𝑥ₛ(δ₁𝑥ᵢ+δ₂𝑥ⱼ+δ₃𝑥ₖ+δ₄𝑥ₗ+δ₅𝑥ₘ+δ₆𝑥ₙ+δₚ𝑥ₚ+δₛ𝑥ₛ)² + * + * “As soon as an Analytical Engine exists, it will necessarily + * guide the future course of the science. Whenever any result + * is sought by its aid, the question will then arise — by what + * course of calculation can these results be arrived at by the + * machine in the shortest time? + * + * — Charles Babbage (Life of a Philosopher, 1864) + * + */ +double DifferSumSq8(const double D[static 8], double L, double H) { + double T10, T100, T101, T102, T103, T104, T105, T106, T107, T108, T109, T11; + double T110, T111, T112, T113, T114, T115, T116, T117, T118, T119, T12, T120; + double T121, T122, T123, T124, T125, T126, T127, T128, T129, T13, T130, T131; + double T132, T133, T134, T135, T136, T137, T138, T139, T14, T140, T141, T142; + double T143, T144, T145, T146, T147, T148, T149, T15, T150, T151, T152, T153; + double T154, T155, T156, T157, T158, T159, T16, T160, T161, T162, T163, T164; + double T165, T166, T167, T168, T169, T17, T170, T171, T172, T173, T174, T175; + double T176, T177, T178, T179, T18, T180, T181, T182, T183, T184, T185, T186; + double T187, T188, T189, T19, T190, T191, T192, T193, T194, T195, T196, T197; + double T198, T199, T2, T20, T200, T201, T202, T203, T204, T205, T206, T207; + double T208, T209, T21, T210, T211, T212, T213, T214, T215, T216, T217, T218; + double T219, T22, T220, T221, T222, T223, T224, T225, T226, T227, T228, T229; + double T230, T231, T232, T233, T234, T235, T236, T237, T238, T239, T24, T240; + double T241, T242, T243, T244, T245, T246, T247, T248, T249, T25, T250, T251; + double T252, T253, T254, T255, T256, T257, T258, T259, T26, T260, T261, T262; + double T263, T264, T265, T266, T267, T268, T269, T27, T270, T271, T272, T273; + double T274, T275, T276, T277, T278, T279, T28, T280, T281, T282, T283, T284; + double T285, T286, T287, T288, T289, T29, T290, T291, T292, T293, T294, T295; + double T296, T297, T298, T299, T3, T30, T300, T301, T302, T303, T304, T305; + double T307, T308, T309, T31, T310, T311, T312, T313, T314, T315, T316, T317; + double T318, T319, T32, T320, T321, T322, T323, T324, T325, T326, T327, T328; + double T329, T33, T330, T331, T332, T333, T334, T335, T336, T337, T338, T339; + double T34, T340, T341, T342, T343, T344, T345, T346, T347, T348, T349, T35; + double T350, T351, T352, T353, T354, T355, T356, T357, T358, T359, T36, T360; + double T361, T362, T363, T364, T365, T366, T367, T368, T369, T37, T370, T371; + double T372, T373, T374, T375, T376, T377, T378, T379, T38, T380, T381, T382; + double T383, T384, T385, T386, T387, T388, T389, T39, T390, T391, T392, T393; + double T394, T395, T396, T397, T398, T399, T4, T40, T400, T401, T402, T403; + double T405, T406, T407, T41, T42, T43, T44, T45, T46, T47, T48, T49, T5, T50; + double T51, T52, T53, T54, T55, T56, T57, T58, T59, T6, T60, T61, T62, T63; + double T65, T66, T67, T68, T69, T7, T70, T71, T72, T73, T74, T75, T76, T77; + double T79, T8, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T9, T90; + double T92, T93, T94, T95, T96, T97, T98, T99, T23, T306, T91, T78, T64, T404; + T2 = 4 * D[5], T3 = 3 * D[4], T4 = 3 * D[3], T5 = 3 * D[2], T6 = 3 * D[1], + T7 = 3 * D[0], T8 = D[7] * D[7], T9 = D[6] * D[6], T10 = -28 * D[5], + T11 = -18 * D[4], T12 = -18 * D[3], T13 = -18 * D[2], T14 = -18 * D[1], + T15 = -18 * D[0], T16 = D[5] * D[5], T17 = D[4] * D[4], T18 = D[3] * D[3], + T19 = D[2] * D[2], T20 = D[1] * D[1], T21 = D[0] * D[0], T22 = -34 * D[5], + T23 = -24 * D[4], T24 = -24 * D[3], T25 = -24 * D[2], T26 = -24 * D[1], + T27 = -24 * D[0], T28 = 84 * D[5], T29 = 39 * D[4], T30 = 39 * D[3], + T31 = 39 * D[2], T32 = 39 * D[1], T33 = 39 * D[0], T34 = 210 * D[5], + T35 = 120 * D[4], T36 = 120 * D[3], T37 = 120 * D[2], T38 = 120 * D[1], + T39 = 120 * D[0], T40 = 128 * D[5], T41 = 84 * D[4], T42 = 84 * D[3], + T43 = 84 * D[2], T44 = 84 * D[1], T45 = 84 * D[0]; + T46 = -144 * D[5], T47 = (T23 + T24 + T25 + T26 + T27) * D[5], + T48 = (T24 + T25 + T26 + T27) * D[4], T49 = (T25 + T26 + T27) * D[3], + T50 = (T26 + T27) * D[2], T51 = -24 * D[0] * D[1], T52 = -552 * D[5], + T53 = -192 * D[4], T54 = -192 * D[3], T55 = -192 * D[2], T56 = -192 * D[1], + T57 = -192 * D[0], T58 = H * H, T59 = -688 * D[5], T60 = -336 * D[4], + T61 = -336 * D[3], T62 = -336 * D[2], T63 = -336 * D[1], T64 = -336 * D[0], + T65 = -280 * D[5], T66 = -168 * D[4], T67 = -168 * D[3], T68 = -168 * D[2], + T69 = -168 * D[1], T70 = -168 * D[0], T71 = 168 * D[5], T72 = -42 * D[4], + T73 = -42 * D[3], T74 = -42 * D[2], T75 = -42 * D[1], T76 = -42 * D[0], + T77 = (H * H * H), T78 = 336 * D[4], T79 = 336 * D[3], T80 = 336 * D[2], + T81 = 336 * D[1], T82 = 336 * D[0], T83 = 1568 * D[5], + T84 = 336 * D[0] * D[1], T85 = 1288 * D[5], T86 = 504 * D[4], + T87 = 504 * D[3], T88 = 504 * D[2], T89 = 504 * D[1], T90 = 504 * D[0], + T91 = 392 * D[5], T92 = 210 * D[4], T93 = 210 * D[3], T94 = 210 * D[2], + T95 = 210 * D[1], T96 = 210 * D[0], T97 = 84 * T8, T98 = 168 * D[6], + T99 = 84 * T9, T100 = 84 * T16, T101 = (T41 + T42 + T43 + T44 + T45) * D[5], + T102 = 84 * T17, T103 = (T42 + T43 + T44 + T45) * D[4], T104 = 84 * T18, + T105 = (T43 + T44 + T45) * D[3], T106 = 84 * T19, T107 = (T44 + T45) * D[2], + T108 = 84 * T20, T109 = 84 * D[0] * D[1], T110 = 84 * T21, T111 = -924 * D[5], + T112 = (T78 + T79 + T80 + T81 + T82) * D[5], + T113 = (T79 + T80 + T81 + T82) * D[4], T114 = (T80 + T81 + T82) * D[3], + T115 = (T81 + T82) * D[2], T116 = (H * H * H * H), T117 = -2128 * D[5], + T118 = -2520 * D[5], T119 = (T66 + T67 + T68 + T69 + T70) * D[5], + T120 = (T67 + T68 + T69 + T70) * D[4], T121 = (T68 + T69 + T70) * D[3], + T122 = (T69 + T70) * D[2], T123 = -168 * D[0] * D[1], T124 = -1512 * D[5], + T125 = -420 * D[4], T126 = -420 * D[3], T127 = -420 * D[2], + T128 = -420 * D[1], T129 = -420 * D[0], T130 = -364 * D[5]; + T131 = T97 + (T98 + T71 + T72 + T73 + T74 + T75 + T76) * D[7] + T99 + + (T71 + T72 + T73 + T74 + T75 + T76) * D[6] + T100 + + (T72 + T73 + T74 + T75 + T76) * D[5] + T102 + + (T73 + T74 + T75 + T76) * D[4] + T104 + (T74 + T75 + T76) * D[3] + + T106 + (T75 + T76) * D[2] + T108 - 42 * D[0] * D[1] + T110; + T132 = 462 * T8, T133 = 924 * D[6], T134 = 924 * D[5], T135 = 462 * T9, + T136 = 462 * T16, T137 = (T60 + T61 + T62 + T63 + T64) * D[5], + T138 = 462 * T17, T139 = (T61 + T62 + T63 + T64) * D[4], T140 = 462 * T18, + T141 = (T62 + T63 + T64) * D[3], T142 = 462 * T19, T143 = (T63 + T64) * D[2], + T144 = 462 * T20, T145 = 462 * T21, T146 = (H * H * H * H * H), + T147 = 2240 * D[5], T148 = -840 * D[4], T149 = -840 * D[3], + T150 = -840 * D[2], T151 = -840 * D[1], T152 = -840 * D[0], + T153 = 3080 * D[5], T154 = (T148 + T149 + T150 + T151 + T152) * D[5], + T155 = (T149 + T150 + T151 + T152) * D[4], T156 = (T150 + T151 + T152) * D[3], + T157 = (T151 + T152) * D[2], T158 = -840 * D[0] * D[1], T159 = 1260 * T8, + T160 = 2520 * D[6], T161 = 2520 * D[5], T162 = 1260 * T9, T163 = 1260 * T16, + T164 = 1260 * T17, T165 = 1260 * T18, T166 = 1260 * T19, T167 = 1260 * T20, + T168 = 210 * D[0] * D[1], T169 = 1260 * T21, T170 = 168 * D[4], + T171 = 168 * D[3], T172 = 168 * D[2], T173 = 168 * D[1], T174 = 168 * D[0], + T175 = 1148 * D[5], T176 = 168 * D[0] * D[1], T177 = 224 * D[5]; + T178 = -72 * T8 + (-144 * D[6] + T46 + T23 + T24 + T25 + T26 + T27) * D[7] - + 72 * T9 + (T46 + T23 + T24 + T25 + T26 + T27) * D[6] - 72 * T16 + T47 - + 72 * T17 + T48 - 72 * T18 + T49 - 72 * T19 + T50 - 72 * T20 + T51 - + 72 * T21; + T179 = 420 * T8, T180 = 840 * D[6], T181 = 840 * D[5], T182 = 420 * T9, + T183 = 840 * D[5] * D[6], T184 = 420 * T16, T185 = 420 * T17, + T186 = 420 * T18, T187 = 420 * T19, T188 = 420 * T20, T189 = 420 * T21, + T190 = (H * H * H * H * H * H); + T191 = -1064 * T8 + + (-2128 * D[6] + T117 + T78 + T79 + T80 + T81 + T82) * D[7] - + 1064 * T9 + (T117 + T78 + T79 + T80 + T81 + T82) * D[6] - 1064 * T16 + + T112 - 1064 * T17 + T113 - 1064 * T18 + T114 - 1064 * T19 + T115 - + 1064 * T20 + T84 - 1064 * T21; + T192 = 1540 * T8, T193 = 3080 * D[6], T194 = 840 * D[4], T195 = 840 * D[3], + T196 = 840 * D[2], T197 = 840 * D[1], T198 = 840 * D[0], T199 = 1540 * T9, + T200 = 1540 * T16, T201 = 1540 * T17, T202 = 1540 * T18, T203 = 1540 * T19, + T204 = 1540 * T20, T205 = 840 * D[0] * D[1], T206 = 1540 * T21, + T207 = -2800 * D[5], T208 = (T194 + T195 + T196 + T197 + T198) * D[5], + T209 = (T195 + T196 + T197 + T198) * D[4], T210 = (T196 + T197 + T198) * D[3], + T211 = (T197 + T198) * D[2], T212 = -1624 * D[5], T213 = -88 * D[5]; + T214 = 42 * T8 + (84 * D[6] + T28 + T29 + T30 + T31 + T32 + T33) * D[7] + + 42 * T9 + (T28 + T29 + T30 + T31 + T32 + T33) * D[6] + 42 * T16 + + (T29 + T30 + T31 + T32 + T33) * D[5] + 42 * T17 + + (T30 + T31 + T32 + T33) * D[4] + 42 * T18 + (T31 + T32 + T33) * D[3] + + 42 * T19 + (T32 + T33) * D[2] + 42 * T20 + 39 * D[0] * D[1] + 42 * T21; + T215 = 276 * T8, T216 = 552 * D[6], T217 = 552 * D[5], T218 = 192 * D[4], + T219 = 192 * D[3], T220 = 192 * D[2], T221 = 192 * D[1], T222 = 192 * D[0], + T223 = 276 * T9, T224 = 276 * T16, T225 = 276 * T17, T226 = 276 * T18, + T227 = 276 * T19, T228 = 276 * T20, T229 = 192 * D[0] * D[1], + T230 = 276 * T21, T231 = (H * H * H * H * H * H * H); + T232 = 784 * T8 + (1568 * D[6] + T83 + T78 + T79 + T80 + T81 + T82) * D[7] + + 784 * T9 + (T83 + T78 + T79 + T80 + T81 + T82) * D[6] + 784 * T16 + + T112 + 784 * T17 + T113 + 784 * T18 + T114 + 784 * T19 + T115 + + 784 * T20 + T84 + 784 * T21; + T233 = (T170 + T171 + T172 + T173 + T174) * D[5]; + T234 = (T171 + T172 + T173 + T174) * D[4]; + T235 = (T172 + T173 + T174) * D[3]; + T236 = (T173 + T174) * D[2]; + T237 = T159 + (T160 + T161 - T92 - T93 - T94 - T95 - T96) * D[7] + T162 + + (T161 - T92 - T93 - T94 - T95 - T96) * D[6] + T163 + + (-T92 - T93 - T94 - T95 - T96) * D[5] + T164 + + (-T93 - T94 - T95 - T96) * D[4] + T165 + (-T94 - T95 - T96) * D[3] + + T166 + (-T95 - T96) * D[2] + T167 - T168 + T169; + T238 = 812 * T8, T239 = 1624 * D[6], T240 = 1624 * D[5], T241 = 812 * T9, + T242 = 812 * T16, T243 = 812 * T17, T244 = 812 * T18, T245 = 812 * T19, + T246 = 812 * T20, T247 = 812 * T21, T248 = 672 * D[5], T249 = 20 * D[5], + T250 = (T3 + T4 + T5 + T6 + T7) * D[5], T251 = (T4 + T5 + T6 + T7) * D[4], + T252 = (T5 + T6 + T7) * D[3], T253 = (T6 + T7) * D[2], T254 = 3 * D[0] * D[1]; + T255 = -14 * T8 + (-28 * D[6] + T10 + T11 + T12 + T13 + T14 + T15) * D[7] - + 14 * T9 + (T10 + T11 + T12 + T13 + T14 + T15) * D[6] - 14 * T16 + + (T11 + T12 + T13 + T14 + T15) * D[5] - 14 * T17 + + (T12 + T13 + T14 + T15) * D[4] - 14 * T18 + (T13 + T14 + T15) * D[3] - + 14 * T19 + (T14 + T15) * D[2] - 14 * T20 - 18 * D[0] * D[1] - 14 * T21; + T256 = 105 * T8, T257 = 210 * D[6], T258 = 105 * T9, T259 = 105 * T16, + T260 = 105 * T17, T261 = 105 * T18, T262 = 105 * T19, T263 = 105 * T20, + T264 = 120 * D[0] * D[1], T265 = 105 * T21, + T266 = (H * H * H * H * H * H * H * H); + T267 = -344 * T8 + (-688 * D[6] + T59 + T60 + T61 + T62 + T63 + T64) * D[7] - + 344 * T9 + (T59 + T60 + T61 + T62 + T63 + T64) * D[6] - 344 * T16 + + T137 - 344 * T17 + T139 - 344 * T18 + T141 - 344 * T19 + T143 - + 344 * T20 - T84 - 344 * T21; + T268 = 644 * T8, T269 = 1288 * D[6], T270 = 644 * T9, T271 = 644 * T16, + T272 = 644 * T17, T273 = 644 * T18, T274 = 644 * T19, T275 = 644 * T20, + T276 = 504 * D[0] * D[1], T277 = 644 * T21; + T278 = -756 * T8 + + (-1512 * D[6] + T124 + T125 + T126 + T127 + T128 + T129) * D[7] - + 756 * T9 + (T124 + T125 + T126 + T127 + T128 + T129) * D[6] - + 756 * T16 + (T125 + T126 + T127 + T128 + T129) * D[5] - 756 * T17 + + (T126 + T127 + T128 + T129) * D[4] - 756 * T18 + + (T127 + T128 + T129) * D[3] - 756 * T19 + (T128 + T129) * D[2] - + 756 * T20 - 420 * D[0] * D[1] - 756 * T21; + T279 = 574 * T8, T280 = 1148 * D[6], T281 = 574 * T9, T282 = 574 * T16, + T283 = 574 * T17, T284 = 574 * T18, T285 = 574 * T19, T286 = 574 * T20, + T287 = 574 * T21; + T288 = -280 * T8 + (-560 * D[6] - 560 * D[5]) * D[7] - 280 * T9 - + 560 * D[5] * D[6] - 280 * T16 - 280 * T17 - 280 * T18 - 280 * T19 - + 280 * T20 - 280 * T21; + T289 = 24 * D[4], T290 = 24 * D[3], T291 = 24 * D[2], T292 = 24 * D[1], + T293 = 24 * D[0], T294 = 24 * D[0] * D[1], T295 = -14 * T8, T296 = -28 * D[6], + T297 = -14 * T9, T298 = 6 * D[4], T299 = 6 * D[3], T300 = 6 * D[2], + T301 = 6 * D[1], T302 = 6 * D[0], T303 = -14 * T16, T304 = -14 * T17, + T305 = -14 * T18, T306 = -14 * T19, T307 = -14 * T20, T308 = -14 * T21; + T309 = 2 * T8 + (4 * D[6] + T2 + T3 + T4 + T5 + T6 + T7) * D[7] + 2 * T9 + + (T2 + T3 + T4 + T5 + T6 + T7) * D[6] + 2 * T16 + T250 + 2 * T17 + + T251 + 2 * T18 + T252 + 2 * T19 + T253 + 2 * T20 + T254 + 2 * T21; + T310 = 17 * T8, T311 = 34 * D[6], T312 = 34 * D[5], T313 = 17 * T9, + T314 = 17 * T16, T315 = (T289 + T290 + T291 + T292 + T293) * D[5]; + T316 = 17 * T17, T317 = (T290 + T291 + T292 + T293) * D[4]; + T318 = 17 * T18, T319 = (T291 + T292 + T293) * D[3]; + T320 = 17 * T19, T321 = (T292 + T293) * D[2]; + T322 = 17 * T20, T323 = 17 * T21, T324 = (H * H * H * H * H * H * H * H * H); + T325 = 64 * T8, + T326 = (128 * D[6] + T40 + T41 + T42 + T43 + T44 + T45) * D[7]; + T327 = 64 * T9, T328 = (T40 + T41 + T42 + T43 + T44 + T45) * D[6]; + T329 = 64 * T16, T330 = 64 * T17, T331 = 64 * T18, T332 = 64 * T19, + T333 = 64 * T20, T334 = 64 * T21, T335 = 140 * T8, T336 = 280 * D[6], + T337 = 280 * D[5], T338 = 140 * T9, T339 = 140 * T16, T340 = 140 * T17, + T341 = 140 * T18, T342 = 140 * T19, T343 = 140 * T20, T344 = 140 * T21, + T345 = 196 * T8; + T346 = (392 * D[6] + T91 + T92 + T93 + T94 + T95 + T96) * D[7]; + T347 = 196 * T9; + T348 = (T91 + T92 + T93 + T94 + T95 + T96) * D[6]; + T349 = 196 * T16; + T350 = (T92 + T93 + T94 + T95 + T96) * D[5]; + T351 = 196 * T17; + T352 = (T93 + T94 + T95 + T96) * D[4]; + T353 = 196 * T18; + T354 = (T94 + T95 + T96) * D[3]; + T355 = 196 * T19; + T356 = (T95 + T96) * D[2]; + T357 = 196 * T20, T358 = 196 * T21, T359 = 182 * T8, T360 = 364 * D[6], + T361 = 364 * D[5], T362 = 182 * T9, T363 = 182 * T16, T364 = 182 * T17, + T365 = 182 * T18, T366 = 182 * T19, T367 = 182 * T20, T368 = 182 * T21, + T369 = 112 * T8; + T370 = (224 * D[6] + T177 + T41 + T42 + T43 + T44 + T45) * D[7]; + T371 = 112 * T9; + T372 = (T177 + T41 + T42 + T43 + T44 + T45) * D[6]; + T373 = 112 * T16, T374 = 112 * T17, T375 = 112 * T18, T376 = 112 * T19, + T377 = 112 * T20, T378 = 112 * T21, T379 = 44 * T8, T380 = 88 * D[6], + T381 = 88 * D[5], T382 = 44 * T9, T383 = 44 * T16, T384 = 44 * T17, + T385 = 44 * T18, T386 = 44 * T19, T387 = 44 * T20, T388 = 44 * T21, + T389 = 10 * T8, T390 = (20 * D[6] + T249 + T3 + T4 + T5 + T6 + T7) * D[7]; + T391 = 10 * T9, T392 = (T249 + T3 + T4 + T5 + T6 + T7) * D[6]; + T393 = 10 * T16, T394 = 10 * T17, T395 = 10 * T18, T396 = 10 * T19, + T397 = 10 * T20, T398 = 10 * T21, T399 = 2 * D[6], T400 = 2 * D[5], + T401 = 2 * D[5] * D[6]; + T402 = T309 * (L * L * L * L * L * L * L * L * L * L) + + (T255 * H - T310 + (-T311 + T22 + T23 + T24 + T25 + T26 + T27) * D[7] - + T313 + (T22 + T23 + T24 + T25 + T26 + T27) * D[6] - T314 + T47 - + T316 + T48 - T318 + T49 - T320 + T50 - T322 + T51 - T323) * + (L * L * L * L * L * L * L * L * L) + + (T214 * T58 + + (T256 + (T257 + T34 + T35 + T36 + T37 + T38 + T39) * D[7] + T258 + + (T34 + T35 + T36 + T37 + T38 + T39) * D[6] + T259 + + (T35 + T36 + T37 + T38 + T39) * D[5] + T260 + + (T36 + T37 + T38 + T39) * D[4] + T261 + (T37 + T38 + T39) * D[3] + + T262 + (T38 + T39) * D[2] + T263 + T264 + T265) * + H + + T325 + T326 + T327 + T328 + T329 + T101 + T330 + T103 + T331 + T105 + + T332 + T107 + T333 + T109 + T334) * + (L * L * L * L * L * L * L * L) + + (T178 * T77 + + (-T215 + (-T216 + T52 + T53 + T54 + T55 + T56 + T57) * D[7] - T223 + + (T52 + T53 + T54 + T55 + T56 + T57) * D[6] - T224 + + (T53 + T54 + T55 + T56 + T57) * D[5] - T225 + + (T54 + T55 + T56 + T57) * D[4] - T226 + (T55 + T56 + T57) * D[3] - + T227 + (T56 + T57) * D[2] - T228 - T229 - T230) * + T58 + + T267 * H - T335 + (-T336 + T65 + T66 + T67 + T68 + T69 + T70) * D[7] - + T338 + (T65 + T66 + T67 + T68 + T69 + T70) * D[6] - T339 + T119 - + T340 + T120 - T341 + T121 - T342 + T122 - T343 + T123 - T344) * + (L * L * L * L * L * L * L); + T403 = + T402 + + (T131 * T116 + + (T179 + (T180 + T181) * D[7] + T182 + T183 + T184 + T185 + T186 + T187 + + T188 + T189) * + T77 + + T232 * T58 + + (T268 + (T269 + T85 + T86 + T87 + T88 + T89 + T90) * D[7] + T270 + + (T85 + T86 + T87 + T88 + T89 + T90) * D[6] + T271 + + (T86 + T87 + T88 + T89 + T90) * D[5] + T272 + + (T87 + T88 + T89 + T90) * D[4] + T273 + (T88 + T89 + T90) * D[3] + + T274 + (T89 + T90) * D[2] + T275 + T276 + T277) * + H + + T345 + T346 + T347 + T348 + T349 + T350 + T351 + T352 + T353 + T354 + + T355 + T356 + T357 + T168 + T358) * + (L * L * L * L * L * L) + + ((-T97 + (-T98 - T71 + T41 + T42 + T43 + T44 + T45) * D[7] - T99 + + (-T71 + T41 + T42 + T43 + T44 + T45) * D[6] - T100 + T101 - T102 + + T103 - T104 + T105 - T106 + T107 - T108 + T109 - T110) * + T146 + + (-T132 + (-T133 + T111 + T78 + T79 + T80 + T81 + T82) * D[7] - T135 + + (T111 + T78 + T79 + T80 + T81 + T82) * D[6] - T136 + T112 - T138 + + T113 - T140 + T114 - T142 + T115 - T144 + T84 - T145) * + T116 + + T191 * T77 + + (-T159 + (-T160 + T118 + T66 + T67 + T68 + T69 + T70) * D[7] - T162 + + (T118 + T66 + T67 + T68 + T69 + T70) * D[6] - T163 + T119 - T164 + + T120 - T165 + T121 - T166 + T122 - T167 + T123 - T169) * + T58 + + T278 * H - T359 + (-T360 + T130 + T66 + T67 + T68 + T69 + T70) * D[7] - + T362 + (T130 + T66 + T67 + T68 + T69 + T70) * D[6] - T363 + T119 - T364 + + T120 - T365 + T121 - T366 + T122 - T367 + T123 - T368) * + (L * L * L * L * L); + T404 = + T403 + + (T131 * T190 + + (T132 + (T133 + T134 + T60 + T61 + T62 + T63 + T64) * D[7] + T135 + + (T134 + T60 + T61 + T62 + T63 + T64) * D[6] + T136 + T137 + T138 + + T139 + T140 + T141 + T142 + T143 + T144 - T84 + T145) * + T146 + + (1120 * T8 + + (2240 * D[6] + T147 + T148 + T149 + T150 + T151 + T152) * D[7] + + 1120 * T9 + (T147 + T148 + T149 + T150 + T151 + T152) * D[6] + + 1120 * T16 + T154 + 1120 * T17 + T155 + 1120 * T18 + T156 + 1120 * T19 + + T157 + 1120 * T20 + T158 + 1120 * T21) * + T116 + + (T192 + (T193 + T153 + T148 + T149 + T150 + T151 + T152) * D[7] + T199 + + (T153 + T148 + T149 + T150 + T151 + T152) * D[6] + T200 + T154 + T201 + + T155 + T202 + T156 + T203 + T157 + T204 + T158 + T206) * + T77 + + T237 * T58 + + (T279 + (T280 + T175 + T170 + T171 + T172 + T173 + T174) * D[7] + T281 + + (T175 + T170 + T171 + T172 + T173 + T174) * D[6] + T282 + T233 + T283 + + T234 + T284 + T235 + T285 + T236 + T286 + T176 + T287) * + H + + T369 + T370 + T371 + T372 + T373 + T101 + T374 + T103 + T375 + T105 + + T376 + T107 + T377 + T109 + T378) * + (L * L * L * L) + + (T178 * T231 + + (-T179 + (-T180 - T181) * D[7] - T182 - T183 - T184 - T185 - T186 - + T187 - T188 - T189) * + T190 + + T191 * T146 + + (-T192 + (-T193 - T153 + T194 + T195 + T196 + T197 + T198) * D[7] - + T199 + (-T153 + T194 + T195 + T196 + T197 + T198) * D[6] - T200 + T208 - + T201 + T209 - T202 + T210 - T203 + T211 - T204 + T205 - T206) * + T116 + + (-1400 * T8 + + (-2800 * D[6] + T207 + T194 + T195 + T196 + T197 + T198) * D[7] - + 1400 * T9 + (T207 + T194 + T195 + T196 + T197 + T198) * D[6] - + 1400 * T16 + T208 - 1400 * T17 + T209 - 1400 * T18 + T210 - 1400 * T19 + + T211 - 1400 * T20 + T205 - 1400 * T21) * + T77 + + (-T238 + (-T239 + T212 + T78 + T79 + T80 + T81 + T82) * D[7] - T241 + + (T212 + T78 + T79 + T80 + T81 + T82) * D[6] - T242 + T112 - T243 + + T113 - T244 + T114 - T245 + T115 - T246 + T84 - T247) * + T58 + + T288 * H - T379 + (-T380 + T213 + T23 + T24 + T25 + T26 + T27) * D[7] - + T382 + (T213 + T23 + T24 + T25 + T26 + T27) * D[6] - T383 + T47 - T384 + + T48 - T385 + T49 - T386 + T50 - T387 + T51 - T388) * + (L * L * L); + T405 = + T214 * T266 + + (T215 + (T216 + T217 + T218 + T219 + T220 + T221 + T222) * D[7] + T223 + + (T217 + T218 + T219 + T220 + T221 + T222) * D[6] + T224 + + (T218 + T219 + T220 + T221 + T222) * D[5] + T225 + + (T219 + T220 + T221 + T222) * D[4] + T226 + (T220 + T221 + T222) * D[3] + + T227 + (T221 + T222) * D[2] + T228 + T229 + T230) * + T231 + + T232 * T190 + + (T159 + (T160 + T161 + T170 + T171 + T172 + T173 + T174) * D[7] + T162 + + (T161 + T170 + T171 + T172 + T173 + T174) * D[6] + T163 + T233 + T164 + + T234 + T165 + T235 + T166 + T236 + T167 + T176 + T169) * + T146 + + T237 * T116 + + (T238 + (T239 + T240 + T60 + T61 + T62 + T63 + T64) * D[7] + T241 + + (T240 + T60 + T61 + T62 + T63 + T64) * D[6] + T242 + T137 + T243 + T139 + + T244 + T141 + T245 + T143 + T246 - T84 + T247) * + T77 + + (336 * T8 + (672 * D[6] + T248 + T66 + T67 + T68 + T69 + T70) * D[7] + + 336 * T9 + (T248 + T66 + T67 + T68 + T69 + T70) * D[6] + 336 * T16 + + T119 + 336 * T17 + T120 + 336 * T18 + T121 + 336 * T19 + T122 + + 336 * T20 - T176 + 336 * T21) * + T58 + + (T97 + (T98 + T71 + T23 + T24 + T25 + T26 + T27) * D[7] + T99 + + (T71 + T23 + T24 + T25 + T26 + T27) * D[6] + T100 + T47 + T102 + T48 + + T104 + T49 + T106 + T50 + T108 + T51 + T110) * + H + + T389 + T390 + T391; + T406 = T255 * T324 + + (-T256 + (-T257 - T34 - T35 - T36 - T37 - T38 - T39) * D[7] - T258 + + (-T34 - T35 - T36 - T37 - T38 - T39) * D[6] - T259 + + (-T35 - T36 - T37 - T38 - T39) * D[5] - T260 + + (-T36 - T37 - T38 - T39) * D[4] - T261 + (-T37 - T38 - T39) * D[3] - + T262 + (-T38 - T39) * D[2] - T263 - T264 - T265) * + T266 + + T267 * T231 + + (-T268 + (-T269 - T85 - T86 - T87 - T88 - T89 - T90) * D[7] - T270 + + (-T85 - T86 - T87 - T88 - T89 - T90) * D[6] - T271 + + (-T86 - T87 - T88 - T89 - T90) * D[5] - T272 + + (-T87 - T88 - T89 - T90) * D[4] - T273 + (-T88 - T89 - T90) * D[3] - + T274 + (-T89 - T90) * D[2] - T275 - T276 - T277) * + T190 + + T278 * T146 + + (-T279 + (-T280 - T175 + T66 + T67 + T68 + T69 + T70) * D[7] - T281 + + (-T175 + T66 + T67 + T68 + T69 + T70) * D[6] - T282 + T119 - T283 + + T120 - T284 + T121 - T285 + T122 - T286 - T176 - T287) * + T116 + + T288 * T77 + + (-T97 + (-T98 - T71 + T289 + T290 + T291 + T292 + T293) * D[7] - T99 + + (-T71 + T289 + T290 + T291 + T292 + T293) * D[6] - T100 + T315 - + T102 + T317 - T104 + T319 - T106 + T321 - T108 + T294 - T110) * + T58; + T407 = T404 + + (T405 + T392 + T393 + T250 + T394 + T251 + T395 + T252 + T396 + T253 + + T397 + T254 + T398) * + L * L + + (T406 + + (T295 + (T296 + T10 + T298 + T299 + T300 + T301 + T302) * D[7] + + T297 + (T10 + T298 + T299 + T300 + T301 + T302) * D[6] + T303 + + (T298 + T299 + T300 + T301 + T302) * D[5] + T304 + + (T299 + T300 + T301 + T302) * D[4] + T305 + + (T300 + T301 + T302) * D[3] + T306 + (T301 + T302) * D[2] + T307 + + 6 * D[0] * D[1] + T308) * + H - + T8 + (-T399 - T400) * D[7] - T9 - T401 - T16 - T17 - T18 - T19 - T20 - + T21) * + L + + T309 * (H * H * H * H * H * H * H * H * H * H) + + (T310 + (T311 + T312 + T289 + T290 + T291 + T292 + T293) * D[7] + + T313 + (T312 + T289 + T290 + T291 + T292 + T293) * D[6] + T314 + + T315 + T316 + T317 + T318 + T319 + T320 + T321 + T322 + T294 + T323) * + T324 + + (T325 + T326 + T327 + T328 + T329 + T101 + T330 + T103 + T331 + T105 + + T332 + T107 + T333 + T109 + T334) * + T266 + + (T335 + (T336 + T337 + T170 + T171 + T172 + T173 + T174) * D[7] + + T338 + (T337 + T170 + T171 + T172 + T173 + T174) * D[6] + T339 + + T233 + T340 + T234 + T341 + T235 + T342 + T236 + T343 + T176 + T344) * + T231 + + (T345 + T346 + T347 + T348 + T349 + T350 + T351 + T352 + T353 + T354 + + T355 + T356 + T357 + T168 + T358) * + T190; + return (T407 + + (T359 + (T360 + T361 + T170 + T171 + T172 + T173 + T174) * D[7] + + T362 + (T361 + T170 + T171 + T172 + T173 + T174) * D[6] + T363 + + T233 + T364 + T234 + T365 + T235 + T366 + T236 + T367 + T176 + + T368) * + T146 + + (T369 + T370 + T371 + T372 + T373 + T101 + T374 + T103 + T375 + T105 + + T376 + T107 + T377 + T109 + T378) * + T116 + + (T379 + (T380 + T381 + T289 + T290 + T291 + T292 + T293) * D[7] + + T382 + (T381 + T289 + T290 + T291 + T292 + T293) * D[6] + T383 + + T315 + T384 + T317 + T385 + T319 + T386 + T321 + T387 + T294 + + T388) * + T77 + + (T389 + T390 + T391 + T392 + T393 + T250 + T394 + T251 + T395 + T252 + + T396 + T253 + T397 + T254 + T398) * + T58 + + (T8 + (T399 + T400) * D[7] + T9 + T401 + T16 + T17 + T18 + T19 + T20 + + T21) * + H) / + 6; +} diff --git a/dsp/core/double2byte.c b/dsp/core/double2byte.c new file mode 100644 index 00000000..9e87c1d1 --- /dev/null +++ b/dsp/core/double2byte.c @@ -0,0 +1,35 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/mem/mem.h" + +void *double2byte(long n, const void *p, double weight, double bias) { + long i; + const double *src; + unsigned char *dst; + if ((dst = valloc(n * sizeof(unsigned char)))) { + for (src = p, i = 0; i < n; ++i) { + dst[i] = MIN(255, MAX(0, rint(src[i] * weight + bias))); + } + } + return dst; +} diff --git a/dsp/core/float2short.c b/dsp/core/float2short.c new file mode 100644 index 00000000..2094c2c3 --- /dev/null +++ b/dsp/core/float2short.c @@ -0,0 +1,41 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/limits.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/str/str.h" + +/** + * Converts floating point audio samples to pulse code modulation. + * + * @param rdi is number of sample chunks + * @param rsi points to aligned pcm [-32k,+32k] output memory + * @param rdx points to aligned float32 [-1,+1] input memory + */ +void float2short(size_t n, short pcm16[n][8], const float binary32[n][8]) { + size_t i, j; + float f[8], w[8]; + for (i = 0; i < n; ++i) { + for (j = 0; j < 8; ++j) { + pcm16[i][j] = + MIN(SHRT_MAX, MAX(SHRT_MIN, floorf(binary32[i][j] * (SHRT_MAX + 1)))); + } + } +} diff --git a/dsp/core/gamma.c b/dsp/core/gamma.c new file mode 100644 index 00000000..a220d931 --- /dev/null +++ b/dsp/core/gamma.c @@ -0,0 +1,40 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "dsp/core/gamma.h" +#include "libc/math.h" + +double rgb2stdpc(double x, double g) { + return COMPANDLUMA_SRGB(x, g); +} +double rgb2linpc(double x, double g) { + return UNCOMPANDLUMA_SRGB(x, g); +} + +double rgb2stdtv(double x) { + return COMPANDLUMA_BT1886(x); +} +double rgb2lintv(double x) { + return UNCOMPANDLUMA_BT1886(x); +} + +double tv2pcgamma(double x, double g) { + return rgb2stdpc(rgb2lintv(x), g); +} diff --git a/dsp/core/gamma.h b/dsp/core/gamma.h new file mode 100644 index 00000000..05f6202a --- /dev/null +++ b/dsp/core/gamma.h @@ -0,0 +1,23 @@ +#ifndef COSMOPOLITAN_DSP_CORE_GAMMA_H_ +#define COSMOPOLITAN_DSP_CORE_GAMMA_H_ +#include "libc/math.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +#define COMPANDLUMA(X, ...) COMPANDLUMA_(X, __VA_ARGS__) +#define COMPANDLUMA_(X, K1, K2, K3, K4) \ + ((X) > (K3) / (K4) ? (1 + (K2)) * pow((X), 1 / (K1)) - (K2) : (X) * (K4)) + +#define UNCOMPANDLUMA(X, ...) UNCOMPANDLUMA_(X, __VA_ARGS__) +#define UNCOMPANDLUMA_(X, K1, K2, K3, K4) \ + ((X) > (K3) ? pow(1 / (1 + (K2)) * ((X) + (K2)), K1) : (X) / (K4)) + +#define COMPANDLUMA_SRGB_MAGNUM .055, .04045, 12.92 +#define COMPANDLUMA_SRGB(X, G) COMPANDLUMA(X, G, COMPANDLUMA_SRGB_MAGNUM) +#define UNCOMPANDLUMA_SRGB(X, G) UNCOMPANDLUMA(X, G, COMPANDLUMA_SRGB_MAGNUM) + +#define COMPANDLUMA_BT1886_MAGNUM 1 / .45, .099, .081, 4.5 +#define COMPANDLUMA_BT1886(X) COMPANDLUMA(X, COMPANDLUMA_BT1886_MAGNUM) +#define UNCOMPANDLUMA_BT1886(X) UNCOMPANDLUMA(X, COMPANDLUMA_BT1886_MAGNUM) + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_GAMMA_H_ */ diff --git a/dsp/core/getintegercoefficients.c b/dsp/core/getintegercoefficients.c new file mode 100644 index 00000000..f52f4555 --- /dev/null +++ b/dsp/core/getintegercoefficients.c @@ -0,0 +1,113 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/q.h" +#include "libc/assert.h" +#include "libc/dce.h" +#include "libc/limits.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/str/str.h" + +/** + * Precomputes integers that can replace floating-point operands. + * + * “G-d made the integers, all else is the work of man. + * — Leopold Kronecker + * + * This function shifts the decimal point to the left: + * + * 𝑛ᵢ ← ROUND[𝑐ᵢ × 2ᵐ] + φᵢ + * + * With extra effort to compute φ which is normally all zeroes but gives + * us better rounding when it isn't. It's assumed optimized coefficients + * will be used like this: + * + * (Σᵢ𝑥ᵢ𝑛ᵢ + 2⁽ᵐ⁻¹⁾) / 2ᵐ where 𝑥∈[𝐿,𝐻] and 𝑖∈[0,6) + * + * Intended to compute this + * + * ROUND[Σᵢ𝑥ᵢ𝑐ᵢ] + * + * As accurately or approximately as you want it to be. Popular scaling + * factors are 7, 15, 16, 22, and 31. Building this code under MODE=tiny + * will DCE the math. + * + * @param N receives optimized integers + * @param C provides ideal coefficients + * @param M is log₂ scaling factor, e.g. 7 + * @param L is minimum input data size, e.g. 0 + * @param H is maximum input data size, e.g. 255 + * @return sum of errors for all inputs + * @see en.wikipedia.org/wiki/Binary_scaling + * @see o/tool/build/coefficients.com + * @cost ~300ns + */ +long GetIntegerCoefficients(long N[static 6], const double C[static 6], long M, + long L, long H) { + int i; + int j[6], J[6]; + int O[6] = {0}; + int S[3] = {0, -1, +1}; + double R[6], K[6], D[6], HM, HL, least, error; + least = 1; + HM = 1L << M; + HL = H - L + 1; + assert(H >= L); + assert(HL <= HM); + for (i = 0; i < 6; ++i) { + least *= HL; + if (fabs(C[i]) > DBL_MIN) { + J[i] = ARRAYLEN(S); + R[i] = C[i] * HM; + K[i] = rint(R[i]); + N[i] = K[i]; + } else { + J[i] = 1; + R[i] = 0; + K[i] = 0; + N[i] = 0; + } + } + if (!IsTiny() && least > 1) { + for (j[0] = 0; j[0] < J[0]; ++j[0]) { + for (j[1] = 0; j[1] < J[1]; ++j[1]) { + for (j[2] = 0; j[2] < J[2]; ++j[2]) { + for (j[3] = 0; j[3] < J[3]; ++j[3]) { + for (j[4] = 0; j[4] < J[4]; ++j[4]) { + for (j[5] = 0; j[5] < J[5]; ++j[5]) { + for (i = 0; i < ARRAYLEN(J); ++i) { + D[i] = S[j[i]] + K[i] - R[i]; + } + if ((error = DifferSumSq(D, L, H) / HM) < least) { + least = error; + memcpy(O, j, sizeof(j)); + } + } + } + } + } + } + } + for (i = 0; i < 6; ++i) { + N[i] += S[O[i]]; + } + } + return lround(least); +} diff --git a/dsp/core/getintegercoefficients8.c b/dsp/core/getintegercoefficients8.c new file mode 100644 index 00000000..1aa61a5b --- /dev/null +++ b/dsp/core/getintegercoefficients8.c @@ -0,0 +1,83 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "dsp/core/q.h" +#include "libc/dce.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/str/str.h" + +/** + * Same as GetIntegerCoefficients() but with eight terms. + * @cost ~3ms + */ +long GetIntegerCoefficients8(long N[static 8], const double C[static 8], long M, + long L, long H) { + int i; + int j[8], J[8]; + int O[8] = {0}; + int S[3] = {0, -1, +1}; + double R[8], K[8], D[8], Z, least, error; + least = 1; + Z = 1L << M; + for (i = 0; i < ARRAYLEN(J); ++i) { + least *= H - L; + if (fabs(C[i]) > DBL_MIN) { + J[i] = ARRAYLEN(S); + R[i] = C[i] * Z; + K[i] = rint(R[i]); + N[i] = K[i]; + } else { + J[i] = 1; + R[i] = 0; + K[i] = 0; + N[i] = 0; + } + } + if (least > 1) { + for (j[0] = 0; j[0] < J[0]; ++j[0]) { + for (j[1] = 0; j[1] < J[1]; ++j[1]) { + for (j[2] = 0; j[2] < J[2]; ++j[2]) { + for (j[3] = 0; j[3] < J[3]; ++j[3]) { + for (j[4] = 0; j[4] < J[4]; ++j[4]) { + for (j[5] = 0; j[5] < J[5]; ++j[5]) { + for (j[6] = 0; j[6] < J[6]; ++j[6]) { + for (j[7] = 0; j[7] < J[7]; ++j[7]) { + for (i = 0; i < ARRAYLEN(J); ++i) { + D[i] = S[j[i]] + K[i] - R[i]; + } + if ((error = DifferSumSq8(D, L, H) / Z) < least) { + least = error; + memcpy(O, j, sizeof(j)); + } + } + } + } + } + } + } + } + } + for (i = 0; i < 8; ++i) { + N[i] += S[O[i]]; + } + } + return lround(least); +} diff --git a/dsp/core/half.h b/dsp/core/half.h new file mode 100644 index 00000000..43d94749 --- /dev/null +++ b/dsp/core/half.h @@ -0,0 +1,12 @@ +#ifndef COSMOPOLITAN_DSP_CORE_HALF_H_ +#define COSMOPOLITAN_DSP_CORE_HALF_H_ +#include "libc/macros.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Divides integer in half w/ rounding. + */ +#define HALF(X) (((X) + 1) / (2 / TYPE_INTEGRAL(typeof(X)))) + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_HALF_H_ */ diff --git a/dsp/core/illumination.c b/dsp/core/illumination.c new file mode 100644 index 00000000..d9e5586b --- /dev/null +++ b/dsp/core/illumination.c @@ -0,0 +1,79 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "dsp/core/illumination.h" +#include "libc/str/str.h" + +const double kIlluminantA[3] = {1.0985, 1, 0.35585}; +const double kIlluminantAD10[3] = {1.11144, 1, 0.35200}; +const double kIlluminantC[3] = {0.98074, 1, 1.18232}; +const double kIlluminantCD10[3] = {0.97285, 1, 1.16145}; +const double kIlluminantD50[3] = {0.96422, 1, 0.82521}; +const double kIlluminantD50D10[3] = {0.9672, 1, 0.81427}; +const double kIlluminantD55[3] = {0.95682, 1, 0.92149}; +const double kIlluminantD55D10[3] = {0.95799, 1, 0.90926}; +const double kIlluminantD65[3] = {0.95047, 1, 1.08883}; +const double kIlluminantD65D10[3] = {0.94811, 1, 1.07304}; +const double kIlluminantD75[3] = {0.94972, 1, 1.22638}; +const double kIlluminantD75D10[3] = {0.94416, 1, 1.20641}; +const double kIlluminantF2[3] = {0.99187, 1, 0.67395}; +const double kIlluminantF2D10[3] = {1.0328, 1, 0.69026}; +const double kIlluminantF7[3] = {0.95044, 1, 1.08755}; +const double kIlluminantF7D10[3] = {0.95792, 1, 1.07687}; +const double kIlluminantF11[3] = {1.00966, 1, 0.6437}; +const double kIlluminantF11D10[3] = {1.03866, 1, 0.65627}; + +/** + * System of equations used for changing illumination. + * + * @see brucelindbloom.com/Eqn_ChromAdapt.html “The Bradford method is + * the newest of the three methods, and is considered by most + * experts to be the best of them. This is the method used in Adobe + * Photoshop. A related article comparing the chromatic adaptation + * algorithms may be found here.” ─Quoth Bruce Lindbloom + */ +const double kBradford[3][3] = { + {0.8951, 0.2664, -.1614}, + {-.7502, 1.7135, 0.0367}, + {0.0389, -.0685, 1.0296}, +}; + +/** + * Computes lightbulb changing coefficients. + * + * @param R will store result + * @param S has intended input illuminant primaries + * @param D has desired output illuminant primaries + * @return R + * @see brucelindbloom.com/Eqn_ChromAdapt.html + * @see fluxometer.com/rainbow/ + */ +void *GetChromaticAdaptationMatrix(double R[3][3], const double S[3], + const double D[3]) { + double M[3][3], T[3][3], U[3][3], V[3], W[3]; + matvmul3(V, kBradford, S); + matvmul3(W, kBradford, D); + memset(M, 0, sizeof(M)); + M[0][0] = W[0] / V[0]; + M[1][1] = W[1] / V[1]; + M[2][2] = W[2] / V[2]; + return matmul3(R, matmul3(T, kBradford, M), + inv3(U, kBradford, det3(kBradford))); +} diff --git a/dsp/core/illumination.h b/dsp/core/illumination.h new file mode 100644 index 00000000..a50c7794 --- /dev/null +++ b/dsp/core/illumination.h @@ -0,0 +1,31 @@ +#ifndef COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_ +#define COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +extern const double kBradford[3][3]; +extern const double kIlluminantA[3]; +extern const double kIlluminantAD10[3]; +extern const double kIlluminantC[3]; +extern const double kIlluminantCD10[3]; +extern const double kIlluminantD50[3]; +extern const double kIlluminantD50D10[3]; +extern const double kIlluminantD55[3]; +extern const double kIlluminantD55D10[3]; +extern const double kIlluminantD65[3]; +extern const double kIlluminantD65D10[3]; +extern const double kIlluminantD75[3]; +extern const double kIlluminantD75D10[3]; +extern const double kIlluminantF2[3]; +extern const double kIlluminantF2D10[3]; +extern const double kIlluminantF7[3]; +extern const double kIlluminantF7D10[3]; +extern const double kIlluminantF11[3]; +extern const double kIlluminantF11D10[3]; + +void *GetChromaticAdaptationMatrix(double[3][3], const double[3], + const double[3]); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_ILLUMINANT_H_ */ diff --git a/dsp/core/inv3.c b/dsp/core/inv3.c new file mode 100644 index 00000000..a13ba86f --- /dev/null +++ b/dsp/core/inv3.c @@ -0,0 +1,46 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "libc/math.h" +#include "libc/str/str.h" + +/** + * Computes 𝐀⁻¹ inverted 3×3 matrix, if it exists. + * + * @param 𝐁 is destination memory + * @param 𝐀 is input matrix, which can't overlap 𝐁 + * @param 𝑑 is |𝐀| the determinant scalar or 0 if degenerate + * @return 𝐀⁻¹ stored inside 𝐁 or NaNs if 𝑑=0 + * @define 𝐀⁻¹=𝐁 such that 𝐀×𝐁=𝐁×𝐀=𝐈ₙ + * @see det3() + */ +void *inv3(double B[restrict 3][3], const double A[restrict 3][3], double d) { + d = d ? 1 / d : NAN; + B[0][0] = (A[1][1] * A[2][2] - A[2][1] * A[1][2]) * d; + B[0][1] = (A[2][1] * A[0][2] - A[0][1] * A[2][2]) * d; + B[0][2] = (A[0][1] * A[1][2] - A[1][1] * A[0][2]) * d; + B[1][0] = (A[2][0] * A[1][2] - A[1][0] * A[2][2]) * d; + B[1][1] = (A[0][0] * A[2][2] - A[2][0] * A[0][2]) * d; + B[1][2] = (A[1][0] * A[0][2] - A[0][0] * A[1][2]) * d; + B[2][0] = (A[1][0] * A[2][1] - A[2][0] * A[1][1]) * d; + B[2][1] = (A[2][0] * A[0][1] - A[0][0] * A[2][1]) * d; + B[2][2] = (A[0][0] * A[1][1] - A[1][0] * A[0][1]) * d; + return B; +} diff --git a/dsp/core/ituround.h b/dsp/core/ituround.h new file mode 100644 index 00000000..79165794 --- /dev/null +++ b/dsp/core/ituround.h @@ -0,0 +1,23 @@ +#ifndef COSMOPOLITAN_DSP_CORE_ITUROUND_H_ +#define COSMOPOLITAN_DSP_CORE_ITUROUND_H_ +#include "libc/math.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * An ITU recommended rounding function. + * + * 1. Negative numbers round toward zero + * 2. Positive numbers round toward infinity + * + * @see round(), rint() + */ +static inline pureconst artificial long ituround(double x) { + return floor(x + .5); +} + +static inline pureconst artificial int ituroundf(float x) { + return floorf(x + .5f); +} + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_ITUROUND_H_ */ diff --git a/dsp/core/ks8.h b/dsp/core/ks8.h new file mode 100644 index 00000000..111480c3 --- /dev/null +++ b/dsp/core/ks8.h @@ -0,0 +1,47 @@ +#ifndef COSMOPOLITAN_DSP_CORE_KS8_H_ +#define COSMOPOLITAN_DSP_CORE_KS8_H_ +#include "libc/macros.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Performs 16-bit scaled rounded madd w/ eight coefficients or fewer. + * + * (Σᵢ₌₀₋₈𝑘ᵢ𝑥ᵢ + 2ᵐ⁻¹)/2ᵐ + * + * @note intent is avoiding type promotion + */ +#define KS8(M, K1, K2, K3, K4, K5, K6, K7, K8, X1, X2, X3, X4, X5, X6, X7, X8) \ + ({ \ + short x1, x2, x3, x4, x5, x6, x7, x8; \ + x1 = X1; \ + x2 = X2; \ + x3 = X3; \ + x4 = X4; \ + x5 = X5; \ + x6 = X6; \ + x7 = X7; \ + x8 = X8; \ + x1 *= K1; \ + x2 *= K2; \ + x3 *= K3; \ + x4 *= K4; \ + x5 *= K5; \ + x6 *= K6; \ + x7 *= K7; \ + x8 *= K8; \ + x1 += x2; \ + x3 += x4; \ + x5 += x6; \ + x7 += x8; \ + x1 += x3; \ + x5 += x7; \ + x1 += x5; \ + if (M) { \ + x1 += 1 << MAX(0, M - 1); \ + x1 >>= M; \ + } \ + x1; \ + }) + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_KS8_H_ */ diff --git a/dsp/core/kss8.h b/dsp/core/kss8.h new file mode 100644 index 00000000..60f86ff9 --- /dev/null +++ b/dsp/core/kss8.h @@ -0,0 +1,43 @@ +#ifndef COSMOPOLITAN_DSP_CORE_KSS8_H_ +#define COSMOPOLITAN_DSP_CORE_KSS8_H_ +#include "libc/limits.h" +#include "libc/macros.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * Performs 16-bit scaled rounded saturated madd w/ eight coefficients or fewer. + * + * (Σᵢ₌₀₋₈𝑘ᵢ𝑥ᵢ + 2ᵐ⁻¹)/2ᵐ + * + * @note compiler struggles with this + */ +#define KSS8(M, K1, K2, K3, K4, K5, K6, K7, K8, X1, X2, X3, X4, X5, X6, X7, \ + X8) \ + ({ \ + short x1, x2, x3, x4, x5, x6, x7, x8; \ + x1 = X1, x2 = X2, x3 = X3, x4 = X4; \ + x5 = X5, x6 = X6, x7 = X7, x8 = X8; \ + x1 = MIN(SHRT_MAX, MAX(SHRT_MIN, x1 * K1)); \ + x2 = MIN(SHRT_MAX, MAX(SHRT_MIN, x2 * K2)); \ + x3 = MIN(SHRT_MAX, MAX(SHRT_MIN, x3 * K3)); \ + x4 = MIN(SHRT_MAX, MAX(SHRT_MIN, x4 * K4)); \ + x5 = MIN(SHRT_MAX, MAX(SHRT_MIN, x5 * K5)); \ + x6 = MIN(SHRT_MAX, MAX(SHRT_MIN, x6 * K6)); \ + x7 = MIN(SHRT_MAX, MAX(SHRT_MIN, x7 * K7)); \ + x8 = MIN(SHRT_MAX, MAX(SHRT_MIN, x8 * K8)); \ + x1 = MIN(SHRT_MAX, MAX(SHRT_MIN, x1 + x2)); \ + x3 = MIN(SHRT_MAX, MAX(SHRT_MIN, x3 + x4)); \ + x5 = MIN(SHRT_MAX, MAX(SHRT_MIN, x5 + x6)); \ + x7 = MIN(SHRT_MAX, MAX(SHRT_MIN, x7 + x8)); \ + x1 = MIN(SHRT_MAX, MAX(SHRT_MIN, x1 + x3)); \ + x5 = MIN(SHRT_MAX, MAX(SHRT_MIN, x5 + x7)); \ + x1 = MIN(SHRT_MAX, MAX(SHRT_MIN, x1 + x5)); \ + if (M) { \ + x1 += 1 << MAX(0, M - 1); \ + x1 >>= M; \ + } \ + x1; \ + }) + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_KSS8_H_ */ diff --git a/dsp/core/matmul3.c b/dsp/core/matmul3.c new file mode 100644 index 00000000..691251fa --- /dev/null +++ b/dsp/core/matmul3.c @@ -0,0 +1,38 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "libc/str/str.h" + +/** + * Multiplies 3×3 matrices. + */ +void *matmul3(double R[restrict 3][3], const double A[3][3], + const double B[3][3]) { + int i, j, k; + memset(R, 0, sizeof(double) * 3 * 3); + for (i = 0; i < 3; ++i) { + for (j = 0; j < 3; ++j) { + for (k = 0; k < 3; ++k) { + R[i][j] += A[k][j] * B[i][k]; + } + } + } + return R; +} diff --git a/dsp/core/matvmul3.c b/dsp/core/matvmul3.c new file mode 100644 index 00000000..60e8b637 --- /dev/null +++ b/dsp/core/matvmul3.c @@ -0,0 +1,32 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" + +/** + * Computes M×V. + * + * @see vmatmul3() for noncommutative corollary + */ +void *matvmul3(double R[restrict 3], const double M[3][3], const double V[3]) { + R[0] = V[0] * M[0][0] + V[1] * M[0][1] + V[2] * M[0][2]; + R[1] = V[0] * M[1][0] + V[1] * M[1][1] + V[2] * M[1][2]; + R[2] = V[0] * M[2][0] + V[1] * M[2][1] + V[2] * M[2][2]; + return R; +} diff --git a/dsp/core/mulaw.S b/dsp/core/mulaw.S new file mode 100644 index 00000000..f82d33a4 --- /dev/null +++ b/dsp/core/mulaw.S @@ -0,0 +1,64 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" + +#define BIAS 0x84 + +/ Encodes audio sample with µ-Law. +/ +/ This is both the highest quality and most widely supported +/ telephony codec, whose use was phased out in the 2000's in +/ favor of cost-saving GSM audio compression that was so bad +/ consumers were willing to pay more cash, for the privilege +/ of saving telcos even more money w/ text messaging. Mu Law +/ reduces PCM data to half its original size, by diminishing +/ audio bands not vocalized by human voice. +/ +/ @param %edi is pcm sample +/ @return %eax is uint8_t encoded sample +mulaw: .leafprologue + .profilable + mov $BIAS,%eax + xor %edx,%edx + test %edi,%edi + js 1f + lea (%edi,%eax),%eax + mov $0xFF,%dl + jmp 2f +1: sub %edi,%eax + mov $0x7F,%dl +2: mov %eax,%esi + or $0xFF,%sil + bsr %esi,%esi + sub $7,%esi + cmp $8,%esi + jge 4f + lea 3(%rdx),%ecx + sar %cl,%eax + and $0xF,%eax + shl $4,%esi + or %esi,%eax + xor %edx,%eax +3: .leafepilogue +4: xor $0x7F,%dl + mov %edx,%eax + jmp 3b + .endfn mulaw,globl + .yoink __FILE__ diff --git a/dsp/core/q.h b/dsp/core/q.h new file mode 100644 index 00000000..5d40c64c --- /dev/null +++ b/dsp/core/q.h @@ -0,0 +1,27 @@ +#ifndef COSMOPOLITAN_DSP_CORE_Q_H_ +#define COSMOPOLITAN_DSP_CORE_Q_H_ +#include "libc/limits.h" +#include "libc/macros.h" +#include "libc/math.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +/** + * @fileoverview Fixed point arithmetic macros. + * @see en.wikipedia.org/wiki/Q_(number_format) + */ + +#define F2Q(Q, I) MIN((1 << Q) - 1, roundf((I) * (1.f * ((1 << Q) - 1)))) +#define Q2F(Q, I) ((I) * (1.f / ((1 << Q) - 1))) +#define QRS(Q, X) (((X) + (1 << (Q - 1))) >> Q) +#define LQRS(Q, X) (((X) + (1L << (Q - 1))) >> Q) + +double DifferSumSq(const double[static 6], double, double); +double DifferSumSq8(const double[static 8], double, double); + +long GetIntegerCoefficients(long[static 6], const double[static 6], long, long, + long); +long GetIntegerCoefficients8(long[static 8], const double[static 8], long, long, + long); + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_Q_H_ */ diff --git a/dsp/core/sad16x8n.S b/dsp/core/sad16x8n.S new file mode 100644 index 00000000..d36a0b0e --- /dev/null +++ b/dsp/core/sad16x8n.S @@ -0,0 +1,41 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" +.align 16 + +/ Mixes audio. +/ +/ @param rdi is # aligned int16[16] sample chunks to process +/ @param rsi points to aligned pcm s16le input/output memory +/ @param rdx points to aligned pcm s16le [0..1] input memory +sad16x8n: + .leafprologue + .profilable + test %rdi,%rdi + jz 1f + shl $3,%rdi +0: sub $8,%rdi + movdqa (%rsi,%rdi,2),%xmm0 + paddsw (%rdx,%rdi,2),%xmm0 + movdqa %xmm0,(%rsi,%rdi,2) + jnz 0b +1: .leafepilogue + .endfn sad16x8n,globl,hidden + .yoink __FILE__ diff --git a/dsp/core/scalevolume.c b/dsp/core/scalevolume.c new file mode 100644 index 00000000..8dceb97c --- /dev/null +++ b/dsp/core/scalevolume.c @@ -0,0 +1,50 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "libc/bits/bits.h" +#include "libc/bits/safemacros.h" +#include "libc/limits.h" + +/** + * Increases or decreases audio volume. + * + * @param 𝑝 is two-power w/ effective range [-15,15] + */ +void scalevolume(size_t n, int16_t pcm[n][8], int p) { + /* TODO(jart): This isn't acceptable. */ + size_t i, j; + if (p > 0) { + if (p > 15) p = 15; + for (i = 0; i < n; ++i) { + for (j = 0; j < 8; ++j) { + pcm[i][j] = + MIN(SHRT_MAX, MAX(SHRT_MIN, (int)((unsigned)pcm[i][j] << p))); + } + } + } else if (p < 0) { + p = -p; + if (p > 15) p = 15; + for (i = 0; i < n; ++i) { + for (j = 0; j < 8; ++j) { + pcm[i][j] = SAR(pcm[i][j], p); + } + } + } +} diff --git a/dsp/core/twixt8.h b/dsp/core/twixt8.h new file mode 100644 index 00000000..2f015635 --- /dev/null +++ b/dsp/core/twixt8.h @@ -0,0 +1,24 @@ +#ifndef COSMOPOLITAN_DSP_CORE_TWIXT8_H_ +#define COSMOPOLITAN_DSP_CORE_TWIXT8_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +/** + * 8-bit linear interpolation kernel. + */ +static inline pureconst artificial unsigned char twixt8(unsigned char al, + unsigned char bl, + unsigned char p) { + short bx; + bx = bl; + bx -= al; + bx *= p; + bx >>= 8; + bx += al; + al = bx; + return al; +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_CORE_TWIXT8_H_ */ diff --git a/dsp/core/vmatmul3.c b/dsp/core/vmatmul3.c new file mode 100644 index 00000000..afc32257 --- /dev/null +++ b/dsp/core/vmatmul3.c @@ -0,0 +1,32 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" + +/** + * Computes V×M. + * + * @see matvmul3() for noncommutative corollary + */ +void *vmatmul3(double R[restrict 3], const double V[3], const double M[3][3]) { + R[0] = V[0] * M[0][0] + V[1] * M[1][0] + V[2] * M[2][0]; + R[1] = V[0] * M[0][1] + V[1] * M[1][1] + V[2] * M[2][1]; + R[2] = V[0] * M[0][2] + V[1] * M[1][2] + V[2] * M[2][2]; + return R; +} diff --git a/dsp/dsp.mk b/dsp/dsp.mk new file mode 100644 index 00000000..a5976588 --- /dev/null +++ b/dsp/dsp.mk @@ -0,0 +1,8 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +.PHONY: o/$(MODE)/dsp +o/$(MODE)/dsp: o/$(MODE)/dsp/core \ + o/$(MODE)/dsp/mpeg \ + o/$(MODE)/dsp/scale \ + o/$(MODE)/dsp/tty diff --git a/dsp/mpeg/README.txt b/dsp/mpeg/README.txt new file mode 100644 index 00000000..53703b7f --- /dev/null +++ b/dsp/mpeg/README.txt @@ -0,0 +1,92 @@ +PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer +Dominic Szablewski - https://phoboslab.org + +-- Synopsis + +// This function gets called for each decoded video frame +void my_video_callback(plm_t *plm, plm_frame_t *frame, void *user) { + // Do something with frame->y.data, frame->cr.data, frame->cb.data +} + +// This function gets called for each decoded audio frame +void my_audio_callback(plm_t *plm, plm_samples_t *frame, void *user) { + // Do something with samples->interleaved +} + +// Load a .mpg (MPEG Program Stream) file +plm_t *plm = plm_create_with_filename("some-file.mpg"); + +// Install the video & audio decode callbacks +plm_set_video_decode_callback(plm, my_video_callback, my_data); +plm_set_audio_decode_callback(plm, my_audio_callback, my_data); + + +// Decode +do { + plm_decode(plm, time_since_last_call); +} while (!plm_has_ended(plm)); + +// All done +plm_destroy(plm); + + + +-- Documentation + +This library provides several interfaces to load, demux and decode MPEG video +and audio data. A high-level API combines the demuxer, video & audio decoders +in an easy to use wrapper. + +Lower-level APIs for accessing the demuxer, video decoder and audio decoder, +as well as providing different data sources are also available. + +Interfaces are written in an object orientet style, meaning you create object +instances via various different constructor functions (plm_*create()), +do some work on them and later dispose them via plm_*destroy(). + +plm_* -- the high-level interface, combining demuxer and decoders +plm_buffer_* -- the data source used by all interfaces +plm_demux_* -- the MPEG-PS demuxer +plm_video_* -- the MPEG1 Video ("mpeg1") decoder +plm_audio_* -- the MPEG1 Audio Layer II ("mp2") decoder + + +This library uses malloc(), realloc() and free() to manage memory. Typically +all allocation happens up-front when creating the interface. However, the +default buffer size may be too small for certain inputs. In these cases plmpeg +will realloc() the buffer with a larger size whenever needed. You can configure +the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before* +including this library. + +With the high-level interface you have two options to decode video & audio: + +1) Use plm_decode() and just hand over the delta time since the last call. +It will decode everything needed and call your callbacks (specified through +plm_set_{video|audio}_decode_callback()) any number of times. + +2) Use plm_decode_video() and plm_decode_audio() to decode exactly one +frame of video or audio data at a time. How you handle the synchronization of +both streams is up to you. + +If you only want to decode video *or* audio through these functions, you should +disable the other stream (plm_set_{video|audio}_enabled(false)) + + +Video data is decoded into a struct with all 3 planes (Y, Cr, Cb) stored in +separate buffers. You can either convert this to RGB on the CPU (slow) via the +plm_frame_to_rgb() function or do it on the GPU with the following matrix: + +mat4 rec601 = mat4( + 1.16438, 0.00000, 1.59603, -0.87079, + 1.16438, -0.39176, -0.81297, 0.52959, + 1.16438, 2.01723, 0.00000, -1.08139, + 0, 0, 0, 1 +); +gl_FragColor = vec4(y, cb, cr, 1.0) * rec601; + +Audio data is decoded into a struct with either one single float array with the +samples for the left and right channel interleaved, or if the +PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into +two separate float arrays - one for each channel. + +See below for detailed the API documentation. diff --git a/dsp/mpeg/blockset.h b/dsp/mpeg/blockset.h new file mode 100644 index 00000000..cb33de55 --- /dev/null +++ b/dsp/mpeg/blockset.h @@ -0,0 +1,22 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ +#define COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) + +#define PLM_BLOCK_SET(DEST, DEST_INDEX, DEST_WIDTH, SOURCE_INDEX, \ + SOURCE_WIDTH, BLOCK_SIZE, OP) \ + do { \ + int dest_scan = DEST_WIDTH - BLOCK_SIZE; \ + int source_scan = SOURCE_WIDTH - BLOCK_SIZE; \ + for (int y = 0; y < BLOCK_SIZE; y++) { \ + for (int x = 0; x < BLOCK_SIZE; x++) { \ + DEST[DEST_INDEX] = OP; \ + SOURCE_INDEX++; \ + DEST_INDEX++; \ + } \ + SOURCE_INDEX += source_scan; \ + DEST_INDEX += dest_scan; \ + } \ + } while (false) + +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ */ diff --git a/dsp/mpeg/buffer.c b/dsp/mpeg/buffer.c new file mode 100644 index 00000000..d383de75 --- /dev/null +++ b/dsp/mpeg/buffer.c @@ -0,0 +1,158 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/buffer.h" +#include "dsp/mpeg/mpeg.h" +#include "libc/calls/calls.h" +#include "libc/log/check.h" +#include "libc/mem/mem.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/madv.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/* clang-format off */ +// ----------------------------------------------------------------------------- +// plm_buffer implementation + +plm_buffer_t *plm_buffer_create_with_filename(const char *filename) { + FILE *fh = fopen(filename, "rb"); + if (!fh) { + return NULL; + } + fadvise(fileno(fh), 0, 0, MADV_SEQUENTIAL); + return plm_buffer_create_with_file(fh, true); +} + +plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) { + plm_buffer_t *b; + b = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE); + b->fh = fh; + b->close_when_done = close_when_done; + b->mode = PLM_BUFFER_MODE_FILE; + plm_buffer_set_load_callback(b, plm_buffer_load_file_callback, NULL); + return b; +} + +plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length, int free_when_done) { + plm_buffer_t *b; + b = memalign(alignof(plm_buffer_t), sizeof(plm_buffer_t)); + memset(b, 0, sizeof(plm_buffer_t)); + b->capacity = length; + b->length = length; + b->free_when_done = free_when_done; + b->bytes = bytes; + b->mode = PLM_BUFFER_MODE_FIXED_MEM; + return b; +} + +plm_buffer_t * plm_buffer_create_with_capacity(size_t capacity) { + plm_buffer_t *b; + b = memalign(alignof(plm_buffer_t), sizeof(plm_buffer_t)); + memset(b, 0, sizeof(plm_buffer_t)); + b->capacity = capacity; + b->free_when_done = true; + b->bytes = (unsigned char *)malloc(capacity); + b->mode = PLM_BUFFER_MODE_DYNAMIC_MEM; + return b; +} + +void plm_buffer_destroy(plm_buffer_t *self) { + if (self->fh && self->close_when_done) { + fclose(self->fh); + } + if (self->free_when_done) { + free(self->bytes); + } + free(self); +} + +size_t plm_buffer_write(plm_buffer_t *self, unsigned char *bytes, size_t length) { + if (self->mode == PLM_BUFFER_MODE_FIXED_MEM) { + return 0; + } + // This should be a ring buffer, but instead it just shifts all unread data + // to the beginning of the buffer and appends new data at the end. Seems + // to be good enough. + plm_buffer_discard_read_bytes(self); + // Do we have to resize to fit the new data? + size_t bytes_available = self->capacity - self->length; + if (bytes_available < length) { + size_t new_size = self->capacity; + do { + new_size *= 2; + } while (new_size - self->length < length); + self->bytes = (unsigned char *)realloc(self->bytes, new_size); + self->capacity = new_size; + } + memcpy(self->bytes + self->length, bytes, length); + self->length += length; + return length; +} + +void plm_buffer_set_load_callback(plm_buffer_t *self, plm_buffer_load_callback fp, void *user) { + self->load_callback = fp; + self->load_callback_user_data = user; +} + +void plm_buffer_rewind(plm_buffer_t *self) { + if (self->fh) { + fseek(self->fh, 0, SEEK_SET); + self->length = 0; + } + if (self->mode != PLM_BUFFER_MODE_FIXED_MEM) { + self->length = 0; + } + self->bit_index = 0; +} + +void plm_buffer_discard_read_bytes(plm_buffer_t *self) { + size_t byte_pos = self->bit_index >> 3; + if (byte_pos == self->length) { + self->bit_index = 0; + self->length = 0; + } + else if (byte_pos > 0) { + memmove(self->bytes, self->bytes + byte_pos, self->length - byte_pos); + self->bit_index -= byte_pos << 3; + self->length -= byte_pos; + } +} + +void plm_buffer_load_file_callback(plm_buffer_t *self, void *user) { + plm_buffer_discard_read_bytes(self); + unsigned bytes_available = self->capacity - self->length; + unsigned bytes_read = fread(self->bytes + self->length, 1, bytes_available, self->fh); + self->length += bytes_read; +} diff --git a/dsp/mpeg/buffer.h b/dsp/mpeg/buffer.h new file mode 100644 index 00000000..93838c6c --- /dev/null +++ b/dsp/mpeg/buffer.h @@ -0,0 +1,163 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_BUFFER_H_ +#define COSMOPOLITAN_DSP_MPEG_BUFFER_H_ +#include "dsp/mpeg/mpeg.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct FILE; + +enum plm_buffer_mode { + PLM_BUFFER_MODE_FILE, + PLM_BUFFER_MODE_FIXED_MEM, + PLM_BUFFER_MODE_DYNAMIC_MEM +}; + +typedef struct plm_buffer_t { + unsigned bit_index; + unsigned capacity; + unsigned length; + int free_when_done; + int close_when_done; + struct FILE *fh; + plm_buffer_load_callback load_callback; + void *load_callback_user_data; + unsigned char *bytes; + enum plm_buffer_mode mode; +} plm_buffer_t; + +typedef struct { + int16_t index; + int16_t value; +} plm_vlc_t; + +typedef struct { + int16_t index; + uint16_t value; +} plm_vlc_uint_t; + +/* bool plm_buffer_has(plm_buffer_t *, size_t); */ +/* int plm_buffer_read(plm_buffer_t *, int); */ +/* void plm_buffer_align(plm_buffer_t *); */ +/* void plm_buffer_skip(plm_buffer_t *, size_t); */ +/* int plm_buffer_skip_bytes(plm_buffer_t *, unsigned char); */ +/* int plm_buffer_next_start_code(plm_buffer_t *); */ +/* int plm_buffer_find_start_code(plm_buffer_t *, int); */ +/* int plm_buffer_no_start_code(plm_buffer_t *); */ +/* int16_t plm_buffer_read_vlc(plm_buffer_t *, const plm_vlc_t *); */ +/* uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *, const plm_vlc_uint_t *); */ + +void plm_buffer_discard_read_bytes(plm_buffer_t *); +relegated void plm_buffer_load_file_callback(plm_buffer_t *, void *); + +forceinline bool plm_buffer_has(plm_buffer_t *b, size_t bits) { + unsigned have; + have = b->length; + have <<= 3; + have -= b->bit_index; + if (bits <= have) { + return true; + } else { + if (b->load_callback) { + b->load_callback(b, b->load_callback_user_data); + return ((b->length << 3) - b->bit_index) >= bits; + } else { + return false; + } + } +} + +forceinline int plm_buffer_read(plm_buffer_t *self, int count) { + if (!plm_buffer_has(self, count)) return 0; + int value = 0; + while (count) { + int current_byte = self->bytes[self->bit_index >> 3]; + int remaining = 8 - (self->bit_index & 7); // Remaining bits in byte + int read = remaining < count ? remaining : count; // Bits in self run + int shift = remaining - read; + int mask = (0xff >> (8 - read)); + value = (value << read) | ((current_byte & (mask << shift)) >> shift); + self->bit_index += read; + count -= read; + } + return value; +} + +forceinline void plm_buffer_align(plm_buffer_t *self) { + self->bit_index = ((self->bit_index + 7) >> 3) << 3; +} + +forceinline void plm_buffer_skip(plm_buffer_t *self, size_t count) { + if (plm_buffer_has(self, count)) { + self->bit_index += count; + } +} + +forceinline int plm_buffer_skip_bytes(plm_buffer_t *self, unsigned char v) { + unsigned skipped; + plm_buffer_align(self); + skipped = 0; + while (plm_buffer_has(self, 8)) { + if (v == self->bytes[self->bit_index >> 3]) { + self->bit_index += 8; + ++skipped; + } else { + break; + } + } + return skipped; +} + +forceinline int plm_buffer_next_start_code(plm_buffer_t *self) { + plm_buffer_align(self); + while (plm_buffer_has(self, (5 << 3))) { + size_t byte_index = (self->bit_index) >> 3; + if (self->bytes[byte_index] == 0x00 && + self->bytes[byte_index + 1] == 0x00 && + self->bytes[byte_index + 2] == 0x01) { + self->bit_index = (byte_index + 4) << 3; + return self->bytes[byte_index + 3]; + } + self->bit_index += 8; + } + self->bit_index = (self->length << 3); + return -1; +} + +forceinline int plm_buffer_find_start_code(plm_buffer_t *self, int code) { + int current = 0; + while (true) { + current = plm_buffer_next_start_code(self); + if (current == code || current == -1) { + return current; + } + } + return -1; +} + +forceinline int plm_buffer_no_start_code(plm_buffer_t *self) { + if (!plm_buffer_has(self, (5 << 3))) { + return false; + } + size_t byte_index = ((self->bit_index + 7) >> 3); + return !(self->bytes[byte_index] == 0x00 && + self->bytes[byte_index + 1] == 0x00 && + self->bytes[byte_index + 2] == 0x01); +} + +forceinline int16_t plm_buffer_read_vlc(plm_buffer_t *self, + const plm_vlc_t *table) { + plm_vlc_t state = {0, 0}; + do { + state = table[state.index + plm_buffer_read(self, 1)]; + } while (state.index > 0); + return state.value; +} + +forceinline uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self, + const plm_vlc_uint_t *table) { + return (uint16_t)plm_buffer_read_vlc(self, (plm_vlc_t *)table); +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_BUFFER_H_ */ diff --git a/dsp/mpeg/clamp4int256-core.S b/dsp/mpeg/clamp4int256-core.S new file mode 100644 index 00000000..a4a8753d --- /dev/null +++ b/dsp/mpeg/clamp4int256-core.S @@ -0,0 +1,32 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" +.yoink __FILE__ + +clamp4int256$core: + .leafprologue + pxor %xmm1,%xmm1 + pmaxsd %xmm1,%xmm0 + pminsd 0f(%rip),%xmm0 + .leafepilogue + .endfn clamp4int256$core,globl + + .rodata.cst16 +0: .long 255,255,255,255 diff --git a/dsp/mpeg/demux.c b/dsp/mpeg/demux.c new file mode 100644 index 00000000..d4055118 --- /dev/null +++ b/dsp/mpeg/demux.c @@ -0,0 +1,208 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/buffer.h" +#include "dsp/mpeg/demux.h" +#include "dsp/mpeg/mpeg.h" +#include "libc/mem/mem.h" +#include "libc/str/str.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/* clang-format off */ +// ---------------------------------------------------------------------------- +// plm_demux implementation + +plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done) { + plm_demux_t *self = (plm_demux_t *)malloc(sizeof(plm_demux_t)); + memset(self, 0, sizeof(plm_demux_t)); + + self->buffer = buffer; + self->destroy_buffer_when_done = destroy_when_done; + + if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) { + plm_demux_decode_pack_header(self); + } + if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) { + plm_demux_decode_system_header(self); + } + return self; +} + +void plm_demux_destroy(plm_demux_t *self) { + if (self->destroy_buffer_when_done) { + plm_buffer_destroy(self->buffer); + } + free(self); +} + +int plm_demux_get_num_video_streams(plm_demux_t *self) { + return self->num_video_streams; +} + +int plm_demux_get_num_audio_streams(plm_demux_t *self) { + return self->num_audio_streams; +} + +void plm_demux_rewind(plm_demux_t *self) { + plm_buffer_rewind(self->buffer); +} + +plm_packet_t *plm_demux_decode(plm_demux_t *self) { + if (self->current_packet.length) { + size_t bits_till_next_packet = self->current_packet.length << 3; + if (!plm_buffer_has(self->buffer, bits_till_next_packet)) { + return NULL; + } + plm_buffer_skip(self->buffer, bits_till_next_packet); + self->current_packet.length = 0; + } + + if (!self->has_pack_header) { + if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) { + plm_demux_decode_pack_header(self); + } + else { + return NULL; + } + } + + if (!self->has_system_header) { + if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) { + plm_demux_decode_system_header(self); + } + else { + return NULL; + } + } + + // pending packet just waiting for data? + if (self->next_packet.length) { + return plm_demux_get_packet(self); + } + + int code; + do { + code = plm_buffer_next_start_code(self->buffer); + if ( + code == PLM_DEMUX_PACKET_VIDEO_1 || + code == PLM_DEMUX_PACKET_PRIVATE || + (code >= PLM_DEMUX_PACKET_AUDIO_1 && code <= PLM_DEMUX_PACKET_AUDIO_4) + ) { + return plm_demux_decode_packet(self, code); + } + } while (code != -1); + + return NULL; +} + +double plm_demux_read_time(plm_demux_t *self) { + int64_t clock = plm_buffer_read(self->buffer, 3) << 30; + plm_buffer_skip(self->buffer, 1); + clock |= plm_buffer_read(self->buffer, 15) << 15; + plm_buffer_skip(self->buffer, 1); + clock |= plm_buffer_read(self->buffer, 15); + plm_buffer_skip(self->buffer, 1); + return (double)clock / 90000.0; +} + +void plm_demux_decode_pack_header(plm_demux_t *self) { + if (plm_buffer_read(self->buffer, 4) != 0x02) { + return; // invalid + } + self->system_clock_ref = plm_demux_read_time(self); + plm_buffer_skip(self->buffer, 1); + plm_buffer_skip(self->buffer, 22); // mux_rate * 50 + plm_buffer_skip(self->buffer, 1); + + self->has_pack_header = true; +} + +void plm_demux_decode_system_header(plm_demux_t *self) { + plm_buffer_skip(self->buffer, 16); // header_length + plm_buffer_skip(self->buffer, 24); // rate bound + self->num_audio_streams = plm_buffer_read(self->buffer, 6); + plm_buffer_skip(self->buffer, 5); // misc flags + self->num_video_streams = plm_buffer_read(self->buffer, 5); + + self->has_system_header = true; +} + +plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code) { + if (!plm_buffer_has(self->buffer, 8 << 3)) { + return NULL; + } + + self->next_packet.type = start_code; + self->next_packet.length = plm_buffer_read(self->buffer, 16); + self->next_packet.length -= plm_buffer_skip_bytes(self->buffer, 0xff); // stuffing + + // skip P-STD + if (plm_buffer_read(self->buffer, 2) == 0x01) { + plm_buffer_skip(self->buffer, 16); + self->next_packet.length -= 2; + } + + int pts_dts_marker = plm_buffer_read(self->buffer, 2); + if (pts_dts_marker == 0x03) { + self->next_packet.pts = plm_demux_read_time(self); + plm_buffer_skip(self->buffer, 40); // skip dts + self->next_packet.length -= 10; + } + else if (pts_dts_marker == 0x02) { + self->next_packet.pts = plm_demux_read_time(self); + self->next_packet.length -= 5; + } + else if (pts_dts_marker == 0x00) { + self->next_packet.pts = 0; + plm_buffer_skip(self->buffer, 4); + self->next_packet.length -= 1; + } + else { + return NULL; // invalid + } + + return plm_demux_get_packet(self); +} + +plm_packet_t *plm_demux_get_packet(plm_demux_t *self) { + if (!plm_buffer_has(self->buffer, self->next_packet.length << 3)) { + return NULL; + } + self->current_packet.data = self->buffer->bytes + (self->buffer->bit_index >> 3); + self->current_packet.length = self->next_packet.length; + self->current_packet.type = self->next_packet.type; + self->current_packet.pts = self->next_packet.pts; + self->next_packet.length = 0; + return &self->current_packet; +} diff --git a/dsp/mpeg/demux.h b/dsp/mpeg/demux.h new file mode 100644 index 00000000..892c5222 --- /dev/null +++ b/dsp/mpeg/demux.h @@ -0,0 +1,31 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_DEMUX_H_ +#define COSMOPOLITAN_DSP_MPEG_DEMUX_H_ +#include "dsp/mpeg/mpeg.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +#define START_PACK 0xBA +#define START_END 0xB9 +#define START_SYSTEM 0xBB + +typedef struct plm_demux_t { + plm_buffer_t *buffer; + int destroy_buffer_when_done; + double system_clock_ref; + int has_pack_header; + int has_system_header; + int num_audio_streams; + int num_video_streams; + plm_packet_t current_packet; + plm_packet_t next_packet; +} plm_demux_t; + +double plm_demux_read_time(plm_demux_t *self); +void plm_demux_decode_pack_header(plm_demux_t *self); +void plm_demux_decode_system_header(plm_demux_t *self); +plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code); +plm_packet_t *plm_demux_get_packet(plm_demux_t *self); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_DEMUX_H_ */ diff --git a/dsp/mpeg/idct.c b/dsp/mpeg/idct.c new file mode 100644 index 00000000..f8c3858d --- /dev/null +++ b/dsp/mpeg/idct.c @@ -0,0 +1,106 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/half.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/** + * Computes Fixed-Point 8x8 Inverse Discrete Cosine Transform. + * + * @note discovered by Nasir Ahmed + */ +void plm_video_idct(int block[8][8]) { + int i, j, t1, t2, m0; + int b1, b3, b4, b6, b7; + int y3, y4, y5, y6, y7; + int x0, x1, x2, x3, x4; + + for (i = 0; i < 8; ++i) { + b1 = block[4][i]; + b3 = block[2][i] + block[6][i]; + b4 = block[5][i] - block[3][i]; + t1 = block[1][i] + block[7][i]; + t2 = block[3][i] + block[5][i]; + b6 = block[1][i] - block[7][i]; + b7 = t1 + t2; + m0 = block[0][i]; + x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7; + x0 = x4 - (((t1 - t2) * 362 + 128) >> 8); + x1 = m0 - b1; + x2 = (((block[2][i] - block[6][i]) * 362 + 128) >> 8) - b3; + x3 = m0 + b1; + y3 = x1 + x2; + y4 = x3 + b3; + y5 = x1 - x2; + y6 = x3 - b3; + y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8); + block[0][i] = b7 + y4; + block[1][i] = x4 + y3; + block[2][i] = y5 - x0; + block[3][i] = y6 - y7; + block[4][i] = y6 + y7; + block[5][i] = x0 + y5; + block[6][i] = y3 - x4; + block[7][i] = y4 - b7; + } + + for (i = 0; i < 8; ++i) { + b1 = block[i][4]; + b3 = block[i][2] + block[i][6]; + b4 = block[i][5] - block[i][3]; + t1 = block[i][1] + block[i][7]; + t2 = block[i][3] + block[i][5]; + b6 = block[i][1] - block[i][7]; + b7 = t1 + t2; + m0 = block[i][0]; + x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7; + x0 = x4 - (((t1 - t2) * 362 + 128) >> 8); + x1 = m0 - b1; + x2 = (((block[i][2] - block[i][6]) * 362 + 128) >> 8) - b3; + x3 = m0 + b1; + y3 = x1 + x2; + y4 = x3 + b3; + y5 = x1 - x2; + y6 = x3 - b3; + y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8); + block[i][0] = (b7 + y4 + 128) >> 8; + block[i][1] = (x4 + y3 + 128) >> 8; + block[i][2] = (y5 - x0 + 128) >> 8; + block[i][3] = (y6 - y7 + 128) >> 8; + block[i][4] = (y6 + y7 + 128) >> 8; + block[i][5] = (x0 + y5 + 128) >> 8; + block[i][6] = (y3 - x4 + 128) >> 8; + block[i][7] = (y4 - b7 + 128) >> 8; + } +} diff --git a/dsp/mpeg/idct.h b/dsp/mpeg/idct.h new file mode 100644 index 00000000..6c64f969 --- /dev/null +++ b/dsp/mpeg/idct.h @@ -0,0 +1,10 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_IDCT_H_ +#define COSMOPOLITAN_DSP_MPEG_IDCT_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +void plm_video_idct(int *); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_IDCT_H_ */ diff --git a/dsp/mpeg/macroblock.c b/dsp/mpeg/macroblock.c new file mode 100644 index 00000000..fb49260f --- /dev/null +++ b/dsp/mpeg/macroblock.c @@ -0,0 +1,171 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/mpeg.h" +#include "dsp/mpeg/video.h" +#include "libc/log/check.h" + +forceinline void plm_video_process_macroblock(plm_video_t *self, + uint8_t *restrict d, + uint8_t *restrict s, int motion_h, + int motion_v, bool interpolate, + unsigned BW) { + unsigned si, di, max_address; + int y, x, dest_scan, source_scan, dw, hp, vp, odd_h, odd_v; + dw = self->mb_width * BW; + hp = motion_h >> 1; + vp = motion_v >> 1; + odd_h = (motion_h & 1) == 1; + odd_v = (motion_v & 1) == 1; + si = ((self->mb_row * BW) + vp) * dw + (self->mb_col * BW) + hp; + di = (self->mb_row * dw + self->mb_col) * BW; + max_address = (dw * (self->mb_height * BW - BW + 1) - BW); + if (si > max_address || di > max_address) return; + d += di; + s += si; + switch (((interpolate << 2) | (odd_h << 1) | (odd_v)) & 7) { + case 0: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + *d++ = *s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 1: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + *d++ = (s[0] + s[dw] + 1) >> 1; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 2: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + *d++ = (s[0] + s[1] + 1) >> 1; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 3: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + *d++ = (s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 4: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + d[0] = (d[0] + (s[0]) + 1) >> 1; + d++; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 5: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + d[0] = (d[0] + ((s[0] + s[dw] + 1) >> 1) + 1) >> 1; + d++; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 6: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + d[0] = (d[0] + ((s[0] + s[1] + 1) >> 1) + 1) >> 1; + d++; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + case 7: + dest_scan = dw - BW; + source_scan = dw - BW; + for (y = 0; y < BW; y++) { + for (x = 0; x < BW; x++) { + d[0] = (d[0] + ((s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2) + 1) >> 1; + d++; + s++; + } + s += source_scan; + d += dest_scan; + } + break; + default: + break; + } +} + +void plm_video_process_macroblock_8(plm_video_t *self, uint8_t *restrict d, + uint8_t *restrict s, int motion_h, + int motion_v, bool interpolate) { + DCHECK_ALIGNED(8, d); + DCHECK_ALIGNED(8, s); + plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 8); +} + +void plm_video_process_macroblock_16(plm_video_t *self, uint8_t *restrict d, + uint8_t *restrict s, int motion_h, + int motion_v, bool interpolate) { + DCHECK_ALIGNED(16, d); + DCHECK_ALIGNED(16, s); + plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 16); +} diff --git a/dsp/mpeg/mp2.c b/dsp/mpeg/mp2.c new file mode 100644 index 00000000..d9c8f88e --- /dev/null +++ b/dsp/mpeg/mp2.c @@ -0,0 +1,775 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/buffer.h" +#include "dsp/mpeg/mpeg.h" +#include "libc/log/log.h" +#include "libc/mem/mem.h" +#include "libc/str/str.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/* clang-format off */ +// ----------------------------------------------------------------------------- +// plm_audio implementation + +// Based on kjmp2 by Martin J. Fiedler +// http://keyj.emphy.de/kjmp2/ + +#define PLM_AUDIO_FRAME_SYNC 0x7ff + +#define PLM_AUDIO_MPEG_2_5 0x0 +#define PLM_AUDIO_MPEG_2 0x2 +#define PLM_AUDIO_MPEG_1 0x3 + +#define PLM_AUDIO_LAYER_III 0x1 +#define PLM_AUDIO_LAYER_II 0x2 +#define PLM_AUDIO_LAYER_I 0x3 + +#define PLM_AUDIO_MODE_STEREO 0x0 +#define PLM_AUDIO_MODE_JOINT_STEREO 0x1 +#define PLM_AUDIO_MODE_DUAL_CHANNEL 0x2 +#define PLM_AUDIO_MODE_MONO 0x3 + +static const unsigned short PLM_AUDIO_SAMPLE_RATE[] = { + 44100, 48000, 32000, 0, // MPEG-1 + 22050, 24000, 16000, 0 // MPEG-2 +}; + +static const short PLM_AUDIO_BIT_RATE[] = { + 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // MPEG-1 + 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 // MPEG-2 +}; + +static const int PLM_AUDIO_SCALEFACTOR_BASE[] = { + 0x02000000, 0x01965FEA, 0x01428A30 +}; + +static const float PLM_AUDIO_SYNTHESIS_WINDOW[] = { + 0.0, -0.5, -0.5, -0.5, -0.5, -0.5, + -0.5, -1.0, -1.0, -1.0, -1.0, -1.5, + -1.5, -2.0, -2.0, -2.5, -2.5, -3.0, + -3.5, -3.5, -4.0, -4.5, -5.0, -5.5, + -6.5, -7.0, -8.0, -8.5, -9.5, -10.5, + -12.0, -13.0, -14.5, -15.5, -17.5, -19.0, + -20.5, -22.5, -24.5, -26.5, -29.0, -31.5, + -34.0, -36.5, -39.5, -42.5, -45.5, -48.5, + -52.0, -55.5, -58.5, -62.5, -66.0, -69.5, + -73.5, -77.0, -80.5, -84.5, -88.0, -91.5, + -95.0, -98.0, -101.0, -104.0, 106.5, 109.0, + 111.0, 112.5, 113.5, 114.0, 114.0, 113.5, + 112.0, 110.5, 107.5, 104.0, 100.0, 94.5, + 88.5, 81.5, 73.0, 63.5, 53.0, 41.5, + 28.5, 14.5, -1.0, -18.0, -36.0, -55.5, + -76.5, -98.5, -122.0, -147.0, -173.5, -200.5, + -229.5, -259.5, -290.5, -322.5, -355.5, -389.5, + -424.0, -459.5, -495.5, -532.0, -568.5, -605.0, + -641.5, -678.0, -714.0, -749.0, -783.5, -817.0, + -849.0, -879.5, -908.5, -935.0, -959.5, -981.0, + -1000.5, -1016.0, -1028.5, -1037.5, -1042.5, -1043.5, + -1040.0, -1031.5, 1018.5, 1000.0, 976.0, 946.5, + 911.0, 869.5, 822.0, 767.5, 707.0, 640.0, + 565.5, 485.0, 397.0, 302.5, 201.0, 92.5, + -22.5, -144.0, -272.5, -407.0, -547.5, -694.0, + -846.0, -1003.0, -1165.0, -1331.5, -1502.0, -1675.5, + -1852.5, -2031.5, -2212.5, -2394.0, -2576.5, -2758.5, + -2939.5, -3118.5, -3294.5, -3467.5, -3635.5, -3798.5, + -3955.0, -4104.5, -4245.5, -4377.5, -4499.0, -4609.5, + -4708.0, -4792.5, -4863.5, -4919.0, -4958.0, -4979.5, + -4983.0, -4967.5, -4931.5, -4875.0, -4796.0, -4694.5, + -4569.5, -4420.0, -4246.0, -4046.0, -3820.0, -3567.0, + 3287.0, 2979.5, 2644.0, 2280.5, 1888.0, 1467.5, + 1018.5, 541.0, 35.0, -499.0, -1061.0, -1650.0, + -2266.5, -2909.0, -3577.0, -4270.0, -4987.5, -5727.5, + -6490.0, -7274.0, -8077.5, -8899.5, -9739.0, -10594.5, + -11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5, + -16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0, + -22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0, + -27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0, + -32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5, + -35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0, + -37156.5, -37315.0, -37428.0, -37496.0, 37519.0, 37496.0, + 37428.0, 37315.0, 37156.5, 36954.0, 36707.5, 36417.5, + 36084.5, 35710.0, 35295.0, 34839.5, 34346.0, 33814.5, + 33247.0, 32645.0, 32009.5, 31342.0, 30644.5, 29919.0, + 29166.5, 28389.0, 27589.0, 26767.0, 25926.5, 25068.5, + 24195.0, 23308.5, 22410.5, 21503.0, 20588.0, 19668.0, + 18744.5, 17820.0, 16895.5, 15973.5, 15056.0, 14144.5, + 13241.0, 12347.0, 11464.5, 10594.5, 9739.0, 8899.5, + 8077.5, 7274.0, 6490.0, 5727.5, 4987.5, 4270.0, + 3577.0, 2909.0, 2266.5, 1650.0, 1061.0, 499.0, + -35.0, -541.0, -1018.5, -1467.5, -1888.0, -2280.5, + -2644.0, -2979.5, 3287.0, 3567.0, 3820.0, 4046.0, + 4246.0, 4420.0, 4569.5, 4694.5, 4796.0, 4875.0, + 4931.5, 4967.5, 4983.0, 4979.5, 4958.0, 4919.0, + 4863.5, 4792.5, 4708.0, 4609.5, 4499.0, 4377.5, + 4245.5, 4104.5, 3955.0, 3798.5, 3635.5, 3467.5, + 3294.5, 3118.5, 2939.5, 2758.5, 2576.5, 2394.0, + 2212.5, 2031.5, 1852.5, 1675.5, 1502.0, 1331.5, + 1165.0, 1003.0, 846.0, 694.0, 547.5, 407.0, + 272.5, 144.0, 22.5, -92.5, -201.0, -302.5, + -397.0, -485.0, -565.5, -640.0, -707.0, -767.5, + -822.0, -869.5, -911.0, -946.5, -976.0, -1000.0, + 1018.5, 1031.5, 1040.0, 1043.5, 1042.5, 1037.5, + 1028.5, 1016.0, 1000.5, 981.0, 959.5, 935.0, + 908.5, 879.5, 849.0, 817.0, 783.5, 749.0, + 714.0, 678.0, 641.5, 605.0, 568.5, 532.0, + 495.5, 459.5, 424.0, 389.5, 355.5, 322.5, + 290.5, 259.5, 229.5, 200.5, 173.5, 147.0, + 122.0, 98.5, 76.5, 55.5, 36.0, 18.0, + 1.0, -14.5, -28.5, -41.5, -53.0, -63.5, + -73.0, -81.5, -88.5, -94.5, -100.0, -104.0, + -107.5, -110.5, -112.0, -113.5, -114.0, -114.0, + -113.5, -112.5, -111.0, -109.0, 106.5, 104.0, + 101.0, 98.0, 95.0, 91.5, 88.0, 84.5, + 80.5, 77.0, 73.5, 69.5, 66.0, 62.5, + 58.5, 55.5, 52.0, 48.5, 45.5, 42.5, + 39.5, 36.5, 34.0, 31.5, 29.0, 26.5, + 24.5, 22.5, 20.5, 19.0, 17.5, 15.5, + 14.5, 13.0, 12.0, 10.5, 9.5, 8.5, + 8.0, 7.0, 6.5, 5.5, 5.0, 4.5, + 4.0, 3.5, 3.5, 3.0, 2.5, 2.5, + 2.0, 2.0, 1.5, 1.5, 1.0, 1.0, + 1.0, 1.0, 0.5, 0.5, 0.5, 0.5, + 0.5, 0.5 +}; + +// Quantizer lookup, step 1: bitrate classes +static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_1[2][16] = { + // 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384 <- bitrate + { 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, // mono + // 16, 24, 28, 32, 40, 48, 56, 64, 80, 96,112,128,160,192 <- bitrate / chan + { 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2 } // stereo +}; + +// Quantizer lookup, step 2: bitrate class, sample rate -> B2 table idx, sblimit +static const uint8_t PLM_AUDIO_QUANT_TAB_A = (27 | 64); // Table 3-B.2a: high-rate, sblimit = 27 +static const uint8_t PLM_AUDIO_QUANT_TAB_B = (30 | 64); // Table 3-B.2b: high-rate, sblimit = 30 +static const uint8_t PLM_AUDIO_QUANT_TAB_C = 8; // Table 3-B.2c: low-rate, sblimit = 8 +static const uint8_t PLM_AUDIO_QUANT_TAB_D = 12; // Table 3-B.2d: low-rate, sblimit = 12 + +static const uint8_t QUANT_LUT_STEP_2[3][3] = { + // 44.1 kHz, 48 kHz, 32 kHz + { PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_D }, // 32 - 48 kbit/sec/ch + { PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A }, // 56 - 80 kbit/sec/ch + { PLM_AUDIO_QUANT_TAB_B, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_B } // 96+ kbit/sec/ch +}; + +// Quantizer lookup, step 3: B2 table, subband -> nbal, row index +// (upper 4 bits: nbal, lower 4 bits: row index) +static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_3[3][32] = { + // Low-rate table (3-B.2c and 3-B.2d) + { + 0x44,0x44, + 0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34 + }, + // High-rate table (3-B.2a and 3-B.2b) + { + 0x43,0x43,0x43, + 0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42, + 0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31, + 0x20,0x20,0x20,0x20,0x20,0x20,0x20 + }, + // MPEG-2 LSR table (B.2 in ISO 13818-3) + { + 0x45,0x45,0x45,0x45, + 0x34,0x34,0x34,0x34,0x34,0x34,0x34, + 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, + 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24 + } +}; + +// Quantizer lookup, step 4: table row, allocation[] value -> quant table index +static const uint8_t PLM_AUDIO_QUANT_LUT_STEP4[6][16] = { + { 0, 1, 2, 17 }, + { 0, 1, 2, 3, 4, 5, 6, 17 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17 }, + { 0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }, + { 0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17 }, + { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } +}; + +typedef struct plm_quantizer_spec_t { + unsigned short levels; + unsigned char group; + unsigned char bits; +} plm_quantizer_spec_t; + +static const plm_quantizer_spec_t PLM_AUDIO_QUANT_TAB[] = { + { 3, 1, 5 }, // 1 + { 5, 1, 7 }, // 2 + { 7, 0, 3 }, // 3 + { 9, 1, 10 }, // 4 + { 15, 0, 4 }, // 5 + { 31, 0, 5 }, // 6 + { 63, 0, 6 }, // 7 + { 127, 0, 7 }, // 8 + { 255, 0, 8 }, // 9 + { 511, 0, 9 }, // 10 + { 1023, 0, 10 }, // 11 + { 2047, 0, 11 }, // 12 + { 4095, 0, 12 }, // 13 + { 8191, 0, 13 }, // 14 + { 16383, 0, 14 }, // 15 + { 32767, 0, 15 }, // 16 + { 65535, 0, 16 } // 17 +}; + +struct plm_audio_t { + double time; + int samples_decoded; + int samplerate_index; + int bitrate_index; + int version; + int layer; + int mode; + int bound; + int v_pos; + int next_frame_data_size; + plm_buffer_t *buffer; + int destroy_buffer_when_done; + const plm_quantizer_spec_t *allocation[2][32]; + uint8_t scale_factor_info[2][32]; + int scale_factor[2][32][3]; + int sample[2][32][3]; + plm_samples_t samples; + float D[1024]; + float V[1024]; + float U[32]; +} aligned(64); + +typedef plm_audio_t plm_audio_t; + +int plm_audio_decode_header(plm_audio_t *self); +void plm_audio_decode_frame(plm_audio_t *self); +const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3); +void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part); +void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp); + +plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) { + plm_audio_t *self = (plm_audio_t *)memalign(alignof(plm_audio_t), sizeof(plm_audio_t)); + memset(self, 0, sizeof(plm_audio_t)); + + self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME; + self->buffer = buffer; + self->destroy_buffer_when_done = destroy_when_done; + self->samplerate_index = 3; // indicates 0 samplerate + + memcpy(self->D, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float)); + memcpy(self->D + 512, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float)); + + // Decode first header + if (plm_buffer_has(self->buffer, 48)) { + self->next_frame_data_size = plm_audio_decode_header(self); + } + + return self; +} + +void plm_audio_destroy(plm_audio_t *self) { + if (self->destroy_buffer_when_done) { + plm_buffer_destroy(self->buffer); + } + free(self); +} + +int plm_audio_get_samplerate(plm_audio_t *self) { + return PLM_AUDIO_SAMPLE_RATE[self->samplerate_index]; +} + +double plm_audio_get_time(plm_audio_t *self) { + return self->time; +} + +void plm_audio_rewind(plm_audio_t *self) { + plm_buffer_rewind(self->buffer); + self->time = 0; + self->samples_decoded = 0; + self->next_frame_data_size = 0; + + // TODO: needed? + memset(self->V, 0, sizeof(self->V)); + memset(self->U, 0, sizeof(self->U)); +} + +plm_samples_t *plm_audio_decode(plm_audio_t *self) { + DEBUGF("%s", "plm_audio_decode"); + // Do we have at least enough information to decode the frame header? + if (!self->next_frame_data_size) { + if (!plm_buffer_has(self->buffer, 48)) { + return NULL; + } + self->next_frame_data_size = plm_audio_decode_header(self); + } + + if ( + self->next_frame_data_size == 0 || + !plm_buffer_has(self->buffer, self->next_frame_data_size << 3) + ) { + return NULL; + } + + plm_audio_decode_frame(self); + self->next_frame_data_size = 0; + + self->samples.time = self->time; + + self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME; + self->time = (double)self->samples_decoded / + (double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index]; + + return &self->samples; +} + +int plm_audio_decode_header(plm_audio_t *self) { + // Check for valid header: syncword OK, MPEG-Audio Layer 2 + plm_buffer_skip_bytes(self->buffer, 0x00); + + int sync = plm_buffer_read(self->buffer, 11); + self->version = plm_buffer_read(self->buffer, 2); + self->layer = plm_buffer_read(self->buffer, 2); + int hasCRC = !plm_buffer_read(self->buffer, 1); + + if ( + sync != PLM_AUDIO_FRAME_SYNC || + self->version != PLM_AUDIO_MPEG_1 || + self->layer != PLM_AUDIO_LAYER_II + ) { + return false; // Invalid header or unsupported version + } + + self->bitrate_index = plm_buffer_read(self->buffer, 4) - 1; + if (self->bitrate_index > 13) { + return false; // Invalid bit rate or 'free format' + } + + self->samplerate_index = plm_buffer_read(self->buffer, 2); + if (self->samplerate_index == 3) { + return false; // Invalid sample rate + } + + if (self->version == PLM_AUDIO_MPEG_2) { + self->samplerate_index += 4; + self->bitrate_index += 14; + } + int padding = plm_buffer_read(self->buffer, 1); + plm_buffer_skip(self->buffer, 1); // f_private + self->mode = plm_buffer_read(self->buffer, 2); + + // Parse the mode_extension, set up the stereo bound + self->bound = 0; + if (self->mode == PLM_AUDIO_MODE_JOINT_STEREO) { + self->bound = (plm_buffer_read(self->buffer, 2) + 1) << 2; + } + else { + plm_buffer_skip(self->buffer, 2); + self->bound = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 32; + } + + // Discard the last 4 bits of the header and the CRC value, if present + plm_buffer_skip(self->buffer, 4); + if (hasCRC) { + plm_buffer_skip(self->buffer, 16); + } + + // Compute frame size, check if we have enough data to decode the whole + // frame. + int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index]; + int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index]; + int frame_size = (144000 * bitrate / samplerate) + padding; + return frame_size - (hasCRC ? 6 : 4); +} + +void plm_audio_decode_frame(plm_audio_t *self) { + // Prepare the quantizer table lookups + int tab3 = 0; + int sblimit = 0; + if (self->version == PLM_AUDIO_MPEG_2) { + // MPEG-2 (LSR) + tab3 = 2; + sblimit = 30; + } + else { + // MPEG-1 + int tab1 = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 1; + int tab2 = PLM_AUDIO_QUANT_LUT_STEP_1[tab1][self->bitrate_index]; + tab3 = QUANT_LUT_STEP_2[tab2][self->samplerate_index]; + sblimit = tab3 & 63; + tab3 >>= 6; + } + + if (self->bound > sblimit) { + self->bound = sblimit; + } + + // Read the allocation information + for (int sb = 0; sb < self->bound; sb++) { + self->allocation[0][sb] = plm_audio_read_allocation(self, sb, tab3); + self->allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3); + } + + for (int sb = self->bound; sb < sblimit; sb++) { + self->allocation[0][sb] = + self->allocation[1][sb] = + plm_audio_read_allocation(self, sb, tab3); + } + + // Read scale factor selector information + int channels = (self->mode == PLM_AUDIO_MODE_MONO) ? 1 : 2; + for (int sb = 0; sb < sblimit; sb++) { + for (int ch = 0; ch < channels; ch++) { + if (self->allocation[ch][sb]) { + self->scale_factor_info[ch][sb] = plm_buffer_read(self->buffer, 2); + } + } + if (self->mode == PLM_AUDIO_MODE_MONO) { + self->scale_factor_info[1][sb] = self->scale_factor_info[0][sb]; + } + } + + // Read scale factors + for (int sb = 0; sb < sblimit; sb++) { + for (int ch = 0; ch < channels; ch++) { + if (self->allocation[ch][sb]) { + int *sf = self->scale_factor[ch][sb]; + switch (self->scale_factor_info[ch][sb]) { + case 0: + sf[0] = plm_buffer_read(self->buffer, 6); + sf[1] = plm_buffer_read(self->buffer, 6); + sf[2] = plm_buffer_read(self->buffer, 6); + break; + case 1: + sf[0] = + sf[1] = plm_buffer_read(self->buffer, 6); + sf[2] = plm_buffer_read(self->buffer, 6); + break; + case 2: + sf[0] = + sf[1] = + sf[2] = plm_buffer_read(self->buffer, 6); + break; + case 3: + sf[0] = plm_buffer_read(self->buffer, 6); + sf[1] = + sf[2] = plm_buffer_read(self->buffer, 6); + break; + } + } + } + if (self->mode == PLM_AUDIO_MODE_MONO) { + self->scale_factor[1][sb][0] = self->scale_factor[0][sb][0]; + self->scale_factor[1][sb][1] = self->scale_factor[0][sb][1]; + self->scale_factor[1][sb][2] = self->scale_factor[0][sb][2]; + } + } + + // Coefficient input and reconstruction + int out_pos = 0; + for (int part = 0; part < 3; part++) { + for (int granule = 0; granule < 4; granule++) { + + // Read the samples + for (int sb = 0; sb < self->bound; sb++) { + plm_audio_read_samples(self, 0, sb, part); + plm_audio_read_samples(self, 1, sb, part); + } + for (int sb = self->bound; sb < sblimit; sb++) { + plm_audio_read_samples(self, 0, sb, part); + self->sample[1][sb][0] = self->sample[0][sb][0]; + self->sample[1][sb][1] = self->sample[0][sb][1]; + self->sample[1][sb][2] = self->sample[0][sb][2]; + } + for (int sb = sblimit; sb < 32; sb++) { + self->sample[0][sb][0] = 0; + self->sample[0][sb][1] = 0; + self->sample[0][sb][2] = 0; + self->sample[1][sb][0] = 0; + self->sample[1][sb][1] = 0; + self->sample[1][sb][2] = 0; + } + + // Synthesis loop + for (int p = 0; p < 3; p++) { + // Shifting step + self->v_pos = (self->v_pos - 64) & 1023; + + for (int ch = 0; ch < 2; ch++) { + plm_audio_matrix_transform(self->sample[ch], p, self->V, self->v_pos); + + // Build U, windowing, calculate output + memset(self->U, 0, sizeof(self->U)); + + int d_index = 512 - (self->v_pos >> 1); + int v_index = (self->v_pos % 128) >> 1; + while (v_index < 1024) { + for (int i = 0; i < 32; ++i) { + self->U[i] += self->D[d_index++] * self->V[v_index++]; + } + + v_index += 128 - 32; + d_index += 64 - 32; + } + + d_index -= (512 - 32); + v_index = (128 - 32 + 1024) - v_index; + while (v_index < 1024) { + for (int i = 0; i < 32; ++i) { + self->U[i] += self->D[d_index++] * self->V[v_index++]; + } + + v_index += 128 - 32; + d_index += 64 - 32; + } + + // Output samples + #ifdef PLM_AUDIO_SEPARATE_CHANNELS + float *out_channel = ch == 0 + ? self->samples.left + : self->samples.right; + for (int j = 0; j < 32; j++) { + out_channel[out_pos + j] = self->U[j] / 2147418112.0f; + } + #else + for (int j = 0; j < 32; j++) { + self->samples.interleaved[((out_pos + j) << 1) + ch] = + self->U[j] / 2147418112.0f; + } + #endif + } // End of synthesis channel loop + out_pos += 32; + } // End of synthesis sub-block loop + + } // Decoding of the granule finished + } + + plm_buffer_align(self->buffer); +} + +const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3) { + int tab4 = PLM_AUDIO_QUANT_LUT_STEP_3[tab3][sb]; + int qtab = PLM_AUDIO_QUANT_LUT_STEP4[tab4 & 15][plm_buffer_read(self->buffer, tab4 >> 4)]; + return qtab ? (&PLM_AUDIO_QUANT_TAB[qtab - 1]) : 0; +} + +void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part) { + const plm_quantizer_spec_t *q = self->allocation[ch][sb]; + int sf = self->scale_factor[ch][sb][part]; + int *sample = self->sample[ch][sb]; + int val = 0; + + if (!q) { + // No bits allocated for this subband + sample[0] = sample[1] = sample[2] = 0; + return; + } + + // Resolve scalefactor + if (sf == 63) { + sf = 0; + } + else { + int shift = (sf / 3) | 0; + sf = (PLM_AUDIO_SCALEFACTOR_BASE[sf % 3] + ((1u << shift) >> 1)) >> shift; + } + + // Decode samples + int adj = q->levels; + if (q->group) { + // Decode grouped samples + val = plm_buffer_read(self->buffer, q->bits); + sample[0] = val % adj; + val /= adj; + sample[1] = val % adj; + sample[2] = val / adj; + } + else { + // Decode direct samples + sample[0] = plm_buffer_read(self->buffer, q->bits); + sample[1] = plm_buffer_read(self->buffer, q->bits); + sample[2] = plm_buffer_read(self->buffer, q->bits); + } + + // Postmultiply samples + int scale = 65536 / (adj + 1); + adj = ((adj + 1) >> 1) - 1; + + val = (adj - sample[0]) * scale; + sample[0] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12; + + val = (adj - sample[1]) * scale; + sample[1] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12; + + val = (adj - sample[2]) * scale; + sample[2] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12; +} + +void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp) { + float t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, + t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, + t25, t26, t27, t28, t29, t30, t31, t32, t33; + + t01 = (float)(s[0][ss] + s[31][ss]); t02 = (float)(s[0][ss] - s[31][ss]) * 0.500602998235f; + t03 = (float)(s[1][ss] + s[30][ss]); t04 = (float)(s[1][ss] - s[30][ss]) * 0.505470959898f; + t05 = (float)(s[2][ss] + s[29][ss]); t06 = (float)(s[2][ss] - s[29][ss]) * 0.515447309923f; + t07 = (float)(s[3][ss] + s[28][ss]); t08 = (float)(s[3][ss] - s[28][ss]) * 0.53104259109f; + t09 = (float)(s[4][ss] + s[27][ss]); t10 = (float)(s[4][ss] - s[27][ss]) * 0.553103896034f; + t11 = (float)(s[5][ss] + s[26][ss]); t12 = (float)(s[5][ss] - s[26][ss]) * 0.582934968206f; + t13 = (float)(s[6][ss] + s[25][ss]); t14 = (float)(s[6][ss] - s[25][ss]) * 0.622504123036f; + t15 = (float)(s[7][ss] + s[24][ss]); t16 = (float)(s[7][ss] - s[24][ss]) * 0.674808341455f; + t17 = (float)(s[8][ss] + s[23][ss]); t18 = (float)(s[8][ss] - s[23][ss]) * 0.744536271002f; + t19 = (float)(s[9][ss] + s[22][ss]); t20 = (float)(s[9][ss] - s[22][ss]) * 0.839349645416f; + t21 = (float)(s[10][ss] + s[21][ss]); t22 = (float)(s[10][ss] - s[21][ss]) * 0.972568237862f; + t23 = (float)(s[11][ss] + s[20][ss]); t24 = (float)(s[11][ss] - s[20][ss]) * 1.16943993343f; + t25 = (float)(s[12][ss] + s[19][ss]); t26 = (float)(s[12][ss] - s[19][ss]) * 1.48416461631f; + t27 = (float)(s[13][ss] + s[18][ss]); t28 = (float)(s[13][ss] - s[18][ss]) * 2.05778100995f; + t29 = (float)(s[14][ss] + s[17][ss]); t30 = (float)(s[14][ss] - s[17][ss]) * 3.40760841847f; + t31 = (float)(s[15][ss] + s[16][ss]); t32 = (float)(s[15][ss] - s[16][ss]) * 10.1900081235f; + + t33 = t01 + t31; t31 = (t01 - t31) * 0.502419286188f; + t01 = t03 + t29; t29 = (t03 - t29) * 0.52249861494f; + t03 = t05 + t27; t27 = (t05 - t27) * 0.566944034816f; + t05 = t07 + t25; t25 = (t07 - t25) * 0.64682178336f; + t07 = t09 + t23; t23 = (t09 - t23) * 0.788154623451f; + t09 = t11 + t21; t21 = (t11 - t21) * 1.06067768599f; + t11 = t13 + t19; t19 = (t13 - t19) * 1.72244709824f; + t13 = t15 + t17; t17 = (t15 - t17) * 5.10114861869f; + t15 = t33 + t13; t13 = (t33 - t13) * 0.509795579104f; + t33 = t01 + t11; t01 = (t01 - t11) * 0.601344886935f; + t11 = t03 + t09; t09 = (t03 - t09) * 0.899976223136f; + t03 = t05 + t07; t07 = (t05 - t07) * 2.56291544774f; + t05 = t15 + t03; t15 = (t15 - t03) * 0.541196100146f; + t03 = t33 + t11; t11 = (t33 - t11) * 1.30656296488f; + t33 = t05 + t03; t05 = (t05 - t03) * 0.707106781187f; + t03 = t15 + t11; t15 = (t15 - t11) * 0.707106781187f; + t03 += t15; + t11 = t13 + t07; t13 = (t13 - t07) * 0.541196100146f; + t07 = t01 + t09; t09 = (t01 - t09) * 1.30656296488f; + t01 = t11 + t07; t07 = (t11 - t07) * 0.707106781187f; + t11 = t13 + t09; t13 = (t13 - t09) * 0.707106781187f; + t11 += t13; t01 += t11; + t11 += t07; t07 += t13; + t09 = t31 + t17; t31 = (t31 - t17) * 0.509795579104f; + t17 = t29 + t19; t29 = (t29 - t19) * 0.601344886935f; + t19 = t27 + t21; t21 = (t27 - t21) * 0.899976223136f; + t27 = t25 + t23; t23 = (t25 - t23) * 2.56291544774f; + t25 = t09 + t27; t09 = (t09 - t27) * 0.541196100146f; + t27 = t17 + t19; t19 = (t17 - t19) * 1.30656296488f; + t17 = t25 + t27; t27 = (t25 - t27) * 0.707106781187f; + t25 = t09 + t19; t19 = (t09 - t19) * 0.707106781187f; + t25 += t19; + t09 = t31 + t23; t31 = (t31 - t23) * 0.541196100146f; + t23 = t29 + t21; t21 = (t29 - t21) * 1.30656296488f; + t29 = t09 + t23; t23 = (t09 - t23) * 0.707106781187f; + t09 = t31 + t21; t31 = (t31 - t21) * 0.707106781187f; + t09 += t31; t29 += t09; t09 += t23; t23 += t31; + t17 += t29; t29 += t25; t25 += t09; t09 += t27; + t27 += t23; t23 += t19; t19 += t31; + t21 = t02 + t32; t02 = (t02 - t32) * 0.502419286188f; + t32 = t04 + t30; t04 = (t04 - t30) * 0.52249861494f; + t30 = t06 + t28; t28 = (t06 - t28) * 0.566944034816f; + t06 = t08 + t26; t08 = (t08 - t26) * 0.64682178336f; + t26 = t10 + t24; t10 = (t10 - t24) * 0.788154623451f; + t24 = t12 + t22; t22 = (t12 - t22) * 1.06067768599f; + t12 = t14 + t20; t20 = (t14 - t20) * 1.72244709824f; + t14 = t16 + t18; t16 = (t16 - t18) * 5.10114861869f; + t18 = t21 + t14; t14 = (t21 - t14) * 0.509795579104f; + t21 = t32 + t12; t32 = (t32 - t12) * 0.601344886935f; + t12 = t30 + t24; t24 = (t30 - t24) * 0.899976223136f; + t30 = t06 + t26; t26 = (t06 - t26) * 2.56291544774f; + t06 = t18 + t30; t18 = (t18 - t30) * 0.541196100146f; + t30 = t21 + t12; t12 = (t21 - t12) * 1.30656296488f; + t21 = t06 + t30; t30 = (t06 - t30) * 0.707106781187f; + t06 = t18 + t12; t12 = (t18 - t12) * 0.707106781187f; + t06 += t12; + t18 = t14 + t26; t26 = (t14 - t26) * 0.541196100146f; + t14 = t32 + t24; t24 = (t32 - t24) * 1.30656296488f; + t32 = t18 + t14; t14 = (t18 - t14) * 0.707106781187f; + t18 = t26 + t24; t24 = (t26 - t24) * 0.707106781187f; + t18 += t24; t32 += t18; + t18 += t14; t26 = t14 + t24; + t14 = t02 + t16; t02 = (t02 - t16) * 0.509795579104f; + t16 = t04 + t20; t04 = (t04 - t20) * 0.601344886935f; + t20 = t28 + t22; t22 = (t28 - t22) * 0.899976223136f; + t28 = t08 + t10; t10 = (t08 - t10) * 2.56291544774f; + t08 = t14 + t28; t14 = (t14 - t28) * 0.541196100146f; + t28 = t16 + t20; t20 = (t16 - t20) * 1.30656296488f; + t16 = t08 + t28; t28 = (t08 - t28) * 0.707106781187f; + t08 = t14 + t20; t20 = (t14 - t20) * 0.707106781187f; + t08 += t20; + t14 = t02 + t10; t02 = (t02 - t10) * 0.541196100146f; + t10 = t04 + t22; t22 = (t04 - t22) * 1.30656296488f; + t04 = t14 + t10; t10 = (t14 - t10) * 0.707106781187f; + t14 = t02 + t22; t02 = (t02 - t22) * 0.707106781187f; + t14 += t02; t04 += t14; t14 += t10; t10 += t02; + t16 += t04; t04 += t08; t08 += t14; t14 += t28; + t28 += t10; t10 += t20; t20 += t02; t21 += t16; + t16 += t32; t32 += t04; t04 += t06; t06 += t08; + t08 += t18; t18 += t14; t14 += t30; t30 += t28; + t28 += t26; t26 += t10; t10 += t12; t12 += t20; + t20 += t24; t24 += t02; + + d[dp + 48] = -t33; + d[dp + 49] = d[dp + 47] = -t21; + d[dp + 50] = d[dp + 46] = -t17; + d[dp + 51] = d[dp + 45] = -t16; + d[dp + 52] = d[dp + 44] = -t01; + d[dp + 53] = d[dp + 43] = -t32; + d[dp + 54] = d[dp + 42] = -t29; + d[dp + 55] = d[dp + 41] = -t04; + d[dp + 56] = d[dp + 40] = -t03; + d[dp + 57] = d[dp + 39] = -t06; + d[dp + 58] = d[dp + 38] = -t25; + d[dp + 59] = d[dp + 37] = -t08; + d[dp + 60] = d[dp + 36] = -t11; + d[dp + 61] = d[dp + 35] = -t18; + d[dp + 62] = d[dp + 34] = -t09; + d[dp + 63] = d[dp + 33] = -t14; + d[dp + 32] = -t05; + d[dp + 0] = t05; d[dp + 31] = -t30; + d[dp + 1] = t30; d[dp + 30] = -t27; + d[dp + 2] = t27; d[dp + 29] = -t28; + d[dp + 3] = t28; d[dp + 28] = -t07; + d[dp + 4] = t07; d[dp + 27] = -t26; + d[dp + 5] = t26; d[dp + 26] = -t23; + d[dp + 6] = t23; d[dp + 25] = -t10; + d[dp + 7] = t10; d[dp + 24] = -t15; + d[dp + 8] = t15; d[dp + 23] = -t12; + d[dp + 9] = t12; d[dp + 22] = -t19; + d[dp + 10] = t19; d[dp + 21] = -t20; + d[dp + 11] = t20; d[dp + 20] = -t13; + d[dp + 12] = t13; d[dp + 19] = -t24; + d[dp + 13] = t24; d[dp + 18] = -t31; + d[dp + 14] = t31; d[dp + 17] = -t02; + d[dp + 15] = t02; d[dp + 16] = 0.0; +}; + diff --git a/dsp/mpeg/mpeg.h b/dsp/mpeg/mpeg.h new file mode 100644 index 00000000..e29de64c --- /dev/null +++ b/dsp/mpeg/mpeg.h @@ -0,0 +1,450 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_MPEG_H_ +#define COSMOPOLITAN_DSP_MPEG_MPEG_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct FILE; + +typedef struct plm_t plm_t; +typedef struct plm_buffer_t plm_buffer_t; +typedef struct plm_demux_t plm_demux_t; +typedef struct plm_video_t plm_video_t; +typedef struct plm_audio_t plm_audio_t; + +/** + * Demuxed MPEG PS packet + * + * The type maps directly to the various MPEG-PES start codes. pts is + * the presentation time stamp of the packet in seconds. Not all packets + * have a pts value. + */ +typedef struct plm_packet_t { + int type; + double pts; + size_t length; + uint8_t *data; +} plm_packet_t; + +/** + * Decoded Video Plane + * + * The byte length of the data is width * height. Note that different + * planes have different sizes: the Luma plane (Y) is double the size of + * each of the two Chroma planes (Cr, Cb) - i.e. 4 times the byte + * length. Also note that the size of the plane does *not* denote the + * size of the displayed frame. The sizes of planes are always rounded + * up to the nearest macroblock (16px). + */ +typedef struct plm_plane_t { + unsigned int width; + unsigned int height; + uint8_t *data; +} plm_plane_t; + +/** + * Decoded Video Frame + * + * Width and height denote the desired display size of the frame. This + * may be different from the internal size of the 3 planes. + */ +typedef struct plm_frame_t { + double time; + unsigned int width; + unsigned int height; + plm_plane_t y; + plm_plane_t cr; + plm_plane_t cb; +} plm_frame_t; + +/** + * Callback function type for decoded video frames used by the high-level + * plm_* interface + */ +typedef void (*plm_video_decode_callback)(plm_t *self, plm_frame_t *frame, + void *user); + +/** + * Decoded Audio Samples + * + * Samples are stored as normalized (-1, 1) float either interleaved, or if + * PLM_AUDIO_SEPARATE_CHANNELS is defined, in two separate arrays. + * The `count` is always PLM_AUDIO_SAMPLES_PER_FRAME and just there for + * convenience. + */ +#define PLM_AUDIO_SAMPLES_PER_FRAME 1152 + +struct plm_samples_t { + double time; + unsigned int count; +#ifdef PLM_AUDIO_SEPARATE_CHANNELS + float left[PLM_AUDIO_SAMPLES_PER_FRAME] aligned(32); + float right[PLM_AUDIO_SAMPLES_PER_FRAME] aligned(32); +#else + float interleaved[PLM_AUDIO_SAMPLES_PER_FRAME * 2] aligned(32); +#endif +} aligned(32); + +typedef struct plm_samples_t plm_samples_t; + +/** + * Callback function type for decoded audio samples used by the high-level + * plm_* interface + */ +typedef void (*plm_audio_decode_callback)(plm_t *self, plm_samples_t *samples, + void *user); + +/** + * Callback function for plm_buffer when it needs more data + */ +typedef void (*plm_buffer_load_callback)(plm_buffer_t *self, void *user); + +/** + * ----------------------------------------------------------------------------- + * plm_* public API + * High-Level API for loading/demuxing/decoding MPEG-PS data + * + * Create a plmpeg instance with a filename. Returns NULL if the file could not + * be opened. + */ +plm_t *plm_create_with_filename(const char *filename); + +/** + * Create a plmpeg instance with file handle. Pass true to close_when_done + * to let plmpeg call fclose() on the handle when plm_destroy() is + * called. + */ +plm_t *plm_create_with_file(struct FILE *fh, int close_when_done); + +/** + * Create a plmpeg instance with pointer to memory as source. This assumes the + * whole file is in memory. Pass true to free_when_done to let plmpeg call + * free() on the pointer when plm_destroy() is called. + */ +plm_t *plm_create_with_memory(uint8_t *bytes, size_t length, + int free_when_done); + +/** + * Create a plmpeg instance with a plm_buffer as source. This is also + * called internally by all the above constructor functions. + */ +plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done); + +/** + * Destroy a plmpeg instance and free all data + */ +void plm_destroy(plm_t *self); + +/** + * Get or set whether video decoding is enabled. + */ +int plm_get_video_enabled(plm_t *self); +void plm_set_video_enabled(plm_t *self, int enabled); + +/** + * Get or set whether audio decoding is enabled. When enabling, you can set the + * desired audio stream (0-3) to decode. + */ +int plm_get_audio_enabled(plm_t *self); +void plm_set_audio_enabled(plm_t *self, int enabled, int stream_index); + +/** + * Get the display width/height of the video stream + */ +int plm_get_width(plm_t *self); +int plm_get_height(plm_t *self); + +double plm_get_pixel_aspect_ratio(plm_t *); + +/** + * Get the framerate of the video stream in frames per second + */ +double plm_get_framerate(plm_t *self); + +/** + * Get the number of available audio streams in the file + */ +int plm_get_num_audio_streams(plm_t *self); + +/** + * Get the samplerate of the audio stream in samples per second + */ +int plm_get_samplerate(plm_t *self); + +/** + * Get or set the audio lead time in seconds - the time in which audio samples + * are decoded in advance (or behind) the video decode time. Default 0. + */ +double plm_get_audio_lead_time(plm_t *self); +void plm_set_audio_lead_time(plm_t *self, double lead_time); + +/** + * Get the current internal time in seconds + */ +double plm_get_time(plm_t *self); + +/** + * Rewind all buffers back to the beginning. + */ +void plm_rewind(plm_t *self); + +/** + * Get or set looping. Default false. + */ +int plm_get_loop(plm_t *self); +void plm_set_loop(plm_t *self, int loop); + +/** + * Get whether the file has ended. If looping is enabled, this will always + * return false. + */ +int plm_has_ended(plm_t *self); + +/** + * Set the callback for decoded video frames used with plm_decode(). If no + * callback is set, video data will be ignored and not be decoded. + */ +void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp, + void *user); + +/** + * Set the callback for decoded audio samples used with plm_decode(). If no + * callback is set, audio data will be ignored and not be decoded. + */ +void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp, + void *user); + +/** + * Advance the internal timer by seconds and decode video/audio up to + * this time. Returns true/false whether anything was decoded. + */ +int plm_decode(plm_t *self, double seconds); + +/** + * Decode and return one video frame. Returns NULL if no frame could be decoded + * (either because the source ended or data is corrupt). If you only want to + * decode video, you should disable audio via plm_set_audio_enabled(). + * The returned plm_frame_t is valid until the next call to + * plm_decode_video call or until the plm_destroy is called. + */ +plm_frame_t *plm_decode_video(plm_t *self); + +/** + * Decode and return one audio frame. Returns NULL if no frame could be decoded + * (either because the source ended or data is corrupt). If you only want to + * decode audio, you should disable video via plm_set_video_enabled(). + * The returned plm_samples_t is valid until the next call to + * plm_decode_video or until the plm_destroy is called. + */ +plm_samples_t *plm_decode_audio(plm_t *self); + +/* ----------------------------------------------------------------------------- + * plm_buffer public API + * Provides the data source for all other plm_* interfaces + * + * The default size for buffers created from files or by the high-level API + */ +#ifndef PLM_BUFFER_DEFAULT_SIZE +#define PLM_BUFFER_DEFAULT_SIZE (128 * 1024) +#endif + +/** + * Create a buffer instance with a filename. Returns NULL if the file could not + * be opened. + */ +plm_buffer_t *plm_buffer_create_with_filename(const char *filename); + +/** + * Create a buffer instance with file handle. Pass true to close_when_done + * to let plmpeg call fclose() on the handle when plm_destroy() is + * called. + */ +plm_buffer_t *plm_buffer_create_with_file(struct FILE *fh, int close_when_done); + +/** + * Create a buffer instance with a pointer to memory as source. This assumes + * the whole file is in memory. Pass 1 to free_when_done to let plmpeg call + * free() on the pointer when plm_destroy() is called. + */ +plm_buffer_t *plm_buffer_create_with_memory(uint8_t *bytes, size_t length, + int free_when_done); + +/** + * Create an empty buffer with an initial capacity. The buffer will grow + * as needed. + */ +plm_buffer_t *plm_buffer_create_with_capacity(size_t capacity); + +/** + * Destroy a buffer instance and free all data + */ +void plm_buffer_destroy(plm_buffer_t *self); + +/** + * Copy data into the buffer. If the data to be written is larger than the + * available space, the buffer will realloc() with a larger capacity. + * Returns the number of bytes written. This will always be the same as the + * passed in length, except when the buffer was created _with_memory() for + * which _write() is forbidden. + */ +size_t plm_buffer_write(plm_buffer_t *self, uint8_t *bytes, size_t length); + +/** + * Set a callback that is called whenever the buffer needs more data + */ +void plm_buffer_set_load_callback(plm_buffer_t *self, + plm_buffer_load_callback fp, void *user); + +/** + * Rewind the buffer back to the beginning. When loading from a file handle, + * this also seeks to the beginning of the file. + */ +void plm_buffer_rewind(plm_buffer_t *self); + +/** + * ----------------------------------------------------------------------------- + * plm_demux public API + * Demux an MPEG Program Stream (PS) data into separate packages + * + * Various Packet Types + */ +#define PLM_DEMUX_PACKET_PRIVATE 0xBD +#define PLM_DEMUX_PACKET_AUDIO_1 0xC0 +#define PLM_DEMUX_PACKET_AUDIO_2 0xC1 +#define PLM_DEMUX_PACKET_AUDIO_3 0xC2 +#define PLM_DEMUX_PACKET_AUDIO_4 0xC2 +#define PLM_DEMUX_PACKET_VIDEO_1 0xE0 + +/** + * Create a demuxer with a plm_buffer as source + */ +plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done); + +/** + * Destroy a demuxer and free all data + */ +void plm_demux_destroy(plm_demux_t *self); + +/** + * Returns the number of video streams found in the system header. + */ +int plm_demux_get_num_video_streams(plm_demux_t *self); + +/** + * Returns the number of audio streams found in the system header. + */ +int plm_demux_get_num_audio_streams(plm_demux_t *self); + +/** + * Rewinds the internal buffer. See plm_buffer_rewind(). + */ +void plm_demux_rewind(plm_demux_t *self); + +/** + * Decode and return the next packet. The returned packet_t is valid until + * the next call to plm_demux_decode() or until the demuxer is destroyed. + */ +plm_packet_t *plm_demux_decode(plm_demux_t *self); + +/* ----------------------------------------------------------------------------- + * plm_video public API + * Decode MPEG1 Video ("mpeg1") data into raw YCrCb frames + */ + +/** + * Create a video decoder with a plm_buffer as source + */ +plm_video_t *plm_video_create_with_buffer(plm_buffer_t *buffer, + int destroy_when_done); + +/** + * Destroy a video decoder and free all data + */ +void plm_video_destroy(plm_video_t *self); + +/** + * Get the framerate in frames per second + */ +double plm_video_get_framerate(plm_video_t *); + +double plm_video_get_pixel_aspect_ratio(plm_video_t *); + +/** + * Get the display width/height + */ +int plm_video_get_width(plm_video_t *); +int plm_video_get_height(plm_video_t *); + +/** + * Set "no delay" mode. When enabled, the decoder assumes that the video does + * *not* contain any B-Frames. This is useful for reducing lag when streaming. + */ +void plm_video_set_no_delay(plm_video_t *self, int no_delay); + +/** + * Get the current internal time in seconds + */ +double plm_video_get_time(plm_video_t *self); + +/** + * Rewinds the internal buffer. See plm_buffer_rewind(). + */ +void plm_video_rewind(plm_video_t *self); + +/** + * Decode and return one frame of video and advance the internal time by + * 1/framerate seconds. The returned frame_t is valid until the next call of + * plm_video_decode() or until the video decoder is destroyed. + */ +plm_frame_t *plm_video_decode(plm_video_t *self); + +/** + * Convert the YCrCb data of a frame into an interleaved RGB buffer. The buffer + * pointed to by *rgb must have a size of (frame->width * frame->height * 3) + * bytes. + */ +void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb); + +/* ----------------------------------------------------------------------------- + * plm_audio public API + * Decode MPEG-1 Audio Layer II ("mp2") data into raw samples + */ + +/** + * Create an audio decoder with a plm_buffer as source. + */ +plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, + int destroy_when_done); + +/** + * Destroy an audio decoder and free all data + */ +void plm_audio_destroy(plm_audio_t *self); + +/** + * Get the samplerate in samples per second + */ +int plm_audio_get_samplerate(plm_audio_t *self); + +/** + * Get the current internal time in seconds + */ +double plm_audio_get_time(plm_audio_t *self); + +/** + * Rewinds the internal buffer. See plm_buffer_rewind(). + */ +void plm_audio_rewind(plm_audio_t *self); + +/** + * Decode and return one "frame" of audio and advance the internal time by + * (PLM_AUDIO_SAMPLES_PER_FRAME/samplerate) seconds. The returned samples_t + * is valid until the next call of plm_audio_decode() or until the audio + * decoder is destroyed. + */ +plm_samples_t *plm_audio_decode(plm_audio_t *self); + +extern long plmpegdecode_latency_; + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_MPEG_H_ */ diff --git a/dsp/mpeg/mpeg.mk b/dsp/mpeg/mpeg.mk new file mode 100644 index 00000000..9d1f6f80 --- /dev/null +++ b/dsp/mpeg/mpeg.mk @@ -0,0 +1,69 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += DSP_MPEG + +DSP_MPEG_ARTIFACTS += DSP_MPEG_A +DSP_MPEG = $(DSP_MPEG_A_DEPS) $(DSP_MPEG_A) +DSP_MPEG_A = o/$(MODE)/dsp/mpeg/mpeg.a +DSP_MPEG_A_FILES := $(wildcard dsp/mpeg/*) +DSP_MPEG_A_HDRS = $(filter %.h,$(DSP_MPEG_A_FILES)) +DSP_MPEG_A_SRCS_S = $(filter %.S,$(DSP_MPEG_A_FILES)) +DSP_MPEG_A_SRCS_C = $(filter %.c,$(DSP_MPEG_A_FILES)) + +DSP_MPEG_A_SRCS = \ + $(DSP_MPEG_A_SRCS_S) \ + $(DSP_MPEG_A_SRCS_C) + +DSP_MPEG_A_OBJS = \ + $(DSP_MPEG_A_SRCS:%=o/$(MODE)/%.zip.o) \ + $(DSP_MPEG_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(DSP_MPEG_A_SRCS_C:%.c=o/$(MODE)/%.o) + +DSP_MPEG_A_CHECKS = \ + $(DSP_MPEG_A).pkg \ + $(DSP_MPEG_A_HDRS:%=o/$(MODE)/%.ok) + +DSP_MPEG_A_DIRECTDEPS = \ + LIBC_CALLS \ + LIBC_LOG \ + LIBC_RUNTIME \ + LIBC_TINYMATH \ + LIBC_TIME \ + LIBC_STUBS \ + LIBC_STR \ + LIBC_NEXGEN32E \ + LIBC_STDIO \ + LIBC_SYSV \ + LIBC_MEM \ + LIBC_LOG \ + LIBC_FMT \ + LIBC_UNICODE \ + +DSP_MPEG_A_DEPS := \ + $(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)))) + +$(DSP_MPEG_A): dsp/mpeg/ \ + $(DSP_MPEG_A).pkg \ + $(DSP_MPEG_A_OBJS) + +$(DSP_MPEG_A).pkg: \ + $(DSP_MPEG_A_OBJS) \ + $(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)_A).pkg) + +o/$(MODE)/dsp/mpeg/clamp4int256-k8.o: \ + OVERRIDE_CFLAGS += \ + -Os + +#o/$(MODE)/dsp/mpeg/macroblock.o: \ + CC = $(CLANG) + +DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x))) +DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS)) +DSP_MPEG_HDRS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_HDRS)) +DSP_MPEG_CHECKS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_CHECKS)) +DSP_MPEG_OBJS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_OBJS)) +$(DSP_MPEG_OBJS): $(BUILD_FILES) dsp/mpeg/mpeg.mk + +.PHONY: o/$(MODE)/dsp/mpeg +o/$(MODE)/dsp/mpeg: $(DSP_MPEG_CHECKS) diff --git a/dsp/mpeg/mpeg1.c b/dsp/mpeg/mpeg1.c new file mode 100644 index 00000000..fa708c19 --- /dev/null +++ b/dsp/mpeg/mpeg1.c @@ -0,0 +1,1115 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/blockset.h" +#include "dsp/mpeg/buffer.h" +#include "dsp/mpeg/idct.h" +#include "dsp/mpeg/mpeg.h" +#include "dsp/mpeg/video.h" +#include "libc/conv/conv.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/mem/mem.h" +#include "libc/str/str.h" +#include "libc/time/time.h" +#include "libc/x/x.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +// ----------------------------------------------------------------------------- +// plm_video implementation + +// Inspired by Java MPEG-1 Video Decoder and Player by Zoltan Korandi +// https://sourceforge.net/projects/javampeg1video/ + +#define GETCONST(ARRAY, DEFAULT) + +static const int PLM_VIDEO_PICTURE_TYPE_INTRA = 1; +static const int PLM_VIDEO_PICTURE_TYPE_PREDICTIVE = 2; +static const int PLM_VIDEO_PICTURE_TYPE_B = 3; + +static const int PLM_START_SEQUENCE = 0xB3; +static const int PLM_START_SLICE_FIRST = 0x01; +static const int PLM_START_SLICE_LAST = 0xAF; +static const int PLM_START_PICTURE = 0x00; +static const int PLM_START_EXTENSION = 0xB5; +static const int PLM_START_USER_DATA = 0xB2; + +static const float PLM_VIDEO_PIXEL_ASPECT_RATIO[] = { + 1.0000, /* square pixels */ + 0.6735, /* 3:4? */ + 0.7031, /* MPEG-1 / MPEG-2 video encoding divergence? */ + 0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815, + 1.0255, 1.0695, 1.0950, 1.1575, 1.2051}; + +static const float PLM_VIDEO_PICTURE_RATE[] = { + 23.976, /* NTSC-Film */ + 24.000, /* NTSC-Film (enriched for foreign nations) */ + 25.000, /* PAL (Britain, Africa, China, etc.) */ + 29.970, /* NTSC */ + 30.000, /* NTSC (enriched for foreign nations) */ + 50.000, /* PAL? */ + 59.940, /* NTSC-Wow */ + 60.000 /* NTSC-Wow (enriched for foreign nations) */ +}; + +static const uint8_t PLM_VIDEO_ZIG_ZAG[] = /* clang-format off */ { + 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, +} /* clang-format on */; + +static const uint8_t PLM_VIDEO_INTRAQUANT_MATRIX[] = /* clang-format off */ { + 8, 16, 19, 22, 26, 27, 29, 34, + 16, 16, 22, 24, 27, 29, 34, 37, + 19, 22, 26, 27, 29, 34, 34, 38, + 22, 22, 26, 27, 29, 34, 37, 40, + 22, 26, 27, 29, 32, 35, 40, 48, + 26, 27, 29, 32, 35, 40, 48, 58, + 26, 27, 29, 34, 38, 46, 56, 69, + 27, 29, 35, 38, 46, 56, 69, 83, +} /* clang-format on */; + +static const uint8_t PLM_VIDEO_NONINTRAQUANT_MATRIX[] = /* clang-format off */ { + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, +} /* clang-format on */; + +static const uint8_t PLM_VIDEO_PREMULTIPLIER_MATRIX[] = /* clang-format off */ { + 32, 44, 42, 38, 32, 25, 17, 9, + 44, 62, 58, 52, 44, 35, 24, 12, + 42, 58, 55, 49, 42, 33, 23, 12, + 38, 52, 49, 44, 38, 30, 20, 10, + 32, 44, 42, 38, 32, 25, 17, 9, + 25, 35, 33, 30, 25, 20, 14, 7, + 17, 24, 23, 20, 17, 14, 9, 5, + 9, 12, 12, 10, 9, 7, 5, 2, +} /* clang-format on */; + +static const plm_vlc_t PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT[] = { + {1 << 1, 0}, {0, 1}, // 0: x + {2 << 1, 0}, {3 << 1, 0}, // 1: 0x + {4 << 1, 0}, {5 << 1, 0}, // 2: 00x + {0, 3}, {0, 2}, // 3: 01x + {6 << 1, 0}, {7 << 1, 0}, // 4: 000x + {0, 5}, {0, 4}, // 5: 001x + {8 << 1, 0}, {9 << 1, 0}, // 6: 0000x + {0, 7}, {0, 6}, // 7: 0001x + {10 << 1, 0}, {11 << 1, 0}, // 8: 0000 0x + {12 << 1, 0}, {13 << 1, 0}, // 9: 0000 1x + {14 << 1, 0}, {15 << 1, 0}, // 10: 0000 00x + {16 << 1, 0}, {17 << 1, 0}, // 11: 0000 01x + {18 << 1, 0}, {19 << 1, 0}, // 12: 0000 10x + {0, 9}, {0, 8}, // 13: 0000 11x + {-1, 0}, {20 << 1, 0}, // 14: 0000 000x + {-1, 0}, {21 << 1, 0}, // 15: 0000 001x + {22 << 1, 0}, {23 << 1, 0}, // 16: 0000 010x + {0, 15}, {0, 14}, // 17: 0000 011x + {0, 13}, {0, 12}, // 18: 0000 100x + {0, 11}, {0, 10}, // 19: 0000 101x + {24 << 1, 0}, {25 << 1, 0}, // 20: 0000 0001x + {26 << 1, 0}, {27 << 1, 0}, // 21: 0000 0011x + {28 << 1, 0}, {29 << 1, 0}, // 22: 0000 0100x + {30 << 1, 0}, {31 << 1, 0}, // 23: 0000 0101x + {32 << 1, 0}, {-1, 0}, // 24: 0000 0001 0x + {-1, 0}, {33 << 1, 0}, // 25: 0000 0001 1x + {34 << 1, 0}, {35 << 1, 0}, // 26: 0000 0011 0x + {36 << 1, 0}, {37 << 1, 0}, // 27: 0000 0011 1x + {38 << 1, 0}, {39 << 1, 0}, // 28: 0000 0100 0x + {0, 21}, {0, 20}, // 29: 0000 0100 1x + {0, 19}, {0, 18}, // 30: 0000 0101 0x + {0, 17}, {0, 16}, // 31: 0000 0101 1x + {0, 35}, {-1, 0}, // 32: 0000 0001 00x + {-1, 0}, {0, 34}, // 33: 0000 0001 11x + {0, 33}, {0, 32}, // 34: 0000 0011 00x + {0, 31}, {0, 30}, // 35: 0000 0011 01x + {0, 29}, {0, 28}, // 36: 0000 0011 10x + {0, 27}, {0, 26}, // 37: 0000 0011 11x + {0, 25}, {0, 24}, // 38: 0000 0100 00x + {0, 23}, {0, 22}, // 39: 0000 0100 01x +}; + +static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_INTRA[] = { + {1 << 1, 0}, + {0, 0x01}, // 0: x + {-1, 0}, + {0, 0x11}, // 1: 0x +}; + +static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE[] = { + {1 << 1, 0}, {0, 0x0a}, // 0: x + {2 << 1, 0}, {0, 0x02}, // 1: 0x + {3 << 1, 0}, {0, 0x08}, // 2: 00x + {4 << 1, 0}, {5 << 1, 0}, // 3: 000x + {6 << 1, 0}, {0, 0x12}, // 4: 0000x + {0, 0x1a}, {0, 0x01}, // 5: 0001x + {-1, 0}, {0, 0x11}, // 6: 0000 0x +}; + +static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_B[] = { + {1 << 1, 0}, {2 << 1, 0}, // 0: x + {3 << 1, 0}, {4 << 1, 0}, // 1: 0x + {0, 0x0c}, {0, 0x0e}, // 2: 1x + {5 << 1, 0}, {6 << 1, 0}, // 3: 00x + {0, 0x04}, {0, 0x06}, // 4: 01x + {7 << 1, 0}, {8 << 1, 0}, // 5: 000x + {0, 0x08}, {0, 0x0a}, // 6: 001x + {9 << 1, 0}, {10 << 1, 0}, // 7: 0000x + {0, 0x1e}, {0, 0x01}, // 8: 0001x + {-1, 0}, {0, 0x11}, // 9: 0000 0x + {0, 0x16}, {0, 0x1a}, // 10: 0000 1x +}; + +static const plm_vlc_t PLM_VIDEO_CODE_BLOCK_PATTERN[] = { + {1 << 1, 0}, {2 << 1, 0}, // 0: x + {3 << 1, 0}, {4 << 1, 0}, // 1: 0x + {5 << 1, 0}, {6 << 1, 0}, // 2: 1x + {7 << 1, 0}, {8 << 1, 0}, // 3: 00x + {9 << 1, 0}, {10 << 1, 0}, // 4: 01x + {11 << 1, 0}, {12 << 1, 0}, // 5: 10x + {13 << 1, 0}, {0, 60}, // 6: 11x + {14 << 1, 0}, {15 << 1, 0}, // 7: 000x + {16 << 1, 0}, {17 << 1, 0}, // 8: 001x + {18 << 1, 0}, {19 << 1, 0}, // 9: 010x + {20 << 1, 0}, {21 << 1, 0}, // 10: 011x + {22 << 1, 0}, {23 << 1, 0}, // 11: 100x + {0, 32}, {0, 16}, // 12: 101x + {0, 8}, {0, 4}, // 13: 110x + {24 << 1, 0}, {25 << 1, 0}, // 14: 0000x + {26 << 1, 0}, {27 << 1, 0}, // 15: 0001x + {28 << 1, 0}, {29 << 1, 0}, // 16: 0010x + {30 << 1, 0}, {31 << 1, 0}, // 17: 0011x + {0, 62}, {0, 2}, // 18: 0100x + {0, 61}, {0, 1}, // 19: 0101x + {0, 56}, {0, 52}, // 20: 0110x + {0, 44}, {0, 28}, // 21: 0111x + {0, 40}, {0, 20}, // 22: 1000x + {0, 48}, {0, 12}, // 23: 1001x + {32 << 1, 0}, {33 << 1, 0}, // 24: 0000 0x + {34 << 1, 0}, {35 << 1, 0}, // 25: 0000 1x + {36 << 1, 0}, {37 << 1, 0}, // 26: 0001 0x + {38 << 1, 0}, {39 << 1, 0}, // 27: 0001 1x + {40 << 1, 0}, {41 << 1, 0}, // 28: 0010 0x + {42 << 1, 0}, {43 << 1, 0}, // 29: 0010 1x + {0, 63}, {0, 3}, // 30: 0011 0x + {0, 36}, {0, 24}, // 31: 0011 1x + {44 << 1, 0}, {45 << 1, 0}, // 32: 0000 00x + {46 << 1, 0}, {47 << 1, 0}, // 33: 0000 01x + {48 << 1, 0}, {49 << 1, 0}, // 34: 0000 10x + {50 << 1, 0}, {51 << 1, 0}, // 35: 0000 11x + {52 << 1, 0}, {53 << 1, 0}, // 36: 0001 00x + {54 << 1, 0}, {55 << 1, 0}, // 37: 0001 01x + {56 << 1, 0}, {57 << 1, 0}, // 38: 0001 10x + {58 << 1, 0}, {59 << 1, 0}, // 39: 0001 11x + {0, 34}, {0, 18}, // 40: 0010 00x + {0, 10}, {0, 6}, // 41: 0010 01x + {0, 33}, {0, 17}, // 42: 0010 10x + {0, 9}, {0, 5}, // 43: 0010 11x + {-1, 0}, {60 << 1, 0}, // 44: 0000 000x + {61 << 1, 0}, {62 << 1, 0}, // 45: 0000 001x + {0, 58}, {0, 54}, // 46: 0000 010x + {0, 46}, {0, 30}, // 47: 0000 011x + {0, 57}, {0, 53}, // 48: 0000 100x + {0, 45}, {0, 29}, // 49: 0000 101x + {0, 38}, {0, 26}, // 50: 0000 110x + {0, 37}, {0, 25}, // 51: 0000 111x + {0, 43}, {0, 23}, // 52: 0001 000x + {0, 51}, {0, 15}, // 53: 0001 001x + {0, 42}, {0, 22}, // 54: 0001 010x + {0, 50}, {0, 14}, // 55: 0001 011x + {0, 41}, {0, 21}, // 56: 0001 100x + {0, 49}, {0, 13}, // 57: 0001 101x + {0, 35}, {0, 19}, // 58: 0001 110x + {0, 11}, {0, 7}, // 59: 0001 111x + {0, 39}, {0, 27}, // 60: 0000 0001x + {0, 59}, {0, 55}, // 61: 0000 0010x + {0, 47}, {0, 31}, // 62: 0000 0011x +}; + +static const plm_vlc_t PLM_VIDEO_MOTION[] = { + {1 << 1, 0}, {0, 0}, // 0: x + {2 << 1, 0}, {3 << 1, 0}, // 1: 0x + {4 << 1, 0}, {5 << 1, 0}, // 2: 00x + {0, 1}, {0, -1}, // 3: 01x + {6 << 1, 0}, {7 << 1, 0}, // 4: 000x + {0, 2}, {0, -2}, // 5: 001x + {8 << 1, 0}, {9 << 1, 0}, // 6: 0000x + {0, 3}, {0, -3}, // 7: 0001x + {10 << 1, 0}, {11 << 1, 0}, // 8: 0000 0x + {12 << 1, 0}, {13 << 1, 0}, // 9: 0000 1x + {-1, 0}, {14 << 1, 0}, // 10: 0000 00x + {15 << 1, 0}, {16 << 1, 0}, // 11: 0000 01x + {17 << 1, 0}, {18 << 1, 0}, // 12: 0000 10x + {0, 4}, {0, -4}, // 13: 0000 11x + {-1, 0}, {19 << 1, 0}, // 14: 0000 001x + {20 << 1, 0}, {21 << 1, 0}, // 15: 0000 010x + {0, 7}, {0, -7}, // 16: 0000 011x + {0, 6}, {0, -6}, // 17: 0000 100x + {0, 5}, {0, -5}, // 18: 0000 101x + {22 << 1, 0}, {23 << 1, 0}, // 19: 0000 0011x + {24 << 1, 0}, {25 << 1, 0}, // 20: 0000 0100x + {26 << 1, 0}, {27 << 1, 0}, // 21: 0000 0101x + {28 << 1, 0}, {29 << 1, 0}, // 22: 0000 0011 0x + {30 << 1, 0}, {31 << 1, 0}, // 23: 0000 0011 1x + {32 << 1, 0}, {33 << 1, 0}, // 24: 0000 0100 0x + {0, 10}, {0, -10}, // 25: 0000 0100 1x + {0, 9}, {0, -9}, // 26: 0000 0101 0x + {0, 8}, {0, -8}, // 27: 0000 0101 1x + {0, 16}, {0, -16}, // 28: 0000 0011 00x + {0, 15}, {0, -15}, // 29: 0000 0011 01x + {0, 14}, {0, -14}, // 30: 0000 0011 10x + {0, 13}, {0, -13}, // 31: 0000 0011 11x + {0, 12}, {0, -12}, // 32: 0000 0100 00x + {0, 11}, {0, -11}, // 33: 0000 0100 01x +}; + +static const plm_vlc_t PLM_VIDEO_DCT_SIZE_LUMINANCE[] = { + {1 << 1, 0}, {2 << 1, 0}, // 0: x + {0, 1}, {0, 2}, // 1: 0x + {3 << 1, 0}, {4 << 1, 0}, // 2: 1x + {0, 0}, {0, 3}, // 3: 10x + {0, 4}, {5 << 1, 0}, // 4: 11x + {0, 5}, {6 << 1, 0}, // 5: 111x + {0, 6}, {7 << 1, 0}, // 6: 1111x + {0, 7}, {8 << 1, 0}, // 7: 1111 1x + {0, 8}, {-1, 0}, // 8: 1111 11x +}; + +static const plm_vlc_t PLM_VIDEO_DCT_SIZE_CHROMINANCE[] = { + {1 << 1, 0}, {2 << 1, 0}, // 0: x + {0, 0}, {0, 1}, // 1: 0x + {0, 2}, {3 << 1, 0}, // 2: 1x + {0, 3}, {4 << 1, 0}, // 3: 11x + {0, 4}, {5 << 1, 0}, // 4: 111x + {0, 5}, {6 << 1, 0}, // 5: 1111x + {0, 6}, {7 << 1, 0}, // 6: 1111 1x + {0, 7}, {8 << 1, 0}, // 7: 1111 11x + {0, 8}, {-1, 0}, // 8: 1111 111x +}; + +// dct_coeff bitmap: +// 0xff00 run +// 0x00ff level + +// Decoded values are unsigned. Sign bit follows in the stream. + +static const plm_vlc_uint_t PLM_VIDEO_DCT_COEFF[] = { + {1 << 1, 0}, {0, 0x0001}, // 0: x + {2 << 1, 0}, {3 << 1, 0}, // 1: 0x + {4 << 1, 0}, {5 << 1, 0}, // 2: 00x + {6 << 1, 0}, {0, 0x0101}, // 3: 01x + {7 << 1, 0}, {8 << 1, 0}, // 4: 000x + {9 << 1, 0}, {10 << 1, 0}, // 5: 001x + {0, 0x0002}, {0, 0x0201}, // 6: 010x + {11 << 1, 0}, {12 << 1, 0}, // 7: 0000x + {13 << 1, 0}, {14 << 1, 0}, // 8: 0001x + {15 << 1, 0}, {0, 0x0003}, // 9: 0010x + {0, 0x0401}, {0, 0x0301}, // 10: 0011x + {16 << 1, 0}, {0, 0xffff}, // 11: 0000 0x + {17 << 1, 0}, {18 << 1, 0}, // 12: 0000 1x + {0, 0x0701}, {0, 0x0601}, // 13: 0001 0x + {0, 0x0102}, {0, 0x0501}, // 14: 0001 1x + {19 << 1, 0}, {20 << 1, 0}, // 15: 0010 0x + {21 << 1, 0}, {22 << 1, 0}, // 16: 0000 00x + {0, 0x0202}, {0, 0x0901}, // 17: 0000 10x + {0, 0x0004}, {0, 0x0801}, // 18: 0000 11x + {23 << 1, 0}, {24 << 1, 0}, // 19: 0010 00x + {25 << 1, 0}, {26 << 1, 0}, // 20: 0010 01x + {27 << 1, 0}, {28 << 1, 0}, // 21: 0000 000x + {29 << 1, 0}, {30 << 1, 0}, // 22: 0000 001x + {0, 0x0d01}, {0, 0x0006}, // 23: 0010 000x + {0, 0x0c01}, {0, 0x0b01}, // 24: 0010 001x + {0, 0x0302}, {0, 0x0103}, // 25: 0010 010x + {0, 0x0005}, {0, 0x0a01}, // 26: 0010 011x + {31 << 1, 0}, {32 << 1, 0}, // 27: 0000 0000x + {33 << 1, 0}, {34 << 1, 0}, // 28: 0000 0001x + {35 << 1, 0}, {36 << 1, 0}, // 29: 0000 0010x + {37 << 1, 0}, {38 << 1, 0}, // 30: 0000 0011x + {39 << 1, 0}, {40 << 1, 0}, // 31: 0000 0000 0x + {41 << 1, 0}, {42 << 1, 0}, // 32: 0000 0000 1x + {43 << 1, 0}, {44 << 1, 0}, // 33: 0000 0001 0x + {45 << 1, 0}, {46 << 1, 0}, // 34: 0000 0001 1x + {0, 0x1001}, {0, 0x0502}, // 35: 0000 0010 0x + {0, 0x0007}, {0, 0x0203}, // 36: 0000 0010 1x + {0, 0x0104}, {0, 0x0f01}, // 37: 0000 0011 0x + {0, 0x0e01}, {0, 0x0402}, // 38: 0000 0011 1x + {47 << 1, 0}, {48 << 1, 0}, // 39: 0000 0000 00x + {49 << 1, 0}, {50 << 1, 0}, // 40: 0000 0000 01x + {51 << 1, 0}, {52 << 1, 0}, // 41: 0000 0000 10x + {53 << 1, 0}, {54 << 1, 0}, // 42: 0000 0000 11x + {55 << 1, 0}, {56 << 1, 0}, // 43: 0000 0001 00x + {57 << 1, 0}, {58 << 1, 0}, // 44: 0000 0001 01x + {59 << 1, 0}, {60 << 1, 0}, // 45: 0000 0001 10x + {61 << 1, 0}, {62 << 1, 0}, // 46: 0000 0001 11x + {-1, 0}, {63 << 1, 0}, // 47: 0000 0000 000x + {64 << 1, 0}, {65 << 1, 0}, // 48: 0000 0000 001x + {66 << 1, 0}, {67 << 1, 0}, // 49: 0000 0000 010x + {68 << 1, 0}, {69 << 1, 0}, // 50: 0000 0000 011x + {70 << 1, 0}, {71 << 1, 0}, // 51: 0000 0000 100x + {72 << 1, 0}, {73 << 1, 0}, // 52: 0000 0000 101x + {74 << 1, 0}, {75 << 1, 0}, // 53: 0000 0000 110x + {76 << 1, 0}, {77 << 1, 0}, // 54: 0000 0000 111x + {0, 0x000b}, {0, 0x0802}, // 55: 0000 0001 000x + {0, 0x0403}, {0, 0x000a}, // 56: 0000 0001 001x + {0, 0x0204}, {0, 0x0702}, // 57: 0000 0001 010x + {0, 0x1501}, {0, 0x1401}, // 58: 0000 0001 011x + {0, 0x0009}, {0, 0x1301}, // 59: 0000 0001 100x + {0, 0x1201}, {0, 0x0105}, // 60: 0000 0001 101x + {0, 0x0303}, {0, 0x0008}, // 61: 0000 0001 110x + {0, 0x0602}, {0, 0x1101}, // 62: 0000 0001 111x + {78 << 1, 0}, {79 << 1, 0}, // 63: 0000 0000 0001x + {80 << 1, 0}, {81 << 1, 0}, // 64: 0000 0000 0010x + {82 << 1, 0}, {83 << 1, 0}, // 65: 0000 0000 0011x + {84 << 1, 0}, {85 << 1, 0}, // 66: 0000 0000 0100x + {86 << 1, 0}, {87 << 1, 0}, // 67: 0000 0000 0101x + {88 << 1, 0}, {89 << 1, 0}, // 68: 0000 0000 0110x + {90 << 1, 0}, {91 << 1, 0}, // 69: 0000 0000 0111x + {0, 0x0a02}, {0, 0x0902}, // 70: 0000 0000 1000x + {0, 0x0503}, {0, 0x0304}, // 71: 0000 0000 1001x + {0, 0x0205}, {0, 0x0107}, // 72: 0000 0000 1010x + {0, 0x0106}, {0, 0x000f}, // 73: 0000 0000 1011x + {0, 0x000e}, {0, 0x000d}, // 74: 0000 0000 1100x + {0, 0x000c}, {0, 0x1a01}, // 75: 0000 0000 1101x + {0, 0x1901}, {0, 0x1801}, // 76: 0000 0000 1110x + {0, 0x1701}, {0, 0x1601}, // 77: 0000 0000 1111x + {92 << 1, 0}, {93 << 1, 0}, // 78: 0000 0000 0001 0x + {94 << 1, 0}, {95 << 1, 0}, // 79: 0000 0000 0001 1x + {96 << 1, 0}, {97 << 1, 0}, // 80: 0000 0000 0010 0x + {98 << 1, 0}, {99 << 1, 0}, // 81: 0000 0000 0010 1x + {100 << 1, 0}, {101 << 1, 0}, // 82: 0000 0000 0011 0x + {102 << 1, 0}, {103 << 1, 0}, // 83: 0000 0000 0011 1x + {0, 0x001f}, {0, 0x001e}, // 84: 0000 0000 0100 0x + {0, 0x001d}, {0, 0x001c}, // 85: 0000 0000 0100 1x + {0, 0x001b}, {0, 0x001a}, // 86: 0000 0000 0101 0x + {0, 0x0019}, {0, 0x0018}, // 87: 0000 0000 0101 1x + {0, 0x0017}, {0, 0x0016}, // 88: 0000 0000 0110 0x + {0, 0x0015}, {0, 0x0014}, // 89: 0000 0000 0110 1x + {0, 0x0013}, {0, 0x0012}, // 90: 0000 0000 0111 0x + {0, 0x0011}, {0, 0x0010}, // 91: 0000 0000 0111 1x + {104 << 1, 0}, {105 << 1, 0}, // 92: 0000 0000 0001 00x + {106 << 1, 0}, {107 << 1, 0}, // 93: 0000 0000 0001 01x + {108 << 1, 0}, {109 << 1, 0}, // 94: 0000 0000 0001 10x + {110 << 1, 0}, {111 << 1, 0}, // 95: 0000 0000 0001 11x + {0, 0x0028}, {0, 0x0027}, // 96: 0000 0000 0010 00x + {0, 0x0026}, {0, 0x0025}, // 97: 0000 0000 0010 01x + {0, 0x0024}, {0, 0x0023}, // 98: 0000 0000 0010 10x + {0, 0x0022}, {0, 0x0021}, // 99: 0000 0000 0010 11x + {0, 0x0020}, {0, 0x010e}, // 100: 0000 0000 0011 00x + {0, 0x010d}, {0, 0x010c}, // 101: 0000 0000 0011 01x + {0, 0x010b}, {0, 0x010a}, // 102: 0000 0000 0011 10x + {0, 0x0109}, {0, 0x0108}, // 103: 0000 0000 0011 11x + {0, 0x0112}, {0, 0x0111}, // 104: 0000 0000 0001 000x + {0, 0x0110}, {0, 0x010f}, // 105: 0000 0000 0001 001x + {0, 0x0603}, {0, 0x1002}, // 106: 0000 0000 0001 010x + {0, 0x0f02}, {0, 0x0e02}, // 107: 0000 0000 0001 011x + {0, 0x0d02}, {0, 0x0c02}, // 108: 0000 0000 0001 100x + {0, 0x0b02}, {0, 0x1f01}, // 109: 0000 0000 0001 101x + {0, 0x1e01}, {0, 0x1d01}, // 110: 0000 0000 0001 110x + {0, 0x1c01}, {0, 0x1b01}, // 111: 0000 0000 0001 111x +}; + +long plmpegdecode_latency_; + +static plm_vlc_t *PLM_VIDEO_MACROBLOCK_TYPE[4]; +static plm_vlc_t *PLM_VIDEO_DCT_SIZE[3]; + +static textstartup void __init_mpeg1(void) { + PLM_VIDEO_MACROBLOCK_TYPE[0] = NULL; + PLM_VIDEO_MACROBLOCK_TYPE[1] = PLM_VIDEO_MACROBLOCK_TYPE_INTRA; + PLM_VIDEO_MACROBLOCK_TYPE[2] = PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE, + PLM_VIDEO_MACROBLOCK_TYPE[3] = PLM_VIDEO_MACROBLOCK_TYPE_B; + PLM_VIDEO_DCT_SIZE[0] = PLM_VIDEO_DCT_SIZE_LUMINANCE; + PLM_VIDEO_DCT_SIZE[1] = PLM_VIDEO_DCT_SIZE_CHROMINANCE; + PLM_VIDEO_DCT_SIZE[2] = PLM_VIDEO_DCT_SIZE_CHROMINANCE; +} + +INITIALIZER(300, _init_mpeg1, __init_mpeg1()); + +#define plm_clamp(n) MIN(255, MAX(0, n)) + +void plm_video_destroy(plm_video_t *self) { + if (self->destroy_buffer_when_done) { + plm_buffer_destroy(self->buffer); + } + if (self->has_sequence_header) { + free(self->frames_data); + } + free(self); +} + +double plm_video_get_pixel_aspect_ratio(plm_video_t *self) { + return self->pixel_aspect_ratio; +} + +double plm_video_get_framerate(plm_video_t *self) { + return self->framerate; +} + +int plm_video_get_width(plm_video_t *self) { + return self->width; +} + +int plm_video_get_height(plm_video_t *self) { + return self->height; +} + +void plm_video_set_no_delay(plm_video_t *self, int no_delay) { + self->assume_no_b_frames = no_delay; +} + +double plm_video_get_time(plm_video_t *self) { + return self->time; +} + +void plm_video_rewind(plm_video_t *self) { + plm_buffer_rewind(self->buffer); + self->time = 0; + self->frames_decoded = 0; + self->has_reference_frame = false; +} + +void plm_video_init_frame(plm_video_t *self, plm_frame_t *frame, + uint8_t *base) { + size_t plane_size = self->luma_width * self->luma_height; + frame->width = self->width; + frame->height = self->height; + frame->y.width = self->luma_width; + frame->y.height = self->luma_height; + frame->y.data = base; + frame->cr.width = self->chroma_width; + frame->cr.height = self->chroma_height; + frame->cr.data = base + plane_size; + frame->cb.width = self->chroma_width; + frame->cb.height = self->chroma_height; + frame->cb.data = base + plane_size * 2; +} + +void plm_video_decode_sequence_header(plm_video_t *self) { + int previous_width = self->width; + int previous_height = self->height; + + self->width = plm_buffer_read(self->buffer, 12); + self->height = plm_buffer_read(self->buffer, 12); + + int pixel_aspect_ratio_code; + pixel_aspect_ratio_code = plm_buffer_read(self->buffer, 4); + pixel_aspect_ratio_code -= 1; + pixel_aspect_ratio_code = MAX(pixel_aspect_ratio_code, 0); + pixel_aspect_ratio_code = + MIN(pixel_aspect_ratio_code, ARRAYLEN(PLM_VIDEO_PIXEL_ASPECT_RATIO) - 1); + self->pixel_aspect_ratio = + PLM_VIDEO_PIXEL_ASPECT_RATIO[pixel_aspect_ratio_code]; + + int framerate_code; + framerate_code = plm_buffer_read(self->buffer, 4); + framerate_code -= 1; + framerate_code = MAX(framerate_code, 0); + framerate_code = MIN(framerate_code, ARRAYLEN(PLM_VIDEO_PICTURE_RATE) - 1); + self->framerate = PLM_VIDEO_PICTURE_RATE[framerate_code]; + + // skip bitRate, marker, bufferSize and constrained bit + plm_buffer_skip(self->buffer, 18 + 1 + 10 + 1); + + if (plm_buffer_read(self->buffer, 1)) { // load custom intra quant matrix? + for (int i = 0; i < 64; i++) { + int idx = PLM_VIDEO_ZIG_ZAG[i]; + self->intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8); + } + } else { + memcpy(self->intra_quant_matrix, PLM_VIDEO_INTRAQUANT_MATRIX, 64); + } + + if (plm_buffer_read(self->buffer, + 1)) { // load custom non intra quant matrix? + for (int i = 0; i < 64; i++) { + int idx = PLM_VIDEO_ZIG_ZAG[i]; + self->non_intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8); + } + } else { + memcpy(self->non_intra_quant_matrix, PLM_VIDEO_NONINTRAQUANT_MATRIX, 64); + } + + if (self->has_sequence_header) { + if (self->width == previous_width && self->height == previous_height) { + // We already had a sequence header with the same width/height; + // nothing else to do here. + return; + } + + // We had a sequence header but with different dimensions; + // delete the previous planes and allocate new. + free(self->frames_data); + } + + self->mb_width = (self->width + 15) >> 4; + self->mb_height = (self->height + 15) >> 4; + self->mb_size = self->mb_width * self->mb_height; + self->luma_width = self->mb_width << 4; + self->luma_height = self->mb_height << 4; + self->chroma_width = self->mb_width << 3; + self->chroma_height = self->mb_height << 3; + + size_t plane_size = self->luma_width * self->luma_height; + self->frames_data = memalign(64, plane_size * 9); + plm_video_init_frame(self, &self->frame_current, + self->frames_data + plane_size * 0); + plm_video_init_frame(self, &self->frame_forward, + self->frames_data + plane_size * 3); + plm_video_init_frame(self, &self->frame_backward, + self->frames_data + plane_size * 6); + + self->has_sequence_header = true; + + LOGF("%s:\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15f;\n" + "\t%-20s = %15f;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;\n" + "\t%-20s = %15d;", + "New MPEG Sequence", "width", self->width, "height", self->height, + "framerate", self->framerate, "pixel_aspect_ratio", + self->pixel_aspect_ratio, "mb_size", self->mb_size, "mb_width", + self->mb_width, "mb_height", self->mb_height, "luma_width", + self->luma_width, "luma_height", self->luma_height, "chroma_width", + self->chroma_width, "chroma_height", self->chroma_height); +} + +static void plm_video_copy_macroblock(plm_video_t *self, int motion_h, + int motion_v, plm_frame_t *d) { + plm_frame_t *s = &self->frame_current; + plm_video_process_macroblock_16(self, s->y.data, d->y.data, motion_h, + motion_v, false); + plm_video_process_macroblock_8(self, s->cr.data, d->cr.data, motion_h / 2, + motion_v / 2, false); + plm_video_process_macroblock_8(self, s->cb.data, d->cb.data, motion_h / 2, + motion_v / 2, false); +} + +static void plm_video_interpolate_macroblock(plm_video_t *self, int motion_h, + int motion_v, plm_frame_t *d) { + plm_frame_t *s = &self->frame_current; + plm_video_process_macroblock_16(self, s->y.data, d->y.data, motion_h, + motion_v, true); + plm_video_process_macroblock_8(self, s->cr.data, d->cr.data, motion_h / 2, + motion_v / 2, true); + plm_video_process_macroblock_8(self, s->cb.data, d->cb.data, motion_h / 2, + motion_v / 2, true); +} + +static int plm_video_decode_motion_vector(plm_video_t *self, int r_size, + int motion) { + int fscale = 1u << r_size; + int m_code = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MOTION); + int r = 0; + int d; + if ((m_code != 0) && (fscale != 1)) { + r = plm_buffer_read(self->buffer, r_size); + d = ((abs(m_code) - 1) << r_size) + r + 1; + if (m_code < 0) { + d = -d; + } + } else { + d = m_code; + } + motion += d; + if (motion > (fscale << 4) - 1) { + motion -= fscale << 5; + } else if (motion < (int)(((unsigned)-fscale) << 4)) { + motion += fscale << 5; + } + return motion; +} + +static void plm_video_decode_motion_vectors(plm_video_t *self) { + // Forward + if (self->motion_forward.is_set) { + int r_size = self->motion_forward.r_size; + self->motion_forward.h = + plm_video_decode_motion_vector(self, r_size, self->motion_forward.h); + self->motion_forward.v = + plm_video_decode_motion_vector(self, r_size, self->motion_forward.v); + } else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) { + // No motion information in P-picture, reset vectors + self->motion_forward.h = 0; + self->motion_forward.v = 0; + } + if (self->motion_backward.is_set) { + int r_size = self->motion_backward.r_size; + self->motion_backward.h = + plm_video_decode_motion_vector(self, r_size, self->motion_backward.h); + self->motion_backward.v = + plm_video_decode_motion_vector(self, r_size, self->motion_backward.v); + } +} + +static void plm_video_predict_macroblock(plm_video_t *self) { + int fw_h = self->motion_forward.h; + int fw_v = self->motion_forward.v; + if (self->motion_forward.full_px) { + fw_h <<= 1; + fw_v <<= 1; + } + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) { + int bw_h = self->motion_backward.h; + int bw_v = self->motion_backward.v; + if (self->motion_backward.full_px) { + bw_h <<= 1; + bw_v <<= 1; + } + if (self->motion_forward.is_set) { + plm_video_copy_macroblock(self, fw_h, fw_v, &self->frame_forward); + if (self->motion_backward.is_set) { + plm_video_interpolate_macroblock(self, bw_h, bw_v, + &self->frame_backward); + } + } else { + plm_video_copy_macroblock(self, bw_h, bw_v, &self->frame_backward); + } + } else { + plm_video_copy_macroblock(self, fw_h, fw_v, &self->frame_forward); + } +} + +static void plm_video_decode_block(plm_video_t *self, int block) { + int n = 0; + uint8_t *quant_matrix; + + // Decode DC coefficient of intra-coded blocks + if (self->macroblock_intra) { + int predictor; + int dct_size; + + // DC prediction + int plane_index = block > 3 ? block - 3 : 0; + predictor = self->dc_predictor[plane_index]; + dct_size = + plm_buffer_read_vlc(self->buffer, PLM_VIDEO_DCT_SIZE[plane_index]); + + // Read DC coeff + if (dct_size > 0) { + int differential = plm_buffer_read(self->buffer, dct_size); + if ((differential & (1 << (dct_size - 1))) != 0) { + self->block_data[0] = predictor + differential; + } else { + self->block_data[0] = + predictor + ((-1u << dct_size) | (differential + 1)); + } + } else { + self->block_data[0] = predictor; + } + + // Save predictor value + self->dc_predictor[plane_index] = self->block_data[0]; + + // Dequantize + premultiply + self->block_data[0] <<= (3 + 5); + + quant_matrix = self->intra_quant_matrix; + n = 1; + } else { + quant_matrix = self->non_intra_quant_matrix; + } + + // Decode AC coefficients (+DC for non-intra) + int level = 0; + while (true) { + int run = 0; + uint16_t coeff = + plm_buffer_read_vlc_uint(self->buffer, PLM_VIDEO_DCT_COEFF); + + if ((coeff == 0x0001) && (n > 0) && + (plm_buffer_read(self->buffer, 1) == 0)) { + // end_of_block + break; + } + if (coeff == 0xffff) { + // escape + run = plm_buffer_read(self->buffer, 6); + level = plm_buffer_read(self->buffer, 8); + if (level == 0) { + level = plm_buffer_read(self->buffer, 8); + } else if (level == 128) { + level = plm_buffer_read(self->buffer, 8) - 256; + } else if (level > 128) { + level = level - 256; + } + } else { + run = coeff >> 8; + level = coeff & 0xff; + if (plm_buffer_read(self->buffer, 1)) { + level = -level; + } + } + + n += run; + if (n < 0 || n >= 64) { + return; // invalid + } + + int de_zig_zagged = PLM_VIDEO_ZIG_ZAG[n]; + n++; + + // Dequantize, oddify, clip + level = (unsigned)level << 1; + if (!self->macroblock_intra) { + level += (level < 0 ? -1 : 1); + } + level = (level * self->quantizer_scale * quant_matrix[de_zig_zagged]) >> 4; + if ((level & 1) == 0) { + level -= level > 0 ? 1 : -1; + } + if (level > 2047) { + level = 2047; + } else if (level < -2048) { + level = -2048; + } + + // Save premultiplied coefficient + self->block_data[de_zig_zagged] = + level * PLM_VIDEO_PREMULTIPLIER_MATRIX[de_zig_zagged]; + } + + // Move block to its place + uint8_t *d; + int dw; + int di; + + if (block < 4) { + d = self->frame_current.y.data; + dw = self->luma_width; + di = (self->mb_row * self->luma_width + self->mb_col) << 4; + if ((block & 1) != 0) { + di += 8; + } + if ((block & 2) != 0) { + di += self->luma_width << 3; + } + } else { + d = (block == 4) ? self->frame_current.cb.data + : self->frame_current.cr.data; + dw = self->chroma_width; + di = ((self->mb_row * self->luma_width) << 2) + (self->mb_col << 3); + } + + int *s = self->block_data; + int si = 0; + if (self->macroblock_intra) { + // Overwrite (no prediction) + if (n == 1) { + int clamped = plm_clamp((s[0] + 128) >> 8); + PLM_BLOCK_SET(d, di, dw, si, 8, 8, clamped); + s[0] = 0; + } else { + plm_video_idct(s); + PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(s[si])); + memset(self->block_data, 0, sizeof(self->block_data)); + } + } else { + // Add data to the predicted macroblock + if (n == 1) { + int value = (s[0] + 128) >> 8; + PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + value)); + s[0] = 0; + } else { + plm_video_idct(s); + PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + s[si])); + memset(self->block_data, 0, sizeof(self->block_data)); + } + } +} + +static void plm_video_decode_macroblock(plm_video_t *self) { + // Decode self->macroblock_address_increment + int increment = 0; + int t = + plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT); + + while (t == 34) { + // macroblock_stuffing + t = plm_buffer_read_vlc(self->buffer, + PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT); + } + while (t == 35) { + // macroblock_escape + increment += 33; + t = plm_buffer_read_vlc(self->buffer, + PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT); + } + increment += t; + + // Process any skipped macroblocks + if (self->slice_begin) { + // The first self->macroblock_address_increment of each slice is relative + // to beginning of the preverious row, not the preverious macroblock + self->slice_begin = false; + self->macroblock_address += increment; + } else { + if (self->macroblock_address + increment >= self->mb_size) { + return; // invalid + } + if (increment > 1) { + // Skipped macroblocks reset DC predictors + self->dc_predictor[0] = 128; + self->dc_predictor[1] = 128; + self->dc_predictor[2] = 128; + + // Skipped macroblocks in P-pictures reset motion vectors + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) { + self->motion_forward.h = 0; + self->motion_forward.v = 0; + } + } + + // Predict skipped macroblocks + while (increment > 1) { + self->macroblock_address++; + self->mb_row = self->macroblock_address / self->mb_width; + self->mb_col = self->macroblock_address % self->mb_width; + + plm_video_predict_macroblock(self); + increment--; + } + self->macroblock_address++; + } + + self->mb_row = self->macroblock_address / self->mb_width; + self->mb_col = self->macroblock_address % self->mb_width; + + if (self->mb_col >= self->mb_width || self->mb_row >= self->mb_height) { + return; // corrupt stream; + } + + // Process the current macroblock + // static const s16 *mbTable = MACROBLOCK_TYPE[self->picture_type]; + // macroblock_type = read_huffman(self->bits, mbTable); + + const plm_vlc_t *table = PLM_VIDEO_MACROBLOCK_TYPE[self->picture_type]; + self->macroblock_type = plm_buffer_read_vlc(self->buffer, table); + + self->macroblock_intra = (self->macroblock_type & 0x01); + self->motion_forward.is_set = (self->macroblock_type & 0x08); + self->motion_backward.is_set = (self->macroblock_type & 0x04); + + // Quantizer scale + if ((self->macroblock_type & 0x10) != 0) { + self->quantizer_scale = plm_buffer_read(self->buffer, 5); + } + + if (self->macroblock_intra) { + // Intra-coded macroblocks reset motion vectors + self->motion_backward.h = self->motion_forward.h = 0; + self->motion_backward.v = self->motion_forward.v = 0; + } else { + // Non-intra macroblocks reset DC predictors + self->dc_predictor[0] = 128; + self->dc_predictor[1] = 128; + self->dc_predictor[2] = 128; + + plm_video_decode_motion_vectors(self); + plm_video_predict_macroblock(self); + } + + // Decode blocks + int cbp = + ((self->macroblock_type & 0x02) != 0) + ? plm_buffer_read_vlc(self->buffer, PLM_VIDEO_CODE_BLOCK_PATTERN) + : (self->macroblock_intra ? 0x3f : 0); + + for (int block = 0, mask = 0x20; block < 6; block++) { + if ((cbp & mask) != 0) { + plm_video_decode_block(self, block); + } + mask >>= 1; + } +} + +static void plm_video_decode_slice(plm_video_t *self, int slice) { + self->slice_begin = true; + self->macroblock_address = (slice - 1) * self->mb_width - 1; + // Reset motion vectors and DC predictors + self->motion_backward.h = self->motion_forward.h = 0; + self->motion_backward.v = self->motion_forward.v = 0; + self->dc_predictor[0] = 128; + self->dc_predictor[1] = 128; + self->dc_predictor[2] = 128; + self->quantizer_scale = plm_buffer_read(self->buffer, 5); + // Skip extra + while (plm_buffer_read(self->buffer, 1)) { + plm_buffer_skip(self->buffer, 8); + } + do { + plm_video_decode_macroblock(self); + } while (self->macroblock_address < self->mb_size - 1 && + plm_buffer_no_start_code(self->buffer)); +} + +static void plm_video_decode_picture(plm_video_t *self) { + plm_buffer_skip(self->buffer, 10); // skip temporalReference + self->picture_type = plm_buffer_read(self->buffer, 3); + plm_buffer_skip(self->buffer, 16); // skip vbv_delay + + // D frames or unknown coding type + if (self->picture_type <= 0 || + self->picture_type > PLM_VIDEO_PICTURE_TYPE_B) { + return; + } + + // forward full_px, f_code + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE || + self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) { + self->motion_forward.full_px = plm_buffer_read(self->buffer, 1); + int f_code = plm_buffer_read(self->buffer, 3); + if (f_code == 0) { + // Ignore picture with zero f_code + return; + } + self->motion_forward.r_size = f_code - 1; + } + + // backward full_px, f_code + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) { + self->motion_backward.full_px = plm_buffer_read(self->buffer, 1); + int f_code = plm_buffer_read(self->buffer, 3); + if (f_code == 0) { + // Ignore picture with zero f_code + return; + } + self->motion_backward.r_size = f_code - 1; + } + + plm_frame_t frame_temp = self->frame_forward; + + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA || + self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) { + self->frame_forward = self->frame_backward; + } + + // Skip extensions, user data + do { + self->start_code = plm_buffer_next_start_code(self->buffer); + } while (self->start_code == PLM_START_EXTENSION || + self->start_code == PLM_START_USER_DATA); + + while (self->start_code >= PLM_START_SLICE_FIRST && + self->start_code <= PLM_START_SLICE_LAST) { + plm_video_decode_slice(self, self->start_code & 0x000000FF); + if (self->macroblock_address == self->mb_size - 1) { + break; + } + self->start_code = plm_buffer_next_start_code(self->buffer); + } + + // If this is a reference picutre rotate the prediction pointers + if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA || + self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) { + self->frame_backward = self->frame_current; + self->frame_current = frame_temp; + } +} + +static plm_frame_t *plm_video_decode_impl(plm_video_t *self) { + plm_frame_t *frame = NULL; + if (!self->has_sequence_header) { + self->start_code = + plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE); + if (self->start_code == -1) { + return NULL; + } + plm_video_decode_sequence_header(self); + } + do { + if (self->start_code != PLM_START_PICTURE) { + self->start_code = + plm_buffer_find_start_code(self->buffer, PLM_START_PICTURE); + } + if (self->start_code == -1) { + return NULL; + } + plm_video_decode_picture(self); + if (self->assume_no_b_frames) { + frame = &self->frame_backward; + } else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) { + frame = &self->frame_current; + } else if (self->has_reference_frame) { + frame = &self->frame_forward; + } else { + self->has_reference_frame = true; + } + } while (!frame); + frame->time = self->time; + self->frames_decoded++; + self->time = (double)self->frames_decoded / self->framerate; + return frame; +} + +plm_frame_t *plm_video_decode(plm_video_t *self) { + long double tsc; + plm_frame_t *res; + LOGF("plm_video_decode"); + tsc = nowl(); + res = plm_video_decode_impl(self); + plmpegdecode_latency_ = lroundl((nowl() - tsc) * 1e6l); + return res; +} + +plm_video_t *plm_video_create_with_buffer(plm_buffer_t *buffer, + int destroy_when_done) { + plm_video_t *self = (plm_video_t *)memalign(64, sizeof(plm_video_t)); + memset(self, 0, sizeof(plm_video_t)); + self->buffer = buffer; + self->destroy_buffer_when_done = destroy_when_done; + self->start_code = + plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE); + if (self->start_code != -1) { + plm_video_decode_sequence_header(self); + } + return self; +} diff --git a/dsp/mpeg/plm.c b/dsp/mpeg/plm.c new file mode 100644 index 00000000..2745f63f --- /dev/null +++ b/dsp/mpeg/plm.c @@ -0,0 +1,337 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/mpeg.h" +#include "libc/log/log.h" +#include "libc/mem/mem.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/* clang-format off */ +// ----------------------------------------------------------------------------- +// plm (high-level interface) implementation + +typedef struct plm_t { + plm_demux_t *demux; + double time; + int has_ended; + int loop; + + int video_packet_type; + plm_buffer_t *video_buffer; + plm_video_t *video_decoder; + + int audio_packet_type; + double audio_lead_time; + plm_buffer_t *audio_buffer; + plm_audio_t *audio_decoder; + + plm_video_decode_callback video_decode_callback; + void *video_decode_callback_user_data; + + plm_audio_decode_callback audio_decode_callback; + void *audio_decode_callback_user_data; +} plm_t; + +void plm_handle_end(plm_t *self); +void plm_read_video_packet(plm_buffer_t *buffer, void *user); +void plm_read_audio_packet(plm_buffer_t *buffer, void *user); +void plm_read_packets(plm_t *self, int requested_type); + +plm_t *plm_create_with_filename(const char *filename) { + plm_buffer_t *buffer = plm_buffer_create_with_filename(filename); + if (!buffer) { + return NULL; + } + return plm_create_with_buffer(buffer, true); +} + +plm_t *plm_create_with_file(FILE *fh, int close_when_done) { + plm_buffer_t *buffer = plm_buffer_create_with_file(fh, close_when_done); + return plm_create_with_buffer(buffer, true); +} + +plm_t *plm_create_with_memory(uint8_t *bytes, size_t length, int free_when_done) { + plm_buffer_t *buffer = plm_buffer_create_with_memory(bytes, length, free_when_done); + return plm_create_with_buffer(buffer, true); +} + +plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) { + plm_t *self = (plm_t *)malloc(sizeof(plm_t)); + memset(self, 0, sizeof(plm_t)); + + self->demux = plm_demux_create(buffer, destroy_when_done); + + // In theory we should check plm_demux_get_num_video_streams() and + // plm_demux_get_num_audio_streams() here, but older files typically + // do not specify these correcly. So we just assume we have a video and + // audio stream and create the decoders. + + self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1; + self->video_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE); + plm_buffer_set_load_callback(self->video_buffer, plm_read_video_packet, self); + + self->audio_packet_type = PLM_DEMUX_PACKET_AUDIO_1; + self->audio_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE); + plm_buffer_set_load_callback(self->audio_buffer, plm_read_audio_packet, self); + + self->video_decoder = plm_video_create_with_buffer(self->video_buffer, true); + self->audio_decoder = plm_audio_create_with_buffer(self->audio_buffer, true); + + return self; +} + +void plm_destroy(plm_t *self) { + plm_video_destroy(self->video_decoder); + plm_audio_destroy(self->audio_decoder); + plm_demux_destroy(self->demux); + free(self); +} + +int plm_get_audio_enabled(plm_t *self) { + return (self->audio_packet_type != 0); +} + +void plm_set_audio_enabled(plm_t *self, int enabled, int stream_index) { + /* int num_streams = plm_demux_get_num_audio_streams(self->demux); */ + self->audio_packet_type = (enabled && stream_index >= 0 && stream_index < 4) + ? PLM_DEMUX_PACKET_AUDIO_1 + stream_index + : 0; +} + +int plm_get_video_enabled(plm_t *self) { + return (self->video_packet_type != 0); +} + +void plm_set_video_enabled(plm_t *self, int enabled) { + self->video_packet_type = (enabled) + ? PLM_DEMUX_PACKET_VIDEO_1 + : 0; +} + +int plm_get_width(plm_t *self) { + return plm_video_get_width(self->video_decoder); +} + +double plm_get_pixel_aspect_ratio(plm_t *self) { + return plm_video_get_pixel_aspect_ratio(self->video_decoder); +} + +int plm_get_height(plm_t *self) { + return plm_video_get_height(self->video_decoder); +} + +double plm_get_framerate(plm_t *self) { + return plm_video_get_framerate(self->video_decoder); +} + +int plm_get_num_audio_streams(plm_t *self) { + // Some files do not specify the number of audio streams in the system header. + // If the reported number of streams is 0, we check if we have a samplerate, + // indicating at least one audio stream. + int num_streams = plm_demux_get_num_audio_streams(self->demux); + return num_streams == 0 && plm_get_samplerate(self) ? 1 : num_streams; +} + +int plm_get_samplerate(plm_t *self) { + return plm_audio_get_samplerate(self->audio_decoder); +} + +double plm_get_audio_lead_time(plm_t *self) { + return self->audio_lead_time; +} + +void plm_set_audio_lead_time(plm_t *self, double lead_time) { + self->audio_lead_time = lead_time; +} + +double plm_get_time(plm_t *self) { + return self->time; +} + +void plm_rewind(plm_t *self) { + plm_video_rewind(self->video_decoder); + plm_audio_rewind(self->audio_decoder); + plm_demux_rewind(self->demux); + self->time = 0; +} + +int plm_get_loop(plm_t *self) { + return self->loop; +} + +void plm_set_loop(plm_t *self, int loop) { + self->loop = loop; +} + +int plm_has_ended(plm_t *self) { + return self->has_ended; +} + +void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp, void *user) { + self->video_decode_callback = fp; + self->video_decode_callback_user_data = user; +} + +void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp, void *user) { + self->audio_decode_callback = fp; + self->audio_decode_callback_user_data = user; +} + +int plm_decode(plm_t *self, double tick) { + DEBUGF("%s", "plm_decode"); + + int decode_video = (self->video_decode_callback && self->video_packet_type); + int decode_audio = (self->audio_decode_callback && self->audio_packet_type); + + if (!decode_video && !decode_audio) { + // Nothing to do here + return false; + } + + int did_decode = false; + int video_ended = false; + int audio_ended = false; + + double video_target_time = self->time + tick; + double audio_target_time = self->time + tick; + + if (self->audio_lead_time > 0 && decode_audio) { + video_target_time -= self->audio_lead_time; + } + else { + audio_target_time -= self->audio_lead_time; + } + + do { + did_decode = false; + + if (decode_video && plm_video_get_time(self->video_decoder) < video_target_time) { + plm_frame_t *frame = plm_video_decode(self->video_decoder); + if (frame) { + self->video_decode_callback(self, frame, self->video_decode_callback_user_data); + did_decode = true; + } + else { + video_ended = true; + } + } + + if (decode_audio && plm_audio_get_time(self->audio_decoder) < audio_target_time) { + plm_samples_t *samples = plm_audio_decode(self->audio_decoder); + if (samples) { + self->audio_decode_callback(self, samples, self->audio_decode_callback_user_data); + did_decode = true; + } + else { + audio_ended = true; + } + } + } while (did_decode); + + // We wanted to decode something but failed -> the source must have ended + if ((!decode_video || video_ended) && (!decode_audio || audio_ended)) { + plm_handle_end(self); + } + else { + self->time += tick; + } + + return did_decode ? true : false; +} + +plm_frame_t *plm_decode_video(plm_t *self) { + if (!self->video_packet_type) { + return NULL; + } + + plm_frame_t *frame = plm_video_decode(self->video_decoder); + if (frame) { + self->time = frame->time; + } + else { + plm_handle_end(self); + } + return frame; +} + +plm_samples_t *plm_decode_audio(plm_t *self) { + if (!self->audio_packet_type) { + return NULL; + } + + plm_samples_t *samples = plm_audio_decode(self->audio_decoder); + if (samples) { + self->time = samples->time; + } + else { + plm_handle_end(self); + } + return samples; +} + +void plm_handle_end(plm_t *self) { + if (self->loop) { + plm_rewind(self); + } + else { + self->has_ended = true; + } +} + +void plm_read_video_packet(plm_buffer_t *buffer, void *user) { + plm_t *self = (plm_t *)user; + plm_read_packets(self, self->video_packet_type); +} + +void plm_read_audio_packet(plm_buffer_t *buffer, void *user) { + plm_t *self = (plm_t *)user; + plm_read_packets(self, self->audio_packet_type); +} + +void plm_read_packets(plm_t *self, int requested_type) { + plm_packet_t *packet; + while ((packet = plm_demux_decode(self->demux))) { + if (packet->type == self->video_packet_type) { + plm_buffer_write(self->video_buffer, packet->data, packet->length); + } + else if (packet->type == self->audio_packet_type) { + plm_buffer_write(self->audio_buffer, packet->data, packet->length); + } + if (packet->type == requested_type) { + return; + } + } +} diff --git a/dsp/mpeg/slowrgb.c b/dsp/mpeg/slowrgb.c new file mode 100644 index 00000000..2bfbafd5 --- /dev/null +++ b/dsp/mpeg/slowrgb.c @@ -0,0 +1,88 @@ +/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8 -*-│ +│vi: set et ft=c ts=4 sw=4 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer │ +│ Dominic Szablewski - https://phoboslab.org │ +│ │ +│ The MIT License(MIT) │ +│ Copyright(c) 2019 Dominic Szablewski │ +│ │ +│ 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. │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/mpeg.h" +#include "libc/macros.h" + +asm(".ident\t\"\\n\\n\ +PL_MPEG (MIT License)\\n\ +Copyright(c) 2019 Dominic Szablewski\\n\ +https://phoboslab.org\""); +asm(".include \"libc/disclaimer.inc\""); + +/** + * @see YCbCr2RGB() in tool/viz/lib/ycbcr2rgb.c + */ +void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb) { + // Chroma values are the same for each block of 4 pixels, so we proccess + // 2 lines at a time, 2 neighboring pixels each. + int w = frame->y.width, w2 = w >> 1; + int y_index1 = 0, y_index2 = w, y_next_2_lines = w + (w - frame->width); + int c_index = 0, c_next_line = w2 - (frame->width >> 1); + int rgb_index1 = 0, rgb_index2 = frame->width * 3, + rgb_next_2_lines = frame->width * 3; + int cols = frame->width >> 1, rows = frame->height >> 1; + int ccb, ccr, r, g, b; + uint8_t *y = frame->y.data, *cb = frame->cb.data, *cr = frame->cr.data; + for (int row = 0; row < rows; row++) { + for (int col = 0; col < cols; col++) { + ccb = cb[c_index]; + ccr = cr[c_index]; + c_index++; + r = (ccr + ((ccr * 103) >> 8)) - 179; + g = ((ccb * 88) >> 8) - 44 + ((ccr * 183) >> 8) - 91; + b = (ccb + ((ccb * 198) >> 8)) - 227; + // Line 1 + int y1 = y[y_index1++]; + int y2 = y[y_index1++]; + rgb[rgb_index1 + 0] = MAX(0, MIN(255, y1 + r)); + rgb[rgb_index1 + 1] = MAX(0, MIN(255, y1 - g)); + rgb[rgb_index1 + 2] = MAX(0, MIN(255, y1 + b)); + rgb[rgb_index1 + 3] = MAX(0, MIN(255, y2 + r)); + rgb[rgb_index1 + 4] = MAX(0, MIN(255, y2 - g)); + rgb[rgb_index1 + 5] = MAX(0, MIN(255, y2 + b)); + rgb_index1 += 6; + // Line 2 + int y3 = y[y_index2++]; + int y4 = y[y_index2++]; + rgb[rgb_index2 + 0] = MAX(0, MIN(255, y3 + r)); + rgb[rgb_index2 + 1] = MAX(0, MIN(255, y3 - g)); + rgb[rgb_index2 + 2] = MAX(0, MIN(255, y3 + b)); + rgb[rgb_index2 + 3] = MAX(0, MIN(255, y4 + r)); + rgb[rgb_index2 + 4] = MAX(0, MIN(255, y4 - g)); + rgb[rgb_index2 + 5] = MAX(0, MIN(255, y4 + b)); + rgb_index2 += 6; + } + y_index1 += y_next_2_lines; + y_index2 += y_next_2_lines; + rgb_index1 += rgb_next_2_lines; + rgb_index2 += rgb_next_2_lines; + c_index += c_next_line; + } +} diff --git a/dsp/mpeg/video.h b/dsp/mpeg/video.h new file mode 100644 index 00000000..546b7d91 --- /dev/null +++ b/dsp/mpeg/video.h @@ -0,0 +1,62 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_VIDEO_H_ +#define COSMOPOLITAN_DSP_MPEG_VIDEO_H_ +#include "dsp/mpeg/mpeg.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +typedef struct { + int full_px; + int is_set; + int r_size; + int h; + int v; +} plm_video_motion_t; + +typedef struct plm_video_t { + double framerate; + double time; + double pixel_aspect_ratio; + int frames_decoded; + int width; + int height; + int mb_width; + int mb_height; + int mb_size; + int luma_width; + int luma_height; + int chroma_width; + int chroma_height; + int start_code; + int picture_type; + plm_video_motion_t motion_forward; + plm_video_motion_t motion_backward; + int has_sequence_header; + int quantizer_scale; + int slice_begin; + int macroblock_address; + int mb_row; + int mb_col; + int macroblock_type; + int macroblock_intra; + int dc_predictor[3]; + plm_buffer_t *buffer; + int destroy_buffer_when_done; + plm_frame_t frame_current; + plm_frame_t frame_forward; + plm_frame_t frame_backward; + uint8_t *frames_data; + int block_data[64]; + uint8_t intra_quant_matrix[64]; + uint8_t non_intra_quant_matrix[64]; + int has_reference_frame; + int assume_no_b_frames; +} plm_video_t; + +void plm_video_process_macroblock_8(plm_video_t *, uint8_t *restrict, + uint8_t *restrict, int, int, bool); +void plm_video_process_macroblock_16(plm_video_t *, uint8_t *restrict, + uint8_t *restrict, int, int, bool); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_VIDEO_H_ */ diff --git a/dsp/mpeg/ycbcrio.c b/dsp/mpeg/ycbcrio.c new file mode 100644 index 00000000..467e1589 --- /dev/null +++ b/dsp/mpeg/ycbcrio.c @@ -0,0 +1,139 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/mpeg/mpeg.h" +#include "dsp/mpeg/ycbcrio.h" +#include "libc/bits/bits.h" +#include "libc/calls/calls.h" +#include "libc/calls/struct/stat.h" +#include "libc/log/check.h" +#include "libc/macros.h" +#include "libc/runtime/runtime.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/map.h" +#include "libc/sysv/consts/o.h" +#include "libc/sysv/consts/prot.h" + +static void CheckPlmFrame(const struct plm_frame_t *frame) { + CHECK_NE(0, frame->width); + CHECK_NE(0, frame->height); + CHECK_GE(frame->y.width, frame->width); + CHECK_GE(frame->y.height, frame->height); + CHECK_EQ(frame->cr.width, frame->cb.width); + CHECK_EQ(frame->cr.height, frame->cb.height); + CHECK_EQ(frame->y.width, frame->cr.width * 2); + CHECK_EQ(frame->y.height, frame->cr.height * 2); + CHECK_NOTNULL(frame->y.data); + CHECK_NOTNULL(frame->cr.data); + CHECK_NOTNULL(frame->cb.data); +} + +static size_t GetHeaderBytes(const struct plm_frame_t *frame) { + return MAX(sizeof(struct Ycbcrio), ROUNDUP(frame->y.width, 16)); +} + +static size_t GetPlaneBytes(const struct plm_plane_t *plane) { + /* + * planes must be 16-byte aligned, but due to their hugeness, and the + * recommendation of intel's 6,000 page manual, it makes sense to have + * planes on isolated 64kb frames for multiprocessing. + */ + return ROUNDUP(ROUNDUP(plane->height, 16) * ROUNDUP(plane->width, 16), + FRAMESIZE); +} + +static size_t CalcMapBytes(const struct plm_frame_t *frame) { + return ROUNDUP(GetHeaderBytes(frame) + GetPlaneBytes(&frame->y) + + GetPlaneBytes(&frame->cb) + GetPlaneBytes(&frame->cb), + FRAMESIZE); +} + +static void FixupPointers(struct Ycbcrio *map) { + map->frame.y.data = (unsigned char *)map + GetHeaderBytes(&map->frame); + map->frame.cr.data = map->frame.y.data + GetPlaneBytes(&map->frame.y); + map->frame.cb.data = map->frame.cr.data + GetPlaneBytes(&map->frame.cr); +} + +static struct Ycbcrio *YcbcrioOpenNew(const char *path, + const struct plm_frame_t *frame) { + int fd; + size_t size; + struct stat st; + struct Ycbcrio *map; + CheckPlmFrame(frame); + size = CalcMapBytes(frame); + CHECK_NE(-1, (fd = open(path, O_CREAT | O_RDWR, 0644))); + CHECK_NE(-1, fstat(fd, &st)); + if (st.st_size < size) { + CHECK_NE(-1, ftruncate(fd, size)); + } + CHECK_NE(MAP_FAILED, + (map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0))); + map->magic = YCBCRIO_MAGIC; + map->fd = fd; + map->size = size; + memcpy(&map->frame, frame, sizeof(map->frame)); + FixupPointers(map); + memcpy(&map->frame.y.data, frame->y.data, GetPlaneBytes(&frame->y)); + memcpy(&map->frame.cb.data, frame->cb.data, GetPlaneBytes(&frame->cb)); + memcpy(&map->frame.cr.data, frame->cr.data, GetPlaneBytes(&frame->cr)); + return map; +} + +static struct Ycbcrio *YcbcrioOpenExisting(const char *path) { + int fd; + struct stat st; + struct Ycbcrio *map; + CHECK_NE(-1, (fd = open(path, O_RDWR))); + CHECK_NE(-1, fstat(fd, &st)); + CHECK_NE(MAP_FAILED, (map = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, + MAP_SHARED, fd, 0))); + CHECK_EQ(YCBCRIO_MAGIC, map->magic); + CHECK_GE(st.st_size, CalcMapBytes(&map->frame)); + FixupPointers(map); + map->fd = fd; + map->size = st.st_size; + return map; +} + +/** + * Opens shareable persistable MPEG video frame memory. + * + * @param path is a file name + * @param frame if NULL means open existing file, otherwise copies new + * @param points to pointer returned by YcbcrioOpen() which is cleared + * @return memory mapping needing YcbcrioClose() + */ +struct Ycbcrio *YcbcrioOpen(const char *path, const struct plm_frame_t *frame) { + if (frame) { + return YcbcrioOpenNew(path, frame); + } else { + return YcbcrioOpenExisting(path); + } +} + +/** + * Closes mapped video frame file. + * + * @param points to pointer returned by YcbcrioOpen() which is cleared + */ +void YcbcrioClose(struct Ycbcrio **map) { + CHECK_NE(-1, close_s(&(*map)->fd)); + CHECK_NE(-1, munmap_s(map, (*map)->size)); +} diff --git a/dsp/mpeg/ycbcrio.h b/dsp/mpeg/ycbcrio.h new file mode 100644 index 00000000..aff70985 --- /dev/null +++ b/dsp/mpeg/ycbcrio.h @@ -0,0 +1,27 @@ +#ifndef COSMOPOLITAN_DSP_MPEG_YCBCRIO_H_ +#define COSMOPOLITAN_DSP_MPEG_YCBCRIO_H_ +#include "dsp/mpeg/mpeg.h" +#include "libc/bits/bits.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +#define YCBCRIO_MAGIC bswap_32(0xBCCBCCBCu) + +/** + * Mappable persistable MPEG-2 video frame in Y-Cr-Cb colorspace. + */ +struct Ycbcrio { + uint32_t magic; + int32_t fd; + uint64_t size; + plm_frame_t frame; +}; + +struct Ycbcrio *YcbcrioOpen(const char *, const struct plm_frame_t *) + paramsnonnull((1)) vallocesque returnsnonnull; + +void YcbcrioClose(struct Ycbcrio **) paramsnonnull(); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_MPEG_YCBCRIO_H_ */ diff --git a/dsp/scale/cdecimate2xuint8x8.c b/dsp/scale/cdecimate2xuint8x8.c new file mode 100644 index 00000000..e487d69f --- /dev/null +++ b/dsp/scale/cdecimate2xuint8x8.c @@ -0,0 +1,100 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/scale/scale.h" +#include "libc/assert.h" +#include "libc/intrin/packuswb.h" +#include "libc/intrin/paddw.h" +#include "libc/intrin/palignr.h" +#include "libc/intrin/pmaddubsw.h" +#include "libc/intrin/psraw.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/nexgen32e/x86feature.h" +#include "libc/str/str.h" + +#define TAPS 8 +#define RATIO 2 +#define OFFSET 3 +#define STRIDE 8 +#define SPREAD (STRIDE * RATIO + TAPS - OFFSET) +#define OVERLAP (SPREAD - STRIDE * RATIO) +#define LOOKBEHIND OFFSET +#define LOOKAHEAD (SPREAD - LOOKBEHIND) +#define SCALE 5 +#define ROUND (1 << (SCALE - 1)) + +/** + * Performs 2D Motion Picture Convolution Acceleration by Leveraging SSSE3. + * + * @note H/T John Costella, Jean-Baptiste Joseph Fourier + * @note RIP Huixiang Chen + */ +void *cDecimate2xUint8x8(unsigned long n, unsigned char A[n], + const signed char K[8]) { + short kRound[8] = {ROUND, ROUND, ROUND, ROUND, ROUND, ROUND, ROUND, ROUND}; + signed char kMadd1[16] = {K[0], K[1], K[0], K[1], K[0], K[1], K[0], K[1], + K[0], K[1], K[0], K[1], K[0], K[1], K[0], K[1]}; + signed char kMadd2[16] = {K[2], K[3], K[2], K[3], K[2], K[3], K[2], K[3], + K[2], K[3], K[2], K[3], K[2], K[3], K[2], K[3]}; + signed char kMadd3[16] = {K[4], K[5], K[4], K[5], K[4], K[5], K[4], K[5], + K[4], K[5], K[4], K[5], K[4], K[5], K[4], K[5]}; + signed char kMadd4[16] = {K[6], K[7], K[6], K[7], K[6], K[7], K[6], K[7], + K[6], K[7], K[6], K[7], K[6], K[7], K[6], K[7]}; + unsigned char in1[16], in2[16], in3[16], in4[32]; + unsigned char bv0[16], bv1[16], bv2[16], bv3[16]; + short wv0[8], wv1[8], wv2[8], wv3[8]; + unsigned long i, j, v, w, o; + if (n >= STRIDE) { + i = 0; + w = (n + RATIO / 2) / RATIO; + memset(in1, A[0], sizeof(in1)); + memset(in2, A[n - 1], 16); + memcpy(in2, A, MIN(16, n)); + for (; i < w; i += STRIDE) { + j = i * RATIO + 16; + if (j + 16 <= n) { + memcpy(in3, &A[j], 16); + } else { + memset(in3, A[n - 1], 16); + if (j < n) { + memcpy(in3, &A[j], n - j); + } + } + palignr(bv0, in2, in1, 13); + palignr(bv1, in2, in1, 15); + palignr(bv2, in3, in2, 1); + palignr(bv3, in3, in2, 3); + pmaddubsw(wv0, bv0, kMadd1); + pmaddubsw(wv1, bv1, kMadd2); + pmaddubsw(wv2, bv2, kMadd3); + pmaddubsw(wv3, bv3, kMadd4); + paddw(wv0, wv0, kRound); + paddw(wv0, wv0, wv1); + paddw(wv0, wv0, wv2); + paddw(wv0, wv0, wv3); + psraw(wv0, wv0, SCALE); + packuswb(bv2, wv0, wv0); + memcpy(&A[i], bv2, STRIDE); + memcpy(in1, in2, 16); + memcpy(in2, in3, 16); + } + } + return A; +} diff --git a/dsp/scale/gyarados.c b/dsp/scale/gyarados.c new file mode 100644 index 00000000..e46ea249 --- /dev/null +++ b/dsp/scale/gyarados.c @@ -0,0 +1,285 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/c161.h" +#include "dsp/core/core.h" +#include "dsp/core/ituround.h" +#include "dsp/core/q.h" +#include "dsp/core/twixt8.h" +#include "dsp/scale/scale.h" +#include "libc/limits.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/mem/mem.h" +#include "libc/nexgen32e/bsr.h" +#include "libc/runtime/gc.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/testlib/testlib.h" +#include "libc/x/x.h" +#include "third_party/dtoa/dtoa.h" +#include "tool/viz/lib/knobs.h" + +/** + * @fileoverview Gyarados resizes graphics. + * @note H/T John Costella, Facebook, Photoshop, Carl Friedrich Gauss + * @note Eric Brasseur has an interesting blog post on tip of iceberg + * @see Magikarp + */ + +#define M 14 +#define SQR(X) ((X) * (X)) + +struct SamplingSolution { + int n, s; + void *weights; + void *indices; +}; + +static double ComputeWeight(double x) { + if (-1.5 < x && x < 1.5) { + if (-.5 < x && x < .5) { + return .75 - SQR(x); + } else if (x < 0) { + return .5 * SQR(x + 1.5); + } else { + return .5 * SQR(x - 1.5); + } + } else { + return 0; + } +} + +static struct SamplingSolution *NewSamplingSolution(long n, long s) { + struct SamplingSolution *ss; + ss = xcalloc(1, sizeof(struct SamplingSolution)); + ss->n = n; + ss->s = s; + ss->weights = xcalloc(n * s, sizeof(short)); + ss->indices = xcalloc(n * s, sizeof(short)); + return ss; +} + +static bool IsNormalized(int n, double A[n]) { + int i; + double x; + for (x = i = 0; i < n; ++i) x += A[i]; + return fabs(x - 1) < 1e-4; +} + +void FreeSamplingSolution(struct SamplingSolution *ss) { + long i; + if (ss) { + free(ss->indices); + free(ss->weights); + free(ss); + } +} + +struct SamplingSolution *ComputeSamplingSolution(long dn, long sn, double dar, + double off, double par) { + double *fweights; + double sum, hw, w, x, f; + short *weights, *indices; + struct SamplingSolution *res; + long j, i, k, n, min, max, s, N[6]; + if (!dar) dar = sn, dar /= dn; + if (!off) off = (dar - 1) / 2; + f = dar < 1 ? 1 / dar : dar; + s = 3 * f + 1; + fweights = gc(xcalloc(s, sizeof(double))); + res = NewSamplingSolution(dn, s); + weights = res->weights; + indices = res->indices; + for (i = 0; i < dn; ++i) { + x = off + i * dar; + hw = 1.5 * f; + min = ceil(x - hw); + max = floor(x + hw); + n = max - min + 1; + CHECK_LE(n, s); + for (k = 0, j = min; j <= max; ++j) { + fweights[k++] = ComputeWeight((j - x) / (f / par)); + } + for (sum = k = 0; k < n; ++k) sum += fweights[k]; + for (j = 0; j < n; ++j) fweights[j] *= 1 / sum; + DCHECK(IsNormalized(n, fweights)); + for (j = 0; j < n; ++j) { + indices[i * s + j] = MIN(sn - 1, MAX(0, min + j)); + } + for (j = 0; j < n; j += 6) { + GetIntegerCoefficients(N, fweights + j, M, 0, 255); + for (k = 0; k < MIN(6, n - j); ++k) { + weights[i * s + j + k] = N[k]; + } + } + } + return res; +} + +static void *ZeroMatrix(long yw, long xw, int p[yw][xw], long yn, long xn) { + long y; + for (y = 0; y < yn; ++y) { + memset(p[y], 0, xn); + } + return p; +} + +static int Sharpen(int ax, int bx, int cx) { + return (-1 * ax + 6 * bx + -1 * cx + 2) / 4; +} + +static void GyaradosImpl(long dyw, long dxw, int dst[dyw][dxw], long syw, + long sxw, const int src[syw][sxw], long dyn, long dxn, + long syn, long sxn, int tmp0[restrict dyn][sxn], + int tmp1[restrict dyn][sxn], + int tmp2[restrict dyn][dxn], long yfn, long xfn, + const short fyi[dyn][yfn], const short fyw[dyn][yfn], + const short fxi[dxn][xfn], const short fxw[dxn][xfn], + bool sharpen) { + long i, j; + int eax, dy, dx, sy, sx; + for (sx = 0; sx < sxn; ++sx) { + for (dy = 0; dy < dyn; ++dy) { + for (eax = i = 0; i < yfn; ++i) { + eax += fyw[dy][i] * src[fyi[dy][i]][sx]; + } + tmp0[dy][sx] = QRS(M, eax); + } + } + for (dy = 0; dy < dyn; ++dy) { + /* TODO: pmulhrsw() would probably make this much faster */ + for (sx = 0; sx < sxn; ++sx) { + tmp1[dy][sx] = sharpen ? Sharpen(tmp0[MIN(dyn - 1, MAX(0, dy - 1))][sx], + tmp0[dy][sx], + tmp0[MIN(dyn - 1, MAX(0, dy + 1))][sx]) + : tmp0[dy][sx]; + } + } + for (dx = 0; dx < dxn; ++dx) { + for (dy = 0; dy < dyn; ++dy) { + for (eax = i = 0; i < xfn; ++i) { + eax += fxw[dx][i] * tmp1[dy][fxi[dx][i]]; + } + tmp2[dy][dx] = QRS(M, eax); + } + } + for (dx = 0; dx < dxn; ++dx) { + for (dy = 0; dy < dyn; ++dy) { + dst[dy][dx] = sharpen ? Sharpen(tmp2[dy][MIN(dxn - 1, MAX(0, dx - 1))], + tmp2[dy][dx], + tmp2[dy][MIN(dxn - 1, MAX(0, dx + 1))]) + : tmp2[dy][dx]; + } + } +} + +/** + * Scales image. + * + * @note gyarados is magikarp in its infinite form + * @see Magikarp2xY(), Magikarp2xX() + */ +void *Gyarados(long dyw, long dxw, int dst[dyw][dxw], long syw, long sxw, + const int src[syw][sxw], long dyn, long dxn, long syn, long sxn, + struct SamplingSolution *cy, struct SamplingSolution *cx, + bool sharpen) { + if (dyn > 0 && dxn > 0) { + if (syn > 0 && sxn > 0) { + CHECK_LE(syn, syw); + CHECK_LE(sxn, sxw); + CHECK_LE(dyn, dyw); + CHECK_LE(dxn, dxw); + CHECK_LT(bsrl(syn) + bsrl(sxn), 32); + CHECK_LT(bsrl(dyn) + bsrl(dxn), 32); + CHECK_LE(dyw, 0x7fff); + CHECK_LE(dxw, 0x7fff); + CHECK_LE(syw, 0x7fff); + CHECK_LE(sxw, 0x7fff); + CHECK_LE(dyn, 0x7fff); + CHECK_LE(dxn, 0x7fff); + CHECK_LE(syn, 0x7fff); + CHECK_LE(sxn, 0x7fff); + GyaradosImpl(dyw, dxw, dst, syw, sxw, src, dyn, dxn, syn, sxn, + gc(xmemalign(64, sizeof(int) * dyn * sxn)), + gc(xmemalign(64, sizeof(int) * dyn * sxn)), + gc(xmemalign(64, sizeof(int) * dyn * dxn)), cy->s, cx->s, + cy->indices, cy->weights, cx->indices, cx->weights, sharpen); + } else { + ZeroMatrix(dyw, dxw, dst, dyn, dxn); + } + } + return dst; +} + +void *GyaradosUint8(long dyw, long dxw, unsigned char dst[dyw][dxw], long syw, + long sxw, const unsigned char src[syw][sxw], long dyn, + long dxn, long syn, long sxn, long lo, long hi, + struct SamplingSolution *cy, struct SamplingSolution *cx, + bool sharpen) { + static bool once; + static int Tin[256]; + static unsigned char Tout[32768]; + long i, y, x; + int(*tmp)[MAX(dyn, syn)][MAX(dxn, sxn)]; + if (!once) { + for (i = 0; i < ARRAYLEN(Tin); ++i) { + Tin[i] = F2Q(15, rgb2linpc(i / 255., 2.4)); + } + for (i = 0; i < ARRAYLEN(Tout); ++i) { + Tout[i] = MIN(255, MAX(0, round(rgb2stdpc(Q2F(15, i), 2.4) * 255.))); + } + once = true; + } + tmp = xmemalign(64, sizeof(int) * MAX(dyn, syn) * MAX(dxn, sxn)); + for (y = 0; y < syn; ++y) { + for (x = 0; x < sxn; ++x) { + (*tmp)[y][x] = Tin[src[y][x]]; + } + } + Gyarados(MAX(dyn, syn), MAX(dxn, sxn), *tmp, MAX(dyn, syn), MAX(dxn, sxn), + *tmp, dyn, dxn, syn, sxn, cy, cx, sharpen); + for (y = 0; y < dyn; ++y) { + for (x = 0; x < dxn; ++x) { + dst[y][x] = Tout[MIN(32767, MAX(0, (*tmp)[y][x]))]; + } + } + free(tmp); + return dst; +} + +void *EzGyarados(long dcw, long dyw, long dxw, unsigned char dst[dcw][dyw][dxw], + long scw, long syw, long sxw, + const unsigned char src[scw][syw][sxw], long c0, long cn, + long dyn, long dxn, long syn, long sxn, double ry, double rx, + double oy, double ox) { + long c; + struct SamplingSolution *cy, *cx; + cy = ComputeSamplingSolution(dyn, syn, ry, oy, 1); + cx = ComputeSamplingSolution(dxn, sxn, rx, ox, 1); + for (c = c0; c < cn; ++c) { + GyaradosUint8(dyw, dxw, dst[c], syw, sxw, src[c], dyn, dxn, syn, sxn, 0, + 255, cy, cx, true); + } + FreeSamplingSolution(cx); + FreeSamplingSolution(cy); + return dst; +} diff --git a/dsp/scale/magikarp.c b/dsp/scale/magikarp.c new file mode 100644 index 00000000..df9a7914 --- /dev/null +++ b/dsp/scale/magikarp.c @@ -0,0 +1,129 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/half.h" +#include "dsp/core/ks8.h" +#include "dsp/core/kss8.h" +#include "dsp/scale/scale.h" +#include "libc/macros.h" +#include "libc/nexgen32e/x86feature.h" +#include "libc/str/str.h" +#include "libc/x/x.h" + +/** + * @fileoverview Magikarp resizes graphics in half very fast. + * @note H/T John Costella, Facebook, and Photoshop + * @note sharpening is good for luma but not chroma + * @see Gyarados + */ + +#define CLAMP(X) MIN(255, MAX(0, X)) +#define MAGIKARP(...) \ + CLAMP(KS8(5, K[0], K[1], K[2], K[3], K[4], K[5], K[6], K[7], __VA_ARGS__)) + +signed char g_magikarp[8]; +const signed char kMagikarp[8][8] = { + {-1, -3, 3, 17, 17, 3, -3, -1}, /* 1331+161 derived w/ one off cas */ + {-1, -3, 6, 28, 6, -3, -1, 0}, /* due to the convolution theorem? */ + {0, 0, -11, 53, -11, 0, 0, 0}, /* plus, some random experimenting */ + {-2, -6, 2, 22, 22, 2, -6, -2}, /* one a line please clang-format? */ + {-3, -9, 1, 27, 27, 1, -9, -3}, +}; + +signed char g_magkern[8]; +const signed char kMagkern[8][8] = { + {1, 2, 3, 10, 10, 3, 2, 1}, + {0, 4, 4, 16, 4, 4, 0, 0}, + {0, 1, 2, 6, 14, 6, 2, 1}, + {0, 1, 2, 13, 13, 2, 1, 0}, +}; + +void *Magikarp2xX(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y; + if (yn && xn > 1) { + for (y = 0; y < yn; ++y) { + /* gcc/clang both struggle with left-to-right matrix ops */ + cDecimate2xUint8x8(xn, p[y], g_magikarp); + } + } + return p; +} + +void *Magikarp2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y, x, h; + signed char K[8]; + memcpy(K, g_magikarp, sizeof(K)); + for (h = HALF(yn), y = 0; y < h; ++y) { + for (x = 0; x < xn; ++x) { + p[y][x] = /* gcc/clang are good at optimizing top-to-bottom matrix ops */ + MAGIKARP(p[MAX(00 + 0, y * 2 - 3)][x], p[MAX(00 + 0, y * 2 - 2)][x], + p[MAX(00 + 0, y * 2 - 1)][x], p[MIN(yn - 1, y * 2 + 0)][x], + p[MIN(yn - 1, y * 2 + 1)][x], p[MIN(yn - 1, y * 2 + 2)][x], + p[MIN(yn - 1, y * 2 + 3)][x], p[MIN(yn - 1, y * 2 + 4)][x]); + } + } + return p; +} + +void *Magkern2xX(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y; + if (yn && xn > 1) { + for (y = 0; y < yn; ++y) { + cDecimate2xUint8x8(xn, p[y], g_magkern); + } + } + return p; +} + +void *Magkern2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y, x, h; + signed char K[8]; + memcpy(K, g_magkern, sizeof(K)); + for (h = HALF(yn), y = 0; y < h; ++y) { + for (x = 0; x < xn; ++x) { + p[y][x] = + MAGIKARP(p[MAX(00 + 0, y * 2 - 3)][x], p[MAX(00 + 0, y * 2 - 2)][x], + p[MAX(00 + 0, y * 2 - 1)][x], p[MIN(yn - 1, y * 2 + 0)][x], + p[MIN(yn - 1, y * 2 + 1)][x], p[MIN(yn - 1, y * 2 + 2)][x], + p[MIN(yn - 1, y * 2 + 3)][x], p[MIN(yn - 1, y * 2 + 4)][x]); + } + } + return p; +} + +void *MagikarpY(long dys, long dxs, unsigned char d[restrict dys][dxs], + long sys, long sxs, const unsigned char s[sys][sxs], long yn, + long xn, const signed char K[8]) { + long y, x; + for (y = 0; y < yn; ++y) { + for (x = 0; x < xn; ++x) { + d[y][x] = MAGIKARP(s[MAX(00 + 0, y - 3)][x], s[MAX(00 + 0, y - 2)][x], + s[MAX(00 + 0, y - 1)][x], s[MIN(yn - 1, y + 0)][x], + s[MIN(yn - 1, y + 1)][x], s[MIN(yn - 1, y + 2)][x], + s[MIN(yn - 1, y + 3)][x], s[MIN(yn - 1, y + 4)][x]); + } + } + return d; +} + +static textstartup void g_magikarp_init() { + memcpy(g_magkern, kMagkern[0], sizeof(g_magkern)); + memcpy(g_magikarp, kMagikarp[0], sizeof(g_magikarp)); +} +const void *const g_magikarp_ctor[] initarray = {g_magikarp_init}; diff --git a/dsp/scale/scale.c b/dsp/scale/scale.c new file mode 100644 index 00000000..a5d38fc0 --- /dev/null +++ b/dsp/scale/scale.c @@ -0,0 +1,41 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/half.h" +#include "dsp/scale/scale.h" + +void *Scale2xX(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y, x, w; + for (w = HALF(xn), y = 0; y < yn; ++y) { + for (x = 0; x < w; ++x) { + p[y][x] = p[y][x * 2]; + } + } + return p; +} + +void *Scale2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) { + long y, x, h; + for (h = HALF(yn), y = 0; y < h; ++y) { + for (x = 0; x < xn; ++x) { + p[y][x] = p[y * 2][x]; + } + } + return p; +} diff --git a/dsp/scale/scale.h b/dsp/scale/scale.h new file mode 100644 index 00000000..fa4a78de --- /dev/null +++ b/dsp/scale/scale.h @@ -0,0 +1,49 @@ +#ifndef COSMOPOLITAN_DSP_SCALE_SCALE_H_ +#define COSMOPOLITAN_DSP_SCALE_SCALE_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +extern long gyarados_latency_; + +extern signed char g_magikarp[8]; +extern signed char g_magkern[8]; +extern const signed char kMagikarp[8][8]; +extern const signed char kMagkern[8][8]; + +struct SamplingSolution; +void FreeSamplingSolution(struct SamplingSolution *); +struct SamplingSolution *ComputeSamplingSolution(long, long, double, double, + double); + +void *Scale2xX(long ys, long xs, unsigned char[ys][xs], long, long); +void *Scale2xY(long ys, long xs, unsigned char[ys][xs], long, long); +void *Magikarp2xX(long ys, long xs, unsigned char[ys][xs], long, long); +void *Magikarp2xY(long ys, long xs, unsigned char[ys][xs], long, long); +void *Magkern2xX(long ys, long xs, unsigned char[ys][xs], long, long); +void *Magkern2xY(long ys, long xs, unsigned char[ys][xs], long, long); +void *MagikarpY(long dys, long dxs, unsigned char d[restrict dys][dxs], + long sys, long sxs, const unsigned char s[sys][sxs], long yn, + long xn, const signed char K[8]); + +void *GyaradosUint8(long dyw, long dxw, unsigned char dst[dyw][dxw], long syw, + long sxw, const unsigned char src[syw][sxw], long dyn, + long dxn, long syn, long sxn, long lo, long hi, + struct SamplingSolution *cy, struct SamplingSolution *cx, + bool sharpen); +void *EzGyarados(long dcw, long dyw, long dxw, unsigned char dst[dcw][dyw][dxw], + long scw, long syw, long sxw, + const unsigned char src[scw][syw][sxw], long c0, long cn, + long dyn, long dxn, long syn, long sxn, double ry, double rx, + double oy, double ox); + +void Decimate2xUint8x8(unsigned long n, unsigned char[n * 2], + const signed char[static 8]); +void *cDecimate2xUint8x8(unsigned long n, unsigned char[n * 2], + const signed char[8]); + +void *transpose(long yn, long xn, const unsigned char[yn][xn]); +extern void (*const transpose88b)(unsigned char[8][8]); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_SCALE_SCALE_H_ */ diff --git a/dsp/scale/scale.mk b/dsp/scale/scale.mk new file mode 100644 index 00000000..6c9035eb --- /dev/null +++ b/dsp/scale/scale.mk @@ -0,0 +1,58 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += DSP_SCALE + +DSP_SCALE_ARTIFACTS += DSP_SCALE_A +DSP_SCALE = $(DSP_SCALE_A_DEPS) $(DSP_SCALE_A) +DSP_SCALE_A = o/$(MODE)/dsp/scale/scale.a +DSP_SCALE_A_FILES := $(wildcard dsp/scale/*) +DSP_SCALE_A_HDRS = $(filter %.h,$(DSP_SCALE_A_FILES)) +DSP_SCALE_A_SRCS_S = $(filter %.S,$(DSP_SCALE_A_FILES)) +DSP_SCALE_A_SRCS_C = $(filter %.c,$(DSP_SCALE_A_FILES)) + +DSP_SCALE_A_SRCS = \ + $(DSP_SCALE_A_SRCS_S) \ + $(DSP_SCALE_A_SRCS_C) + +DSP_SCALE_A_OBJS = \ + $(DSP_SCALE_A_SRCS:%=o/$(MODE)/%.zip.o) \ + $(DSP_SCALE_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(DSP_SCALE_A_SRCS_C:%.c=o/$(MODE)/%.o) + +DSP_SCALE_A_CHECKS = \ + $(DSP_SCALE_A).pkg \ + $(DSP_SCALE_A_HDRS:%=o/$(MODE)/%.ok) + +DSP_SCALE_A_DIRECTDEPS = \ + DSP_CORE \ + LIBC_INTRIN \ + LIBC_NEXGEN32E \ + LIBC_TINYMATH \ + LIBC_TIME \ + LIBC_RUNTIME \ + LIBC_LOG \ + LIBC_MEM \ + LIBC_X \ + LIBC_STUBS + +DSP_SCALE_A_DEPS := \ + $(call uniq,$(foreach x,$(DSP_SCALE_A_DIRECTDEPS),$($(x)))) + +$(DSP_SCALE_A): dsp/scale/ \ + $(DSP_SCALE_A).pkg \ + $(DSP_SCALE_A_OBJS) + +$(DSP_SCALE_A).pkg: \ + $(DSP_SCALE_A_OBJS) \ + $(foreach x,$(DSP_SCALE_A_DIRECTDEPS),$($(x)_A).pkg) + +DSP_SCALE_LIBS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x))) +DSP_SCALE_SRCS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_SRCS)) +DSP_SCALE_HDRS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_HDRS)) +DSP_SCALE_CHECKS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_CHECKS)) +DSP_SCALE_OBJS = $(foreach x,$(DSP_SCALE_ARTIFACTS),$($(x)_OBJS)) +$(DSP_SCALE_OBJS): $(BUILD_FILES) dsp/scale/scale.mk + +.PHONY: o/$(MODE)/dsp/scale +o/$(MODE)/dsp/scale: $(DSP_SCALE_CHECKS) diff --git a/dsp/tty/altbuf.c b/dsp/tty/altbuf.c new file mode 100644 index 00000000..f9950284 --- /dev/null +++ b/dsp/tty/altbuf.c @@ -0,0 +1,33 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" + +/** + * Asks teletypewriter to flip to alternate display page. + * + * The alternate buffer trick lets one restore the console exactly as it + * was, once the program is done running. + */ +int ttyenablealtbuf(int ttyfd) { return ttysend(ttyfd, "\e[?1049h"); } + +/** + * Asks teletypewriter to restore blinking box thing. + */ +int ttydisablealtbuf(int ttyfd) { return ttysend(ttyfd, "\e[?1049l"); } diff --git a/dsp/tty/config.c b/dsp/tty/config.c new file mode 100644 index 00000000..bc8a624e --- /dev/null +++ b/dsp/tty/config.c @@ -0,0 +1,46 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" +#include "libc/calls/termios.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/termios.h" + +/** + * Applies configuration to teletypewriter. + * + * @param opt_out_oldconf is only modified if successful + * @return 0 on success, or -1 w/ errno + * @see ttyconfig(), ttyrestore() + */ +int ttyconfig(int ttyfd, ttyconf_f fn, int64_t arg, + const struct termios *opt_out_oldconf) { + struct termios conf[2]; + if (tcgetattr(ttyfd, &conf[0]) != -1 && + fn(memcpy(&conf[1], &conf[0], sizeof(conf[0])), arg) != -1 && + tcsetattr(ttyfd, TCSAFLUSH, &conf[1]) != -1) { + if (opt_out_oldconf) { + memcpy(opt_out_oldconf, &conf[0], sizeof(conf[0])); + } + return 0; + } else { + return -1; + } +} diff --git a/dsp/tty/describe.c b/dsp/tty/describe.c new file mode 100644 index 00000000..07defd8f --- /dev/null +++ b/dsp/tty/describe.c @@ -0,0 +1,77 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/fmt/fmt.h" +#include "libc/mem/mem.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/x/x.h" + +#define BUFFY 48 + +static char *ttydescriber(char *b, const struct TtyIdent *ti) { + switch (ti->id) { + case 0: + snprintf(b, BUFFY, "%s %d", "putty", ti->version); + break; + case 1: + if (ti->version > 1000) { + snprintf(b, BUFFY, "%s %d", "gnome terminal", ti->version); + } else { + snprintf(b, BUFFY, "%s %d", "mlterm", ti->version); + } + break; + case kTtyIdScreen: + snprintf(b, BUFFY, "%s %d", "gnu screen", ti->version); + break; + case 77: + snprintf(b, BUFFY, "%s %d", "redhat mintty", ti->version); + break; + case 41: + snprintf(b, BUFFY, "%s %d", "xterm", ti->version); + break; + case 82: + snprintf(b, BUFFY, "%s %d", "rxvt", ti->version); + break; + default: + snprintf(b, BUFFY, "%s %d %d", "unknown teletypewriter no.", ti->id, + ti->version); + break; + } + return b; +} + +/** + * Makes educated guess about name of teletypewriter. + */ +char *ttydescribe(char *out, size_t size, const struct TtyIdent *ti) { + char b1[BUFFY], b2[BUFFY]; + if (ti) { + ttydescriber(b1, ti); + if (ti->next) { + snprintf(out, size, "%s%s%s", ttydescriber(b2, ti->next), " inside ", b1); + } else { + snprintf(out, size, "%s", b1); + } + } else { + snprintf(out, size, "%s", "no tty"); + } + return out; +} diff --git a/dsp/tty/hidecursor.c b/dsp/tty/hidecursor.c new file mode 100644 index 00000000..6e798cfc --- /dev/null +++ b/dsp/tty/hidecursor.c @@ -0,0 +1,53 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/bits/pushpop.h" +#include "libc/dce.h" +#include "libc/log/log.h" +#include "libc/nt/console.h" +#include "libc/nt/runtime.h" +#include "libc/nt/struct/consolecursorinfo.h" + +static int ttysetcursor(int fd, bool visible) { + struct NtConsoleCursorInfo ntcursor; + char code[8] = "\e[?25l"; + if (isterminalinarticulate()) return 0; + if (visible) code[5] = 'h'; + if (SupportsWindows()) { + GetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor); + ntcursor.bVisible = visible; + SetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor); + } + return ttysend(fd, code); +} + +/** + * Asks teletypewriter to hide blinking box. + */ +int ttyhidecursor(int fd) { + return ttysetcursor(fd, false); +} + +/** + * Asks teletypewriter to restore blinking box. + */ +int ttyshowcursor(int fd) { + return ttysetcursor(fd, true); +} diff --git a/dsp/tty/ident.c b/dsp/tty/ident.c new file mode 100644 index 00000000..3560c270 --- /dev/null +++ b/dsp/tty/ident.c @@ -0,0 +1,95 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/bits/bits.h" +#include "libc/bits/safemacros.h" +#include "libc/calls/calls.h" +#include "libc/calls/termios.h" +#include "libc/fmt/fmt.h" +#include "libc/mem/mem.h" +#include "libc/runtime/runtime.h" +#include "libc/sock/sock.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/poll.h" +#include "libc/sysv/errfuns.h" + +static int ttyident_probe(struct TtyIdent *ti, int ttyinfd, int ttyoutfd, + const char *msg) { + ssize_t rc; + size_t got; + char buf[64]; + int id, version; + if ((rc = write(ttyoutfd, msg, strlen(msg))) != -1) { + TryAgain: + if ((rc = read(ttyinfd, buf, sizeof(buf))) != -1) { + buf[min((got = (size_t)rc), sizeof(buf) - 1)] = '\0'; + if (sscanf(buf, "\e[>%d;%d", &id, &version) >= 1) { + ti->id = id; + ti->version = version; + rc = 0; + } else { + rc = eio(); + } + } else if (errno == EINTR) { + goto TryAgain; + } else if (errno == EAGAIN) { + if (poll((struct pollfd[]){{ttyinfd, POLLIN}}, 1, 100) != 0) { + goto TryAgain; + } else { + rc = etimedout(); + } + } + } + return rc; +} + +/** + * Identifies teletypewriter. + * + * For example, we can tell if process is running in a GNU Screen + * session Gnome Terminal. + * + * @return object if TTY responds, or NULL w/ errno + * @see ttyidentclear() + */ +int ttyident(struct TtyIdent *ti, int ttyinfd, int ttyoutfd) { + int rc; + struct termios old; + struct TtyIdent outer; + rc = -1; + if (!IsWindows()) { + if (ttyconfig(ttyinfd, ttysetrawdeadline, 3, &old) != -1) { + if (ttyident_probe(ti, ttyinfd, ttyoutfd, "\e[>c") != -1) { + rc = 0; + memset(&outer, 0, sizeof(outer)); + if (ti->id == 83 /* GNU Screen */ && (ti->next || weaken(malloc)) && + ttyident_probe(&outer, ttyinfd, ttyoutfd, "\eP\e[>c\e\\") != -1 && + (ti->next = (ti->next ? ti->next + : weaken(malloc)(sizeof(struct TtyIdent))))) { + memcpy(ti->next, &outer, sizeof(outer)); + } else { + free_s(&ti->next); + } + } + ttyrestore(ttyinfd, &old); + } + } + return rc; +} diff --git a/dsp/tty/identclear.c b/dsp/tty/identclear.c new file mode 100644 index 00000000..9eded590 --- /dev/null +++ b/dsp/tty/identclear.c @@ -0,0 +1,43 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" +#include "libc/mem/mem.h" +#include "libc/runtime/runtime.h" +#include "libc/str/str.h" + +static void ttyidentfree(struct TtyIdent *ti) { + if (ti) { + assert(ti != ti->next); + ttyidentfree(ti->next); + free_s(&ti); + } +} + +/** + * Destroys TtyIdent object. + * + * @see ttyident() + */ +void ttyidentclear(struct TtyIdent *ti) { + assert(ti != ti->next); + ttyidentfree(ti->next); + memset(ti, 0, sizeof(*ti)); +} diff --git a/dsp/tty/internal.h b/dsp/tty/internal.h new file mode 100644 index 00000000..02ea1d1d --- /dev/null +++ b/dsp/tty/internal.h @@ -0,0 +1,33 @@ +#ifndef COSMOPOLITAN_DSP_TTY_INTERNAL_H_ +#define COSMOPOLITAN_DSP_TTY_INTERNAL_H_ +#include "dsp/tty/ttyrgb.h" +#include "libc/bits/xmmintrin.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct TtyRgb rgb2tty24f_(__m128); +struct TtyRgb rgb2ttyf2i_(__m128); +struct TtyRgb rgb2ttyi2f_(int, int, int); +struct TtyRgb rgb2ansi_(int, int, int); +struct TtyRgb rgb2ansihash_(int, int, int); +struct TtyRgb rgb2xterm24_(int, int, int); +struct TtyRgb rgb2xterm256gray_(__m128); +struct TtyRgb tty2rgb_(struct TtyRgb); +struct TtyRgb tty2rgb24_(struct TtyRgb); +__m128 tty2rgbf_(struct TtyRgb); +__m128 tty2rgbf24_(struct TtyRgb); + +char *setbg16_(char *, struct TtyRgb); +char *setfg16_(char *, struct TtyRgb); +char *setbgfg16_(char *, struct TtyRgb, struct TtyRgb); +char *setbg256_(char *, struct TtyRgb); +char *setfg256_(char *, struct TtyRgb); +char *setbgfg256_(char *, struct TtyRgb, struct TtyRgb); +char *setbg24_(char *, struct TtyRgb); +char *setfg24_(char *, struct TtyRgb); +char *setbgfg24_(char *, struct TtyRgb, struct TtyRgb); +struct TtyRgb rgb2ansi8_(int, int, int); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_INTERNAL_H_ */ diff --git a/dsp/tty/itoa8.c b/dsp/tty/itoa8.c new file mode 100644 index 00000000..c7ecffb1 --- /dev/null +++ b/dsp/tty/itoa8.c @@ -0,0 +1,51 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/itoa8.h" +#include "libc/bits/bits.h" +#include "libc/str/str.h" + +struct Itoa8 kItoa8; + +static nooptimize textstartup void itoa8init(void) { + size_t i; + uint8_t z; + char p[4]; + /*102*/ + for (i = 0; i < 256; ++i) { + memset(p, 0, sizeof(p)); + if (i < 10) { + z = 1; + p[0] = '0' + i; + } else if (i < 100) { + z = 2; + p[0] = '0' + i / 10; + p[1] = '0' + i % 10; + } else { + z = 3; + p[0] = '0' + i / 100; + p[1] = '0' + i % 100 / 10; + p[2] = '0' + i % 100 % 10; + } + kItoa8.size[i] = z; + memcpy(&kItoa8.data[i], p, sizeof(p)); + } +} + +INITIALIZER(301, _init_itoa8, itoa8init()); diff --git a/dsp/tty/itoa8.h b/dsp/tty/itoa8.h new file mode 100644 index 00000000..3c384905 --- /dev/null +++ b/dsp/tty/itoa8.h @@ -0,0 +1,21 @@ +#ifndef COSMOPOLITAN_DSP_TTY_ITOA8_H_ +#define COSMOPOLITAN_DSP_TTY_ITOA8_H_ +#include "libc/str/str.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct Itoa8 { + uint8_t size[256]; + uint32_t data[256]; +}; + +extern struct Itoa8 kItoa8; + +forceinline char *itoa8(char *p, uint8_t c) { + memcpy(p, &kItoa8.data[c], 4); + return p + kItoa8.size[c]; +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_ITOA8_H_ */ diff --git a/dsp/tty/kcgapalette.c b/dsp/tty/kcgapalette.c new file mode 100644 index 00000000..89fbd05b --- /dev/null +++ b/dsp/tty/kcgapalette.c @@ -0,0 +1,29 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "dsp/tty/quant.h" + +const ttypalette_t kCgaPalette = { + [0][0] = {0, 0, 0, 0}, /* normal black: \e[30m (or \e[38;5;0m) */ + [1][0] = {85, 85, 85, 8}, /* bright black: \e[90m (or \e[38;5;8m) */ + [0][1] = {170, 0, 0, 1}, /* normal red: \e[31m */ + [1][1] = {255, 85, 85, 9}, /* bright red: \e[91m (or \e[1;31m) */ + [0][2] = {0, 170, 0, 2}, /* normal green: \e[32m */ + [1][2] = {85, 255, 85, 10}, /* bright green: \e[92m */ + [0][3] = {170, 85, 0, 3}, /* normal yellow: \e[33m */ + [1][3] = {255, 255, 85, 11}, /* bright yellow: \e[93m */ + [0][4] = {0, 0, 170, 4}, /* normal blue: \e[34m */ + [1][4] = {85, 85, 255, 12}, /* bright blue: \e[94m */ + [0][5] = {170, 0, 170, 5}, /* normal magenta: \e[35m */ + [1][5] = {255, 85, 255, 13}, /* bright magenta: \e[95m */ + [0][6] = {0, 170, 170, 6}, /* normal cyan: \e[36m */ + [1][6] = {85, 255, 255, 14}, /* bright cyan: \e[96m */ + [0][7] = {170, 170, 170, 7}, /* normal white: \e[37m */ + [1][7] = {255, 255, 255, 15}, /* bright white: \e[97m */ +}; diff --git a/dsp/tty/ktangopalette.c b/dsp/tty/ktangopalette.c new file mode 100644 index 00000000..e40e8c04 --- /dev/null +++ b/dsp/tty/ktangopalette.c @@ -0,0 +1,29 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "dsp/tty/quant.h" + +const ttypalette_t kTangoPalette = { + [0][0] = {0x2E, 0x34, 0x36, 0}, /* aluminium1 */ + [1][0] = {0x55, 0x57, 0x53, 8}, + [0][1] = {0xCC, 0x00, 0x00, 1}, /* scarietred */ + [1][1] = {0xEF, 0x29, 0x29, 9}, + [0][2] = {0x4E, 0x9A, 0x06, 2}, /* chameleon */ + [1][2] = {0x8A, 0xE2, 0x34, 10}, + [0][3] = {0xC4, 0xA0, 0x00, 3}, /* butter */ + [1][3] = {0xFC, 0xE9, 0x4F, 11}, + [0][4] = {0x34, 0x65, 0xA4, 4}, /* skyblue */ + [1][4] = {0x72, 0x9F, 0xCF, 12}, + [0][5] = {0x75, 0x50, 0x7B, 5}, /* plum */ + [1][5] = {0xAD, 0x7F, 0xA8, 13}, + [0][6] = {0x06, 0x98, 0x9A, 6}, /* cyan */ + [1][6] = {0x34, 0xE2, 0xE2, 14}, + [0][7] = {0xD3, 0xD7, 0xCF, 7}, /* aluminium2 */ + [1][7] = {0xEE, 0xEE, 0xEC, 15}, +}; diff --git a/dsp/tty/kxtermcubesteps.c b/dsp/tty/kxtermcubesteps.c new file mode 100644 index 00000000..8dc4518e --- /dev/null +++ b/dsp/tty/kxtermcubesteps.c @@ -0,0 +1,22 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" + +const uint8_t kXtermCubeSteps[] = {0, 0137, 0207, 0257, 0327, 0377}; diff --git a/dsp/tty/kxtermpalette.c b/dsp/tty/kxtermpalette.c new file mode 100644 index 00000000..bd1acecb --- /dev/null +++ b/dsp/tty/kxtermpalette.c @@ -0,0 +1,29 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "dsp/tty/quant.h" + +const ttypalette_t kXtermPalette = { + [0][0] = {0, 0, 0, 0}, /* normal black: \e[30m (or \e[38;5;0m) */ + [1][0] = {127, 127, 127, 8}, /* bright black: \e[90m (or \e[38;5;8m) */ + [0][1] = {205, 0, 0, 1}, /* normal red: \e[31m */ + [1][1] = {255, 0, 0, 9}, /* bright red: \e[91m (or \e[1;31m) */ + [0][2] = {0, 205, 0, 2}, /* normal green: \e[32m */ + [1][2] = {0, 255, 0, 10}, /* bright green: \e[92m */ + [0][3] = {205, 205, 0, 3}, /* normal yellow: \e[33m */ + [1][3] = {255, 255, 0, 11}, /* bright yellow: \e[93m */ + [0][4] = {0, 0, 238, 4}, /* normal blue: \e[34m */ + [1][4] = {92, 92, 255, 12}, /* bright blue: \e[94m */ + [0][5] = {205, 0, 205, 5}, /* normal magenta: \e[35m */ + [1][5] = {255, 0, 255, 13}, /* bright magenta: \e[95m */ + [0][6] = {0, 205, 205, 6}, /* normal cyan: \e[36m */ + [1][6] = {0, 255, 255, 14}, /* bright cyan: \e[96m */ + [0][7] = {229, 229, 229, 7}, /* normal white: \e[37m */ + [1][7] = {255, 255, 255, 15}, /* bright white: \e[97m */ +}; diff --git a/dsp/tty/mpsadbw.S b/dsp/tty/mpsadbw.S new file mode 100644 index 00000000..99a0b926 --- /dev/null +++ b/dsp/tty/mpsadbw.S @@ -0,0 +1,29 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" + +/ TODO(jart): write me + + movdqa a,%xmm0 + mpsadbw $0,inv,%xmm0 + + .rodata.cst32 +a: .byte 1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 +inv: .byte 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 diff --git a/dsp/tty/quant.h b/dsp/tty/quant.h new file mode 100644 index 00000000..93e06ca2 --- /dev/null +++ b/dsp/tty/quant.h @@ -0,0 +1,84 @@ +#ifndef DSP_TTY_QUANT_H_ +#define DSP_TTY_QUANT_H_ +#include "dsp/tty/ttyrgb.h" +#include "libc/assert.h" +#include "libc/bits/bits.h" +#include "libc/bits/xmmintrin.h" +#include "libc/limits.h" +#include "libc/str/str.h" +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +#define TL 0 +#define TR 1 +#define BL 2 +#define BR 3 + +typedef __m128 (*tty2rgbf_f)(struct TtyRgb); +typedef char *(*setbg_f)(char *, struct TtyRgb); +typedef char *(*setbgfg_f)(char *, struct TtyRgb, struct TtyRgb); +typedef char *(*setfg_f)(char *, struct TtyRgb); +typedef struct TtyRgb (*rgb2tty_f)(int, int, int); +typedef struct TtyRgb (*rgb2ttyf_f)(__m128); +typedef struct TtyRgb (*tty2rgb_f)(struct TtyRgb); +typedef struct TtyRgb ttypalette_t[2][8]; + +struct TtyQuant { + enum TtyQuantizationAlgorithm { + kTtyQuantAnsi, + kTtyQuantTrue, + kTtyQuantXterm256, + } alg; + enum TtyBlocksSelection { + kTtyBlocksUnicode, + kTtyBlocksCp437, + } blocks; + enum TtyQuantizationChannels { + kTtyQuantGrayscale = 1, + kTtyQuantRgb = 3, + } chans; + unsigned min; + unsigned max; + setbg_f setbg; + setfg_f setfg; + setbgfg_f setbgfg; + rgb2tty_f rgb2tty; + rgb2ttyf_f rgb2ttyf; + tty2rgb_f tty2rgb; + tty2rgbf_f tty2rgbf; + const ttypalette_t *palette; +}; + +extern const ttypalette_t kCgaPalette; +extern const ttypalette_t kXtermPalette; +extern const ttypalette_t kTangoPalette; + +extern const uint8_t kXtermCubeSteps[6]; +extern double g_xterm256_gamma; +extern struct TtyRgb g_ansi2rgb_[256]; +extern struct TtyQuant g_ttyquant_; +extern const uint8_t kXtermXlat[2][256]; + +void ttyquantinit(enum TtyQuantizationAlgorithm, enum TtyQuantizationChannels, + enum TtyBlocksSelection); + +extern char *ttyraster(char *, const struct TtyRgb *, size_t, size_t, + struct TtyRgb, struct TtyRgb); + +#define ttyquant() (&g_ttyquant_) +#define TTYQUANT() VEIL("r", &g_ttyquant_) +#define rgb2tty(...) (ttyquant()->rgb2tty(__VA_ARGS__)) +#define tty2rgb(...) (ttyquant()->tty2rgb(__VA_ARGS__)) +#define rgb2ttyf(...) (ttyquant()->rgb2ttyf(__VA_ARGS__)) +#define tty2rgbf(...) (ttyquant()->tty2rgbf(__VA_ARGS__)) +#define setbg(...) (ttyquant()->setbg(__VA_ARGS__)) +#define setfg(...) (ttyquant()->setfg(__VA_ARGS__)) +#define setbgfg(...) (ttyquant()->setbgfg(__VA_ARGS__)) + +forceinline bool ttyeq(struct TtyRgb x, struct TtyRgb y) { + return x.r == y.r && x.g == y.g && x.b == y.b; +} + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* DSP_TTY_QUANT_H_ */ diff --git a/dsp/tty/quantinit.c b/dsp/tty/quantinit.c new file mode 100644 index 00000000..07caa3e1 --- /dev/null +++ b/dsp/tty/quantinit.c @@ -0,0 +1,78 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/internal.h" +#include "dsp/tty/quant.h" +#include "libc/dce.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" + +struct TtyQuant g_ttyquant_; + +/** + * Chooses xterm quantization mode. + */ +optimizesize textstartup void ttyquantinit(enum TtyQuantizationAlgorithm alg, + enum TtyQuantizationChannels chans, + enum TtyBlocksSelection blocks) { + switch (alg) { + case kTtyQuantAnsi: + TTYQUANT()->rgb2tty = rgb2ansi_; + TTYQUANT()->rgb2ttyf = rgb2ttyf2i_; + TTYQUANT()->tty2rgb = tty2rgb_; + TTYQUANT()->tty2rgbf = tty2rgbf_; + TTYQUANT()->setbg = setbg16_; + TTYQUANT()->setfg = setfg16_; + TTYQUANT()->setbgfg = setbgfg16_; + TTYQUANT()->min = 0; + TTYQUANT()->max = 16; + break; + case kTtyQuantTrue: + TTYQUANT()->rgb2tty = rgb2xterm24_; + TTYQUANT()->rgb2ttyf = rgb2tty24f_; + TTYQUANT()->tty2rgb = tty2rgb24_; + TTYQUANT()->tty2rgbf = tty2rgbf24_; + TTYQUANT()->setbg = setbg24_; + TTYQUANT()->setfg = setfg24_; + TTYQUANT()->setbgfg = setbgfg24_; + TTYQUANT()->min = 16; + TTYQUANT()->max = 256; + break; + case kTtyQuantXterm256: + TTYQUANT()->rgb2tty = rgb2ansi_; + TTYQUANT()->rgb2ttyf = rgb2ttyf2i_; + TTYQUANT()->tty2rgb = tty2rgb_; + TTYQUANT()->tty2rgbf = tty2rgbf_; + TTYQUANT()->setbg = setbg256_; + TTYQUANT()->setfg = setfg256_; + TTYQUANT()->setbgfg = setbgfg256_; + TTYQUANT()->min = 16; + TTYQUANT()->max = 256; + break; + default: + abort(); + } + TTYQUANT()->chans = chans; + TTYQUANT()->alg = alg; + TTYQUANT()->blocks = blocks; +} + +INITIALIZER(400, _init_ttyquant, + ttyquantinit(kTtyQuantXterm256, kTtyQuantRgb, kTtyBlocksUnicode)); diff --git a/dsp/tty/restore.c b/dsp/tty/restore.c new file mode 100644 index 00000000..18e4edfc --- /dev/null +++ b/dsp/tty/restore.c @@ -0,0 +1,29 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/calls/termios.h" +#include "libc/sysv/consts/termios.h" + +/** + * Puts teletypewriter back into previous configuration. + */ +int ttyrestore(int ttyoutfd, const struct termios *conf) { + return tcsetattr(ttyoutfd, TCSADRAIN, conf); +} diff --git a/dsp/tty/rgb2ansi.c b/dsp/tty/rgb2ansi.c new file mode 100644 index 00000000..f418d0ec --- /dev/null +++ b/dsp/tty/rgb2ansi.c @@ -0,0 +1,129 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/core.h" +#include "dsp/tty/quant.h" +#include "libc/assert.h" +#include "libc/limits.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/str/str.h" + +#define CUTOFF_VALUE 200 + +#define DIST(X, Y) ((X) - (Y)) +#define SQR(X) ((X) * (X)) +#define SUM(X, Y, Z) ((X) + (Y) + (Z)) + +static const uint8_t kXtermCube[] = {0, 0137, 0207, 0257, 0327, 0377}; +struct TtyRgb g_ansi2rgb_[256]; +static uint8_t g_quant[256]; +static uint8_t g_rindex[256]; +static uint8_t g_gindex[256]; +static uint8_t g_bindex[256]; +double g_xterm256_gamma; + +struct TtyRgb tty2rgb_(struct TtyRgb rgbxt) { + return g_ansi2rgb_[rgbxt.xt]; +} + +__m128 tty2rgbf_(struct TtyRgb rgbxt) { + rgbxt = g_ansi2rgb_[rgbxt.xt]; + return (__m128){(int)rgbxt.r, (int)rgbxt.g, (int)rgbxt.b} / 255; +} + +static int rgb2xterm256_(int r, int g, int b) { + int cerr, gerr, ir, ig, ib, gray, grai, cr, cg, cb, gv; + gray = round(r * .299 + g * .587 + b * .114); + grai = gray > 238 ? 23 : (gray - 3) / 10; + ir = r < 48 ? 0 : r < 115 ? 1 : (r - 35) / 40; + ig = g < 48 ? 0 : g < 115 ? 1 : (g - 35) / 40; + ib = b < 48 ? 0 : b < 115 ? 1 : (b - 35) / 40; + cr = kXtermCube[ir]; + cg = kXtermCube[ig]; + cb = kXtermCube[ib]; + gv = 8 + 10 * grai; + cerr = SQR(DIST(cr, r)) + SQR(DIST(cg, g)) + SQR(DIST(cb, b)); + gerr = SQR(DIST(gv, r)) + SQR(DIST(gv, g)) + SQR(DIST(gv, b)); + if (cerr <= gerr) { + return 16 + 36 * ir + 6 * ig + ib; + } else { + return 232 + grai; + } +} + +/** + * Quantizes RGB to ANSI w/ euclidean distance in 3D color space. + */ +struct TtyRgb rgb2ansi_(int r, int g, int b) { + uint32_t d, least; + size_t c, best, min, max; + r = MAX(MIN(r, 255), 0); + g = MAX(MIN(g, 255), 0); + b = MAX(MIN(b, 255), 0); + min = ttyquant()->min; + max = ttyquant()->max; + if (min == 16 && max == 256) { + return (struct TtyRgb){r, g, b, rgb2xterm256_(r, g, b)}; + } else { + least = UINT32_MAX; + best = 0; + for (c = min; c < max; c++) { + d = SUM(SQR(DIST(g_ansi2rgb_[c].r, r)), SQR(DIST(g_ansi2rgb_[c].g, g)), + SQR(DIST(g_ansi2rgb_[c].b, b))); + if (d < least) { + least = d; + best = c; + } + } + return (struct TtyRgb){r, g, b, best}; + } +} + +static int uncube(int x) { + return x < 48 ? 0 : x < 115 ? 1 : (x - 35) / 40; +} + +static optimizesize textstartup void xterm2rgbsetup_(void) { + uint8_t c, y; + uint32_t i, j; + memcpy(g_ansi2rgb_, &kCgaPalette, sizeof(kCgaPalette)); + for (i = 0; i < 256; ++i) { + j = uncube(i); + g_quant[i] = kXtermCube[j]; + g_rindex[i] = j * 36; + g_gindex[i] = j * 6; + g_bindex[i] = j + 16; + } + for (i = 16; i < 232; ++i) { + g_ansi2rgb_[i].r = kXtermCube[((i - 020) / 044) % 06]; + g_ansi2rgb_[i].g = kXtermCube[((i - 020) / 06) % 06]; + g_ansi2rgb_[i].b = kXtermCube[(i - 020) % 06]; + g_ansi2rgb_[i].xt = i; + } + for (i = 232, c = 8; i < 256; i++, c += 10) { + g_ansi2rgb_[i].r = c; + g_ansi2rgb_[i].g = c; + g_ansi2rgb_[i].b = c; + g_ansi2rgb_[i].xt = i; + } +} + +INITIALIZER(301, _init_ansi2rgb, xterm2rgbsetup_()); diff --git a/dsp/tty/rgb2ttyf2i.c b/dsp/tty/rgb2ttyf2i.c new file mode 100644 index 00000000..de6cbf20 --- /dev/null +++ b/dsp/tty/rgb2ttyf2i.c @@ -0,0 +1,29 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" +#include "libc/bits/xmmintrin.h" + +struct TtyRgb rgb2ttyf2i_(__m128 rgb) { + __v4si i4; + rgb *= 255; + /* i4 = __builtin_ia32_cvtps2dq(rgb); */ + asm("cvttps2dq\t%0,%1" : "+%x"(rgb), "=x"(i4)); + return rgb2tty(i4[0], i4[1], i4[2]); +} diff --git a/dsp/tty/rgb2ttyi2f.c b/dsp/tty/rgb2ttyi2f.c new file mode 100644 index 00000000..377c9548 --- /dev/null +++ b/dsp/tty/rgb2ttyi2f.c @@ -0,0 +1,26 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" +#include "libc/log/check.h" +#include "libc/macros.h" + +struct TtyRgb rgb2ttyi2f_(int r, int g, int b) { + return rgb2ttyf((__m128){r, g, b} / 255); +} diff --git a/dsp/tty/rgb2xterm24.c b/dsp/tty/rgb2xterm24.c new file mode 100644 index 00000000..5f088890 --- /dev/null +++ b/dsp/tty/rgb2xterm24.c @@ -0,0 +1,26 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" +#include "libc/macros.h" + +struct TtyRgb rgb2xterm24_(int r, int g, int b) { + return (struct TtyRgb){MAX(MIN(r, 255), 0), MAX(MIN(g, 255), 0), + MAX(MIN(b, 255), 0), 0}; +} diff --git a/dsp/tty/rgb2xterm24f.c b/dsp/tty/rgb2xterm24f.c new file mode 100644 index 00000000..8617bc0b --- /dev/null +++ b/dsp/tty/rgb2xterm24f.c @@ -0,0 +1,42 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" +#include "libc/math.h" + +/* +struct TtyRgb rgb2tty24f_(__m128 rgb) { + const __v4si kMax = {255, 255, 255, 255}; + const __v4si kMin = {0, 0, 0, 0}; + struct TtyRgb res; + __v4si rgb255; + rgb255 = _mm_min_ps(_mm_max_ps(_mm_cvtps_epi32(rgb * 255), kMin), kMax); + res = (struct TtyRgb){rgb255[0], rgb255[1], rgb255[2], rgb255[3]}; + return res; +} +*/ + +struct TtyRgb rgb2tty24f_(__m128 rgb) { + const __m128 kMax = {1, 1, 1, 1}; + const __m128 kMin = {0, 0, 0, 0}; + struct TtyRgb res; + rgb = _mm_min_ps(_mm_max_ps(rgb, kMin), kMax) * 255; + res = (struct TtyRgb){rgb[0], rgb[1], rgb[2], rgb[3]}; + return res; +} diff --git a/dsp/tty/rgb2xterm256.c b/dsp/tty/rgb2xterm256.c new file mode 100644 index 00000000..3f37a1f6 --- /dev/null +++ b/dsp/tty/rgb2xterm256.c @@ -0,0 +1,71 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/rgb2xterm256.h" + +/* 1bc */ +forceinline int sqr(int x) { return x * x; } +/* forceinline int dst6(int x) { return x * x; } */ +int rgb2xterm256v2(int r, int g, int b) { + static const int i2cv[] = {0, 0137, 0207, 0257, 0327, 0377, 0377}; +#define v2ci(v) (v < 060 ? 0 : v < 0163 ? 01 : (v - 043) / 050) +#define dst6(A, B, C, a, b, c) (sqr(A - a) + sqr(B - b) + sqr(C - c)) + int ir = v2ci(r); + int ig = v2ci(g); + int ib = v2ci(b); + int avg = (r + g + b) / 3; + int cr = i2cv[ir]; + int cg = i2cv[ig]; + int cb = i2cv[ib]; + int gidx = avg > 238 ? 23 : (avg - 3) / 10; + int gv = 8 + 10 * gidx; + int cerr = dst6(cr, cg, cb, r, g, b); + int gerr = dst6(gv, gv, gv, r, g, b); + return cerr <= gerr ? 16 + (36 * ir + 6 * ig + ib) : 232 + gidx; +#undef dst6 +#undef cidx +#undef v2ci +} + +/* 1e3 */ +// Convert RGB24 to xterm-256 8-bit value +// For simplicity, assume RGB space is perceptually uniform. +// There are 5 places where one of two outputs needs to be chosen when +// input is the exact middle: +// - The r/g/b channels and the gray value: choose higher value output +// - If gray and color have same distance from input - choose color +int rgb2xterm256(uint8_t r, uint8_t g, uint8_t b) { + // Calculate the nearest 0-based color index at 16 .. 231 +#define v2ci(v) (v < 48 ? 0 : v < 115 ? 1 : (v - 35) / 40) + int ir = v2ci(r), ig = v2ci(g), ib = v2ci(b); // 0..5 each +#define color_index() (36 * ir + 6 * ig + ib) /* 0..215, lazy eval */ + // Calculate the nearest 0-based gray index at 232 .. 255 + int average = (r + g + b) / 3; + int gray_index = average > 238 ? 23 : (average - 3) / 10; // 0..23 + // Calculate the represented colors back from the index + static const int i2cv[6] = {0, 0x5f, 0x87, 0xaf, 0xd7, 0xff}; + int cr = i2cv[ir], cg = i2cv[ig], cb = i2cv[ib]; // r/g/b, 0..255 each + int gv = 8 + 10 * gray_index; // same value for r/g/b, 0..255 +// Return the one which is nearer to the original input rgb value +#define dist_square(A, B, C, a, b, c) \ + ((A - a) * (A - a) + (B - b) * (B - b) + (C - c) * (C - c)) + int color_err = dist_square(cr, cg, cb, r, g, b); + int gray_err = dist_square(gv, gv, gv, r, g, b); + return color_err <= gray_err ? 16 + color_index() : 232 + gray_index; +} diff --git a/dsp/tty/rgb2xterm256.h b/dsp/tty/rgb2xterm256.h new file mode 100644 index 00000000..071de016 --- /dev/null +++ b/dsp/tty/rgb2xterm256.h @@ -0,0 +1,11 @@ +#ifndef COSMOPOLITAN_DSP_TTY_RGB2XTERM256_H_ +#define COSMOPOLITAN_DSP_TTY_RGB2XTERM256_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +int rgb2xterm256(uint8_t, uint8_t, uint8_t); +int rgb2xterm256v2(int, int, int); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_RGB2XTERM256_H_ */ diff --git a/dsp/tty/savecursor.c b/dsp/tty/savecursor.c new file mode 100644 index 00000000..41d15654 --- /dev/null +++ b/dsp/tty/savecursor.c @@ -0,0 +1,30 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" + +/** + * Asks teletypewriter to push current position. + */ +int ttysavecursor(int ttyfd) { return ttysend(ttyfd, "\e[s"); } + +/** + * Asks teletypewriter to pop previous position. + */ +int ttyrestorecursor(int ttyfd) { return ttysend(ttyfd, "\e[u"); } diff --git a/dsp/tty/send.c b/dsp/tty/send.c new file mode 100644 index 00000000..55366653 --- /dev/null +++ b/dsp/tty/send.c @@ -0,0 +1,30 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/str/str.h" + +/** + * Sends data to teletypewriter. + * + * This function blocks until the full amount is transmitted. + * + * @return 0 on success, or -1 w/ errno + */ +int ttysend(int fd, const char *str) { return ttywrite(fd, str, strlen(str)); } diff --git a/dsp/tty/sendtitle.c b/dsp/tty/sendtitle.c new file mode 100644 index 00000000..499379f3 --- /dev/null +++ b/dsp/tty/sendtitle.c @@ -0,0 +1,41 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/alg/arraylist2.h" +#include "libc/runtime/gc.h" +#include "libc/x/x.h" + +/** + * Changes text in title bar of pseudo-teletypewriter window. + * + * @param title is trustworthy text without any BEL characters + * @param ti comes from ttyident() and null means no-op + */ +int ttysendtitle(int ttyfd, const char *title, const struct TtyIdent *ti) { + if (ti) { + if (ti->id == kTtyIdScreen) { + return ttysend(ttyfd, gc(xstrcat("\eP\e]0;", title, "\a\e\\"))); + } else { + return ttysend(ttyfd, gc(xstrcat("\e]0;", title, "\a"))); + } + } else { + return 0; + } +} diff --git a/dsp/tty/setansipalette.c b/dsp/tty/setansipalette.c new file mode 100644 index 00000000..774c1a73 --- /dev/null +++ b/dsp/tty/setansipalette.c @@ -0,0 +1,25 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" +#include "libc/str/str.h" + +void setansipalette(ttypalette_t palette) { + memcpy(g_ansi2rgb_, palette, sizeof(struct TtyRgb) * 2 * 8); +} diff --git a/dsp/tty/setbgfg16.c b/dsp/tty/setbgfg16.c new file mode 100644 index 00000000..6adca49d --- /dev/null +++ b/dsp/tty/setbgfg16.c @@ -0,0 +1,43 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/itoa8.h" +#include "dsp/tty/quant.h" +#include "libc/limits.h" + +static char *ansitoa(char *p, unsigned xt, unsigned base) { + if (xt >= 8) xt -= 8, base += 60; + return itoa8(p, xt + base); +} + +static char *setansibgfg(char *p, unsigned bg, unsigned fg) { + *p++ = '\e'; + *p++ = '['; + if (bg != -1u) p = ansitoa(p, bg, 40); + if (bg != -1u && fg != -1u) *p++ = ';'; + if (fg != -1u) p = ansitoa(p, fg, 30); + *p++ = 'm'; + return p; +} + +char *setbg16_(char *p, struct TtyRgb bg) { return setansibgfg(p, bg.xt, -1u); } +char *setfg16_(char *p, struct TtyRgb fg) { return setansibgfg(p, -1u, fg.xt); } +char *setbgfg16_(char *p, struct TtyRgb bg, struct TtyRgb fg) { + return setansibgfg(p, bg.xt, fg.xt); +} diff --git a/dsp/tty/setbgfg24.c b/dsp/tty/setbgfg24.c new file mode 100644 index 00000000..6425b820 --- /dev/null +++ b/dsp/tty/setbgfg24.c @@ -0,0 +1,54 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/itoa8.h" +#include "dsp/tty/quant.h" +#include "libc/str/str.h" + +static char *rgbcpy(char *p, struct TtyRgb bg) { + memcpy(p, ";2;\0", 4); + p = itoa8(p + 3, bg.r); + *p++ = ';'; + p = itoa8(p, bg.g); + *p++ = ';'; + return itoa8(p, bg.b); +} + +char *setbg24_(char *p, struct TtyRgb bg) { + memcpy(p, "\e[48", 4); + p = rgbcpy(p + 4, bg); + *p++ = 'm'; + return p; +} + +char *setfg24_(char *p, struct TtyRgb fg) { + memcpy(p, "\e[38", 4); + p = rgbcpy(p + 4, fg); + *p++ = 'm'; + return p; +} + +char *setbgfg24_(char *p, struct TtyRgb bg, struct TtyRgb fg) { + memcpy(p, "\e[48", 4); + p = rgbcpy(p + 4, bg); + memcpy(p, ";38\0", 4); + p = rgbcpy(p + 3, fg); + *p++ = 'm'; + return p; +} diff --git a/dsp/tty/setbgfg256.c b/dsp/tty/setbgfg256.c new file mode 100644 index 00000000..6b7ea202 --- /dev/null +++ b/dsp/tty/setbgfg256.c @@ -0,0 +1,48 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/itoa8.h" +#include "dsp/tty/quant.h" + +char *setbg256_(char *p, struct TtyRgb bg) { + memcpy(p, "\e[48", 4); + memcpy(p + 4, ";5;\0", 4); + p = itoa8(p + 7, bg.xt); + *p++ = 'm'; + return p; +} + +char *setfg256_(char *p, struct TtyRgb fg) { + memcpy(p, "\e[38", 4); + memcpy(p + 4, ";5;\0", 4); + p = itoa8(p + 7, fg.xt); + *p++ = 'm'; + return p; +} + +char *setbgfg256_(char *p, struct TtyRgb bg, struct TtyRgb fg) { + memcpy(p, "\e[48", 4); + memcpy(p + 4, ";5;\0", 4); + p = itoa8(p + 7, bg.xt); + memcpy(p, ";38;", 4); + memcpy(p + 4, "5;\0", 4); + p = itoa8(p + 6, fg.xt); + *p++ = 'm'; + return p; +} diff --git a/dsp/tty/setraw.c b/dsp/tty/setraw.c new file mode 100644 index 00000000..c6a5daa4 --- /dev/null +++ b/dsp/tty/setraw.c @@ -0,0 +1,52 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/calls/termios.h" +#include "libc/sysv/consts/termios.h" + +/** + * Enables direct teletypewriter communication. + * + * @see ttyconfig(), ttyrestore() + */ +int ttysetraw(struct termios *conf, int64_t flags) { + conf->c_iflag &= ~(INPCK | ISTRIP | PARMRK | INLCR | IGNCR | ICRNL | IXON); + conf->c_lflag &= ~(IEXTEN | ICANON); + conf->c_cflag &= ~(CSIZE | PARENB); + conf->c_cflag |= CS8; + conf->c_iflag |= IUTF8; + /* if (flags & kTtyLfToCrLf) { */ + /* /\* conf->c_oflag &= ~(OLCUC | OCRNL | ONLRET | OFILL | OFDEL); *\/ */ + /* /\* conf->c_oflag |= ONLCR | ONOCR; *\/ */ + /* conf->c_oflag |= ONLCR; */ + /* } else { */ + /* conf->c_oflag &= ~OPOST; */ + /* } */ + if (!(flags & kTtySigs)) { + conf->c_iflag &= ~(IGNBRK | BRKINT); + conf->c_lflag &= ~(ISIG); + } + if (flags & kTtyEcho) { + conf->c_lflag |= ECHO | ECHONL; + } else { + conf->c_lflag &= ~(ECHO | ECHONL); + } + return 0; +} diff --git a/dsp/tty/setrawdeadline.c b/dsp/tty/setrawdeadline.c new file mode 100644 index 00000000..3664c3e5 --- /dev/null +++ b/dsp/tty/setrawdeadline.c @@ -0,0 +1,34 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" +#include "libc/calls/termios.h" +#include "libc/sysv/consts/termios.h" + +/** + * Enables direct teletypewriter communication w/ read timeouts. + * @see ttyconfig(), ttyrestore() + */ +int ttysetrawdeadline(struct termios *conf, int64_t deciseconds) { + assert(0 < deciseconds && deciseconds < 256); + conf->c_cc[VMIN] = 0; + conf->c_cc[VTIME] = deciseconds; + return ttysetraw(conf, 0); +} diff --git a/dsp/tty/setrawmode.c b/dsp/tty/setrawmode.c new file mode 100644 index 00000000..211beae9 --- /dev/null +++ b/dsp/tty/setrawmode.c @@ -0,0 +1,33 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" +#include "libc/calls/termios.h" +#include "libc/sysv/consts/termios.h" + +/** + * Enables blocking raw mode for teletypewriter w/ recommended settings. + * @see ttyconfig(), ttyrestore() + */ +int ttysetrawmode(struct termios *conf, int64_t flags) { + conf->c_cc[VMIN] = 1; + conf->c_cc[VTIME] = 1; + return ttysetraw(conf, flags); +} diff --git a/dsp/tty/tty.h b/dsp/tty/tty.h new file mode 100644 index 00000000..be4f53ac --- /dev/null +++ b/dsp/tty/tty.h @@ -0,0 +1,59 @@ +#ifndef COSMOPOLITAN_DSP_TTY_TTY_H_ +#define COSMOPOLITAN_DSP_TTY_TTY_H_ + +#define kTtyIdScreen 83 + +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct FILE; +struct termios; + +struct TtyIdent { + int id; /* first number sent back by \e[>c */ + int version; /* second number sent back by \e[>c */ + struct TtyIdent *next; /* yo dawg */ +}; + +struct TtyCursor { + int y; + int x; + int bg; + int fg; +}; + +enum TtyRawFlags { + kTtyEcho = 1 << 0, /* echo input */ + kTtyCursor = 1 << 1, /* show cursor */ + kTtySigs = 1 << 2, /* auto raise() on CTRL+C, CTRL+Z, and CTRL+\ */ + kTtyLfToCrLf = 1 << 3, /* enables unix newline magic */ +}; + +typedef int (*ttyconf_f)(struct termios *, int64_t); + +int ttyraw(enum TtyRawFlags); +int ttyhidecursor(int); +int ttyshowcursor(int); +int ttysavecursor(int); +int ttyrestorecursor(int); +int ttyenablealtbuf(int); +int ttydisablealtbuf(int); +int ttysend(int, const char *); +int ttywrite(int, const void *, size_t); +int ttysendtitle(int, const char *, const struct TtyIdent *); +int ttyident(struct TtyIdent *, int, int); +void ttyidentclear(struct TtyIdent *); +char *ttydescribe(char *, size_t, const struct TtyIdent *); +int ttyconfig(int, ttyconf_f, int64_t, const struct termios *); +int ttyrestore(int, const struct termios *); +int ttysetrawdeadline(struct termios *, int64_t); +int ttysetrawmode(struct termios *, int64_t); +int ttysetraw(struct termios *, int64_t); +char *ttymove(struct TtyCursor *, char *, int, int) + paramsnonnull() returnsnonnull; +void ttyhisto(uint32_t[hasatleast 256], uint8_t[hasatleast 256], + const uint8_t *, const uint8_t *, size_t); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_TTY_H_ */ diff --git a/dsp/tty/tty.mk b/dsp/tty/tty.mk new file mode 100644 index 00000000..4c9478f6 --- /dev/null +++ b/dsp/tty/tty.mk @@ -0,0 +1,70 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += DSP_TTY + +DSP_TTY_ARTIFACTS += DSP_TTY_A +DSP_TTY = $(DSP_TTY_A_DEPS) $(DSP_TTY_A) +DSP_TTY_A = o/$(MODE)/dsp/tty/tty.a +DSP_TTY_A_FILES := $(wildcard dsp/tty/*) +DSP_TTY_A_HDRS = $(filter %.h,$(DSP_TTY_A_FILES)) +DSP_TTY_A_SRCS_S = $(filter %.S,$(DSP_TTY_A_FILES)) +DSP_TTY_A_SRCS_C = $(filter %.c,$(DSP_TTY_A_FILES)) + +DSP_TTY_A_SRCS = \ + $(DSP_TTY_A_SRCS_S) \ + $(DSP_TTY_A_SRCS_C) + +DSP_TTY_A_OBJS = \ + $(DSP_TTY_A_SRCS:%=o/$(MODE)/%.zip.o) \ + $(DSP_TTY_A_SRCS_S:%.S=o/$(MODE)/%.o) \ + $(DSP_TTY_A_SRCS_C:%.c=o/$(MODE)/%.o) + +DSP_TTY_A_CHECKS = \ + $(DSP_TTY_A).pkg \ + $(DSP_TTY_A_HDRS:%=o/$(MODE)/%.ok) + +DSP_TTY_A_DIRECTDEPS = \ + DSP_CORE \ + LIBC_ALG \ + LIBC_CALLS \ + LIBC_FMT \ + LIBC_LOG \ + LIBC_RUNTIME \ + LIBC_MEM \ + LIBC_NEXGEN32E \ + LIBC_NT_KERNELBASE \ + LIBC_STR \ + LIBC_STDIO \ + LIBC_STUBS \ + LIBC_SOCK \ + LIBC_SYSV \ + LIBC_TINYMATH \ + LIBC_TIME \ + LIBC_X \ + LIBC_UNICODE + +DSP_TTY_A_DEPS := \ + $(call uniq,$(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x)))) + +$(DSP_TTY_A): dsp/tty/ \ + $(DSP_TTY_A).pkg \ + $(DSP_TTY_A_OBJS) + +$(DSP_TTY_A).pkg: \ + $(DSP_TTY_A_OBJS) \ + $(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x)_A).pkg) + +o/$(MODE)/dsp/tty/ttyraster.o: \ + OVERRIDE_CFLAGS += \ + $(MATHEMATICAL) + +DSP_TTY_LIBS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x))) +DSP_TTY_SRCS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_SRCS)) +DSP_TTY_HDRS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_HDRS)) +DSP_TTY_CHECKS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_CHECKS)) +DSP_TTY_OBJS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)_OBJS)) +$(DSP_TTY_OBJS): $(BUILD_FILES) dsp/tty/tty.mk + +.PHONY: o/$(MODE)/dsp/tty +o/$(MODE)/dsp/tty: $(DSP_TTY_CHECKS) diff --git a/dsp/tty/tty2rgb24.c b/dsp/tty/tty2rgb24.c new file mode 100644 index 00000000..11d76785 --- /dev/null +++ b/dsp/tty/tty2rgb24.c @@ -0,0 +1,24 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" + +struct TtyRgb tty2rgb24_(struct TtyRgb rgbxt) { + return rgbxt; +} diff --git a/dsp/tty/tty2rgbf24.c b/dsp/tty/tty2rgbf24.c new file mode 100644 index 00000000..b2d6b3c9 --- /dev/null +++ b/dsp/tty/tty2rgbf24.c @@ -0,0 +1,24 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/quant.h" + +__m128 tty2rgbf24_(struct TtyRgb rgbxt) { + return (__m128){(int)rgbxt.r, (int)rgbxt.g, (int)rgbxt.b} / 255; +} diff --git a/dsp/tty/ttyhisto.c b/dsp/tty/ttyhisto.c new file mode 100644 index 00000000..8e722eaf --- /dev/null +++ b/dsp/tty/ttyhisto.c @@ -0,0 +1,51 @@ + +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/alg/alg.h" +#include "libc/nexgen32e/nexgen32e.h" +#include "libc/str/str.h" + +static int histcmp(const uint8_t *i1p, const uint8_t *i2p, + uint32_t histogram[hasatleast 256]) { + if (histogram[*i1p] > histogram[*i2p]) { + return -1; + } else if (histogram[*i1p] < histogram[*i2p]) { + return 1; + } else { + return 0; + } +} + +void ttyhisto(uint32_t histogram[hasatleast 256], + uint8_t dominant[hasatleast 256], const uint8_t *xtcolors, + const uint8_t *eqmask, size_t size) { + size_t i; + uint64_t q; + memset(histogram, 0, sizeof(uint32_t) * 256); + for (i = 0; i < size / 8; ++i) { + memcpy(&q, &xtcolors[i * 8], 8); + if (q == (xtcolors[i * 8] & 0xff) * 0x0101010101010101ul) { + histogram[xtcolors[i * 8]]++; + } + } + imapxlatab(dominant); + qsort_r(dominant, 256, 1, (void *)histcmp, histogram); +} diff --git a/dsp/tty/ttymove.c b/dsp/tty/ttymove.c new file mode 100644 index 00000000..d685624b --- /dev/null +++ b/dsp/tty/ttymove.c @@ -0,0 +1,198 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/itoa8.h" +#include "dsp/tty/tty.h" +#include "libc/bits/safemacros.h" +#include "libc/limits.h" +#include "libc/log/check.h" + +/** + * Moves teletypewriter cursor to new coordinate. + * + * This uses codings defined by ANSI X3.4-1967 / X3.64-1979. + * + * @param c [in/out] tracks cursor coordinate + * @param p [out] buffer receives ANSI/VT sequences + * @param y is 0-indexed row + * @param x is 0-indexed column + * @return p + written, like mempcpy() + */ +char *ttymove(struct TtyCursor *c, char *p, int y, int x) { + int d; + DCHECK_GE(y, 0); + DCHECK_GE(x, 0); + DCHECK_LE(y, UINT16_MAX); + DCHECK_LE(x, UINT16_MAX); + if (y != c->y || x != c->x) { + do { + if (y != c->y && x != c->x) { + if (y == c->y + 1 && x == 0) { + p[0] = '\r'; + p[1] = '\n'; + p[2] = '\0'; + p[3] = '\0'; + p += 2; + c->y++; + c->x = 0; + break; + } else if (x < 256 && y < 256) { + if (y == 0 && x == 0) { + if (c->y == 0) { + p[0] = '\r'; + p[1] = '\0'; + p += 1; + c->x = 0; + } else { + p[0] = '\e'; /* CUP(1,1) */ + p[1] = '['; + p[2] = 'H'; + p[3] = '\0'; + p += 3; + c->y = 0; + c->x = 0; + } + } else if (x == 0) { + *p++ = '\e'; /* CUP(y,1) */ + *p++ = '['; + p = itoa8(p, y + 1); + *p++ = 'H'; + *p = '\0'; + c->y = y; + c->x = 0; + } else if (y == 0) { + *p++ = '\e'; /* CUP(1,x) */ + *p++ = '['; + *p++ = ';'; + *p = '\0'; + p = itoa8(p, x + 1); + *p++ = 'H'; + *p = '\0'; + c->y = 0; + c->x = x; + } else { + *p++ = '\e'; /* CUP(y,1) */ + *p++ = '['; + p = itoa8(p, y + 1); + *p++ = ';'; + p = itoa8(p, x + 1); + *p++ = 'H'; + *p = '\0'; + c->y = y; + c->x = x; + } + break; + } + } + if (x != c->x) { + if (!x) { + p[0] = '\r'; /* goto beginning of line */ + p[1] = '\0'; + p += 1; + c->x = 0; + } else if (x > c->x) { + d = min(255, x - c->x); + if (d == 1) { + p[0] = '\e'; + p[1] = '['; + p[2] = 'C'; /* cursor forward (CUF) */ + p[3] = '\0'; + p += 3; + } else { + p[0] = '\e'; + p[1] = '['; + p = itoa8(p + 2, d); + p[0] = 'C'; /* cursor forward (CUF) */ + p[1] = '\0'; + p[2] = '\0'; + p[3] = '\0'; + p += 1; + } + c->x += d; + } else { + d = min(255, c->x - x); + if (d == 1) { + p[0] = '\e'; + p[1] = '['; + p[2] = 'D'; /* cursor backward (CUB) */ + p[3] = '\0'; + p += 3; + } else { + p[0] = '\e'; + p[1] = '['; + p = itoa8(p + 2, d); + p[0] = 'D'; /* cursor backward (CUB) */ + p[1] = '\0'; + p[2] = '\0'; + p[3] = '\0'; + p += 1; + } + c->x -= d; + } + } + if (y != c->y) { + if (y > c->y) { + d = min(255, y - c->y); + if (d == 1) { + p[0] = '\e'; + p[1] = 'D'; /* index down (IND) */ + p[2] = '\0'; + p[3] = '\0'; + p += 2; + } else { + p[0] = '\e'; + p[1] = '['; + p = itoa8(p + 2, d); + p[0] = 'B'; /* cursor down (CUD) */ + p[1] = '\0'; + p[2] = '\0'; + p[3] = '\0'; + p += 1; + } + c->y += d; + } else { + d = min(255, c->y - y); + if (d == 1) { + p[0] = '\e'; + p[1] = 'M'; /* reverse index (RI) */ + p[2] = '\0'; + p[3] = '\0'; + p += 2; + } else { + p[0] = '\e'; + p[1] = '['; + p = itoa8(p + 2, d); + p[0] = 'A'; /* cursor up (CUU) */ + p[1] = '\0'; + p[2] = '\0'; + p[3] = '\0'; + p += 1; + } + c->y -= d; + } + } + } while (x != c->x || y != c->y); + } else { + p[0] = '\0'; + } + DCHECK_EQ(y, c->y); + DCHECK_EQ(x, c->x); + DCHECK_EQ(p[0], '\0'); + return p; +} diff --git a/dsp/tty/ttyraster.c b/dsp/tty/ttyraster.c new file mode 100644 index 00000000..3064f2a0 --- /dev/null +++ b/dsp/tty/ttyraster.c @@ -0,0 +1,799 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/core/twixt8.h" +#include "dsp/tty/quant.h" +#include "dsp/tty/tty.h" +#include "dsp/tty/ttyrgb.h" +#include "dsp/tty/windex.h" +#include "libc/assert.h" +#include "libc/bits/bits.h" +#include "libc/bits/safemacros.h" +#include "libc/limits.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/nexgen32e/x86feature.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" + +#define SQR(X) ((X) * (X)) +#define DIST(X, Y) ((X) - (Y)) +#define QSUB(A, B, C) ABS(DIST(A##C, B##C)) +#define DIFF(A, B) (QSUB(A, B, r) + QSUB(A, B, g) + QSUB(A, B, b)) +#define JUDGE(M) (DIFF(ttl, M) + DIFF(ttr, M) + DIFF(tbl, M) + DIFF(tbr, M)) + +static const struct Glyph { + char c1, c2, c3, len; +} kGlyphs[2][11] = { + {{0x20, 0x00, 0x00, 1}, /* */ + {0xE2, 0x96, 0x84, 3}, /* ▄ */ + {0xE2, 0x96, 0x8C, 3}, /* ▌ */ + {0xE2, 0x96, 0x9D, 3}, /* ▝ */ + {0xE2, 0x96, 0x97, 3}, /* ▗ */ + {0xE2, 0x96, 0x96, 3}, /* ▖ */ + {0xE2, 0x96, 0x9E, 3}, /* ▞ */ + {0xE2, 0x96, 0x98, 3}, /* ▘ */ + {0xE2, 0x96, 0x91, 3}, /* ░ */ + {0xE2, 0x96, 0x93, 3}, /* ▓ */ + {0xE2, 0x96, 0x92, 3}}, /* ▒ */ + {{0xE2, 0x96, 0x88, 3}, /* █ */ + {0xE2, 0x96, 0x80, 3}, /* ▀ */ + {0xE2, 0x96, 0x90, 3}, /* ▐ */ + {0xE2, 0x96, 0x99, 3}, /* ▙ */ + {0xE2, 0x96, 0x9B, 3}, /* ▛ */ + {0xE2, 0x96, 0x9C, 3}, /* ▜ */ + {0xE2, 0x96, 0x9A, 3}, /* ▚ */ + {0xE2, 0x96, 0x9F, 3}, /* ▟ */ + {0xE2, 0x96, 0x93, 3}, /* ▓ */ + {0xE2, 0x96, 0x91, 3}, /* ░ */ + {0xE2, 0x96, 0x92, 3}}, /* ▒ */ +}; + +static const struct Pick { + unsigned char fg, bg, k; +} kPicksUnicode[96] = { + {-1, BL, 0}, /* */ + {BR, BL, 4}, /* ▗ */ + {TL, BL, 4}, /* ▗ */ + {TR, BL, 4}, /* ▗ */ + {BR, BL, 5}, /* ▖ */ + {BR, BL, 1}, /* ▄ */ + {TL, BL, 5}, /* ▖ */ + {TL, BL, 1}, /* ▄ */ + {TR, BL, 5}, /* ▖ */ + {TR, BL, 1}, /* ▄ */ + {BR, BL, 3}, /* ▝ */ + {BL, BR, 2}, /* ▌ */ + {BR, BL, 6}, /* ▞ */ + {BL, BR, 7}, /* ▘ */ + {TL, BL, 3}, /* ▝ */ + {BL, TL, 2}, /* ▌ */ + {TL, BL, 6}, /* ▞ */ + {BL, TL, 7}, /* ▘ */ + {TR, BL, 3}, /* ▝ */ + {BL, TR, 2}, /* ▌ */ + {TR, BL, 6}, /* ▞ */ + {BL, TR, 7}, /* ▘ */ + {BR, BL, 7}, /* ▘ */ + {BL, BR, 6}, /* ▞ */ + {BR, BL, 2}, /* ▌ */ + {BL, BR, 3}, /* ▝ */ + {BL, BR, 1}, /* ▄ */ + {BL, BR, 5}, /* ▖ */ + {BL, BR, 4}, /* ▗ */ + {-1, BR, 0}, /* */ + {TL, BR, 4}, /* ▗ */ + {TR, BR, 4}, /* ▗ */ + {TL, BR, 5}, /* ▖ */ + {TL, BR, 1}, /* ▄ */ + {TR, BR, 5}, /* ▖ */ + {TR, BR, 1}, /* ▄ */ + {TL, BR, 3}, /* ▝ */ + {BR, TL, 2}, /* ▌ */ + {TL, BR, 6}, /* ▞ */ + {BR, TL, 7}, /* ▘ */ + {TR, BR, 3}, /* ▝ */ + {BR, TR, 2}, /* ▌ */ + {TR, BR, 6}, /* ▞ */ + {BR, TR, 7}, /* ▘ */ + {TL, BL, 7}, /* ▘ */ + {BL, TL, 6}, /* ▞ */ + {TL, BL, 2}, /* ▌ */ + {BL, TL, 3}, /* ▝ */ + {TL, BR, 7}, /* ▘ */ + {BR, TL, 6}, /* ▞ */ + {TL, BR, 2}, /* ▌ */ + {BR, TL, 3}, /* ▝ */ + {BL, TL, 1}, /* ▄ */ + {BL, TL, 5}, /* ▖ */ + {BR, TL, 1}, /* ▄ */ + {BR, TL, 5}, /* ▖ */ + {BL, TL, 4}, /* ▗ */ + {BR, TL, 4}, /* ▗ */ + {-1, TL, 0}, /* */ + {TR, TL, 4}, /* ▗ */ + {TR, TL, 5}, /* ▖ */ + {TR, TL, 1}, /* ▄ */ + {TR, TL, 3}, /* ▝ */ + {TL, TR, 2}, /* ▌ */ + {TR, TL, 6}, /* ▞ */ + {TL, TR, 7}, /* ▘ */ + {TR, BL, 7}, /* ▘ */ + {BL, TR, 6}, /* ▞ */ + {TR, BL, 2}, /* ▌ */ + {BL, TR, 3}, /* ▝ */ + {TR, BR, 7}, /* ▘ */ + {BR, TR, 6}, /* ▞ */ + {TR, BR, 2}, /* ▌ */ + {BR, TR, 3}, /* ▝ */ + {TR, TL, 7}, /* ▘ */ + {TL, TR, 6}, /* ▞ */ + {TR, TL, 2}, /* ▌ */ + {TL, TR, 3}, /* ▝ */ + {BL, TR, 1}, /* ▄ */ + {BL, TR, 5}, /* ▖ */ + {BR, TR, 1}, /* ▄ */ + {BR, TR, 5}, /* ▖ */ + {TL, TR, 1}, /* ▄ */ + {TL, TR, 5}, /* ▖ */ + {BL, TR, 4}, /* ▗ */ + {BR, TR, 4}, /* ▗ */ + {TL, TR, 4}, /* ▗ */ + {-1, TR, 0}, /* */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ +}; + +static const struct Pick kPicksCp437[32] = { + {-1, BL, 0}, /* */ + {BR, BL, 1}, /* ▄ */ + {TL, BL, 1}, /* ▄ */ + {TR, BL, 1}, /* ▄ */ + {BL, BR, 1}, /* ▄ */ + {BL, TL, 1}, /* ▄ */ + {BL, TR, 1}, /* ▄ */ + {BL, BR, 2}, /* ▌ */ + {BL, TL, 2}, /* ▌ */ + {BL, TR, 2}, /* ▌ */ + {BR, BL, 2}, /* ▌ */ + {-1, BR, 0}, /* */ + {TL, BR, 1}, /* ▄ */ + {TR, BR, 1}, /* ▄ */ + {BR, TL, 2}, /* ▌ */ + {BR, TR, 2}, /* ▌ */ + {TL, BL, 2}, /* ▌ */ + {TL, BR, 2}, /* ▌ */ + {BR, TL, 1}, /* ▄ */ + {-1, TL, 0}, /* */ + {TR, TL, 1}, /* ▄ */ + {TL, TR, 2}, /* ▌ */ + {TR, BL, 2}, /* ▌ */ + {TR, BR, 2}, /* ▌ */ + {TR, TL, 2}, /* ▌ */ + {BR, TR, 1}, /* ▄ */ + {TL, TR, 1}, /* ▄ */ + {-1, TR, 0}, /* */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ + {-1, -1, -1}, /* X */ +}; + +static const struct Pick kPicksMixBlock[32] = { + {BR, BL, 8}, /* ░ */ + {BR, BL, 9}, /* ▓ */ + {TL, BL, 8}, /* ░ */ + {TL, BL, 9}, /* ▓ */ + {TR, BL, 8}, /* ░ */ + {TR, BL, 9}, /* ▓ */ + {TL, BR, 8}, /* ░ */ + {TL, BR, 9}, /* ▓ */ + {TR, BR, 8}, /* ░ */ + {TR, BR, 9}, /* ▓ */ + {BL, TL, 8}, /* ░ */ + {BL, TL, 9}, /* ▓ */ + {BL, TL, 8}, /* ░ */ + {BL, TL, 9}, /* ▓ */ + {TR, TL, 8}, /* ░ */ + {TR, TL, 9}, /* ▓ */ + {BL, TR, 8}, /* ░ */ + {BL, TR, 9}, /* ▓ */ + {BR, TR, 8}, /* ░ */ + {BR, TR, 9}, /* ▓ */ + {TL, TR, 8}, /* ░ */ + {TL, TR, 9}, /* ▓ */ + /**/ + {BL, TL, 8}, /* ░ */ + {BL, TL, 9}, /* ▓ */ + {TR, TL, 8}, /* ░ */ + {TR, TL, 9}, /* ▓ */ + {BL, TR, 8}, /* ░ */ + {BL, TR, 9}, /* ▓ */ + {BR, TR, 8}, /* ░ */ + {BR, TR, 9}, /* ▓ */ + {TL, TR, 8}, /* ░ */ + {TL, TR, 9}, /* ▓ */ +}; + +static unsigned short bdist(struct TtyRgb a, struct TtyRgb b, struct TtyRgb c, + struct TtyRgb d, struct TtyRgb w, struct TtyRgb x, + struct TtyRgb y, struct TtyRgb z) { + unsigned short dist; + dist = 0; + dist += ABS(a.r - w.r); + dist += ABS(a.g - w.g); + dist += ABS(a.b - w.b); + dist += ABS(b.r - x.r); + dist += ABS(b.g - x.g); + dist += ABS(b.b - x.b); + dist += ABS(c.r - y.r); + dist += ABS(c.g - y.g); + dist += ABS(c.b - y.b); + dist += ABS(d.r - z.r); + dist += ABS(d.g - z.g); + dist += ABS(d.b - z.b); + return dist; +} + +static uint16_t *mixblock(uint16_t *p, struct TtyRgb ttl, struct TtyRgb ttr, + struct TtyRgb tbl, struct TtyRgb tbr, + struct TtyRgb qtl, struct TtyRgb qtr, + struct TtyRgb qbl, struct TtyRgb qbr) { + unsigned char ttlr, ttlg, ttlb, qtlr, qtlg, qtlb, ttrr, ttrg, ttrb, qtrr, + qtrg, qtrb, tblr, tblg, tblb, qblr, qblg, qblb, tbrr, tbrg, tbrb, qbrr, + qbrg, qbrb, l00r, l00g, l00b, l01r, l01g, l01b, l02r, l02g, l02b, l03r, + l03g, l03b, l04r, l04g, l04b, l05r, l05g, l05b, l06r, l06g, l06b, l07r, + l07g, l07b, l08r, l08g, l08b, l09r, l09g, l09b, l10r, l10g, l10b, l11r, + l11g, l11b, l12r, l12g, l12b, l13r, l13g, l13b, l14r, l14g, l14b, l15r, + l15g, l15b, l16r, l16g, l16b, l17r, l17g, l17b, l18r, l18g, l18b, l19r, + l19g, l19b, l20r, l20g, l20b, l21r, l21g, l21b, l22r, l22g, l22b, l23r, + l23g, l23b, l24r, l24g, l24b, l25r, l25g, l25b, l26r, l26g, l26b, l27r, + l27g, l27b, l28r, l28g, l28b, l29r, l29g, l29b, l30r, l30g, l30b, l31r, + l31g, l31b; + unsigned short p00, p01, p02, p03, p04, p05, p06, p07, p08, p09, p10, p11, + p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, + p27, p28, p29, p30, p31; + ttlr = ttl.r; + ttlg = ttl.g; + ttlb = ttl.b; + qtlr = qtl.r; + qtlg = qtl.g; + qtlb = qtl.b; + ttrr = ttr.r; + ttrg = ttr.g; + ttrb = ttr.b; + qtrr = qtr.r; + qtrg = qtr.g; + qtrb = qtr.b; + tblr = tbl.r; + tblg = tbl.g; + tblb = tbl.b; + qblr = qbl.r; + qblg = qbl.g; + qblb = qbl.b; + tbrr = tbr.r; + tbrg = tbr.g; + tbrb = tbr.b; + qbrr = qbr.r; + qbrg = qbr.g; + qbrb = qbr.b; + l00r = twixt8(qblr, qbrr, 0100); + l00g = twixt8(qblg, qbrg, 0100); + l00b = twixt8(qblb, qbrb, 0100); + l01r = twixt8(qblr, qbrr, 0300); + l01g = twixt8(qblg, qbrg, 0300); + l01b = twixt8(qblb, qbrb, 0300); + l02r = twixt8(qblr, qbrr, 0200); + l02g = twixt8(qblg, qbrg, 0200); + l02b = twixt8(qblb, qbrb, 0200); + l03r = twixt8(qblr, qtlr, 0100); + l03g = twixt8(qblg, qtlg, 0100); + l03b = twixt8(qblb, qtlb, 0100); + l04r = twixt8(qblr, qtlr, 0300); + l04g = twixt8(qblg, qtlg, 0300); + l04b = twixt8(qblb, qtlb, 0300); + l05r = twixt8(qblr, qtlr, 0200); + l05g = twixt8(qblg, qtlg, 0200); + l05b = twixt8(qblb, qtlb, 0200); + l06r = twixt8(qblr, qtrr, 0100); + l06g = twixt8(qblg, qtrg, 0100); + l06b = twixt8(qblb, qtrb, 0100); + l07r = twixt8(qblr, qtrr, 0300); + l07g = twixt8(qblg, qtrg, 0300); + l07b = twixt8(qblb, qtrb, 0300); + l08r = twixt8(qblr, qtrr, 0200); + l08g = twixt8(qblg, qtrg, 0200); + l08b = twixt8(qblb, qtrb, 0200); + l09r = twixt8(qbrr, qtlr, 0100); + l09g = twixt8(qbrg, qtlg, 0100); + l09b = twixt8(qbrb, qtlb, 0100); + l10r = twixt8(qbrr, qtlr, 0300); + l10g = twixt8(qbrg, qtlg, 0300); + l10b = twixt8(qbrb, qtlb, 0300); + l11r = twixt8(qbrr, qtlr, 0200); + l11g = twixt8(qbrg, qtlg, 0200); + l11b = twixt8(qbrb, qtlb, 0200); + l12r = twixt8(qbrr, qtrr, 0100); + l12g = twixt8(qbrg, qtrg, 0100); + l12b = twixt8(qbrb, qtrb, 0100); + l13r = twixt8(qbrr, qtrr, 0300); + l13g = twixt8(qbrg, qtrg, 0300); + l13b = twixt8(qbrb, qtrb, 0300); + l14r = twixt8(qbrr, qtrr, 0200); + l14g = twixt8(qbrg, qtrg, 0200); + l14b = twixt8(qbrb, qtrb, 0200); + l15r = twixt8(qtlr, qblr, 0100); + l15g = twixt8(qtlg, qblg, 0100); + l15b = twixt8(qtlb, qblb, 0100); + l16r = twixt8(qtlr, qblr, 0300); + l16g = twixt8(qtlg, qblg, 0300); + l16b = twixt8(qtlb, qblb, 0300); + l17r = twixt8(qtlr, qblr, 0200); + l17g = twixt8(qtlg, qblg, 0200); + l17b = twixt8(qtlb, qblb, 0200); + l18r = twixt8(qtlr, qbrr, 0100); + l18g = twixt8(qtlg, qbrg, 0100); + l18b = twixt8(qtlb, qbrb, 0100); + l19r = twixt8(qtlr, qbrr, 0300); + l19g = twixt8(qtlg, qbrg, 0300); + l19b = twixt8(qtlb, qbrb, 0300); + l20r = twixt8(qtlr, qbrr, 0200); + l20g = twixt8(qtlg, qbrg, 0200); + l20b = twixt8(qtlb, qbrb, 0200); + l21r = twixt8(qtlr, qtrr, 0100); + l21g = twixt8(qtlg, qtrg, 0100); + l21b = twixt8(qtlb, qtrb, 0100); + l22r = twixt8(qtlr, qtrr, 0300); + l22g = twixt8(qtlg, qtrg, 0300); + l22b = twixt8(qtlb, qtrb, 0300); + l23r = twixt8(qtlr, qtrr, 0200); + l23g = twixt8(qtlg, qtrg, 0200); + l23b = twixt8(qtlb, qtrb, 0200); + l24r = twixt8(qtrr, qblr, 0100); + l24g = twixt8(qtrg, qblg, 0100); + l24b = twixt8(qtrb, qblb, 0100); + l25r = twixt8(qtrr, qblr, 0300); + l25g = twixt8(qtrg, qblg, 0300); + l25b = twixt8(qtrb, qblb, 0300); + l26r = twixt8(qtrr, qblr, 0200); + l26g = twixt8(qtrg, qblg, 0200); + l26b = twixt8(qtrb, qblb, 0200); + l27r = twixt8(qtrr, qbrr, 0100); + l27g = twixt8(qtrg, qbrg, 0100); + l27b = twixt8(qtrb, qbrb, 0100); + l28r = twixt8(qtrr, qbrr, 0300); + l28g = twixt8(qtrg, qbrg, 0300); + l28b = twixt8(qtrb, qbrb, 0300); + l29r = twixt8(qtrr, qbrr, 0200); + l29g = twixt8(qtrg, qbrg, 0200); + l29b = twixt8(qtrb, qbrb, 0200); + l30r = twixt8(qtrr, qtlr, 0100); + l30g = twixt8(qtrg, qtlg, 0100); + l30b = twixt8(qtrb, qtlb, 0100); + l31r = twixt8(qtrr, qtlr, 0300); + l31g = twixt8(qtrg, qtlg, 0300); + l31b = twixt8(qtrb, qtlb, 0300); + p00 = JUDGE(l00); + p01 = JUDGE(l01); + p02 = JUDGE(l02); + p03 = JUDGE(l03); + p04 = JUDGE(l04); + p05 = JUDGE(l05); + p06 = JUDGE(l06); + p07 = JUDGE(l07); + p08 = JUDGE(l08); + p09 = JUDGE(l09); + p10 = JUDGE(l10); + p11 = JUDGE(l11); + p12 = JUDGE(l12); + p13 = JUDGE(l13); + p14 = JUDGE(l14); + p15 = JUDGE(l15); + p16 = JUDGE(l16); + p17 = JUDGE(l17); + p18 = JUDGE(l18); + p19 = JUDGE(l19); + p20 = JUDGE(l20); + p21 = JUDGE(l21); + p22 = JUDGE(l22); + p23 = JUDGE(l23); + p24 = JUDGE(l24); + p25 = JUDGE(l25); + p26 = JUDGE(l26); + p27 = JUDGE(l27); + p28 = JUDGE(l28); + p29 = JUDGE(l29); + p30 = JUDGE(l30); + p31 = JUDGE(l31); + *p++ = p00; + *p++ = p01; + *p++ = p02; + *p++ = p03; + *p++ = p04; + *p++ = p05; + *p++ = p06; + *p++ = p07; + *p++ = p08; + *p++ = p09; + *p++ = p10; + *p++ = p11; + *p++ = p12; + *p++ = p13; + *p++ = p14; + *p++ = p15; + *p++ = p16; + *p++ = p17; + *p++ = p18; + *p++ = p19; + *p++ = p20; + *p++ = p21; + *p++ = p22; + *p++ = p23; + *p++ = p24; + *p++ = p25; + *p++ = p26; + *p++ = p27; + *p++ = p28; + *p++ = p29; + *p++ = p30; + *p++ = p31; + return p; +} + +static struct TtyRgb getquant(struct TtyRgb rgb) { + return g_ansi2rgb_[rgb.xt]; +} + +static uint16_t *pickunicode(uint16_t *p, struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br, + struct TtyRgb tl2, struct TtyRgb tr2, + struct TtyRgb bl2, struct TtyRgb br2) { +#define PICK(A, B, C, D) *p++ = bdist(tl, tr, bl, br, A, B, C, D) + PICK(bl2, bl2, bl2, bl2); /* k=0 bg=bl fg=NULL */ + PICK(bl2, bl2, bl2, br2); /* ▗ k=4 bg=bl fg=br */ + PICK(bl2, bl2, bl2, tl2); /* ▗ k=4 bg=bl fg=tl */ + PICK(bl2, bl2, bl2, tr2); /* ▗ k=4 bg=bl fg=tr */ + PICK(bl2, bl2, br2, bl2); /* ▖ k=5 bg=bl fg=br */ + PICK(bl2, bl2, br2, br2); /* ▄ k=1 bg=bl fg=br */ + PICK(bl2, bl2, tl2, bl2); /* ▖ k=5 bg=bl fg=tl */ + PICK(bl2, bl2, tl2, tl2); /* ▄ k=1 bg=bl fg=tl */ + PICK(bl2, bl2, tr2, bl2); /* ▖ k=5 bg=bl fg=tr */ + PICK(bl2, bl2, tr2, tr2); /* ▄ k=1 bg=bl fg=tr */ + PICK(bl2, br2, bl2, bl2); /* ▝ k=3 bg=bl fg=br */ + PICK(bl2, br2, bl2, br2); /* ▌ k=2 bg=br fg=bl */ + PICK(bl2, br2, br2, bl2); /* ▞ k=6 bg=bl fg=br */ + PICK(bl2, br2, br2, br2); /* ▘ k=7 bg=br fg=bl */ + PICK(bl2, tl2, bl2, bl2); /* ▝ k=3 bg=bl fg=tl */ + PICK(bl2, tl2, bl2, tl2); /* ▌ k=2 bg=tl fg=bl */ + PICK(bl2, tl2, tl2, bl2); /* ▞ k=6 bg=bl fg=tl */ + PICK(bl2, tl2, tl2, tl2); /* ▘ k=7 bg=tl fg=bl */ + PICK(bl2, tr2, bl2, bl2); /* ▝ k=3 bg=bl fg=tr */ + PICK(bl2, tr2, bl2, tr2); /* ▌ k=2 bg=tr fg=bl */ + PICK(bl2, tr2, tr2, bl2); /* ▞ k=6 bg=bl fg=tr */ + PICK(bl2, tr2, tr2, tr2); /* ▘ k=7 bg=tr fg=bl */ + PICK(br2, bl2, bl2, bl2); /* ▘ k=7 bg=bl fg=br */ + PICK(br2, bl2, bl2, br2); /* ▞ k=6 bg=br fg=bl */ + PICK(br2, bl2, br2, bl2); /* ▌ k=2 bg=bl fg=br */ + PICK(br2, bl2, br2, br2); /* ▝ k=3 bg=br fg=bl */ + PICK(br2, br2, bl2, bl2); /* ▄ k=1 bg=br fg=bl */ + PICK(br2, br2, bl2, br2); /* ▖ k=5 bg=br fg=bl */ + PICK(br2, br2, br2, bl2); /* ▗ k=4 bg=br fg=bl */ + PICK(br2, br2, br2, br2); /* k=0 bg=br fg=NULL */ + PICK(br2, br2, br2, tl2); /* ▗ k=4 bg=br fg=tl */ + PICK(br2, br2, br2, tr2); /* ▗ k=4 bg=br fg=tr */ + PICK(br2, br2, tl2, br2); /* ▖ k=5 bg=br fg=tl */ + PICK(br2, br2, tl2, tl2); /* ▄ k=1 bg=br fg=tl */ + PICK(br2, br2, tr2, br2); /* ▖ k=5 bg=br fg=tr */ + PICK(br2, br2, tr2, tr2); /* ▄ k=1 bg=br fg=tr */ + PICK(br2, tl2, br2, br2); /* ▝ k=3 bg=br fg=tl */ + PICK(br2, tl2, br2, tl2); /* ▌ k=2 bg=tl fg=br */ + PICK(br2, tl2, tl2, br2); /* ▞ k=6 bg=br fg=tl */ + PICK(br2, tl2, tl2, tl2); /* ▘ k=7 bg=tl fg=br */ + PICK(br2, tr2, br2, br2); /* ▝ k=3 bg=br fg=tr */ + PICK(br2, tr2, br2, tr2); /* ▌ k=2 bg=tr fg=br */ + PICK(br2, tr2, tr2, br2); /* ▞ k=6 bg=br fg=tr */ + PICK(br2, tr2, tr2, tr2); /* ▘ k=7 bg=tr fg=br */ + PICK(tl2, bl2, bl2, bl2); /* ▘ k=7 bg=bl fg=tl */ + PICK(tl2, bl2, bl2, tl2); /* ▞ k=6 bg=tl fg=bl */ + PICK(tl2, bl2, tl2, bl2); /* ▌ k=2 bg=bl fg=tl */ + PICK(tl2, bl2, tl2, tl2); /* ▝ k=3 bg=tl fg=bl */ + PICK(tl2, br2, br2, br2); /* ▘ k=7 bg=br fg=tl */ + PICK(tl2, br2, br2, tl2); /* ▞ k=6 bg=tl fg=br */ + PICK(tl2, br2, tl2, br2); /* ▌ k=2 bg=br fg=tl */ + PICK(tl2, br2, tl2, tl2); /* ▝ k=3 bg=tl fg=br */ + PICK(tl2, tl2, bl2, bl2); /* ▄ k=1 bg=tl fg=bl */ + PICK(tl2, tl2, bl2, tl2); /* ▖ k=5 bg=tl fg=bl */ + PICK(tl2, tl2, br2, br2); /* ▄ k=1 bg=tl fg=br */ + PICK(tl2, tl2, br2, tl2); /* ▖ k=5 bg=tl fg=br */ + PICK(tl2, tl2, tl2, bl2); /* ▗ k=4 bg=tl fg=bl */ + PICK(tl2, tl2, tl2, br2); /* ▗ k=4 bg=tl fg=br */ + PICK(tl2, tl2, tl2, tl2); /* k=0 bg=tl fg=NULL */ + PICK(tl2, tl2, tl2, tr2); /* ▗ k=4 bg=tl fg=tr */ + PICK(tl2, tl2, tr2, tl2); /* ▖ k=5 bg=tl fg=tr */ + PICK(tl2, tl2, tr2, tr2); /* ▄ k=1 bg=tl fg=tr */ + PICK(tl2, tr2, tl2, tl2); /* ▝ k=3 bg=tl fg=tr */ + PICK(tl2, tr2, tl2, tr2); /* ▌ k=2 bg=tr fg=tl */ + PICK(tl2, tr2, tr2, tl2); /* ▞ k=6 bg=tl fg=tr */ + PICK(tl2, tr2, tr2, tr2); /* ▘ k=7 bg=tr fg=tl */ + PICK(tr2, bl2, bl2, bl2); /* ▘ k=7 bg=bl fg=tr */ + PICK(tr2, bl2, bl2, tr2); /* ▞ k=6 bg=tr fg=bl */ + PICK(tr2, bl2, tr2, bl2); /* ▌ k=2 bg=bl fg=tr */ + PICK(tr2, bl2, tr2, tr2); /* ▝ k=3 bg=tr fg=bl */ + PICK(tr2, br2, br2, br2); /* ▘ k=7 bg=br fg=tr */ + PICK(tr2, br2, br2, tr2); /* ▞ k=6 bg=tr fg=br */ + PICK(tr2, br2, tr2, br2); /* ▌ k=2 bg=br fg=tr */ + PICK(tr2, br2, tr2, tr2); /* ▝ k=3 bg=tr fg=br */ + PICK(tr2, tl2, tl2, tl2); /* ▘ k=7 bg=tl fg=tr */ + PICK(tr2, tl2, tl2, tr2); /* ▞ k=6 bg=tr fg=tl */ + PICK(tr2, tl2, tr2, tl2); /* ▌ k=2 bg=tl fg=tr */ + PICK(tr2, tl2, tr2, tr2); /* ▝ k=3 bg=tr fg=tl */ + PICK(tr2, tr2, bl2, bl2); /* ▄ k=1 bg=tr fg=bl */ + PICK(tr2, tr2, bl2, tr2); /* ▖ k=5 bg=tr fg=bl */ + PICK(tr2, tr2, br2, br2); /* ▄ k=1 bg=tr fg=br */ + PICK(tr2, tr2, br2, tr2); /* ▖ k=5 bg=tr fg=br */ + PICK(tr2, tr2, tl2, tl2); /* ▄ k=1 bg=tr fg=tl */ + PICK(tr2, tr2, tl2, tr2); /* ▖ k=5 bg=tr fg=tl */ + PICK(tr2, tr2, tr2, bl2); /* ▗ k=4 bg=tr fg=bl */ + PICK(tr2, tr2, tr2, br2); /* ▗ k=4 bg=tr fg=br */ + PICK(tr2, tr2, tr2, tl2); /* ▗ k=4 bg=tr fg=tl */ + PICK(tr2, tr2, tr2, tr2); /* k=0 bg=tr fg=NULL */ +#undef PICK + return p; +} + +static uint16_t *pickcp437(uint16_t *p, struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br, + struct TtyRgb tl2, struct TtyRgb tr2, + struct TtyRgb bl2, struct TtyRgb br2) { +#define PICK(A, B, C, D) *p++ = bdist(tl, tr, bl, br, A, B, C, D) + PICK(bl2, bl2, bl2, bl2); /* k=0 bg=bl fg=NULL */ + PICK(bl2, bl2, br2, br2); /* ▄ k=1 bg=bl fg=br */ + PICK(bl2, bl2, tl2, tl2); /* ▄ k=1 bg=bl fg=tl */ + PICK(bl2, bl2, tr2, tr2); /* ▄ k=1 bg=bl fg=tr */ + PICK(br2, br2, bl2, bl2); /* ▄ k=1 bg=br fg=bl */ + PICK(tl2, tl2, bl2, bl2); /* ▄ k=1 bg=tl fg=bl */ + PICK(tr2, tr2, bl2, bl2); /* ▄ k=1 bg=tr fg=bl */ + PICK(bl2, br2, bl2, br2); /* ▌ k=2 bg=br fg=bl */ + PICK(bl2, tl2, bl2, tl2); /* ▌ k=2 bg=tl fg=bl */ + PICK(bl2, tr2, bl2, tr2); /* ▌ k=2 bg=tr fg=bl */ + PICK(br2, bl2, br2, bl2); /* ▌ k=2 bg=bl fg=br */ + PICK(br2, br2, br2, br2); /* k=0 bg=br fg=NULL */ + PICK(br2, br2, tl2, tl2); /* ▄ k=1 bg=br fg=tl */ + PICK(br2, br2, tr2, tr2); /* ▄ k=1 bg=br fg=tr */ + PICK(br2, tl2, br2, tl2); /* ▌ k=2 bg=tl fg=br */ + PICK(br2, tr2, br2, tr2); /* ▌ k=2 bg=tr fg=br */ + PICK(tl2, bl2, tl2, bl2); /* ▌ k=2 bg=bl fg=tl */ + PICK(tl2, br2, tl2, br2); /* ▌ k=2 bg=br fg=tl */ + PICK(tl2, tl2, br2, br2); /* ▄ k=1 bg=tl fg=br */ + PICK(tl2, tl2, tl2, tl2); /* k=0 bg=tl fg=NULL */ + PICK(tl2, tl2, tr2, tr2); /* ▄ k=1 bg=tl fg=tr */ + PICK(tl2, tr2, tl2, tr2); /* ▌ k=2 bg=tr fg=tl */ + PICK(tr2, bl2, tr2, bl2); /* ▌ k=2 bg=bl fg=tr */ + PICK(tr2, br2, tr2, br2); /* ▌ k=2 bg=br fg=tr */ + PICK(tr2, tl2, tr2, tl2); /* ▌ k=2 bg=tl fg=tr */ + PICK(tr2, tr2, br2, br2); /* ▄ k=1 bg=tr fg=br */ + PICK(tr2, tr2, tl2, tl2); /* ▄ k=1 bg=tr fg=tl */ + PICK(tr2, tr2, tr2, tr2); /* k=0 bg=tr fg=NULL */ +#undef PICK + return p; +} + +static struct Pick pickblock_unicode_ansi(struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br) { + struct TtyRgb tl2 = getquant(tl); + struct TtyRgb tr2 = getquant(tr); + struct TtyRgb bl2 = getquant(bl); + struct TtyRgb br2 = getquant(br); + unsigned i, p1, p2; + uint16_t picks1[96] aligned(32); + uint16_t picks2[32] aligned(32); + memset(picks1, 0x79, sizeof(picks1)); + memset(picks2, 0x79, sizeof(picks2)); + pickunicode(picks1, tl, tr, bl, br, tl2, tr2, bl2, br2); + mixblock(picks2, tl, tr, bl, br, tl2, tr2, bl2, br2); + p1 = windex(picks1, 96); + p2 = windex(picks2, 32); + return picks1[p1] <= picks2[p2] ? kPicksUnicode[p1] : kPicksMixBlock[p2]; +} + +static struct Pick pickblock_unicode_true(struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br) { + unsigned i; + uint16_t picks[96] aligned(32); + memset(picks, 0x79, sizeof(picks)); + pickunicode(picks, tl, tr, bl, br, tl, tr, bl, br); + i = windex(picks, 96); + if (i >= 88) { + unsigned j; + fprintf(stderr, "uint16_t picks[96] = {"); + for (j = 0; j < 96; ++j) { + fprintf(stderr, "%3d,", picks[j]); + } + fprintf(stderr, "}\n"); + } + CHECK_LT(i, 88); + return kPicksUnicode[i]; +} + +static struct Pick pickblock_cp437_ansi(struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br) { + struct TtyRgb tl2 = getquant(tl); + struct TtyRgb tr2 = getquant(tr); + struct TtyRgb bl2 = getquant(bl); + struct TtyRgb br2 = getquant(br); + unsigned i, p1, p2; + uint16_t picks1[32] aligned(32); + uint16_t picks2[32] aligned(32); + memset(picks1, 0x79, sizeof(picks1)); + memset(picks2, 0x79, sizeof(picks2)); + pickcp437(picks1, tl, tr, bl, br, tl2, tr2, bl2, br2); + mixblock(picks2, tl, tr, bl, br, tl2, tr2, bl2, br2); + p1 = windex(picks1, 32); + p2 = windex(picks2, 32); + return picks1[p1] <= picks2[p2] ? kPicksCp437[p1] : kPicksMixBlock[p2]; +} + +static struct Pick pickblock_cp437_true(struct TtyRgb tl, struct TtyRgb tr, + struct TtyRgb bl, struct TtyRgb br) { + unsigned i; + uint16_t picks[32] aligned(32); + memset(picks, 0x79, sizeof(picks)); + pickcp437(picks, tl, tr, bl, br, tl, tr, bl, br); + return kPicksCp437[windex(picks, 32)]; +} + +static char *copyglyph(char *v, struct Glyph glyph) { + memcpy(v, &glyph, 4); + return v + glyph.len; +} + +static char *copyblock(char *v, const struct TtyRgb chunk[hasatleast 4], + struct Pick pick, struct TtyRgb *bg, struct TtyRgb *fg, + struct Glyph *glyph) { + unsigned i; + CHECK_LT(pick.bg, 4); + if (pick.fg != 0xff) CHECK_LT(pick.fg, 4); + i = 0; + if (pick.fg == 0xff) { + if (!ttyeq(*bg, chunk[pick.bg])) { + if (ttyeq(*fg, chunk[pick.bg])) { + if (memcmp(glyph, &kGlyphs[1][0], sizeof(*glyph)) == 0) { + v = setbg(v, (*bg = *fg)); + } else { + i = 1; + } + } else { + v = setbg(v, (*bg = chunk[pick.bg])); + } + } + } else if (ttyeq(chunk[pick.bg], chunk[pick.fg])) { + pick.k = 0; + if (!ttyeq(*bg, chunk[pick.bg])) { + if (ttyeq(*fg, chunk[pick.bg])) { + if (memcmp(glyph, &kGlyphs[1][0], sizeof(*glyph)) == 0) { + v = setbg(v, (*bg = *fg)); + } else { + i = 1; + } + } else { + v = setbg(v, (*bg = chunk[pick.bg])); + } + } + } else if (!ttyeq(*fg, chunk[pick.fg])) { + if (!ttyeq(*bg, chunk[pick.bg])) { + if (ttyeq(*fg, chunk[pick.bg]) && ttyeq(*bg, chunk[pick.fg])) { + if (pick.k == 0 && memcmp(glyph, &kGlyphs[1][0], sizeof(*glyph)) == 0) { + v = setbg(v, (*bg = *fg)); + } else { + i = 1; + } + } else { + v = setbgfg(v, (*bg = chunk[pick.bg]), (*fg = chunk[pick.fg])); + } + } else { + v = setfg(v, (*fg = chunk[pick.fg])); + } + } else if (!ttyeq(*bg, chunk[pick.bg])) { + v = setbg(v, (*bg = chunk[pick.bg])); + } + return copyglyph(v, (*glyph = kGlyphs[i][pick.k])); +} + +static bool chunkeq(struct TtyRgb c[hasatleast 4], + struct TtyRgb c2[hasatleast 4]) { + return ttyeq(c[TL], c[TR]) && ttyeq(c[BL], c[BR]) && ttyeq(c2[TL], c2[TR]) && + ttyeq(c2[BL], c2[BR]); +} + +static struct TtyRgb *copychunk(struct TtyRgb chunk[hasatleast 4], + const struct TtyRgb *c, size_t n) { + chunk[TL] = c[0 + 0]; + chunk[TR] = c[0 + 1]; + chunk[BL] = c[n + 0]; + chunk[BR] = c[n + 1]; + return chunk; +} + +static noinline char *copyrun(char *v, size_t n, + struct TtyRgb lastchunk[hasatleast 4], + const struct TtyRgb **c, size_t *x, + struct TtyRgb *bg, struct TtyRgb *fg, + struct Glyph *glyph) { + struct TtyRgb chunk[4]; + if (memcmp(glyph, &kGlyphs[1][0], sizeof(*glyph)) == 0) { + if (!ttyeq(*bg, *fg)) { + v = setbg(v, (*bg = *fg)); + } + *glyph = kGlyphs[0][0]; + } + do { + v = copyglyph(v, *glyph); + *x += 2; + *c += 2; + if (*x >= n) break; + copychunk(chunk, *c, n); + } while (chunkeq(chunk, lastchunk)); + *x -= 2; + *c -= 2; + return v; +} + +/** + * Maps 2×2 pixel chunks onto ANSI UNICODE cells. + * @note h/t Nick Black for his quadrant blitting work on notcurses + */ +char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t n, + struct TtyRgb bg, struct TtyRgb fg) { + unsigned y, x; + struct Pick p; + struct Glyph glyph; + struct TtyRgb chun[4], lastchunk[4]; + for (y = 0; y < yn; y += 2, c += n) { + if (y) *v++ = '\r', *v++ = '\n'; + for (x = 0; x < n; x += 2, c += 2) { + copychunk(chun, c, n); + if (ttyquant()->alg == kTtyQuantTrue) { + if (ttyquant()->blocks == kTtyBlocksCp437) { + p = pickblock_cp437_true(chun[TL], chun[TR], chun[BL], chun[BR]); + } else { + p = pickblock_unicode_true(chun[TL], chun[TR], chun[BL], chun[BR]); + } + } else { + if (ttyquant()->blocks == kTtyBlocksCp437) { + p = pickblock_cp437_ansi(chun[TL], chun[TR], chun[BL], chun[BR]); + } else { + p = pickblock_unicode_ansi(chun[TL], chun[TR], chun[BL], chun[BR]); + } + } + v = copyblock(v, chun, p, &bg, &fg, &glyph); + memcpy(lastchunk, chun, sizeof(chun)); + } + } + *v = '\0'; + return v; +} diff --git a/dsp/tty/ttyraw.c b/dsp/tty/ttyraw.c new file mode 100644 index 00000000..a285cbe9 --- /dev/null +++ b/dsp/tty/ttyraw.c @@ -0,0 +1,155 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" +#include "libc/calls/calls.h" +#include "libc/calls/sigbits.h" +#include "libc/calls/struct/sigaction.h" +#include "libc/calls/struct/siginfo.h" +#include "libc/calls/termios.h" +#include "libc/calls/typedef/sigaction_f.h" +#include "libc/calls/ucontext.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/runtime/gc.h" +#include "libc/runtime/rbx.h" +#include "libc/runtime/runtime.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/sysv/consts/sa.h" +#include "libc/sysv/consts/sig.h" +#include "libc/sysv/errfuns.h" +#include "libc/x/x.h" + +#define FD STDOUT_FILENO + +static struct TtyRaw { + bool setup; + bool noreentry; + bool initialized; + enum TtyRawFlags flags; + sigaction_f next[10]; + unsigned char sigs[10]; + struct termios old; +} g_ttyraw; + +static textstartup int ttyraw_setup(void) { + if (isatty(FD) && + ttyconfig(FD, ttysetrawmode, g_ttyraw.flags, &g_ttyraw.old) != -1) { + return 0; + } else { + return -1; + } +} + +static textstartup int ttyraw_enable(void) { + int rc; + g_ttyraw.setup = (rc = ttyraw_setup()) != -1 || g_ttyraw.setup; + return rc; +} + +static textstartup void ttyraw_hidecursor(void) { + if (!g_ttyraw.setup) return; + if (g_ttyraw.flags & kTtyCursor) return; + ttyhidecursor(FD); +} + +static textexit int ttyraw_disable(void) { + if (!g_ttyraw.setup) return 0; + ttyshowcursor(FD); + return ttyrestore(FD, &g_ttyraw.old); +} + +static textexit void ttyraw_onexit(void) { + ttyraw_disable(); +} + +static relegated void ttyraw_onsig(int sig, struct siginfo *info, + struct ucontext *ctx) { + size_t i; + if (g_ttyraw.noreentry) _Exit(128 + sig); + g_ttyraw.noreentry = true; + if (g_ttyraw.flags != -1) { + if (sig == SIGCONT) { + ttyraw_enable(); + } else { + ttyraw_disable(); + } + } + for (i = 0; i < ARRAYLEN(g_ttyraw.sigs); ++i) { + if (g_ttyraw.sigs[i] == sig) { + if (g_ttyraw.next[i] != SIG_IGN) { + if (g_ttyraw.next[i] != SIG_DFL) { + g_ttyraw.next[i](sig, info, ctx); + } else if (sig != SIGCONT) { + _Exit(128 + sig); + } + } + break; + } + } + g_ttyraw.noreentry = false; +} + +static textstartup void ttyraw_initsig(int sig, unsigned flags, unsigned mask) { + static unsigned i; + struct sigaction old; + g_ttyraw.next[i] = xsigaction(sig, ttyraw_onsig, flags, mask, &old) != -1 + ? old.sa_sigaction + : SIG_DFL; + g_ttyraw.sigs[i++] = sig; +} + +static textstartup void ttyraw_init(void) { + unsigned crashmask = ~(SIGILL | SIGBUS | SIGSEGV | SIGABRT); + ttyraw_initsig(SIGILL, SA_SIGINFO | SA_NODEFER | SA_ONSTACK, crashmask); + ttyraw_initsig(SIGSEGV, SA_SIGINFO | SA_NODEFER | SA_ONSTACK, crashmask); + ttyraw_initsig(SIGBUS, SA_SIGINFO | SA_NODEFER | SA_ONSTACK, crashmask); + ttyraw_initsig(SIGABRT, SA_SIGINFO | SA_NODEFER, crashmask); + ttyraw_initsig(SIGFPE, SA_SIGINFO | SA_RESTART, crashmask); + ttyraw_initsig(SIGTRAP, SA_SIGINFO | SA_RESTART, crashmask); + ttyraw_initsig(SIGHUP, SA_SIGINFO | SA_RESTART, crashmask); + ttyraw_initsig(SIGINT, SA_SIGINFO | SA_RESTART, crashmask); + ttyraw_initsig(SIGQUIT, SA_SIGINFO | SA_RESTART, crashmask); + ttyraw_initsig(SIGCONT, SA_SIGINFO | SA_RESTART, crashmask); + atexit(ttyraw_onexit); +} + +/** + * Sets raw mode, safely, the easy way. + * + * This should be called after your signal handlers have been installed. + */ +textstartup int ttyraw(enum TtyRawFlags flags) { + int rc; + if ((g_ttyraw.flags = flags) != -1) { + if (!g_ttyraw.initialized) { + g_ttyraw.initialized = true; + ttyraw_init(); + } + if ((rc = ttyraw_enable()) != -1) { + ttyraw_hidecursor(); + } + } else { + rc = ttyraw_disable(); + } + cancolor(); + return rc; +} diff --git a/dsp/tty/ttyrgb.h b/dsp/tty/ttyrgb.h new file mode 100644 index 00000000..cc1d713d --- /dev/null +++ b/dsp/tty/ttyrgb.h @@ -0,0 +1,12 @@ +#ifndef COSMOPOLITAN_DSP_TTY_RGB_H_ +#define COSMOPOLITAN_DSP_TTY_RGB_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +struct TtyRgb { + uint8_t r, g, b, xt; +}; + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_RGB_H_ */ diff --git a/dsp/tty/windex-avx2.S b/dsp/tty/windex-avx2.S new file mode 100644 index 00000000..215e2528 --- /dev/null +++ b/dsp/tty/windex-avx2.S @@ -0,0 +1,72 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" +.yoink __FILE__ + +/ Returns index of minimum uint16 in array. +/ +/ @param rdi points to nonempty array +/ @param rsi is item count divisible by 16 +/ @note needs avx2 (haswell+) +windex$avx2: + push %rbp + mov %rsp,%rbp + .profilable + and $-32,%rsp + sub $32,%rsp + vmovdqa (%rdi),%ymm1 + vmovdqa .Lidx(%rip),%ymm3 + vmovdqa .Linc(%rip),%ymm5 + cmp $16,%esi + jbe 2f + vmovdqa %ymm3,%ymm0 + mov $16,%eax +3: vpaddw %ymm0,%ymm5,%ymm0 + mov %eax,%edx + vmovdqa (%rdi,%rdx,2),%ymm2 + vpcmpgtw %ymm2,%ymm1,%ymm4 + vpblendvb %ymm4,%ymm0,%ymm3,%ymm3 + vpminsw %ymm1,%ymm2,%ymm1 + add $16,%eax + cmp %eax,%esi + ja 3b +2: vphminposuw %xmm1,%xmm0 + vextracti128 $0x1,%ymm1,%xmm1 + vphminposuw %xmm1,%xmm1 + vmovdqa %ymm3,(%rsp) + vmovq %xmm0,%rdx + vmovq %xmm1,%rax + cmp %dx,%ax + jbe 4f + sar $16,%rdx + movzwl %dx,%edx + movzwl (%rsp,%rdx,2),%eax + jmp 5f +4: sar $16,%rax + movzwl %ax,%eax + movzwl 16(%rsp,%rax,2),%eax +5: vzeroupper + leave + ret + .endfn windex$avx2,globl + + .rodata.cst32 +.Lidx: .short 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 +.Linc: .value 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16 diff --git a/dsp/tty/windex-k8.c b/dsp/tty/windex-k8.c new file mode 100644 index 00000000..bae65651 --- /dev/null +++ b/dsp/tty/windex-k8.c @@ -0,0 +1,34 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/assert.h" + +unsigned windex$k8(short *a, size_t n) { + unsigned short min, res, i; + res = 0; + min = a[0]; + for (i = 1; i < n; ++i) { + if (a[i] < min) { + min = a[i]; + res = i; + } + } + return res; +} diff --git a/dsp/tty/windex-sse4.S b/dsp/tty/windex-sse4.S new file mode 100644 index 00000000..b90f41be --- /dev/null +++ b/dsp/tty/windex-sse4.S @@ -0,0 +1,62 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/macros.h" +.yoink __FILE__ + +/ Returns index of minimum positive int16 in array. +/ +/ @param rdi points to nonempty array +/ @param esi is 16-byte aligned 8+ / 8 multiple array item count +/ @note needs sse4 (nehalem+) +windex$sse4: + push %rbp + mov %rsp,%rbp + .profilable + mov $8,%eax + sub $32,%rsp + movdqa (%rdi),%xmm2 + movdqa .Lidx(%rip),%xmm1 + movdqa .Linc(%rip),%xmm6 + movdqa %xmm1,%xmm3 +0: cmp %eax,%esi + je 1f + add $8,%eax + movdqa -16(%rdi,%rax,2),%xmm4 + movdqa %xmm2,%xmm7 + movdqa %xmm3,%xmm5 + paddw %xmm6,%xmm5 + movdqa %xmm5,%xmm3 + pcmpgtw %xmm4,%xmm7 + pminsw %xmm4,%xmm2 + movdqa %xmm7,%xmm0 + pblendvb %xmm0,%xmm5,%xmm1 + jmp 0b +1: phminposuw %xmm2,%xmm0 + movd %xmm0,%eax + movdqa %xmm1,-32(%rbp) + shr $16,%eax + movzwl -32(%rbp,%rax,2),%eax + leave + ret + .endfn windex$sse4,globl + + .rodata.cst16 +.Lidx: .short 0,1,2,3,4,5,6,7 +.Linc: .value 8,8,8,8,8,8,8,8 diff --git a/dsp/tty/windex.S b/dsp/tty/windex.S new file mode 100644 index 00000000..004f98f2 --- /dev/null +++ b/dsp/tty/windex.S @@ -0,0 +1,43 @@ +/*-*- mode:asm; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│ +│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/nexgen32e/x86feature.h" +#include "libc/macros.h" +.yoink __FILE__ + +/ Dispatches to fastest windex() implementation. + .initbss 300,_init_windex +windex: .quad 0 + .endobj windex,globl + .previous + + .init.start 300,_init_windex + ezlea windex$avx2,ax +#if !X86_NEED(AVX2) + ezlea windex$sse4,dx + testb X86_HAVE(AVX2)+kCpuids(%rip) + cmovz %rdx,%rax +#endif /* AVX */ +#if !X86_NEED(SSE4_2) + ezlea windex$k8,dx + testb X86_HAVE(SSE4_2)+kCpuids(%rip) + cmovz %rdx,%rax +#endif /* SSE4 */ + stosq + .init.end 300,_init_windex diff --git a/dsp/tty/windex.h b/dsp/tty/windex.h new file mode 100644 index 00000000..95b26cd3 --- /dev/null +++ b/dsp/tty/windex.h @@ -0,0 +1,10 @@ +#ifndef COSMOPOLITAN_DSP_TTY_WINDEX_H_ +#define COSMOPOLITAN_DSP_TTY_WINDEX_H_ +#if !(__ASSEMBLER__ + __LINKER__ + 0) +COSMOPOLITAN_C_START_ + +extern unsigned (*const windex)(uint16_t *, size_t); + +COSMOPOLITAN_C_END_ +#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */ +#endif /* COSMOPOLITAN_DSP_TTY_WINDEX_H_ */ diff --git a/dsp/tty/write.c b/dsp/tty/write.c new file mode 100644 index 00000000..7e356ddb --- /dev/null +++ b/dsp/tty/write.c @@ -0,0 +1,59 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "dsp/tty/tty.h" +#include "libc/calls/calls.h" +#include "libc/calls/termios.h" +#include "libc/errno.h" +#include "libc/sock/sock.h" +#include "libc/sysv/consts/poll.h" +#include "libc/sysv/consts/termios.h" + +/** + * Sends data to teletypewriter the pain-free way. + * + * This function blocks forever until the full amount is transmitted, + * regardless of whether or not the character device is in non-blocking + * mode, regardless of whether or not it's interrupted by a signal. It + * can still be escaped by longjmp'ing out of a signal handler. + * + * @return 0 on success, or -1 w/ errno + */ +int ttywrite(int fd, const void *data, size_t size) { + char *p; + ssize_t rc; + size_t wrote, n; + p = data; + n = size; + do { + TryAgain: + if ((rc = write(fd, p, n)) != -1) { + wrote = rc; + p += wrote; + n -= wrote; + } else if (errno == EINTR) { + goto TryAgain; + } else if (errno == EAGAIN) { + poll((struct pollfd[]){{fd, POLLOUT}}, 1, -1); + } else { + return -1; + } + } while (n); + return 0; +} diff --git a/examples/backtrace.c b/examples/backtrace.c new file mode 100644 index 00000000..66aae016 --- /dev/null +++ b/examples/backtrace.c @@ -0,0 +1,61 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/calls/calls.h" +#include "libc/log/log.h" +#include "libc/mem/mem.h" +#include "libc/runtime/gc.h" +#include "libc/runtime/runtime.h" +#include "libc/runtime/symbols.h" +#include "libc/stdio/stdio.h" + +/* + + Your executables will try to find the addr2line tool, which is needed + to decrypt gcc debug information, enabling backtraces like this: + + 0x0000000000403a7a: Hello at examples/backtrace.c:31 + 0x0000000000403ac3: World at examples/backtrace.c:38 + 0x0000000000401608: main at examples/backtrace.c:42 + 0x0000000000401379: _start at libc/crt/crt.S:61 + + If that doesn't work, then your αcτµαlly pδrταblε εxεcµταblε will use + its own builtin fallback solution: + + 0000ac2fa7e0 000000403a9b Hello+0x49 + 0000ac2fa7f0 000000403ac4 World+0x22 + 0000ac2fa800 000000401609 main+0x7 + 0000ac2fa810 00000040137a _start+0x63 + + This is guaranteed to work if the .com.dbg file can be found. + Otherwise it'll print numbers: + + 0000268a8390 000000403a90 (null)+0x403a8f + 0000268a83a0 000000403aef (null)+0x403aee + 0000268a83b0 0000004015fe (null)+0x4015fd + 0000268a83c0 00000040137a (null)+0x401379 + +*/ + +void hello(void) { + gc(malloc(1)); + backtrace(stdout); + setenv("ADDR2LINE", "", true); + backtrace(stdout); +} + +void world(void) { + gc(malloc(1)); + hello(); +} + +int main(int argc, char *argv[]) { + world(); + return 0; +} diff --git a/examples/bigmem.c b/examples/bigmem.c new file mode 100644 index 00000000..fd58835c --- /dev/null +++ b/examples/bigmem.c @@ -0,0 +1,101 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/calls/calls.h" +#include "libc/calls/hefty/spawn.h" +#include "libc/calls/struct/stat.h" +#include "libc/log/check.h" +#include "libc/macros.h" +#include "libc/runtime/gc.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/auxv.h" +#include "libc/sysv/consts/clock.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/sysv/consts/madv.h" +#include "libc/sysv/consts/map.h" +#include "libc/sysv/consts/o.h" +#include "libc/sysv/consts/prot.h" +#include "libc/time/time.h" +#include "libc/x/x.h" + +/** + * @fileoverview Overcommit tutorial. + * You can allocate memory like a central banker prints money. + */ + +/* #define kHugeAmount (10LU * 1024LU * 1024LU * 1024LU * 1024LU) */ +#define kHugeAmount (1LU * 1024LU * 1024LU * 1024LU) + +int copyfile2(const char *frompath, const char *topath, bool dontoverwrite) { + struct stat st; + ssize_t transferred; + int rc, fromfd, tofd; + int64_t inoffset, outoffset; + rc = -1; + if ((fromfd = open(frompath, O_RDONLY | O_DIRECT, 0)) != -1) { + if (fstat(fromfd, &st) != -1 && + (tofd = + open(topath, + O_WRONLY | O_CREAT | O_DIRECT | (dontoverwrite ? O_EXCL : 0), + st.st_mode & 0777)) != -1) { + inoffset = 0; + outoffset = 0; + while (st.st_size && + (transferred = copy_file_range(fromfd, &inoffset, tofd, &outoffset, + st.st_size, 0)) != -1) { + st.st_size -= transferred; + } + if (!st.st_size) rc = 0; + rc |= close(tofd); + } + rc |= close(fromfd); + } + return rc; +} + +int main(int argc, char *argv[]) { + int fd, pid; + size_t size; + long double t1, t2; + const char *core, *core2, *core3; + volatile unsigned char *mem; + size = ROUNDUP(kHugeAmount, PAGESIZE); + core = gc(xasprintf("%s.%s", getauxval(AT_EXECFN), "core")); + core2 = gc(xasprintf("%s.%s", getauxval(AT_EXECFN), "core2")); + core3 = gc(xasprintf("%s.%s", getauxval(AT_EXECFN), "core3")); + CHECK_NE(-1, (fd = open(core, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0600))); + CHECK_NE(-1, ftruncate(fd, size)); + CHECK_NE(MAP_FAILED, + (mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0))); + strcpy(&mem[0], "hello\n\n\n\n\n\n\n\n\n\n"); + strcpy(&mem[kHugeAmount / 2], "hello\n\n\n\n\n\n\n\n\n\n"); + CHECK_NE(-1, munmap(mem, size)); + CHECK_NE(-1, + (pid = spawnve( + 0, (int[3]){STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO}, + "o/examples/stat.com", + (char *const[]){"o/examples/stat.com", core, NULL}, environ))); + CHECK_NE(-1, waitpid(pid, NULL, 0)); + CHECK_NE(-1, close(fd)); + + t1 = dtime(CLOCK_REALTIME); + CHECK_NE(-1, copyfile(core, core2, false)); + t2 = dtime(CLOCK_REALTIME); + printf("%.6Lf\n", t2 - t1); + + t1 = dtime(CLOCK_REALTIME); + CHECK_NE(-1, copyfile2(core, core3, false)); + t2 = dtime(CLOCK_REALTIME); + printf("%.6Lf\n", t2 - t1); + + /* CHECK_NE(-1, unlink(core)); */ + return 0; +} diff --git a/examples/breakpoint.c b/examples/breakpoint.c new file mode 100644 index 00000000..8c772f79 --- /dev/null +++ b/examples/breakpoint.c @@ -0,0 +1,23 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/log/log.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" + +int main(int argc, char *argv[]) { + showcrashreports(); + if (IsDebuggerPresent(false)) { + printf("debugger found!\r\n"); + DebugBreak(); + return 0; + } + printf("try running: gdb %s\r\n", argv[0]); + return 1; +} diff --git a/examples/cplusplus.cc b/examples/cplusplus.cc new file mode 100644 index 00000000..a0885b14 --- /dev/null +++ b/examples/cplusplus.cc @@ -0,0 +1,48 @@ +/*-*-mode:c++;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8-*-│ +│vi: set net ft=c++ ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2020 Justine Alexandra Roberts Tunney │ +│ │ +│ 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; version 2 of the License. │ +│ │ +│ 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., 51 Franklin Street, Fifth Floor, Boston, MA │ +│ 02110-1301 USA │ +╚─────────────────────────────────────────────────────────────────────────────*/ +#include "libc/bits/safemacros.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" + +class Log { + public: + Log(); + ~Log(); + int *x(); + + private: + int *x_; +}; + +Log::Log() { x_ = new int[64]; } +Log::~Log() { delete x_; } +int *Log::x() { return x_; } + +class Log g_log; + +int main(int argc, char *argv[]) { + int *x = new int[64]; + memset(x, 0, 64 * sizeof(int)); + for (int i = 0; i < min(64, argc); ++i) g_log.x()[i] += argc; + printf("%p %d %d %d\n", (void *)(intptr_t)g_log.x(), g_log.x()[0], + g_log.x()[0], g_log.x()[0]); + delete x; + return 0; +} diff --git a/examples/crashreport.c b/examples/crashreport.c new file mode 100644 index 00000000..dc39c2b1 --- /dev/null +++ b/examples/crashreport.c @@ -0,0 +1,89 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/bits/pushpop.h" +#include "libc/calls/ucontext.h" +#include "libc/log/log.h" +#include "libc/math.h" +#include "libc/nt/enum/errormodeflags.h" +#include "libc/nt/signals.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" + +/** + * @fileoverview Demonstrates SEGFAULT via NULL pointer dereference. + * + * In MODE=dbg mode, UBSAN should catch this and display a backtrace. + * In most other modes, e.g. MODE=balanced, the oncrash.c sig handler + * will either launch GDB or display a very fancy report. + * + * make -j8 -O MODE=opt o/opt/examples/crashreportdemo.com + * o/opt/examples/crashreportdemo.com + * + * To prevent the GDB GUI from popping up: + * + * export GDB="" + * make -j8 -O MODE=opt o/opt/examples/crashreportdemo.com + * o/opt/examples/crashreportdemo.com + */ + +int boo; + +void boop(void); + +int main(int argc, char *argv[]) { + int64_t res; + showcrashreports(); + res = 0; + + asm volatile( + "mov\t$0x1111111111111111,%rax\n\t" + "mov\t$0x3333333333333333,%rcx\n\t" + "mov\t$0x4444444444444444,%rdx\n\t" + "mov\t$0x8888888888888888,%r8\n\t" + "mov\t$0x9999999999999999,%r9d\n\t" + "mov\t$0xaaaaaaaaaaaaaaaa,%r10d\n\t" + "mov\t$0xbbbbbbbbbbbbbbbb,%r11d\n\t" + "mov\t$0x0000000000000000,%rax\n\t" + "movd\t%rax,%xmm0\n\t" + "mov\t$0x1111111111111111,%rax\n\t" + "movd\t%rax,%xmm1\n\t" + "mov\t$0x2222222222222222,%rax\n\t" + "movd\t%rax,%xmm2\n\t" + "mov\t$0x3333333333333333,%rax\n\t" + "movd\t%rax,%xmm3\n\t" + "mov\t$0x4444444444444444,%rax\n\t" + "movd\t%rax,%xmm4\n\t" + "mov\t$0x5555555555555555,%rax\n\t" + "movd\t%rax,%xmm5\n\t" + "mov\t$0x6666666666666666,%rax\n\t" + "movd\t%rax,%xmm6\n\t" + "mov\t$0x7777777777777777,%rax\n\t" + "movd\t%rax,%xmm7\n\t" + "mov\t$0x8888888888888888,%rax\n\t" + "movd\t%rax,%xmm8\n\t" + "mov\t$0x9999999999999999,%rax\n\t" + "movd\t%rax,%xmm9\n\t" + "mov\t$0xaaaaaaaaaaaaaaaa,%rax\n\t" + "movd\t%rax,%xmm10\n\t" + "mov\t$0xbbbbbbbbbbbbbbbb,%rax\n\t" + "movd\t%rax,%xmm11\n\t" + "mov\t$0xcccccccccccccccc,%rax\n\t" + "movd\t%rax,%xmm12\n\t" + "mov\t$0xdddddddddddddddd,%rax\n\t" + "movd\t%rax,%xmm13\n\t" + "mov\t$0xeeeeeeeeeeeeeeee,%rax\n\t" + "movd\t%rax,%xmm14\n\t" + "mov\t$0xffffffffffffffff,%rax\n\t" + "movd\t%rax,%xmm15\n\t" + "fldlg2\n\t"); + + res = *(int *)(intptr_t)boo / boo; + return res; +} diff --git a/examples/ctrlc.c b/examples/ctrlc.c new file mode 100644 index 00000000..2bbf4290 --- /dev/null +++ b/examples/ctrlc.c @@ -0,0 +1,66 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/calls/calls.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/mem/mem.h" +#include "libc/runtime/gc.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/exit.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/sysv/consts/sig.h" + +#define kTutorialMessage "This echos stdio until Ctrl+C is pressed.\n" +#define kVictoryMessage "\rGot Ctrl+C and longjmp() ran dtors (>'.')>\n" + +jmp_buf jb; + +void GotCtrlC(int sig) { + gclongjmp(jb, 1); + unreachable; +} + +size_t HowManyBytesOfHeapMemoryAreAllocated(void) { + return mallinfo().uordblks; +} + +void ReadAndPrintLinesLoop(void) { + ssize_t got; + unsigned char *buf; + buf = gc(malloc(BUFSIZ)); + CHECK_NE(0, HowManyBytesOfHeapMemoryAreAllocated()); + for (;;) { + CHECK_NE(-1, (got = read(STDIN_FILENO, buf, BUFSIZ))); + CHECK_EQ(got, write(STDOUT_FILENO, buf, got)); + } +} + +int main(int argc, char *argv[]) { + int rc; + rc = 0; + showcrashreports(); + if (cancolor()) { + CHECK_EQ(0 /* cosmo runtime doesn't link malloc */, + HowManyBytesOfHeapMemoryAreAllocated()); + puts("This echos stdio until Ctrl+C is pressed."); + if (!(rc = setjmp(jb))) { + CHECK_NE(SIG_ERR, signal(SIGINT, GotCtrlC)); + ReadAndPrintLinesLoop(); + unreachable; + } else { + --rc; + } + CHECK_EQ(0, HowManyBytesOfHeapMemoryAreAllocated()); + puts("\rGot Ctrl+C and longjmp() ran dtors (>'.')>"); + } + return rc; +} diff --git a/examples/date.c b/examples/date.c new file mode 100644 index 00000000..5b8c9f91 --- /dev/null +++ b/examples/date.c @@ -0,0 +1,21 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/runtime/gc.h" +#include "libc/stdio/stdio.h" +#include "libc/x/x.h" + +/** + * @fileoverview ISO-8601 international high-precision timestamp printer. + */ + +int main(int argc, char *argv[]) { + puts(gc(xiso8601ts(NULL))); + return 0; +} diff --git a/examples/dinlerp.c b/examples/dinlerp.c new file mode 100644 index 00000000..067f9383 --- /dev/null +++ b/examples/dinlerp.c @@ -0,0 +1,376 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "dsp/core/core.h" +#include "dsp/core/twixt8.h" +#include "dsp/scale/scale.h" +#include "dsp/tty/itoa8.h" +#include "dsp/tty/quant.h" +#include "libc/alg/arraylist2.h" +#include "libc/calls/calls.h" +#include "libc/calls/ioctl.h" +#include "libc/calls/struct/stat.h" +#include "libc/calls/struct/winsize.h" +#include "libc/limits.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/macros.h" +#include "libc/math.h" +#include "libc/mem/mem.h" +#include "libc/runtime/gc.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/sysv/consts/map.h" +#include "libc/sysv/consts/o.h" +#include "libc/sysv/consts/prot.h" +#include "libc/sysv/consts/termios.h" +#include "libc/x/x.h" +#include "third_party/stb/stb_image.h" + +/** + * Hat tips go out to Hornet, CRTC, DESiRE, Hans Petter Jansson, Guihua + * Cui, Ming Ronnier Luoand anyone else Mister Rogers would describe as + * the The Helpers Of This World who've helped us learn more about the + * cool yet exceedingly difficult things possible to do with graphics. + */ + +#define DIN99 1 +#define GAMMA 4.1 +#define GAMMA_A .05 +#define GAMMA_B 50. +#define GAMMA_C .055 +#define COLORSPACE_SRC kSrgbD65ToXyzD50 +#define COLORSPACE_TTY kSrgbD65ToXyzD50 + +#define SQR(X) ((X) * (X)) +#define DEG(X) ((X)*M_PI / 180) + +const double kXyzKappa = 24389 / 27.; +const double kXyzEpsilon = 216 / 24389.; + +const double kSrgbD65ToXyzD50[3][3] = { + {.4360747, .3850649, .1430804}, + {.2225045, .7168786, .0606169}, + {.0139322, .0971045, .7141733}, +}; + +const double kCieRgbEToXyz[3][3] = { + {.4887180, .3106803, .2006017}, + {.1762044, .8129847, .0108109}, + {.0000000, .0102048, .9897952}, +}; + +const unsigned char kShadePct[] = {0300, 0200, 0100}; +const unsigned short kShadeRune[] = {u'▓', u'▒', u'░'}; + +const unsigned char kAnsiTango[16][3] = { + {46, 52, 54}, {204, 0, 0}, {78, 154, 6}, {196, 160, 0}, + {52, 101, 164}, {117, 80, 123}, {6, 152, 154}, {211, 215, 207}, + {85, 87, 83}, {239, 41, 41}, {138, 226, 52}, {252, 233, 79}, + {114, 159, 207}, {173, 127, 168}, {52, 226, 226}, {238, 238, 236}, +}; + +const unsigned char kCga[16][3] = { + {0, 0, 0}, {170, 0, 0}, {0, 170, 0}, {170, 85, 0}, + {0, 0, 170}, {170, 0, 170}, {0, 170, 170}, {170, 170, 170}, + {85, 85, 85}, {255, 85, 85}, {85, 255, 85}, {255, 255, 85}, + {85, 85, 255}, {255, 85, 255}, {85, 255, 255}, {255, 255, 255}, +}; + +struct Blends { + size_t i, n; + struct Blend { + unsigned char color[4]; + unsigned char bg, fg; + unsigned short rune; + } * p; +} blends; + +static double Gamma(double x) { + if (x < GAMMA_A) return x / GAMMA_B; + return pow(1 / (1 + GAMMA_C) * (x + GAMMA_C), GAMMA); +} + +static void *LoadRgb(double rgb[3], const unsigned char pix[3]) { + rgb[0] = Gamma(1. / 255 * pix[0]); + rgb[1] = Gamma(1. / 255 * pix[1]); + rgb[2] = Gamma(1. / 255 * pix[2]); + return rgb; +} + +static double Lab(double x) { + return x > kXyzEpsilon ? cbrtf(x) : (kXyzKappa * x + 16) / 116; +} + +static void XyzToLab(double lab[3], const double d50xyz[3]) { + double Y, L, a, b; + Y = Lab(d50xyz[1]); + L = 116 * Y - 16; + a = 500 * (Lab(d50xyz[0]) - Y); + b = 200 * (Y - Lab(d50xyz[2])); + lab[0] = L, lab[1] = a, lab[2] = b; +} + +static void XyzToDin99d(unsigned char din99d[3], const double d50xyz[3]) { + double e, f, G, C, h, xyz[3], lab[3]; + memcpy(xyz, d50xyz, sizeof(xyz)); + xyz[0] = 1.12f * xyz[0] - .12f * xyz[2]; + XyzToLab(lab, xyz); + e = (+lab[1] * cosf(DEG(50)) + lab[2] * sinf(DEG(50))); + f = (-lab[1] * sinf(DEG(50)) + lab[2] + cosf(DEG(50))) * 1.14; + G = sqrtf(SQR(e) + SQR(f)); + C = logf(1 + .06 * G) * 22.5f; + h = atan2f(f, e) + DEG(50); + h = fmodf(h, DEG(360)); + if (h < 0) h += DEG(360); + din99d[0] = MIN(255, MAX(0, 325.22f * logf(1 + .0036 * lab[0]) * 2.5f)); + din99d[1] = MIN(255, MAX(0, C * cos(h) * 2.5f + 128)); + din99d[2] = MIN(255, MAX(0, C * sin(h) * 2.5f + 128)); +} + +static void AddColor(int bg, int fg, int rune, int r, int g, int b, int x) { + int i; + if (blends.i) { + for (i = blends.i; --i;) { + if (blends.p[i].color[0] == r && blends.p[i].color[1] == g && + blends.p[i].color[2] == b) { + return; + } + } + } + CHECK_NE( + -1, + APPEND(&blends.p, &blends.i, &blends.n, + (&(struct Blend){ + .bg = bg, .fg = fg, .rune = rune, .color = {r, g, b, x}}))); +} + +static void AddBlend(int bgxterm, int fgxterm, int rune, int shade, + const unsigned char bgrgb[4], + const unsigned char fgrgb[4]) { + AddColor(bgxterm, fgxterm, rune, twixt8(bgrgb[0], fgrgb[0], shade), + twixt8(bgrgb[1], fgrgb[1], shade), twixt8(bgrgb[2], fgrgb[2], shade), + 0); +} + +static void MakeBlends(const unsigned char palette[16][3]) { + int r, i, j, k; + double rgb[3], xyz[3]; + unsigned char tab[256][4]; + unsigned char cube[6] = {0, 0137, 0207, 0257, 0327, 0377}; + unsigned char seqs[2][2] = {{16, 255}}; + for (i = 0; i < 16; ++i) { + tab[i][0] = palette[i][0]; + tab[i][1] = palette[i][1]; + tab[i][2] = palette[i][2]; + tab[i][3] = i; + } + for (i = 16; i < 232; ++i) { + tab[i][0] = cube[((i - 020) / 044) % 6]; + tab[i][1] = cube[((i - 020) / 6) % 6]; + tab[i][2] = cube[(i - 020) % 6]; + tab[i][3] = i; + } + for (i = 232; i < 256; ++i) { + tab[i][0] = 8 + (i - 232) * 10; + tab[i][1] = 8 + (i - 232) * 10; + tab[i][2] = 8 + (i - 232) * 10; + tab[i][3] = i; + } +#if DIN99 + for (i = 0; i < 256; ++i) { + LoadRgb(rgb, tab[i]); + vmatmul3(xyz, rgb, COLORSPACE_TTY); + XyzToDin99d(tab[i], xyz); + } +#endif + for (r = 0; r < ARRAYLEN(seqs); ++r) { + for (i = seqs[r][0]; i <= seqs[r][1]; ++i) { + for (j = seqs[r][0]; j <= seqs[r][1]; ++j) { + if (i == j) { + AddColor(i, 0, 0, tab[i][0], tab[i][1], tab[i][2], 0); + } else { + for (k = 0; k < ARRAYLEN(kShadeRune); ++k) { + AddBlend(i, j, kShadeRune[k], kShadePct[k], tab[i], tab[j]); + AddBlend(j, i, kShadeRune[k], kShadePct[k], tab[j], tab[i]); + } + } + } + } + } +} + +static int PickColor(unsigned char color[3]) { + int i, best, least, dist; + best = -1; + least = INT_MAX; + for (i = 0; i < blends.i; ++i) { + dist = SQR(blends.p[i].color[0] - color[0]) + + SQR(blends.p[i].color[1] - color[1]) + + SQR(blends.p[i].color[2] - color[2]); + if (dist < least) { + least = dist; + best = i; + } + } + return best; +} + +static void SetBg(int x) { + if (0 <= x && x < 16) { + if (x < 8) { + x += 40; + } else { + x -= 8; + x *= 100; + } + printf("\e[%dm", x); + } else { + /* assert(false); */ + printf("\e[48;5;%dm", x); + } +} + +static void SetFg(int x) { + if (0 <= x && x < 16) { + if (x < 8) { + x += 30; + } else { + x -= 8; + x *= 90; + } + printf("\e[%dm", x); + } else { + /* assert(false); */ + printf("\e[38;5;%dm", x); + } +} + +static void PrintImage(long yn, long xn, unsigned char src[4][yn][xn]) { + int y, x, c; + double rgb[3], xyz[3]; + unsigned char din99d[3]; + for (y = 0; y < yn; ++y) { + printf("\n"); + for (x = 0; x < xn; ++x) { + din99d[0] = src[0][y][x]; + din99d[1] = src[1][y][x]; + din99d[2] = src[2][y][x]; +#if DIN99 + LoadRgb(rgb, din99d); + vmatmul3(xyz, rgb, COLORSPACE_SRC); + XyzToDin99d(din99d, xyz); +#endif + c = PickColor(din99d); + if (blends.p[c].rune) { + SetBg(blends.p[c].bg); + SetFg(blends.p[c].fg); + printf("%hc", blends.p[c].rune); + } else { + SetBg(blends.p[c].bg); + printf(" "); + } + } + printf("\e[0m"); + } + printf("\r"); +} + +static void *Deinterlace(long dcn, long dyn, long dxn, + unsigned char dst[dcn][dyn][dxn], long syw, long sxw, + long scw, const unsigned char src[syw][sxw][scw], + long syn, long sxn, long sy0, long sx0, long sc0) { + long y, x, c; + for (y = 0; y < dyn; ++y) { + for (x = 0; x < dxn; ++x) { + for (c = 0; c < dcn; ++c) { + dst[c][y][x] = src[sy0 + y][sx0 + x][sc0 + c]; + } + } + } + return dst; +} + +static void GetTermSize(int out_rows[1], int out_cols[1]) { + struct winsize ws; + ws.ws_row = 24; + ws.ws_col = 80; + if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) == -1) { + ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws); + } + out_rows[0] = ws.ws_row; + out_cols[0] = ws.ws_col; +} + +static void ProcessImage(long syn, long sxn, unsigned char img[syn][sxn][4]) { + int dyn, dxn; + double ry, rx; + GetTermSize(&dyn, &dxn); + ry = syn, rx = sxn; + ry /= dyn, rx /= dxn; + PrintImage( + dyn, dxn, + EzGyarados(4, dyn, dxn, gc(xmemalign(32, dyn * dxn * 4)), 4, syn, sxn, + Deinterlace(4, syn, sxn, gc(xmemalign(32, syn * sxn * 4)), syn, + sxn, 4, img, syn, sxn, 0, 0, 0), + 0, 4, dyn, dxn, syn, sxn, ry, rx, 0, 0)); +} + +static void WithImageFile(const char *path, + void fn(long yn, long xn, + unsigned char src[yn][xn][4])) { + struct stat st; + void *map, *data; + int fd, yn, xn, cn; + CHECK_NE(-1, (fd = open(path, O_RDONLY)), "%s", path); + CHECK_NE(-1, fstat(fd, &st)); + CHECK_GT(st.st_size, 0); + CHECK_LE(st.st_size, INT_MAX); + CHECK_NE(MAP_FAILED, + (map = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0))); + CHECK_NOTNULL( + (data = stbi_load_from_memory(map, st.st_size, &xn, &yn, NULL, 4)), "%s", + path); + CHECK_NE(-1, munmap(map, st.st_size)); + CHECK_NE(-1, close(fd)); + fn(yn, xn, data); + free(data); +} + +static void PrintData(void) { + int i; + for (i = 0; i < blends.i; ++i) { + printf("%3d %3d %3d %3d %3d %d\n", blends.p[i].color[0], + blends.p[i].color[1], blends.p[i].color[2], blends.p[i].bg, + blends.p[i].fg, blends.p[i].rune); + } +} + +void *OpenRgbMap(const char *path) { + int fd; + void *map; + size_t size; + size = 256 * 256 * 256 * 3; + CHECK_NE(-1, (fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644))); + CHECK_NE(-1, ftruncate(fd, size)); + CHECK_NE(MAP_FAILED, + (map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0))); + CHECK_NE(-1, close(fd)); + return map; +} + +int main(int argc, char *argv[]) { + int i; + MakeBlends(kCga); + for (i = 1; i < argc; ++i) { + WithImageFile(argv[i], ProcessImage); + } + return 0; +} diff --git a/examples/examples.mk b/examples/examples.mk new file mode 100644 index 00000000..458f13ab --- /dev/null +++ b/examples/examples.mk @@ -0,0 +1,118 @@ +#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐ +#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘ + +PKGS += EXAMPLES + +EXAMPLES_FILES := $(wildcard examples/*) +EXAMPLES_MAINS_S = $(filter %.S,$(EXAMPLES_FILES)) +EXAMPLES_MAINS_C = $(filter %.c,$(EXAMPLES_FILES)) +EXAMPLES_MAINS_CC = $(filter %.cc,$(EXAMPLES_FILES)) + +EXAMPLES_SRCS = \ + $(EXAMPLES_MAINS_S) \ + $(EXAMPLES_MAINS_C) \ + $(EXAMPLES_MAINS_CC) + +EXAMPLES_MAINS = \ + $(EXAMPLES_MAINS_S) \ + $(EXAMPLES_MAINS_C) \ + $(EXAMPLES_MAINS_CC) + +EXAMPLES_OBJS = \ + $(EXAMPLES_SRCS:%=o/$(MODE)/%.zip.o) \ + $(EXAMPLES_MAINS_S:%.S=o/$(MODE)/%.o) \ + $(EXAMPLES_MAINS_C:%.c=o/$(MODE)/%.o) \ + $(EXAMPLES_MAINS_CC:%.cc=o/$(MODE)/%.o) + +EXAMPLES_COMS = \ + $(EXAMPLES_OBJS:%.o=%.com) + +EXAMPLES_ELFS = \ + $(EXAMPLES_OBJS:%.o=%.elf) + +EXAMPLES_BINS = \ + $(EXAMPLES_ELFS) \ + $(EXAMPLES_COMS) \ + $(EXAMPLES_COMS:%=%.dbg) + +EXAMPLES_DIRECTDEPS = \ + APE_LIB \ + DSP_CORE \ + DSP_SCALE \ + DSP_TTY \ + LIBC_ALG \ + LIBC_BITS \ + LIBC_CALLS \ + LIBC_CALLS_HEFTY \ + LIBC_CONV \ + LIBC_FMT \ + LIBC_LOG \ + LIBC_MATH \ + LIBC_MEM \ + LIBC_NEXGEN32E \ + LIBC_NT_KERNELBASE \ + LIBC_NT_NTDLL \ + LIBC_NT_USER32 \ + LIBC_RAND \ + LIBC_RUNTIME \ + LIBC_SOCK \ + LIBC_STDIO \ + LIBC_STR \ + LIBC_STUBS \ + LIBC_SYSV \ + LIBC_SYSV_CALLS \ + LIBC_TESTLIB \ + LIBC_TIME \ + LIBC_TINYMATH \ + LIBC_UNICODE \ + LIBC_X \ + THIRD_PARTY_COMPILER_RT \ + THIRD_PARTY_DLMALLOC \ + THIRD_PARTY_DTOA \ + THIRD_PARTY_DUKTAPE \ + THIRD_PARTY_GETOPT \ + THIRD_PARTY_MUSL \ + THIRD_PARTY_STB \ + THIRD_PARTY_XED \ + THIRD_PARTY_ZLIB \ + TOOL_VIZ_LIB + +EXAMPLES_DEPS := \ + $(call uniq,$(foreach x,$(EXAMPLES_DIRECTDEPS),$($(x)))) + +o/$(MODE)/examples/examples.pkg: \ + $(EXAMPLES_OBJS) \ + $(foreach x,$(EXAMPLES_DIRECTDEPS),$($(x)_A).pkg) + +o/$(MODE)/examples/unbourne.o: \ + OVERRIDE_CPPFLAGS += \ + -DSTACK_FRAME_UNLIMITED + +o/$(MODE)/examples/%.com.dbg: \ + $(EXAMPLES_DEPS) \ + o/$(MODE)/examples/%.o \ + o/$(MODE)/examples/examples.pkg \ + $(CRT) \ + $(APE) + @$(APELINK) + +o/$(MODE)/examples/%.elf: \ + $(EXAMPLES_DEPS) \ + o/$(MODE)/examples/%.o \ + $(CRT) \ + $(ELF) + @$(ELFLINK) + +$(EXAMPLES_OBJS): examples/examples.mk + +o/$(MODE)/examples/hellojs.com.dbg: \ + $(EXAMPLES_DEPS) \ + o/$(MODE)/examples/hellojs.o \ + o/$(MODE)/examples/hello.js.zip.o \ + o/$(MODE)/examples/examples.pkg \ + $(CRT) \ + $(APE) + @$(APELINK) + +.PHONY: o/$(MODE)/examples +o/$(MODE)/examples: $(EXAMPLES_BINS) diff --git a/examples/findprime.c b/examples/findprime.c new file mode 100644 index 00000000..7a7524f5 --- /dev/null +++ b/examples/findprime.c @@ -0,0 +1,64 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/bits/bits.h" +#include "libc/calls/calls.h" +#include "libc/calls/struct/itimerval.h" +#include "libc/conv/conv.h" +#include "libc/limits.h" +#include "libc/log/check.h" +#include "libc/log/log.h" +#include "libc/math.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/sysv/consts/itimer.h" +#include "libc/sysv/consts/sig.h" +#include "libc/time/time.h" + +static const struct itimerval kTimer = {{0, 10000}, {0, 10000}}; /* 10ms */ +static volatile bool32 showprogress_; +static const char *magic_; + +void OnInterrupt(int sig) { + showprogress_ = true; +} +void ShowProgress(uintmax_t i, uintmax_t j, uintmax_t n) { + fprintf(stderr, "%s%,40jd%,40jd%,40jd\r\n", magic_, i, j, n); + showprogress_ = false; +} + +static bool IsPrime(uintmax_t i) { + uintmax_t j, n; + for (j = 3, n = (unsigned long)floorl(sqrtl(i)); j <= n; j += 2) { + if (showprogress_) ShowProgress(i, j, n); + if (i % j == 0) return false; + } + return true; +} + +static void TryNumber(uintmax_t x, uintmax_t i) { + if (IsPrime(i)) { + printf("%s%,jd%s%,jd\n", "the prime nearest ", x, " is ", i); + exit(0); + } +} + +int main(int argc, char **argv) { + uintmax_t x, i, j; + CHECK_EQ(2, argc); + signal(SIGALRM, OnInterrupt); + setitimer(ITIMER_REAL, &kTimer, NULL); + magic_ = cancolor() ? "\e[F\e[K" : ""; + if ((x = strtoumax(argv[1], NULL, 0)) % 2 == 0) ++x; + TryNumber(x, x); + for (i = x, j = x;;) { + if (i < UINTMAX_MAX) TryNumber(x, i), i += 2; + if (j > 1) TryNumber(x, j), j -= 2; + } +} diff --git a/examples/fld.c b/examples/fld.c new file mode 100644 index 00000000..fc00cae9 --- /dev/null +++ b/examples/fld.c @@ -0,0 +1,121 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/inttypes.h" +#include "libc/literal.h" +#include "libc/math.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" + +static const char kHeaderBin[] = "\ +/\t┌sign\n\ +/\t│ ┌exponent\n\ +/\t│ │ ┌intpart\n\ +/\t│ │ │ ┌fraction\n\ +/\t│ │ │ │\n\ +/\t│┌┴────────────┐│┌┴────────────────────────────────────────────────────────────┐\n"; + +static const char kHeaderHex[] = "\ +/\t ┌sign/exponent\n\ +/\t │ ┌intpart/fraction\n\ +/\t │ │\n\ +/\t┌┴─┐┌┴─────────────┐\n"; + +void dobin(const char *op, long double x, FILE *f) { + uint16_t hi; + uint64_t lo; + uint8_t buf[16]; + memcpy(buf, &x, sizeof(x)); + memcpy(&lo, &buf[0], sizeof(lo)); + memcpy(&hi, &buf[8], sizeof(hi)); + fprintf(f, "/\t%016" PRIb16 "%064" PRIb64 " %-8s %19.19Lf\n", hi, lo, op, x); +} + +void dohex(const char *op, long double x, FILE *f) { + uint16_t hi; + uint64_t lo; + uint8_t buf[16]; + memcpy(buf, &x, sizeof(x)); + memcpy(&lo, &buf[0], sizeof(lo)); + memcpy(&hi, &buf[8], sizeof(hi)); + fprintf(f, "/\t%04" PRIx16 "%016" PRIx64 " %-8s %19.19Lf\n", hi, lo, op, x); +} + +#define DOBIN(OP) \ + dobin(" " #OP, OP(), stdout); \ + dobin("-" #OP, -OP(), stdout) + +#define DOHEX(OP) \ + dohex(" " #OP, OP(), stdout); \ + dohex("-" #OP, -OP(), stdout) + +int main(int argc, char *argv[]) { + fputs(kHeaderBin, stdout); + DOBIN(fldz); + DOBIN(fld1); + DOBIN(fldpi); + DOBIN(fldl2t); + DOBIN(fldlg2); + DOBIN(fldln2); + DOBIN(fldl2e); + DOBIN(finit); + fputc('\n', stdout); + fputs(kHeaderHex, stdout); + DOHEX(fldz); + DOHEX(fld1); + DOHEX(fldpi); + DOHEX(fldl2t); + DOHEX(fldlg2); + DOHEX(fldln2); + DOHEX(fldl2e); + DOHEX(finit); + return 0; +} + +// clang-format off +// +// ┌sign +// │ ┌exponent +// │ │ ┌intpart +// │ │ │ ┌fraction +// │ │ │ │ +// │┌┴────────────┐│┌┴────────────────────────────────────────────────────────────┐ +// 00000000000000000000000000000000000000000000000000000000000000000000000000000000 fldz 0.0000000000000000000 +// 10000000000000000000000000000000000000000000000000000000000000000000000000000000 -fldz -0.0000000000000000000 +// 00111111111111111000000000000000000000000000000000000000000000000000000000000000 fld1 1.0000000000000000000 +// 10111111111111111000000000000000000000000000000000000000000000000000000000000000 -fld1 -1.0000000000000000000 +// 01000000000000001100100100001111110110101010001000100001011010001100001000110101 fldpi 3.1415926540000000000 +// 11000000000000001100100100001111110110101010001000100001011010001100001000110101 -fldpi -3.1415926540000000000 +// 01000000000000001101010010011010011110000100101111001101000110111000101011111110 fldl2t 3.3219280950000000000 +// 11000000000000001101010010011010011110000100101111001101000110111000101011111110 -fldl2t -3.3219280950000000000 +// 00111111111111011001101000100000100110101000010011111011110011111111011110011001 fldlg2 0.3010299960000000000 +// 10111111111111011001101000100000100110101000010011111011110011111111011110011001 -fldlg2 -0.3010299960000000000 +// 00111111111111101011000101110010000101111111011111010001110011110111100110101100 fldln2 0.6931471810000000000 +// 10111111111111101011000101110010000101111111011111010001110011110111100110101100 -fldln2 -0.6931471810000000000 +// 00111111111111111011100010101010001110110010100101011100000101111111000010111100 fldl2e 1.4426950410000000000 +// 10111111111111111011100010101010001110110010100101011100000101111111000010111100 -fldl2e -1.4426950410000000000 +// +// ┌sign/exponent +// │ ┌intpart/fraction +// │ │ +// ┌┴─┐┌┴─────────────┐ +// 00000000000000000000 fldz 0.0000000000000000000 +// 80000000000000000000 -fldz -0.0000000000000000000 +// 3fff8000000000000000 fld1 1.0000000000000000000 +// bfff8000000000000000 -fld1 -1.0000000000000000000 +// 4000c90fdaa22168c235 fldpi 3.1415926540000000000 +// c000c90fdaa22168c235 -fldpi -3.1415926540000000000 +// 4000d49a784bcd1b8afe fldl2t 3.3219280950000000000 +// c000d49a784bcd1b8afe -fldl2t -3.3219280950000000000 +// 3ffd9a209a84fbcff799 fldlg2 0.3010299960000000000 +// bffd9a209a84fbcff799 -fldlg2 -0.3010299960000000000 +// 3ffeb17217f7d1cf79ac fldln2 0.6931471810000000000 +// bffeb17217f7d1cf79ac -fldln2 -0.6931471810000000000 +// 3fffb8aa3b295c17f0bc fldl2e 1.4426950410000000000 +// bfffb8aa3b295c17f0bc -fldl2e -1.4426950410000000000 diff --git a/examples/forkrand.c b/examples/forkrand.c new file mode 100644 index 00000000..725e7d81 --- /dev/null +++ b/examples/forkrand.c @@ -0,0 +1,44 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/log/log.h" +#include "libc/nt/nt/process.h" +#include "libc/rand/rand.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/calls/calls.h" +#include "libc/time/time.h" + +noinline void dostuff(void) { + srand(rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */ + for (unsigned i = 0; i < 5; ++i) { + int us = rand() % 500000; + usleep(us); + printf("%s%u%s%u [%s=%d]\n", "hello no. ", i, " from ", getpid(), "us", us); + fflush(stdout); + } +} + +int main(int argc, char *argv[]) { + fprintf(stderr, "%p\n", RtlCloneUserProcess); + int child; + if ((child = fork()) == -1) perror("fork"), exit(1); + if (!child) { + /* child process */ + dostuff(); + return 0; + } else { + /* parent process */ + dostuff(); + /* note: abandoned children become zombies */ + int rc, wstatus; + if ((rc = wait(&wstatus)) == -1) perror("wait"), exit(1); + return WEXITSTATUS(wstatus); + } +} diff --git a/examples/forky.c b/examples/forky.c new file mode 100644 index 00000000..7863f5c0 --- /dev/null +++ b/examples/forky.c @@ -0,0 +1,51 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/calls/calls.h" +#include "libc/calls/hefty/spawn.h" +#include "libc/calls/internal.h" +#include "libc/conv/conv.h" +#include "libc/log/check.h" +#include "libc/mem/mem.h" +#include "libc/nt/enum/filemapflags.h" +#include "libc/nt/enum/pageflags.h" +#include "libc/nt/memory.h" +#include "libc/runtime/gc.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/x/x.h" + +int main(int argc, char *argv[]) { + int pid; + long *addr; + int64_t fh; + if (argc == 1) { + fh = CreateFileMappingNuma(-1, &kNtIsInheritable, kNtPageReadwrite, 0, + FRAMESIZE, NULL, kNtNumaNoPreferredNode); + addr = MapViewOfFileExNuma(fh, kNtFileMapRead | kNtFileMapWrite, 0, 0, + FRAMESIZE, NULL, kNtNumaNoPreferredNode); + *addr = 0x31337; + CHECK_NE(-1, (pid = spawnve( + 0, (int[3]){STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO}, + "o/examples/forky.com", + (char *const[]){"o/examples/forky.com", + gc(xasprintf("%#lx", (intptr_t)addr)), + gc(xasprintf("%#lx", fh)), NULL}, + environ))); + CHECK_NE(-1, waitpid(pid, NULL, 0)); + } else { + addr = (long *)(intptr_t)strtoul(argv[1], NULL, 0); + fh = strtoul(argv[2], NULL, 0); + addr = MapViewOfFileExNuma(fh, kNtFileMapRead | kNtFileMapWrite, 0, 0, + FRAMESIZE, addr, kNtNumaNoPreferredNode); + printf("%#lx\n", *addr); + } + return 0; +} diff --git a/examples/generalized-automatic-datastructure-printing.c b/examples/generalized-automatic-datastructure-printing.c new file mode 100644 index 00000000..d7f8edbc --- /dev/null +++ b/examples/generalized-automatic-datastructure-printing.c @@ -0,0 +1,52 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/log/gdb.h" +#include "libc/rand/rand.h" +#include "libc/stdio/stdio.h" + +/** + * @fileovierview gdbexec(s) demo + * It basically launches an ephemeral `gdb -p $PID -ex "$s"`. + */ + +int i; +int M[8][8] = { + {772549, 921569, 407843, 352941, 717647, 78431, 666667, 627451}, + {321569, 419608, 227451, 396078, 223529, 882353, 952941, 937255}, + {15686, 545098, 31373, 7843, 15686, 298039, 976471, 352941}, + {70588, 858824, 415686, 184314, 25098, 5098, 141176, 47059}, + {141176, 541176, 658824, 227451, 490196, 301961, 937255, 678431}, + {188235, 823529, 858824, 87451, 545098, 611765, 188235, 576471}, + {580392, 913725, 996078, 592157, 7451, 176471, 862745, 784314}, + {278431, 945098, 843137, 439216, 878431, 529412, 262745, 43137}, +}; + +int main(int argc, char *argv[]) { + int y, x; + for (i = 0;; ++i) { + for (y = 0; y < 8; ++y) { + for (x = 0; x < 8; ++x) { + if (!(M[y][x] % 2)) { + M[y][x] /= 2; + } else { + M[y][x] *= 3; + M[y][x] += 1; + } + } + } + if (rand() % 10000 == 0) { + gdbexec("print i"); + gdbexec("print M"); + break; + } + } + printf("quitting\n"); + return 0; +} diff --git a/examples/gui.c b/examples/gui.c new file mode 100644 index 00000000..291f38fb --- /dev/null +++ b/examples/gui.c @@ -0,0 +1,15 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/nt/enum/messageboxtype.h" +#include "libc/nt/messagebox.h" + +int main(int argc, char *argv[]) { + return MessageBox(0, u"hello world", u"cosmopolitan", kNtMbOk) ? 0 : 1; +} diff --git a/examples/hello.c b/examples/hello.c new file mode 100644 index 00000000..3b2e16d0 --- /dev/null +++ b/examples/hello.c @@ -0,0 +1,23 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/errno.h" +#include "libc/stdio/stdio.h" + +int main() { + /* + * Cosmopolitan's "Hello World" demonstrates a best practice. + * + * Since we conditionally link heavyweight features based on which + * characters are present in the format string, it's a good idea to + * have that string consist solely of directives. + */ + printf("%s\n", "hello world"); + return errno; +} diff --git a/examples/hello.js b/examples/hello.js new file mode 100644 index 00000000..d5058ec8 --- /dev/null +++ b/examples/hello.js @@ -0,0 +1,2 @@ +NativePrint('Hello world!\n'); +NativePrint('2+3=' + NativeAdd(2, 3) + '\n'); diff --git a/examples/hello2.c b/examples/hello2.c new file mode 100644 index 00000000..d1fc18fe --- /dev/null +++ b/examples/hello2.c @@ -0,0 +1,28 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/str/str.h" +#include "libc/calls/calls.h" +#include "libc/sysv/consts/fileno.h" + +#define kMessage "hello world\r\n" + +int main() { + /* + * Cosmopolitan "Hello World" using system calls. + * + * Another Cosmopolitan best practice is to use the standard symbolic + * names for file descriptors 0, 1, and 2. This is a good idea because + * on Windows the numbers are actually different. Because Cosmopolitan + * is a zero-emulation library, we address that problem by turning + * traditional #define's into variables, which the runtime determines + * automatically. + */ + return write(STDOUT_FILENO, kMessage, strlen(kMessage)) != -1 ? 0 : 1; +} diff --git a/examples/hello3.c b/examples/hello3.c new file mode 100644 index 00000000..49896be5 --- /dev/null +++ b/examples/hello3.c @@ -0,0 +1,19 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/errno.h" +#include "libc/runtime/gc.h" +#include "libc/calls/calls.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/x/x.h" + +int main() { + dprintf(STDOUT_FILENO, "%s\n", gc(xasprintf("%'s", "(╯°□°)╯︵' ┻━┻"))); + return errno; +} diff --git a/examples/hello4.c b/examples/hello4.c new file mode 100644 index 00000000..29a69466 --- /dev/null +++ b/examples/hello4.c @@ -0,0 +1,16 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/errno.h" +#include "libc/stdio/stdio.h" + +int main() { + printf("%s \n", "hello world"); + return errno; +} diff --git a/examples/hellojs.c b/examples/hellojs.c new file mode 100644 index 00000000..8afb234d --- /dev/null +++ b/examples/hellojs.c @@ -0,0 +1,56 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/calls/calls.h" +#include "libc/calls/struct/stat.h" +#include "libc/log/check.h" +#include "libc/mem/mem.h" +#include "libc/runtime/gc.h" +#include "libc/sysv/consts/o.h" +#include "third_party/duktape/duktape.h" + +static duk_ret_t NativePrint(duk_context *ctx) { + duk_push_string(ctx, " "); + duk_insert(ctx, 0); + duk_join(ctx, duk_get_top(ctx) - 1); + fputs(duk_safe_to_string(ctx, -1), stdout); + return 0; +} + +static duk_ret_t NativeAdd(duk_context *ctx) { + int i, n; + double r; + n = duk_get_top(ctx); + for (r = i = 0; i < n; i++) r += duk_to_number(ctx, i); + duk_push_number(ctx, r); + return 1; +} + +int main(int argc, char *argv[]) { + int fd; + struct stat st; + const char *code; + duk_context *ctx; + ctx = duk_create_heap_default(); + duk_push_c_function(ctx, NativePrint, DUK_VARARGS); + duk_put_global_string(ctx, "NativePrint"); + duk_push_c_function(ctx, NativeAdd, DUK_VARARGS); + duk_put_global_string(ctx, "NativeAdd"); + + CHECK_NE(-1, (fd = open("zip:examples/hello.js", O_RDONLY))); + CHECK_NE(-1, fstat(fd, &st)); + CHECK_NOTNULL((code = gc(malloc(st.st_size)))); + CHECK_EQ(st.st_size, read(fd, code, st.st_size)); + CHECK_NE(-1, close(fd)); + + duk_eval_string(ctx, code); + duk_pop(ctx); + duk_destroy_heap(ctx); + return 0; +} diff --git a/examples/hidecursor.c b/examples/hidecursor.c new file mode 100644 index 00000000..05bf4c3d --- /dev/null +++ b/examples/hidecursor.c @@ -0,0 +1,26 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/nt/console.h" +#include "libc/nt/runtime.h" +#include "libc/nt/struct/consolecursorinfo.h" +#include "libc/nt/synchronization.h" + +int main(int argc, char *argv[]) { + struct NtConsoleCursorInfo ntcursor; + SleepEx(1000, false); + GetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor); + ntcursor.bVisible = false; + SetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor); + SleepEx(1000, false); + ntcursor.bVisible = true; + SetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor); + SleepEx(1000, false); + return 0; +} diff --git a/examples/invtsc.c b/examples/invtsc.c new file mode 100644 index 00000000..c4d9b77f --- /dev/null +++ b/examples/invtsc.c @@ -0,0 +1,77 @@ +#if 0 +/*─────────────────────────────────────────────────────────────────╗ +│ To the extent possible under law, Justine Tunney has waived │ +│ all copyright and related or neighboring rights to this file, │ +│ as it is written in the following disclaimers: │ +│ • http://unlicense.org/ │ +│ • http://creativecommons.org/publicdomain/zero/1.0/ │ +╚─────────────────────────────────────────────────────────────────*/ +#endif +#include "libc/bits/bits.h" +#include "libc/dce.h" +#include "libc/log/check.h" +#include "libc/nexgen32e/rdtsc.h" +#include "libc/nexgen32e/x86feature.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/sysv/consts/clock.h" +#include "libc/sysv/consts/sig.h" +#include "libc/time/time.h" +#include "libc/x/x.h" +#include "third_party/dtoa/dtoa.h" + +/** + * @fileoverview Measure CPU clock mystery constants. + * @note CPUID EAX=15h/16h is a joke + */ + +const long double kInterval = 0.001L; + +long double start_; +char dtoabuf_[3][32]; +volatile bool isdone_; + +void OnCtrlC(int sig) { + isdone_ = true; +} + +long double now(void) { + return dtime(CLOCK_MONOTONIC); +} + +long double GetSample(void) { + uint64_t tick1, tick2; + long double time1, time2; + time1 = now(); + tick1 = rdtsc(); + nanosleep(&(struct timespec){0, 100000}, NULL); + time2 = now(); + tick2 = rdtsc(); + return ((time2 - time1) * 1e9L) / (long double)(tick2 - tick1); +} + +void MeasureNanosecondsPerAlwaysRunningTimerCycle(void) { + int i; + long double avg, samp; + start_ = now(); + for (i = 1, avg = 1.0L; !isdone_; ++i) { + samp = GetSample(); + avg += (samp - avg) / i; + dsleep(kInterval); + printf("1c = %sns (last=%sns spent=%ss)\n", g_fmt(dtoabuf_[0], (double)avg), + g_fmt(dtoabuf_[1], (double)samp), + g_fmt(dtoabuf_[2], (double)(now() - start_))); + } +} + +int main(int argc, char *argv[]) { + if (!X86_HAVE(INVTSC)) { + fprintf(stderr, "warning: html can reprogram your microcode\n"); + } + if (X86_HAVE(HYPERVISOR)) { + fprintf(stderr, "warning: virtual machine rdtsc isn't great\n"); + } + CHECK_NE(-1, xsigaction(SIGINT, OnCtrlC, 0, 0, NULL)); + MeasureNanosecondsPerAlwaysRunningTimerCycle(); + return 0; +} diff --git a/examples/kilo.c b/examples/kilo.c new file mode 100644 index 00000000..a9607fe9 --- /dev/null +++ b/examples/kilo.c @@ -0,0 +1,1372 @@ +/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ +│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ │ +│ Kilo ── A very simple editor in less than 1-kilo lines of code (as │ +│ counted by "cloc"). Does not depend on libcurses, directly │ +│ emits VT100 escapes on the terminal. │ +│ │ +╞══════════════════════════════════════════════════════════════════════════════╡ +│ Copyright 2016 Salvatore Sanfilippo │ +│ │ +│ Redistribution and use in source and binary forms, with or without │ +│ modification, are permitted provided that the following conditions are │ +│ met: │ +│ │ +│ * Redistributions of source code must retain the above copyright │ +│ notice, this list of conditions and the following disclaimer. │ +│ │ +│ * Redistributions in binary form must reproduce the above copyright │ +│ notice, this list of conditions and the following disclaimer in the │ +│ documentation and/or other materials provided with the distribution. │ +│ │ +│ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS │ +│ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT │ +│ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR │ +│ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT │ +│ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, │ +│ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT │ +│ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, │ +│ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY │ +│ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT │ +│ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE │ +│ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. │ +╚─────────────────────────────────────────────────────────────────────────────*/ + +asm(".ident \"\n\ +Kilo ─ A very simple editor (BSD-2)\n\ +Copyright 2016 Salvatore Sanfilippo\n\ +Contact: antirez@gmail.com\"\n\ +.include \"libc/disclaimer.inc\""); + +/* + * This software has been modified by Justine Tunney to: + * + * 1. Have Emacs keybindings. + * + * 2. Be capable of editing files with ANSI color codes, in such a way + * that the ANSI color codes are displayed 'as is' (since that's + * something no other editor can quite do). The kinda buggy syntax + * highlighting code needed to be commented out, to do this. + */ + +#define KILO_VERSION "0.0.1" + +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define _GNU_SOURCE + +#include "libc/alg/alg.h" +#include "libc/alg/arraylist.h" +#include "libc/calls/calls.h" +#include "libc/calls/termios.h" +#include "libc/calls/weirdtypes.h" +#include "libc/errno.h" +#include "libc/fmt/fmt.h" +#include "libc/log/log.h" +#include "libc/mem/mem.h" +#include "libc/runtime/runtime.h" +#include "libc/stdio/stdio.h" +#include "libc/str/str.h" +#include "libc/sysv/consts/fileno.h" +#include "libc/sysv/consts/o.h" +#include "libc/sysv/consts/termios.h" +#include "libc/time/time.h" + +/* Syntax highlight types */ +#define HL_NORMAL 0 +#define HL_NONPRINT 1 +#define HL_COMMENT 2 /* Single line comment. */ +#define HL_MLCOMMENT 3 /* Multi-line comment. */ +#define HL_KEYWORD1 4 +#define HL_KEYWORD2 5 +#define HL_STRING 6 +#define HL_NUMBER 7 +#define HL_MATCH 8 /* Search match. */ + +#define HL_HIGHLIGHT_STRINGS (1 << 0) +#define HL_HIGHLIGHT_NUMBERS (1 << 1) + +struct editorSyntax { + const char *const *filematch; + const char *const *keywords; + char singleline_comment_start[2]; + char multiline_comment_start[3]; + char multiline_comment_end[3]; + int flags; +}; + +/* This structure represents a single line of the file we are editing. */ +typedef struct erow { + int idx; /* Row index in the file, zero-based. */ + int size; /* Size of the row, excluding the null term. */ + int rsize; /* Size of the rendered row. */ + char *chars; /* Row content. */ + char *render; /* Row content "rendered" for screen (for TABs). */ + unsigned char *hl; /* Syntax highlight type for each character in render.*/ + int hl_oc; /* Row had open comment at end in last syntax highlight + check. */ +} erow; + +typedef struct hlcolor { + int r, g, b; +} hlcolor; + +struct editorConfig { + int cx, cy; /* Cursor x and y position in characters */ + int rowoff; /* Offset of row displayed. */ + int coloff; /* Offset of column displayed. */ + int screenrows; /* Number of rows that we can show */ + int screencols; /* Number of cols that we can show */ + int numrows; /* Number of rows */ + int rawmode; /* Is terminal raw mode enabled? */ + erow *row; /* Rows */ + int dirty; /* File modified but not saved. */ + char *filename; /* Currently open filename */ + char statusmsg[80]; + time_t statusmsg_time; + const struct editorSyntax *syntax; /* Current syntax highlight, or NULL. */ +}; + +static struct editorConfig E; + +#define CTRL(C) ((C) ^ 0b01000000) /* where ^W etc. codes come from */ + +enum KEY_ACTION { + ARROW_LEFT = 1000, + ARROW_RIGHT, + ARROW_UP, + ARROW_DOWN, + DEL_KEY, + HOME_KEY, + END_KEY, + PAGE_UP, + PAGE_DOWN +}; + +void editorSetStatusMessage(const char *fmt, ...); + +/* =========================== Syntax highlights DB ========================= + * + * In order to add a new syntax, define two arrays with a list of file name + * matches and keywords. The file name matches are used in order to match + * a given syntax with a given file name: if a match pattern starts with a + * dot, it is matched as the last past of the filename, for example ".c". + * Otherwise the pattern is just searched inside the filenme, like "Makefile"). + * + * The list of keywords to highlight is just a list of words, however if they + * a trailing '|' character is added at the end, they are highlighted in + * a different color, so that you can have two different sets of keywords. + * + * Finally add a stanza in the HLDB global variable with two two arrays + * of strings, and a set of flags in order to enable highlighting of + * comments and numbers. + * + * The characters for single and multi line comments must be exactly two + * and must be provided as well (see the C language example). + * + * There is no support to highlight patterns currently. */ + +/* C / C++ */ +const char *const C_HL_extensions[] = {".c", ".cpp", NULL}; +const char *const C_HL_keywords[] = { + /* A few C / C++ keywords */ + "switch", "if", "while", "for", "break", "continue", "return", "else", + "struct", "union", "typedef", "static", "enum", "class", + /* C types */ + "int|", "long|", "double|", "float|", "char|", "unsigned|", "signed|", + "void|", NULL}; + +/* Here we define an array of syntax highlights by extensions, keywords, + * comments delimiters and flags. */ +const struct editorSyntax HLDB[] = { + {/* C / C++ */ + C_HL_extensions, C_HL_keywords, "//", "/*", "*/", + HL_HIGHLIGHT_STRINGS | HL_HIGHLIGHT_NUMBERS}}; + +#define HLDB_ENTRIES (sizeof(HLDB) / sizeof(HLDB[0])) + +/* ======================= Low level terminal handling ====================== */ + +static struct termios orig_termios; /* In order to restore at exit.*/ + +void disableRawMode(int64_t fd) { + /* Don't even check the return value as it's too late. */ + if (E.rawmode) { + tcsetattr(fd, TCSAFLUSH, &orig_termios); + E.rawmode = 0; + } +} + +/* Called at exit to avoid remaining in raw mode. */ +void editorAtExit(void) { + disableRawMode(STDIN_FILENO); +} + +/* Raw mode: 1960 magic shit. */ +int enableRawMode(int64_t fd) { + struct termios raw; + + if (E.rawmode) return 0; /* Already enabled. */ + if (!isatty(STDIN_FILENO)) goto fatal; + atexit(editorAtExit); + if (tcgetattr(fd, &orig_termios) == -1) goto fatal; + + raw = orig_termios; /* modify the original mode */ + /* input modes: no break, no CR to NL, no parity check, no strip char, + * no start/stop output control. */ + raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); + /* output modes - disable post processing */ + raw.c_oflag &= ~(OPOST); + /* control modes - set 8 bit chars */ + raw.c_cflag |= (CS8); + /* local modes - choing off, canonical off, no extended functions, + * no signal chars (^Z,^C) */ + raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); + /* control chars - set return condition: min number of bytes and timer. */ + raw.c_cc[VMIN] = 0; /* Return each byte, or zero for timeout. */ + raw.c_cc[VTIME] = 1; /* 100 ms timeout (unit is tens of second). */ + + /* put terminal in raw mode after flushing */ + if (tcsetattr(fd, TCSAFLUSH, &raw) < 0) goto fatal; + E.rawmode = 1; + return 0; + +fatal: + errno = ENOTTY; + return -1; +} + +/* Read a key from the terminal put in raw mode, trying to handle + * escape sequences. */ +int editorReadKey(int64_t fd) { + int nread; + char c, seq[3]; + while ((nread = read(fd, &c, 1)) == 0) { + } + if (nread == -1) exit(1); + + while (1) { + switch (c) { + case CTRL('J'): /* newline */ + return CTRL('M'); + case CTRL('['): /* escape sequence */ + /* If this is just an ESC, we'll timeout here. */ + if (read(fd, seq, 1) == 0) return CTRL('['); + if (read(fd, seq + 1, 1) == 0) return CTRL('['); + + /* ESC [ sequences. */ + if (seq[0] == '[') { + if (seq[1] >= '0' && seq[1] <= '9') { + /* Extended escape, read additional byte. */ + if (read(fd, seq + 2, 1) == 0) return CTRL('['); + if (seq[2] == '~') { + switch (seq[1]) { + case '3': + return DEL_KEY; + case '5': + return PAGE_UP; + case '6': + return PAGE_DOWN; + } + } + } else { + /* Arrow Keys + * + * KEY CODE FN SHIFT OPTION + * ───── ────── ────── ────── ────── + * UP ←[A ←[5~ ←[A ←[A + * DOWN ←[B ←[6~ ←[B ←[B + * RIGHT ←[C ←[4~ ←[1;2C ←[f + * LEFT ←[D ←[1~ ←[1;2C ←[b + */ + switch (seq[1]) { + case 'A': + return ARROW_UP; + case 'B': + return ARROW_DOWN; + case 'C': + return ARROW_RIGHT; + case 'D': + return ARROW_LEFT; + case 'H': + return HOME_KEY; + case 'F': + return END_KEY; + } + } + } + + /* ESC O sequences. */ + else if (seq[0] == 'O') { + switch (seq[1]) { + case 'H': + return HOME_KEY; + case 'F': + return END_KEY; + } + } + break; + default: + return c; + } + } +} + +/* Use the ESC [6n escape sequence to query the horizontal cursor position + * and return it. On error -1 is returned, on success the position of the + * cursor is stored at *rows and *cols and 0 is returned. */ +int getCursorPosition(int64_t ifd, int64_t ofd, int *rows, int *cols) { + char buf[32]; + unsigned i = 0; + + /* Report cursor location */ + if (write(ofd, "\e[6n", 4) != 4) return -1; + + /* Read the response: ESC [ rows ; cols R */ + while (i < sizeof(buf) - 1) { + if (read(ifd, buf + i, 1) != 1) break; + if (buf[i] == 'R') break; + i++; + } + buf[i] = '\0'; + + /* Parse it. */ + if (buf[0] != CTRL('[') || buf[1] != '[') return -1; + if (sscanf(buf + 2, "%d;%d", rows, cols) != 2) retu