mirror of https://github.com/libAthena/athena.git
embedded lzo source in repo
This commit is contained in:
Jack Andersen
parent
71bd0b9d76
commit
0e2825efce
|
|
@ -1,13 +1,14 @@
|
|||
!contains(ATHENA_PRO, true): {
|
||||
INCLUDEPATH += $$PWD/include
|
||||
mac:INCLUDEPATH += /usr/local/include
|
||||
unix:LIBS += -lz -llzo2
|
||||
win32:LIBS += -lz -llzo2
|
||||
mac:LIBS += -L/usr/local/lib -lz -llzo2
|
||||
unix:LIBS += -lz
|
||||
mac:LIBS += -L/usr/local/lib -lz
|
||||
QMAKE_CXXFLAGS += -std=c++11
|
||||
mac:QMAKE_CXXFLAGS += -stdlib=libc++
|
||||
}
|
||||
|
||||
include(extern/lzo/lzo.pri)
|
||||
|
||||
ATHENA_CORE=true
|
||||
|
||||
SOURCES += \
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
Authors of the LZO data compression library:
|
||||
|
||||
Markus F.X.J. Oberhumer. Invented, designed and implemented LZO.
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
============================================================================
|
||||
LZO -- a real-time data compression library
|
||||
============================================================================
|
||||
|
||||
LZO is free of any known bugs.
|
||||
|
||||
Nevertheless LZO has been reported to break the optimizer of some
|
||||
compilers including gcc 2.7.2 (AIX, IRIX) and Watcom C 9.5.
|
||||
|
||||
So if 'lzotest' reports data decompression errors you should recompile
|
||||
everything without optimizations and see if that fixes the problem.
|
||||
I'd like to hear about optimizer problems and possible workarounds.
|
||||
|
||||
|
||||
Known compiler problems:
|
||||
------------------------
|
||||
some versions of gcc use '-O2 -fno-strength-reduce'
|
||||
some versions of gcc use '-O2 -fno-schedule-insns -fno-schedule-insns2'
|
||||
Watcom C 9.5 compile with '-oneax' instead of '-oneatx'
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,339 @@
|
|||
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 Lesser 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.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 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.
|
||||
|
||||
<signature of Ty Coon>, 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 Lesser General
|
||||
Public License instead of this License.
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
Sorry, no detailed ChangeLog available yet.
|
||||
|
||||
Please see the file NEWS for a list of user visible changes.
|
||||
|
|
@ -0,0 +1,265 @@
|
|||
Introduction
|
||||
============
|
||||
|
||||
This installation guide is for POSIX (Autoconf) systems.
|
||||
For Win32, Win64, DOS and OS/2 please read the file B/00README.TXT.
|
||||
|
||||
Quick start
|
||||
-----------
|
||||
./configure
|
||||
make
|
||||
make check
|
||||
make test (run a full test)
|
||||
make install (when logged in as root)
|
||||
|
||||
Exotic machines
|
||||
---------------
|
||||
Instead of using Autoconf you may want to adapt the simple build
|
||||
script in B/generic/build.sh.
|
||||
|
||||
Shared libraries
|
||||
----------------
|
||||
LZO uses Libtool so that shared libraries are supported on many
|
||||
systems. If want to build shared libraries type you have to type
|
||||
`./configure --enable-shared' - building shared libraries is not
|
||||
enabled by default.
|
||||
|
||||
Assembler versions
|
||||
------------------
|
||||
On Intel i386 systems, the assembler versions of the decompressors are
|
||||
built and used by default. You can use `./configure --disable-asm' if
|
||||
for some reason they cause compilation problems on your system.
|
||||
|
||||
|
||||
|
||||
[ The standard Autoconf installation instructions follow below. ]
|
||||
|
||||
|
||||
|
||||
Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
|
||||
Foundation, Inc.
|
||||
|
||||
This file is free documentation; the Free Software Foundation gives
|
||||
unlimited permission to copy, distribute and modify it.
|
||||
|
||||
Basic Installation
|
||||
==================
|
||||
|
||||
These are generic installation instructions.
|
||||
|
||||
The `configure' shell script attempts to guess correct values for
|
||||
various system-dependent variables used during compilation. It uses
|
||||
those values to create a `Makefile' in each directory of the package.
|
||||
It may also create one or more `.h' files containing system-dependent
|
||||
definitions. Finally, it creates a shell script `config.status' that
|
||||
you can run in the future to recreate the current configuration, and a
|
||||
file `config.log' containing compiler output (useful mainly for
|
||||
debugging `configure').
|
||||
|
||||
It can also use an optional file (typically called `config.cache'
|
||||
and enabled with `--cache-file=config.cache' or simply `-C') that saves
|
||||
the results of its tests to speed up reconfiguring. (Caching is
|
||||
disabled by default to prevent problems with accidental use of stale
|
||||
cache files.)
|
||||
|
||||
If you need to do unusual things to compile the package, please try
|
||||
to figure out how `configure' could check whether to do them, and mail
|
||||
diffs or instructions to the address given in the `README' so they can
|
||||
be considered for the next release. If you are using the cache, and at
|
||||
some point `config.cache' contains results you don't want to keep, you
|
||||
may remove or edit it.
|
||||
|
||||
The file `configure.ac' (or `configure.in') is used to create
|
||||
`configure' by a program called `autoconf'. You only need
|
||||
`configure.ac' if you want to change it or regenerate `configure' using
|
||||
a newer version of `autoconf'.
|
||||
|
||||
The simplest way to compile this package is:
|
||||
|
||||
1. `cd' to the directory containing the package's source code and type
|
||||
`./configure' to configure the package for your system. If you're
|
||||
using `csh' on an old version of System V, you might need to type
|
||||
`sh ./configure' instead to prevent `csh' from trying to execute
|
||||
`configure' itself.
|
||||
|
||||
Running `configure' takes awhile. While running, it prints some
|
||||
messages telling which features it is checking for.
|
||||
|
||||
2. Type `make' to compile the package.
|
||||
|
||||
3. Optionally, type `make check' to run any self-tests that come with
|
||||
the package.
|
||||
|
||||
4. Type `make install' to install the programs and any data files and
|
||||
documentation.
|
||||
|
||||
5. You can remove the program binaries and object files from the
|
||||
source code directory by typing `make clean'. To also remove the
|
||||
files that `configure' created (so you can compile the package for
|
||||
a different kind of computer), type `make distclean'. There is
|
||||
also a `make maintainer-clean' target, but that is intended mainly
|
||||
for the package's developers. If you use it, you may have to get
|
||||
all sorts of other programs in order to regenerate files that came
|
||||
with the distribution.
|
||||
|
||||
Compilers and Options
|
||||
=====================
|
||||
|
||||
Some systems require unusual options for compilation or linking that
|
||||
the `configure' script does not know about. Run `./configure --help'
|
||||
for details on some of the pertinent environment variables.
|
||||
|
||||
You can give `configure' initial values for configuration parameters
|
||||
by setting variables in the command line or in the environment. Here
|
||||
is an example:
|
||||
|
||||
./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
|
||||
|
||||
Compiling For Multiple Architectures
|
||||
====================================
|
||||
|
||||
You can compile the package for more than one kind of computer at the
|
||||
same time, by placing the object files for each architecture in their
|
||||
own directory. To do this, you must use a version of `make' that
|
||||
supports the `VPATH' variable, such as GNU `make'. `cd' to the
|
||||
directory where you want the object files and executables to go and run
|
||||
the `configure' script. `configure' automatically checks for the
|
||||
source code in the directory that `configure' is in and in `..'.
|
||||
|
||||
If you have to use a `make' that does not support the `VPATH'
|
||||
variable, you have to compile the package for one architecture at a
|
||||
time in the source code directory. After you have installed the
|
||||
package for one architecture, use `make distclean' before reconfiguring
|
||||
for another architecture.
|
||||
|
||||
Installation Names
|
||||
==================
|
||||
|
||||
By default, `make install' will install the package's files in
|
||||
`/usr/local/bin', `/usr/local/man', etc. You can specify an
|
||||
installation prefix other than `/usr/local' by giving `configure' the
|
||||
option `--prefix=PATH'.
|
||||
|
||||
You can specify separate installation prefixes for
|
||||
architecture-specific files and architecture-independent files. If you
|
||||
give `configure' the option `--exec-prefix=PATH', the package will use
|
||||
PATH as the prefix for installing programs and libraries.
|
||||
Documentation and other data files will still use the regular prefix.
|
||||
|
||||
In addition, if you use an unusual directory layout you can give
|
||||
options like `--bindir=PATH' to specify different values for particular
|
||||
kinds of files. Run `configure --help' for a list of the directories
|
||||
you can set and what kinds of files go in them.
|
||||
|
||||
If the package supports it, you can cause programs to be installed
|
||||
with an extra prefix or suffix on their names by giving `configure' the
|
||||
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
|
||||
|
||||
Optional Features
|
||||
=================
|
||||
|
||||
Some packages pay attention to `--enable-FEATURE' options to
|
||||
`configure', where FEATURE indicates an optional part of the package.
|
||||
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
|
||||
is something like `gnu-as' or `x' (for the X Window System). The
|
||||
`README' should mention any `--enable-' and `--with-' options that the
|
||||
package recognizes.
|
||||
|
||||
For packages that use the X Window System, `configure' can usually
|
||||
find the X include and library files automatically, but if it doesn't,
|
||||
you can use the `configure' options `--x-includes=DIR' and
|
||||
`--x-libraries=DIR' to specify their locations.
|
||||
|
||||
Specifying the System Type
|
||||
==========================
|
||||
|
||||
There may be some features `configure' cannot figure out
|
||||
automatically, but needs to determine by the type of machine the package
|
||||
will run on. Usually, assuming the package is built to be run on the
|
||||
_same_ architectures, `configure' can figure that out, but if it prints
|
||||
a message saying it cannot guess the machine type, give it the
|
||||
`--build=TYPE' option. TYPE can either be a short name for the system
|
||||
type, such as `sun4', or a canonical name which has the form:
|
||||
|
||||
CPU-COMPANY-SYSTEM
|
||||
|
||||
where SYSTEM can have one of these forms:
|
||||
|
||||
OS KERNEL-OS
|
||||
|
||||
See the file `config.sub' for the possible values of each field. If
|
||||
`config.sub' isn't included in this package, then this package doesn't
|
||||
need to know the machine type.
|
||||
|
||||
If you are _building_ compiler tools for cross-compiling, you should
|
||||
use the `--target=TYPE' option to select the type of system they will
|
||||
produce code for.
|
||||
|
||||
If you want to _use_ a cross compiler, that generates code for a
|
||||
platform different from the build platform, you should specify the
|
||||
"host" platform (i.e., that on which the generated programs will
|
||||
eventually be run) with `--host=TYPE'.
|
||||
|
||||
Sharing Defaults
|
||||
================
|
||||
|
||||
If you want to set default values for `configure' scripts to share,
|
||||
you can create a site shell script called `config.site' that gives
|
||||
default values for variables like `CC', `cache_file', and `prefix'.
|
||||
`configure' looks for `PREFIX/share/config.site' if it exists, then
|
||||
`PREFIX/etc/config.site' if it exists. Or, you can set the
|
||||
`CONFIG_SITE' environment variable to the location of the site script.
|
||||
A warning: not all `configure' scripts look for a site script.
|
||||
|
||||
Defining Variables
|
||||
==================
|
||||
|
||||
Variables not defined in a site shell script can be set in the
|
||||
environment passed to `configure'. However, some packages may run
|
||||
configure again during the build, and the customized values of these
|
||||
variables may be lost. In order to avoid this problem, you should set
|
||||
them in the `configure' command line, using `VAR=value'. For example:
|
||||
|
||||
./configure CC=/usr/local2/bin/gcc
|
||||
|
||||
will cause the specified gcc to be used as the C compiler (unless it is
|
||||
overridden in the site shell script).
|
||||
|
||||
`configure' Invocation
|
||||
======================
|
||||
|
||||
`configure' recognizes the following options to control how it
|
||||
operates.
|
||||
|
||||
`--help'
|
||||
`-h'
|
||||
Print a summary of the options to `configure', and exit.
|
||||
|
||||
`--version'
|
||||
`-V'
|
||||
Print the version of Autoconf used to generate the `configure'
|
||||
script, and exit.
|
||||
|
||||
`--cache-file=FILE'
|
||||
Enable the cache: use and save the results of the tests in FILE,
|
||||
traditionally `config.cache'. FILE defaults to `/dev/null' to
|
||||
disable caching.
|
||||
|
||||
`--config-cache'
|
||||
`-C'
|
||||
Alias for `--cache-file=config.cache'.
|
||||
|
||||
`--quiet'
|
||||
`--silent'
|
||||
`-q'
|
||||
Do not print messages saying which checks are being made. To
|
||||
suppress all normal output, redirect it to `/dev/null' (any error
|
||||
messages will still be shown).
|
||||
|
||||
`--srcdir=DIR'
|
||||
Look for the package's source code in directory DIR. Usually
|
||||
`configure' can determine that directory automatically.
|
||||
|
||||
`configure' also accepts some other, not widely useful, options. Run
|
||||
`configure --help' for more details.
|
||||
|
||||
|
|
@ -0,0 +1,288 @@
|
|||
============================================================================
|
||||
User visible changes for LZO -- a real-time data compression library
|
||||
============================================================================
|
||||
|
||||
Changes in 2.09 (04 Feb 2015)
|
||||
* Work around gcc bug #64516 that could affect architectures like
|
||||
armv4, armv5 and sparc.
|
||||
|
||||
Changes in 2.08 (29 Jun 2014)
|
||||
* Updated the Autoconf scripts to fix some reported build problems.
|
||||
* Added CMake build support.
|
||||
* Fixed lzo_init() on big-endian architectures like Sparc.
|
||||
|
||||
Changes in 2.07 (25 Jun 2014)
|
||||
* Fixed a potential integer overflow condition in the "safe" decompressor
|
||||
variants which could result in a possible buffer overrun when
|
||||
processing maliciously crafted compressed input data.
|
||||
|
||||
Fortunately this issue only affects 32-bit systems and also can only happen
|
||||
if you use uncommonly huge buffer sizes where you have to decompress more
|
||||
than 16 MiB (> 2^24 bytes) untrusted compressed bytes within a single
|
||||
function call, so the practical implications are limited.
|
||||
|
||||
POTENTIAL SECURITY ISSUE. CVE-2014-4607.
|
||||
|
||||
* Removed support for ancient configurations like 16-bit "huge" pointers -
|
||||
LZO now requires a flat 32-bit or 64-bit memory model.
|
||||
* Assorted cleanups.
|
||||
|
||||
Changes in 2.06 (12 Aug 2011)
|
||||
* Some minor optimizations for big-endian architectures.
|
||||
* Fixed overly strict malloc() misalignment check in examples.
|
||||
|
||||
Changes in 2.05 (23 Apr 2011)
|
||||
* Converted the configure system to non-recursive Automake.
|
||||
* Applied some overdue speed optimizations for modern x86/x64 architectures
|
||||
and current compilers like gcc 4.6 and MSVC 2010.
|
||||
|
||||
Changes in 2.04 (31 Oct 2010)
|
||||
* Fixed a gcc-4.5 aliasing issue in lzo_init().
|
||||
* Updated the configure system.
|
||||
* Assorted cleanups.
|
||||
|
||||
Changes in 2.03 (30 Apr 2008)
|
||||
* Updated the ELF assembler sources to mark the stack as non-executable.
|
||||
* Fixed a HP-UX 11 build issue with Itanium in ILP32 mode.
|
||||
* Updated the configure system.
|
||||
|
||||
Changes in 2.02 (17 Oct 2005)
|
||||
* Updated the build and Autoconf scripts to fix some reported
|
||||
compilation problems.
|
||||
|
||||
Changes in 2.01 (27 Jun 2005)
|
||||
* Changed the configure system to install the LZO library under the
|
||||
name "liblzo2" so that parallel installation with LZO v1 is possible.
|
||||
* Improved auto-configuration in miniLZO for some embedded targets like
|
||||
Blackfin and H8/300 processors.
|
||||
|
||||
Changes in 2.00 (30 May 2005)
|
||||
|
||||
[Library interface changes]
|
||||
* The 'lzo_uint' typedef has been changed to match 'size_t', which means
|
||||
it now is 64 bits on most 64-bit architectures. 32-bit machines
|
||||
are not affected by this change.
|
||||
* The formula for maximum expansion of incompressible data has changed.
|
||||
See doc/LZO.FAQ. This is needed for some upcoming speed improvements,
|
||||
and also for compatibility with our commercial LZO Professional product.
|
||||
* The progress indicator callback interface has been revamped.
|
||||
* All public header files now get installed into a "lzo" subdirectory, so
|
||||
your applications should use #include <lzo/lzoXXX.h>.
|
||||
* A number of (internal) macros have been renamed. See LZO_CFG_COMPAT
|
||||
in <lzo/lzoconf.h> if your code depends on these.
|
||||
|
||||
[Speed]
|
||||
* Small overall speedup by exploiting features like branch prediction
|
||||
hints and explicit inline control present in modern C/C++ compilers.
|
||||
* Significant speedup for 64-bit architectures like AMD64.
|
||||
|
||||
[Portability]
|
||||
* LZO now fully supports the LLP64 programming model.
|
||||
* LZO now fully supports the ILP64 and SILP64 programming models which
|
||||
are used on some supercomputing architectures.
|
||||
* Full Win64 support for AMD64 (aka x64) and IA64 (Itanium).
|
||||
* Full 16-bit support for ancient DOS 286 protected mode, OS/2 1.x
|
||||
and Windows 3.x.
|
||||
* The LZO library now compiles and works on completely freestanding or
|
||||
embedded systems as long as you have <limits.h> and <stddef.h> header
|
||||
files. See the B/generic/build_freestanding.sh build script.
|
||||
|
||||
[Misc]
|
||||
* The i386 assembler versions of the decompressors are now automatically
|
||||
built and installed. See also asm/i386/00README.TXT.
|
||||
* Added include file <lzo/lzo_asm.h> that provides prototypes for all
|
||||
assembler functions.
|
||||
* Under MacOS X, the configure script now will use the '-no-cpp-precomp'
|
||||
compiler option in order to work around bugs in some versions of
|
||||
Apple's native "smart" preprocessor.
|
||||
* Worked around a preprocessor bug that is present in all compilers which
|
||||
are based on the lcc compiler kit.
|
||||
* Added simple B/generic/build.sh build script family.
|
||||
* Added lots of new build scripts for various DOS/Windows compilers.
|
||||
|
||||
[Upgrade instructions from LZO v1 to LZO v2]
|
||||
* On 64-bit architectures, revisit all uses of lzo_uint.
|
||||
* Adapt for the maximum expansion change of incompressible data.
|
||||
* If you use the progress callback then adapt for the new interface.
|
||||
* Use #include <lzo/lzoXXX.h> or adjust your include path.
|
||||
* Check your code for use of deprecated macros. Add a
|
||||
#define LZO_CFG_COMPAT if necessary.
|
||||
* Other than that LZO v2 should be fully source-compatible with LZO v1.
|
||||
Of course, the compressed data is fully compatible as well.
|
||||
* Re-compile and re-link your application.
|
||||
* Enjoy the improvements!
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
Changes in 1.08 (12 Jul 2002)
|
||||
* Much better support for cross compiling.
|
||||
* Straighten out ANSI-conforming compiler checks.
|
||||
* Avoid harmless compiler warnings reported by -Wcast-align.
|
||||
* Fixed some sign extension problems on rather exotic machines where
|
||||
sizeof(size_t) < sizeof(ptrdiff_t) and sizeof(lzo_uint) == sizeof(size_t)
|
||||
* Updated the configure system to use the latest Autoconf, Automake
|
||||
and Libtool versions.
|
||||
|
||||
Changes in 1.07 (18 Oct 2000)
|
||||
* Default to '--disable-shared' (I'm getting tired of Libtool's
|
||||
shared library build problems, this time AIX was the culprit).
|
||||
* Avoid some harmless compiler warnings.
|
||||
|
||||
Changes in 1.06 (29 Nov 1999)
|
||||
* Updated the configure system to use Autoconf 2.13, Automake 1.4 and
|
||||
Libtool 1.3.3. This should hopefully fix the shared-library build
|
||||
problems that were reported on some machines.
|
||||
* Enhanced example programs a little bit.
|
||||
|
||||
Changes in 1.05 (14 Apr 1998)
|
||||
* Just a one-line change in the configure script to workaround
|
||||
a HPUX and IRIX build problem.
|
||||
|
||||
Changes in 1.04 (15 Mar 1998)
|
||||
* Worked around a bug in the cpp preprocessor under HPUX 10.20.
|
||||
* Adapted for Automake 1.2f and Libtool 1.1.
|
||||
|
||||
Changes in 1.03 (18 Jan 1998)
|
||||
* minor compression ratio improvement
|
||||
* extended example program to show how to do overlapping compression
|
||||
* assembler changes, added support for the nasm assembler
|
||||
* better support for cross compiling
|
||||
* some cleanups
|
||||
|
||||
Changes in 1.02 (07 Dec 1997)
|
||||
* improved LZO1X-999 and LZO1Y-999 compression ratio a little bit again
|
||||
* introduced compression levels for LZO1X-999 and LZO1Y-999
|
||||
* added support for preset dictionaries
|
||||
* implemented LZO1X-1(12): needs 16 KiB for compression
|
||||
* new algorithm LZO1Z: this is another variant of LZO1X
|
||||
* added example program: how to use preset dictionaries
|
||||
* added example program: how to do in-place decompression
|
||||
* added a little file-packer example program
|
||||
* LZO now works cleanly under checkergcc
|
||||
* strict 16-bit memory model is working (but not officially supported)
|
||||
* shared libraries are supported on many platforms
|
||||
* adapted for Automake 1.2d and Libtool 1.0h
|
||||
|
||||
Changes in 1.01 (10 Aug 1997)
|
||||
* improved LZO1X-999 and LZO1Y-999 compression ratio a little bit
|
||||
* i386+gcc: significant speedup of the C version of the LZO1, LZO1A,
|
||||
LZO1B and LZO1C decompressors
|
||||
* added example programs that show how to generate pre-compressed data
|
||||
* added Makefiles for DOS, Windows and OS/2 targets
|
||||
|
||||
Changes in 1.00 (13 Jul 1997)
|
||||
* added miniLZO - can be easily included in your project
|
||||
* improved documentation, added LZO.FAQ
|
||||
* added build scripts for many systems where Autoconf is not available:
|
||||
Windows 3.1 (LIB+DLL), Windows 95/NT (LIB+DLL), DOS (16+32 bit), OS/2
|
||||
* adapted for Automake 1.2 and Libtool 1.0
|
||||
|
||||
Changes in 0.90 (27 Jun 1997): never released
|
||||
* LZO now uses GNU Automake 1.0 - lots of configuration changes
|
||||
* added LZO1X-1(11): this version needs only 8 KiB for compression
|
||||
* implemented LZO1Y-1
|
||||
* added i386 assembler decompressors for MASM/TASM/WASM
|
||||
* the name of some assembler functions changed
|
||||
* the numeric value of some error codes changed
|
||||
* portability fixes
|
||||
|
||||
Changes in 0.29 (04 May 1997)
|
||||
* Linux ELF shared library support
|
||||
* workaround for gcc 2.7.2 optimizer bug under AIX
|
||||
* added lzo_crc32() checksum
|
||||
|
||||
Changes in 0.28 (22 Feb 1997)
|
||||
* new algorithm LZO1Y: LZO1Y-999 and LZO1Y decompressor
|
||||
* added lzo1x_optimize() and lzo1y_optimize()
|
||||
* minor speedup in assembler decompressors (i386+gcc)
|
||||
* ltest.c rewritten
|
||||
|
||||
Changes in 0.27 (19 Jan 1997)
|
||||
* fixed a bug in LZO1B-999 and LZO1C-999 that could produce
|
||||
invalid compressed data in very rare cases
|
||||
|
||||
Changes in 0.26 (18 Jan 1997): never released
|
||||
* implemented LZO1B-999
|
||||
* renamed LZO1D to LZO2A (also updated all docs)
|
||||
* some cleanups
|
||||
|
||||
Changes in 0.25 (28 Dec 1996): never released
|
||||
* some portability fixes (LZO now works on my old Atari ST :-)
|
||||
* adapted for Autoconf 2.12
|
||||
|
||||
Changes in 0.24 (30 Nov 1996): never released
|
||||
* improved performance of LZO1X assembler decompressor on a Pentium (i386+gcc)
|
||||
|
||||
Changes in 0.23 (23 Nov 1996)
|
||||
* added LZO1C, LZO1F and LZO1X decompressors in assembler (i386+gcc)
|
||||
* added corresponding LZO_PUBLIC to all LZO_EXTERN functions
|
||||
* added support for Microsoft C 7.0 (16-bit DOS)
|
||||
* introduced lzo_uint32. This could prove useful for a strict 16-bit
|
||||
version that doesn't use 'huge' pointers.
|
||||
* all algorithms use incremental hashing now
|
||||
* some cleanups and portability fixes
|
||||
|
||||
Changes in 0.22 (19 Sep 1996)
|
||||
* LZO1X: minor decompressor speedup, added some checks in safe decompressor
|
||||
* Autoconf: added detection of gcc strength-reduction bug
|
||||
* Makefile changes
|
||||
|
||||
Changes in 0.21 (08 Sep 1996)
|
||||
* LZO now uses GNU Autoconf 2.10 - lots of configuration changes
|
||||
* a few cosmetical changes
|
||||
|
||||
Changes in 0.20 (11 Aug 1996)
|
||||
* new algorithm LZO1X: LZO1X-1, LZO1X-999 and LZO1X decompressor
|
||||
* significantly speeded up LZO1B, LZO1C and LZO1F decompressors
|
||||
on CPUs which allow unaligned memory access (e.g. Intel i386)
|
||||
* greatly speeded up LZO2A-999 compressor at the cost of some memory
|
||||
* some cleanups, portability fixes and minor speedups
|
||||
|
||||
Changes in 0.16 (22 Jul 1996)
|
||||
* speeded up LZO1F decompressor a little bit
|
||||
* improved LZO1F-999 compression ratio
|
||||
|
||||
Changes in 0.15 (10 Jul 1996)
|
||||
* new algorithm LZO1F: LZO1F-1, LZO1F-999 and LZO1F decompressor
|
||||
* improved LZO2A-999 compression ratio
|
||||
* removed LZO1E as it is dominated by LZO1F
|
||||
|
||||
Changes in 0.14 (06 Jul 1996): never released
|
||||
* experimental algorithms: LZO1E and LZO1F
|
||||
* added LZO_EXTERN to all prototypes. Useful when building a DLL.
|
||||
* improved LZO1C-999 and LZO2A-999 compression ratio a little bit
|
||||
* fixed progress indicator callback (it was called only once)
|
||||
|
||||
Changes in 0.13 (20 Jun 1996)
|
||||
* some speed improvements in LZO1C-999 and LZO2A-999
|
||||
|
||||
Changes in 0.12 (18 Jun 1996): never released
|
||||
* added LZO1C-999, a slow but nearly optimal compressor
|
||||
intended for generating pre-compressed data
|
||||
* added tests for lookbehind-overrun in all safe decompressors
|
||||
* source tree completely rearranged, some filenames changed
|
||||
* extensions changed: a .ch file is a C source code that is included
|
||||
for reasons of code sharing
|
||||
* new algorithm LZO2A: LZO2A-999 and LZO2A decompressor. There is
|
||||
no fast compressor yet.
|
||||
* some cleanups
|
||||
|
||||
Changes in 0.11 (29 May 1996)
|
||||
* source tree rearranged
|
||||
* LZO now compiles fine as a C++ library (interface still has C linkage)
|
||||
* improved overall compression ratio a little bit
|
||||
* LZO1B-99/LZO1C-99 now search for longer matches
|
||||
* incremental hash is working, it's a little bit faster
|
||||
* Makefile changed
|
||||
* added lzo_uint and lzo_sizeof in some places
|
||||
* split LZO1B compressor into even more include-files
|
||||
|
||||
Changes in 0.10 (20 May 1996): first public release of the LZO library
|
||||
* includes LZO1, LZO1A, LZO1B and LZO1C algorithms
|
||||
(compression levels 1-9 and 99)
|
||||
|
||||
14 Mar 1996:
|
||||
* public release of the LZO1A algorithm
|
||||
|
||||
04 Mar 1996:
|
||||
* public release of the LZO1 algorithm
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
============================================================================
|
||||
LZO -- a real-time data compression library
|
||||
============================================================================
|
||||
|
||||
Please read the file doc/LZO.TXT for an introduction to LZO.
|
||||
See the file doc/LZO.FAQ for various tidbits of information.
|
||||
|
||||
See the file NEWS for a list of major changes in the current release.
|
||||
|
||||
See the file INSTALL for compilation and installation instructions.
|
||||
|
||||
For a quick start how to use LZO look at examples/lzopack.c.
|
||||
|
||||
|
||||
Directory overview:
|
||||
-------------------
|
||||
autoconf Autoconf configuration files (UNIX specific)
|
||||
B various support files for DOS, Windows, OS/2, ...
|
||||
doc documentation
|
||||
examples example programs
|
||||
include public header files
|
||||
minilzo a lightweight subset for easy inclusion in your project
|
||||
src library source
|
||||
tests more or less exotic test programs
|
||||
util some utility scripts
|
||||
|
||||
|
||||
Have fun,
|
||||
Markus
|
||||
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
I want to thank the following people for giving feedback, doing
|
||||
beta-testing or helping me some other way:
|
||||
|
||||
Charles W. Sandmann <sandmann@clio.rice.edu>
|
||||
Frank Donahoe <fdonahoe@wilkes1.wilkes.edu>
|
||||
Holger Berger <Holger.Berger@rus.uni-stuttgart.de>
|
||||
Jean-loup Gailly <jloup@gzip.org>
|
||||
Laszlo Molnar <ml1050@freemail.c3.hu>
|
||||
Mark Adler <madler@alumni.caltech.edu>
|
||||
Paul D. Eccles <pde@sd.inri.com>
|
||||
Rodolphe Ortalo <ortalo@laas.fr>
|
||||
William Magro <wmagro@TC.Cornell.EDU>
|
||||
Wolfgang Lugmayr <W.Lugmayr@infosys.tuwien.ac.at>
|
||||
Natascha
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
/* lzo1.h -- public interface of the LZO1 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1_H_INCLUDED
|
||||
#define __LZO1_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1_MEM_COMPRESS ((lzo_uint32_t) (8192L * lzo_sizeof_dict_t))
|
||||
#define LZO1_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1_99_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
/* lzo1a.h -- public interface of the LZO1A compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1A_H_INCLUDED
|
||||
#define __LZO1A_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1A_MEM_COMPRESS ((lzo_uint32_t) (8192L * lzo_sizeof_dict_t))
|
||||
#define LZO1A_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1a_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1a_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1A_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1a_99_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
/* lzo1b.h -- public interface of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1B_H_INCLUDED
|
||||
#define __LZO1B_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1B_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
|
||||
#define LZO1B_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
/* compression levels */
|
||||
#define LZO1B_BEST_SPEED 1
|
||||
#define LZO1B_BEST_COMPRESSION 9
|
||||
#define LZO1B_DEFAULT_COMPRESSION (-1) /* fastest by default */
|
||||
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
int compression_level );
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_2_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_3_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_4_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_5_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_6_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_7_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_8_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_9_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1B_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_99_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
#define LZO1B_999_MEM_COMPRESS ((lzo_uint32_t) (3 * 65536L * sizeof(lzo_xint)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
/* lzo1c.h -- public interface of the LZO1C compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1C_H_INCLUDED
|
||||
#define __LZO1C_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1C_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
|
||||
#define LZO1C_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
/* compression levels */
|
||||
#define LZO1C_BEST_SPEED 1
|
||||
#define LZO1C_BEST_COMPRESSION 9
|
||||
#define LZO1C_DEFAULT_COMPRESSION (-1) /* fastest by default */
|
||||
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
int compression_level );
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_2_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_3_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_4_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_5_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_6_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_7_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_8_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_9_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1C_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_99_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
#define LZO1C_999_MEM_COMPRESS ((lzo_uint32_t) (5 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
/* lzo1f.h -- public interface of the LZO1F compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1F_H_INCLUDED
|
||||
#define __LZO1F_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1F_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
|
||||
#define LZO1F_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1f_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1f_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1f_1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1F_999_MEM_COMPRESS ((lzo_uint32_t) (5 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1f_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,165 @@
|
|||
/* lzo1x.h -- public interface of the LZO1X compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1X_H_INCLUDED
|
||||
#define __LZO1X_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1X_MEM_COMPRESS LZO1X_1_MEM_COMPRESS
|
||||
#define LZO1X_MEM_DECOMPRESS (0)
|
||||
#define LZO1X_MEM_OPTIMIZE (0)
|
||||
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1X_1_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// special compressor versions
|
||||
************************************************************************/
|
||||
|
||||
/* this version needs only 8 KiB work memory */
|
||||
#define LZO1X_1_11_MEM_COMPRESS ((lzo_uint32_t) (2048L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_1_11_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/* this version needs 16 KiB work memory */
|
||||
#define LZO1X_1_12_MEM_COMPRESS ((lzo_uint32_t) (4096L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_1_12_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/* use this version if you need a little more compression speed */
|
||||
#define LZO1X_1_15_MEM_COMPRESS ((lzo_uint32_t) (32768L * lzo_sizeof_dict_t))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_1_15_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1X_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_999_compress_dict ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_999_compress_level ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int compression_level );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimize a compressed data block
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_optimize ( lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
/* lzo1y.h -- public interface of the LZO1Y compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1Y_H_INCLUDED
|
||||
#define __LZO1Y_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1Y_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t))
|
||||
#define LZO1Y_MEM_DECOMPRESS (0)
|
||||
#define LZO1Y_MEM_OPTIMIZE (0)
|
||||
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_1_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1Y_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_999_compress_dict ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_999_compress_level ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int compression_level );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimize a compressed data block
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1y_optimize ( lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,109 @@
|
|||
/* lzo1z.h -- public interface of the LZO1Z compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1Z_H_INCLUDED
|
||||
#define __LZO1Z_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* Memory required for the wrkmem parameter.
|
||||
* When the required size is 0, you can also pass a NULL pointer.
|
||||
*/
|
||||
|
||||
#define LZO1Z_MEM_DECOMPRESS (0)
|
||||
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO1Z_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_999_compress_dict ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_999_compress_level ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int compression_level );
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1z_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
/* lzo2a.h -- public interface of the LZO2A compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO2A_H_INCLUDED
|
||||
#define __LZO2A_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO2A_MEM_DECOMPRESS (0)
|
||||
|
||||
/* decompression */
|
||||
LZO_EXTERN(int)
|
||||
lzo2a_decompress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
/* safe decompression with overrun testing */
|
||||
LZO_EXTERN(int)
|
||||
lzo2a_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem /* NOT USED */ );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// better compression ratio at the cost of more memory and time
|
||||
************************************************************************/
|
||||
|
||||
#define LZO2A_999_MEM_COMPRESS ((lzo_uint32_t) (8 * 16384L * sizeof(short)))
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo2a_999_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,140 @@
|
|||
/* lzo_asm.h -- assembler prototypes for the LZO data compression library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_ASM_H_INCLUDED
|
||||
#define __LZO_ASM_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// i386 assembly decompressors
|
||||
//
|
||||
// NOTE:
|
||||
// ====
|
||||
//
|
||||
// - For reasons of speed all fast assembler decompressors (having '_fast'
|
||||
// in their name) can access (write to) up to 3 bytes past the end of
|
||||
// the decompressed ("dst") block. Data past the end of the compressed
|
||||
// ("src") block is never accessed (read from).
|
||||
// [ technical note: because data is transferred in 32-bit units ]
|
||||
//
|
||||
// - Please also see asm/i386/00README.TXT and doc/LZO.FAQ for more
|
||||
// important details about the assembler versions.
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int) lzo1c_decompress_asm
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1c_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
|
||||
LZO_EXTERN(int) lzo1f_decompress_asm_fast
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm_fast
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
|
||||
LZO_EXTERN(int) lzo1y_decompress_asm
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1y_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1y_decompress_asm_fast
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// checksum and misc functions
|
||||
************************************************************************/
|
||||
|
||||
#if 0
|
||||
|
||||
LZO_EXTERN(lzo_uint32_t)
|
||||
lzo_crc32_asm(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len,
|
||||
const lzo_uint32_tp tab);
|
||||
|
||||
LZO_EXTERN(lzo_uint32_t)
|
||||
lzo_crc32_asm_small(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo_cpuid_asm(lzo_uint32_tp /* lzo_uint32_t info[16] */ );
|
||||
|
||||
LZO_EXTERN(lzo_uint32_t)
|
||||
lzo_rdtsc_asm(lzo_uint32_tp /* lzo_uint32_t ticks[2] */ );
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,453 @@
|
|||
/* lzoconf.h -- configuration of the LZO data compression library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#define __LZOCONF_H_INCLUDED 1
|
||||
|
||||
#define LZO_VERSION 0x2090
|
||||
#define LZO_VERSION_STRING "2.09"
|
||||
#define LZO_VERSION_DATE "Feb 04 2015"
|
||||
|
||||
/* internal Autoconf configuration file - only used when building LZO */
|
||||
#if defined(LZO_HAVE_CONFIG_H)
|
||||
# include <config.h>
|
||||
#endif
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO requires a conforming <limits.h>
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(CHAR_BIT) || (CHAR_BIT != 8)
|
||||
# error "invalid CHAR_BIT"
|
||||
#endif
|
||||
#if !defined(UCHAR_MAX) || !defined(USHRT_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX)
|
||||
# error "check your compiler installation"
|
||||
#endif
|
||||
#if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1)
|
||||
# error "your limits.h macros are broken"
|
||||
#endif
|
||||
|
||||
/* get OS and architecture defines */
|
||||
#ifndef __LZODEFS_H_INCLUDED
|
||||
#include <lzo/lzodefs.h>
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// some core defines
|
||||
************************************************************************/
|
||||
|
||||
/* memory checkers */
|
||||
#if !defined(__LZO_CHECKER)
|
||||
# if defined(__BOUNDS_CHECKING_ON)
|
||||
# define __LZO_CHECKER 1
|
||||
# elif defined(__CHECKER__)
|
||||
# define __LZO_CHECKER 1
|
||||
# elif defined(__INSURE__)
|
||||
# define __LZO_CHECKER 1
|
||||
# elif defined(__PURIFY__)
|
||||
# define __LZO_CHECKER 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// integral and pointer types
|
||||
************************************************************************/
|
||||
|
||||
/* lzo_uint must match size_t */
|
||||
#if !defined(LZO_UINT_MAX)
|
||||
# if (LZO_ABI_LLP64)
|
||||
# if (LZO_OS_WIN64)
|
||||
typedef unsigned __int64 lzo_uint;
|
||||
typedef __int64 lzo_int;
|
||||
# define LZO_TYPEOF_LZO_INT LZO_TYPEOF___INT64
|
||||
# else
|
||||
typedef lzo_ullong_t lzo_uint;
|
||||
typedef lzo_llong_t lzo_int;
|
||||
# define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG_LONG
|
||||
# endif
|
||||
# define LZO_SIZEOF_LZO_INT 8
|
||||
# define LZO_UINT_MAX 0xffffffffffffffffull
|
||||
# define LZO_INT_MAX 9223372036854775807LL
|
||||
# define LZO_INT_MIN (-1LL - LZO_INT_MAX)
|
||||
# elif (LZO_ABI_IP32L64) /* MIPS R5900 */
|
||||
typedef unsigned int lzo_uint;
|
||||
typedef int lzo_int;
|
||||
# define LZO_SIZEOF_LZO_INT LZO_SIZEOF_INT
|
||||
# define LZO_TYPEOF_LZO_INT LZO_TYPEOF_INT
|
||||
# define LZO_UINT_MAX UINT_MAX
|
||||
# define LZO_INT_MAX INT_MAX
|
||||
# define LZO_INT_MIN INT_MIN
|
||||
# elif (ULONG_MAX >= LZO_0xffffffffL)
|
||||
typedef unsigned long lzo_uint;
|
||||
typedef long lzo_int;
|
||||
# define LZO_SIZEOF_LZO_INT LZO_SIZEOF_LONG
|
||||
# define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG
|
||||
# define LZO_UINT_MAX ULONG_MAX
|
||||
# define LZO_INT_MAX LONG_MAX
|
||||
# define LZO_INT_MIN LONG_MIN
|
||||
# else
|
||||
# error "lzo_uint"
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* The larger type of lzo_uint and lzo_uint32_t. */
|
||||
#if (LZO_SIZEOF_LZO_INT >= 4)
|
||||
# define lzo_xint lzo_uint
|
||||
#else
|
||||
# define lzo_xint lzo_uint32_t
|
||||
#endif
|
||||
|
||||
typedef int lzo_bool;
|
||||
|
||||
/* sanity checks */
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int) == LZO_SIZEOF_LZO_INT)
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == LZO_SIZEOF_LZO_INT)
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_xint) >= sizeof(lzo_uint))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_xint) >= sizeof(lzo_uint32_t))
|
||||
|
||||
#ifndef __LZO_MMODEL
|
||||
#define __LZO_MMODEL /*empty*/
|
||||
#endif
|
||||
|
||||
/* no typedef here because of const-pointer issues */
|
||||
#define lzo_bytep unsigned char __LZO_MMODEL *
|
||||
#define lzo_charp char __LZO_MMODEL *
|
||||
#define lzo_voidp void __LZO_MMODEL *
|
||||
#define lzo_shortp short __LZO_MMODEL *
|
||||
#define lzo_ushortp unsigned short __LZO_MMODEL *
|
||||
#define lzo_intp lzo_int __LZO_MMODEL *
|
||||
#define lzo_uintp lzo_uint __LZO_MMODEL *
|
||||
#define lzo_xintp lzo_xint __LZO_MMODEL *
|
||||
#define lzo_voidpp lzo_voidp __LZO_MMODEL *
|
||||
#define lzo_bytepp lzo_bytep __LZO_MMODEL *
|
||||
|
||||
#define lzo_int8_tp lzo_int8_t __LZO_MMODEL *
|
||||
#define lzo_uint8_tp lzo_uint8_t __LZO_MMODEL *
|
||||
#define lzo_int16_tp lzo_int16_t __LZO_MMODEL *
|
||||
#define lzo_uint16_tp lzo_uint16_t __LZO_MMODEL *
|
||||
#define lzo_int32_tp lzo_int32_t __LZO_MMODEL *
|
||||
#define lzo_uint32_tp lzo_uint32_t __LZO_MMODEL *
|
||||
#if defined(lzo_int64_t)
|
||||
#define lzo_int64_tp lzo_int64_t __LZO_MMODEL *
|
||||
#define lzo_uint64_tp lzo_uint64_t __LZO_MMODEL *
|
||||
#endif
|
||||
|
||||
/* Older LZO versions used to support ancient systems and memory models
|
||||
* such as 16-bit MSDOS with __huge pointers or Cray PVP, but these
|
||||
* obsolete configurations are not supported any longer.
|
||||
*/
|
||||
#if defined(__LZO_MMODEL_HUGE)
|
||||
#error "__LZO_MMODEL_HUGE memory model is unsupported"
|
||||
#endif
|
||||
#if (LZO_MM_PVP)
|
||||
#error "LZO_MM_PVP memory model is unsupported"
|
||||
#endif
|
||||
#if (LZO_SIZEOF_INT < 4)
|
||||
#error "LZO_SIZEOF_INT < 4 is unsupported"
|
||||
#endif
|
||||
#if (__LZO_UINTPTR_T_IS_POINTER)
|
||||
#error "__LZO_UINTPTR_T_IS_POINTER is unsupported"
|
||||
#endif
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(int) >= 4)
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) >= 4)
|
||||
/* Strange configurations where sizeof(lzo_uint) != sizeof(size_t) should
|
||||
* work but have not received much testing lately, so be strict here.
|
||||
*/
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(size_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(ptrdiff_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(lzo_uintptr_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_uintptr_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_uintptr_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long *) == sizeof(lzo_uintptr_t))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_voidp))
|
||||
LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_bytep))
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// function types
|
||||
************************************************************************/
|
||||
|
||||
/* name mangling */
|
||||
#if !defined(__LZO_EXTERN_C)
|
||||
# ifdef __cplusplus
|
||||
# define __LZO_EXTERN_C extern "C"
|
||||
# else
|
||||
# define __LZO_EXTERN_C extern
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* calling convention */
|
||||
#if !defined(__LZO_CDECL)
|
||||
# define __LZO_CDECL __lzo_cdecl
|
||||
#endif
|
||||
|
||||
/* DLL export information */
|
||||
#if !defined(__LZO_EXPORT1)
|
||||
# define __LZO_EXPORT1 /*empty*/
|
||||
#endif
|
||||
#if !defined(__LZO_EXPORT2)
|
||||
# define __LZO_EXPORT2 /*empty*/
|
||||
#endif
|
||||
|
||||
/* __cdecl calling convention for public C and assembly functions */
|
||||
#if !defined(LZO_PUBLIC)
|
||||
# define LZO_PUBLIC(r) __LZO_EXPORT1 r __LZO_EXPORT2 __LZO_CDECL
|
||||
#endif
|
||||
#if !defined(LZO_EXTERN)
|
||||
# define LZO_EXTERN(r) __LZO_EXTERN_C LZO_PUBLIC(r)
|
||||
#endif
|
||||
#if !defined(LZO_PRIVATE)
|
||||
# define LZO_PRIVATE(r) static r __LZO_CDECL
|
||||
#endif
|
||||
|
||||
/* function types */
|
||||
typedef int
|
||||
(__LZO_CDECL *lzo_compress_t) ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
typedef int
|
||||
(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
typedef int
|
||||
(__LZO_CDECL *lzo_optimize_t) ( lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem );
|
||||
|
||||
typedef int
|
||||
(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
typedef int
|
||||
(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len );
|
||||
|
||||
|
||||
/* Callback interface. Currently only the progress indicator ("nprogress")
|
||||
* is used, but this may change in a future release. */
|
||||
|
||||
struct lzo_callback_t;
|
||||
typedef struct lzo_callback_t lzo_callback_t;
|
||||
#define lzo_callback_p lzo_callback_t __LZO_MMODEL *
|
||||
|
||||
/* malloc & free function types */
|
||||
typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t)
|
||||
(lzo_callback_p self, lzo_uint items, lzo_uint size);
|
||||
typedef void (__LZO_CDECL *lzo_free_func_t)
|
||||
(lzo_callback_p self, lzo_voidp ptr);
|
||||
|
||||
/* a progress indicator callback function */
|
||||
typedef void (__LZO_CDECL *lzo_progress_func_t)
|
||||
(lzo_callback_p, lzo_uint, lzo_uint, int);
|
||||
|
||||
struct lzo_callback_t
|
||||
{
|
||||
/* custom allocators (set to 0 to disable) */
|
||||
lzo_alloc_func_t nalloc; /* [not used right now] */
|
||||
lzo_free_func_t nfree; /* [not used right now] */
|
||||
|
||||
/* a progress indicator callback function (set to 0 to disable) */
|
||||
lzo_progress_func_t nprogress;
|
||||
|
||||
/* INFO: the first parameter "self" of the nalloc/nfree/nprogress
|
||||
* callbacks points back to this struct, so you are free to store
|
||||
* some extra info in the following variables. */
|
||||
lzo_voidp user1;
|
||||
lzo_xint user2;
|
||||
lzo_xint user3;
|
||||
};
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// error codes and prototypes
|
||||
************************************************************************/
|
||||
|
||||
/* Error codes for the compression/decompression functions. Negative
|
||||
* values are errors, positive values will be used for special but
|
||||
* normal events.
|
||||
*/
|
||||
#define LZO_E_OK 0
|
||||
#define LZO_E_ERROR (-1)
|
||||
#define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */
|
||||
#define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */
|
||||
#define LZO_E_INPUT_OVERRUN (-4)
|
||||
#define LZO_E_OUTPUT_OVERRUN (-5)
|
||||
#define LZO_E_LOOKBEHIND_OVERRUN (-6)
|
||||
#define LZO_E_EOF_NOT_FOUND (-7)
|
||||
#define LZO_E_INPUT_NOT_CONSUMED (-8)
|
||||
#define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */
|
||||
#define LZO_E_INVALID_ARGUMENT (-10)
|
||||
#define LZO_E_INVALID_ALIGNMENT (-11) /* pointer argument is not properly aligned */
|
||||
#define LZO_E_OUTPUT_NOT_CONSUMED (-12)
|
||||
#define LZO_E_INTERNAL_ERROR (-99)
|
||||
|
||||
|
||||
#ifndef lzo_sizeof_dict_t
|
||||
# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep))
|
||||
#endif
|
||||
|
||||
/* lzo_init() should be the first function you call.
|
||||
* Check the return code !
|
||||
*
|
||||
* lzo_init() is a macro to allow checking that the library and the
|
||||
* compiler's view of various types are consistent.
|
||||
*/
|
||||
#define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\
|
||||
(int)sizeof(long),(int)sizeof(lzo_uint32_t),(int)sizeof(lzo_uint),\
|
||||
(int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\
|
||||
(int)sizeof(lzo_callback_t))
|
||||
LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int);
|
||||
|
||||
/* version functions (useful for shared libraries) */
|
||||
LZO_EXTERN(unsigned) lzo_version(void);
|
||||
LZO_EXTERN(const char *) lzo_version_string(void);
|
||||
LZO_EXTERN(const char *) lzo_version_date(void);
|
||||
LZO_EXTERN(const lzo_charp) _lzo_version_string(void);
|
||||
LZO_EXTERN(const lzo_charp) _lzo_version_date(void);
|
||||
|
||||
/* string functions */
|
||||
LZO_EXTERN(int)
|
||||
lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len);
|
||||
LZO_EXTERN(lzo_voidp)
|
||||
lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
|
||||
LZO_EXTERN(lzo_voidp)
|
||||
lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
|
||||
LZO_EXTERN(lzo_voidp)
|
||||
lzo_memset(lzo_voidp buf, int c, lzo_uint len);
|
||||
|
||||
/* checksum functions */
|
||||
LZO_EXTERN(lzo_uint32_t)
|
||||
lzo_adler32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
|
||||
LZO_EXTERN(lzo_uint32_t)
|
||||
lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len);
|
||||
LZO_EXTERN(const lzo_uint32_tp)
|
||||
lzo_get_crc32_table(void);
|
||||
|
||||
/* misc. */
|
||||
LZO_EXTERN(int) _lzo_config_check(void);
|
||||
typedef union {
|
||||
lzo_voidp a00; lzo_bytep a01; lzo_uint a02; lzo_xint a03; lzo_uintptr_t a04;
|
||||
void *a05; unsigned char *a06; unsigned long a07; size_t a08; ptrdiff_t a09;
|
||||
#if defined(lzo_int64_t)
|
||||
lzo_uint64_t a10;
|
||||
#endif
|
||||
} lzo_align_t;
|
||||
|
||||
/* align a char pointer on a boundary that is a multiple of 'size' */
|
||||
LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp p, lzo_uint size);
|
||||
#define LZO_PTR_ALIGN_UP(p,size) \
|
||||
((p) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(p),(lzo_uint)(size)))
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// deprecated macros - only for backward compatibility
|
||||
************************************************************************/
|
||||
|
||||
/* deprecated - use 'lzo_bytep' instead of 'lzo_byte *' */
|
||||
#define lzo_byte unsigned char
|
||||
/* deprecated type names */
|
||||
#define lzo_int32 lzo_int32_t
|
||||
#define lzo_uint32 lzo_uint32_t
|
||||
#define lzo_int32p lzo_int32_t __LZO_MMODEL *
|
||||
#define lzo_uint32p lzo_uint32_t __LZO_MMODEL *
|
||||
#define LZO_INT32_MAX LZO_INT32_C(2147483647)
|
||||
#define LZO_UINT32_MAX LZO_UINT32_C(4294967295)
|
||||
#if defined(lzo_int64_t)
|
||||
#define lzo_int64 lzo_int64_t
|
||||
#define lzo_uint64 lzo_uint64_t
|
||||
#define lzo_int64p lzo_int64_t __LZO_MMODEL *
|
||||
#define lzo_uint64p lzo_uint64_t __LZO_MMODEL *
|
||||
#define LZO_INT64_MAX LZO_INT64_C(9223372036854775807)
|
||||
#define LZO_UINT64_MAX LZO_UINT64_C(18446744073709551615)
|
||||
#endif
|
||||
/* deprecated types */
|
||||
typedef union { lzo_bytep a; lzo_uint b; } __lzo_pu_u;
|
||||
typedef union { lzo_bytep a; lzo_uint32_t b; } __lzo_pu32_u;
|
||||
/* deprecated defines */
|
||||
#if !defined(LZO_SIZEOF_LZO_UINT)
|
||||
# define LZO_SIZEOF_LZO_UINT LZO_SIZEOF_LZO_INT
|
||||
#endif
|
||||
|
||||
#if defined(LZO_CFG_COMPAT)
|
||||
|
||||
#define __LZOCONF_H 1
|
||||
|
||||
#if defined(LZO_ARCH_I086)
|
||||
# define __LZO_i386 1
|
||||
#elif defined(LZO_ARCH_I386)
|
||||
# define __LZO_i386 1
|
||||
#endif
|
||||
|
||||
#if defined(LZO_OS_DOS16)
|
||||
# define __LZO_DOS 1
|
||||
# define __LZO_DOS16 1
|
||||
#elif defined(LZO_OS_DOS32)
|
||||
# define __LZO_DOS 1
|
||||
#elif defined(LZO_OS_WIN16)
|
||||
# define __LZO_WIN 1
|
||||
# define __LZO_WIN16 1
|
||||
#elif defined(LZO_OS_WIN32)
|
||||
# define __LZO_WIN 1
|
||||
#endif
|
||||
|
||||
#define __LZO_CMODEL /*empty*/
|
||||
#define __LZO_DMODEL /*empty*/
|
||||
#define __LZO_ENTRY __LZO_CDECL
|
||||
#define LZO_EXTERN_CDECL LZO_EXTERN
|
||||
#define LZO_ALIGN LZO_PTR_ALIGN_UP
|
||||
|
||||
#define lzo_compress_asm_t lzo_compress_t
|
||||
#define lzo_decompress_asm_t lzo_decompress_t
|
||||
|
||||
#endif /* LZO_CFG_COMPAT */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,62 @@
|
|||
/* lzoutil.h -- utility functions for use by applications
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZOUTIL_H_INCLUDED
|
||||
#define __LZOUTIL_H_INCLUDED 1
|
||||
|
||||
#ifndef __LZOCONF_H_INCLUDED
|
||||
#include <lzo/lzoconf.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO-v1 deprecated macros (which were used in the old example programs)
|
||||
//
|
||||
// THIS FILE IS DEPRECATED. DO NOT USE.
|
||||
************************************************************************/
|
||||
|
||||
#define lzo_alloc(a,b) (malloc((a)*(b)))
|
||||
#define lzo_malloc(a) (malloc(a))
|
||||
#define lzo_free(a) (free(a))
|
||||
|
||||
#define lzo_fread(f,b,s) (fread(b,1,s,f))
|
||||
#define lzo_fwrite(f,b,s) (fwrite(b,1,s,f))
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
SOURCES += \
|
||||
$$PWD/src/lzo1.c \
|
||||
$$PWD/src/lzo1_99.c \
|
||||
$$PWD/src/lzo1a.c \
|
||||
$$PWD/src/lzo1a_99.c \
|
||||
$$PWD/src/lzo1b_1.c \
|
||||
$$PWD/src/lzo1b_2.c \
|
||||
$$PWD/src/lzo1b_3.c \
|
||||
$$PWD/src/lzo1b_4.c \
|
||||
$$PWD/src/lzo1b_5.c \
|
||||
$$PWD/src/lzo1b_6.c \
|
||||
$$PWD/src/lzo1b_7.c \
|
||||
$$PWD/src/lzo1b_8.c \
|
||||
$$PWD/src/lzo1b_9.c \
|
||||
$$PWD/src/lzo1b_99.c \
|
||||
$$PWD/src/lzo1b_9x.c \
|
||||
$$PWD/src/lzo1b_cc.c \
|
||||
$$PWD/src/lzo1b_d1.c \
|
||||
$$PWD/src/lzo1b_d2.c \
|
||||
$$PWD/src/lzo1b_rr.c \
|
||||
$$PWD/src/lzo1b_xx.c \
|
||||
$$PWD/src/lzo1c_1.c \
|
||||
$$PWD/src/lzo1c_2.c \
|
||||
$$PWD/src/lzo1c_3.c \
|
||||
$$PWD/src/lzo1c_4.c \
|
||||
$$PWD/src/lzo1c_5.c \
|
||||
$$PWD/src/lzo1c_6.c \
|
||||
$$PWD/src/lzo1c_7.c \
|
||||
$$PWD/src/lzo1c_8.c \
|
||||
$$PWD/src/lzo1c_9.c \
|
||||
$$PWD/src/lzo1c_99.c \
|
||||
$$PWD/src/lzo1c_9x.c \
|
||||
$$PWD/src/lzo1c_cc.c \
|
||||
$$PWD/src/lzo1c_d1.c \
|
||||
$$PWD/src/lzo1c_d2.c \
|
||||
$$PWD/src/lzo1c_rr.c \
|
||||
$$PWD/src/lzo1c_xx.c \
|
||||
$$PWD/src/lzo1f_1.c \
|
||||
$$PWD/src/lzo1f_9x.c \
|
||||
$$PWD/src/lzo1f_d1.c \
|
||||
$$PWD/src/lzo1f_d2.c \
|
||||
$$PWD/src/lzo1x_1.c \
|
||||
$$PWD/src/lzo1x_1k.c \
|
||||
$$PWD/src/lzo1x_1l.c \
|
||||
$$PWD/src/lzo1x_1o.c \
|
||||
$$PWD/src/lzo1x_9x.c \
|
||||
$$PWD/src/lzo1x_d1.c \
|
||||
$$PWD/src/lzo1x_d2.c \
|
||||
$$PWD/src/lzo1x_d3.c \
|
||||
$$PWD/src/lzo1x_o.c \
|
||||
$$PWD/src/lzo1y_1.c \
|
||||
$$PWD/src/lzo1y_9x.c \
|
||||
$$PWD/src/lzo1y_d1.c \
|
||||
$$PWD/src/lzo1y_d2.c \
|
||||
$$PWD/src/lzo1y_d3.c \
|
||||
$$PWD/src/lzo1y_o.c \
|
||||
$$PWD/src/lzo1z_9x.c \
|
||||
$$PWD/src/lzo1z_d1.c \
|
||||
$$PWD/src/lzo1z_d2.c \
|
||||
$$PWD/src/lzo1z_d3.c \
|
||||
$$PWD/src/lzo2a_9x.c \
|
||||
$$PWD/src/lzo2a_d1.c \
|
||||
$$PWD/src/lzo2a_d2.c \
|
||||
$$PWD/src/lzo_crc.c \
|
||||
$$PWD/src/lzo_init.c \
|
||||
$$PWD/src/lzo_ptr.c \
|
||||
$$PWD/src/lzo_str.c \
|
||||
$$PWD/src/lzo_util.c
|
||||
|
||||
HEADERS += \
|
||||
$$PWD/include/lzo/lzo1.h \
|
||||
$$PWD/include/lzo/lzo1x.h \
|
||||
$$PWD/include/lzo/lzoconf.h \
|
||||
$$PWD/include/lzo/lzodefs.h \
|
||||
$$PWD/include/lzo/lzoutil.h
|
||||
|
||||
INCLUDEPATH += $$PWD/include
|
||||
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
/* compr1b.h --
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1b.h"
|
||||
|
||||
|
||||
#if !defined(COMPRESS_ID)
|
||||
#define COMPRESS_ID LZO_PP_ECONCAT2(DD_BITS,CLEVEL)
|
||||
#endif
|
||||
|
||||
|
||||
#include "lzo1b_c.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_COMPRESS \
|
||||
LZO_PP_ECONCAT3(lzo1b_,COMPRESS_ID,_compress)
|
||||
|
||||
#define LZO_COMPRESS_FUNC \
|
||||
LZO_PP_ECONCAT3(_lzo1b_,COMPRESS_ID,_compress_func)
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return _lzo1b_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
/* compr1c.h --
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1c.h"
|
||||
|
||||
|
||||
#if !defined(COMPRESS_ID)
|
||||
#define COMPRESS_ID LZO_PP_ECONCAT2(DD_BITS,CLEVEL)
|
||||
#endif
|
||||
|
||||
|
||||
#include "lzo1b_c.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_COMPRESS \
|
||||
LZO_PP_ECONCAT3(lzo1c_,COMPRESS_ID,_compress)
|
||||
|
||||
#define LZO_COMPRESS_FUNC \
|
||||
LZO_PP_ECONCAT3(_lzo1c_,COMPRESS_ID,_compress_func)
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
const lzo_compress_t LZO_COMPRESS_FUNC = do_compress;
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return _lzo1c_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
/* config1.h -- configuration for the LZO1 algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
#ifndef __LZO_CONFIG1_H
|
||||
#define __LZO_CONFIG1_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1.h>
|
||||
|
||||
#define LZO_NO_R1 1
|
||||
#include "config1a.h"
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,182 @@
|
|||
/* config1a.h -- configuration for the LZO1A algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1A_H
|
||||
#define __LZO_CONFIG1A_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1a.h>
|
||||
|
||||
#undef LZO_COLLECT_STATS /* no support for stats here */
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm configuration
|
||||
************************************************************************/
|
||||
|
||||
/* run bits (4 - 5) - the compressor and the decompressor
|
||||
* must use the same value. */
|
||||
#if !defined(RBITS)
|
||||
# define RBITS 5
|
||||
#endif
|
||||
|
||||
/* dictionary depth (0 - 6) - this only affects the compressor.
|
||||
* 0 is fastest, 6 is best compression ratio */
|
||||
#if !defined(DDBITS)
|
||||
# define DDBITS 0
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio */
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* check configuration */
|
||||
#if (RBITS < 4 || RBITS > 5)
|
||||
# error "invalid RBITS"
|
||||
#endif
|
||||
#if (DDBITS < 0 || DDBITS > 6)
|
||||
# error "invalid DDBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* add a special code so that the decompressor can detect the
|
||||
* end of the compressed data block (overhead is 3 bytes per block) */
|
||||
#undef LZO_EOF_CODE
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
|
||||
/* config */
|
||||
#define R_BITS RBITS
|
||||
#define DD_BITS DDBITS
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 16
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimization and debugging
|
||||
************************************************************************/
|
||||
|
||||
/* Collect statistics */
|
||||
#if 0 && !defined(LZO_COLLECT_STATS)
|
||||
# define LZO_COLLECT_STATS 1
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define M3O_BITS M2O_BITS
|
||||
#define M3L_BITS CHAR_BIT
|
||||
#define M3_MAX_LEN (M3_MIN_LEN + LZO_SIZE(M3L_BITS) - 1)
|
||||
#define _MAX_OFFSET _M2_MAX_OFFSET
|
||||
#define LZO_NO_M3 1
|
||||
|
||||
#include "lzo1b_de.h"
|
||||
#include "stats1b.h"
|
||||
|
||||
#include "lzo1b_cc.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// check for total LZO1/LZO1A compatibility
|
||||
************************************************************************/
|
||||
|
||||
#undef M2_MARKER
|
||||
#define M2_MARKER (1 << M2O_BITS)
|
||||
|
||||
#if (R_BITS != 5)
|
||||
# error
|
||||
#endif
|
||||
#if (M2O_BITS != 5)
|
||||
# error
|
||||
#endif
|
||||
#if (M3O_BITS != 5)
|
||||
# error
|
||||
#endif
|
||||
#if (M2_MIN_LEN != 3)
|
||||
# error
|
||||
#endif
|
||||
#if (M2_MAX_LEN != 8)
|
||||
# error
|
||||
#endif
|
||||
#if (M3_MIN_LEN != 9)
|
||||
# error
|
||||
#endif
|
||||
#if (M3_MAX_LEN != 264)
|
||||
# error
|
||||
#endif
|
||||
#if (_M2_MAX_OFFSET != (1u << 13))
|
||||
# error
|
||||
#endif
|
||||
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
|
||||
# error
|
||||
#endif
|
||||
#if (_M2_MAX_OFFSET != _MAX_OFFSET)
|
||||
# error
|
||||
#endif
|
||||
#if (R0MIN != 32)
|
||||
# error
|
||||
#endif
|
||||
#if (R0MAX != 287)
|
||||
# error
|
||||
#endif
|
||||
#if (R0FAST != 280)
|
||||
# error
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
/* config1b.h -- configuration for the LZO1B algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1B_H
|
||||
#define __LZO_CONFIG1B_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1b.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm configuration
|
||||
************************************************************************/
|
||||
|
||||
/* run bits (4 - 5) - the compressor and the decompressor
|
||||
* must use the same value. */
|
||||
#if !defined(RBITS)
|
||||
# define RBITS 5
|
||||
#endif
|
||||
|
||||
/* dictionary depth (0 - 6) - this only affects the compressor.
|
||||
* 0 is fastest, 6 is best compression ratio */
|
||||
#if !defined(DDBITS)
|
||||
# define DDBITS 0
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio */
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* check configuration */
|
||||
#if (RBITS < 4 || RBITS > 5)
|
||||
# error "invalid RBITS"
|
||||
#endif
|
||||
#if (DDBITS < 0 || DDBITS > 6)
|
||||
# error "invalid DDBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* add a special code so that the decompressor can detect the
|
||||
* end of the compressed data block (overhead is 3 bytes per block) */
|
||||
#define LZO_EOF_CODE 1
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
|
||||
/* config */
|
||||
#define R_BITS RBITS
|
||||
#define DD_BITS DDBITS
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 14
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimization and debugging
|
||||
************************************************************************/
|
||||
|
||||
/* Collect statistics */
|
||||
#if 0 && !defined(LZO_COLLECT_STATS)
|
||||
# define LZO_COLLECT_STATS 1
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#include "lzo1b_de.h"
|
||||
#include "stats1b.h"
|
||||
|
||||
#include "lzo1b_cc.h"
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
/* config1c.h -- configuration for the LZO1C algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1C_H
|
||||
#define __LZO_CONFIG1C_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1c.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm configuration
|
||||
************************************************************************/
|
||||
|
||||
/* run bits (4 - 5) - the compressor and the decompressor
|
||||
* must use the same value. */
|
||||
#if !defined(RBITS)
|
||||
# define RBITS 5
|
||||
#endif
|
||||
|
||||
/* dictionary depth (0 - 6) - this only affects the compressor.
|
||||
* 0 is fastest, 6 is best compression ratio */
|
||||
#if !defined(DDBITS)
|
||||
# define DDBITS 0
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio */
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* check configuration */
|
||||
#if (RBITS < 4 || RBITS > 5)
|
||||
# error "invalid RBITS"
|
||||
#endif
|
||||
#if (DDBITS < 0 || DDBITS > 6)
|
||||
# error "invalid DDBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* add a special code so that the decompressor can detect the
|
||||
* end of the compressed data block (overhead is 3 bytes per block) */
|
||||
#define LZO_EOF_CODE 1
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
|
||||
/* config */
|
||||
#define R_BITS RBITS
|
||||
#define DD_BITS DDBITS
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 14
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimization and debugging
|
||||
************************************************************************/
|
||||
|
||||
/* Collect statistics */
|
||||
#if 0 && !defined(LZO_COLLECT_STATS)
|
||||
# define LZO_COLLECT_STATS 1
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* good parameters when using a blocksize of 8kB */
|
||||
#define M3O_BITS 6
|
||||
#undef LZO_DETERMINISTIC
|
||||
|
||||
|
||||
#include "lzo1b_de.h"
|
||||
#include "stats1c.h"
|
||||
|
||||
#include "lzo1c_cc.h"
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
/* config1f.h -- configuration for the LZO1F algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1F_H
|
||||
#define __LZO_CONFIG1F_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1f.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_EOF_CODE 1
|
||||
#undef LZO_DETERMINISTIC
|
||||
|
||||
#define M2_MAX_OFFSET 0x0800
|
||||
#define M3_MAX_OFFSET 0x3fff
|
||||
|
||||
#define M2_MIN_LEN 3
|
||||
#define M2_MAX_LEN 8
|
||||
#define M3_MIN_LEN 3
|
||||
#define M3_MAX_LEN 33
|
||||
|
||||
#define M3_MARKER 224
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#ifndef MIN_LOOKAHEAD
|
||||
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
|
||||
#endif
|
||||
|
||||
#if defined(LZO_NEED_DICT_H)
|
||||
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
#define DL_MIN_LEN M2_MIN_LEN
|
||||
#include "lzo_dict.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
/* config1x.h -- configuration for the LZO1X algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1X_H
|
||||
#define __LZO_CONFIG1X_H 1
|
||||
|
||||
#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
|
||||
# define LZO1X 1
|
||||
#endif
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#if !defined(__LZO_IN_MINILZO)
|
||||
#include <lzo/lzo1x.h>
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#ifndef LZO_EOF_CODE
|
||||
#define LZO_EOF_CODE 1
|
||||
#endif
|
||||
#undef LZO_DETERMINISTIC
|
||||
|
||||
#define M1_MAX_OFFSET 0x0400
|
||||
#ifndef M2_MAX_OFFSET
|
||||
#define M2_MAX_OFFSET 0x0800
|
||||
#endif
|
||||
#define M3_MAX_OFFSET 0x4000
|
||||
#define M4_MAX_OFFSET 0xbfff
|
||||
|
||||
#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)
|
||||
|
||||
#define M1_MIN_LEN 2
|
||||
#define M1_MAX_LEN 2
|
||||
#define M2_MIN_LEN 3
|
||||
#ifndef M2_MAX_LEN
|
||||
#define M2_MAX_LEN 8
|
||||
#endif
|
||||
#define M3_MIN_LEN 3
|
||||
#define M3_MAX_LEN 33
|
||||
#define M4_MIN_LEN 3
|
||||
#define M4_MAX_LEN 9
|
||||
|
||||
#define M1_MARKER 0
|
||||
#define M2_MARKER 64
|
||||
#define M3_MARKER 32
|
||||
#define M4_MARKER 16
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#ifndef MIN_LOOKAHEAD
|
||||
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
|
||||
#endif
|
||||
|
||||
#if defined(LZO_NEED_DICT_H)
|
||||
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
|
||||
#endif
|
||||
#define DL_MIN_LEN M2_MIN_LEN
|
||||
#include "lzo_dict.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/* config1y.h -- configuration for the LZO1Y algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1Y_H
|
||||
#define __LZO_CONFIG1Y_H 1
|
||||
|
||||
#if !defined(LZO1Y)
|
||||
# define LZO1Y 1
|
||||
#endif
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1y.h>
|
||||
|
||||
#define M2_MAX_LEN 14
|
||||
#define M2_MAX_OFFSET 0x0400
|
||||
#include "config1x.h"
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
/* config1z.h -- configuration for the LZO1Z algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG1Z_H
|
||||
#define __LZO_CONFIG1Z_H 1
|
||||
|
||||
#if !defined(LZO1Z)
|
||||
# define LZO1Z 1
|
||||
#endif
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1z.h>
|
||||
|
||||
#define M2_MAX_OFFSET 0x0700
|
||||
#include "config1x.h"
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
/* config2a.h -- configuration for the LZO2A algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_CONFIG2A_H
|
||||
#define __LZO_CONFIG2A_H 1
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo2a.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm configuration
|
||||
************************************************************************/
|
||||
|
||||
/* dictionary depth (0 - 6) - this only affects the compressor.
|
||||
* 0 is fastest, 6 is best compression ratio */
|
||||
#if !defined(DDBITS)
|
||||
# define DDBITS 0
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio */
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* check configuration */
|
||||
#if (DDBITS < 0 || DDBITS > 6)
|
||||
# error "invalid DDBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
************************************************************************/
|
||||
|
||||
#if 1
|
||||
#define SWD_N 8191 /* size of ring buffer */
|
||||
#else
|
||||
#define SWD_N 16383 /* size of ring buffer */
|
||||
#endif
|
||||
|
||||
#define M1_MIN_LEN 2
|
||||
#define M1_MAX_LEN 5
|
||||
#define M2_MIN_LEN 3
|
||||
#define M3_MIN_LEN 3
|
||||
|
||||
|
||||
/* add a special code so that the decompressor can detect the
|
||||
* end of the compressed data block (overhead is 3 bytes per block) */
|
||||
#define LZO_EOF_CODE 1
|
||||
|
||||
#undef LZO_DETERMINISTIC
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// algorithm internal configuration
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
|
||||
/* config */
|
||||
#define DD_BITS DDBITS
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 14
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// optimization and debugging
|
||||
************************************************************************/
|
||||
|
||||
/* Collect statistics */
|
||||
#if 0 && !defined(LZO_COLLECT_STATS)
|
||||
# define LZO_COLLECT_STATS 1
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/* get bits */
|
||||
#define _NEEDBITS \
|
||||
{ _NEEDBYTE; b |= ((lzo_uint32_t) _NEXTBYTE) << k; k += 8; assert(k <= 32); }
|
||||
#define NEEDBITS(j) { assert((j) < 8); if (k < (j)) _NEEDBITS }
|
||||
|
||||
/* set bits */
|
||||
#define SETBITS(j,x) { b |= ((lzo_uint32_t)(x)) << k; k += (j); assert(k <= 32); }
|
||||
|
||||
/* access bits */
|
||||
#define MASKBITS(j) (b & ((((lzo_uint32_t)1 << (j)) - 1)))
|
||||
|
||||
/* drop bits */
|
||||
#define DUMPBITS(j) { assert(k >= j); b >>= (j); k -= (j); }
|
||||
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,621 @@
|
|||
/* lzo1.c -- implementation of the LZO1 algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// The next two defines can be changed to customize LZO1.
|
||||
// The default version is LZO1-5/1.
|
||||
************************************************************************/
|
||||
|
||||
/* run bits (3 - 5) - the compressor and the decompressor
|
||||
* must use the same value. */
|
||||
#if !defined(RBITS)
|
||||
# define RBITS 5
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio */
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* check configuration */
|
||||
#if (RBITS < 3 || RBITS > 5)
|
||||
# error "invalid RBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// You should not have to change anything below this line.
|
||||
************************************************************************/
|
||||
|
||||
/*
|
||||
Format of the marker byte
|
||||
|
||||
|
||||
76543210
|
||||
--------
|
||||
00000000 a long run (a 'R0' run) - there are short and long R0 runs
|
||||
000rrrrr a short run with len r
|
||||
mmmooooo a short match (len = 2+m, o = offset low bits)
|
||||
111ooooo a long match (o = offset low bits)
|
||||
*/
|
||||
|
||||
|
||||
#define RSIZE (1 << RBITS)
|
||||
#define RMASK (RSIZE - 1)
|
||||
|
||||
#define OBITS RBITS /* offset and run-length use same bits */
|
||||
#define OSIZE (1 << OBITS)
|
||||
#define OMASK (OSIZE - 1)
|
||||
|
||||
#define MBITS (8 - OBITS)
|
||||
#define MSIZE (1 << MBITS)
|
||||
#define MMASK (MSIZE - 1)
|
||||
|
||||
|
||||
/* sanity checks */
|
||||
#if (OBITS < 3 || OBITS > 5)
|
||||
# error "invalid OBITS"
|
||||
#endif
|
||||
#if (MBITS < 3 || MBITS > 5)
|
||||
# error "invalid MBITS"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// some macros to improve readability
|
||||
************************************************************************/
|
||||
|
||||
/* Minimum len of a match */
|
||||
#define MIN_MATCH 3
|
||||
#define THRESHOLD (MIN_MATCH - 1)
|
||||
|
||||
/* Minimum len of match coded in 2 bytes */
|
||||
#define MIN_MATCH_SHORT MIN_MATCH
|
||||
|
||||
/* Maximum len of match coded in 2 bytes */
|
||||
#define MAX_MATCH_SHORT (THRESHOLD + (MSIZE - 2))
|
||||
/* MSIZE - 2: 0 is used to indicate runs,
|
||||
* MSIZE-1 is used to indicate a long match */
|
||||
|
||||
/* Minimum len of match coded in 3 bytes */
|
||||
#define MIN_MATCH_LONG (MAX_MATCH_SHORT + 1)
|
||||
|
||||
/* Maximum len of match coded in 3 bytes */
|
||||
#define MAX_MATCH_LONG (MIN_MATCH_LONG + 255)
|
||||
|
||||
/* Maximum offset of a match */
|
||||
#define MAX_OFFSET (1 << (8 + OBITS))
|
||||
|
||||
|
||||
/*
|
||||
|
||||
RBITS | MBITS MIN THR. MSIZE MAXS MINL MAXL MAXO R0MAX R0FAST
|
||||
======+===============================================================
|
||||
3 | 5 3 2 32 32 33 288 2048 263 256
|
||||
4 | 4 3 2 16 16 17 272 4096 271 264
|
||||
5 | 3 3 2 8 8 9 264 8192 287 280
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
// all of these affect compression only
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,5,5)) >> 5)
|
||||
#define D_INDEX2(d,p) d = d ^ D_MASK
|
||||
|
||||
#define DBITS (8 + RBITS)
|
||||
#include "lzo_dict.h"
|
||||
#define DVAL_LEN DVAL_LOOKAHEAD
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// get algorithm info, return memory required for compression
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(lzo_uint) lzo1_info ( int *rbits, int *clevel );
|
||||
|
||||
LZO_PUBLIC(lzo_uint)
|
||||
lzo1_info ( int *rbits, int *clevel )
|
||||
{
|
||||
if (rbits)
|
||||
*rbits = RBITS;
|
||||
if (clevel)
|
||||
*clevel = CLEVEL;
|
||||
return D_SIZE * lzo_sizeof(lzo_bytep);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// decode a R0 literal run (a long run)
|
||||
************************************************************************/
|
||||
|
||||
#define R0MIN (RSIZE) /* Minimum len of R0 run of literals */
|
||||
#define R0MAX (R0MIN + 255) /* Maximum len of R0 run of literals */
|
||||
#define R0FAST (R0MAX & ~7u) /* R0MAX aligned to 8 byte boundary */
|
||||
|
||||
#if (R0MAX - R0FAST != 7) || ((R0FAST & 7) != 0)
|
||||
# error "something went wrong"
|
||||
#endif
|
||||
|
||||
/* 7 special codes from R0FAST+1 .. R0MAX
|
||||
* these codes mean long R0 runs with lengths
|
||||
* 512, 1024, 2048, 4096, 8192, 16384, 32768 */
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO1 decompress a block of data.
|
||||
//
|
||||
// Could be easily translated into assembly code.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1_decompress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
const lzo_bytep const ip_end = in + in_len;
|
||||
lzo_uint t;
|
||||
|
||||
LZO_UNUSED(wrkmem);
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
while (ip < ip_end)
|
||||
{
|
||||
t = *ip++; /* get marker */
|
||||
|
||||
if (t < R0MIN) /* a literal run */
|
||||
{
|
||||
if (t == 0) /* a R0 literal run */
|
||||
{
|
||||
t = *ip++;
|
||||
if (t >= R0FAST - R0MIN) /* a long R0 run */
|
||||
{
|
||||
t -= R0FAST - R0MIN;
|
||||
if (t == 0)
|
||||
t = R0FAST;
|
||||
else
|
||||
{
|
||||
#if 0
|
||||
t = 256u << ((unsigned) t);
|
||||
#else
|
||||
/* help the optimizer */
|
||||
lzo_uint tt = 256;
|
||||
do tt <<= 1; while (--t > 0);
|
||||
t = tt;
|
||||
#endif
|
||||
}
|
||||
MEMCPY8_DS(op,ip,t);
|
||||
continue;
|
||||
}
|
||||
t += R0MIN;
|
||||
}
|
||||
MEMCPY_DS(op,ip,t);
|
||||
}
|
||||
else /* a match */
|
||||
{
|
||||
lzo_uint tt;
|
||||
/* get match offset */
|
||||
const lzo_bytep m_pos = op - 1;
|
||||
m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) *ip++) << OBITS);
|
||||
|
||||
/* get match len */
|
||||
if (t >= ((MSIZE - 1) << OBITS)) /* all m-bits set */
|
||||
tt = (MIN_MATCH_LONG - THRESHOLD) + *ip++; /* a long match */
|
||||
else
|
||||
tt = t >> OBITS; /* a short match */
|
||||
|
||||
assert(m_pos >= out);
|
||||
assert(m_pos < op);
|
||||
/* a half unrolled loop */
|
||||
*op++ = *m_pos++;
|
||||
*op++ = *m_pos++;
|
||||
MEMCPY_DS(op,m_pos,tt);
|
||||
}
|
||||
}
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
/* the next line is the only check in the decompressor ! */
|
||||
return (ip == ip_end ? LZO_E_OK :
|
||||
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// code a literal run
|
||||
************************************************************************/
|
||||
|
||||
static
|
||||
#if LZO_ARCH_AVR
|
||||
__lzo_noinline
|
||||
#endif
|
||||
lzo_bytep
|
||||
store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len)
|
||||
{
|
||||
assert(r_len > 0);
|
||||
|
||||
/* code a long R0 run */
|
||||
if (r_len >= 512)
|
||||
{
|
||||
unsigned r_bits = 7; /* 256 << 7 == 32768 */
|
||||
do {
|
||||
while (r_len >= (256u << r_bits))
|
||||
{
|
||||
r_len -= (256u << r_bits);
|
||||
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
|
||||
MEMCPY8_DS(op, ii, (256u << r_bits));
|
||||
}
|
||||
} while (--r_bits > 0);
|
||||
}
|
||||
while (r_len >= R0FAST)
|
||||
{
|
||||
r_len -= R0FAST;
|
||||
*op++ = 0; *op++ = R0FAST - R0MIN;
|
||||
MEMCPY8_DS(op, ii, R0FAST);
|
||||
}
|
||||
|
||||
if (r_len >= R0MIN)
|
||||
{
|
||||
/* code a short R0 run */
|
||||
*op++ = 0; *op++ = LZO_BYTE(r_len - R0MIN);
|
||||
MEMCPY_DS(op, ii, r_len);
|
||||
}
|
||||
else if (r_len > 0)
|
||||
{
|
||||
/* code a 'normal' run */
|
||||
*op++ = LZO_BYTE(r_len);
|
||||
MEMCPY_DS(op, ii, r_len);
|
||||
}
|
||||
|
||||
assert(r_len == 0);
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO1 compress a block of data.
|
||||
//
|
||||
// Could be translated into assembly code without too much effort.
|
||||
//
|
||||
// I apologize for the spaghetti code, but it really helps the optimizer.
|
||||
************************************************************************/
|
||||
|
||||
static int
|
||||
do_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
const lzo_bytep ip;
|
||||
#if defined(__LZO_HASH_INCREMENTAL)
|
||||
lzo_xint dv;
|
||||
#endif
|
||||
lzo_bytep op;
|
||||
const lzo_bytep m_pos;
|
||||
const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG;
|
||||
const lzo_bytep const in_end = in+in_len - DVAL_LEN;
|
||||
const lzo_bytep ii;
|
||||
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
|
||||
|
||||
#if !defined(NDEBUG)
|
||||
const lzo_bytep m_pos_sav;
|
||||
#endif
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
ii = ip; /* point to start of literal run */
|
||||
if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
|
||||
goto the_end;
|
||||
|
||||
/* init dictionary */
|
||||
#if (LZO_DETERMINISTIC)
|
||||
BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
|
||||
#endif
|
||||
|
||||
DVAL_FIRST(dv,ip);
|
||||
UPDATE_D(dict,0,dv,ip,in);
|
||||
ip++;
|
||||
DVAL_NEXT(dv,ip);
|
||||
|
||||
do {
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
|
||||
lzo_uint dindex;
|
||||
|
||||
DINDEX1(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
|
||||
goto match;
|
||||
DINDEX2(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
|
||||
goto match;
|
||||
goto literal;
|
||||
|
||||
|
||||
literal:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
if (++ip >= ip_end)
|
||||
break;
|
||||
continue;
|
||||
|
||||
match:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
#if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
|
||||
m_pos_sav = m_pos;
|
||||
#endif
|
||||
m_pos += 3;
|
||||
{
|
||||
/* we have found a match (of at least length 3) */
|
||||
#if !defined(NDEBUG) && !(LZO_DICT_USE_PTR)
|
||||
assert((m_pos_sav = ip - m_off) == (m_pos - 3));
|
||||
#endif
|
||||
/* 1) store the current literal run */
|
||||
if (pd(ip,ii) > 0)
|
||||
{
|
||||
lzo_uint t = pd(ip,ii);
|
||||
#if 1
|
||||
/* OPTIMIZED: inline the copying of a short run */
|
||||
if (t < R0MIN)
|
||||
{
|
||||
*op++ = LZO_BYTE(t);
|
||||
MEMCPY_DS(op, ii, t);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
op = store_run(op,ii,t);
|
||||
}
|
||||
|
||||
/* 2a) compute match len */
|
||||
ii = ip; /* point to start of current match */
|
||||
|
||||
/* we already matched MIN_MATCH bytes,
|
||||
* m_pos also already advanced MIN_MATCH bytes */
|
||||
ip += MIN_MATCH;
|
||||
assert(m_pos < ip);
|
||||
|
||||
/* try to match another MIN_MATCH_LONG - MIN_MATCH bytes
|
||||
* to see if we get a long match */
|
||||
|
||||
#define PS *m_pos++ != *ip++
|
||||
|
||||
#if (MIN_MATCH_LONG - MIN_MATCH == 2) /* MBITS == 2 */
|
||||
if (PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 6) /* MBITS == 3 */
|
||||
if (PS || PS || PS || PS || PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 14) /* MBITS == 4 */
|
||||
if (PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 30) /* MBITS == 5 */
|
||||
if (PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS)
|
||||
#else
|
||||
# error "MBITS not yet implemented"
|
||||
#endif
|
||||
{
|
||||
lzo_uint m_len;
|
||||
|
||||
/* 2b) code a short match */
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
--ip; /* ran one too far, point back to non-match */
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= MIN_MATCH_SHORT);
|
||||
assert(m_len <= MAX_MATCH_SHORT);
|
||||
assert(m_off > 0);
|
||||
assert(m_off <= MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
--m_off;
|
||||
/* code short match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) |
|
||||
(m_off & OMASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> OBITS);
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
|
||||
#define SI /* nothing */
|
||||
#define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,0,dv,ii,in);
|
||||
#define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip));
|
||||
|
||||
#if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
UPDATE_D(dict,0,dv,ii,in);
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
/* we've found a long match - see how far we can still go */
|
||||
const lzo_bytep end;
|
||||
lzo_uint m_len;
|
||||
|
||||
assert(ip <= in_end);
|
||||
assert(ii == ip - MIN_MATCH_LONG);
|
||||
|
||||
if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
|
||||
end = in_end;
|
||||
else
|
||||
{
|
||||
end = ip + (MAX_MATCH_LONG - MIN_MATCH_LONG);
|
||||
assert(end < in_end);
|
||||
}
|
||||
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
assert(ip <= in_end);
|
||||
|
||||
/* 2b) code the long match */
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= MIN_MATCH_LONG);
|
||||
assert(m_len <= MAX_MATCH_LONG);
|
||||
assert(m_off > 0);
|
||||
assert(m_off <= MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
--m_off;
|
||||
/* code long match flag + low offset bits */
|
||||
*op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> OBITS);
|
||||
/* code match len */
|
||||
*op++ = LZO_BYTE(m_len - MIN_MATCH_LONG);
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
#if (CLEVEL == 9)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
/* This is not recommended because it is slow. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
UPDATE_D(dict,0,dv,ii,in);
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 8)
|
||||
SI DI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 7)
|
||||
SI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 6)
|
||||
SI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 5)
|
||||
SI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 4)
|
||||
SI DI DI DI XI
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ii now points to the start of next literal run */
|
||||
assert(ii == ip);
|
||||
}
|
||||
} while (ip < ip_end);
|
||||
|
||||
|
||||
|
||||
the_end:
|
||||
assert(ip <= in_end);
|
||||
|
||||
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
/* return -1 if op == out to indicate that we
|
||||
* couldn't compress and didn't copy anything.
|
||||
*/
|
||||
if (op == out)
|
||||
{
|
||||
*out_len = 0;
|
||||
return LZO_E_NOT_COMPRESSIBLE;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* store the final literal run */
|
||||
if (pd(in_end+DVAL_LEN,ii) > 0)
|
||||
op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return 0; /* compression went ok */
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compress public entry point.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
int r = LZO_E_OK;
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
*out_len = 0;
|
||||
else if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(store_run(out,in,in_len), out);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = do_compress(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
/* lzo1_99.c -- implementation of the LZO1-99 algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#define COMPRESS_ID 99
|
||||
|
||||
#define DDBITS 3
|
||||
#define CLEVEL 9
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compression internal entry point.
|
||||
************************************************************************/
|
||||
|
||||
static int
|
||||
_lzo1_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func )
|
||||
{
|
||||
int r;
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
{
|
||||
*out_len = 0;
|
||||
r = LZO_E_OK;
|
||||
}
|
||||
else if (in_len <= MIN_LOOKAHEAD + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
*out_len = 0;
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(STORE_RUN(out,in,in_len), out);
|
||||
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = func(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(COMPRESS_ID)
|
||||
#define COMPRESS_ID _LZO_ECONCAT2(DD_BITS,CLEVEL)
|
||||
#endif
|
||||
|
||||
|
||||
#define LZO_CODE_MATCH_INCLUDE_FILE "lzo1_cm.ch"
|
||||
#include "lzo1b_c.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_COMPRESS \
|
||||
LZO_PP_ECONCAT3(lzo1_,COMPRESS_ID,_compress)
|
||||
|
||||
#define LZO_COMPRESS_FUNC \
|
||||
LZO_PP_ECONCAT3(_lzo1_,COMPRESS_ID,_compress_func)
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return _lzo1_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/* lzo1_cm.ch -- implementation of the LZO1 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo1a_cm.ch"
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
/* lzo1_d.ch -- common decompression stuff
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN)
|
||||
# if !defined(LZO_TEST_OVERRUN_INPUT)
|
||||
# define LZO_TEST_OVERRUN_INPUT 2
|
||||
# endif
|
||||
# if !defined(LZO_TEST_OVERRUN_OUTPUT)
|
||||
# define LZO_TEST_OVERRUN_OUTPUT 2
|
||||
# endif
|
||||
# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND)
|
||||
# define LZO_TEST_OVERRUN_LOOKBEHIND 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// Overrun detection is internally handled by these macros:
|
||||
//
|
||||
// TEST_IP test input overrun at loop begin
|
||||
// NEED_IP test input overrun at every input byte
|
||||
//
|
||||
// TEST_OP test output overrun at loop begin
|
||||
// NEED_OP test output overrun at every output byte
|
||||
//
|
||||
// TEST_LB test match position
|
||||
//
|
||||
// The fastest decompressor results when testing for no overruns
|
||||
// and using LZO_EOF_CODE.
|
||||
************************************************************************/
|
||||
|
||||
#undef TEST_IP
|
||||
#undef TEST_OP
|
||||
#undef TEST_IP_AND_TEST_OP
|
||||
#undef TEST_LB
|
||||
#undef TEST_LBO
|
||||
#undef NEED_IP
|
||||
#undef NEED_OP
|
||||
#undef TEST_IV
|
||||
#undef TEST_OV
|
||||
#undef HAVE_TEST_IP
|
||||
#undef HAVE_TEST_OP
|
||||
#undef HAVE_NEED_IP
|
||||
#undef HAVE_NEED_OP
|
||||
#undef HAVE_ANY_IP
|
||||
#undef HAVE_ANY_OP
|
||||
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_INPUT)
|
||||
# if (LZO_TEST_OVERRUN_INPUT >= 1)
|
||||
# define TEST_IP (ip < ip_end)
|
||||
# endif
|
||||
# if (LZO_TEST_OVERRUN_INPUT >= 2)
|
||||
# define NEED_IP(x) \
|
||||
if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
|
||||
# define TEST_IV(x) if ((x) > (lzo_uint)0 - (511)) goto input_overrun
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_OUTPUT)
|
||||
# if (LZO_TEST_OVERRUN_OUTPUT >= 1)
|
||||
# define TEST_OP (op <= op_end)
|
||||
# endif
|
||||
# if (LZO_TEST_OVERRUN_OUTPUT >= 2)
|
||||
# undef TEST_OP /* don't need both of the tests here */
|
||||
# define NEED_OP(x) \
|
||||
if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
|
||||
# define TEST_OV(x) if ((x) > (lzo_uint)0 - (511)) goto output_overrun
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
|
||||
# define TEST_LB(m_pos) if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op)) goto lookbehind_overrun
|
||||
# define TEST_LBO(m_pos,o) if (PTR_LT(m_pos,out) || PTR_GE(m_pos,op-(o))) goto lookbehind_overrun
|
||||
#else
|
||||
# define TEST_LB(m_pos) ((void) 0)
|
||||
# define TEST_LBO(m_pos,o) ((void) 0)
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
|
||||
/* if we have no EOF code, we have to test for the end of the input */
|
||||
# define TEST_IP (ip < ip_end)
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(TEST_IP)
|
||||
# define HAVE_TEST_IP 1
|
||||
#else
|
||||
# define TEST_IP 1
|
||||
#endif
|
||||
#if defined(TEST_OP)
|
||||
# define HAVE_TEST_OP 1
|
||||
#else
|
||||
# define TEST_OP 1
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_TEST_IP) && defined(HAVE_TEST_OP)
|
||||
# define TEST_IP_AND_TEST_OP (TEST_IP && TEST_OP)
|
||||
#elif defined(HAVE_TEST_IP)
|
||||
# define TEST_IP_AND_TEST_OP TEST_IP
|
||||
#elif defined(HAVE_TEST_OP)
|
||||
# define TEST_IP_AND_TEST_OP TEST_OP
|
||||
#else
|
||||
# define TEST_IP_AND_TEST_OP 1
|
||||
#endif
|
||||
|
||||
#if defined(NEED_IP)
|
||||
# define HAVE_NEED_IP 1
|
||||
#else
|
||||
# define NEED_IP(x) ((void) 0)
|
||||
# define TEST_IV(x) ((void) 0)
|
||||
#endif
|
||||
#if defined(NEED_OP)
|
||||
# define HAVE_NEED_OP 1
|
||||
#else
|
||||
# define NEED_OP(x) ((void) 0)
|
||||
# define TEST_OV(x) ((void) 0)
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
|
||||
# define HAVE_ANY_IP 1
|
||||
#endif
|
||||
#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
|
||||
# define HAVE_ANY_OP 1
|
||||
#endif
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,643 @@
|
|||
/* lzo1a.c -- implementation of the LZO1A algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1a.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// The next two defines can be changed to customize LZO1A.
|
||||
// The default version is LZO1A-5/1.
|
||||
************************************************************************/
|
||||
|
||||
/* run bits (3 - 5) - the compressor and the decompressor
|
||||
* must use the same value. */
|
||||
#if !defined(RBITS)
|
||||
# define RBITS 5
|
||||
#endif
|
||||
|
||||
/* compression level (1 - 9) - this only affects the compressor.
|
||||
* 1 is fastest, 9 is best compression ratio
|
||||
*/
|
||||
#if !defined(CLEVEL)
|
||||
# define CLEVEL 1 /* fastest by default */
|
||||
#endif
|
||||
|
||||
|
||||
/* Collect statistics */
|
||||
#if 0 && !defined(LZO_COLLECT_STATS)
|
||||
# define LZO_COLLECT_STATS 1
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// You should not have to change anything below this line.
|
||||
************************************************************************/
|
||||
|
||||
/* check configuration */
|
||||
#if (RBITS < 3 || RBITS > 5)
|
||||
# error "invalid RBITS"
|
||||
#endif
|
||||
#if (CLEVEL < 1 || CLEVEL > 9)
|
||||
# error "invalid CLEVEL"
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// internal configuration
|
||||
// all of these affect compression only
|
||||
************************************************************************/
|
||||
|
||||
/* choose the hashing strategy */
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,5,5)) >> 5)
|
||||
#define D_INDEX2(d,p) d = d ^ D_MASK
|
||||
|
||||
#include "lzo1a_de.h"
|
||||
#include "stats1a.h"
|
||||
|
||||
|
||||
/* check other constants */
|
||||
#if (LBITS < 5 || LBITS > 8)
|
||||
# error "invalid LBITS"
|
||||
#endif
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
static lzo1a_stats_t lzo_statistics;
|
||||
lzo1a_stats_t *lzo1a_stats = &lzo_statistics;
|
||||
# define lzo_stats lzo1a_stats
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// get algorithm info, return memory required for compression
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(lzo_uint) lzo1a_info ( int *rbits, int *clevel );
|
||||
|
||||
LZO_PUBLIC(lzo_uint)
|
||||
lzo1a_info ( int *rbits, int *clevel )
|
||||
{
|
||||
if (rbits)
|
||||
*rbits = RBITS;
|
||||
if (clevel)
|
||||
*clevel = CLEVEL;
|
||||
return D_SIZE * lzo_sizeof(lzo_bytep);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO1A decompress a block of data.
|
||||
//
|
||||
// Could be easily translated into assembly code.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
const lzo_bytep m_pos;
|
||||
const lzo_bytep const ip_end = in + in_len;
|
||||
|
||||
LZO_UNUSED(wrkmem);
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
while (ip < ip_end)
|
||||
{
|
||||
t = *ip++; /* get marker */
|
||||
LZO_STATS(lzo_stats->marker[t]++);
|
||||
|
||||
if (t == 0) /* a R0 literal run */
|
||||
{
|
||||
t = *ip++;
|
||||
if (t >= R0FAST - R0MIN) /* a long R0 run */
|
||||
{
|
||||
t -= R0FAST - R0MIN;
|
||||
if (t == 0)
|
||||
t = R0FAST;
|
||||
else
|
||||
{
|
||||
#if 0
|
||||
t = 256u << ((unsigned) t);
|
||||
#else
|
||||
/* help the optimizer */
|
||||
lzo_uint tt = 256;
|
||||
do tt <<= 1; while (--t > 0);
|
||||
t = tt;
|
||||
#endif
|
||||
}
|
||||
MEMCPY8_DS(op,ip,t);
|
||||
continue;
|
||||
}
|
||||
t += R0MIN;
|
||||
goto literal;
|
||||
}
|
||||
else if (t < R0MIN) /* a short literal run */
|
||||
{
|
||||
literal:
|
||||
MEMCPY_DS(op,ip,t);
|
||||
|
||||
/* after a literal a match must follow */
|
||||
while (ip < ip_end)
|
||||
{
|
||||
t = *ip++; /* get R1 marker */
|
||||
if (t >= R0MIN)
|
||||
goto match;
|
||||
|
||||
/* R1 match - a context sensitive 3 byte match + 1 byte literal */
|
||||
assert((t & OMASK) == t);
|
||||
m_pos = op - MIN_OFFSET;
|
||||
m_pos -= t | (((lzo_uint) *ip++) << OBITS);
|
||||
assert(m_pos >= out); assert(m_pos < op);
|
||||
*op++ = m_pos[0];
|
||||
*op++ = m_pos[1];
|
||||
*op++ = m_pos[2];
|
||||
*op++ = *ip++;
|
||||
}
|
||||
}
|
||||
else /* a match */
|
||||
{
|
||||
match:
|
||||
/* get match offset */
|
||||
m_pos = op - MIN_OFFSET;
|
||||
m_pos -= (t & OMASK) | (((lzo_uint) *ip++) << OBITS);
|
||||
assert(m_pos >= out); assert(m_pos < op);
|
||||
|
||||
/* get match len */
|
||||
if (t < ((MSIZE - 1) << OBITS)) /* a short match */
|
||||
{
|
||||
t >>= OBITS;
|
||||
*op++ = *m_pos++;
|
||||
*op++ = *m_pos++;
|
||||
MEMCPY_DS(op,m_pos,t);
|
||||
}
|
||||
else /* a long match */
|
||||
{
|
||||
#if (LBITS < 8)
|
||||
t = (MIN_MATCH_LONG - THRESHOLD) + ((lzo_uint)(*ip++) & LMASK);
|
||||
#else
|
||||
t = (MIN_MATCH_LONG - THRESHOLD) + (lzo_uint)(*ip++);
|
||||
#endif
|
||||
*op++ = *m_pos++;
|
||||
*op++ = *m_pos++;
|
||||
MEMCPY_DS(op,m_pos,t);
|
||||
#if (LBITS < 8)
|
||||
/* a very short literal following a long match */
|
||||
t = ip[-1] >> LBITS;
|
||||
if (t) do
|
||||
*op++ = *ip++;
|
||||
while (--t);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
/* the next line is the only check in the decompressor */
|
||||
return (ip == ip_end ? LZO_E_OK :
|
||||
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO1A compress a block of data.
|
||||
//
|
||||
// I apologize for the spaghetti code, but it really helps the optimizer.
|
||||
************************************************************************/
|
||||
|
||||
#include "lzo1a_cr.ch"
|
||||
|
||||
static int
|
||||
do_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
const lzo_bytep ip;
|
||||
#if defined(__LZO_HASH_INCREMENTAL)
|
||||
lzo_xint dv;
|
||||
#endif
|
||||
const lzo_bytep m_pos;
|
||||
lzo_bytep op;
|
||||
const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG;
|
||||
const lzo_bytep const in_end = in+in_len - DVAL_LEN;
|
||||
const lzo_bytep ii;
|
||||
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
|
||||
const lzo_bytep r1 = ip_end; /* pointer for R1 match (none yet) */
|
||||
#if (LBITS < 8)
|
||||
const lzo_bytep im = ip_end; /* pointer to last match start */
|
||||
#endif
|
||||
|
||||
#if !defined(NDEBUG)
|
||||
const lzo_bytep m_pos_sav;
|
||||
#endif
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
ii = ip; /* point to start of current literal run */
|
||||
|
||||
/* init dictionary */
|
||||
#if (LZO_DETERMINISTIC)
|
||||
BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
|
||||
#endif
|
||||
|
||||
DVAL_FIRST(dv,ip); UPDATE_D(dict,0,dv,ip,in); ip++;
|
||||
DVAL_NEXT(dv,ip);
|
||||
|
||||
do {
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
|
||||
lzo_uint dindex;
|
||||
|
||||
DINDEX1(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
|
||||
goto match;
|
||||
DINDEX2(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
|
||||
goto match;
|
||||
goto literal;
|
||||
|
||||
literal:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
if (++ip >= ip_end)
|
||||
break;
|
||||
continue;
|
||||
|
||||
match:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
#if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
|
||||
assert(m_pos == NULL || m_pos >= in);
|
||||
m_pos_sav = m_pos;
|
||||
#endif
|
||||
m_pos += 3;
|
||||
{
|
||||
/* we have found a match (of at least length 3) */
|
||||
|
||||
#if !defined(NDEBUG) && !(LZO_DICT_USE_PTR)
|
||||
assert((m_pos_sav = ip - m_off) == (m_pos - 3));
|
||||
#endif
|
||||
|
||||
assert(m_pos >= in);
|
||||
assert(ip < ip_end);
|
||||
|
||||
/* 1) store the current literal run */
|
||||
if (pd(ip,ii) > 0)
|
||||
{
|
||||
lzo_uint t = pd(ip,ii);
|
||||
|
||||
if (ip - r1 == MIN_MATCH + 1)
|
||||
{
|
||||
/* Code a context sensitive R1 match.
|
||||
* This is tricky and somewhat difficult to explain:
|
||||
* multiplex a literal run of length 1 into the previous
|
||||
* short match of length MIN_MATCH.
|
||||
* The key idea is:
|
||||
* - after a short run a match MUST follow
|
||||
* - therefore the value m = 000 in the mmmooooo marker is free
|
||||
* - use 000ooooo to indicate a MIN_MATCH match (this
|
||||
* is already coded) plus a 1 byte literal
|
||||
*/
|
||||
assert(t == 1);
|
||||
/* modify marker byte */
|
||||
assert((op[-2] >> OBITS) == (MIN_MATCH - THRESHOLD));
|
||||
op[-2] &= OMASK;
|
||||
assert((op[-2] >> OBITS) == 0);
|
||||
/* copy 1 literal */
|
||||
*op++ = *ii;
|
||||
LZO_STATS(lzo_stats->r1_matches++);
|
||||
r1 = ip; /* set new R1 pointer */
|
||||
}
|
||||
else if (t < R0MIN)
|
||||
{
|
||||
/* inline the copying of a short run */
|
||||
#if (LBITS < 8)
|
||||
if (t < (1 << (8-LBITS)) && ii - im >= MIN_MATCH_LONG)
|
||||
{
|
||||
/* Code a very short literal run into the
|
||||
* previous long match length byte.
|
||||
*/
|
||||
LZO_STATS(lzo_stats->lit_runs_after_long_match++);
|
||||
LZO_STATS(lzo_stats->lit_run_after_long_match[t]++);
|
||||
assert(ii - im <= MAX_MATCH_LONG);
|
||||
assert((op[-1] >> LBITS) == 0);
|
||||
op[-1] = LZO_BYTE(op[-1] | (t << LBITS));
|
||||
MEMCPY_DS(op, ii, t);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
LZO_STATS(lzo_stats->lit_runs++);
|
||||
LZO_STATS(lzo_stats->lit_run[t]++);
|
||||
*op++ = LZO_BYTE(t);
|
||||
MEMCPY_DS(op, ii, t);
|
||||
r1 = ip; /* set new R1 pointer */
|
||||
}
|
||||
}
|
||||
else if (t < R0FAST)
|
||||
{
|
||||
/* inline the copying of a short R0 run */
|
||||
LZO_STATS(lzo_stats->r0short_runs++);
|
||||
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
|
||||
MEMCPY_DS(op, ii, t);
|
||||
r1 = ip; /* set new R1 pointer */
|
||||
}
|
||||
else
|
||||
op = store_run(op,ii,t);
|
||||
}
|
||||
#if (LBITS < 8)
|
||||
im = ip;
|
||||
#endif
|
||||
|
||||
|
||||
/* 2) compute match len */
|
||||
ii = ip; /* point to start of current match */
|
||||
|
||||
/* we already matched MIN_MATCH bytes,
|
||||
* m_pos also already advanced MIN_MATCH bytes */
|
||||
ip += MIN_MATCH;
|
||||
assert(m_pos < ip);
|
||||
|
||||
/* try to match another MIN_MATCH_LONG - MIN_MATCH bytes
|
||||
* to see if we get a long match */
|
||||
|
||||
#define PS *m_pos++ != *ip++
|
||||
|
||||
#if (MIN_MATCH_LONG - MIN_MATCH == 2) /* MBITS == 2 */
|
||||
if (PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 6) /* MBITS == 3 */
|
||||
if (PS || PS || PS || PS || PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 14) /* MBITS == 4 */
|
||||
if (PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS)
|
||||
#elif (MIN_MATCH_LONG - MIN_MATCH == 30) /* MBITS == 5 */
|
||||
if (PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS || PS || PS ||
|
||||
PS || PS || PS || PS || PS || PS)
|
||||
#else
|
||||
# error "MBITS not yet implemented"
|
||||
#endif
|
||||
{
|
||||
/* we've found a short match */
|
||||
lzo_uint m_len;
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
assert(ip-m_pos == (int)m_off);
|
||||
--ip; /* ran one too far, point back to non-match */
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= MIN_MATCH_SHORT);
|
||||
assert(m_len <= MAX_MATCH_SHORT);
|
||||
assert(m_off >= MIN_OFFSET);
|
||||
assert(m_off <= MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
m_off -= MIN_OFFSET;
|
||||
|
||||
/* 2b) code a short match */
|
||||
/* code short match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) |
|
||||
(m_off & OMASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> OBITS);
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->short_matches++;
|
||||
lzo_stats->short_match[m_len]++;
|
||||
if (m_off < OSIZE)
|
||||
lzo_stats->short_match_offset_osize[m_len]++;
|
||||
if (m_off < 256)
|
||||
lzo_stats->short_match_offset_256[m_len]++;
|
||||
if (m_off < 1024)
|
||||
lzo_stats->short_match_offset_1024[m_len]++;
|
||||
#endif
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
|
||||
#define SI /* nothing */
|
||||
#define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,0,dv,ii,in);
|
||||
#define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip));
|
||||
|
||||
#if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
UPDATE_D(dict,0,dv,ii,in);
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
/* we've found a long match - see how far we can still go */
|
||||
const lzo_bytep end;
|
||||
lzo_uint m_len;
|
||||
|
||||
assert(ip <= in_end);
|
||||
assert(ii == ip - MIN_MATCH_LONG);
|
||||
|
||||
if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG))
|
||||
end = in_end;
|
||||
else
|
||||
{
|
||||
end = ip + (MAX_MATCH_LONG - MIN_MATCH_LONG);
|
||||
assert(end < in_end);
|
||||
}
|
||||
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
assert(ip <= in_end);
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= MIN_MATCH_LONG);
|
||||
assert(m_len <= MAX_MATCH_LONG);
|
||||
assert(m_off >= MIN_OFFSET);
|
||||
assert(m_off <= MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
m_off -= MIN_OFFSET;
|
||||
|
||||
/* 2b) code the long match */
|
||||
/* code long match flag + low offset bits */
|
||||
*op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> OBITS);
|
||||
/* code match len */
|
||||
*op++ = LZO_BYTE(m_len - MIN_MATCH_LONG);
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->long_matches++;
|
||||
lzo_stats->long_match[m_len]++;
|
||||
#endif
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
#if (CLEVEL == 9)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
/* This is not recommended because it is slow. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
UPDATE_D(dict,0,dv,ii,in);
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 8)
|
||||
SI DI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 7)
|
||||
SI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 6)
|
||||
SI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 5)
|
||||
SI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 4)
|
||||
SI DI DI DI XI
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ii now points to the start of the next literal run */
|
||||
assert(ii == ip);
|
||||
}
|
||||
|
||||
} while (ip < ip_end);
|
||||
|
||||
assert(ip <= in_end);
|
||||
|
||||
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
/* return -1 if op == out to indicate that we
|
||||
* couldn't compress and didn't copy anything.
|
||||
*/
|
||||
if (op == out)
|
||||
{
|
||||
*out_len = 0;
|
||||
return LZO_E_NOT_COMPRESSIBLE;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* store the final literal run */
|
||||
if (pd(in_end+DVAL_LEN,ii) > 0)
|
||||
op = store_run(op,ii,pd(in_end+DVAL_LEN,ii));
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return 0; /* compression went ok */
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// LZO1A compress public entry point.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1a_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
int r = LZO_E_OK;
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
|
||||
lzo_stats->rbits = RBITS;
|
||||
lzo_stats->clevel = CLEVEL;
|
||||
lzo_stats->dbits = DBITS;
|
||||
lzo_stats->lbits = LBITS;
|
||||
lzo_stats->min_match_short = MIN_MATCH_SHORT;
|
||||
lzo_stats->max_match_short = MAX_MATCH_SHORT;
|
||||
lzo_stats->min_match_long = MIN_MATCH_LONG;
|
||||
lzo_stats->max_match_long = MAX_MATCH_LONG;
|
||||
lzo_stats->min_offset = MIN_OFFSET;
|
||||
lzo_stats->max_offset = MAX_OFFSET;
|
||||
lzo_stats->r0min = R0MIN;
|
||||
lzo_stats->r0fast = R0FAST;
|
||||
lzo_stats->r0max = R0MAX;
|
||||
lzo_stats->in_len = in_len;
|
||||
#endif
|
||||
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
*out_len = 0;
|
||||
else if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(store_run(out,in,in_len), out);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = do_compress(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->short_matches -= lzo_stats->r1_matches;
|
||||
lzo_stats->short_match[MIN_MATCH] -= lzo_stats->r1_matches;
|
||||
lzo_stats->out_len = *out_len;
|
||||
#endif
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
/* lzo1a_99.c -- implementation of the LZO1A-99 algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#define COMPRESS_ID 99
|
||||
|
||||
#define DDBITS 3
|
||||
#define CLEVEL 9
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1a.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compression internal entry point.
|
||||
************************************************************************/
|
||||
|
||||
static int
|
||||
_lzo1a_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func )
|
||||
{
|
||||
int r;
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
{
|
||||
*out_len = 0;
|
||||
r = LZO_E_OK;
|
||||
}
|
||||
else if (in_len <= MIN_LOOKAHEAD + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
*out_len = 0;
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(STORE_RUN(out,in,in_len), out);
|
||||
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = func(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(COMPRESS_ID)
|
||||
#define COMPRESS_ID _LZO_ECONCAT2(DD_BITS,CLEVEL)
|
||||
#endif
|
||||
|
||||
|
||||
#define LZO_CODE_MATCH_INCLUDE_FILE "lzo1a_cm.ch"
|
||||
#include "lzo1b_c.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define LZO_COMPRESS \
|
||||
LZO_PP_ECONCAT3(lzo1a_,COMPRESS_ID,_compress)
|
||||
|
||||
#define LZO_COMPRESS_FUNC \
|
||||
LZO_PP_ECONCAT3(_lzo1a_,COMPRESS_ID,_compress_func)
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return _lzo1a_do_compress(in,in_len,out,out_len,wrkmem,do_compress);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,228 @@
|
|||
/* lzo1a_cm.ch -- implementation of the LZO1A compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// code the match in LZO1 compatible format
|
||||
************************************************************************/
|
||||
|
||||
#define THRESHOLD (M2_MIN_LEN - 1)
|
||||
#define MSIZE LZO_SIZE(M2L_BITS)
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if (DD_BITS == 0)
|
||||
|
||||
/* we already matched M2_MIN_LEN bytes,
|
||||
* m_pos also already advanced M2_MIN_LEN bytes */
|
||||
ip += M2_MIN_LEN;
|
||||
assert(m_pos < ip);
|
||||
|
||||
/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
|
||||
* to see if we get more than a M2 match */
|
||||
#define M2_OR_M3 (MATCH_M2)
|
||||
|
||||
#else /* (DD_BITS == 0) */
|
||||
|
||||
/* we already matched m_len bytes */
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
ip += m_len;
|
||||
assert(ip <= in_end);
|
||||
|
||||
#define M2_OR_M3 (m_len <= M2_MAX_LEN)
|
||||
|
||||
#endif /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
if (M2_OR_M3)
|
||||
{
|
||||
/* we've found a short match */
|
||||
assert(ip <= in_end);
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
#if (DD_BITS == 0)
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
--ip; /* ran one too far, point back to non-match */
|
||||
m_len = ip - ii;
|
||||
#endif
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
assert(m_len <= M2_MAX_LEN);
|
||||
|
||||
assert(m_off >= M2_MIN_OFFSET);
|
||||
assert(m_off <= M2_MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
|
||||
/* 2b) code the match */
|
||||
m_off -= M2_MIN_OFFSET;
|
||||
/* code short match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - THRESHOLD) << M2O_BITS) |
|
||||
(m_off & M2O_MASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M2O_BITS);
|
||||
|
||||
|
||||
if (ip >= ip_end)
|
||||
{
|
||||
ii = ip;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
|
||||
#if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
#if 0
|
||||
UPDATE_D(dict,drun,dv,ii,in);
|
||||
#else
|
||||
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
|
||||
#endif
|
||||
MI
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
else
|
||||
|
||||
{
|
||||
/* we've found a long match - see how far we can still go */
|
||||
const lzo_bytep end;
|
||||
|
||||
assert(ip <= in_end);
|
||||
assert(ii == ip - (M2_MAX_LEN + 1));
|
||||
assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
|
||||
|
||||
#if (DD_BITS > 0)
|
||||
assert(m_len == (lzo_uint)(ip-ii));
|
||||
m_pos = ip - m_off;
|
||||
assert(m_pos == m_pos_sav + m_len);
|
||||
#endif
|
||||
|
||||
if (pd(in_end,ip) <= (M3_MAX_LEN - M3_MIN_LEN))
|
||||
end = in_end;
|
||||
else
|
||||
{
|
||||
end = ip + (M3_MAX_LEN - M3_MIN_LEN);
|
||||
assert(end < in_end);
|
||||
}
|
||||
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
assert(ip <= in_end);
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= M3_MIN_LEN);
|
||||
assert(m_len <= M3_MAX_LEN);
|
||||
|
||||
assert(m_off >= M3_MIN_OFFSET);
|
||||
assert(m_off <= M3_MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
|
||||
/* 2b) code the match */
|
||||
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
|
||||
/* code long match flag + low offset bits */
|
||||
*op++ = LZO_BYTE(((MSIZE - 1) << M3O_BITS) | (m_off & M3O_MASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M3O_BITS);
|
||||
/* code match len */
|
||||
*op++ = LZO_BYTE(m_len - M3_MIN_LEN);
|
||||
|
||||
|
||||
if (ip >= ip_end)
|
||||
{
|
||||
ii = ip;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
#if (CLEVEL == 9)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
/* This is not recommended because it can be slow. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
#if 0
|
||||
UPDATE_D(dict,drun,dv,ii,in);
|
||||
#else
|
||||
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
|
||||
#endif
|
||||
MI
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 8)
|
||||
SI DI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 7)
|
||||
SI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 6)
|
||||
SI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 5)
|
||||
SI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 4)
|
||||
SI DI DI DI XI
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ii now points to the start of the next literal run */
|
||||
assert(ii == ip);
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
/* lzo1a_cr.ch -- literal run handling for the the LZO1A algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the LZO package and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1A_CR_H
|
||||
#define __LZO1A_CR_H 1
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// code a literal run
|
||||
************************************************************************/
|
||||
|
||||
static lzo_bytep
|
||||
store_run(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
|
||||
op = oo;
|
||||
ip = ii;
|
||||
assert(r_len > 0);
|
||||
|
||||
/* code a long R0 run */
|
||||
if (r_len >= 512)
|
||||
{
|
||||
unsigned r_bits = 6; /* 256 << 6 == 16384 */
|
||||
lzo_uint tt = 32768u;
|
||||
|
||||
while (r_len >= (t = tt))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = (R0MAX - R0MIN);
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0long_runs++);
|
||||
}
|
||||
tt >>= 1;
|
||||
do {
|
||||
if (r_len >= (t = tt))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0long_runs++);
|
||||
}
|
||||
tt >>= 1;
|
||||
} while (--r_bits > 0);
|
||||
}
|
||||
assert(r_len < 512);
|
||||
|
||||
while (r_len >= (t = R0FAST))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = (R0FAST - R0MIN);
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0fast_runs++);
|
||||
}
|
||||
|
||||
t = r_len;
|
||||
if (t >= R0MIN)
|
||||
{
|
||||
/* code a short R0 run */
|
||||
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
|
||||
MEMCPY_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0short_runs++);
|
||||
}
|
||||
else if (t > 0)
|
||||
{
|
||||
/* code a short literal run */
|
||||
LZO_STATS(lzo_stats->lit_runs++);
|
||||
LZO_STATS(lzo_stats->lit_run[t]++);
|
||||
*op++ = LZO_BYTE(t);
|
||||
MEMCPY_DS(op, ip, t);
|
||||
}
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,144 @@
|
|||
/* lzo1a_de.h -- definitions for the the LZO1A algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the LZO package and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_DEFS_H
|
||||
#define __LZO_DEFS_H 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/*
|
||||
Format of the marker byte
|
||||
|
||||
|
||||
76543210
|
||||
--------
|
||||
00000000 a long literal run ('R0' run) - there are short and long R0 runs
|
||||
000rrrrr a short literal run with len r
|
||||
mmmooooo a short match (len = 2+m, o = offset low bits)
|
||||
111ooooo a long match (o = offset low bits)
|
||||
*/
|
||||
|
||||
|
||||
#define RSIZE (1 << RBITS)
|
||||
#define RMASK (RSIZE - 1)
|
||||
|
||||
#define MBITS (8 - OBITS)
|
||||
#define MSIZE (1 << MBITS)
|
||||
#define MMASK (MSIZE - 1)
|
||||
|
||||
#define OBITS RBITS /* offset and run-length use same bits */
|
||||
#define OSIZE (1 << OBITS)
|
||||
#define OMASK (OSIZE - 1)
|
||||
|
||||
|
||||
/* additional bits for coding the length in a long match */
|
||||
#define LBITS 8
|
||||
#define LSIZE (1 << LBITS)
|
||||
#define LMASK (LSIZE - 1)
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// some macros to improve readability
|
||||
************************************************************************/
|
||||
|
||||
/* Minimum len of a match */
|
||||
#define MIN_MATCH 3
|
||||
#define THRESHOLD (MIN_MATCH - 1)
|
||||
|
||||
/* Min-/Maximum len of a match coded in 2 bytes */
|
||||
#define MIN_MATCH_SHORT (MIN_MATCH)
|
||||
#define MAX_MATCH_SHORT (MIN_MATCH_SHORT + (MSIZE - 2) - 1)
|
||||
/* why (MSIZE - 2) ? because 0 is used to mark runs,
|
||||
* and MSIZE-1 is used to mark a long match */
|
||||
|
||||
/* Min-/Maximum len of a match coded in 3 bytes */
|
||||
#define MIN_MATCH_LONG (MAX_MATCH_SHORT + 1)
|
||||
#define MAX_MATCH_LONG (MIN_MATCH_LONG + LSIZE - 1)
|
||||
|
||||
/* Min-/Maximum offset of a match */
|
||||
#define MIN_OFFSET 1
|
||||
#define MAX_OFFSET (1 << (CHAR_BIT + OBITS))
|
||||
|
||||
|
||||
/* R0 literal run (a long run) */
|
||||
|
||||
#define R0MIN (RSIZE) /* Minimum len of R0 run of literals */
|
||||
#define R0MAX (R0MIN + 255) /* Maximum len of R0 run of literals */
|
||||
#define R0FAST (R0MAX & ~7) /* R0MAX aligned to 8 byte boundary */
|
||||
|
||||
#if (R0MAX - R0FAST != 7) || ((R0FAST & 7) != 0)
|
||||
# error "something went wrong"
|
||||
#endif
|
||||
|
||||
/* 7 special codes from R0FAST+1 .. R0MAX
|
||||
* these codes mean long R0 runs with lengths
|
||||
* 512, 1024, 2048, 4096, 8192, 16384, 32768 */
|
||||
|
||||
|
||||
/*
|
||||
|
||||
RBITS | MBITS MIN THR. MSIZE MAXS MINL MAXL MAXO R0MAX R0FAST
|
||||
======+===============================================================
|
||||
3 | 5 3 2 32 32 33 288 2048 263 256
|
||||
4 | 4 3 2 16 16 17 272 4096 271 264
|
||||
5 | 3 3 2 8 8 9 264 8192 287 280
|
||||
|
||||
*/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define DBITS 13
|
||||
#include "lzo_dict.h"
|
||||
#define DVAL_LEN DVAL_LOOKAHEAD
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_1.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 1
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 1
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_2.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 2
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 2
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_3.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 3
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 3
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_4.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 4
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 2
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_5.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 5
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 3
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_6.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 6
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 5
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_7.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 7
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 3
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_8.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 8
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 8
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1b_9.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 9
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 9
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/* lzo1b_99.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 99
|
||||
|
||||
#define DDBITS 3
|
||||
#define CLEVEL 9
|
||||
|
||||
#define D_BITS 16
|
||||
#define MATCH_IP_END in_end
|
||||
#include "compr1b.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,350 @@
|
|||
/* lzo1b_9x.c -- implementation of the LZO1B-999 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1b.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define SWD_N 0xffffL /* size of ring buffer */
|
||||
#define SWD_THRESHOLD 2 /* lower limit for match length */
|
||||
#define SWD_F 2048 /* upper limit for match length */
|
||||
|
||||
|
||||
#define LZO1B 1
|
||||
#define LZO_COMPRESS_T lzo1b_999_t
|
||||
#define lzo_swd_t lzo1b_999_swd_t
|
||||
#include "lzo_mchw.ch"
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static lzo_bytep
|
||||
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
|
||||
{
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
assert(m_off >= M2_MIN_OFFSET);
|
||||
|
||||
m_off -= M2_MIN_OFFSET;
|
||||
/* code match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
|
||||
(m_off & M2O_MASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M2O_BITS);
|
||||
c->m2_m++;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(m_len >= M3_MIN_LEN);
|
||||
assert(m_off <= M3_MAX_OFFSET);
|
||||
|
||||
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
|
||||
/* code match len */
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
|
||||
else
|
||||
{
|
||||
assert(m_len >= M4_MIN_LEN);
|
||||
/* code M4 match len flag */
|
||||
*op++ = M4_MARKER;
|
||||
/* code match len */
|
||||
m_len -= M4_MIN_LEN - 1;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
/* code low offset bits */
|
||||
*op++ = LZO_BYTE(m_off & M3O_MASK);
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M3O_BITS);
|
||||
|
||||
c->r1_m_len = 0;
|
||||
c->m3_m++;
|
||||
}
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// this is a public function, but there is no prototype in a header file
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain );
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ii;
|
||||
lzo_uint lit;
|
||||
lzo_uint m_len, m_off;
|
||||
LZO_COMPRESS_T cc;
|
||||
LZO_COMPRESS_T * const c = &cc;
|
||||
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
|
||||
int r;
|
||||
|
||||
/* sanity check */
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1B_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
|
||||
c->init = 0;
|
||||
c->ip = c->in = in;
|
||||
c->in_end = in + in_len;
|
||||
c->cb = cb;
|
||||
c->r1_r = c->m3_r = c->m2_m = c->m3_m = 0;
|
||||
|
||||
op = out;
|
||||
ii = c->ip; /* point to start of literal run */
|
||||
lit = 0;
|
||||
c->r1_m_len = 0;
|
||||
|
||||
r = init_match(c,swd,NULL,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
if (max_chain > 0)
|
||||
swd->max_chain = max_chain;
|
||||
|
||||
r = find_match(c,swd,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
while (c->look > 0)
|
||||
{
|
||||
int lazy_match_min_gain = -1;
|
||||
lzo_uint ahead = 0;
|
||||
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
|
||||
#if 0
|
||||
printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
|
||||
m_len, m_off);
|
||||
#endif
|
||||
|
||||
assert(c->ip - c->look >= in);
|
||||
if (lit == 0)
|
||||
ii = c->ip - c->look;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
assert(swd->b_char == *(c->ip - c->look));
|
||||
|
||||
if ((m_len < M2_MIN_LEN) ||
|
||||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
|
||||
{
|
||||
m_len = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(c->ip - c->look - m_off >= in);
|
||||
assert(c->ip - c->look - m_off + m_len < c->ip);
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
|
||||
if (lit > 0)
|
||||
{
|
||||
/* we have a current literal run: do not try a lazy match,
|
||||
if the literal could be coded into a r1 match */
|
||||
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
|
||||
lazy_match_min_gain = -1;
|
||||
else
|
||||
lazy_match_min_gain = 1;
|
||||
|
||||
#if (M2_MIN_LEN == 2)
|
||||
if (m_len == 2)
|
||||
{
|
||||
/* don't code a match of len 2 if we have to
|
||||
code a literal run. Code a literal instead. */
|
||||
m_len = 0;
|
||||
}
|
||||
#endif
|
||||
#if (M2_MIN_LEN == M3_MIN_LEN)
|
||||
if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
|
||||
{
|
||||
/* don't code a M3 match of len 3 if we have to
|
||||
code a literal run. Code a literal instead. */
|
||||
m_len = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
/* no current literal run: only try a lazy match,
|
||||
if the literal could be coded into a r1 match */
|
||||
if (c->r1_m_len == M2_MIN_LEN)
|
||||
lazy_match_min_gain = 0;
|
||||
else
|
||||
lazy_match_min_gain = -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* try a lazy match */
|
||||
if (m_len == 0)
|
||||
lazy_match_min_gain = -1;
|
||||
if (lazy_match_min_gain >= 0 && c->look > m_len)
|
||||
{
|
||||
assert(m_len > 0);
|
||||
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
assert(c->look > 0);
|
||||
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
|
||||
c->m_off > M2_MAX_OFFSET)
|
||||
lazy_match_min_gain += 1;
|
||||
|
||||
if (c->m_len >= m_len + lazy_match_min_gain)
|
||||
{
|
||||
c->lazy++;
|
||||
#if !defined(NDEBUG)
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
#endif
|
||||
lit++;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
ahead = 1;
|
||||
assert(ii + lit + 1 == c->ip - c->look);
|
||||
}
|
||||
assert(m_len > 0);
|
||||
}
|
||||
assert(ii + lit + ahead == c->ip - c->look);
|
||||
|
||||
|
||||
if (m_len == 0)
|
||||
{
|
||||
/* a literal */
|
||||
lit++;
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 1 - store run */
|
||||
if (lit > 0)
|
||||
{
|
||||
/* code current literal run */
|
||||
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
|
||||
{
|
||||
/* Code a context sensitive R1 match. */
|
||||
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
|
||||
op[-2] &= M2O_MASK;
|
||||
assert((op[-2] >> M2O_BITS) == 0);
|
||||
/* copy 1 literal */
|
||||
*op++ = *ii++;
|
||||
assert(ii + ahead == c->ip - c->look);
|
||||
c->r1_r++;
|
||||
}
|
||||
else
|
||||
{
|
||||
op = STORE_RUN(op,ii,lit);
|
||||
}
|
||||
if (lit < R0FAST)
|
||||
c->r1_m_len = m_len;
|
||||
else
|
||||
c->r1_m_len = 0;
|
||||
lit = 0;
|
||||
}
|
||||
else
|
||||
c->r1_m_len = 0;
|
||||
|
||||
/* 2 - code match */
|
||||
op = code_match(c,op,m_len,m_off);
|
||||
r = find_match(c,swd,m_len,1+ahead);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
}
|
||||
|
||||
|
||||
/* store final run */
|
||||
if (lit > 0)
|
||||
op = STORE_RUN(op,ii,lit);
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
*op++ = M3_MARKER | 1;
|
||||
*op++ = 0;
|
||||
*op++ = 0;
|
||||
#endif
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
assert(c->textsize == in_len);
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
if (c->cb && c->cb->nprogress)
|
||||
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
|
||||
|
||||
#if 0
|
||||
printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n",
|
||||
(long) c->textsize, (long)in_len, (long) c->codesize,
|
||||
c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy);
|
||||
#endif
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1b_999_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return lzo1b_999_compress_callback(in,in_len,out,out_len,wrkmem,
|
||||
(lzo_callback_p) 0, 0);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,262 @@
|
|||
/* lzo1b_c.ch -- implementation of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(LZO_HAVE_R1) && !defined(LZO_NO_R1)
|
||||
# define LZO_HAVE_R1 1
|
||||
#endif
|
||||
|
||||
#if !defined(LZO_HAVE_M3) && !defined(LZO_NO_M3)
|
||||
# if (M3O_BITS < 8)
|
||||
# define LZO_HAVE_M3 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
#define MI /*empty*/
|
||||
#define SI MI
|
||||
#if (DD_BITS > 0)
|
||||
#define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,drun,dv,ii,in); MI
|
||||
#define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip));
|
||||
#else
|
||||
#define DI ++ii; DINDEX1(dindex,ii); UPDATE_I(dict,0,dindex,ii,in); MI
|
||||
#define XI assert(ii < ip); ii = ip;
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compress a block of data.
|
||||
//
|
||||
// I really apologize for this spaghetti code.
|
||||
************************************************************************/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
LZO_PRIVATE(int)
|
||||
do_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
const lzo_bytep ip;
|
||||
#if (DD_BITS > 0)
|
||||
#if defined(__LZO_HASH_INCREMENTAL)
|
||||
lzo_xint dv;
|
||||
#endif
|
||||
unsigned drun = 0;
|
||||
#endif
|
||||
lzo_bytep op;
|
||||
const lzo_bytep const in_end = in + in_len;
|
||||
const lzo_bytep const ip_end = in + in_len - MIN_LOOKAHEAD;
|
||||
const lzo_bytep ii;
|
||||
#if defined(LZO_HAVE_R1)
|
||||
const lzo_bytep r1 = ip_end; /* pointer for R1 match (none yet) */
|
||||
#endif
|
||||
#if defined(LZO_HAVE_M3)
|
||||
lzo_bytep m3 = out + 1; /* pointer after last m3/m4 match */
|
||||
#endif
|
||||
|
||||
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->r_bits = R_BITS;
|
||||
lzo_stats->m3o_bits = M3O_BITS;
|
||||
lzo_stats->dd_bits = DD_BITS;
|
||||
lzo_stats->clevel = CLEVEL;
|
||||
lzo_stats->d_bits = D_BITS;
|
||||
lzo_stats->min_lookahead = MIN_LOOKAHEAD;
|
||||
lzo_stats->max_lookbehind = MAX_LOOKBEHIND;
|
||||
lzo_stats->compress_id = LZO_PP_MACRO_EXPAND(COMPRESS_ID);
|
||||
#endif
|
||||
|
||||
/* init dictionary */
|
||||
#if (LZO_DETERMINISTIC)
|
||||
BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE);
|
||||
#endif
|
||||
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
ii = ip; /* point to start of current literal run */
|
||||
|
||||
|
||||
#if (DD_BITS > 0)
|
||||
DVAL_FIRST(dv,ip);
|
||||
UPDATE_D(dict,drun,dv,ip,in);
|
||||
ip++;
|
||||
DVAL_NEXT(dv,ip);
|
||||
#else
|
||||
ip++;
|
||||
#endif
|
||||
|
||||
assert(ip < ip_end);
|
||||
for (;;)
|
||||
{
|
||||
const lzo_bytep m_pos;
|
||||
#if !defined(NDEBUG)
|
||||
const lzo_bytep m_pos_sav = NULL;
|
||||
#endif
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
|
||||
#if (DD_BITS == 0)
|
||||
lzo_uint dindex;
|
||||
#endif
|
||||
lzo_uint m_len;
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// search for a match
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(LZO_SEARCH_MATCH_INCLUDE_FILE)
|
||||
# define LZO_SEARCH_MATCH_INCLUDE_FILE "lzo1b_sm.ch"
|
||||
#endif
|
||||
|
||||
#include LZO_SEARCH_MATCH_INCLUDE_FILE
|
||||
|
||||
|
||||
#if !defined(LZO_TEST_MATCH_INCLUDE_FILE)
|
||||
# define LZO_TEST_MATCH_INCLUDE_FILE "lzo1b_tm.ch"
|
||||
#endif
|
||||
|
||||
#include LZO_TEST_MATCH_INCLUDE_FILE
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// found a literal
|
||||
************************************************************************/
|
||||
|
||||
|
||||
/* a literal */
|
||||
literal:
|
||||
#if (DD_BITS == 0)
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
#endif
|
||||
if (++ip >= ip_end)
|
||||
break;
|
||||
#if (DD_BITS > 0)
|
||||
DVAL_NEXT(dv,ip);
|
||||
#endif
|
||||
continue;
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// found a match
|
||||
************************************************************************/
|
||||
|
||||
match:
|
||||
#if (DD_BITS == 0)
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
#endif
|
||||
/* we have found a match of at least M2_MIN_LEN */
|
||||
|
||||
|
||||
#if !defined(LZO_CODE_RUN_INCLUDE_FILE)
|
||||
# define LZO_CODE_RUN_INCLUDE_FILE "lzo1b_cr.ch"
|
||||
#endif
|
||||
|
||||
#include LZO_CODE_RUN_INCLUDE_FILE
|
||||
|
||||
|
||||
/* ii now points to the start of the current match */
|
||||
assert(ii == ip);
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// code the match
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(LZO_CODE_MATCH_INCLUDE_FILE)
|
||||
# define LZO_CODE_MATCH_INCLUDE_FILE "lzo1b_cm.ch"
|
||||
#endif
|
||||
|
||||
#include LZO_CODE_MATCH_INCLUDE_FILE
|
||||
|
||||
|
||||
/* ii now points to the start of the next literal run */
|
||||
assert(ii == ip);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// end of block
|
||||
************************************************************************/
|
||||
|
||||
assert(ip <= in_end);
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
{
|
||||
lzo_uint i;
|
||||
const lzo_bytep p;
|
||||
|
||||
for (i = 0; i < D_SIZE; i++)
|
||||
{
|
||||
p = dict[i];
|
||||
if (BOUNDS_CHECKING_OFF_IN_EXPR(p == NULL || p < in || p > in_end))
|
||||
lzo_stats->unused_dict_entries++;
|
||||
}
|
||||
lzo_stats->unused_dict_entries_percent =
|
||||
100.0 * lzo_stats->unused_dict_entries / D_SIZE;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
/* return if op == out to indicate that we
|
||||
* couldn't compress and didn't copy anything.
|
||||
*/
|
||||
if (op == out)
|
||||
{
|
||||
*out_len = 0;
|
||||
return LZO_E_NOT_COMPRESSIBLE;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* store the final literal run */
|
||||
if (pd(in_end,ii) > 0)
|
||||
{
|
||||
lzo_uint t = pd(in_end,ii);
|
||||
op = STORE_RUN(op,ii,t);
|
||||
}
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OK; /* compression went ok */
|
||||
}
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
/* lzo1b_cc.c -- LZO1B compression internal entry point
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1b.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compression internal entry point.
|
||||
************************************************************************/
|
||||
|
||||
LZO_LOCAL_IMPL(int)
|
||||
_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func )
|
||||
{
|
||||
int r;
|
||||
#if defined(LZO_TEST_COMPRESS_OVERRUN)
|
||||
lzo_uint avail_out = *out_len;
|
||||
#endif
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
_lzo1b_stats_init(lzo_stats);
|
||||
lzo_stats->in_len = in_len;
|
||||
#endif
|
||||
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
{
|
||||
*out_len = 0;
|
||||
r = LZO_E_OK;
|
||||
}
|
||||
else if (in_len <= MIN_LOOKAHEAD + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
*out_len = 0;
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(STORE_RUN(out,in,in_len), out);
|
||||
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = func(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
#if defined(LZO_TEST_COMPRESS_OVERRUN)
|
||||
if (r == LZO_E_OK && avail_out - *out_len < 3)
|
||||
r = LZO_E_COMPRESS_OVERRUN;
|
||||
#endif
|
||||
if (r == LZO_E_OK)
|
||||
{
|
||||
lzo_bytep op = out + *out_len;
|
||||
op[0] = M3_MARKER | 1;
|
||||
op[1] = 0;
|
||||
op[2] = 0;
|
||||
*out_len += 3;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->out_len = *out_len;
|
||||
lzo_stats->match_bytes =
|
||||
1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches +
|
||||
3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches;
|
||||
_lzo1b_stats_calc(lzo_stats);
|
||||
#endif
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// note: this is not thread safe, but as it is used for finetuning only
|
||||
// we don't care
|
||||
************************************************************************/
|
||||
|
||||
#undef lzo_stats
|
||||
/* lzo_stats_t is still defined */
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
|
||||
static lzo_stats_t lzo_statistics;
|
||||
lzo_stats_t * const lzo1b_stats = &lzo_statistics;
|
||||
|
||||
|
||||
void _lzo1b_stats_init(lzo_stats_t *lzo_stats)
|
||||
{
|
||||
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
|
||||
}
|
||||
|
||||
|
||||
void _lzo1b_stats_calc(lzo_stats_t *lzo_stats)
|
||||
{
|
||||
lzo_stats->matches =
|
||||
lzo_stats->m1_matches + lzo_stats->m2_matches +
|
||||
lzo_stats->m3_matches + lzo_stats->m4_matches;
|
||||
|
||||
lzo_stats->literal_overhead = lzo_stats->lit_runs +
|
||||
2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs +
|
||||
lzo_stats->r0long_runs);
|
||||
lzo_stats->literal_bytes = lzo_stats->literals +
|
||||
lzo_stats->literal_overhead;
|
||||
|
||||
#if 0
|
||||
assert(lzo_stats->match_bytes + lzo_stats->literal_bytes ==
|
||||
lzo_stats->out_len);
|
||||
#endif
|
||||
|
||||
lzo_stats->m2_matches -= lzo_stats->r1_matches;
|
||||
lzo_stats->m2_match[M2_MIN_LEN] -= lzo_stats->r1_matches;
|
||||
|
||||
if (lzo_stats->literals > 0)
|
||||
lzo_stats->literal_overhead_percent =
|
||||
100.0 * lzo_stats->literal_overhead / lzo_stats->literals;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
/* lzo1b_cc.h -- definitions for the the LZO1B compression driver
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1B_CC_H
|
||||
#define __LZO1B_CC_H 1
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
extern const lzo_compress_t _lzo1b_1_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_2_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_3_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_4_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_5_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_6_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_7_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_8_compress_func;
|
||||
extern const lzo_compress_t _lzo1b_9_compress_func;
|
||||
|
||||
extern const lzo_compress_t _lzo1b_99_compress_func;
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_LOCAL_DECL(lzo_bytep )
|
||||
_lzo1b_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
|
||||
lzo_uint r_len);
|
||||
|
||||
#define STORE_RUN _lzo1b_store_run
|
||||
|
||||
|
||||
LZO_LOCAL_DECL(int)
|
||||
_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func );
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,280 @@
|
|||
/* lzo1b_cm.ch -- implementation of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// code the match
|
||||
************************************************************************/
|
||||
|
||||
#if (DD_BITS == 0)
|
||||
|
||||
/* we already matched M2_MIN_LEN bytes,
|
||||
* m_pos also already advanced M2_MIN_LEN bytes */
|
||||
ip += M2_MIN_LEN;
|
||||
assert(m_pos < ip);
|
||||
|
||||
/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
|
||||
* to see if we get more than a M2 match */
|
||||
#define M2_OR_M3 (MATCH_M2)
|
||||
|
||||
#else /* (DD_BITS == 0) */
|
||||
|
||||
/* we already matched m_len bytes */
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
ip += m_len;
|
||||
assert(ip <= in_end);
|
||||
|
||||
#define M2_OR_M3 (m_len <= M2_MAX_LEN)
|
||||
|
||||
#endif /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
|
||||
if (M2_OR_M3)
|
||||
{
|
||||
/* we've found a M2 or M3 match */
|
||||
assert(ip <= in_end);
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
#if (DD_BITS == 0)
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
--ip; /* ran one too far, point back to non-match */
|
||||
m_len = pd(ip, ii);
|
||||
#endif
|
||||
|
||||
/* 2a2) verify match parameters */
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
assert(m_len <= M2_MAX_LEN);
|
||||
assert(m_len <= M3_MAX_LEN);
|
||||
|
||||
assert(m_off >= M2_MIN_OFFSET);
|
||||
assert(m_off >= M3_MIN_OFFSET);
|
||||
assert(m_off <= M3_MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
|
||||
/* 2b) code the match */
|
||||
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
|
||||
if (m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
#else
|
||||
assert(m_off <= M2_MAX_OFFSET);
|
||||
#endif
|
||||
m_off -= M2_MIN_OFFSET;
|
||||
/* code match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
|
||||
(m_off & M2O_MASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M2O_BITS);
|
||||
LZO_STATS(lzo_stats->m2_matches++);
|
||||
LZO_STATS(lzo_stats->m2_match[m_len]++);
|
||||
#if (_M2_MAX_OFFSET != _M3_MAX_OFFSET)
|
||||
}
|
||||
else
|
||||
{
|
||||
#if defined(LZO_HAVE_R1)
|
||||
#if (M3_MIN_LEN == M2_MIN_LEN)
|
||||
r1 = ip_end; /* invalidate R1 pointer */
|
||||
#endif
|
||||
#endif
|
||||
assert(m_len >= M3_MIN_LEN);
|
||||
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
|
||||
/* code match len */
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
|
||||
/* code low offset bits */
|
||||
*op++ = LZO_BYTE(m_off & M3O_MASK);
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M3O_BITS);
|
||||
LZO_STATS(lzo_stats->m3_matches++);
|
||||
LZO_STATS(lzo_stats->m3_match[m_len]++);
|
||||
#if defined(LZO_HAVE_M3)
|
||||
m3 = op; /* set M3 pointer */
|
||||
#endif
|
||||
}
|
||||
#endif /* (_M2_MAX_OFFSET != _M3_MAX_OFFSET) */
|
||||
|
||||
|
||||
if (ip >= ip_end)
|
||||
{
|
||||
ii = ip;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
|
||||
#if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
#if 0
|
||||
UPDATE_D(dict,drun,dv,ii,in);
|
||||
#else
|
||||
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
|
||||
#endif
|
||||
MI
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
else
|
||||
|
||||
{
|
||||
/* we've found a M3 or M4 match - see how far we can still go */
|
||||
assert(ip <= in_end);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0);
|
||||
|
||||
/* 2a) compute match parameters */
|
||||
#if !defined(MATCH_IP_END)
|
||||
assert(ii == ip - (M2_MAX_LEN + 1));
|
||||
#if (DD_BITS > 0)
|
||||
assert(m_len == (lzo_uint)(ip-ii));
|
||||
m_pos = ip - m_off;
|
||||
assert(m_pos == m_pos_sav + m_len);
|
||||
#endif
|
||||
{
|
||||
const lzo_bytep end;
|
||||
end = in_end;
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
assert(ip <= in_end);
|
||||
m_len = pd(ip, ii);
|
||||
}
|
||||
assert(pd(ip,m_pos) == m_off);
|
||||
#endif
|
||||
|
||||
/* 2a2) verify match parameters */
|
||||
assert(m_len >= M3_MIN_LEN);
|
||||
|
||||
assert(m_off >= M3_MIN_OFFSET);
|
||||
assert(m_off >= M4_MIN_OFFSET);
|
||||
assert(m_off <= M3_MAX_OFFSET);
|
||||
assert(m_off <= M4_MAX_OFFSET);
|
||||
assert(ii-m_off == m_pos_sav);
|
||||
assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0);
|
||||
|
||||
/* 2b) code the match */
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
{
|
||||
/* code match len */
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
|
||||
LZO_STATS(lzo_stats->m3_matches++);
|
||||
LZO_STATS(lzo_stats->m3_match[m_len]++);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(m_len >= M4_MIN_LEN);
|
||||
/* code M4 match len flag */
|
||||
*op++ = M4_MARKER;
|
||||
/* code match len */
|
||||
m_len -= M4_MIN_LEN - 1;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
LZO_STATS(lzo_stats->m4_matches++);
|
||||
}
|
||||
|
||||
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
|
||||
/* code low offset bits */
|
||||
*op++ = LZO_BYTE(m_off & M3O_MASK);
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M3O_BITS);
|
||||
|
||||
#if defined(LZO_HAVE_M3)
|
||||
m3 = op; /* set M3 pointer */
|
||||
#endif
|
||||
|
||||
|
||||
if (ip >= ip_end)
|
||||
{
|
||||
ii = ip;
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* 2c) Insert phrases (beginning with ii+1) into the dictionary. */
|
||||
#if (CLEVEL == 9)
|
||||
/* Insert the whole match (ii+1)..(ip-1) into dictionary. */
|
||||
/* This is not recommended because it can be slow. */
|
||||
++ii;
|
||||
do {
|
||||
DVAL_NEXT(dv,ii);
|
||||
#if 0
|
||||
UPDATE_D(dict,drun,dv,ii,in);
|
||||
#else
|
||||
dict[ DINDEX(dv,ii) ] = DENTRY(ii,in);
|
||||
#endif
|
||||
MI
|
||||
} while (++ii < ip);
|
||||
DVAL_NEXT(dv,ii);
|
||||
assert(ii == ip);
|
||||
DVAL_ASSERT(dv,ip);
|
||||
#elif (CLEVEL >= 8)
|
||||
SI DI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 7)
|
||||
SI DI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 6)
|
||||
SI DI DI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 5)
|
||||
SI DI DI DI DI XI
|
||||
#elif (CLEVEL >= 4)
|
||||
SI DI DI DI XI
|
||||
#elif (CLEVEL >= 3)
|
||||
SI DI DI XI
|
||||
#elif (CLEVEL >= 2)
|
||||
SI DI XI
|
||||
#else
|
||||
XI
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ii now points to the start of the next literal run */
|
||||
assert(ii == ip);
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
/* lzo1b_cr.ch -- implementation of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// store the current literal run
|
||||
************************************************************************/
|
||||
|
||||
assert(ip < ip_end);
|
||||
if (pd(ip,ii) > 0)
|
||||
{
|
||||
lzo_uint t = pd(ip,ii);
|
||||
|
||||
#if defined(LZO_HAVE_R1)
|
||||
if (ip == r1)
|
||||
{
|
||||
/* Code a context sensitive R1 match. */
|
||||
LZO_STATS(lzo_stats->literals += t);
|
||||
LZO_STATS(lzo_stats->r1_matches++);
|
||||
assert(t == 1);
|
||||
/* modify marker byte */
|
||||
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
|
||||
op[-2] &= M2O_MASK;
|
||||
assert((op[-2] >> M2O_BITS) == 0);
|
||||
/* copy 1 literal */
|
||||
*op++ = *ii++;
|
||||
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (t < R0MIN)
|
||||
{
|
||||
/* inline the copying of a short run */
|
||||
LZO_STATS(lzo_stats->literals += t);
|
||||
LZO_STATS(lzo_stats->lit_runs++);
|
||||
LZO_STATS(lzo_stats->lit_run[t]++);
|
||||
#if defined(LZO_HAVE_M3)
|
||||
if (t < LZO_SIZE(8-M3O_BITS) && op == m3)
|
||||
{
|
||||
/* Code a very short literal run into the low offset bits
|
||||
* of the previous M3/M4 match.
|
||||
*/
|
||||
LZO_STATS(lzo_stats->lit_runs_after_m3_match++);
|
||||
LZO_STATS(lzo_stats->lit_run_after_m3_match[t]++);
|
||||
assert((m3[-2] >> M3O_BITS) == 0);
|
||||
m3[-2] = LZO_BYTE(m3[-2] | (t << M3O_BITS));
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
*op++ = LZO_BYTE(t);
|
||||
}
|
||||
MEMCPY_DS(op, ii, t);
|
||||
#if defined(LZO_HAVE_R1)
|
||||
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
|
||||
#endif
|
||||
}
|
||||
else if (t < R0FAST)
|
||||
{
|
||||
/* inline the copying of a short R0 run */
|
||||
LZO_STATS(lzo_stats->literals += t);
|
||||
LZO_STATS(lzo_stats->r0short_runs++);
|
||||
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
|
||||
MEMCPY_DS(op, ii, t);
|
||||
#if defined(LZO_HAVE_R1)
|
||||
r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
op = STORE_RUN(op,ii,t);
|
||||
ii = ip;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ii now points to the start of the current match */
|
||||
assert(ii == ip);
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,268 @@
|
|||
/* lzo1b_d.ch -- implementation of the LZO1B decompression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo1_d.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// decompress a block of data.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
const lzo_bytep m_pos;
|
||||
|
||||
const lzo_bytep const ip_end = in + in_len;
|
||||
#if defined(HAVE_ANY_OP)
|
||||
lzo_bytep const op_end = out + *out_len;
|
||||
#endif
|
||||
|
||||
LZO_UNUSED(wrkmem);
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
|
||||
while (TEST_IP_AND_TEST_OP)
|
||||
{
|
||||
t = *ip++; /* get marker */
|
||||
|
||||
if (t < R0MIN) /* a literal run */
|
||||
{
|
||||
if (t == 0) /* a R0 literal run */
|
||||
{
|
||||
NEED_IP(1);
|
||||
t = *ip++;
|
||||
if (t >= R0FAST - R0MIN) /* a long R0 run */
|
||||
{
|
||||
t -= R0FAST - R0MIN;
|
||||
if (t == 0)
|
||||
t = R0FAST;
|
||||
else
|
||||
{
|
||||
#if 0
|
||||
t = 256u << ((unsigned) t);
|
||||
#else
|
||||
/* help the optimizer */
|
||||
lzo_uint tt = 256;
|
||||
do tt <<= 1; while (--t > 0);
|
||||
t = tt;
|
||||
#endif
|
||||
}
|
||||
|
||||
NEED_IP(t); NEED_OP(t);
|
||||
#if 1 && (LZO_OPT_UNALIGNED32)
|
||||
do {
|
||||
UA_COPY4(op+0, ip+0);
|
||||
UA_COPY4(op+4, ip+4);
|
||||
op += 8; ip += 8;
|
||||
t -= 8;
|
||||
} while (t > 0);
|
||||
#else
|
||||
MEMCPY8_DS(op,ip,t);
|
||||
#endif
|
||||
continue;
|
||||
}
|
||||
t += R0MIN; /* a short R0 run */
|
||||
}
|
||||
|
||||
NEED_IP(t); NEED_OP(t);
|
||||
/* copy literal run */
|
||||
#if 1 && (LZO_OPT_UNALIGNED32)
|
||||
if (t >= 4)
|
||||
{
|
||||
do {
|
||||
UA_COPY4(op, ip);
|
||||
op += 4; ip += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
#if (M3O_BITS < 7)
|
||||
literal1:
|
||||
#endif
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
|
||||
#if (M3O_BITS == 7)
|
||||
literal2:
|
||||
#endif
|
||||
|
||||
/* after a literal a match must follow */
|
||||
while (TEST_IP_AND_TEST_OP)
|
||||
{
|
||||
t = *ip++; /* get R1 marker */
|
||||
if (t >= R0MIN)
|
||||
goto match;
|
||||
|
||||
NEED_IP(2); NEED_OP(M2_MIN_LEN + 1);
|
||||
|
||||
/* R1 match - a M2_MIN_LEN match + 1 byte literal */
|
||||
assert((t & M2O_MASK) == t);
|
||||
m_pos = op - M2_MIN_OFFSET;
|
||||
m_pos -= t | (((lzo_uint) *ip++) << M2O_BITS);
|
||||
assert(m_pos >= out); assert(m_pos < op);
|
||||
TEST_LB(m_pos);
|
||||
COPY_M2;
|
||||
*op++ = *ip++;
|
||||
}
|
||||
|
||||
#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
match:
|
||||
|
||||
if (t >= M2_MARKER) /* a M2 match */
|
||||
{
|
||||
/* get match offset */
|
||||
NEED_IP(1);
|
||||
m_pos = op - M2_MIN_OFFSET;
|
||||
m_pos -= (t & M2O_MASK) | (((lzo_uint) *ip++) << M2O_BITS);
|
||||
assert(m_pos >= out); assert(m_pos < op);
|
||||
TEST_LB(m_pos);
|
||||
|
||||
/* get match len */
|
||||
t = (t >> M2O_BITS) - 1;
|
||||
NEED_OP(t + M2_MIN_LEN - 1);
|
||||
COPY_M2X;
|
||||
MEMCPY_DS(op,m_pos,t);
|
||||
}
|
||||
else /* a M3 or M4 match */
|
||||
{
|
||||
/* get match len */
|
||||
t &= M3L_MASK;
|
||||
if (t == 0) /* a M4 match */
|
||||
{
|
||||
NEED_IP(1);
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_OV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += (M4_MIN_LEN - M3_MIN_LEN) + *ip++;
|
||||
}
|
||||
|
||||
/* get match offset */
|
||||
NEED_IP(2);
|
||||
m_pos = op - (M3_MIN_OFFSET - M3_EOF_OFFSET);
|
||||
m_pos -= *ip++ & M3O_MASK;
|
||||
m_pos -= (lzo_uint)(*ip++) << M3O_BITS;
|
||||
#if defined(LZO_EOF_CODE)
|
||||
if (m_pos == op)
|
||||
goto eof_found;
|
||||
#endif
|
||||
|
||||
/* copy match */
|
||||
assert(m_pos >= out); assert(m_pos < op);
|
||||
TEST_LB(m_pos); NEED_OP(t + M3_MIN_LEN - 1);
|
||||
#if (LZO_OPT_UNALIGNED32)
|
||||
if (t >= 2 * 4 - (M3_MIN_LEN - 1) && (op - m_pos) >= 4)
|
||||
{
|
||||
UA_COPY4(op, m_pos);
|
||||
op += 4; m_pos += 4; t -= 4 - (M3_MIN_LEN - 1);
|
||||
do {
|
||||
UA_COPY4(op, m_pos);
|
||||
op += 4; m_pos += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *m_pos++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
COPY_M3X;
|
||||
MEMCPY_DS(op,m_pos,t);
|
||||
}
|
||||
|
||||
|
||||
#if (M3O_BITS < 7)
|
||||
t = ip[-2] >> M3O_BITS;
|
||||
if (t)
|
||||
{
|
||||
NEED_IP(t); NEED_OP(t);
|
||||
goto literal1;
|
||||
}
|
||||
#elif (M3O_BITS == 7)
|
||||
/* optimized version */
|
||||
if (ip[-2] & (1 << M3O_BITS))
|
||||
{
|
||||
NEED_IP(1); NEED_OP(1);
|
||||
*op++ = *ip++;
|
||||
goto literal2;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
|
||||
/* no EOF code was found */
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_EOF_NOT_FOUND;
|
||||
#endif
|
||||
|
||||
eof_found:
|
||||
assert(t == 1);
|
||||
#endif
|
||||
*out_len = pd(op, out);
|
||||
return (ip == ip_end ? LZO_E_OK :
|
||||
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
||||
|
||||
|
||||
#if defined(HAVE_NEED_IP)
|
||||
input_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_INPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_NEED_OP)
|
||||
output_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OUTPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
|
||||
lookbehind_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_LOOKBEHIND_OVERRUN;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* lzo1b_d1.c -- LZO1B decompression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1b.h"
|
||||
|
||||
#undef LZO_TEST_OVERRUN
|
||||
#define DO_DECOMPRESS lzo1b_decompress
|
||||
|
||||
#include "lzo1b_d.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* lzo1b_d2.c -- LZO1B decompression with overrun testing
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1b.h"
|
||||
|
||||
#define LZO_TEST_OVERRUN 1
|
||||
#define DO_DECOMPRESS lzo1b_decompress_safe
|
||||
|
||||
#include "lzo1b_d.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,330 @@
|
|||
/* lzo1b_de.h -- definitions for the the LZO1B/LZO1C algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO_DEFS_H
|
||||
#define __LZO_DEFS_H 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
/*
|
||||
Format of the marker byte
|
||||
|
||||
76543210
|
||||
--------
|
||||
00000000 R0 - a long literal run ('R0' run)
|
||||
000rrrrr R - a short literal run with len r
|
||||
00100000 M4 - a very long match
|
||||
001mmmmm M3 - a long match (len = m+M3_MIN_LEN)
|
||||
mmmooooo M2 - a short match (len = m+M2_MIN_LEN, o = offset low bits)
|
||||
|
||||
M1 is not used !
|
||||
*/
|
||||
|
||||
|
||||
#ifndef R_BITS
|
||||
#define R_BITS (5)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef M1L_BITS
|
||||
#define M1L_BITS (0)
|
||||
#endif
|
||||
#ifndef M2L_BITS
|
||||
#define M2L_BITS (CHAR_BIT - M2O_BITS)
|
||||
#endif
|
||||
#ifndef M3L_BITS
|
||||
#define M3L_BITS (R_BITS)
|
||||
#endif
|
||||
#ifndef M4L_BITS
|
||||
#define M4L_BITS (CHAR_BIT)
|
||||
#endif
|
||||
|
||||
#ifndef M1O_BITS
|
||||
#define M1O_BITS (6)
|
||||
#endif
|
||||
#ifndef M2O_BITS
|
||||
#define M2O_BITS (R_BITS)
|
||||
#endif
|
||||
#ifndef M3O_BITS
|
||||
#define M3O_BITS (CHAR_BIT)
|
||||
#endif
|
||||
#ifndef M4O_BITS
|
||||
#define M4O_BITS (M3O_BITS) /* must be the same */
|
||||
#endif
|
||||
|
||||
#ifndef M1X_BITS
|
||||
#define M1X_BITS (M1O_BITS)
|
||||
#endif
|
||||
#ifndef M2X_BITS
|
||||
#define M2X_BITS (M2O_BITS + CHAR_BIT)
|
||||
#endif
|
||||
#ifndef M3X_BITS
|
||||
#define M3X_BITS (M3O_BITS + CHAR_BIT)
|
||||
#endif
|
||||
#ifndef M4X_BITS
|
||||
#define M4X_BITS M3X_BITS
|
||||
#endif
|
||||
|
||||
|
||||
#define __MIN_OFFSET(bits) 1
|
||||
#define __MAX_OFFSET(bits) LZO_SIZE(bits)
|
||||
|
||||
#define M1_MIN_OFFSET __MIN_OFFSET(M1X_BITS)
|
||||
#define M2_MIN_OFFSET __MIN_OFFSET(M2X_BITS)
|
||||
#define M3_MIN_OFFSET __MIN_OFFSET(M3X_BITS)
|
||||
#define M4_MIN_OFFSET M3_MIN_OFFSET
|
||||
|
||||
#if defined(LZO_EOF_CODE) && !defined(M3_EOF_OFFSET)
|
||||
#define M3_EOF_OFFSET 1
|
||||
#else
|
||||
#define M3_EOF_OFFSET 0
|
||||
#endif
|
||||
|
||||
#ifndef _M1_MAX_OFFSET
|
||||
#define _M1_MAX_OFFSET __MAX_OFFSET(M1X_BITS)
|
||||
#endif
|
||||
#ifndef _M2_MAX_OFFSET
|
||||
#define _M2_MAX_OFFSET __MAX_OFFSET(M2X_BITS)
|
||||
#endif
|
||||
#ifndef _M3_MAX_OFFSET
|
||||
#define _M3_MAX_OFFSET (__MAX_OFFSET(M3X_BITS) - M3_EOF_OFFSET)
|
||||
#endif
|
||||
#ifndef _M4_MAX_OFFSET
|
||||
#define _M4_MAX_OFFSET _M3_MAX_OFFSET
|
||||
#endif
|
||||
#ifndef _MAX_OFFSET
|
||||
#define _MAX_OFFSET _M4_MAX_OFFSET
|
||||
#endif
|
||||
|
||||
#if (M3_EOF_OFFSET > 0) && (_M2_MAX_OFFSET == _M3_MAX_OFFSET + M3_EOF_OFFSET)
|
||||
# undef _M2_MAX_OFFSET
|
||||
# define _M2_MAX_OFFSET _M3_MAX_OFFSET
|
||||
#endif
|
||||
#if (_M2_MAX_OFFSET > _M3_MAX_OFFSET)
|
||||
# error
|
||||
#endif
|
||||
|
||||
#define M1_MAX_OFFSET ((lzo_uint) _M1_MAX_OFFSET)
|
||||
#define M2_MAX_OFFSET ((lzo_uint) _M2_MAX_OFFSET)
|
||||
#define M3_MAX_OFFSET ((lzo_uint) _M3_MAX_OFFSET)
|
||||
#define M4_MAX_OFFSET ((lzo_uint) _M4_MAX_OFFSET)
|
||||
#define MAX_OFFSET ((lzo_uint) _MAX_OFFSET)
|
||||
|
||||
|
||||
#ifndef M1_MIN_LEN
|
||||
#define M1_MIN_LEN (2)
|
||||
#endif
|
||||
#ifndef M2_MIN_LEN
|
||||
#define M2_MIN_LEN (3)
|
||||
#endif
|
||||
#ifndef M3_MIN_LEN
|
||||
#if (M3X_BITS == M2X_BITS)
|
||||
#define M3_MIN_LEN (M2_MAX_LEN + 1)
|
||||
#else
|
||||
#define M3_MIN_LEN (4)
|
||||
#endif
|
||||
#endif
|
||||
#ifndef M4_MIN_LEN
|
||||
#define M4_MIN_LEN (M3_MAX_LEN + 1)
|
||||
#endif
|
||||
|
||||
#ifndef M1_MAX_LEN
|
||||
#define M1_MAX_LEN (M1_MIN_LEN + LZO_SIZE(M1L_BITS) - 1)
|
||||
#endif
|
||||
#ifndef M2_MAX_LEN
|
||||
#define M2_MAX_LEN (M2_MIN_LEN + LZO_SIZE(M2L_BITS) - 3)
|
||||
#endif
|
||||
#ifndef M3_MAX_LEN
|
||||
#define M3_MAX_LEN (M3_MIN_LEN + LZO_SIZE(M3L_BITS) - 2)
|
||||
#endif
|
||||
#ifndef M4_MAX_LEN
|
||||
#define M4_MAX_LEN (ULONG_MAX)
|
||||
#endif
|
||||
|
||||
|
||||
#define M1O_MASK LZO_MASK(M1O_BITS)
|
||||
#define M1L_MASK LZO_MASK(M1L_BITS)
|
||||
#define M2O_MASK LZO_MASK(M2O_BITS)
|
||||
#define M2L_MASK LZO_MASK(M2L_BITS)
|
||||
#define M3O_MASK LZO_MASK(M3O_BITS)
|
||||
#define M3L_MASK LZO_MASK(M3L_BITS)
|
||||
#define M4O_MASK LZO_MASK(M4O_BITS)
|
||||
#define M4L_MASK LZO_MASK(M4L_BITS)
|
||||
|
||||
|
||||
#define M1_MARKER (1 << M1O_BITS)
|
||||
#define M2_MARKER (2 << M2O_BITS)
|
||||
#define M3_MARKER (1 << M3L_BITS)
|
||||
#define M4_MARKER M3_MARKER
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// R0 literal run (a long run)
|
||||
************************************************************************/
|
||||
|
||||
#ifndef R0MIN
|
||||
#define R0MIN (LZO_SIZE(R_BITS)) /* Minimum len of R0 run of literals */
|
||||
#endif
|
||||
#define R0MAX (R0MIN + 256 - 1) /* Maximum len of R0 run of literals */
|
||||
|
||||
#if (R0MAX - (R0MAX & ~7u) >= 7)
|
||||
#define R0FAST (R0MAX & ~7u) /* R0MAX aligned to 8 byte boundary */
|
||||
#else
|
||||
#define R0FAST (R0MAX & ~15u) /* R0MAX aligned to 8 byte boundary */
|
||||
#endif
|
||||
|
||||
#if (R0MAX - R0FAST < 7) || ((R0FAST & 7) != 0)
|
||||
# error "something went wrong"
|
||||
#endif
|
||||
#if (R0FAST * 2 < 512)
|
||||
# error "R0FAST is not big enough"
|
||||
#endif
|
||||
|
||||
/* 7 special codes from R0FAST+1 .. R0MAX
|
||||
* these codes mean long R0 runs with lengths
|
||||
* 512, 1024, 2048, 4096, 8192, 16384, 32768
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// matching
|
||||
************************************************************************/
|
||||
|
||||
#define PS *m_pos++ != *ip++
|
||||
|
||||
|
||||
/* We already matched M2_MIN_LEN bytes.
|
||||
* Try to match another M2_MAX_LEN - M2_MIN_LEN bytes. */
|
||||
|
||||
#if (M2_MAX_LEN - M2_MIN_LEN == 4)
|
||||
# define MATCH_M2X (PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 5)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 6)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 7)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 13)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 14)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 16)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS || PS || PS || PS)
|
||||
#elif (M2_MAX_LEN - M2_MIN_LEN == 29)
|
||||
# define MATCH_M2X (PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS || PS || PS || PS || \
|
||||
PS || PS || PS || PS || PS)
|
||||
#else
|
||||
# error "MATCH_M2X not yet implemented"
|
||||
#endif
|
||||
|
||||
|
||||
/* We already matched M2_MIN_LEN bytes.
|
||||
* Try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes
|
||||
* to see if we get more than a M2 match */
|
||||
|
||||
#define MATCH_M2 (MATCH_M2X || PS)
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// copying
|
||||
************************************************************************/
|
||||
|
||||
#define _CP *op++ = *m_pos++
|
||||
|
||||
#if (M2_MIN_LEN == 2)
|
||||
# define COPY_M2X _CP
|
||||
#elif (M2_MIN_LEN == 3)
|
||||
# define COPY_M2X _CP; _CP
|
||||
#elif (M2_MIN_LEN == 4)
|
||||
# define COPY_M2X _CP; _CP; _CP
|
||||
#else
|
||||
# error "COPY_M2X not yet implemented"
|
||||
#endif
|
||||
|
||||
#if (M3_MIN_LEN == 3)
|
||||
# define COPY_M3X _CP; _CP
|
||||
#elif (M3_MIN_LEN == 4)
|
||||
# define COPY_M3X _CP; _CP; _CP
|
||||
#elif (M3_MIN_LEN == 9)
|
||||
# define COPY_M3X _CP; _CP; _CP; _CP; _CP; _CP; _CP; _CP
|
||||
#else
|
||||
# error "COPY_M3X not yet implemented"
|
||||
#endif
|
||||
|
||||
#define COPY_M2 COPY_M2X; *op++ = *m_pos++
|
||||
#define COPY_M3 COPY_M3X; *op++ = *m_pos++
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if defined(LZO_NEED_DICT_H)
|
||||
|
||||
#define DL_MIN_LEN M2_MIN_LEN
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
|
||||
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
|
||||
#include "lzo_dict.h"
|
||||
|
||||
#ifndef MIN_LOOKAHEAD
|
||||
#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
|
||||
#endif
|
||||
#ifndef MAX_LOOKBEHIND
|
||||
#define MAX_LOOKBEHIND (MAX_OFFSET)
|
||||
#endif
|
||||
|
||||
#endif /* defined(LZO_NEED_DICT_H) */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
/* lzo1b_r.ch -- literal run handling for the the LZO1B/LZO1C algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// store a literal run (internal)
|
||||
************************************************************************/
|
||||
|
||||
LZO_LOCAL_IMPL(lzo_bytep )
|
||||
STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len)
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
|
||||
LZO_STATS(lzo_stats->literals += r_len);
|
||||
|
||||
op = oo;
|
||||
ip = ii;
|
||||
assert(r_len > 0);
|
||||
|
||||
/* code a long R0 run */
|
||||
if (r_len >= 512)
|
||||
{
|
||||
unsigned r_bits = 6; /* 256 << 6 == 16384 */
|
||||
lzo_uint tt = 32768u;
|
||||
|
||||
while (r_len >= (t = tt))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = (R0FAST - R0MIN) + 7;
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0long_runs++);
|
||||
}
|
||||
tt >>= 1;
|
||||
do {
|
||||
if (r_len >= (t = tt))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits);
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0long_runs++);
|
||||
}
|
||||
tt >>= 1;
|
||||
} while (--r_bits > 0);
|
||||
}
|
||||
assert(r_len < 512);
|
||||
|
||||
while (r_len >= (t = R0FAST))
|
||||
{
|
||||
r_len -= t;
|
||||
*op++ = 0; *op++ = (R0FAST - R0MIN);
|
||||
MEMCPY8_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0fast_runs++);
|
||||
}
|
||||
|
||||
t = r_len;
|
||||
if (t >= R0MIN)
|
||||
{
|
||||
/* code a short R0 run */
|
||||
*op++ = 0; *op++ = LZO_BYTE(t - R0MIN);
|
||||
MEMCPY_DS(op, ip, t);
|
||||
LZO_STATS(lzo_stats->r0short_runs++);
|
||||
}
|
||||
else if (t > 0)
|
||||
{
|
||||
/* code a short literal run */
|
||||
LZO_STATS(lzo_stats->lit_runs++);
|
||||
LZO_STATS(lzo_stats->lit_run[t]++);
|
||||
*op++ = LZO_BYTE(t);
|
||||
MEMCPY_DS(op, ip, t);
|
||||
}
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/* lzo1b_rr.c -- literal run handling
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1b.h"
|
||||
|
||||
#include "lzo1b_r.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
/* lzo1b_sm.ch -- implementation of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// search for a match
|
||||
************************************************************************/
|
||||
|
||||
#if (DD_BITS == 0)
|
||||
|
||||
/* search ip in the dictionary */
|
||||
DINDEX1(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
|
||||
goto literal;
|
||||
#if 1
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
DINDEX2(dindex,ip);
|
||||
#endif
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
goto literal;
|
||||
|
||||
|
||||
#else /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
|
||||
/* search ip in the deepened dictionary */
|
||||
{
|
||||
lzo_dict_p d = &dict [ DINDEX(dv,ip) ];
|
||||
const lzo_bytep ip_sav;
|
||||
unsigned j = DD_SIZE;
|
||||
lzo_uint x_len;
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, x_off, 0);
|
||||
|
||||
DVAL_ASSERT(dv,ip);
|
||||
|
||||
ip_sav = ip;
|
||||
m_len = 0;
|
||||
do {
|
||||
#if !defined(NDEBUG)
|
||||
const lzo_bytep z_pos = NULL;
|
||||
#endif
|
||||
#if (LZO_DICT_USE_PTR)
|
||||
m_pos = *d;
|
||||
assert((z_pos = m_pos) == *d);
|
||||
#if (LZO_DETERMINISTIC)
|
||||
assert(m_pos == NULL || m_pos >= in);
|
||||
assert(m_pos == NULL || m_pos < ip);
|
||||
#endif
|
||||
#else
|
||||
x_off = *d;
|
||||
#endif
|
||||
assert(ip == ip_sav);
|
||||
|
||||
if (LZO_CHECK_MPOS(m_pos,x_off,in,ip,MAX_OFFSET))
|
||||
#if (CLEVEL == 9)
|
||||
*d = DENTRY(ip,in);
|
||||
#else
|
||||
((void)(0));
|
||||
#endif
|
||||
else if (m_pos[m_len] != ip[m_len])
|
||||
((void)(0));
|
||||
else if (*m_pos++ == *ip++ && *m_pos++ == *ip++ && *m_pos++ == *ip++)
|
||||
{
|
||||
#if !(LZO_DICT_USE_PTR)
|
||||
assert((z_pos = ip - 3 - x_off) == (m_pos - 3));
|
||||
#endif
|
||||
/* a match */
|
||||
if (MATCH_M2)
|
||||
{
|
||||
x_len = pd((ip - 1), ip_sav);
|
||||
if (x_len > m_len)
|
||||
{
|
||||
m_len = x_len;
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
}
|
||||
#if (CLEVEL == 9)
|
||||
/* try to find a closer match */
|
||||
else if (x_len == m_len && x_off < m_off)
|
||||
{
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
assert((ip - ip_sav) == M2_MAX_LEN + 1);
|
||||
#if (CLEVEL == 9)
|
||||
#if defined(MATCH_IP_END)
|
||||
{
|
||||
const lzo_bytep end;
|
||||
end = MATCH_IP_END;
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
assert(ip <= in_end);
|
||||
x_len = pd(ip, ip_sav);
|
||||
}
|
||||
if (x_len > m_len)
|
||||
{
|
||||
m_len = x_len;
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
if (ip >= MATCH_IP_END)
|
||||
{
|
||||
ip = ip_sav;
|
||||
#if 0
|
||||
/* not needed - we are at the end */
|
||||
d -= DD_SIZE - j;
|
||||
assert(d == &dict [ DINDEX(dv,ip) ]);
|
||||
UPDATE_P(d,drun,ip,in);
|
||||
#endif
|
||||
goto match;
|
||||
}
|
||||
}
|
||||
else if (x_len == m_len && x_off < m_off)
|
||||
{
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
}
|
||||
#else
|
||||
/* try to find a closer match */
|
||||
if (m_len < M2_MAX_LEN + 1 || x_off < m_off)
|
||||
{
|
||||
m_len = M2_MAX_LEN + 1;
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
/* don't search for a longer/closer match */
|
||||
m_len = M2_MAX_LEN + 1;
|
||||
m_off = x_off;
|
||||
assert((m_pos_sav = z_pos) != NULL);
|
||||
ip = ip_sav;
|
||||
d -= DD_SIZE - j;
|
||||
assert(d == &dict [ DINDEX(dv,ip) ]);
|
||||
UPDATE_P(d,drun,ip,in);
|
||||
goto match;
|
||||
#endif
|
||||
}
|
||||
ip = ip_sav;
|
||||
}
|
||||
else
|
||||
ip = ip_sav;
|
||||
d++;
|
||||
} while (--j > 0);
|
||||
assert(ip == ip_sav);
|
||||
|
||||
d -= DD_SIZE;
|
||||
assert(d == &dict [ DINDEX(dv,ip) ]);
|
||||
UPDATE_P(d,drun,ip,in);
|
||||
}
|
||||
|
||||
#endif /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
/* lzo1b_tm.ch -- implementation of the LZO1B compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// test for a potential match
|
||||
************************************************************************/
|
||||
|
||||
|
||||
#if (DD_BITS == 0)
|
||||
|
||||
try_match:
|
||||
#if !defined(NDEBUG) && (LZO_DICT_USE_PTR)
|
||||
#if (LZO_DETERMINISTIC)
|
||||
assert(m_pos == NULL || m_pos >= in);
|
||||
assert(m_pos == NULL || m_pos < ip);
|
||||
#endif
|
||||
m_pos_sav = m_pos;
|
||||
#endif
|
||||
if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2])
|
||||
{
|
||||
m_pos += 3;
|
||||
goto match;
|
||||
}
|
||||
|
||||
|
||||
#else /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
/* test potential match */
|
||||
|
||||
if (m_len > M2_MIN_LEN)
|
||||
goto match;
|
||||
if (m_len == M2_MIN_LEN)
|
||||
{
|
||||
#if (_MAX_OFFSET == _M2_MAX_OFFSET)
|
||||
goto match;
|
||||
#else
|
||||
if (m_off <= M2_MAX_OFFSET)
|
||||
goto match;
|
||||
#if 0 && (M3_MIN_LEN == M2_MIN_LEN)
|
||||
if (ip == ii)
|
||||
goto match;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
goto literal;
|
||||
|
||||
|
||||
#endif /* (DD_BITS == 0) */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
/* lzo1b_xx.c -- LZO1B compression public entry point
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1b.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static const lzo_compress_t * const c_funcs [9] =
|
||||
{
|
||||
&_lzo1b_1_compress_func,
|
||||
&_lzo1b_2_compress_func,
|
||||
&_lzo1b_3_compress_func,
|
||||
&_lzo1b_4_compress_func,
|
||||
&_lzo1b_5_compress_func,
|
||||
&_lzo1b_6_compress_func,
|
||||
&_lzo1b_7_compress_func,
|
||||
&_lzo1b_8_compress_func,
|
||||
&_lzo1b_9_compress_func
|
||||
};
|
||||
|
||||
|
||||
static lzo_compress_t lzo1b_get_compress_func(int clevel)
|
||||
{
|
||||
const lzo_compress_t *f;
|
||||
|
||||
if (clevel < LZO1B_BEST_SPEED || clevel > LZO1B_BEST_COMPRESSION)
|
||||
{
|
||||
if (clevel == LZO1B_DEFAULT_COMPRESSION)
|
||||
clevel = LZO1B_BEST_SPEED;
|
||||
else
|
||||
return (lzo_compress_t) 0;
|
||||
}
|
||||
f = c_funcs[clevel-1];
|
||||
assert(f && *f);
|
||||
return *f;
|
||||
}
|
||||
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1b_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
int clevel )
|
||||
{
|
||||
lzo_compress_t f;
|
||||
|
||||
f = lzo1b_get_compress_func(clevel);
|
||||
if (!f)
|
||||
return LZO_E_ERROR;
|
||||
return _lzo1b_do_compress(src,src_len,dst,dst_len,wrkmem,f);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_1.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 1
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 1
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_2.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 2
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 2
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_3.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 3
|
||||
|
||||
#define DDBITS 0
|
||||
#define CLEVEL 3
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_4.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 4
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 2
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_5.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 5
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 3
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_6.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 6
|
||||
|
||||
#define DDBITS 1
|
||||
#define CLEVEL 5
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_7.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 7
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 3
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_8.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 8
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 8
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
/* lzo1c_9.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 9
|
||||
|
||||
#define DDBITS 2
|
||||
#define CLEVEL 9
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/* lzo1c_99.c -- main internal configuration file for the the LZO library
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define COMPRESS_ID 99
|
||||
|
||||
#define DDBITS 3
|
||||
#define CLEVEL 9
|
||||
|
||||
#define D_BITS 16
|
||||
#define MATCH_IP_END in_end
|
||||
#include "compr1c.h"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,364 @@
|
|||
/* lzo1c_9x.c -- implementation of the LZO1C-999 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1c.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define SWD_N 16383 /* size of ring buffer */
|
||||
#define SWD_THRESHOLD 2 /* lower limit for match length */
|
||||
#define SWD_F 2048 /* upper limit for match length */
|
||||
|
||||
|
||||
#define LZO1C 1
|
||||
#define LZO_COMPRESS_T lzo1c_999_t
|
||||
#define lzo_swd_t lzo1c_999_swd_t
|
||||
#include "lzo_mchw.ch"
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static lzo_bytep
|
||||
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
|
||||
{
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
assert(m_len >= M2_MIN_LEN);
|
||||
assert(m_off >= M2_MIN_OFFSET);
|
||||
|
||||
m_off -= M2_MIN_OFFSET;
|
||||
/* code match len + low offset bits */
|
||||
*op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) |
|
||||
(m_off & M2O_MASK));
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M2O_BITS);
|
||||
c->m2_m++;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(m_len >= M3_MIN_LEN);
|
||||
assert(m_off <= M3_MAX_OFFSET);
|
||||
|
||||
m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET;
|
||||
/* code match len */
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1)));
|
||||
else
|
||||
{
|
||||
assert(m_len >= M4_MIN_LEN);
|
||||
/* code M4 match len flag */
|
||||
*op++ = M4_MARKER;
|
||||
/* code match len */
|
||||
m_len -= M4_MIN_LEN - 1;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
/* code low offset bits */
|
||||
*op++ = LZO_BYTE(m_off & M3O_MASK);
|
||||
/* code high offset bits */
|
||||
*op++ = LZO_BYTE(m_off >> M3O_BITS);
|
||||
|
||||
c->r1_m_len = 0;
|
||||
c->m3 = op;
|
||||
c->m3_m++;
|
||||
}
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// this is a public function, but there is no prototype in a header file
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain );
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ii;
|
||||
lzo_uint lit;
|
||||
lzo_uint m_len, m_off;
|
||||
LZO_COMPRESS_T cc;
|
||||
LZO_COMPRESS_T * const c = &cc;
|
||||
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
|
||||
int r;
|
||||
|
||||
/* sanity check */
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1C_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
|
||||
c->init = 0;
|
||||
c->ip = c->in = in;
|
||||
c->in_end = in + in_len;
|
||||
c->cb = cb;
|
||||
c->r1_r = c->m3_r = c->m2_m = c->m3_m = 0;
|
||||
|
||||
op = out;
|
||||
ii = c->ip; /* point to start of literal run */
|
||||
lit = 0;
|
||||
c->r1_m_len = 0;
|
||||
c->m3 = out + 1; /* pointer after last m3/m4 match */
|
||||
|
||||
r = init_match(c,swd,NULL,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
if (max_chain > 0)
|
||||
swd->max_chain = max_chain;
|
||||
|
||||
r = find_match(c,swd,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
while (c->look > 0)
|
||||
{
|
||||
int lazy_match_min_gain = -1;
|
||||
lzo_uint ahead = 0;
|
||||
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
|
||||
#if 0
|
||||
printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look,
|
||||
m_len, m_off);
|
||||
#endif
|
||||
|
||||
assert(c->ip - c->look >= in);
|
||||
if (lit == 0)
|
||||
ii = c->ip - c->look;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
assert(swd->b_char == *(c->ip - c->look));
|
||||
|
||||
if ((m_len < M2_MIN_LEN) ||
|
||||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
|
||||
{
|
||||
m_len = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(c->ip - c->look - m_off >= in);
|
||||
assert(c->ip - c->look - m_off + m_len < c->ip);
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
|
||||
if (lit > 0)
|
||||
{
|
||||
/* we have a current literal run: do not try a lazy match,
|
||||
if the literal could be coded into a r1 or m3 match */
|
||||
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
|
||||
lazy_match_min_gain = -1;
|
||||
else if (lit == 3 && op == c->m3)
|
||||
lazy_match_min_gain = -1;
|
||||
else if (lit < 3 && op == c->m3)
|
||||
lazy_match_min_gain = 0;
|
||||
else
|
||||
lazy_match_min_gain = 1;
|
||||
|
||||
#if (M2_MIN_LEN == 2)
|
||||
if (m_len == 2)
|
||||
{
|
||||
/* don't code a match of len 2 if we have to
|
||||
code a literal run. Code a literal instead. */
|
||||
m_len = 0;
|
||||
}
|
||||
#endif
|
||||
#if (M2_MIN_LEN == M3_MIN_LEN)
|
||||
if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET)
|
||||
{
|
||||
/* don't code a M3 match of len 3 if we have to
|
||||
code a literal run. Code a literal instead. */
|
||||
m_len = 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
/* no current literal run: only try a lazy match,
|
||||
if the literal could be coded into a r1 or m3 match */
|
||||
if (c->r1_m_len == M2_MIN_LEN || op == c->m3)
|
||||
lazy_match_min_gain = 0;
|
||||
else
|
||||
lazy_match_min_gain = -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* try a lazy match */
|
||||
if (m_len == 0)
|
||||
lazy_match_min_gain = -1;
|
||||
if (lazy_match_min_gain >= 0 && c->look > m_len)
|
||||
{
|
||||
assert(m_len > 0);
|
||||
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
assert(c->look > 0);
|
||||
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
|
||||
c->m_off > M2_MAX_OFFSET)
|
||||
lazy_match_min_gain += 1;
|
||||
|
||||
if (c->m_len >= m_len + lazy_match_min_gain)
|
||||
{
|
||||
c->lazy++;
|
||||
#if !defined(NDEBUG)
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
#endif
|
||||
lit++;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
ahead = 1;
|
||||
assert(ii + lit + 1 == c->ip - c->look);
|
||||
}
|
||||
assert(m_len > 0);
|
||||
}
|
||||
assert(ii + lit + ahead == c->ip - c->look);
|
||||
|
||||
|
||||
if (m_len == 0)
|
||||
{
|
||||
/* a literal */
|
||||
lit++;
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 1 - store run */
|
||||
if (lit > 0)
|
||||
{
|
||||
/* code current literal run */
|
||||
if (lit == 1 && c->r1_m_len == M2_MIN_LEN)
|
||||
{
|
||||
/* Code a context sensitive R1 match. */
|
||||
assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS));
|
||||
op[-2] &= M2O_MASK;
|
||||
assert((op[-2] >> M2O_BITS) == 0);
|
||||
/* copy 1 literal */
|
||||
*op++ = *ii++;
|
||||
assert(ii + ahead == c->ip - c->look);
|
||||
c->r1_r++;
|
||||
}
|
||||
else if (lit < 4 && op == c->m3)
|
||||
{
|
||||
assert((c->m3[-2] >> M3O_BITS) == 0);
|
||||
c->m3[-2] = LZO_BYTE(c->m3[-2] | (lit << M3O_BITS));
|
||||
MEMCPY_DS(op, ii, lit);
|
||||
assert(ii + ahead == c->ip - c->look);
|
||||
c->m3_r++;
|
||||
}
|
||||
else
|
||||
{
|
||||
op = STORE_RUN(op,ii,lit);
|
||||
}
|
||||
if (lit < R0FAST)
|
||||
c->r1_m_len = m_len;
|
||||
else
|
||||
c->r1_m_len = 0;
|
||||
lit = 0;
|
||||
}
|
||||
else
|
||||
c->r1_m_len = 0;
|
||||
|
||||
/* 2 - code match */
|
||||
op = code_match(c,op,m_len,m_off);
|
||||
r = find_match(c,swd,m_len,1+ahead);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
}
|
||||
|
||||
|
||||
/* store final run */
|
||||
if (lit > 0)
|
||||
op = STORE_RUN(op,ii,lit);
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
*op++ = M3_MARKER | 1;
|
||||
*op++ = 0;
|
||||
*op++ = 0;
|
||||
#endif
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
assert(c->textsize == in_len);
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
if (c->cb && c->cb->nprogress)
|
||||
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
|
||||
|
||||
#if 0
|
||||
printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n",
|
||||
(long) c->textsize, (long)in_len, (long) c->codesize,
|
||||
c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy);
|
||||
#endif
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1c_999_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return lzo1c_999_compress_callback(in,in_len,out,out_len,wrkmem,
|
||||
(lzo_callback_p) 0, 0);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
/* lzo1c_cc.c -- LZO1C compression internal entry point
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#include "config1c.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compression internal entry point.
|
||||
************************************************************************/
|
||||
|
||||
LZO_LOCAL_IMPL(int)
|
||||
_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func )
|
||||
{
|
||||
int r;
|
||||
#if defined(LZO_TEST_COMPRESS_OVERRUN)
|
||||
lzo_uint avail_out = *out_len;
|
||||
#endif
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
_lzo1c_stats_init(lzo_stats);
|
||||
lzo_stats->in_len = in_len;
|
||||
#endif
|
||||
|
||||
|
||||
/* don't try to compress a block that's too short */
|
||||
if (in_len == 0)
|
||||
{
|
||||
*out_len = 0;
|
||||
r = LZO_E_OK;
|
||||
}
|
||||
else if (in_len <= MIN_LOOKAHEAD + 1)
|
||||
{
|
||||
#if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE)
|
||||
*out_len = 0;
|
||||
r = LZO_E_NOT_COMPRESSIBLE;
|
||||
#else
|
||||
*out_len = pd(STORE_RUN(out,in,in_len), out);
|
||||
r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
r = func(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
#if defined(LZO_TEST_COMPRESS_OVERRUN)
|
||||
if (r == LZO_E_OK && avail_out - *out_len < 3)
|
||||
r = LZO_E_COMPRESS_OVERRUN;
|
||||
#endif
|
||||
if (r == LZO_E_OK)
|
||||
{
|
||||
lzo_bytep op = out + *out_len;
|
||||
op[0] = M3_MARKER | 1;
|
||||
op[1] = 0;
|
||||
op[2] = 0;
|
||||
*out_len += 3;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
lzo_stats->out_len = *out_len;
|
||||
lzo_stats->match_bytes =
|
||||
1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches +
|
||||
3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches;
|
||||
_lzo1c_stats_calc(lzo_stats);
|
||||
#endif
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// note: this is not thread safe, but as it is used for finetuning only
|
||||
// we don't care
|
||||
************************************************************************/
|
||||
|
||||
#undef lzo_stats
|
||||
/* lzo_stats_t is still defined */
|
||||
|
||||
|
||||
#if (LZO_COLLECT_STATS)
|
||||
|
||||
static lzo_stats_t lzo_statistics;
|
||||
lzo_stats_t * const lzo1c_stats = &lzo_statistics;
|
||||
|
||||
|
||||
void _lzo1c_stats_init(lzo_stats_t *lzo_stats)
|
||||
{
|
||||
lzo_memset(lzo_stats,0,sizeof(*lzo_stats));
|
||||
}
|
||||
|
||||
|
||||
void _lzo1c_stats_calc(lzo_stats_t *lzo_stats)
|
||||
{
|
||||
lzo_stats->matches =
|
||||
lzo_stats->m1_matches + lzo_stats->m2_matches +
|
||||
lzo_stats->m3_matches + lzo_stats->m4_matches;
|
||||
|
||||
lzo_stats->literal_overhead = lzo_stats->lit_runs +
|
||||
2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs +
|
||||
lzo_stats->r0long_runs);
|
||||
lzo_stats->literal_bytes = lzo_stats->literals +
|
||||
lzo_stats->literal_overhead;
|
||||
|
||||
#if 0
|
||||
assert(lzo_stats->match_bytes + lzo_stats->literal_bytes ==
|
||||
lzo_stats->out_len);
|
||||
#endif
|
||||
|
||||
lzo_stats->m2_matches -= lzo_stats->r1_matches;
|
||||
lzo_stats->m2_match[M2_MIN_LEN] -= lzo_stats->r1_matches;
|
||||
|
||||
if (lzo_stats->literals > 0)
|
||||
lzo_stats->literal_overhead_percent =
|
||||
100.0 * lzo_stats->literal_overhead / lzo_stats->literals;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
/* lzo1c_cc.h -- definitions for the the LZO1C compression driver
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the library and is subject
|
||||
to change.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __LZO1C_CC_H
|
||||
#define __LZO1C_CC_H 1
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
extern const lzo_compress_t _lzo1c_1_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_2_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_3_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_4_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_5_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_6_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_7_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_8_compress_func;
|
||||
extern const lzo_compress_t _lzo1c_9_compress_func;
|
||||
|
||||
extern const lzo_compress_t _lzo1c_99_compress_func;
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_LOCAL_DECL(lzo_bytep )
|
||||
_lzo1c_store_run ( lzo_bytep const oo, const lzo_bytep const ii,
|
||||
lzo_uint r_len);
|
||||
|
||||
#define STORE_RUN _lzo1c_store_run
|
||||
|
||||
|
||||
LZO_LOCAL_DECL(int)
|
||||
_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_compress_t func );
|
||||
|
||||
|
||||
#endif /* already included */
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* lzo1c_d1.c -- LZO1C decompression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1c.h"
|
||||
|
||||
#undef LZO_TEST_OVERRUN
|
||||
#define DO_DECOMPRESS lzo1c_decompress
|
||||
|
||||
#include "lzo1b_d.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
/* lzo1c_d2.c -- LZO1C decompression with overrun testing
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1c.h"
|
||||
|
||||
#define LZO_TEST_OVERRUN 1
|
||||
#define DO_DECOMPRESS lzo1c_decompress_safe
|
||||
|
||||
#include "lzo1b_d.ch"
|
||||
|
||||
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
|
||||
LZO_EXTERN(int) lzo1c_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_PUBLIC(int) lzo1c_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem)
|
||||
{
|
||||
return lzo1c_decompress_safe(src, src_len, dst, dst_len, wrkmem);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/* lzo1c_rr.c -- literal run handling
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1c.h"
|
||||
|
||||
#include "lzo1b_r.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
/* lzo1c_xx.c -- LZO1C compression public entry point
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1c.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static const lzo_compress_t * const c_funcs [9] =
|
||||
{
|
||||
&_lzo1c_1_compress_func,
|
||||
&_lzo1c_2_compress_func,
|
||||
&_lzo1c_3_compress_func,
|
||||
&_lzo1c_4_compress_func,
|
||||
&_lzo1c_5_compress_func,
|
||||
&_lzo1c_6_compress_func,
|
||||
&_lzo1c_7_compress_func,
|
||||
&_lzo1c_8_compress_func,
|
||||
&_lzo1c_9_compress_func
|
||||
};
|
||||
|
||||
|
||||
static lzo_compress_t lzo1c_get_compress_func(int clevel)
|
||||
{
|
||||
const lzo_compress_t *f;
|
||||
|
||||
if (clevel < LZO1C_BEST_SPEED || clevel > LZO1C_BEST_COMPRESSION)
|
||||
{
|
||||
if (clevel == LZO1C_DEFAULT_COMPRESSION)
|
||||
clevel = LZO1C_BEST_SPEED;
|
||||
else
|
||||
return (lzo_compress_t) 0;
|
||||
}
|
||||
f = c_funcs[clevel-1];
|
||||
assert(f && *f);
|
||||
return *f;
|
||||
}
|
||||
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1c_compress ( const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem,
|
||||
int clevel )
|
||||
{
|
||||
lzo_compress_t f;
|
||||
|
||||
f = lzo1c_get_compress_func(clevel);
|
||||
if (!f)
|
||||
return LZO_E_ERROR;
|
||||
return _lzo1c_do_compress(src,src_len,dst,dst_len,wrkmem,f);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,301 @@
|
|||
/* lzo1f_1.c -- implementation of the LZO1F-1 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#include <lzo/lzo1f.h>
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define M2_MAX_OFFSET 0x0800
|
||||
#define M3_MAX_OFFSET 0x3fff
|
||||
#define M3_MARKER 224
|
||||
|
||||
|
||||
#ifndef LZO_HASH
|
||||
#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_A
|
||||
#endif
|
||||
#define D_BITS 14
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
|
||||
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
|
||||
#include "lzo_dict.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compress a block of data.
|
||||
************************************************************************/
|
||||
|
||||
static __lzo_noinline
|
||||
int do_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
const lzo_bytep ip;
|
||||
lzo_bytep op;
|
||||
const lzo_bytep const in_end = in + in_len;
|
||||
const lzo_bytep const ip_end = in + in_len - 9;
|
||||
const lzo_bytep ii;
|
||||
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
ii = ip;
|
||||
|
||||
ip++;
|
||||
for (;;)
|
||||
{
|
||||
const lzo_bytep m_pos;
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
|
||||
lzo_uint m_len;
|
||||
lzo_uint dindex;
|
||||
lzo_uint lit;
|
||||
|
||||
DINDEX1(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
|
||||
goto literal;
|
||||
#if 1
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
DINDEX2(dindex,ip);
|
||||
#endif
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
goto literal;
|
||||
|
||||
|
||||
try_match:
|
||||
#if 0 && (LZO_OPT_UNALIGNED16)
|
||||
if (UA_GET_NE16(m_pos) != UA_GET_NE16(ip))
|
||||
#else
|
||||
if (m_pos[0] != ip[0] || m_pos[1] != ip[1])
|
||||
#endif
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_pos[2] == ip[2])
|
||||
{
|
||||
m_pos += 3;
|
||||
#if 0
|
||||
if (m_off <= M2_MAX_OFFSET)
|
||||
goto match;
|
||||
if (lit <= 3)
|
||||
goto match;
|
||||
if (lit == 3) /* better compression, but slower */
|
||||
{
|
||||
assert(op - 2 > out); op[-2] |= LZO_BYTE(3);
|
||||
*op++ = *ii++; *op++ = *ii++; *op++ = *ii++;
|
||||
goto code_match;
|
||||
}
|
||||
if (*m_pos == ip[3])
|
||||
#endif
|
||||
goto match;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* a literal */
|
||||
literal:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
if (++ip >= ip_end)
|
||||
break;
|
||||
continue;
|
||||
|
||||
|
||||
/* a match */
|
||||
match:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
/* store current literal run */
|
||||
lit = pd(ip,ii);
|
||||
if (lit > 0)
|
||||
{
|
||||
lzo_uint t = lit;
|
||||
|
||||
if (t < 4 && op > out)
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
else if (t <= 31)
|
||||
*op++ = LZO_BYTE(t);
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 31;
|
||||
|
||||
*op++ = 0;
|
||||
while (tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
}
|
||||
do *op++ = *ii++; while (--t > 0);
|
||||
}
|
||||
assert(ii == ip);
|
||||
|
||||
|
||||
/* code the match */
|
||||
ip += 3;
|
||||
if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ ||
|
||||
*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++)
|
||||
{
|
||||
--ip;
|
||||
m_len = pd(ip, ii);
|
||||
assert(m_len >= 3); assert(m_len <= 8);
|
||||
|
||||
if (m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
m_off -= 1;
|
||||
*op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
}
|
||||
else if (m_len == 3 && m_off <= 2*M2_MAX_OFFSET && lit > 0)
|
||||
{
|
||||
m_off -= 1;
|
||||
/* m_off -= M2_MAX_OFFSET; */
|
||||
*op++ = LZO_BYTE(((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
}
|
||||
else
|
||||
{
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
|
||||
*op++ = LZO_BYTE((m_off & 63) << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
{
|
||||
const lzo_bytep end;
|
||||
end = in_end;
|
||||
while (ip < end && *m_pos == *ip)
|
||||
m_pos++, ip++;
|
||||
m_len = pd(ip, ii);
|
||||
}
|
||||
assert(m_len >= 3);
|
||||
|
||||
if (m_len <= 33)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= 33;
|
||||
*op++ = M3_MARKER | 0;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
*op++ = LZO_BYTE((m_off & 63) << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
}
|
||||
|
||||
ii = ip;
|
||||
if (ip >= ip_end)
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
/* store final literal run */
|
||||
if (pd(in_end,ii) > 0)
|
||||
{
|
||||
lzo_uint t = pd(in_end,ii);
|
||||
|
||||
if (t < 4 && op > out)
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
else if (t <= 31)
|
||||
*op++ = LZO_BYTE(t);
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 31;
|
||||
|
||||
*op++ = 0;
|
||||
while (tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
}
|
||||
UA_COPYN(op, ii, t);
|
||||
op += t;
|
||||
}
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// public entry point
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1f_1_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
lzo_bytep op = out;
|
||||
int r = LZO_E_OK;
|
||||
|
||||
if (in_len == 0)
|
||||
*out_len = 0;
|
||||
else if (in_len <= 10)
|
||||
{
|
||||
*op++ = LZO_BYTE(in_len);
|
||||
do *op++ = *in++; while (--in_len > 0);
|
||||
*out_len = pd(op, out);
|
||||
}
|
||||
else
|
||||
r = do_compress(in,in_len,out,out_len,wrkmem);
|
||||
|
||||
if (r == LZO_E_OK)
|
||||
{
|
||||
op = out + *out_len;
|
||||
op[0] = M3_MARKER | 1;
|
||||
op[1] = 0;
|
||||
op[2] = 0;
|
||||
*out_len += 3;
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,330 @@
|
|||
/* lzo1f_9x.c -- implementation of the LZO1F-999 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1f.h"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define SWD_N 16383 /* size of ring buffer */
|
||||
#define SWD_THRESHOLD 2 /* lower limit for match length */
|
||||
#define SWD_F 2048 /* upper limit for match length */
|
||||
|
||||
|
||||
#define LZO1F 1
|
||||
#define LZO_COMPRESS_T lzo1f_999_t
|
||||
#define lzo_swd_t lzo1f_999_swd_t
|
||||
#include "lzo_mchw.ch"
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static lzo_bytep
|
||||
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
|
||||
{
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
m_off -= 1;
|
||||
*op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
c->m2_m++;
|
||||
}
|
||||
else if (m_len == M2_MIN_LEN && m_off <= 2 * M2_MAX_OFFSET &&
|
||||
c->r1_lit > 0)
|
||||
{
|
||||
assert(m_off > M2_MAX_OFFSET);
|
||||
m_off -= 1 + M2_MAX_OFFSET;
|
||||
*op++ = LZO_BYTE(((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
c->r1_r++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= M3_MAX_LEN;
|
||||
*op++ = M3_MARKER | 0;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
*op++ = LZO_BYTE((m_off & 63) << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
c->m3_m++;
|
||||
}
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
static lzo_bytep
|
||||
STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out )
|
||||
{
|
||||
if (t < 4 && op > out)
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
else if (t <= 31)
|
||||
*op++ = LZO_BYTE(t);
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 31;
|
||||
|
||||
*op++ = 0;
|
||||
while (tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
}
|
||||
do *op++ = *ii++; while (--t > 0);
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// this is a public function, but there is no prototype in a header file
|
||||
************************************************************************/
|
||||
|
||||
LZO_EXTERN(int)
|
||||
lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain );
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
lzo_callback_p cb,
|
||||
lzo_uint max_chain )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ii;
|
||||
lzo_uint lit;
|
||||
lzo_uint m_len, m_off;
|
||||
LZO_COMPRESS_T cc;
|
||||
LZO_COMPRESS_T * const c = &cc;
|
||||
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
|
||||
int r;
|
||||
|
||||
/* sanity check */
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1F_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
|
||||
c->init = 0;
|
||||
c->ip = c->in = in;
|
||||
c->in_end = in + in_len;
|
||||
c->cb = cb;
|
||||
c->r1_r = c->m2_m = c->m3_m = 0;
|
||||
|
||||
op = out;
|
||||
ii = c->ip; /* point to start of literal run */
|
||||
lit = 0;
|
||||
c->r1_lit = c->r1_m_len = 0;
|
||||
|
||||
r = init_match(c,swd,NULL,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
if (max_chain > 0)
|
||||
swd->max_chain = max_chain;
|
||||
|
||||
r = find_match(c,swd,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
while (c->look > 0)
|
||||
{
|
||||
int lazy_match_min_gain = -1;
|
||||
lzo_uint ahead = 0;
|
||||
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
|
||||
assert(c->ip - c->look >= in);
|
||||
if (lit == 0)
|
||||
ii = c->ip - c->look;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
assert(swd->b_char == *(c->ip - c->look));
|
||||
|
||||
if ((m_len < M2_MIN_LEN) ||
|
||||
(m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET))
|
||||
{
|
||||
m_len = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(c->ip - c->look - m_off >= in);
|
||||
assert(c->ip - c->look - m_off + m_len < c->ip);
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
|
||||
if (lit < 3)
|
||||
lazy_match_min_gain = 1;
|
||||
else if (lit == 3)
|
||||
lazy_match_min_gain = 3;
|
||||
else if (lit == 31)
|
||||
lazy_match_min_gain = 3;
|
||||
else
|
||||
lazy_match_min_gain = 1;
|
||||
}
|
||||
|
||||
/* try a lazy match */
|
||||
if (m_len > 0 && lazy_match_min_gain >= 0 && c->look > m_len)
|
||||
{
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
assert(c->look > 0);
|
||||
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET &&
|
||||
c->m_off > M2_MAX_OFFSET)
|
||||
{
|
||||
lazy_match_min_gain += 1;
|
||||
}
|
||||
else if (c->m_len <= M2_MAX_LEN &&
|
||||
c->m_off <= M2_MAX_OFFSET &&
|
||||
m_off > M2_MAX_OFFSET)
|
||||
{
|
||||
if (lazy_match_min_gain > 0)
|
||||
lazy_match_min_gain -= 1;
|
||||
}
|
||||
else if (m_len == M2_MIN_LEN && c->m_len == M2_MIN_LEN &&
|
||||
c->m_off <= 2 * M2_MAX_OFFSET &&
|
||||
m_off > M2_MAX_OFFSET)
|
||||
{
|
||||
if (lazy_match_min_gain > 0)
|
||||
lazy_match_min_gain -= 1;
|
||||
}
|
||||
|
||||
if (c->m_len >= m_len + lazy_match_min_gain)
|
||||
{
|
||||
c->lazy++;
|
||||
#if !defined(NDEBUG)
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
assert(lzo_memcmp(c->ip - c->look, c->ip - c->look - m_off,
|
||||
m_len) == 0);
|
||||
#endif
|
||||
lit++;
|
||||
assert(ii + lit == c->ip - c->look);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
ahead = 1;
|
||||
assert(ii + lit + 1 == c->ip - c->look);
|
||||
}
|
||||
assert(m_len > 0);
|
||||
}
|
||||
assert(ii + lit + ahead == c->ip - c->look);
|
||||
|
||||
|
||||
if (m_len == 0)
|
||||
{
|
||||
/* a literal */
|
||||
lit++;
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 1 - store run */
|
||||
if (lit > 0)
|
||||
{
|
||||
op = STORE_RUN(op,ii,lit,out);
|
||||
c->r1_m_len = m_len;
|
||||
c->r1_lit = lit;
|
||||
lit = 0;
|
||||
}
|
||||
else
|
||||
c->r1_lit = c->r1_m_len = 0;
|
||||
|
||||
/* 2 - code match */
|
||||
op = code_match(c,op,m_len,m_off);
|
||||
r = find_match(c,swd,m_len,1+ahead);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
}
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
}
|
||||
|
||||
|
||||
/* store final run */
|
||||
if (lit > 0)
|
||||
op = STORE_RUN(op,ii,lit,out);
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
*op++ = M3_MARKER | 1;
|
||||
*op++ = 0;
|
||||
*op++ = 0;
|
||||
#endif
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
assert(c->textsize == in_len);
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
if (c->cb && c->cb->nprogress)
|
||||
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
|
||||
|
||||
#if 0
|
||||
printf("%ld %ld -> %ld: %ld %ld %ld %ld\n",
|
||||
(long) c->textsize, (long)in_len, (long) c->codesize,
|
||||
c->r1_r, c->m2_m, c->m3_m, c->lazy);
|
||||
#endif
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1f_999_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return lzo1f_999_compress_callback(in,in_len,out,out_len,wrkmem,
|
||||
(lzo_callback_p) 0, 0);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,210 @@
|
|||
/* lzo1f_d.ch -- implementation of the LZO1F decompression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo1_d.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// decompress a block of data.
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
const lzo_bytep m_pos;
|
||||
|
||||
const lzo_bytep const ip_end = in + in_len;
|
||||
#if defined(HAVE_ANY_OP)
|
||||
lzo_bytep const op_end = out + *out_len;
|
||||
#endif
|
||||
|
||||
LZO_UNUSED(wrkmem);
|
||||
|
||||
*out_len = 0;
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
|
||||
while (TEST_IP_AND_TEST_OP)
|
||||
{
|
||||
t = *ip++;
|
||||
if (t > 31)
|
||||
goto match;
|
||||
|
||||
/* a literal run */
|
||||
if (t == 0)
|
||||
{
|
||||
NEED_IP(1);
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_IV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += 31 + *ip++;
|
||||
}
|
||||
/* copy literals */
|
||||
assert(t > 0); NEED_OP(t); NEED_IP(t+1);
|
||||
#if (LZO_OPT_UNALIGNED32)
|
||||
if (t >= 4)
|
||||
{
|
||||
do {
|
||||
UA_COPY4(op, ip);
|
||||
op += 4; ip += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
|
||||
t = *ip++;
|
||||
|
||||
while (TEST_IP_AND_TEST_OP)
|
||||
{
|
||||
/* handle matches */
|
||||
if (t < 32)
|
||||
{
|
||||
m_pos = op - 1 - 0x800;
|
||||
m_pos -= (t >> 2) & 7;
|
||||
m_pos -= *ip++ << 3;
|
||||
TEST_LB(m_pos); NEED_OP(3);
|
||||
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++;
|
||||
}
|
||||
else
|
||||
{
|
||||
match:
|
||||
if (t < M3_MARKER)
|
||||
{
|
||||
m_pos = op - 1;
|
||||
m_pos -= (t >> 2) & 7;
|
||||
m_pos -= *ip++ << 3;
|
||||
t >>= 5;
|
||||
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
|
||||
goto copy_match;
|
||||
}
|
||||
else
|
||||
{
|
||||
t &= 31;
|
||||
if (t == 0)
|
||||
{
|
||||
NEED_IP(1);
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_OV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += 31 + *ip++;
|
||||
}
|
||||
NEED_IP(2);
|
||||
m_pos = op;
|
||||
#if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
|
||||
m_pos -= UA_GET_LE16(ip) >> 2;
|
||||
ip += 2;
|
||||
#else
|
||||
m_pos -= *ip++ >> 2;
|
||||
m_pos -= *ip++ << 6;
|
||||
#endif
|
||||
if (m_pos == op)
|
||||
goto eof_found;
|
||||
}
|
||||
|
||||
/* copy match */
|
||||
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
|
||||
#if (LZO_OPT_UNALIGNED32)
|
||||
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
|
||||
{
|
||||
UA_COPY4(op, m_pos);
|
||||
op += 4; m_pos += 4; t -= 4 - (3 - 1);
|
||||
do {
|
||||
UA_COPY4(op, m_pos);
|
||||
op += 4; m_pos += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *m_pos++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
copy_match:
|
||||
*op++ = *m_pos++; *op++ = *m_pos++;
|
||||
do *op++ = *m_pos++; while (--t > 0);
|
||||
}
|
||||
}
|
||||
t = ip[-2] & 3;
|
||||
if (t == 0)
|
||||
break;
|
||||
|
||||
/* copy literals */
|
||||
assert(t > 0); NEED_OP(t); NEED_IP(t+1);
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
t = *ip++;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
|
||||
/* no EOF code was found */
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_EOF_NOT_FOUND;
|
||||
#endif
|
||||
|
||||
eof_found:
|
||||
assert(t == 1);
|
||||
*out_len = pd(op, out);
|
||||
return (ip == ip_end ? LZO_E_OK :
|
||||
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
||||
|
||||
|
||||
#if defined(HAVE_NEED_IP)
|
||||
input_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_INPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_NEED_OP)
|
||||
output_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OUTPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
|
||||
lookbehind_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_LOOKBEHIND_OVERRUN;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* lzo1f_d1.c -- LZO1F decompression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1f.h"
|
||||
|
||||
#undef LZO_TEST_OVERRUN
|
||||
#define DO_DECOMPRESS lzo1f_decompress
|
||||
|
||||
#include "lzo1f_d.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
/* lzo1f_d2.c -- LZO1F decompression with overrun testing
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1f.h"
|
||||
|
||||
#define LZO_TEST_OVERRUN 1
|
||||
#define DO_DECOMPRESS lzo1f_decompress_safe
|
||||
|
||||
#include "lzo1f_d.ch"
|
||||
|
||||
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
|
||||
LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_PUBLIC(int) lzo1f_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem)
|
||||
{
|
||||
return lzo1f_decompress_safe(src, src_len, dst, dst_len, wrkmem);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
/* lzo1x_1.c -- LZO1X-1 compression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#if 1 && defined(UA_GET_LE32)
|
||||
#undef LZO_DICT_USE_PTR
|
||||
#define LZO_DICT_USE_PTR 0
|
||||
#undef lzo_dict_t
|
||||
#define lzo_dict_t lzo_uint16_t
|
||||
#endif
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 14
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
|
||||
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
|
||||
#if 1
|
||||
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
|
||||
#else
|
||||
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
|
||||
#endif
|
||||
#include "config1x.h"
|
||||
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
|
||||
|
||||
#ifndef DO_COMPRESS
|
||||
#define DO_COMPRESS lzo1x_1_compress
|
||||
#endif
|
||||
|
||||
#include "lzo1x_c.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
/* lzo1x_1k.c -- LZO1X-1(11) compression (needs only 8kB work memory)
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#if 1 && defined(UA_GET_LE32)
|
||||
#undef LZO_DICT_USE_PTR
|
||||
#define LZO_DICT_USE_PTR 0
|
||||
#undef lzo_dict_t
|
||||
#define lzo_dict_t lzo_uint16_t
|
||||
#endif
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 11
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,3,5)) >> 5)
|
||||
#define D_INDEX2(d,p) d = d ^ D_MASK
|
||||
#if 1
|
||||
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
|
||||
#else
|
||||
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
|
||||
#endif
|
||||
#include "config1x.h"
|
||||
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
|
||||
|
||||
#ifndef DO_COMPRESS
|
||||
#define DO_COMPRESS lzo1x_1_11_compress
|
||||
#endif
|
||||
|
||||
#include "lzo1x_c.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
/* lzo1x_1l.c -- LZO1X-1(12) compression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#if 1 && defined(UA_GET_LE32)
|
||||
#undef LZO_DICT_USE_PTR
|
||||
#define LZO_DICT_USE_PTR 0
|
||||
#undef lzo_dict_t
|
||||
#define lzo_dict_t lzo_uint16_t
|
||||
#endif
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 12
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX2(p,4,5)) >> 5)
|
||||
#define D_INDEX2(d,p) d = d ^ D_MASK
|
||||
#if 1
|
||||
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
|
||||
#else
|
||||
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
|
||||
#endif
|
||||
#include "config1x.h"
|
||||
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
|
||||
|
||||
#ifndef DO_COMPRESS
|
||||
#define DO_COMPRESS lzo1x_1_12_compress
|
||||
#endif
|
||||
|
||||
#include "lzo1x_c.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
/* lzo1x_1o.c -- LZO1X-1(15) compression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo_conf.h"
|
||||
#if 1 && defined(UA_GET_LE32)
|
||||
#undef LZO_DICT_USE_PTR
|
||||
#define LZO_DICT_USE_PTR 0
|
||||
#undef lzo_dict_t
|
||||
#define lzo_dict_t lzo_uint16_t
|
||||
#define D_BITS 13
|
||||
#endif
|
||||
|
||||
#define LZO_NEED_DICT_H 1
|
||||
#ifndef D_BITS
|
||||
#define D_BITS 15
|
||||
#endif
|
||||
#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
|
||||
#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
|
||||
#if 1
|
||||
#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
|
||||
#else
|
||||
#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
|
||||
#endif
|
||||
#include "config1x.h"
|
||||
#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
|
||||
|
||||
#ifndef DO_COMPRESS
|
||||
#define DO_COMPRESS lzo1x_1_15_compress
|
||||
#endif
|
||||
|
||||
#include "lzo1x_c.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,867 @@
|
|||
/* lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
|
||||
# define LZO1X 1
|
||||
#endif
|
||||
|
||||
#if defined(LZO1X)
|
||||
# include "config1x.h"
|
||||
#elif defined(LZO1Y)
|
||||
# include "config1y.h"
|
||||
#elif defined(LZO1Z)
|
||||
# include "config1z.h"
|
||||
#else
|
||||
# error
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#define SWD_N M4_MAX_OFFSET /* size of ring buffer */
|
||||
#define SWD_THRESHOLD 1 /* lower limit for match length */
|
||||
#define SWD_F 2048 /* upper limit for match length */
|
||||
|
||||
#define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1)
|
||||
|
||||
#if defined(LZO1X)
|
||||
# define LZO_COMPRESS_T lzo1x_999_t
|
||||
# define lzo_swd_t lzo1x_999_swd_t
|
||||
#elif defined(LZO1Y)
|
||||
# define LZO_COMPRESS_T lzo1y_999_t
|
||||
# define lzo_swd_t lzo1y_999_swd_t
|
||||
# define lzo1x_999_compress_internal lzo1y_999_compress_internal
|
||||
# define lzo1x_999_compress_dict lzo1y_999_compress_dict
|
||||
# define lzo1x_999_compress_level lzo1y_999_compress_level
|
||||
# define lzo1x_999_compress lzo1y_999_compress
|
||||
#elif defined(LZO1Z)
|
||||
# define LZO_COMPRESS_T lzo1z_999_t
|
||||
# define lzo_swd_t lzo1z_999_swd_t
|
||||
# define lzo1x_999_compress_internal lzo1z_999_compress_internal
|
||||
# define lzo1x_999_compress_dict lzo1z_999_compress_dict
|
||||
# define lzo1x_999_compress_level lzo1z_999_compress_level
|
||||
# define lzo1x_999_compress lzo1z_999_compress
|
||||
#else
|
||||
# error
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
# define HEAD3(b,p) \
|
||||
((((((lzo_xint)b[p]<<3)^b[p+1])<<3)^b[p+2]) & (SWD_HSIZE-1))
|
||||
#endif
|
||||
#if 0 && (LZO_OPT_UNALIGNED32) && (LZO_ABI_LITTLE_ENDIAN)
|
||||
# define HEAD3(b,p) \
|
||||
(((* (lzo_uint32_tp) &b[p]) ^ ((* (lzo_uint32_tp) &b[p])>>10)) & (SWD_HSIZE-1))
|
||||
#endif
|
||||
|
||||
#include "lzo_mchw.ch"
|
||||
|
||||
|
||||
/* this is a public functions, but there is no prototype in a header file */
|
||||
LZO_EXTERN(int)
|
||||
lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int try_lazy_parm,
|
||||
lzo_uint good_length,
|
||||
lzo_uint max_lazy,
|
||||
lzo_uint nice_length,
|
||||
lzo_uint max_chain,
|
||||
lzo_uint32_t flags );
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static lzo_bytep
|
||||
code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off )
|
||||
{
|
||||
lzo_uint x_len = m_len;
|
||||
lzo_uint x_off = m_off;
|
||||
|
||||
c->match_bytes += m_len;
|
||||
|
||||
#if 0
|
||||
/*
|
||||
static lzo_uint last_m_len = 0, last_m_off = 0;
|
||||
static lzo_uint prev_m_off[4];
|
||||
static unsigned prev_m_off_ptr = 0;
|
||||
unsigned i;
|
||||
|
||||
//if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
if (m_len >= 3 && m_len <= M2_MAX_LEN)
|
||||
{
|
||||
//if (m_len == last_m_len && m_off == last_m_off)
|
||||
//printf("last_m_len + last_m_off\n");
|
||||
//else
|
||||
if (m_off == last_m_off)
|
||||
printf("last_m_off\n");
|
||||
else
|
||||
{
|
||||
for (i = 0; i < 4; i++)
|
||||
if (m_off == prev_m_off[i])
|
||||
printf("prev_m_off %u: %5ld\n",i,(long)m_off);
|
||||
}
|
||||
}
|
||||
last_m_len = m_len;
|
||||
last_m_off = prev_m_off[prev_m_off_ptr] = m_off;
|
||||
prev_m_off_ptr = (prev_m_off_ptr + 1) & 3;
|
||||
*/
|
||||
#endif
|
||||
|
||||
assert(op > c->out);
|
||||
if (m_len == 2)
|
||||
{
|
||||
assert(m_off <= M1_MAX_OFFSET);
|
||||
assert(c->r1_lit > 0); assert(c->r1_lit < 4);
|
||||
m_off -= 1;
|
||||
#if defined(LZO1Z)
|
||||
*op++ = LZO_BYTE(M1_MARKER | (m_off >> 6));
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
#else
|
||||
*op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 2);
|
||||
#endif
|
||||
c->m1a_m++;
|
||||
}
|
||||
#if defined(LZO1Z)
|
||||
else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off))
|
||||
#else
|
||||
else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
#endif
|
||||
{
|
||||
assert(m_len >= 3);
|
||||
#if defined(LZO1X)
|
||||
m_off -= 1;
|
||||
*op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
assert(op[-2] >= M2_MARKER);
|
||||
#elif defined(LZO1Y)
|
||||
m_off -= 1;
|
||||
*op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 2);
|
||||
assert(op[-2] >= M2_MARKER);
|
||||
#elif defined(LZO1Z)
|
||||
if (m_off == c->last_m_off)
|
||||
*op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6));
|
||||
else
|
||||
{
|
||||
m_off -= 1;
|
||||
*op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6));
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
}
|
||||
#endif
|
||||
c->m2_m++;
|
||||
}
|
||||
else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && c->r1_lit >= 4)
|
||||
{
|
||||
assert(m_len == 3);
|
||||
assert(m_off > M2_MAX_OFFSET);
|
||||
m_off -= 1 + M2_MAX_OFFSET;
|
||||
#if defined(LZO1Z)
|
||||
*op++ = LZO_BYTE(M1_MARKER | (m_off >> 6));
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
#else
|
||||
*op++ = LZO_BYTE(M1_MARKER | ((m_off & 3) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 2);
|
||||
#endif
|
||||
c->m1b_m++;
|
||||
}
|
||||
else if (m_off <= M3_MAX_OFFSET)
|
||||
{
|
||||
assert(m_len >= 3);
|
||||
m_off -= 1;
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= M3_MAX_LEN;
|
||||
*op++ = M3_MARKER | 0;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
#if defined(LZO1Z)
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
#else
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
#endif
|
||||
c->m3_m++;
|
||||
}
|
||||
else
|
||||
{
|
||||
lzo_uint k;
|
||||
|
||||
assert(m_len >= 3);
|
||||
assert(m_off > 0x4000); assert(m_off <= 0xbfff);
|
||||
m_off -= 0x4000;
|
||||
k = (m_off & 0x4000) >> 11;
|
||||
if (m_len <= M4_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= M4_MAX_LEN;
|
||||
*op++ = LZO_BYTE(M4_MARKER | k | 0);
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(m_len > 0);
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
#if defined(LZO1Z)
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
#else
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
#endif
|
||||
c->m4_m++;
|
||||
}
|
||||
|
||||
c->last_m_len = x_len;
|
||||
c->last_m_off = x_off;
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
static lzo_bytep
|
||||
STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t )
|
||||
{
|
||||
c->lit_bytes += t;
|
||||
|
||||
if (op == c->out && t <= 238)
|
||||
{
|
||||
*op++ = LZO_BYTE(17 + t);
|
||||
}
|
||||
else if (t <= 3)
|
||||
{
|
||||
#if defined(LZO1Z)
|
||||
op[-1] = LZO_BYTE(op[-1] | t);
|
||||
#else
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
#endif
|
||||
c->lit1_r++;
|
||||
}
|
||||
else if (t <= 18)
|
||||
{
|
||||
*op++ = LZO_BYTE(t - 3);
|
||||
c->lit2_r++;
|
||||
}
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 18;
|
||||
|
||||
*op++ = 0;
|
||||
while (tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
*op++ = 0;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
c->lit3_r++;
|
||||
}
|
||||
do *op++ = *ii++; while (--t > 0);
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
static lzo_bytep
|
||||
code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii,
|
||||
lzo_uint lit, lzo_uint m_len )
|
||||
{
|
||||
if (lit > 0)
|
||||
{
|
||||
assert(m_len >= 2);
|
||||
op = STORE_RUN(c,op,ii,lit);
|
||||
c->r1_m_len = m_len;
|
||||
c->r1_lit = lit;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(m_len >= 3);
|
||||
c->r1_m_len = 0;
|
||||
c->r1_lit = 0;
|
||||
}
|
||||
|
||||
return op;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
static lzo_uint
|
||||
len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit )
|
||||
{
|
||||
lzo_uint n = 4;
|
||||
|
||||
if (m_len < 2)
|
||||
return 0;
|
||||
if (m_len == 2)
|
||||
return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0;
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
return 2;
|
||||
if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4)
|
||||
return 2;
|
||||
if (m_off <= M3_MAX_OFFSET)
|
||||
{
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
return 3;
|
||||
m_len -= M3_MAX_LEN;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
if (m_off <= M4_MAX_OFFSET)
|
||||
{
|
||||
if (m_len <= M4_MAX_LEN)
|
||||
return 3;
|
||||
m_len -= M4_MAX_LEN;
|
||||
while (m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
n++;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static lzo_uint
|
||||
min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lzo_uint l3)
|
||||
{
|
||||
lzo_uint lazy_match_min_gain;
|
||||
|
||||
assert (ahead >= 1);
|
||||
lazy_match_min_gain = ahead;
|
||||
|
||||
#if 0
|
||||
if (l3)
|
||||
lit2 -= ahead;
|
||||
#endif
|
||||
|
||||
if (lit1 <= 3)
|
||||
lazy_match_min_gain += (lit2 <= 3) ? 0 : 2;
|
||||
else if (lit1 <= 18)
|
||||
lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
|
||||
|
||||
lazy_match_min_gain += (l2 - l1) * 2;
|
||||
if (l3)
|
||||
lazy_match_min_gain -= (ahead - l3) * 2;
|
||||
|
||||
if ((lzo_int) lazy_match_min_gain < 0)
|
||||
lazy_match_min_gain = 0;
|
||||
|
||||
#if 0
|
||||
if (l1 == 2)
|
||||
if (lazy_match_min_gain == 0)
|
||||
lazy_match_min_gain = 1;
|
||||
#endif
|
||||
|
||||
return lazy_match_min_gain;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
#if !defined(NDEBUG)
|
||||
static
|
||||
void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off )
|
||||
{
|
||||
const LZO_COMPRESS_T *c = swd->c;
|
||||
lzo_uint d_off;
|
||||
|
||||
assert(m_len >= 2);
|
||||
if (m_off <= (lzo_uint) (c->bp - c->in))
|
||||
{
|
||||
assert(c->bp - m_off + m_len < c->ip);
|
||||
assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(swd->dict != NULL);
|
||||
d_off = m_off - (lzo_uint) (c->bp - c->in);
|
||||
assert(d_off <= swd->dict_len);
|
||||
if (m_len > d_off)
|
||||
{
|
||||
assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0);
|
||||
assert(c->in + m_len - d_off < c->ip);
|
||||
assert(lzo_memcmp(c->bp + d_off, c->in, m_len - d_off) == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(lzo_memcmp(c->bp, swd->dict_end - d_off, m_len) == 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
# define assert_match(a,b,c) ((void)0)
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(SWD_BEST_OFF)
|
||||
|
||||
static void
|
||||
better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off )
|
||||
{
|
||||
#if defined(LZO1Z)
|
||||
const LZO_COMPRESS_T *c = swd->c;
|
||||
#endif
|
||||
|
||||
if (*m_len <= M2_MIN_LEN)
|
||||
return;
|
||||
#if defined(LZO1Z)
|
||||
if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN)
|
||||
return;
|
||||
#if 1
|
||||
if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
|
||||
c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off)
|
||||
{
|
||||
*m_len = *m_len - 1;
|
||||
*m_off = swd->best_off[*m_len];
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (*m_off <= M2_MAX_OFFSET)
|
||||
return;
|
||||
|
||||
#if 1
|
||||
/* M3/M4 -> M2 */
|
||||
if (*m_off > M2_MAX_OFFSET &&
|
||||
*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
|
||||
swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET)
|
||||
{
|
||||
*m_len = *m_len - 1;
|
||||
*m_off = swd->best_off[*m_len];
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/* M4 -> M2 */
|
||||
if (*m_off > M3_MAX_OFFSET &&
|
||||
*m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 &&
|
||||
swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET)
|
||||
{
|
||||
*m_len = *m_len - 2;
|
||||
*m_off = swd->best_off[*m_len];
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
/* M4 -> M3 */
|
||||
if (*m_off > M3_MAX_OFFSET &&
|
||||
*m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 &&
|
||||
swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET)
|
||||
{
|
||||
*m_len = *m_len - 1;
|
||||
*m_off = swd->best_off[*m_len];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int try_lazy_parm,
|
||||
lzo_uint good_length,
|
||||
lzo_uint max_lazy,
|
||||
lzo_uint nice_length,
|
||||
lzo_uint max_chain,
|
||||
lzo_uint32_t flags )
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ii;
|
||||
lzo_uint lit;
|
||||
lzo_uint m_len, m_off;
|
||||
LZO_COMPRESS_T cc;
|
||||
LZO_COMPRESS_T * const c = &cc;
|
||||
lzo_swd_p const swd = (lzo_swd_p) wrkmem;
|
||||
lzo_uint try_lazy;
|
||||
int r;
|
||||
|
||||
/* sanity check */
|
||||
#if defined(LZO1X)
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1X_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
#elif defined(LZO1Y)
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1Y_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
#elif defined(LZO1Z)
|
||||
LZO_COMPILE_TIME_ASSERT(LZO1Z_999_MEM_COMPRESS >= SIZEOF_LZO_SWD_T)
|
||||
#else
|
||||
# error
|
||||
#endif
|
||||
|
||||
/* setup parameter defaults */
|
||||
/* number of lazy match tries */
|
||||
try_lazy = (lzo_uint) try_lazy_parm;
|
||||
if (try_lazy_parm < 0)
|
||||
try_lazy = 1;
|
||||
/* reduce lazy match search if we already have a match with this length */
|
||||
if (good_length == 0)
|
||||
good_length = 32;
|
||||
/* do not try a lazy match if we already have a match with this length */
|
||||
if (max_lazy == 0)
|
||||
max_lazy = 32;
|
||||
/* stop searching for longer matches than this one */
|
||||
if (nice_length == 0)
|
||||
nice_length = 0;
|
||||
/* don't search more positions than this */
|
||||
if (max_chain == 0)
|
||||
max_chain = SWD_MAX_CHAIN;
|
||||
|
||||
c->init = 0;
|
||||
c->ip = c->in = in;
|
||||
c->in_end = in + in_len;
|
||||
c->out = out;
|
||||
c->cb = cb;
|
||||
c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0;
|
||||
c->lit1_r = c->lit2_r = c->lit3_r = 0;
|
||||
|
||||
op = out;
|
||||
ii = c->ip; /* point to start of literal run */
|
||||
lit = 0;
|
||||
c->r1_lit = c->r1_m_len = 0;
|
||||
|
||||
r = init_match(c,swd,dict,dict_len,flags);
|
||||
if (r != 0)
|
||||
return r;
|
||||
if (max_chain > 0)
|
||||
swd->max_chain = max_chain;
|
||||
if (nice_length > 0)
|
||||
swd->nice_length = nice_length;
|
||||
|
||||
r = find_match(c,swd,0,0);
|
||||
if (r != 0)
|
||||
return r;
|
||||
while (c->look > 0)
|
||||
{
|
||||
lzo_uint ahead;
|
||||
lzo_uint max_ahead;
|
||||
lzo_uint l1, l2, l3;
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
|
||||
m_len = c->m_len;
|
||||
m_off = c->m_off;
|
||||
|
||||
assert(c->bp == c->ip - c->look);
|
||||
assert(c->bp >= in);
|
||||
if (lit == 0)
|
||||
ii = c->bp;
|
||||
assert(ii + lit == c->bp);
|
||||
assert(swd->b_char == *(c->bp));
|
||||
|
||||
if ( m_len < 2 ||
|
||||
(m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) ||
|
||||
#if 1
|
||||
/* Do not accept this match for compressed-data compatibility
|
||||
* with LZO v1.01 and before
|
||||
* [ might be a problem for decompress() and optimize() ]
|
||||
*/
|
||||
(m_len == 2 && op == out) ||
|
||||
#endif
|
||||
(op == out && lit == 0))
|
||||
{
|
||||
/* a literal */
|
||||
m_len = 0;
|
||||
}
|
||||
else if (m_len == M2_MIN_LEN)
|
||||
{
|
||||
/* compression ratio improves if we code a literal in some cases */
|
||||
if (m_off > MX_MAX_OFFSET && lit >= 4)
|
||||
m_len = 0;
|
||||
}
|
||||
|
||||
if (m_len == 0)
|
||||
{
|
||||
/* a literal */
|
||||
lit++;
|
||||
swd->max_chain = max_chain;
|
||||
r = find_match(c,swd,1,0);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* a match */
|
||||
#if defined(SWD_BEST_OFF)
|
||||
if (swd->use_best_off)
|
||||
better_match(swd,&m_len,&m_off);
|
||||
#endif
|
||||
assert_match(swd,m_len,m_off);
|
||||
|
||||
|
||||
/* shall we try a lazy match ? */
|
||||
ahead = 0;
|
||||
if (try_lazy == 0 || m_len >= max_lazy)
|
||||
{
|
||||
/* no */
|
||||
l1 = 0;
|
||||
max_ahead = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* yes, try a lazy match */
|
||||
l1 = len_of_coded_match(m_len,m_off,lit);
|
||||
assert(l1 > 0);
|
||||
#if 1
|
||||
max_ahead = LZO_MIN(try_lazy, l1 - 1);
|
||||
#else
|
||||
max_ahead = LZO_MIN3(try_lazy, l1, m_len - 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
while (ahead < max_ahead && c->look > m_len)
|
||||
{
|
||||
lzo_uint lazy_match_min_gain;
|
||||
|
||||
if (m_len >= good_length)
|
||||
swd->max_chain = max_chain >> 2;
|
||||
else
|
||||
swd->max_chain = max_chain;
|
||||
r = find_match(c,swd,1,0);
|
||||
ahead++;
|
||||
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
assert(c->look > 0);
|
||||
assert(ii + lit + ahead == c->bp);
|
||||
|
||||
#if defined(LZO1Z)
|
||||
if (m_off == c->last_m_off && c->m_off != c->last_m_off)
|
||||
if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN)
|
||||
c->m_len = 0;
|
||||
#endif
|
||||
if (c->m_len < m_len)
|
||||
continue;
|
||||
#if 1
|
||||
if (c->m_len == m_len && c->m_off >= m_off)
|
||||
continue;
|
||||
#endif
|
||||
#if defined(SWD_BEST_OFF)
|
||||
if (swd->use_best_off)
|
||||
better_match(swd,&c->m_len,&c->m_off);
|
||||
#endif
|
||||
l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead);
|
||||
if (l2 == 0)
|
||||
continue;
|
||||
#if 0
|
||||
if (c->m_len == m_len && l2 >= l1)
|
||||
continue;
|
||||
#endif
|
||||
|
||||
|
||||
#if 1
|
||||
/* compressed-data compatibility [see above] */
|
||||
l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit);
|
||||
#else
|
||||
l3 = len_of_coded_match(ahead,m_off,lit);
|
||||
#endif
|
||||
|
||||
lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3);
|
||||
if (c->m_len >= m_len + lazy_match_min_gain)
|
||||
{
|
||||
c->lazy++;
|
||||
assert_match(swd,c->m_len,c->m_off);
|
||||
|
||||
if (l3)
|
||||
{
|
||||
/* code previous run */
|
||||
op = code_run(c,op,ii,lit,ahead);
|
||||
lit = 0;
|
||||
/* code shortened match */
|
||||
op = code_match(c,op,ahead,m_off);
|
||||
}
|
||||
else
|
||||
{
|
||||
lit += ahead;
|
||||
assert(ii + lit == c->bp);
|
||||
}
|
||||
goto lazy_match_done;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
assert(ii + lit + ahead == c->bp);
|
||||
|
||||
/* 1 - code run */
|
||||
op = code_run(c,op,ii,lit,m_len);
|
||||
lit = 0;
|
||||
|
||||
/* 2 - code match */
|
||||
op = code_match(c,op,m_len,m_off);
|
||||
swd->max_chain = max_chain;
|
||||
r = find_match(c,swd,m_len,1+ahead);
|
||||
assert(r == 0); LZO_UNUSED(r);
|
||||
|
||||
lazy_match_done: ;
|
||||
}
|
||||
|
||||
|
||||
/* store final run */
|
||||
if (lit > 0)
|
||||
op = STORE_RUN(c,op,ii,lit);
|
||||
|
||||
#if defined(LZO_EOF_CODE)
|
||||
*op++ = M4_MARKER | 1;
|
||||
*op++ = 0;
|
||||
*op++ = 0;
|
||||
#endif
|
||||
|
||||
c->codesize = pd(op, out);
|
||||
assert(c->textsize == in_len);
|
||||
|
||||
*out_len = pd(op, out);
|
||||
|
||||
if (c->cb && c->cb->nprogress)
|
||||
(*c->cb->nprogress)(c->cb, c->textsize, c->codesize, 0);
|
||||
|
||||
#if 0
|
||||
printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n",
|
||||
(long) c->textsize, (long) in_len, (long) c->codesize,
|
||||
c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m,
|
||||
c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy);
|
||||
#endif
|
||||
assert(c->lit_bytes + c->match_bytes == in_len);
|
||||
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len,
|
||||
lzo_callback_p cb,
|
||||
int compression_level )
|
||||
{
|
||||
static const struct
|
||||
{
|
||||
int try_lazy_parm;
|
||||
lzo_uint good_length;
|
||||
lzo_uint max_lazy;
|
||||
lzo_uint nice_length;
|
||||
lzo_uint max_chain;
|
||||
lzo_uint32_t flags;
|
||||
} c[9] = {
|
||||
/* faster compression */
|
||||
{ 0, 0, 0, 8, 4, 0 },
|
||||
{ 0, 0, 0, 16, 8, 0 },
|
||||
{ 0, 0, 0, 32, 16, 0 },
|
||||
{ 1, 4, 4, 16, 16, 0 },
|
||||
{ 1, 8, 16, 32, 32, 0 },
|
||||
{ 1, 8, 16, 128, 128, 0 },
|
||||
{ 2, 8, 32, 128, 256, 0 },
|
||||
{ 2, 32, 128, SWD_F, 2048, 1 },
|
||||
{ 2, SWD_F, SWD_F, SWD_F, 4096, 1 }
|
||||
/* max. compression */
|
||||
};
|
||||
|
||||
if (compression_level < 1 || compression_level > 9)
|
||||
return LZO_E_ERROR;
|
||||
|
||||
compression_level -= 1;
|
||||
return lzo1x_999_compress_internal(in, in_len, out, out_len, wrkmem,
|
||||
dict, dict_len, cb,
|
||||
c[compression_level].try_lazy_parm,
|
||||
c[compression_level].good_length,
|
||||
c[compression_level].max_lazy,
|
||||
#if 0
|
||||
c[compression_level].nice_length,
|
||||
#else
|
||||
0,
|
||||
#endif
|
||||
c[compression_level].max_chain,
|
||||
c[compression_level].flags);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
//
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1x_999_compress_dict ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem,
|
||||
const lzo_bytep dict, lzo_uint dict_len )
|
||||
{
|
||||
return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
|
||||
dict, dict_len, 0, 8);
|
||||
}
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1x_999_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem,
|
||||
NULL, 0, (lzo_callback_p) 0, 8);
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,403 @@
|
|||
/* lzo1x_c.ch -- implementation of the LZO1[XY]-1 compression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#if 1 && defined(DO_COMPRESS) && !defined(do_compress)
|
||||
/* choose a unique name to better help PGO optimizations */
|
||||
# define do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core)
|
||||
#endif
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// compress a block of data.
|
||||
************************************************************************/
|
||||
|
||||
static __lzo_noinline lzo_uint
|
||||
do_compress ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_uint ti, lzo_voidp wrkmem)
|
||||
{
|
||||
const lzo_bytep ip;
|
||||
lzo_bytep op;
|
||||
const lzo_bytep const in_end = in + in_len;
|
||||
const lzo_bytep const ip_end = in + in_len - 20;
|
||||
const lzo_bytep ii;
|
||||
lzo_dict_p const dict = (lzo_dict_p) wrkmem;
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
ii = ip;
|
||||
|
||||
ip += ti < 4 ? 4 - ti : 0;
|
||||
for (;;)
|
||||
{
|
||||
const lzo_bytep m_pos;
|
||||
#if !(LZO_DETERMINISTIC)
|
||||
LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
|
||||
lzo_uint m_len;
|
||||
lzo_uint dindex;
|
||||
next:
|
||||
if __lzo_unlikely(ip >= ip_end)
|
||||
break;
|
||||
DINDEX1(dindex,ip);
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
|
||||
goto literal;
|
||||
#if 1
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
DINDEX2(dindex,ip);
|
||||
#endif
|
||||
GINDEX(m_pos,m_off,dict,dindex,in);
|
||||
if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
|
||||
goto literal;
|
||||
if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
|
||||
goto try_match;
|
||||
goto literal;
|
||||
|
||||
try_match:
|
||||
#if (LZO_OPT_UNALIGNED32)
|
||||
if (UA_GET_NE32(m_pos) != UA_GET_NE32(ip))
|
||||
#else
|
||||
if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3])
|
||||
#endif
|
||||
{
|
||||
/* a literal */
|
||||
literal:
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
ip += 1 + ((ip - ii) >> 5);
|
||||
continue;
|
||||
}
|
||||
/*match:*/
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
#else
|
||||
lzo_uint m_off;
|
||||
lzo_uint m_len;
|
||||
{
|
||||
lzo_uint32_t dv;
|
||||
lzo_uint dindex;
|
||||
literal:
|
||||
ip += 1 + ((ip - ii) >> 5);
|
||||
next:
|
||||
if __lzo_unlikely(ip >= ip_end)
|
||||
break;
|
||||
dv = UA_GET_LE32(ip);
|
||||
dindex = DINDEX(dv,ip);
|
||||
GINDEX(m_off,m_pos,in+dict,dindex,in);
|
||||
UPDATE_I(dict,0,dindex,ip,in);
|
||||
if __lzo_unlikely(dv != UA_GET_LE32(m_pos))
|
||||
goto literal;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* a match */
|
||||
|
||||
ii -= ti; ti = 0;
|
||||
{
|
||||
lzo_uint t = pd(ip,ii);
|
||||
if (t != 0)
|
||||
{
|
||||
if (t <= 3)
|
||||
{
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
#if (LZO_OPT_UNALIGNED32)
|
||||
UA_COPY4(op, ii);
|
||||
op += t;
|
||||
#else
|
||||
{ do *op++ = *ii++; while (--t > 0); }
|
||||
#endif
|
||||
}
|
||||
#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
|
||||
else if (t <= 16)
|
||||
{
|
||||
*op++ = LZO_BYTE(t - 3);
|
||||
UA_COPY8(op, ii);
|
||||
UA_COPY8(op+8, ii+8);
|
||||
op += t;
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
if (t <= 18)
|
||||
*op++ = LZO_BYTE(t - 3);
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 18;
|
||||
*op++ = 0;
|
||||
while __lzo_unlikely(tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
}
|
||||
#if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64)
|
||||
do {
|
||||
UA_COPY8(op, ii);
|
||||
UA_COPY8(op+8, ii+8);
|
||||
op += 16; ii += 16; t -= 16;
|
||||
} while (t >= 16); if (t > 0)
|
||||
#endif
|
||||
{ do *op++ = *ii++; while (--t > 0); }
|
||||
}
|
||||
}
|
||||
}
|
||||
m_len = 4;
|
||||
{
|
||||
#if (LZO_OPT_UNALIGNED64)
|
||||
lzo_uint64_t v;
|
||||
v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
|
||||
if __lzo_unlikely(v == 0) {
|
||||
do {
|
||||
m_len += 8;
|
||||
v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len);
|
||||
if __lzo_unlikely(ip + m_len >= ip_end)
|
||||
goto m_len_done;
|
||||
} while (v == 0);
|
||||
}
|
||||
#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz64)
|
||||
m_len += lzo_bitops_ctlz64(v) / CHAR_BIT;
|
||||
#elif (LZO_ABI_BIG_ENDIAN)
|
||||
if ((v >> (64 - CHAR_BIT)) == 0) do {
|
||||
v <<= CHAR_BIT;
|
||||
m_len += 1;
|
||||
} while ((v >> (64 - CHAR_BIT)) == 0);
|
||||
#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz64)
|
||||
m_len += lzo_bitops_cttz64(v) / CHAR_BIT;
|
||||
#elif (LZO_ABI_LITTLE_ENDIAN)
|
||||
if ((v & UCHAR_MAX) == 0) do {
|
||||
v >>= CHAR_BIT;
|
||||
m_len += 1;
|
||||
} while ((v & UCHAR_MAX) == 0);
|
||||
#else
|
||||
if (ip[m_len] == m_pos[m_len]) do {
|
||||
m_len += 1;
|
||||
} while (ip[m_len] == m_pos[m_len]);
|
||||
#endif
|
||||
#elif (LZO_OPT_UNALIGNED32)
|
||||
lzo_uint32_t v;
|
||||
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
|
||||
if __lzo_unlikely(v == 0) {
|
||||
do {
|
||||
m_len += 4;
|
||||
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
|
||||
if (v != 0)
|
||||
break;
|
||||
m_len += 4;
|
||||
v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len);
|
||||
if __lzo_unlikely(ip + m_len >= ip_end)
|
||||
goto m_len_done;
|
||||
} while (v == 0);
|
||||
}
|
||||
#if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz32)
|
||||
m_len += lzo_bitops_ctlz32(v) / CHAR_BIT;
|
||||
#elif (LZO_ABI_BIG_ENDIAN)
|
||||
if ((v >> (32 - CHAR_BIT)) == 0) do {
|
||||
v <<= CHAR_BIT;
|
||||
m_len += 1;
|
||||
} while ((v >> (32 - CHAR_BIT)) == 0);
|
||||
#elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz32)
|
||||
m_len += lzo_bitops_cttz32(v) / CHAR_BIT;
|
||||
#elif (LZO_ABI_LITTLE_ENDIAN)
|
||||
if ((v & UCHAR_MAX) == 0) do {
|
||||
v >>= CHAR_BIT;
|
||||
m_len += 1;
|
||||
} while ((v & UCHAR_MAX) == 0);
|
||||
#else
|
||||
if (ip[m_len] == m_pos[m_len]) do {
|
||||
m_len += 1;
|
||||
} while (ip[m_len] == m_pos[m_len]);
|
||||
#endif
|
||||
#else
|
||||
if __lzo_unlikely(ip[m_len] == m_pos[m_len]) {
|
||||
do {
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if (ip[m_len] != m_pos[m_len])
|
||||
break;
|
||||
m_len += 1;
|
||||
if __lzo_unlikely(ip + m_len >= ip_end)
|
||||
goto m_len_done;
|
||||
} while (ip[m_len] == m_pos[m_len]);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
m_len_done:
|
||||
m_off = pd(ip,m_pos);
|
||||
ip += m_len;
|
||||
ii = ip;
|
||||
if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
|
||||
{
|
||||
m_off -= 1;
|
||||
#if defined(LZO1X)
|
||||
*op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 3);
|
||||
#elif defined(LZO1Y)
|
||||
*op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2));
|
||||
*op++ = LZO_BYTE(m_off >> 2);
|
||||
#endif
|
||||
}
|
||||
else if (m_off <= M3_MAX_OFFSET)
|
||||
{
|
||||
m_off -= 1;
|
||||
if (m_len <= M3_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= M3_MAX_LEN;
|
||||
*op++ = M3_MARKER | 0;
|
||||
while __lzo_unlikely(m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_off -= 0x4000;
|
||||
if (m_len <= M4_MAX_LEN)
|
||||
*op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2));
|
||||
else
|
||||
{
|
||||
m_len -= M4_MAX_LEN;
|
||||
*op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8));
|
||||
while __lzo_unlikely(m_len > 255)
|
||||
{
|
||||
m_len -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
*op++ = LZO_BYTE(m_len);
|
||||
}
|
||||
*op++ = LZO_BYTE(m_off << 2);
|
||||
*op++ = LZO_BYTE(m_off >> 6);
|
||||
}
|
||||
goto next;
|
||||
}
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return pd(in_end,ii-ti);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// public entry point
|
||||
************************************************************************/
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
{
|
||||
const lzo_bytep ip = in;
|
||||
lzo_bytep op = out;
|
||||
lzo_uint l = in_len;
|
||||
lzo_uint t = 0;
|
||||
|
||||
while (l > 20)
|
||||
{
|
||||
lzo_uint ll = l;
|
||||
lzo_uintptr_t ll_end;
|
||||
#if 0 || (LZO_DETERMINISTIC)
|
||||
ll = LZO_MIN(ll, 49152);
|
||||
#endif
|
||||
ll_end = (lzo_uintptr_t)ip + ll;
|
||||
if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll)
|
||||
break;
|
||||
#if (LZO_DETERMINISTIC)
|
||||
lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t));
|
||||
#endif
|
||||
t = do_compress(ip,ll,op,out_len,t,wrkmem);
|
||||
ip += ll;
|
||||
op += *out_len;
|
||||
l -= ll;
|
||||
}
|
||||
t += l;
|
||||
|
||||
if (t > 0)
|
||||
{
|
||||
const lzo_bytep ii = in + in_len - t;
|
||||
|
||||
if (op == out && t <= 238)
|
||||
*op++ = LZO_BYTE(17 + t);
|
||||
else if (t <= 3)
|
||||
op[-2] = LZO_BYTE(op[-2] | t);
|
||||
else if (t <= 18)
|
||||
*op++ = LZO_BYTE(t - 3);
|
||||
else
|
||||
{
|
||||
lzo_uint tt = t - 18;
|
||||
|
||||
*op++ = 0;
|
||||
while (tt > 255)
|
||||
{
|
||||
tt -= 255;
|
||||
UA_SET1(op, 0);
|
||||
op++;
|
||||
}
|
||||
assert(tt > 0);
|
||||
*op++ = LZO_BYTE(tt);
|
||||
}
|
||||
UA_COPYN(op, ii, t);
|
||||
op += t;
|
||||
}
|
||||
|
||||
*op++ = M4_MARKER | 1;
|
||||
*op++ = 0;
|
||||
*op++ = 0;
|
||||
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OK;
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,475 @@
|
|||
/* lzo1x_d.ch -- implementation of the LZO1X decompression algorithm
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "lzo1_d.ch"
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
// decompress a block of data.
|
||||
************************************************************************/
|
||||
|
||||
#if defined(DO_DECOMPRESS)
|
||||
LZO_PUBLIC(int)
|
||||
DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem )
|
||||
#endif
|
||||
{
|
||||
lzo_bytep op;
|
||||
const lzo_bytep ip;
|
||||
lzo_uint t;
|
||||
#if defined(COPY_DICT)
|
||||
lzo_uint m_off;
|
||||
const lzo_bytep dict_end;
|
||||
#else
|
||||
const lzo_bytep m_pos;
|
||||
#endif
|
||||
|
||||
const lzo_bytep const ip_end = in + in_len;
|
||||
#if defined(HAVE_ANY_OP)
|
||||
lzo_bytep const op_end = out + *out_len;
|
||||
#endif
|
||||
#if defined(LZO1Z)
|
||||
lzo_uint last_m_off = 0;
|
||||
#endif
|
||||
|
||||
LZO_UNUSED(wrkmem);
|
||||
|
||||
#if defined(COPY_DICT)
|
||||
if (dict)
|
||||
{
|
||||
if (dict_len > M4_MAX_OFFSET)
|
||||
{
|
||||
dict += dict_len - M4_MAX_OFFSET;
|
||||
dict_len = M4_MAX_OFFSET;
|
||||
}
|
||||
dict_end = dict + dict_len;
|
||||
}
|
||||
else
|
||||
{
|
||||
dict_len = 0;
|
||||
dict_end = NULL;
|
||||
}
|
||||
#endif /* COPY_DICT */
|
||||
|
||||
*out_len = 0;
|
||||
|
||||
op = out;
|
||||
ip = in;
|
||||
|
||||
NEED_IP(1);
|
||||
if (*ip > 17)
|
||||
{
|
||||
t = *ip++ - 17;
|
||||
if (t < 4)
|
||||
goto match_next;
|
||||
assert(t > 0); NEED_OP(t); NEED_IP(t+3);
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
goto first_literal_run;
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
NEED_IP(3);
|
||||
t = *ip++;
|
||||
if (t >= 16)
|
||||
goto match;
|
||||
/* a literal run */
|
||||
if (t == 0)
|
||||
{
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_IV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += 15 + *ip++;
|
||||
}
|
||||
/* copy literals */
|
||||
assert(t > 0); NEED_OP(t+3); NEED_IP(t+6);
|
||||
#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
|
||||
t += 3;
|
||||
if (t >= 8) do
|
||||
{
|
||||
UA_COPY8(op,ip);
|
||||
op += 8; ip += 8; t -= 8;
|
||||
} while (t >= 8);
|
||||
if (t >= 4)
|
||||
{
|
||||
UA_COPY4(op,ip);
|
||||
op += 4; ip += 4; t -= 4;
|
||||
}
|
||||
if (t > 0)
|
||||
{
|
||||
*op++ = *ip++;
|
||||
if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
|
||||
}
|
||||
#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
|
||||
#if !(LZO_OPT_UNALIGNED32)
|
||||
if (PTR_ALIGNED2_4(op,ip))
|
||||
{
|
||||
#endif
|
||||
UA_COPY4(op,ip);
|
||||
op += 4; ip += 4;
|
||||
if (--t > 0)
|
||||
{
|
||||
if (t >= 4)
|
||||
{
|
||||
do {
|
||||
UA_COPY4(op,ip);
|
||||
op += 4; ip += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
#if !(LZO_OPT_UNALIGNED32)
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
#if !(LZO_OPT_UNALIGNED32)
|
||||
{
|
||||
*op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
first_literal_run:
|
||||
|
||||
|
||||
t = *ip++;
|
||||
if (t >= 16)
|
||||
goto match;
|
||||
#if defined(COPY_DICT)
|
||||
#if defined(LZO1Z)
|
||||
m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
|
||||
last_m_off = m_off;
|
||||
#else
|
||||
m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
|
||||
#endif
|
||||
NEED_OP(3);
|
||||
t = 3; COPY_DICT(t,m_off)
|
||||
#else /* !COPY_DICT */
|
||||
#if defined(LZO1Z)
|
||||
t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
|
||||
m_pos = op - t;
|
||||
last_m_off = t;
|
||||
#else
|
||||
m_pos = op - (1 + M2_MAX_OFFSET);
|
||||
m_pos -= t >> 2;
|
||||
m_pos -= *ip++ << 2;
|
||||
#endif
|
||||
TEST_LB(m_pos); NEED_OP(3);
|
||||
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
|
||||
#endif /* COPY_DICT */
|
||||
goto match_done;
|
||||
|
||||
|
||||
/* handle matches */
|
||||
for (;;) {
|
||||
match:
|
||||
if (t >= 64) /* a M2 match */
|
||||
{
|
||||
#if defined(COPY_DICT)
|
||||
#if defined(LZO1X)
|
||||
m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3);
|
||||
t = (t >> 5) - 1;
|
||||
#elif defined(LZO1Y)
|
||||
m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2);
|
||||
t = (t >> 4) - 3;
|
||||
#elif defined(LZO1Z)
|
||||
m_off = t & 0x1f;
|
||||
if (m_off >= 0x1c)
|
||||
m_off = last_m_off;
|
||||
else
|
||||
{
|
||||
m_off = 1 + (m_off << 6) + (*ip++ >> 2);
|
||||
last_m_off = m_off;
|
||||
}
|
||||
t = (t >> 5) - 1;
|
||||
#endif
|
||||
#else /* !COPY_DICT */
|
||||
#if defined(LZO1X)
|
||||
m_pos = op - 1;
|
||||
m_pos -= (t >> 2) & 7;
|
||||
m_pos -= *ip++ << 3;
|
||||
t = (t >> 5) - 1;
|
||||
#elif defined(LZO1Y)
|
||||
m_pos = op - 1;
|
||||
m_pos -= (t >> 2) & 3;
|
||||
m_pos -= *ip++ << 2;
|
||||
t = (t >> 4) - 3;
|
||||
#elif defined(LZO1Z)
|
||||
{
|
||||
lzo_uint off = t & 0x1f;
|
||||
m_pos = op;
|
||||
if (off >= 0x1c)
|
||||
{
|
||||
assert(last_m_off > 0);
|
||||
m_pos -= last_m_off;
|
||||
}
|
||||
else
|
||||
{
|
||||
off = 1 + (off << 6) + (*ip++ >> 2);
|
||||
m_pos -= off;
|
||||
last_m_off = off;
|
||||
}
|
||||
}
|
||||
t = (t >> 5) - 1;
|
||||
#endif
|
||||
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
|
||||
goto copy_match;
|
||||
#endif /* COPY_DICT */
|
||||
}
|
||||
else if (t >= 32) /* a M3 match */
|
||||
{
|
||||
t &= 31;
|
||||
if (t == 0)
|
||||
{
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_OV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += 31 + *ip++;
|
||||
NEED_IP(2);
|
||||
}
|
||||
#if defined(COPY_DICT)
|
||||
#if defined(LZO1Z)
|
||||
m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
|
||||
last_m_off = m_off;
|
||||
#else
|
||||
m_off = 1 + (ip[0] >> 2) + (ip[1] << 6);
|
||||
#endif
|
||||
#else /* !COPY_DICT */
|
||||
#if defined(LZO1Z)
|
||||
{
|
||||
lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2);
|
||||
m_pos = op - off;
|
||||
last_m_off = off;
|
||||
}
|
||||
#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
|
||||
m_pos = op - 1;
|
||||
m_pos -= UA_GET_LE16(ip) >> 2;
|
||||
#else
|
||||
m_pos = op - 1;
|
||||
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
|
||||
#endif
|
||||
#endif /* COPY_DICT */
|
||||
ip += 2;
|
||||
}
|
||||
else if (t >= 16) /* a M4 match */
|
||||
{
|
||||
#if defined(COPY_DICT)
|
||||
m_off = (t & 8) << 11;
|
||||
#else /* !COPY_DICT */
|
||||
m_pos = op;
|
||||
m_pos -= (t & 8) << 11;
|
||||
#endif /* COPY_DICT */
|
||||
t &= 7;
|
||||
if (t == 0)
|
||||
{
|
||||
while (*ip == 0)
|
||||
{
|
||||
t += 255;
|
||||
ip++;
|
||||
TEST_OV(t);
|
||||
NEED_IP(1);
|
||||
}
|
||||
t += 7 + *ip++;
|
||||
NEED_IP(2);
|
||||
}
|
||||
#if defined(COPY_DICT)
|
||||
#if defined(LZO1Z)
|
||||
m_off += (ip[0] << 6) + (ip[1] >> 2);
|
||||
#else
|
||||
m_off += (ip[0] >> 2) + (ip[1] << 6);
|
||||
#endif
|
||||
ip += 2;
|
||||
if (m_off == 0)
|
||||
goto eof_found;
|
||||
m_off += 0x4000;
|
||||
#if defined(LZO1Z)
|
||||
last_m_off = m_off;
|
||||
#endif
|
||||
#else /* !COPY_DICT */
|
||||
#if defined(LZO1Z)
|
||||
m_pos -= (ip[0] << 6) + (ip[1] >> 2);
|
||||
#elif (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN)
|
||||
m_pos -= UA_GET_LE16(ip) >> 2;
|
||||
#else
|
||||
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
|
||||
#endif
|
||||
ip += 2;
|
||||
if (m_pos == op)
|
||||
goto eof_found;
|
||||
m_pos -= 0x4000;
|
||||
#if defined(LZO1Z)
|
||||
last_m_off = pd((const lzo_bytep)op, m_pos);
|
||||
#endif
|
||||
#endif /* COPY_DICT */
|
||||
}
|
||||
else /* a M1 match */
|
||||
{
|
||||
#if defined(COPY_DICT)
|
||||
#if defined(LZO1Z)
|
||||
m_off = 1 + (t << 6) + (*ip++ >> 2);
|
||||
last_m_off = m_off;
|
||||
#else
|
||||
m_off = 1 + (t >> 2) + (*ip++ << 2);
|
||||
#endif
|
||||
NEED_OP(2);
|
||||
t = 2; COPY_DICT(t,m_off)
|
||||
#else /* !COPY_DICT */
|
||||
#if defined(LZO1Z)
|
||||
t = 1 + (t << 6) + (*ip++ >> 2);
|
||||
m_pos = op - t;
|
||||
last_m_off = t;
|
||||
#else
|
||||
m_pos = op - 1;
|
||||
m_pos -= t >> 2;
|
||||
m_pos -= *ip++ << 2;
|
||||
#endif
|
||||
TEST_LB(m_pos); NEED_OP(2);
|
||||
*op++ = *m_pos++; *op++ = *m_pos;
|
||||
#endif /* COPY_DICT */
|
||||
goto match_done;
|
||||
}
|
||||
|
||||
/* copy match */
|
||||
#if defined(COPY_DICT)
|
||||
|
||||
NEED_OP(t+3-1);
|
||||
t += 3-1; COPY_DICT(t,m_off)
|
||||
|
||||
#else /* !COPY_DICT */
|
||||
|
||||
TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
|
||||
#if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32)
|
||||
if (op - m_pos >= 8)
|
||||
{
|
||||
t += (3 - 1);
|
||||
if (t >= 8) do
|
||||
{
|
||||
UA_COPY8(op,m_pos);
|
||||
op += 8; m_pos += 8; t -= 8;
|
||||
} while (t >= 8);
|
||||
if (t >= 4)
|
||||
{
|
||||
UA_COPY4(op,m_pos);
|
||||
op += 4; m_pos += 4; t -= 4;
|
||||
}
|
||||
if (t > 0)
|
||||
{
|
||||
*op++ = m_pos[0];
|
||||
if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
|
||||
}
|
||||
}
|
||||
else
|
||||
#elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4)
|
||||
#if !(LZO_OPT_UNALIGNED32)
|
||||
if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos))
|
||||
{
|
||||
assert((op - m_pos) >= 4); /* both pointers are aligned */
|
||||
#else
|
||||
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
|
||||
{
|
||||
#endif
|
||||
UA_COPY4(op,m_pos);
|
||||
op += 4; m_pos += 4; t -= 4 - (3 - 1);
|
||||
do {
|
||||
UA_COPY4(op,m_pos);
|
||||
op += 4; m_pos += 4; t -= 4;
|
||||
} while (t >= 4);
|
||||
if (t > 0) do *op++ = *m_pos++; while (--t > 0);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
copy_match:
|
||||
*op++ = *m_pos++; *op++ = *m_pos++;
|
||||
do *op++ = *m_pos++; while (--t > 0);
|
||||
}
|
||||
|
||||
#endif /* COPY_DICT */
|
||||
|
||||
match_done:
|
||||
#if defined(LZO1Z)
|
||||
t = ip[-1] & 3;
|
||||
#else
|
||||
t = ip[-2] & 3;
|
||||
#endif
|
||||
if (t == 0)
|
||||
break;
|
||||
|
||||
/* copy literals */
|
||||
match_next:
|
||||
assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3);
|
||||
#if 0
|
||||
do *op++ = *ip++; while (--t > 0);
|
||||
#else
|
||||
*op++ = *ip++;
|
||||
if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
|
||||
#endif
|
||||
t = *ip++;
|
||||
}
|
||||
}
|
||||
|
||||
eof_found:
|
||||
*out_len = pd(op, out);
|
||||
return (ip == ip_end ? LZO_E_OK :
|
||||
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
||||
|
||||
|
||||
#if defined(HAVE_NEED_IP)
|
||||
input_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_INPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(HAVE_NEED_OP)
|
||||
output_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_OUTPUT_OVERRUN;
|
||||
#endif
|
||||
|
||||
#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
|
||||
lookbehind_overrun:
|
||||
*out_len = pd(op, out);
|
||||
return LZO_E_LOOKBEHIND_OVERRUN;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
/* lzo1x_d1.c -- LZO1X decompression
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1x.h"
|
||||
|
||||
#undef LZO_TEST_OVERRUN
|
||||
#define DO_DECOMPRESS lzo1x_decompress
|
||||
|
||||
#include "lzo1x_d.ch"
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
/* lzo1x_d2.c -- LZO1X decompression with overrun testing
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1x.h"
|
||||
|
||||
#define LZO_TEST_OVERRUN 1
|
||||
#define DO_DECOMPRESS lzo1x_decompress_safe
|
||||
|
||||
#include "lzo1x_d.ch"
|
||||
|
||||
#if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM)
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_PUBLIC(int) lzo1x_decompress_asm_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem)
|
||||
{
|
||||
return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem);
|
||||
}
|
||||
LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem);
|
||||
LZO_PUBLIC(int) lzo1x_decompress_asm_fast_safe
|
||||
(const lzo_bytep src, lzo_uint src_len,
|
||||
lzo_bytep dst, lzo_uintp dst_len,
|
||||
lzo_voidp wrkmem)
|
||||
{
|
||||
return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/* lzo1x_d3.c -- LZO1X decompression with preset dictionary
|
||||
|
||||
This file is part of the LZO real-time data compression library.
|
||||
|
||||
Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
|
||||
All Rights Reserved.
|
||||
|
||||
The LZO library 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.
|
||||
|
||||
The LZO library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with the LZO library; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
|
||||
Markus F.X.J. Oberhumer
|
||||
<markus@oberhumer.com>
|
||||
http://www.oberhumer.com/opensource/lzo/
|
||||
*/
|
||||
|
||||
|
||||
#include "config1x.h"
|
||||
|
||||
#define LZO_TEST_OVERRUN 1
|
||||
|
||||
|
||||
#define SLOW_MEMCPY(a,b,l) { do *a++ = *b++; while (--l > 0); }
|
||||
#define FAST_MEMCPY(a,b,l) { lzo_memcpy(a,b,l); a += l; }
|
||||
|
||||
#if 1 && defined(FAST_MEMCPY)
|
||||
# define DICT_MEMMOVE(op,m_pos,m_len,m_off) \
|
||||
if (m_off >= (m_len)) \
|
||||
FAST_MEMCPY(op,m_pos,m_len) \
|
||||
else \
|
||||
SLOW_MEMCPY(op,m_pos,m_len)
|
||||
#else
|
||||
# define DICT_MEMMOVE(op,m_pos,m_len,m_off) \
|
||||
SLOW_MEMCPY(op,m_pos,m_len)
|
||||
#endif
|
||||
|
||||
#if !defined(FAST_MEMCPY)
|
||||
# define FAST_MEMCPY SLOW_MEMCPY
|
||||
#endif
|
||||
|
||||
|
||||
#define COPY_DICT_DICT(m_len,m_off) \
|
||||
{ \
|
||||
const lzo_bytep m_pos; \
|
||||
m_off -= pd(op, out); assert(m_off > 0); \
|
||||
if (m_off > dict_len) goto lookbehind_overrun; \
|
||||
m_pos = dict_end - m_off; \
|
||||
if (m_len > m_off) \
|
||||
{ \
|
||||
m_len -= m_off; \
|
||||
FAST_MEMCPY(op,m_pos,m_off) \
|
||||
m_pos = out; \
|
||||
SLOW_MEMCPY(op,m_pos,m_len) \
|
||||
} \
|
||||
else \
|
||||
FAST_MEMCPY(op,m_pos,m_len) \
|
||||
}
|
||||
|
||||
#define COPY_DICT(m_len,m_off) \
|
||||
assert(m_len >= 2); assert(m_off > 0); assert(op > out); \
|
||||
if (m_off <= pd(op, out)) \
|
||||
{ \
|
||||
const lzo_bytep m_pos = op - m_off; \
|
||||
DICT_MEMMOVE(op,m_pos,m_len,m_off) \
|
||||
} \
|
||||
else \
|
||||
COPY_DICT_DICT(m_len,m_off)
|
||||
|
||||
|
||||
|
||||
|
||||
LZO_PUBLIC(int)
|
||||
lzo1x_decompress_dict_safe ( const lzo_bytep in, lzo_uint in_len,
|
||||
lzo_bytep out, lzo_uintp out_len,
|
||||
lzo_voidp wrkmem /* NOT USED */,
|
||||
const lzo_bytep dict, lzo_uint dict_len)
|
||||
|
||||
|
||||
#include "lzo1x_d.ch"
|
||||
|
||||
|
||||
/* vim:set ts=4 sw=4 et: */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue