ICNSTranslator: use outsourced package libicns
* clean up Copyrights section. * libicns becomes a default package
This commit is contained in:
Jérôme Duval
@@ -27,8 +27,8 @@ AddHaikuImagePackages [ FFilterByBuildFeatures
|
||||
|
||||
regular_image @{
|
||||
bzip2 ctags ffmpeg findutils gawk glu grep gutenprint jasper jpeg less
|
||||
libpng libwebp mesa mesa_devel mesa_swrast sed sharutils tar tiff wget
|
||||
which
|
||||
libicns libpng libwebp mesa mesa_devel mesa_swrast sed sharutils tar
|
||||
tiff wget which
|
||||
}@
|
||||
] ;
|
||||
if $(HAIKU_PACKAGING_ARCHS[1]) != x86_gcc2 {
|
||||
@@ -45,7 +45,7 @@ if $(HAIKU_PACKAGING_ARCHS[2]) {
|
||||
curl freetype icu libsolv zlib
|
||||
|
||||
regular_image @{
|
||||
ffmpeg glu jasper jpeg libpng libwebp mesa
|
||||
ffmpeg glu jasper jpeg libicns libpng libwebp mesa
|
||||
}@
|
||||
] ;
|
||||
if $(TARGET_PACKAGING_ARCH) != x86_gcc2 {
|
||||
|
||||
@@ -16,10 +16,6 @@
|
||||
#undef B_TRANSLATION_CONTEXT
|
||||
#define B_TRANSLATION_CONTEXT "ICNSConfig"
|
||||
|
||||
extern "C" {
|
||||
#include <openjpeg.h>
|
||||
};
|
||||
|
||||
|
||||
ConfigView::ConfigView(TranslatorSettings *settings)
|
||||
: BGroupView("ICNSTranslator Settings", B_VERTICAL, 0)
|
||||
@@ -71,10 +67,7 @@ ConfigView::ConfigView(TranslatorSettings *settings)
|
||||
|
||||
BString copyrightText;
|
||||
copyrightText << "libicns v0.8.1\n"
|
||||
<< B_UTF8_COPYRIGHT "2001-2012 Mathew Eis <[email protected]>\n\n"
|
||||
<< "OpenJPEG " << opj_version() << "\n"
|
||||
<< B_UTF8_COPYRIGHT "2002-2012, Communications and Remote Sensing "
|
||||
<< "Laboratory, Universite catholique de Louvain (UCL), Belgium";
|
||||
<< B_UTF8_COPYRIGHT "2001-2012 Mathew Eis <[email protected]>";
|
||||
|
||||
fCopyrightView = new BTextView("CopyrightLibs");
|
||||
fCopyrightView->SetExplicitAlignment(leftAlignment);
|
||||
|
||||
@@ -2,68 +2,19 @@ SubDir HAIKU_TOP src add-ons translators icns ;
|
||||
|
||||
SetSubDirSupportedPlatformsBeOSCompatible ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) openjpeg ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) libicns ] ;
|
||||
|
||||
SubDirHdrs [ FDirName $(SUBDIR) $(DOTDOT) shared ] ;
|
||||
#for BaseTranslator.h and friends
|
||||
|
||||
SubDirC++Flags [ FDefines BEOS_R5_COMPATIBLE ] ;
|
||||
|
||||
local openjpeg_files =
|
||||
bio.c
|
||||
cio.c
|
||||
dwt.c
|
||||
event.c
|
||||
image.c
|
||||
j2k.c
|
||||
j2k_lib.c
|
||||
jp2.c
|
||||
jpt.c
|
||||
mct.c
|
||||
mqc.c
|
||||
openjpeg.c
|
||||
pi.c
|
||||
raw.c
|
||||
t1.c
|
||||
t2.c
|
||||
tcd.c
|
||||
tgt.c
|
||||
cidx_manager.c
|
||||
phix_manager.c
|
||||
ppix_manager.c
|
||||
thix_manager.c
|
||||
tpix_manager.c
|
||||
;
|
||||
|
||||
ObjectCcFlags [ FGristFiles $(openjpeg_files:S=$(SUFOBJ)) ] : -w ;
|
||||
|
||||
local libicns_files =
|
||||
icns_debug.c
|
||||
icns_element.c
|
||||
icns_family.c
|
||||
icns_image.c
|
||||
icns_io.c
|
||||
icns_jp2.c
|
||||
icns_png.c
|
||||
icns_rle24.c
|
||||
icns_utils.c
|
||||
;
|
||||
|
||||
ObjectCcFlags [ FGristFiles $(libicns_files:S=$(SUFOBJ)) ] : -w ;
|
||||
|
||||
AddResources ICNSTranslator : ICNSTranslator.rdef ;
|
||||
|
||||
local architectureObject ;
|
||||
for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
on $(architectureObject) {
|
||||
# Let Jam know where to find some of our source files
|
||||
SEARCH_SOURCE += [ FDirName $(SUBDIR) openjpeg ] ;
|
||||
SEARCH_SOURCE += [ FDirName $(SUBDIR) libicns ] ;
|
||||
UseBuildFeatureHeaders libicns ;
|
||||
|
||||
UseBuildFeatureHeaders libpng ;
|
||||
Includes [ FGristFiles icns_png.c ]
|
||||
: [ BuildFeatureAttribute libpng : headers ] ;
|
||||
Translator [ MultiArchDefaultGristFiles ICNSTranslator ] :
|
||||
|
||||
# ICNSTranslator
|
||||
@@ -72,17 +23,18 @@ for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
ConfigView.cpp
|
||||
main.cpp
|
||||
|
||||
$(openjpeg_files)
|
||||
|
||||
$(libicns_files)
|
||||
|
||||
: be translation
|
||||
[ MultiArchDefaultGristFiles libtranslatorsutils.a ]
|
||||
[ TargetLibsupc++ ]
|
||||
[ BuildFeatureAttribute libicns : library ]
|
||||
[ BuildFeatureAttribute jasper : library ]
|
||||
[ BuildFeatureAttribute libpng : library ]
|
||||
localestub
|
||||
: true
|
||||
;
|
||||
|
||||
Includes [ FGristFiles ICNSTranslator.cpp ICNSLoader.cpp ]
|
||||
: [ BuildFeatureAttribute libicns : headers ] ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,481 +0,0 @@
|
||||
GNU LIBRARY GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1991 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the library GPL. It is
|
||||
numbered 2 because it goes with version 2 of the ordinary GPL.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Library General Public License, applies to some
|
||||
specially designated Free Software Foundation software, and to any
|
||||
other libraries whose authors decide to use it. You can use it for
|
||||
your libraries, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if
|
||||
you distribute copies of the library, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link a program with the library, you must provide
|
||||
complete object files to the recipients so that they can relink them
|
||||
with the library, after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
Our method of protecting your rights has two steps: (1) copyright
|
||||
the library, and (2) offer you this license which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
Also, for each distributor's protection, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
library. If the library is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original
|
||||
version, so that any problems introduced by others will not reflect on
|
||||
the original authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that companies distributing free
|
||||
software will individually obtain patent licenses, thus in effect
|
||||
transforming the program into proprietary software. To prevent this,
|
||||
we have made it clear that any patent must be licensed for everyone's
|
||||
free use or not licensed at all.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the ordinary
|
||||
GNU General Public License, which was designed for utility programs. This
|
||||
license, the GNU Library General Public License, applies to certain
|
||||
designated libraries. This license is quite different from the ordinary
|
||||
one; be sure to read it in full, and don't assume that anything in it is
|
||||
the same as in the ordinary license.
|
||||
|
||||
The reason we have a separate public license for some libraries is that
|
||||
they blur the distinction we usually make between modifying or adding to a
|
||||
program and simply using it. Linking a program with a library, without
|
||||
changing the library, is in some sense simply using the library, and is
|
||||
analogous to running a utility program or application program. However, in
|
||||
a textual and legal sense, the linked executable is a combined work, a
|
||||
derivative of the original library, and the ordinary General Public License
|
||||
treats it as such.
|
||||
|
||||
Because of this blurred distinction, using the ordinary General
|
||||
Public License for libraries did not effectively promote software
|
||||
sharing, because most developers did not use the libraries. We
|
||||
concluded that weaker conditions might promote sharing better.
|
||||
|
||||
However, unrestricted linking of non-free programs would deprive the
|
||||
users of those programs of all benefit from the free status of the
|
||||
libraries themselves. This Library General Public License is intended to
|
||||
permit developers of non-free programs to use free libraries, while
|
||||
preserving your freedom as a user of such programs to change the free
|
||||
libraries that are incorporated in them. (We have not seen how to achieve
|
||||
this as regards changes in header files, but we have achieved it as regards
|
||||
changes in the actual functions of the Library.) The hope is that this
|
||||
will lead to faster development of free libraries.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, while the latter only
|
||||
works together with the library.
|
||||
|
||||
Note that it is possible for a library to be covered by the ordinary
|
||||
General Public License rather than by this special one.
|
||||
|
||||
GNU LIBRARY GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library which
|
||||
contains a notice placed by the copyright holder or other authorized
|
||||
party saying it may be distributed under the terms of this Library
|
||||
General Public License (also called "this License"). Each licensee is
|
||||
addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also compile or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
c) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
d) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the source code distributed need not include anything that is normally
|
||||
distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Library General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms of the
|
||||
ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library. It is
|
||||
safest to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least the
|
||||
"copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the library, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
@@ -1,118 +0,0 @@
|
||||
===============================================================================
|
||||
README for libicns 0.8.1 - June 14, 2012
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
|
||||
Other individuals have supported the development of libicns; they are credited
|
||||
in the source files where their respective contibutions have been made.
|
||||
|
||||
===============================================================================
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
|
||||
===============================================================================
|
||||
This package include the following libraries and utilities:
|
||||
1) libicns - A library for the translation of the icns format
|
||||
2) icns2png - A utility for converting icns files into png images
|
||||
3) icontainer2icns - A utility for extracting icns files from icontainer packs
|
||||
|
||||
You should be able to get the latest version at http://sf.net/projects/icns
|
||||
|
||||
===============================================================================
|
||||
libicns is a library for manipulation of the Mac OS icns resource format, also
|
||||
known as the IconFamily resource type. It can read and write files from the
|
||||
Mac OS X icns format, as well as read from Mac OS resource files and macbinary
|
||||
encoded Mac OS resource forks.
|
||||
|
||||
As of release 0.5.9, it can fully manipulate any 128x128 and smaller 32-bit
|
||||
icons, and has partial support for manipulating 8-bit, 4-bit, and 1-bit icons.
|
||||
|
||||
When linked with Jasper, it also has full support for 256x256 and 512x512
|
||||
icon sizes within the icon family.
|
||||
|
||||
As of release 0.8.0, it can read the PNG format introduced with OS X Lion 10.7
|
||||
|
||||
|
||||
Please see DEVNOTES for more information on how to use libicns
|
||||
|
||||
===============================================================================
|
||||
Using icns2png
|
||||
|
||||
icns2png -x OmniWeb.icns
|
||||
Converting OmniWeb.icns to OmniWeb_128x128x32.png...
|
||||
|
||||
This will result in a file OmniWeb_128x128x32.png with a 128x128 icon from OmniWeb.icns.
|
||||
|
||||
Run icns2png --help for more detailed information.
|
||||
|
||||
===============================================================================
|
||||
Using icontainer2icns
|
||||
|
||||
icontainer2icns foo.icontainer
|
||||
|
||||
This will end up with a couple of icns files identified by the iContainer ID
|
||||
and the iContainer name in a (new) folder carrying the icontainer name
|
||||
(without any suffix)
|
||||
|
||||
===============================================================================
|
||||
NOTICE: icontainer2icns is NOT related to www.iconfactory.com - though it
|
||||
decodes this library type. They are NOT involved, please don't bother them
|
||||
with bug reports.
|
||||
|
||||
For bug/wishes regarding icontainer2icns mailto: [email protected]
|
||||
|
||||
===============================================================================
|
||||
Understanding the Mac OS X Icons
|
||||
|
||||
Mac OS X Icon files come in two formats - icns files, and icns resources
|
||||
embedded with rsrc files. They may also be stored in a macbinary encoded
|
||||
rsrc files, or applesingle/appledouble encoded rsrc files
|
||||
|
||||
libicns (and icns2png) can decode all five storage formats
|
||||
|
||||
The .icns files are much easier to deal with, since they are in a format that
|
||||
can be easily accesed from Linux/UNIX/Windows.
|
||||
|
||||
You can however access the icons from the resource files. OS X Icons like
|
||||
those from http://interfacelift.com/icons-mac/ are compressed in .sit files.
|
||||
These files can be uncompressed using Aladdin Stuffit Expander for Linux,
|
||||
which can be obtained from http://www.stuffit.com/unix/index.html
|
||||
|
||||
When unstuffing, be sure to use a command similar to the following:
|
||||
|
||||
unstuff --text=auto --macbinary=auto --eol=unix icons.hqx.sit
|
||||
|
||||
This will help ensure that the resource forks are uncompressed into
|
||||
MacBinary files, so that icns2png can read them.
|
||||
|
||||
If there are resource forks in the files, when stuffit decompresses them,
|
||||
it will create two files from the one mac file. For example, if the mac
|
||||
file was named "Gnu", the resulting decomressed files will be
|
||||
"Gnu", and "Gnu_1". The "Snowflake_1" file is the resource
|
||||
fork. This is the file you will want to extract the icon from. The file
|
||||
"Gnu" does not contain any icon data. If, however, there is no
|
||||
"Gnu_1", then the file may be in the .icns format, and you will
|
||||
extract the icon from "Gnu" - resulting in a file "Gnu.png"
|
||||
|
||||
It is really fairly simple, once you get the hang of it - you will also
|
||||
notice that if the icon was in the resource fork, then the other main
|
||||
file will be etremely small, sometimes even 0k.
|
||||
|
||||
The underlying data in both of the files is similar - they both hold the
|
||||
following icon data (Although most icons to not have a complete set):
|
||||
16x12 pixels - 1 bit mask - 1, 4, or 8 bit icon
|
||||
16x16 pixels - 1 or 8 bit mask - 1, 4, 8 or 24 bit icon
|
||||
32x32 pixels - 1 or 8 bit mask - 1, 4, 8, or 24 bit icon
|
||||
64x64 pixels - 1 or 8 bit mask - 1, 4, 8, or 24 bit icon
|
||||
128x128 pixels - 8 bit mask - 24 bit icon
|
||||
@@ -1,30 +0,0 @@
|
||||
#define HAVE_DLFCN_H 1
|
||||
#define HAVE_FORK 1
|
||||
#define HAVE_GETOPT_H 1
|
||||
#define HAVE_INTTYPES_H 1
|
||||
#define HAVE_MEMORY_H 1
|
||||
#define HAVE_PNG_H 1
|
||||
#define HAVE_STDINT_H 1
|
||||
#define HAVE_STDLIB_H 1
|
||||
#define HAVE_STRINGS_H 1
|
||||
#define HAVE_STRING_H 1
|
||||
#define HAVE_SYS_STAT_H 1
|
||||
#define HAVE_SYS_TYPES_H 1
|
||||
#define HAVE_UNALIGNED_MEMCPY 1
|
||||
#define HAVE_UNISTD_H 1
|
||||
#define HAVE_VFORK 1
|
||||
#define HAVE_WORKING_FORK 1
|
||||
#define HAVE_WORKING_VFORK 1
|
||||
#define ICNS_OPENJPEG 1
|
||||
#define STDC_HEADERS 1
|
||||
#define VERSION "0.8.1"
|
||||
|
||||
#if defined AC_APPLE_UNIVERSAL_BUILD
|
||||
# if defined __BIG_ENDIAN__
|
||||
# define WORDS_BIGENDIAN 1
|
||||
# endif
|
||||
#else
|
||||
# ifndef WORDS_BIGENDIAN
|
||||
/* # undef WORDS_BIGENDIAN */
|
||||
# endif
|
||||
#endif
|
||||
@@ -1,212 +0,0 @@
|
||||
/*
|
||||
File: icns.h
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
Copyright (C) 2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
With the exception of the limited portions mentiond, this library
|
||||
is free software; you can redistribute it and/or modify it under
|
||||
the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation; either version 2.1 of the License,
|
||||
or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef _ICNS_H_
|
||||
#define _ICNS_H_
|
||||
|
||||
/* basic data types */
|
||||
typedef uint8_t icns_bool_t;
|
||||
|
||||
typedef uint8_t icns_uint8_t;
|
||||
typedef int8_t icns_sint8_t;
|
||||
typedef uint16_t icns_uint16_t;
|
||||
typedef int16_t icns_sint16_t;
|
||||
typedef uint32_t icns_uint32_t;
|
||||
typedef int32_t icns_sint32_t;
|
||||
typedef uint64_t icns_uint64_t;
|
||||
typedef int64_t icns_sint64_t;
|
||||
|
||||
typedef uint8_t icns_byte_t;
|
||||
|
||||
|
||||
/* data header types */
|
||||
typedef uint32_t icns_type_t;
|
||||
typedef int32_t icns_size_t;
|
||||
|
||||
/* icon family and element types */
|
||||
typedef struct icns_element_t {
|
||||
icns_type_t elementType; /* 'ICN#', 'icl8', etc... */
|
||||
icns_size_t elementSize; /* Total size of element */
|
||||
icns_byte_t elementData[1]; /* icon image data */
|
||||
} icns_element_t;
|
||||
|
||||
typedef struct icns_family_t {
|
||||
icns_type_t resourceType; /* Always should be 'icns' */
|
||||
icns_size_t resourceSize; /* Total size of resource */
|
||||
icns_element_t elements[1]; /* icon elements */
|
||||
} icns_family_t;
|
||||
|
||||
/* icon image data structure */
|
||||
typedef struct icns_image_t
|
||||
{
|
||||
icns_uint32_t imageWidth; // width of image in pixels
|
||||
icns_uint32_t imageHeight; // height of image in pixels
|
||||
icns_uint8_t imageChannels; // number of channels in data
|
||||
icns_uint16_t imagePixelDepth;// number of bits-per-pixel
|
||||
icns_uint64_t imageDataSize; // bytes = width * height * depth / bits-per-pixel
|
||||
icns_byte_t *imageData; // pointer to base address of uncompressed raw image data
|
||||
} icns_image_t;
|
||||
|
||||
/* used for getting information about various types */
|
||||
/* not part of the actual icns data format */
|
||||
typedef struct icns_icon_info_t
|
||||
{
|
||||
icns_type_t iconType; // type of icon (or mask)
|
||||
icns_bool_t isImage; // is this type an image
|
||||
icns_bool_t isMask; // is this type a mask
|
||||
icns_uint32_t iconWidth; // width of icon in pixels
|
||||
icns_uint32_t iconHeight; // height of icon in pixels
|
||||
icns_uint8_t iconChannels; // number of channels in data
|
||||
icns_uint16_t iconPixelDepth; // number of bits-per-pixel
|
||||
icns_uint16_t iconBitDepth; // overall bit depth = iconPixelDepth * iconChannels
|
||||
icns_uint64_t iconRawDataSize; // uncompressed bytes = width * height * depth / bits-per-pixel
|
||||
} icns_icon_info_t;
|
||||
|
||||
/* icns element type constants */
|
||||
|
||||
#define ICNS_TABLE_OF_CONTENTS 0x544F4320 // "TOC "
|
||||
|
||||
#define ICNS_ICON_VERSION 0x69636E56 // "icnV"
|
||||
|
||||
#define ICNS_1024x1024_32BIT_ARGB_DATA 0x69633130 // "ic10"
|
||||
|
||||
#define ICNS_512x512_32BIT_ARGB_DATA 0x69633039 // "ic09"
|
||||
#define ICNS_256x256_32BIT_ARGB_DATA 0x69633038 // "ic08"
|
||||
|
||||
#define ICNS_128X128_32BIT_DATA 0x69743332 // "it32"
|
||||
#define ICNS_128X128_8BIT_MASK 0x74386D6B // "t8mk"
|
||||
|
||||
#define ICNS_48x48_1BIT_DATA 0x69636823 // "ich#"
|
||||
#define ICNS_48x48_4BIT_DATA 0x69636834 // "ich4"
|
||||
#define ICNS_48x48_8BIT_DATA 0x69636838 // "ich8"
|
||||
#define ICNS_48x48_32BIT_DATA 0x69683332 // "ih32"
|
||||
#define ICNS_48x48_1BIT_MASK 0x69636823 // "ich#"
|
||||
#define ICNS_48x48_8BIT_MASK 0x68386D6B // "h8mk"
|
||||
|
||||
#define ICNS_32x32_1BIT_DATA 0x49434E23 // "ICN#"
|
||||
#define ICNS_32x32_4BIT_DATA 0x69636C34 // "icl4"
|
||||
#define ICNS_32x32_8BIT_DATA 0x69636C38 // "icl8"
|
||||
#define ICNS_32x32_32BIT_DATA 0x696C3332 // "il32"
|
||||
#define ICNS_32x32_1BIT_MASK 0x49434E23 // "ICN#"
|
||||
#define ICNS_32x32_8BIT_MASK 0x6C386D6B // "l8mk"
|
||||
|
||||
#define ICNS_16x16_1BIT_DATA 0x69637323 // "ics#"
|
||||
#define ICNS_16x16_4BIT_DATA 0x69637334 // "ics4"
|
||||
#define ICNS_16x16_8BIT_DATA 0x69637338 // "ics8"
|
||||
#define ICNS_16x16_32BIT_DATA 0x69733332 // "is32"
|
||||
#define ICNS_16x16_1BIT_MASK 0x69637323 // "ics#"
|
||||
#define ICNS_16x16_8BIT_MASK 0x73386D6B // "s8mk"
|
||||
|
||||
#define ICNS_16x12_1BIT_DATA 0x69636D23 // "icm#"
|
||||
#define ICNS_16x12_4BIT_DATA 0x69636D34 // "icm4"
|
||||
#define ICNS_16x12_1BIT_MASK 0x69636D23 // "icm#"
|
||||
#define ICNS_16x12_8BIT_DATA 0x69636D38 // "icm8"
|
||||
|
||||
#define ICNS_32x32_1BIT_ICON 0x49434F4E // "ICON"
|
||||
|
||||
#define ICNS_TILE_VARIANT 0x74696C65 // "tile"
|
||||
#define ICNS_ROLLOVER_VARIANT 0x6F766572 // "over"
|
||||
#define ICNS_DROP_VARIANT 0x64726F70 // "drop"
|
||||
#define ICNS_OPEN_VARIANT 0x6F70656E // "open"
|
||||
#define ICNS_OPEN_DROP_VARIANT 0x6F647270 // "odrp"
|
||||
|
||||
#define ICNS_NULL_DATA 0x00000000
|
||||
#define ICNS_NULL_MASK 0x00000000
|
||||
|
||||
/* icns file / resource type constants */
|
||||
|
||||
#define ICNS_FAMILY_TYPE 0x69636E73 // "icns"
|
||||
|
||||
#define ICNS_MACBINARY_TYPE 0x6D42494E // "mBIN"
|
||||
|
||||
#define ICNS_NULL_TYPE 0x00000000
|
||||
|
||||
/* icns error return values */
|
||||
|
||||
#define ICNS_STATUS_OK 0
|
||||
|
||||
#define ICNS_STATUS_NULL_PARAM -1
|
||||
#define ICNS_STATUS_NO_MEMORY -2
|
||||
#define ICNS_STATUS_INVALID_DATA -3
|
||||
|
||||
#define ICNS_STATUS_IO_READ_ERR 1
|
||||
#define ICNS_STATUS_IO_WRITE_ERR 2
|
||||
#define ICNS_STATUS_DATA_NOT_FOUND 3
|
||||
#define ICNS_STATUS_UNSUPPORTED 4
|
||||
|
||||
/* icns function prototypes */
|
||||
/* NOTE: internal functions are found in icns_internals.h */
|
||||
|
||||
// icns_io.c
|
||||
int icns_write_family_to_file(FILE *dataFile,icns_family_t *iconFamilyIn);
|
||||
int icns_read_family_from_file(FILE *dataFile,icns_family_t **iconFamilyOut);
|
||||
int icns_read_family_from_rsrc(FILE *rsrcFile,icns_family_t **iconFamilyOut);
|
||||
int icns_export_family_data(icns_family_t *iconFamily,icns_size_t *dataSizeOut,icns_byte_t **dataPtrOut);
|
||||
int icns_import_family_data(icns_size_t dataSize,icns_byte_t *data,icns_family_t **iconFamilyOut);
|
||||
|
||||
// icns_family.c
|
||||
int icns_create_family(icns_family_t **iconFamilyOut);
|
||||
int icns_count_elements_in_family(icns_family_t *iconFamily, icns_sint32_t *elementTotal);
|
||||
|
||||
// icns_element.c
|
||||
int icns_get_element_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_element_t **iconElementOut);
|
||||
int icns_set_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement);
|
||||
int icns_add_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement);
|
||||
int icns_remove_element_in_family(icns_family_t **iconFamilyRef,icns_type_t iconType);
|
||||
int icns_new_element_from_image(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut);
|
||||
int icns_new_element_from_mask(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut);
|
||||
int icns_update_element_with_image(icns_image_t *imageIn,icns_element_t **iconElement);
|
||||
int icns_update_element_with_mask(icns_image_t *imageIn,icns_element_t **iconElement);
|
||||
|
||||
// icns_image.c
|
||||
int icns_get_image32_with_mask_from_family(icns_family_t *iconFamily,icns_type_t sourceType,icns_image_t *imageOut);
|
||||
int icns_get_image_from_element(icns_element_t *iconElement,icns_image_t *imageOut);
|
||||
int icns_get_mask_from_element(icns_element_t *iconElement,icns_image_t *imageOut);
|
||||
int icns_init_image_for_type(icns_type_t iconType,icns_image_t *imageOut);
|
||||
int icns_init_image(icns_uint32_t iconWidth,icns_uint32_t iconHeight,icns_uint32_t iconChannels,icns_uint32_t iconPixelDepth,icns_image_t *imageOut);
|
||||
int icns_free_image(icns_image_t *imageIn);
|
||||
|
||||
// icns_rle24.c
|
||||
int icns_decode_rle24_data(icns_size_t rawDataSize, icns_byte_t *rawDataPtr,icns_size_t expectedPixelCount, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
int icns_encode_rle24_data(icns_size_t dataSizeIn, icns_byte_t *dataPtrIn,icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
|
||||
// icns_jp2.c
|
||||
int icns_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
|
||||
int icns_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
|
||||
// icns_utils.c
|
||||
icns_icon_info_t icns_get_image_info_for_type(icns_type_t iconType);
|
||||
icns_type_t icns_get_mask_type_for_icon_type(icns_type_t);
|
||||
icns_type_t icns_get_type_from_image_info(icns_icon_info_t iconInfo);
|
||||
icns_type_t icns_get_type_from_image(icns_image_t iconImage);
|
||||
icns_type_t icns_get_type_from_mask(icns_image_t iconImage);
|
||||
icns_bool_t icns_types_equal(icns_type_t typeA,icns_type_t typeB);
|
||||
icns_bool_t icns_types_not_equal(icns_type_t typeA,icns_type_t typeB);
|
||||
const char * icns_type_str(icns_type_t type, char *strbuf);
|
||||
void icns_set_print_errors(icns_bool_t shouldPrint);
|
||||
|
||||
#endif
|
||||
@@ -1,314 +0,0 @@
|
||||
/*
|
||||
File: icns_colormaps.h
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
Copyright (C) 2004 Brion Vibber <[email protected]>
|
||||
Copyright (C) 2007 Lyonel Vincent <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#ifndef _COLORMAPS_H_
|
||||
#define _COLORMAPS_H_ 1
|
||||
|
||||
typedef struct icns_colormap_rgb_t
|
||||
{
|
||||
icns_byte_t r;
|
||||
icns_byte_t g;
|
||||
icns_byte_t b;
|
||||
} icns_colormap_rgb_t;
|
||||
|
||||
|
||||
static const icns_colormap_rgb_t icns_colormap_4[] =
|
||||
{
|
||||
{0xFF, 0xFF, 0xFF},
|
||||
{0xFC, 0xF3, 0x05},
|
||||
{0xFF, 0x64, 0x02},
|
||||
{0xDD, 0x08, 0x06},
|
||||
{0xF2, 0x08, 0x84},
|
||||
{0x46, 0x00, 0xA5},
|
||||
{0x00, 0x00, 0xD4},
|
||||
{0x02, 0xAB, 0xEA},
|
||||
{0x1F, 0xB7, 0x14},
|
||||
{0x00, 0x64, 0x11},
|
||||
{0x56, 0x2C, 0x05},
|
||||
{0x90, 0x71, 0x3A},
|
||||
{0xC0, 0xC0, 0xC0},
|
||||
{0x80, 0x80, 0x80},
|
||||
{0x40, 0x40, 0x40},
|
||||
{0x00, 0x00, 0x00}
|
||||
};
|
||||
|
||||
static const icns_colormap_rgb_t icns_colormap_8[] =
|
||||
{
|
||||
{0xFF, 0xFF, 0xFF},
|
||||
{0xFF, 0xFF, 0xCC},
|
||||
{0xFF, 0xFF, 0x99},
|
||||
{0xFF, 0xFF, 0x66},
|
||||
{0xFF, 0xFF, 0x33},
|
||||
{0xFF, 0xFF, 0x00},
|
||||
{0xFF, 0xCC, 0xFF},
|
||||
{0xFF, 0xCC, 0xCC},
|
||||
{0xFF, 0xCC, 0x99},
|
||||
{0xFF, 0xCC, 0x66},
|
||||
{0xFF, 0xCC, 0x33},
|
||||
{0xFF, 0xCC, 0x00},
|
||||
{0xFF, 0x99, 0xFF},
|
||||
{0xFF, 0x99, 0xCC},
|
||||
{0xFF, 0x99, 0x99},
|
||||
{0xFF, 0x99, 0x66},
|
||||
{0xFF, 0x99, 0x33},
|
||||
{0xFF, 0x99, 0x00},
|
||||
{0xFF, 0x66, 0xFF},
|
||||
{0xFF, 0x66, 0xCC},
|
||||
{0xFF, 0x66, 0x99},
|
||||
{0xFF, 0x66, 0x66},
|
||||
{0xFF, 0x66, 0x33},
|
||||
{0xFF, 0x66, 0x00},
|
||||
{0xFF, 0x33, 0xFF},
|
||||
{0xFF, 0x33, 0xCC},
|
||||
{0xFF, 0x33, 0x99},
|
||||
{0xFF, 0x33, 0x66},
|
||||
{0xFF, 0x33, 0x33},
|
||||
{0xFF, 0x33, 0x00},
|
||||
{0xFF, 0x00, 0xFF},
|
||||
{0xFF, 0x00, 0xCC},
|
||||
{0xFF, 0x00, 0x99},
|
||||
{0xFF, 0x00, 0x66},
|
||||
{0xFF, 0x00, 0x33},
|
||||
{0xFF, 0x00, 0x00},
|
||||
{0xCC, 0xFF, 0xFF},
|
||||
{0xCC, 0xFF, 0xCC},
|
||||
{0xCC, 0xFF, 0x99},
|
||||
{0xCC, 0xFF, 0x66},
|
||||
{0xCC, 0xFF, 0x33},
|
||||
{0xCC, 0xFF, 0x00},
|
||||
{0xCC, 0xCC, 0xFF},
|
||||
{0xCC, 0xCC, 0xCC},
|
||||
{0xCC, 0xCC, 0x99},
|
||||
{0xCC, 0xCC, 0x66},
|
||||
{0xCC, 0xCC, 0x33},
|
||||
{0xCC, 0xCC, 0x00},
|
||||
{0xCC, 0x99, 0xFF},
|
||||
{0xCC, 0x99, 0xCC},
|
||||
{0xCC, 0x99, 0x99},
|
||||
{0xCC, 0x99, 0x66},
|
||||
{0xCC, 0x99, 0x33},
|
||||
{0xCC, 0x99, 0x00},
|
||||
{0xCC, 0x66, 0xFF},
|
||||
{0xCC, 0x66, 0xCC},
|
||||
{0xCC, 0x66, 0x99},
|
||||
{0xCC, 0x66, 0x66},
|
||||
{0xCC, 0x66, 0x33},
|
||||
{0xCC, 0x66, 0x00},
|
||||
{0xCC, 0x33, 0xFF},
|
||||
{0xCC, 0x33, 0xCC},
|
||||
{0xCC, 0x33, 0x99},
|
||||
{0xCC, 0x33, 0x66},
|
||||
{0xCC, 0x33, 0x33},
|
||||
{0xCC, 0x33, 0x00},
|
||||
{0xCC, 0x00, 0xFF},
|
||||
{0xCC, 0x00, 0xCC},
|
||||
{0xCC, 0x00, 0x99},
|
||||
{0xCC, 0x00, 0x66},
|
||||
{0xCC, 0x00, 0x33},
|
||||
{0xCC, 0x00, 0x00},
|
||||
{0x99, 0xFF, 0xFF},
|
||||
{0x99, 0xFF, 0xCC},
|
||||
{0x99, 0xFF, 0x99},
|
||||
{0x99, 0xFF, 0x66},
|
||||
{0x99, 0xFF, 0x33},
|
||||
{0x99, 0xFF, 0x00},
|
||||
{0x99, 0xCC, 0xFF},
|
||||
{0x99, 0xCC, 0xCC},
|
||||
{0x99, 0xCC, 0x99},
|
||||
{0x99, 0xCC, 0x66},
|
||||
{0x99, 0xCC, 0x33},
|
||||
{0x99, 0xCC, 0x00},
|
||||
{0x99, 0x99, 0xFF},
|
||||
{0x99, 0x99, 0xCC},
|
||||
{0x99, 0x99, 0x99},
|
||||
{0x99, 0x99, 0x66},
|
||||
{0x99, 0x99, 0x33},
|
||||
{0x99, 0x99, 0x00},
|
||||
{0x99, 0x66, 0xFF},
|
||||
{0x99, 0x66, 0xCC},
|
||||
{0x99, 0x66, 0x99},
|
||||
{0x99, 0x66, 0x66},
|
||||
{0x99, 0x66, 0x33},
|
||||
{0x99, 0x66, 0x00},
|
||||
{0x99, 0x33, 0xFF},
|
||||
{0x99, 0x33, 0xCC},
|
||||
{0x99, 0x33, 0x99},
|
||||
{0x99, 0x33, 0x66},
|
||||
{0x99, 0x33, 0x33},
|
||||
{0x99, 0x33, 0x00},
|
||||
{0x99, 0x00, 0xFF},
|
||||
{0x99, 0x00, 0xCC},
|
||||
{0x99, 0x00, 0x99},
|
||||
{0x99, 0x00, 0x66},
|
||||
{0x99, 0x00, 0x33},
|
||||
{0x99, 0x00, 0x00},
|
||||
{0x66, 0xFF, 0xFF},
|
||||
{0x66, 0xFF, 0xCC},
|
||||
{0x66, 0xFF, 0x99},
|
||||
{0x66, 0xFF, 0x66},
|
||||
{0x66, 0xFF, 0x33},
|
||||
{0x66, 0xFF, 0x00},
|
||||
{0x66, 0xCC, 0xFF},
|
||||
{0x66, 0xCC, 0xCC},
|
||||
{0x66, 0xCC, 0x99},
|
||||
{0x66, 0xCC, 0x66},
|
||||
{0x66, 0xCC, 0x33},
|
||||
{0x66, 0xCC, 0x00},
|
||||
{0x66, 0x99, 0xFF},
|
||||
{0x66, 0x99, 0xCC},
|
||||
{0x66, 0x99, 0x99},
|
||||
{0x66, 0x99, 0x66},
|
||||
{0x66, 0x99, 0x33},
|
||||
{0x66, 0x99, 0x00},
|
||||
{0x66, 0x66, 0xFF},
|
||||
{0x66, 0x66, 0xCC},
|
||||
{0x66, 0x66, 0x99},
|
||||
{0x66, 0x66, 0x66},
|
||||
{0x66, 0x66, 0x33},
|
||||
{0x66, 0x66, 0x00},
|
||||
{0x66, 0x33, 0xFF},
|
||||
{0x66, 0x33, 0xCC},
|
||||
{0x66, 0x33, 0x99},
|
||||
{0x66, 0x33, 0x66},
|
||||
{0x66, 0x33, 0x33},
|
||||
{0x66, 0x33, 0x00},
|
||||
{0x66, 0x00, 0xFF},
|
||||
{0x66, 0x00, 0xCC},
|
||||
{0x66, 0x00, 0x99},
|
||||
{0x66, 0x00, 0x66},
|
||||
{0x66, 0x00, 0x33},
|
||||
{0x66, 0x00, 0x00},
|
||||
{0x33, 0xFF, 0xFF},
|
||||
{0x33, 0xFF, 0xCC},
|
||||
{0x33, 0xFF, 0x99},
|
||||
{0x33, 0xFF, 0x66},
|
||||
{0x33, 0xFF, 0x33},
|
||||
{0x33, 0xFF, 0x00},
|
||||
{0x33, 0xCC, 0xFF},
|
||||
{0x33, 0xCC, 0xCC},
|
||||
{0x33, 0xCC, 0x99},
|
||||
{0x33, 0xCC, 0x66},
|
||||
{0x33, 0xCC, 0x33},
|
||||
{0x33, 0xCC, 0x00},
|
||||
{0x33, 0x99, 0xFF},
|
||||
{0x33, 0x99, 0xCC},
|
||||
{0x33, 0x99, 0x99},
|
||||
{0x33, 0x99, 0x66},
|
||||
{0x33, 0x99, 0x33},
|
||||
{0x33, 0x99, 0x00},
|
||||
{0x33, 0x66, 0xFF},
|
||||
{0x33, 0x66, 0xCC},
|
||||
{0x33, 0x66, 0x99},
|
||||
{0x33, 0x66, 0x66},
|
||||
{0x33, 0x66, 0x33},
|
||||
{0x33, 0x66, 0x00},
|
||||
{0x33, 0x33, 0xFF},
|
||||
{0x33, 0x33, 0xCC},
|
||||
{0x33, 0x33, 0x99},
|
||||
{0x33, 0x33, 0x66},
|
||||
{0x33, 0x33, 0x33},
|
||||
{0x33, 0x33, 0x00},
|
||||
{0x33, 0x00, 0xFF},
|
||||
{0x33, 0x00, 0xCC},
|
||||
{0x33, 0x00, 0x99},
|
||||
{0x33, 0x00, 0x66},
|
||||
{0x33, 0x00, 0x33},
|
||||
{0x33, 0x00, 0x00},
|
||||
{0x00, 0xFF, 0xFF},
|
||||
{0x00, 0xFF, 0xCC},
|
||||
{0x00, 0xFF, 0x99},
|
||||
{0x00, 0xFF, 0x66},
|
||||
{0x00, 0xFF, 0x33},
|
||||
{0x00, 0xFF, 0x00},
|
||||
{0x00, 0xCC, 0xFF},
|
||||
{0x00, 0xCC, 0xCC},
|
||||
{0x00, 0xCC, 0x99},
|
||||
{0x00, 0xCC, 0x66},
|
||||
{0x00, 0xCC, 0x33},
|
||||
{0x00, 0xCC, 0x00},
|
||||
{0x00, 0x99, 0xFF},
|
||||
{0x00, 0x99, 0xCC},
|
||||
{0x00, 0x99, 0x99},
|
||||
{0x00, 0x99, 0x66},
|
||||
{0x00, 0x99, 0x33},
|
||||
{0x00, 0x99, 0x00},
|
||||
{0x00, 0x66, 0xFF},
|
||||
{0x00, 0x66, 0xCC},
|
||||
{0x00, 0x66, 0x99},
|
||||
{0x00, 0x66, 0x66},
|
||||
{0x00, 0x66, 0x33},
|
||||
{0x00, 0x66, 0x00},
|
||||
{0x00, 0x33, 0xFF},
|
||||
{0x00, 0x33, 0xCC},
|
||||
{0x00, 0x33, 0x99},
|
||||
{0x00, 0x33, 0x66},
|
||||
{0x00, 0x33, 0x33},
|
||||
{0x00, 0x33, 0x00},
|
||||
{0x00, 0x00, 0xFF},
|
||||
{0x00, 0x00, 0xCC},
|
||||
{0x00, 0x00, 0x99},
|
||||
{0x00, 0x00, 0x66},
|
||||
{0x00, 0x00, 0x33},
|
||||
{0xEE, 0x00, 0x00},
|
||||
{0xDD, 0x00, 0x00},
|
||||
{0xBB, 0x00, 0x00},
|
||||
{0xAA, 0x00, 0x00},
|
||||
{0x88, 0x00, 0x00},
|
||||
{0x77, 0x00, 0x00},
|
||||
{0x55, 0x00, 0x00},
|
||||
{0x44, 0x00, 0x00},
|
||||
{0x22, 0x00, 0x00},
|
||||
{0x11, 0x00, 0x00},
|
||||
{0x00, 0xEE, 0x00},
|
||||
{0x00, 0xDD, 0x00},
|
||||
{0x00, 0xBB, 0x00},
|
||||
{0x00, 0xAA, 0x00},
|
||||
{0x00, 0x88, 0x00},
|
||||
{0x00, 0x77, 0x00},
|
||||
{0x00, 0x55, 0x00},
|
||||
{0x00, 0x44, 0x00},
|
||||
{0x00, 0x22, 0x00},
|
||||
{0x00, 0x11, 0x00},
|
||||
{0x00, 0x00, 0xEE},
|
||||
{0x00, 0x00, 0xDD},
|
||||
{0x00, 0x00, 0xBB},
|
||||
{0x00, 0x00, 0xAA},
|
||||
{0x00, 0x00, 0x88},
|
||||
{0x00, 0x00, 0x77},
|
||||
{0x00, 0x00, 0x55},
|
||||
{0x00, 0x00, 0x44},
|
||||
{0x00, 0x00, 0x22},
|
||||
{0x00, 0x00, 0x11},
|
||||
{0xEE, 0xEE, 0xEE},
|
||||
{0xDD, 0xDD, 0xDD},
|
||||
{0xBB, 0xBB, 0xBB},
|
||||
{0xAA, 0xAA, 0xAA},
|
||||
{0x88, 0x88, 0x88},
|
||||
{0x77, 0x77, 0x77},
|
||||
{0x55, 0x55, 0x55},
|
||||
{0x44, 0x44, 0x44},
|
||||
{0x22, 0x22, 0x22},
|
||||
{0x11, 0x11, 0x11},
|
||||
{0x00, 0x00, 0x00}
|
||||
};
|
||||
|
||||
#endif /*_COLORMAPS_H_ */
|
||||
@@ -1,61 +0,0 @@
|
||||
/*
|
||||
File: icns_debug.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
#ifdef ICNS_DEBUG
|
||||
void bin_print_byte(int x)
|
||||
{
|
||||
int n;
|
||||
for(n=0; n<8; n++)
|
||||
{
|
||||
if((x & 0x80) !=0)
|
||||
{
|
||||
printf("1");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("0");
|
||||
}
|
||||
if(n==3)
|
||||
{
|
||||
printf(" "); /* insert a space between nybbles */
|
||||
}
|
||||
x = x<<1;
|
||||
}
|
||||
}
|
||||
|
||||
void bin_print_int(int x)
|
||||
{
|
||||
int hi, lo;
|
||||
hi=(x>>8) & 0xff;
|
||||
lo=x&0xff;
|
||||
bin_print_byte(hi);
|
||||
printf(" ");
|
||||
bin_print_byte(lo);
|
||||
}
|
||||
#endif /* ifdef ICNS_DEBUG */
|
||||
|
||||
|
||||
@@ -1,740 +0,0 @@
|
||||
/*
|
||||
File: icns_element.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
2007 Thomas Lübking <[email protected]>
|
||||
2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
|
||||
|
||||
//***************************** icns_get_element_from_family **************************//
|
||||
// Parses requested data from an icon family - puts it into a icon element
|
||||
|
||||
int icns_get_element_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_element_t **iconElementOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
int foundData = 0;
|
||||
icns_type_t iconFamilyType = ICNS_NULL_TYPE;
|
||||
icns_size_t iconFamilySize = 0;
|
||||
icns_element_t *iconElement = NULL;
|
||||
icns_type_t elementType = ICNS_NULL_TYPE;
|
||||
icns_size_t elementSize = 0;
|
||||
icns_uint32_t dataOffset = 0;
|
||||
|
||||
if(iconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: icns family is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconElementOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_element_in_family: icns element out is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
else
|
||||
{
|
||||
*iconElementOut = NULL;
|
||||
}
|
||||
|
||||
if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: Invalid icns family!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("Looking for icon element of type: '%s'\n",icns_type_str(iconType,typeStr));
|
||||
printf(" icon family type check: '%s'\n",icns_type_str(iconFamilyType,typeStr));
|
||||
printf(" icon family size check: %d\n",iconFamilySize);
|
||||
}
|
||||
#endif
|
||||
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
while ( (foundData == 0) && (dataOffset < iconFamilySize) )
|
||||
{
|
||||
iconElement = ((icns_element_t*)(((icns_byte_t*)iconFamily)+dataOffset));
|
||||
|
||||
if( iconFamilySize < (dataOffset+sizeof(icns_type_t)+sizeof(icns_size_t)) )
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: Corrupted icns family!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("element data...\n");
|
||||
printf(" type: '%s'%s\n",icns_type_str(elementType,typeStr),(elementType == iconType) ? " - match!" : " ");
|
||||
printf(" size: %d\n",(int)elementSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
if( (elementSize < 8) || ((dataOffset+elementSize) > iconFamilySize) )
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: Invalid element size! (%d)\n",elementSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(elementType == iconType)
|
||||
foundData = 1;
|
||||
else
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
if(foundData)
|
||||
{
|
||||
*iconElementOut = malloc(elementSize);
|
||||
if(*iconElementOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: Unable to allocate memory block of size: %d!\n",elementSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memcpy( *iconElementOut, iconElement, elementSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
icns_print_err("icns_get_element_from_family: Unable to find requested icon data!\n");
|
||||
error = ICNS_STATUS_DATA_NOT_FOUND;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
//***************************** icns_set_element_in_family **************************//
|
||||
// Adds/updates the icns element of it's type in the icon family
|
||||
|
||||
int icns_set_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
int foundData = 0;
|
||||
int copiedData = 0;
|
||||
icns_family_t *iconFamily = NULL;
|
||||
icns_type_t iconFamilyType = ICNS_NULL_TYPE;
|
||||
icns_size_t iconFamilySize = 0;
|
||||
icns_element_t *iconElement = NULL;
|
||||
icns_type_t newElementType = ICNS_NULL_TYPE;
|
||||
icns_size_t newElementSize = 0;
|
||||
icns_type_t elementType = ICNS_NULL_TYPE;
|
||||
icns_size_t elementSize = 0;
|
||||
icns_uint32_t dataOffset = 0;
|
||||
icns_size_t newIconFamilySize = 0;
|
||||
icns_family_t *newIconFamily = NULL;
|
||||
icns_uint32_t newDataOffset = 0;
|
||||
icns_uint32_t elementOrder = 0;
|
||||
icns_uint32_t newElementOrder = 0;
|
||||
|
||||
|
||||
if(iconFamilyRef == NULL)
|
||||
{
|
||||
icns_print_err("icns_set_element_in_family: icns family reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
iconFamily = *iconFamilyRef;
|
||||
|
||||
if(iconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_set_element_in_family: icns family is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Setting element in icon family...\n");
|
||||
#endif
|
||||
|
||||
if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
|
||||
{
|
||||
icns_print_err("icns_set_element_in_family: Invalid icns family!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf(" family type '%s'\n",icns_type_str(iconFamilyType,typeStr));
|
||||
printf(" family size: %d (0x%08X)\n",(int)iconFamilySize,iconFamilySize);
|
||||
}
|
||||
#endif
|
||||
|
||||
if(newIconElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_set_element_in_family: icns element is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
// Retrieve first, then swap. May help with problems on some arch
|
||||
ICNS_READ_UNALIGNED(newElementType, &(newIconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(newElementSize, &(newIconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf(" element type '%s'\n",icns_type_str(newElementType,typeStr));
|
||||
printf(" element size: %d (0x%08X)\n",(int)newElementSize,newElementSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
while ( (foundData == 0) && (dataOffset < iconFamilySize) )
|
||||
{
|
||||
iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
|
||||
ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
if(elementType == newElementType)
|
||||
foundData = 1;
|
||||
else
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
if(foundData)
|
||||
newIconFamilySize = iconFamilySize - elementSize + newElementSize;
|
||||
else
|
||||
newIconFamilySize = iconFamilySize + newElementSize;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf(" new family type 'icns'\n");
|
||||
printf(" new family size: %d (0x%08X)\n",(int)newIconFamilySize,newIconFamilySize);
|
||||
#endif
|
||||
|
||||
newIconFamily = malloc(newIconFamilySize);
|
||||
|
||||
if(newIconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_set_element_in_family: Unable to allocate memory block of size: %d!\n",newIconFamilySize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
newIconFamily->resourceType = ICNS_FAMILY_TYPE;
|
||||
newIconFamily->resourceSize = newIconFamilySize;
|
||||
|
||||
newDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
copiedData = 0;
|
||||
|
||||
newElementOrder = icns_get_element_order(newElementType);
|
||||
|
||||
while ( dataOffset < iconFamilySize )
|
||||
{
|
||||
iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
|
||||
ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
elementOrder = icns_get_element_order(elementType);
|
||||
|
||||
if(!copiedData && (elementType == newElementType))
|
||||
{
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
|
||||
newDataOffset += newElementSize;
|
||||
copiedData = 1;
|
||||
}
|
||||
else if(!copiedData && !foundData && newElementOrder < elementOrder)
|
||||
{
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
|
||||
newDataOffset += newElementSize;
|
||||
copiedData = 1;
|
||||
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
|
||||
newDataOffset += elementSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
|
||||
newDataOffset += elementSize;
|
||||
}
|
||||
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
if(!copiedData)
|
||||
{
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , (char *)newIconElement, newElementSize);
|
||||
newDataOffset += newElementSize;
|
||||
}
|
||||
|
||||
*iconFamilyRef = newIconFamily;
|
||||
|
||||
free(iconFamily);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
//***************************** icns_add_element_in_family **************************//
|
||||
// Adds/updates the icns element of it's type in the icon family
|
||||
// A convenience alias to icns_set_element_in_family
|
||||
|
||||
int icns_add_element_in_family(icns_family_t **iconFamilyRef,icns_element_t *newIconElement)
|
||||
{
|
||||
if(iconFamilyRef == NULL)
|
||||
{
|
||||
icns_print_err("icns_add_element_in_family: icns family reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(newIconElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_add_element_in_family: icon element is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
return icns_set_element_in_family(iconFamilyRef,newIconElement);
|
||||
}
|
||||
|
||||
//***************************** icns_remove_element_in_family **************************//
|
||||
// Parses requested data from an icon family - puts it into a "raw" image format
|
||||
|
||||
int icns_remove_element_in_family(icns_family_t **iconFamilyRef,icns_type_t iconElementType)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
int foundData = 0;
|
||||
icns_family_t *iconFamily = NULL;
|
||||
icns_type_t iconFamilyType = ICNS_NULL_TYPE;
|
||||
icns_size_t iconFamilySize = 0;
|
||||
icns_element_t *iconElement = NULL;
|
||||
icns_type_t elementType = ICNS_NULL_TYPE;
|
||||
icns_size_t elementSize = 0;
|
||||
icns_uint32_t dataOffset = 0;
|
||||
|
||||
icns_size_t newIconFamilySize = 0;
|
||||
icns_family_t *newIconFamily = NULL;
|
||||
icns_uint32_t newDataOffset = 0;
|
||||
|
||||
if(iconFamilyRef == NULL)
|
||||
{
|
||||
icns_print_err("icns_remove_element_in_family: icon family reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
iconFamily = *iconFamilyRef;
|
||||
|
||||
if(iconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_remove_element_in_family: icon family is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconFamily->resourceType != ICNS_FAMILY_TYPE)
|
||||
{
|
||||
icns_print_err("icns_remove_element_in_family: Invalid icon family!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
|
||||
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
while ( (foundData == 0) && (dataOffset < iconFamilySize) )
|
||||
{
|
||||
iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
|
||||
ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
if(elementType == iconElementType)
|
||||
foundData = 1;
|
||||
else
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
if(!foundData)
|
||||
{
|
||||
icns_print_err("icns_remove_element_in_family: Unable to find requested icon data for removal!\n");
|
||||
return ICNS_STATUS_DATA_NOT_FOUND;
|
||||
}
|
||||
|
||||
|
||||
newIconFamilySize = iconFamilySize - elementSize;
|
||||
newIconFamily = malloc(newIconFamilySize);
|
||||
|
||||
if(newIconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_remove_element_in_family: Unable to allocate memory block of size: %d!\n",newIconFamilySize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
newIconFamily->resourceType = ICNS_FAMILY_TYPE;
|
||||
newIconFamily->resourceSize = newIconFamilySize;
|
||||
|
||||
newDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
while ( dataOffset < iconFamilySize )
|
||||
{
|
||||
iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
|
||||
ICNS_READ_UNALIGNED(elementType, &(iconElement->elementType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
if(elementType != iconElementType)
|
||||
{
|
||||
memcpy( ((char *)(newIconFamily))+newDataOffset , ((char *)(iconFamily))+dataOffset, elementSize);
|
||||
newDataOffset += elementSize;
|
||||
}
|
||||
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
*iconFamilyRef = newIconFamily;
|
||||
|
||||
free(iconFamily);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//***************************** icns_new_element_from_image **************************//
|
||||
// Creates a new icon element from an image
|
||||
int icns_new_element_from_image(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut)
|
||||
{
|
||||
return icns_new_element_from_image_or_mask(imageIn,iconType,0,iconElementOut);
|
||||
}
|
||||
|
||||
//***************************** icns_new_element_from_mask **************************//
|
||||
// Creates a new icon element from an image
|
||||
int icns_new_element_from_mask(icns_image_t *imageIn,icns_type_t iconType,icns_element_t **iconElementOut)
|
||||
{
|
||||
return icns_new_element_from_image_or_mask(imageIn,iconType,1,iconElementOut);
|
||||
}
|
||||
|
||||
|
||||
//***************************** icns_new_element_from_image_or_mask **************************//
|
||||
// Creates a new icon element from an image
|
||||
int icns_new_element_from_image_or_mask(icns_image_t *imageIn,icns_type_t iconType,icns_bool_t isMask,icns_element_t **iconElementOut)
|
||||
{
|
||||
icns_element_t *newElement = NULL;
|
||||
icns_size_t newElementSize = 0;
|
||||
|
||||
if(iconElementOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_new_element_with_image_or_mask: Icon element reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
else
|
||||
{
|
||||
*iconElementOut = NULL;
|
||||
}
|
||||
|
||||
newElementSize = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
newElement = (icns_element_t *)malloc(newElementSize);
|
||||
if(newElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_new_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",(int)newElementSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
newElement->elementType = iconType;
|
||||
newElement->elementSize = newElementSize;
|
||||
*iconElementOut = newElement;
|
||||
|
||||
return icns_update_element_with_image_or_mask(imageIn,isMask,iconElementOut);
|
||||
}
|
||||
|
||||
//***************************** icns_update_element_from_image **************************//
|
||||
// Updates an icon element with the given image
|
||||
int icns_update_element_with_image(icns_image_t *imageIn,icns_element_t **iconElement)
|
||||
{
|
||||
return icns_update_element_with_image_or_mask(imageIn,0,iconElement);
|
||||
}
|
||||
|
||||
//***************************** icns_update_element_from_mask **************************//
|
||||
// Updates an icon element with the given mask
|
||||
int icns_update_element_with_mask(icns_image_t *imageIn,icns_element_t **iconElement)
|
||||
{
|
||||
return icns_update_element_with_image_or_mask(imageIn,1,iconElement);
|
||||
}
|
||||
|
||||
//***************************** icns_update_element_with_image_or_mask **************************//
|
||||
// Updates an icon element with the given image or mask
|
||||
int icns_update_element_with_image_or_mask(icns_image_t *imageIn,icns_bool_t isMask,icns_element_t **iconElement)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
icns_type_t iconType;
|
||||
icns_icon_info_t iconInfo;
|
||||
|
||||
// Finally, done with all the preliminary checks
|
||||
icns_size_t imageDataSize = 0;
|
||||
icns_byte_t *imageDataPtr = NULL;
|
||||
|
||||
// For use to easily track deallocation if we use rle24, or jp2
|
||||
icns_size_t newDataSize = 0;
|
||||
icns_byte_t *newDataPtr = NULL;
|
||||
|
||||
|
||||
if(imageIn == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Icon image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Icon element reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(*iconElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Icon element is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
iconType = (*iconElement)->elementType;
|
||||
|
||||
if(iconType == ICNS_NULL_DATA) {
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid icon type!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// Determine what the height and width ought to be, to check the incoming image
|
||||
iconInfo = icns_get_image_info_for_type(iconType);
|
||||
|
||||
// Check the image width, height, and pixel depth
|
||||
|
||||
if(imageIn->imageWidth != iconInfo.iconWidth)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image width: %d\n",imageIn->imageWidth);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(imageIn->imageWidth != iconInfo.iconWidth)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image width: %d\n",imageIn->imageWidth);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(imageIn->imageHeight != iconInfo.iconHeight)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image height: %d\n",imageIn->imageHeight);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(imageIn->imagePixelDepth != (iconInfo.iconBitDepth/iconInfo.iconChannels))
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: libicns does't support bit depth conversion yet.\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// Check the image data size and data pointer
|
||||
|
||||
if(imageIn->imageDataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data size: %d\n",(int)imageIn->imageDataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(imageIn->imageData == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
switch(iconType)
|
||||
{
|
||||
case ICNS_1024x1024_32BIT_ARGB_DATA:
|
||||
case ICNS_256x256_32BIT_ARGB_DATA:
|
||||
case ICNS_512x512_32BIT_ARGB_DATA:
|
||||
error = icns_image_to_jp2(imageIn,&newDataSize,&newDataPtr);
|
||||
imageDataSize = newDataSize;
|
||||
imageDataPtr = newDataPtr;
|
||||
break;
|
||||
case ICNS_128X128_32BIT_DATA:
|
||||
case ICNS_48x48_32BIT_DATA:
|
||||
case ICNS_32x32_32BIT_DATA:
|
||||
case ICNS_16x16_32BIT_DATA:
|
||||
newDataSize = imageIn->imageDataSize;
|
||||
|
||||
// Note: icns_encode_rle24_data allocates memory that must be freed later
|
||||
if( (error = icns_encode_rle24_data(imageIn->imageDataSize,imageIn->imageData,&newDataSize,&newDataPtr)) )
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Error rle encoding image data.\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
imageDataSize = newDataSize;
|
||||
imageDataPtr = newDataPtr;
|
||||
break;
|
||||
// Note that ICNS_NNxNN_1BIT_DATA == ICNS_NNxNN_1BIT_MASK
|
||||
// so we do not need to put them here twice
|
||||
case ICNS_48x48_1BIT_DATA:
|
||||
case ICNS_32x32_1BIT_DATA:
|
||||
case ICNS_16x16_1BIT_DATA:
|
||||
case ICNS_16x12_1BIT_DATA:
|
||||
{
|
||||
icns_byte_t *existingData = NULL;
|
||||
icns_size_t existingDataSize = 0;
|
||||
icns_size_t existingDataOffset = 0;
|
||||
|
||||
if(imageIn->imageDataSize != iconInfo.iconRawDataSize)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Invalid input image data size: %d!\n",imageIn->imageDataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
newDataSize = iconInfo.iconRawDataSize * 2;
|
||||
newDataPtr = (icns_byte_t *)malloc(newDataSize);
|
||||
if(newDataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",newDataSize);
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
memset (newDataPtr,0,newDataSize);
|
||||
|
||||
existingData = (icns_byte_t*)(*iconElement);
|
||||
existingDataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
existingDataSize = (*iconElement)->elementSize - existingDataOffset;
|
||||
|
||||
// No icon data
|
||||
if(existingDataSize == 0)
|
||||
{
|
||||
if(isMask == 0) {
|
||||
memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
|
||||
} else {
|
||||
memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
|
||||
}
|
||||
}
|
||||
// Only image data
|
||||
else if(existingDataSize == iconInfo.iconRawDataSize)
|
||||
{
|
||||
if(isMask == 0) {
|
||||
memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
|
||||
} else {
|
||||
memcpy(newDataPtr,existingData+existingDataOffset,iconInfo.iconRawDataSize);
|
||||
memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
|
||||
}
|
||||
}
|
||||
// Image + Mask data
|
||||
else if(existingDataSize == newDataSize)
|
||||
{
|
||||
if(isMask == 0) {
|
||||
memcpy(newDataPtr,imageIn->imageData,imageIn->imageDataSize);
|
||||
memcpy(newDataPtr,existingData+existingDataOffset+iconInfo.iconRawDataSize,iconInfo.iconRawDataSize);
|
||||
} else {
|
||||
memcpy(newDataPtr,existingData+existingDataOffset,iconInfo.iconRawDataSize);
|
||||
memcpy(newDataPtr,imageIn->imageData + iconInfo.iconRawDataSize,imageIn->imageDataSize);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Unexpected element data size: %d!\n",existingDataSize);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
imageDataSize = newDataSize;
|
||||
imageDataPtr = newDataPtr;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
imageDataSize = imageIn->imageDataSize;
|
||||
imageDataPtr = imageIn->imageData;
|
||||
break;
|
||||
}
|
||||
|
||||
if(error == ICNS_STATUS_OK)
|
||||
{
|
||||
icns_element_t *newElement = NULL;
|
||||
icns_size_t newElementSize = 0;
|
||||
icns_type_t newElementType = ICNS_NULL_DATA;
|
||||
icns_size_t newElementHeaderSize = 0;
|
||||
|
||||
if(imageDataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Image data size should not be 0!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
if(imageDataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Image data should not be NULL!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
// Set up and create the new element
|
||||
newElementHeaderSize = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
newElementSize = newElementHeaderSize + imageDataSize;
|
||||
newElementType = iconType;
|
||||
|
||||
newElement = (icns_element_t *)malloc(newElementSize);
|
||||
|
||||
if(newElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_update_element_with_image_or_mask: Unable to allocate memory block of size: %d!\n",(int)newElementSize);
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
// Set up the element info
|
||||
newElement->elementType = newElementType;
|
||||
newElement->elementSize = newElementSize;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf(" updated element data...\n");
|
||||
printf(" type: '%s'\n",icns_type_str(newElementType,typeStr));
|
||||
printf(" size: %d\n",(int)newElementSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Copy in the image data
|
||||
memcpy(newElement->elementData,imageDataPtr,imageDataSize);
|
||||
|
||||
// Free the old element...
|
||||
if(*iconElement != NULL)
|
||||
free(*iconElement);
|
||||
|
||||
// and move the pointer to the new element
|
||||
*iconElement = newElement;
|
||||
}
|
||||
|
||||
exception:
|
||||
|
||||
// We might have allocated new memory earlier...
|
||||
if(newDataPtr != NULL)
|
||||
{
|
||||
free(newDataPtr);
|
||||
newDataPtr = NULL;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
@@ -1,111 +0,0 @@
|
||||
/*
|
||||
File: icns_family.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
2007 Thomas Lübking <[email protected]>
|
||||
2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
|
||||
/***************************** icns_create_family **************************/
|
||||
|
||||
int icns_create_family(icns_family_t **iconFamilyOut)
|
||||
{
|
||||
icns_family_t *newIconFamily = NULL;
|
||||
icns_type_t iconFamilyType = ICNS_NULL_TYPE;
|
||||
icns_size_t iconFamilySize = 0;
|
||||
|
||||
if(iconFamilyOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_create_family: icon family reference is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
*iconFamilyOut = NULL;
|
||||
|
||||
iconFamilyType = ICNS_FAMILY_TYPE;
|
||||
iconFamilySize = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
newIconFamily = malloc(iconFamilySize);
|
||||
|
||||
if(newIconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_create_family: Unable to allocate memory block of size: %d!\n",iconFamilySize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
ICNS_WRITE_UNALIGNED(&(newIconFamily->resourceType), iconFamilyType, sizeof(icns_type_t));
|
||||
ICNS_WRITE_UNALIGNED(&(newIconFamily->resourceSize), iconFamilySize, sizeof(icns_size_t));
|
||||
|
||||
*iconFamilyOut = newIconFamily;
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
/***************************** icns_count_elements_in_family **************************/
|
||||
|
||||
int icns_count_elements_in_family(icns_family_t *iconFamily, icns_sint32_t *elementTotal)
|
||||
{
|
||||
icns_type_t iconFamilyType = ICNS_NULL_TYPE;
|
||||
icns_size_t iconFamilySize = 0;
|
||||
icns_uint32_t dataOffset = 0;
|
||||
icns_uint32_t elementCount = 0;
|
||||
|
||||
if(iconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_count_elements_in_family: icns family is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(elementTotal == NULL)
|
||||
{
|
||||
icns_print_err("icns_count_elements_in_family: element count ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
ICNS_READ_UNALIGNED(iconFamilyType, &(iconFamily->resourceType),sizeof( icns_type_t));
|
||||
ICNS_READ_UNALIGNED(iconFamilySize, &(iconFamily->resourceSize),sizeof( icns_size_t));
|
||||
|
||||
dataOffset = sizeof(icns_type_t) + sizeof(icns_size_t);
|
||||
|
||||
while( dataOffset < iconFamilySize )
|
||||
{
|
||||
icns_element_t *iconElement = NULL;
|
||||
icns_size_t elementSize = 0;
|
||||
|
||||
iconElement = ((icns_element_t*)(((char*)iconFamily)+dataOffset));
|
||||
ICNS_READ_UNALIGNED(elementSize, &(iconElement->elementSize),sizeof( icns_size_t));
|
||||
|
||||
elementCount++;
|
||||
|
||||
dataOffset += elementSize;
|
||||
}
|
||||
|
||||
*elementTotal = elementCount;
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,794 +0,0 @@
|
||||
/*
|
||||
File: icns_image.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
2007 Thomas Lübking <[email protected]>
|
||||
2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
#include "icns_colormaps.h"
|
||||
|
||||
|
||||
int icns_get_image32_with_mask_from_family(icns_family_t *iconFamily,icns_type_t iconType,icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
icns_type_t maskType = ICNS_NULL_TYPE;
|
||||
icns_element_t *iconElement = NULL;
|
||||
icns_element_t *maskElement = NULL;
|
||||
icns_image_t iconImage;
|
||||
icns_image_t maskImage;
|
||||
unsigned long dataCount = 0;
|
||||
icns_byte_t dataValue = 0;
|
||||
unsigned long pixelCount = 0;
|
||||
unsigned long pixelID = 0;
|
||||
icns_byte_t colorIndex = 0;
|
||||
|
||||
memset ( &iconImage, 0, sizeof(icns_image_t) );
|
||||
memset ( &maskImage, 0, sizeof(icns_image_t) );
|
||||
|
||||
if(iconFamily == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Icon family is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Icon image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
else
|
||||
{
|
||||
icns_free_image(imageOut);
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("Making 32-bit image...\n");
|
||||
printf(" using icon type '%s'\n",icns_type_str(iconType,typeStr));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
if((iconType == ICNS_128X128_8BIT_MASK) || \
|
||||
(iconType == ICNS_48x48_8BIT_MASK) || \
|
||||
(iconType == ICNS_32x32_8BIT_MASK) || \
|
||||
(iconType == ICNS_16x16_8BIT_MASK) )
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Can't make an image with mask from a mask\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// Preliminaries checked - carry on with the icon/mask merge
|
||||
|
||||
// Load icon element then image
|
||||
error = icns_get_element_from_family(iconFamily,iconType,&iconElement);
|
||||
|
||||
if(error) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unable to load icon element from icon family!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
error = icns_get_image_from_element(iconElement,&iconImage);
|
||||
|
||||
if(error) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unable to load icon image data from icon element!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
// We used the jp2 processor for these two, so we're done!
|
||||
if( (iconType == ICNS_256x256_32BIT_ARGB_DATA) || (iconType == ICNS_512x512_32BIT_ARGB_DATA) || (iconType == ICNS_1024x1024_32BIT_ARGB_DATA) ) {
|
||||
memcpy(imageOut,&iconImage,sizeof(icns_image_t));
|
||||
if(iconElement != NULL) {
|
||||
free(iconElement);
|
||||
iconElement = NULL;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
maskType = icns_get_mask_type_for_icon_type(iconType);
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf(" using mask type '%s'\n",icns_type_str(maskType,typeStr));
|
||||
}
|
||||
#endif
|
||||
|
||||
if( (maskType == ICNS_NULL_DATA) )
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Can't find mask for type '%s'\n",icns_type_str(iconType,typeStr));
|
||||
return ICNS_STATUS_DATA_NOT_FOUND;
|
||||
}
|
||||
|
||||
// Load mask element then image...
|
||||
error = icns_get_element_from_family(iconFamily,maskType,&maskElement);
|
||||
|
||||
// Note that we could arguably recover from not having a mask
|
||||
// by creating a dummy blank mask. However, the icns data type
|
||||
// should always have the corresponding mask present. This
|
||||
// function was designed to retreive a VALID image... There are
|
||||
// other API functions better used if the goal is editing, data
|
||||
// recovery, etc.
|
||||
if(error) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unable to load mask element from icon family!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
error = icns_get_mask_from_element(maskElement,&maskImage);
|
||||
|
||||
if(error) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unable to load mask image data from icon element!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if(iconImage.imageWidth != maskImage.imageWidth) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: icon and mask widths do not match! (%d != %d)\n",iconImage.imageWidth,maskImage.imageHeight);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if(iconImage.imageHeight != maskImage.imageHeight) {
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: icon and mask heights do not match! (%d != %d)\n",iconImage.imageHeight,maskImage.imageHeight);
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
// Unpack image pixels if depth is < 32
|
||||
if((iconImage.imagePixelDepth * iconImage.imageChannels) < 32)
|
||||
{
|
||||
icns_byte_t *oldData = NULL;
|
||||
icns_byte_t *newData = NULL;
|
||||
icns_uint32_t oldBitDepth = 0;
|
||||
unsigned long newBlockSize = 0;
|
||||
unsigned long newDataSize = 0;
|
||||
icns_colormap_rgb_t colorRGB;
|
||||
|
||||
oldBitDepth = (iconImage.imagePixelDepth * iconImage.imageChannels);
|
||||
|
||||
pixelCount = iconImage.imageWidth * iconImage.imageHeight;
|
||||
|
||||
newBlockSize = iconImage.imageWidth * 32;
|
||||
newDataSize = newBlockSize * iconImage.imageHeight;
|
||||
|
||||
oldData = iconImage.imageData;
|
||||
newData = (icns_byte_t *)malloc(newDataSize);
|
||||
|
||||
if(newData == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unable to allocate memory block of size: %d!\n",(int)newDataSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
dataCount = 0;
|
||||
|
||||
// 8-Bit Icon Image Data Types
|
||||
if((iconType == ICNS_48x48_8BIT_DATA) || \
|
||||
(iconType == ICNS_32x32_8BIT_DATA) || \
|
||||
(iconType == ICNS_16x16_8BIT_DATA) || \
|
||||
(iconType == ICNS_16x12_8BIT_DATA) )
|
||||
{
|
||||
if(oldBitDepth != 8)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
|
||||
free(newData);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
for(pixelID = 0; pixelID < pixelCount; pixelID++)
|
||||
{
|
||||
colorIndex = oldData[dataCount++];
|
||||
colorRGB = icns_colormap_8[colorIndex];
|
||||
newData[pixelID * 4 + 0] = colorRGB.r;
|
||||
newData[pixelID * 4 + 1] = colorRGB.g;
|
||||
newData[pixelID * 4 + 2] = colorRGB.b;
|
||||
newData[pixelID * 4 + 3] = 0xff;
|
||||
}
|
||||
}
|
||||
// 4-Bit Icon Image Data Types
|
||||
else if((iconType == ICNS_48x48_4BIT_DATA) || \
|
||||
(iconType == ICNS_32x32_4BIT_DATA) || \
|
||||
(iconType == ICNS_16x16_4BIT_DATA) || \
|
||||
(iconType == ICNS_16x12_4BIT_DATA) )
|
||||
{
|
||||
if(oldBitDepth != 4)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
|
||||
free(newData);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
for(pixelID = 0; pixelID < pixelCount; pixelID++)
|
||||
{
|
||||
if(pixelID % 2 == 0)
|
||||
dataValue = oldData[dataCount++];
|
||||
colorIndex = (dataValue & 0xF0) >> 4;
|
||||
dataValue = dataValue << 4;
|
||||
colorRGB = icns_colormap_4[colorIndex];
|
||||
newData[pixelID * 4 + 0] = colorRGB.r;
|
||||
newData[pixelID * 4 + 1] = colorRGB.g;
|
||||
newData[pixelID * 4 + 2] = colorRGB.b;
|
||||
newData[pixelID * 4 + 3] = 0xFF;
|
||||
}
|
||||
}
|
||||
// 1-Bit Icon Image Data Types
|
||||
else if((iconType == ICNS_48x48_1BIT_DATA) || \
|
||||
(iconType == ICNS_32x32_1BIT_DATA) || \
|
||||
(iconType == ICNS_16x16_1BIT_DATA) || \
|
||||
(iconType == ICNS_16x12_1BIT_DATA) )
|
||||
{
|
||||
if(oldBitDepth != 1)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - type mismatch!\n");
|
||||
free(newData);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
for(pixelID = 0; pixelID < pixelCount; pixelID++)
|
||||
{
|
||||
if(pixelID % 8 == 0)
|
||||
dataValue = oldData[dataCount++];
|
||||
colorIndex = (dataValue & 0x80) ? 0x00 : 0xFF;
|
||||
dataValue = dataValue << 1;
|
||||
newData[pixelID * 4 + 0] = colorIndex;
|
||||
newData[pixelID * 4 + 1] = colorIndex;
|
||||
newData[pixelID * 4 + 2] = colorIndex;
|
||||
newData[pixelID * 4 + 3] = 0xFF;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unpack error - unknown icon type! ('%s')\n",icns_type_str(iconType,typeStr));
|
||||
free(newData);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
iconImage.imagePixelDepth = 8;
|
||||
iconImage.imageChannels = 4;
|
||||
iconImage.imageDataSize = newDataSize;
|
||||
iconImage.imageData = newData;
|
||||
|
||||
free(oldData);
|
||||
}
|
||||
|
||||
// 8-Bit Icon Mask Data Types
|
||||
if((maskType == ICNS_128X128_8BIT_MASK) || \
|
||||
(maskType == ICNS_48x48_8BIT_MASK) || \
|
||||
(maskType == ICNS_32x32_8BIT_MASK) || \
|
||||
(maskType == ICNS_16x16_8BIT_MASK) )
|
||||
{
|
||||
pixelCount = maskImage.imageWidth * maskImage.imageHeight;
|
||||
dataCount = 0;
|
||||
if((maskImage.imagePixelDepth * maskImage.imageChannels) != 8)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - mismatch!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
for(pixelID = 0; pixelID < pixelCount; pixelID++)
|
||||
{
|
||||
iconImage.imageData[pixelID * 4 + 3] = maskImage.imageData[dataCount++];
|
||||
}
|
||||
}
|
||||
// 1-Bit Icon Mask Data Types
|
||||
else if((maskType == ICNS_48x48_1BIT_MASK) || \
|
||||
(maskType == ICNS_32x32_1BIT_MASK) || \
|
||||
(maskType == ICNS_16x16_1BIT_MASK) || \
|
||||
(maskType == ICNS_16x12_1BIT_MASK) )
|
||||
{
|
||||
pixelCount = maskImage.imageWidth * maskImage.imageHeight;
|
||||
dataCount = 0;
|
||||
if((maskImage.imagePixelDepth * maskImage.imageChannels) != 1)
|
||||
{
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Invalid bit depth - mismatch!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
for(pixelID = 0; pixelID < pixelCount; pixelID++)
|
||||
{
|
||||
if(pixelID % 8 == 0)
|
||||
dataValue = maskImage.imageData[dataCount++];
|
||||
colorIndex = (dataValue & 0x80) ? 0xFF : 0x00;
|
||||
dataValue = dataValue << 1;
|
||||
iconImage.imageData[pixelID * 4 + 3] = colorIndex;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_image32_with_mask_from_family: Unpack error - unknown mask type! ('%s')\n",icns_type_str(maskType,typeStr));
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
|
||||
if(maskElement != NULL) {
|
||||
free(maskElement);
|
||||
maskElement = NULL;
|
||||
}
|
||||
icns_free_image(&maskImage);
|
||||
|
||||
if(iconElement != NULL) {
|
||||
free(iconElement);
|
||||
iconElement = NULL;
|
||||
}
|
||||
|
||||
// We only free the icon image if there was an error. Otherwise, we
|
||||
// pass the data onto the outgoing image
|
||||
if(error) {
|
||||
icns_free_image(&iconImage);
|
||||
} else {
|
||||
memcpy(imageOut,&iconImage,sizeof(icns_image_t));
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Finished 32-bit image...\n");
|
||||
printf(" height: %d\n",imageOut->imageHeight);
|
||||
printf(" width: %d\n",imageOut->imageHeight);
|
||||
printf(" channels: %d\n",imageOut->imageChannels);
|
||||
printf(" pixel depth: %d\n",imageOut->imagePixelDepth);
|
||||
printf(" data size: %d\n",(int)(imageOut->imageDataSize));
|
||||
#endif
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
//***************************** icns_get_image_from_element **************************//
|
||||
// Actual conversion of the icon data into uncompressed raw pixels
|
||||
|
||||
int icns_get_image_from_element(icns_element_t *iconElement,icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
unsigned long dataCount = 0;
|
||||
icns_type_t elementType = ICNS_NULL_TYPE;
|
||||
icns_size_t elementSize = 0;
|
||||
icns_type_t iconType = ICNS_NULL_TYPE;
|
||||
unsigned long rawDataSize = 0;
|
||||
icns_byte_t *rawDataPtr = NULL;
|
||||
icns_uint32_t iconBitDepth = 0;
|
||||
unsigned long iconDataRowSize = 0;
|
||||
|
||||
if(iconElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Icon element is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Icon image structure is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
elementType = iconElement->elementType;
|
||||
elementSize = iconElement->elementSize;
|
||||
|
||||
#if ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("Retreiving image from icon element...\n");
|
||||
printf(" type is: '%s'\n",icns_type_str(elementType,typeStr));
|
||||
printf(" size is: %d\n",(int)elementSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
if(elementSize <= 8)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Invalid element size! (%d)\n",elementSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
iconType = elementType;
|
||||
rawDataSize = elementSize - sizeof(icns_type_t) - sizeof(icns_size_t);
|
||||
rawDataPtr = (icns_byte_t*)&(iconElement->elementData[0]);
|
||||
|
||||
#if ICNS_DEBUG
|
||||
printf(" data size is: %d\n",(int)rawDataSize);
|
||||
#endif
|
||||
|
||||
switch(iconType)
|
||||
{
|
||||
// 32-Bit Icon Image Data Types ( > 256px )
|
||||
case ICNS_256x256_32BIT_ARGB_DATA:
|
||||
case ICNS_512x512_32BIT_ARGB_DATA:
|
||||
case ICNS_1024x1024_32BIT_ARGB_DATA:
|
||||
{
|
||||
uint8_t magicPNG[] = {0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A};
|
||||
uint8_t magicByt[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
|
||||
|
||||
ICNS_READ_UNALIGNED(magicByt[0], rawDataPtr, 8);
|
||||
|
||||
// 256x256+ sizes may or may not be PNG dta as of 10.7 Lion, so check
|
||||
if(memcmp(&magicByt[0], &magicPNG[0], 8) == 0) {
|
||||
// We know to use the PNG processor
|
||||
error = icns_png_to_image((int)rawDataSize, (icns_byte_t *)rawDataPtr, imageOut);
|
||||
} else {
|
||||
// We assume use of the jp2 processor
|
||||
error = icns_jp2_to_image((int)rawDataSize, (icns_byte_t *)rawDataPtr, imageOut);
|
||||
}
|
||||
return error;
|
||||
}
|
||||
case ICNS_128X128_32BIT_DATA:
|
||||
case ICNS_48x48_32BIT_DATA:
|
||||
case ICNS_32x32_32BIT_DATA:
|
||||
case ICNS_16x16_32BIT_DATA:
|
||||
|
||||
error = icns_init_image_for_type(iconType,imageOut);
|
||||
if(error)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Error allocating new icns image!\n");
|
||||
icns_free_image(imageOut);
|
||||
return error;
|
||||
}
|
||||
|
||||
iconBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
|
||||
iconDataRowSize = imageOut->imageWidth * iconBitDepth / ICNS_BYTE_BITS;
|
||||
|
||||
if(rawDataSize < imageOut->imageDataSize)
|
||||
{
|
||||
icns_uint32_t pixelCount = 0;
|
||||
icns_size_t decodedDataSize = imageOut->imageDataSize;
|
||||
icns_byte_t *decodedImageData = imageOut->imageData;
|
||||
|
||||
pixelCount = imageOut->imageWidth * imageOut->imageHeight;
|
||||
error = icns_decode_rle24_data(rawDataSize,rawDataPtr,pixelCount,&decodedDataSize,&decodedImageData);
|
||||
if(error)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Error decoding RLE data!\n");
|
||||
icns_free_image(imageOut);
|
||||
return error;
|
||||
}
|
||||
else
|
||||
{
|
||||
imageOut->imageDataSize = decodedDataSize;
|
||||
imageOut->imageData = decodedImageData;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned long pixelCount = 0;
|
||||
icns_byte_t *swapPtr = NULL;
|
||||
icns_argb_t *pixelPtr = NULL;
|
||||
|
||||
for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
|
||||
memcpy(&(((char*)(imageOut->imageData))[dataCount*iconDataRowSize]),&(((char*)(rawDataPtr))[dataCount*iconDataRowSize]),iconDataRowSize);
|
||||
|
||||
pixelCount = imageOut->imageWidth * imageOut->imageHeight;
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Converting %d pixels from argb to rgba\n",(int)pixelCount);
|
||||
#endif
|
||||
swapPtr = imageOut->imageData;
|
||||
for(dataCount = 0; dataCount < pixelCount; dataCount++)
|
||||
{
|
||||
pixelPtr = (icns_argb_t *)(swapPtr + (dataCount * 4));
|
||||
*((icns_rgba_t *)pixelPtr) = ICNS_ARGB_TO_RGBA( *((icns_argb_t *)pixelPtr) );
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ICNS_48x48_8BIT_DATA:
|
||||
case ICNS_32x32_8BIT_DATA:
|
||||
case ICNS_16x16_8BIT_DATA:
|
||||
case ICNS_16x12_8BIT_DATA:
|
||||
case ICNS_48x48_4BIT_DATA:
|
||||
case ICNS_32x32_4BIT_DATA:
|
||||
case ICNS_16x16_4BIT_DATA:
|
||||
case ICNS_16x12_4BIT_DATA:
|
||||
case ICNS_48x48_1BIT_DATA:
|
||||
case ICNS_32x32_1BIT_DATA:
|
||||
case ICNS_16x16_1BIT_DATA:
|
||||
case ICNS_16x12_1BIT_DATA:
|
||||
|
||||
error = icns_init_image_for_type(iconType,imageOut);
|
||||
if(error)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Error allocating new icns image!\n");
|
||||
icns_free_image(imageOut);
|
||||
return error;
|
||||
}
|
||||
|
||||
iconBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
|
||||
iconDataRowSize = imageOut->imageWidth * iconBitDepth / ICNS_BYTE_BITS;
|
||||
|
||||
for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
|
||||
memcpy(&(((char*)(imageOut->imageData))[dataCount*iconDataRowSize]),&(((char*)(rawDataPtr))[dataCount*iconDataRowSize]),iconDataRowSize);
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_image_from_element: Unknown icon type! ('%s')\n",icns_type_str(iconType,typeStr));
|
||||
icns_free_image(imageOut);
|
||||
}
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
//***************************** icns_get_mask_from_element **************************//
|
||||
// Actual conversion of the mask data into uncompressed raw pixels
|
||||
|
||||
int icns_get_mask_from_element(icns_element_t *maskElement,icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
unsigned long dataCount = 0;
|
||||
icns_type_t elementType = ICNS_NULL_TYPE;
|
||||
icns_size_t elementSize = 0;
|
||||
icns_type_t maskType = ICNS_NULL_TYPE;
|
||||
unsigned long rawDataSize = 0;
|
||||
icns_byte_t *rawDataPtr = NULL;
|
||||
icns_uint32_t maskBitDepth = 0;
|
||||
unsigned long maskDataSize = 0;
|
||||
unsigned long maskDataRowSize = 0;
|
||||
|
||||
if(maskElement == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_mask_from_element: Mask element is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_get_mask_from_element: Mask image structure is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
elementType = maskElement->elementType;
|
||||
elementSize = maskElement->elementSize;
|
||||
|
||||
#if ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("Retreiving image from mask element...\n");
|
||||
printf(" type is: '%s'\n",icns_type_str(elementType,typeStr));
|
||||
printf(" size is: %d\n",(int)elementSize);
|
||||
}
|
||||
#endif
|
||||
|
||||
if(elementSize <= 8)
|
||||
{
|
||||
icns_print_err("icns_get_image_from_element: Invalid element size! (%d)\n",elementSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
maskType = elementType;
|
||||
rawDataSize = elementSize - sizeof(icns_type_t) - sizeof(icns_size_t);
|
||||
rawDataPtr = (icns_byte_t*)&(maskElement->elementData[0]);
|
||||
|
||||
#if ICNS_DEBUG
|
||||
printf(" data size is: %d\n",(int)rawDataSize);
|
||||
#endif
|
||||
|
||||
switch(maskType)
|
||||
{
|
||||
case ICNS_128X128_8BIT_MASK:
|
||||
case ICNS_48x48_8BIT_MASK:
|
||||
case ICNS_32x32_8BIT_MASK:
|
||||
case ICNS_16x16_8BIT_MASK:
|
||||
|
||||
error = icns_init_image_for_type(maskType,imageOut);
|
||||
if(error)
|
||||
{
|
||||
icns_print_err("icns_get_mask_from_element: Error allocating new icns image!\n");
|
||||
icns_free_image(imageOut);
|
||||
return error;
|
||||
}
|
||||
|
||||
maskBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
|
||||
|
||||
if(maskBitDepth != 8) {
|
||||
icns_print_err("icns_get_mask_from_element: Unknown bit depth!\n");
|
||||
icns_free_image(imageOut);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
maskDataSize = imageOut->imageDataSize;
|
||||
maskDataRowSize = imageOut->imageWidth * maskBitDepth / ICNS_BYTE_BITS;
|
||||
|
||||
for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
|
||||
memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize]),maskDataRowSize);
|
||||
|
||||
break;
|
||||
case ICNS_48x48_1BIT_MASK:
|
||||
case ICNS_32x32_1BIT_MASK:
|
||||
case ICNS_16x16_1BIT_MASK:
|
||||
case ICNS_16x12_1BIT_MASK:
|
||||
|
||||
error = icns_init_image_for_type(maskType,imageOut);
|
||||
if(error)
|
||||
{
|
||||
icns_print_err("icns_get_mask_from_element: Error allocating new icns image!\n");
|
||||
icns_free_image(imageOut);
|
||||
return error;
|
||||
}
|
||||
|
||||
maskBitDepth = imageOut->imagePixelDepth * imageOut->imageChannels;
|
||||
|
||||
if(maskBitDepth != 1) {
|
||||
icns_print_err("icns_get_mask_from_element: Unknown bit depth!\n");
|
||||
icns_free_image(imageOut);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
maskDataSize = imageOut->imageDataSize;
|
||||
maskDataRowSize = imageOut->imageWidth * maskBitDepth / ICNS_BYTE_BITS;
|
||||
|
||||
#if ICNS_DEBUG
|
||||
printf(" raw mask data size is: %d\n",(int)rawDataSize);
|
||||
printf(" image mask data size is: %d\n",(int)maskDataSize);
|
||||
#endif
|
||||
|
||||
if(rawDataSize == (maskDataSize * 2) )
|
||||
{
|
||||
#if ICNS_DEBUG
|
||||
printf(" mask data in second memory block\n");
|
||||
#endif
|
||||
// Mask data found - Copy the second block of memory
|
||||
for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
|
||||
memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize+maskDataSize]),maskDataRowSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if ICNS_DEBUG
|
||||
printf(" using icon data from first memory block\n");
|
||||
#endif
|
||||
// Hmm, no mask - copy the first block of memory
|
||||
for(dataCount = 0; dataCount < imageOut->imageHeight; dataCount++)
|
||||
memcpy(&(((char*)(imageOut->imageData))[dataCount*maskDataRowSize]),&(((char*)(rawDataPtr))[dataCount*maskDataRowSize]),maskDataRowSize);
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_mask_from_element: Unknown mask type! ('%s')\n",icns_type_str(maskType,typeStr));
|
||||
icns_free_image(imageOut);
|
||||
}
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//***************************** icns_init_image_for_type **************************//
|
||||
// Initialize a new image structure for holding the data
|
||||
// using the information for the specified type
|
||||
|
||||
int icns_init_image_for_type(icns_type_t iconType,icns_image_t *imageOut)
|
||||
{
|
||||
icns_icon_info_t iconInfo;
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_init_image_for_type: Icon image structure is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
// Determine what the height and width ought to be, to check the incoming image
|
||||
|
||||
iconInfo = icns_get_image_info_for_type(iconType);
|
||||
|
||||
if(iconType != iconInfo.iconType)
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_init_image_for_type: Couldn't determine information for type! ('%s')\n",icns_type_str(iconType,typeStr));
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
return icns_init_image(iconInfo.iconWidth,iconInfo.iconHeight,iconInfo.iconChannels,iconInfo.iconPixelDepth,imageOut);
|
||||
|
||||
}
|
||||
|
||||
//***************************** icns_init_image **************************//
|
||||
// Initialize a new image structure for holding the data
|
||||
|
||||
int icns_init_image(icns_uint32_t iconWidth,icns_uint32_t iconHeight,icns_uint32_t iconChannels,icns_uint32_t iconPixelDepth,icns_image_t *imageOut)
|
||||
{
|
||||
icns_uint32_t iconBitDepth = 0;
|
||||
unsigned long iconDataSize = 0;
|
||||
unsigned long iconDataRowSize = 0;
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_init_image: Icon image structure is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconWidth == 0)
|
||||
{
|
||||
icns_print_err("icns_init_image: icon width is 0!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(iconHeight == 0)
|
||||
{
|
||||
icns_print_err("icns_init_image: icon height is 0!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(iconChannels == 0)
|
||||
{
|
||||
icns_print_err("icns_init_image: icon channels is 0!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
if(iconPixelDepth == 0)
|
||||
{
|
||||
icns_print_err("icns_init_image: icon pixel depth is 0!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
iconBitDepth = iconPixelDepth * iconChannels;
|
||||
iconDataRowSize = iconWidth * iconBitDepth / ICNS_BYTE_BITS;
|
||||
iconDataSize = iconHeight * iconDataRowSize;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Initializing new image...\n");
|
||||
printf(" width is: %d\n",iconWidth);
|
||||
printf(" height is: %d\n",iconHeight);
|
||||
printf(" channels are: %d\n",iconChannels);
|
||||
printf(" bit depth is: %d\n",iconBitDepth);
|
||||
printf(" data size is: %d\n",(int)iconDataSize);
|
||||
#endif
|
||||
|
||||
imageOut->imageWidth = iconWidth;
|
||||
imageOut->imageHeight = iconHeight;
|
||||
imageOut->imageChannels = iconChannels;
|
||||
imageOut->imagePixelDepth = (iconBitDepth / iconChannels);
|
||||
imageOut->imageDataSize = iconDataSize;
|
||||
imageOut->imageData = (icns_byte_t *)malloc(iconDataSize);
|
||||
if(!imageOut->imageData)
|
||||
{
|
||||
icns_print_err("icns_init_image: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)iconDataSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memset(imageOut->imageData,0,iconDataSize);
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
//***************************** icns_free_image **************************//
|
||||
// Deallocate data in an image structure
|
||||
|
||||
int icns_free_image(icns_image_t *imageIn)
|
||||
{
|
||||
imageIn->imageWidth = 0;
|
||||
imageIn->imageHeight = 0;
|
||||
imageIn->imageChannels = 0;
|
||||
imageIn->imagePixelDepth = 0;
|
||||
imageIn->imageDataSize = 0;
|
||||
|
||||
if(imageIn->imageData != NULL)
|
||||
{
|
||||
free(imageIn->imageData);
|
||||
imageIn->imageData = NULL;
|
||||
}
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
@@ -1,207 +0,0 @@
|
||||
/*
|
||||
File: icns.h
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
Copyright (C) 2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
With the exception of the limited portions mentiond, this library
|
||||
is free software; you can redistribute it and/or modify it under
|
||||
the terms of the GNU Lesser General Public License as published
|
||||
by the Free Software Foundation; either version 2.1 of the License,
|
||||
or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#ifndef _ICNS_INTERNALS_H_
|
||||
#define _ICNS_INTERNALS_H_
|
||||
|
||||
/* Compile-time variables */
|
||||
/* These should really be set from the Makefile */
|
||||
|
||||
// Enable debugging messages?
|
||||
// #define ICNS_DEBUG 1
|
||||
|
||||
// Enable supprt for 256x256, 512x512 and 1024x1024 icons
|
||||
// Use either Jasper or OpenJPEG, but not both
|
||||
// #define ICNS_JASPER
|
||||
// #define ICNS_OPENJPEG
|
||||
|
||||
/* Make sure we're not using both libraries */
|
||||
#if defined(ICNS_JASPER) && defined(ICNS_OPENJPEG)
|
||||
#error "Must use either Jasper or OpenJPEG, but not both!"
|
||||
#endif
|
||||
|
||||
/* Include Jasper headers */
|
||||
#ifdef ICNS_JASPER
|
||||
#include <jasper.h>
|
||||
#endif
|
||||
|
||||
/* Include OpenJPEG headers */
|
||||
#ifdef ICNS_OPENJPEG
|
||||
#include <openjpeg.h>
|
||||
#endif
|
||||
|
||||
// We do not want to expose any of the internal stuff
|
||||
#pragma GCC visibility push(hidden)
|
||||
|
||||
/* icns structures */
|
||||
|
||||
typedef struct icns_rgba_t
|
||||
{
|
||||
icns_byte_t r;
|
||||
icns_byte_t g;
|
||||
icns_byte_t b;
|
||||
icns_byte_t a;
|
||||
} icns_rgba_t;
|
||||
|
||||
typedef struct icns_argb_t
|
||||
{
|
||||
icns_byte_t a;
|
||||
icns_byte_t r;
|
||||
icns_byte_t g;
|
||||
icns_byte_t b;
|
||||
} icns_argb_t;
|
||||
|
||||
typedef struct icns_rgb_t
|
||||
{
|
||||
icns_byte_t r;
|
||||
icns_byte_t g;
|
||||
icns_byte_t b;
|
||||
} icns_rgb_t;
|
||||
|
||||
/* icns constants */
|
||||
|
||||
|
||||
typedef enum icns_rsrc_endian_t
|
||||
{
|
||||
ICNS_BE_RSRC = 0,
|
||||
ICNS_LE_RSRC = 1
|
||||
} icns_rsrc_endian_t;
|
||||
|
||||
#define ICNS_BYTE_BITS 8
|
||||
|
||||
#define ICNS_APPLE_SINGLE_MAGIC 0x00051600
|
||||
#define ICNS_APPLE_DOUBLE_MAGIC 0x00051607
|
||||
|
||||
#define ICNS_APPLE_ENC_DATA 1
|
||||
#define ICNS_APPLE_ENC_RSRC 2
|
||||
|
||||
/* icns macros */
|
||||
|
||||
/*
|
||||
These functions swap the position of the alpha channel
|
||||
*/
|
||||
static inline icns_rgba_t ICNS_ARGB_TO_RGBA(icns_argb_t pxin) {
|
||||
icns_rgba_t pxout;
|
||||
pxout.r = pxin.r;
|
||||
pxout.g = pxin.g;
|
||||
pxout.b = pxin.b;
|
||||
pxout.a = pxin.a;
|
||||
return pxout;
|
||||
}
|
||||
|
||||
static inline icns_argb_t ICNS_RGBA_TO_ARGB(icns_rgba_t pxin) {
|
||||
icns_argb_t pxout;
|
||||
pxout.r = pxin.r;
|
||||
pxout.g = pxin.g;
|
||||
pxout.b = pxin.b;
|
||||
pxout.a = pxin.a;
|
||||
return pxout;
|
||||
}
|
||||
|
||||
/*
|
||||
These macros will work on systems that support unaligned
|
||||
accesses, as well as those that don't support it.
|
||||
Unfortunately, gcc doesn't support unaligned access well
|
||||
with memcpy on some architectures due to a combination of
|
||||
memcpy being inlined during the optimization process and
|
||||
memory alignment. So, we try to work around this here.
|
||||
*/
|
||||
|
||||
// If the autotools didn't tell us, try and make a good guess
|
||||
#ifndef HAVE_UNALIGNED_MEMCPY
|
||||
#if defined(__GNUC__) && (defined(__arm__) || defined(__thumb__) || defined(__sparc__))
|
||||
#define HAVE_UNALIGNED_MEMCPY 0
|
||||
#else
|
||||
#define HAVE_UNALIGNED_MEMCPY 1
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Set up the macros
|
||||
#if HAVE_UNALIGNED_MEMCPY == 0
|
||||
__attribute__ ((noinline)) void *icns_memcpy( void *dst, const void *src, size_t num );
|
||||
#define ICNS_READ_UNALIGNED(val, addr, size) icns_memcpy(&(val), (addr), size)
|
||||
#define ICNS_WRITE_UNALIGNED(addr, val, size) icns_memcpy((addr), &(val), size)
|
||||
#else
|
||||
#define ICNS_READ_UNALIGNED(val, addr, size) memcpy(&(val), (addr), size)
|
||||
#define ICNS_WRITE_UNALIGNED(addr, val, size) memcpy((addr), &(val), size)
|
||||
#endif
|
||||
|
||||
/* global variables */
|
||||
extern icns_bool_t gShouldPrintErrors;
|
||||
|
||||
/* icns function prototypes */
|
||||
|
||||
// icns_debug.c
|
||||
void bin_print_byte(int x);
|
||||
void bin_print_int(int x);
|
||||
|
||||
// icns_element.c
|
||||
int icns_new_element_from_image_or_mask(icns_image_t *imageIn,icns_type_t iconType,icns_bool_t isMask,icns_element_t **iconElementOut);
|
||||
int icns_update_element_with_image_or_mask(icns_image_t *imageIn,icns_bool_t isMask,icns_element_t **iconElement);
|
||||
|
||||
// icns_io.c
|
||||
int icns_parse_family_data(icns_size_t dataSize,icns_byte_t *data,icns_family_t **iconFamilyOut);
|
||||
int icns_find_family_in_mac_resource(icns_size_t resDataSize, icns_byte_t *resData, icns_rsrc_endian_t fileEndian, icns_family_t **dataOut);
|
||||
int icns_read_macbinary_resource_fork(icns_size_t dataSize,icns_byte_t *dataPtr,icns_type_t *dataTypeOut, icns_type_t *dataCreatorOut,icns_size_t *parsedResSizeOut,icns_byte_t **parsedResDataOut);
|
||||
int icns_read_apple_encoded_resource_fork(icns_size_t dataSize,icns_byte_t *dataPtr,icns_type_t *dataTypeOut, icns_type_t *dataCreatorOut,icns_size_t *parsedResSizeOut,icns_byte_t **parsedResDataOut);
|
||||
icns_bool_t icns_icns_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
|
||||
icns_bool_t icns_rsrc_header_check(icns_size_t dataSize,icns_byte_t *dataPtr,icns_rsrc_endian_t fileEndian);
|
||||
icns_bool_t icns_macbinary_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
|
||||
icns_bool_t icns_apple_encoded_header_check(icns_size_t dataSize,icns_byte_t *dataPtr);
|
||||
|
||||
// icns_png.c
|
||||
int icns_image_to_png(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
int icns_png_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
|
||||
|
||||
// icns_jp2.c
|
||||
#ifdef ICNS_JASPER
|
||||
int icns_jas_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
|
||||
int icns_jas_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
#endif
|
||||
#ifdef ICNS_OPENJPEG
|
||||
int icns_opj_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut);
|
||||
int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **imageOut);
|
||||
int icns_opj_to_image(opj_image_t *image, icns_image_t *outIcon);
|
||||
int icns_opj_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut);
|
||||
void icns_opj_error_callback(const char *msg, void *client_data);
|
||||
void icns_opj_warning_callback(const char *msg, void *client_data);
|
||||
void icns_opj_info_callback(const char *msg, void *client_data);
|
||||
#endif
|
||||
void icns_place_jp2_cdef(icns_byte_t *dataPtr, icns_size_t dataSize);
|
||||
|
||||
// icns_utils.c
|
||||
icns_uint32_t icns_get_element_order(icns_type_t iconType);
|
||||
void icns_print_err(const char *template, ...);
|
||||
|
||||
// Stop hiding symbols
|
||||
#pragma GCC visibility pop
|
||||
|
||||
#endif /* _ICNS_INTERNALS_H_ */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,961 +0,0 @@
|
||||
/*
|
||||
File: icns_jp2.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
2007 Thomas Lübking <[email protected]>
|
||||
2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
|
||||
#ifdef ICNS_JASPER
|
||||
#include <jasper.h>
|
||||
#endif
|
||||
|
||||
#ifdef ICNS_OPENJPEG
|
||||
#include <openjpeg.h>
|
||||
#endif
|
||||
|
||||
#define true 1
|
||||
#define false 0
|
||||
|
||||
#if defined(ICNS_JASPER) && defined(ICNS_OPENJPEG)
|
||||
#error "Should use either Jasper or OpenJPEG, but not both!"
|
||||
#endif
|
||||
|
||||
|
||||
int icns_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
|
||||
if(dataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_jp2_to_image: JP2 data is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_jp2_to_image: Image out is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_jp2_to_image: Invalid data size! (%d)\n",dataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Decoding JP2 image...\n");
|
||||
#endif
|
||||
|
||||
#ifdef ICNS_JASPER
|
||||
error = icns_jas_jp2_to_image(dataSize, dataPtr, imageOut);
|
||||
#else
|
||||
#ifdef ICNS_OPENJPEG
|
||||
error = icns_opj_jp2_to_image(dataSize, dataPtr, imageOut);
|
||||
#else
|
||||
icns_print_err("icns_jp2_to_image: libicns requires jasper or openjpeg to convert jp2 data!\n");
|
||||
icns_free_image(imageOut);
|
||||
error = ICNS_STATUS_UNSUPPORTED;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
if(error == ICNS_STATUS_OK) {
|
||||
printf(" decode result:\n");
|
||||
printf(" width is: %d\n",imageOut->imageWidth);
|
||||
printf(" height is: %d\n",imageOut->imageHeight);
|
||||
printf(" channels are: %d\n",imageOut->imageChannels);
|
||||
printf(" pixel depth is: %d\n",imageOut->imagePixelDepth);
|
||||
printf(" data size is: %d\n",(int)imageOut->imageDataSize);
|
||||
} else {
|
||||
printf(" decode failed.\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
int icns_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
|
||||
if(image == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_jp2: Image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_jp2: Data size NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_jp2: Data ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Encoding JP2 image...\n");
|
||||
#endif
|
||||
|
||||
#ifdef ICNS_JASPER
|
||||
error = icns_jas_image_to_jp2(image, dataSizeOut, dataPtrOut);
|
||||
#else
|
||||
#ifdef ICNS_OPENJPEG
|
||||
error = icns_opj_image_to_jp2(image, dataSizeOut, dataPtrOut);
|
||||
#else
|
||||
*dataPtrOut = NULL;
|
||||
error = ICNS_STATUS_UNSUPPORTED;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#ifdef ICNS_JASPER
|
||||
|
||||
int icns_jas_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
jas_stream_t *imagestream = NULL;
|
||||
int datafmt = 0;
|
||||
jas_image_t *image = NULL;
|
||||
jas_matrix_t *bufs[4] = {NULL,NULL,NULL,NULL};
|
||||
icns_sint32_t imageChannels = 0;
|
||||
icns_sint32_t imageWidth = 0;
|
||||
icns_sint32_t imageHeight = 0;
|
||||
icns_sint32_t imagePixelDepth = 0;
|
||||
icns_sint32_t imageDataSize = 0;
|
||||
icns_byte_t *imageData = NULL;
|
||||
icns_sint8_t adjust[4] = {0,0,0,0};
|
||||
int x, y, c;
|
||||
|
||||
if(dataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: JP2 data is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Image out is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Invalid data size! (%d)\n",dataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
jas_init();
|
||||
|
||||
// Connect a jasper stream to the memory
|
||||
imagestream = jas_stream_memopen((char*)dataPtr, dataSize);
|
||||
|
||||
if(imagestream == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Unable to connect to buffer for decoding!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// Determine the image format
|
||||
datafmt = jas_image_getfmt(imagestream);
|
||||
|
||||
if(datafmt < 0)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Unable to determine jp2 data format! (%d)\n",datafmt);
|
||||
jas_stream_close(imagestream);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
//.Decode the image data
|
||||
// WARNING: libjasper as of 1.9001 may 'crash' here if built with
|
||||
// debugging enabled. There is an assertion in the decoding library
|
||||
// that fails if there are not 3 channels or components (RGB). The
|
||||
// data in icns files is usually RGBA - 4 channels. Thus, the
|
||||
// assert will cause the program to crash.
|
||||
if(!(image = jas_image_decode(imagestream, datafmt, 0)))
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Error while decoding jp2 data stream!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
jas_stream_close(imagestream);
|
||||
|
||||
// JP2 components, i.e. channels in icns case
|
||||
imageChannels = jas_image_numcmpts(image);
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("%d components in jp2 data\n",imageChannels);
|
||||
#endif
|
||||
|
||||
// There should be 4 of these
|
||||
if( imageChannels != 4)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Number of jp2 components (%d) is invalid!\n",imageChannels);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// Assume that we can retrieve all the relevant image
|
||||
// information from componenent number zero.
|
||||
imageWidth = jas_image_cmptwidth(image, 0);
|
||||
imageHeight = jas_image_cmptheight(image, 0);
|
||||
imagePixelDepth = jas_image_cmptprec(image, 0);
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
printf("component %d type: %d\n",c,jas_image_cmpttype(image, c));
|
||||
}
|
||||
#endif
|
||||
|
||||
imageDataSize = imageHeight * imageWidth * imageChannels * (imagePixelDepth / ICNS_BYTE_BITS);
|
||||
imageOut->imageWidth = imageWidth;
|
||||
imageOut->imageHeight = imageHeight;
|
||||
imageOut->imageChannels = imageChannels;
|
||||
imageOut->imagePixelDepth = imagePixelDepth;
|
||||
imageOut->imageDataSize = imageDataSize;
|
||||
imageData = (icns_byte_t *)malloc(imageDataSize);
|
||||
if(!imageData) {
|
||||
icns_print_err("icns_jas_jp2_to_image: Unable to allocate memory block of size: %d!\n",imageDataSize);
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
} else {
|
||||
memset(imageData,0,imageDataSize);
|
||||
imageOut->imageData = imageData;
|
||||
}
|
||||
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
int depth = jas_image_cmptprec(image, c);
|
||||
if(depth > 8) {
|
||||
adjust[c] = depth - 8;
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("BMP CONVERSION: Will be trucating component %d (%d bits) by %d bits to 8 bits.\n",c,depth,adjust[c]);
|
||||
#endif
|
||||
} else {
|
||||
adjust[c] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (c = 0; c < 4; c++)
|
||||
{
|
||||
if((bufs[c] = jas_matrix_create(1, imageWidth)) == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Unable to create image matix! (No memory)\n");
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
}
|
||||
}
|
||||
|
||||
for (y=0; y<imageHeight; y++)
|
||||
{
|
||||
icns_rgba_t *dst_pixel;
|
||||
int r, g, b, a;
|
||||
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
if(jas_image_readcmpt(image, c, 0, y, imageWidth, 1, bufs[c]))
|
||||
{
|
||||
icns_print_err("icns_jas_jp2_to_image: Unable to read data for component #%d!\n",c);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
}
|
||||
|
||||
for (x=0; x<imageWidth; x++)
|
||||
{
|
||||
r = (jas_matrix_getv(bufs[0], x));
|
||||
g = (jas_matrix_getv(bufs[1], x));
|
||||
b = (jas_matrix_getv(bufs[2], x));
|
||||
a = (jas_matrix_getv(bufs[3], x));
|
||||
|
||||
dst_pixel = (icns_rgba_t *)&(imageData[y*imageWidth*imageChannels+x*imageChannels]);
|
||||
|
||||
dst_pixel->r = (icns_byte_t) ((r >> adjust[0])+((r >> (adjust[0]-1))%2));
|
||||
dst_pixel->g = (icns_byte_t) ((g >> adjust[1])+((g >> (adjust[1]-1))%2));
|
||||
dst_pixel->b = (icns_byte_t) ((b >> adjust[2])+((b >> (adjust[2]-1))%2));
|
||||
dst_pixel->a = (icns_byte_t) ((a >> adjust[3])+((a >> (adjust[3]-1))%2));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
exception:
|
||||
|
||||
for(c = 0; c < 4; c++) {
|
||||
if(bufs[c] != NULL)
|
||||
jas_matrix_destroy(bufs[c]);
|
||||
}
|
||||
|
||||
jas_image_destroy(image);
|
||||
jas_image_clearfmts();
|
||||
jas_cleanup();
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
int icns_jas_image_to_jp2(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
jas_stream_t *imagestream = NULL;
|
||||
jas_image_t *jasimage = NULL;
|
||||
jas_matrix_t *bufs[4] = {NULL,NULL,NULL,NULL};
|
||||
jas_image_cmptparm_t cmptparms[4];
|
||||
icns_sint32_t c = 0;
|
||||
icns_sint32_t x = 0;
|
||||
icns_sint32_t y = 0;
|
||||
icns_sint32_t height = 0;
|
||||
icns_sint32_t width = 0;
|
||||
|
||||
if(image == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Data size NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Data ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(image->imageChannels != 4)
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: number if channels in input image should be 4!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
|
||||
}
|
||||
|
||||
if(image->imagePixelDepth != 8)
|
||||
{
|
||||
// Maybe support 64/128-bit images (16/32-bits per channel) in the future?
|
||||
icns_print_err("icns_jas_image_to_jp2: jp2 images currently need to be 8 bits per pixel per channel!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
|
||||
}
|
||||
|
||||
// Set these NULL for now
|
||||
*dataSizeOut = 0;
|
||||
*dataPtrOut = NULL;
|
||||
|
||||
// Apple JP2 icns format seems to be as follows:
|
||||
// JP - JP2 Signature
|
||||
// FTYP - File Type
|
||||
// JP2 - JP2 Header
|
||||
// IHDR
|
||||
// COLR
|
||||
// METH = 1
|
||||
// EnumCS = sRGB
|
||||
// CDEF
|
||||
// JP2C - JPEG 2000 Codestream
|
||||
|
||||
// Set up the component parameters
|
||||
for (c = 0; c < 4; c++) {
|
||||
cmptparms[c].tlx = 0;
|
||||
cmptparms[c].tly = 0;
|
||||
cmptparms[c].hstep = 1;
|
||||
cmptparms[c].vstep = 1;
|
||||
cmptparms[c].width = image->imageWidth;
|
||||
cmptparms[c].height = image->imageHeight;
|
||||
cmptparms[c].prec = image->imagePixelDepth;
|
||||
cmptparms[c].sgnd = false;
|
||||
}
|
||||
|
||||
// Initialize Jasper
|
||||
jas_init();
|
||||
|
||||
// Allocate a new japser image
|
||||
if(!(jasimage = jas_image_create(4, cmptparms, JAS_CLRSPC_UNKNOWN)))
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: could not allocate new jasper image! (Likely out of memory)\n");
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
// Set up the image components
|
||||
jas_image_setclrspc(jasimage, JAS_CLRSPC_SRGB);
|
||||
jas_image_setcmpttype(jasimage, 0, JAS_IMAGE_CT_RGB_R);
|
||||
jas_image_setcmpttype(jasimage, 1, JAS_IMAGE_CT_RGB_G);
|
||||
jas_image_setcmpttype(jasimage, 2, JAS_IMAGE_CT_RGB_B);
|
||||
jas_image_setcmpttype(jasimage, 3, JAS_IMAGE_CT_OPACITY);
|
||||
|
||||
width = image->imageWidth;
|
||||
height = image->imageHeight;
|
||||
|
||||
// Allocate the matrix buffers
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
if((bufs[c] = jas_matrix_create(height, width)) == NULL)
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Unable to create image matix! (No memory)\n");
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
}
|
||||
}
|
||||
|
||||
// Copy all the image data into the jasper matrices
|
||||
for (y=0; y<height; y++)
|
||||
{
|
||||
icns_rgba_t *src_pixel;
|
||||
int offset = 0;
|
||||
|
||||
for (x=0; x<width; x++)
|
||||
{
|
||||
offset = y*width*4+x*4;
|
||||
src_pixel = (icns_rgba_t *)&((image->imageData)[offset]);
|
||||
|
||||
jas_matrix_set(bufs[0], y, x, src_pixel->r);
|
||||
jas_matrix_set(bufs[1], y, x, src_pixel->g);
|
||||
jas_matrix_set(bufs[2], y, x, src_pixel->b);
|
||||
jas_matrix_set(bufs[3], y, x, src_pixel->a);
|
||||
}
|
||||
}
|
||||
|
||||
// Write each channel component to the jasper image
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
if(jas_image_writecmpt(jasimage, c, 0, 0, width, height, bufs[c]))
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Unable to write data for component #%d!\n",c);
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
}
|
||||
|
||||
// Create a new in-memory stream - Jasper will allocate and grow this as needed
|
||||
imagestream = jas_stream_memopen( NULL, 0);
|
||||
|
||||
if(jas_image_encode(jasimage, imagestream, jas_image_strtofmt("jp2"),NULL)) {
|
||||
icns_print_err("icns_jas_image_to_jp2: Unable to encode jp2 data!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
jas_stream_flush(imagestream);
|
||||
|
||||
// Get the size of the stream - add 34 bytes for cdef
|
||||
*dataSizeOut = jas_stream_length(imagestream)+34;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Compressed jp2 data size is %d\n",*dataSizeOut);
|
||||
#endif
|
||||
|
||||
// Offload the stream to our memory buffers
|
||||
*dataPtrOut = (icns_byte_t *)malloc(*dataSizeOut);
|
||||
if(!(*dataPtrOut))
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)*dataSizeOut);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
jas_stream_rewind(imagestream);
|
||||
jas_stream_read(imagestream,*dataPtrOut,*dataSizeOut);
|
||||
|
||||
jas_stream_close(imagestream);
|
||||
|
||||
icns_place_jp2_cdef(*dataPtrOut,*dataSizeOut);
|
||||
|
||||
exception:
|
||||
|
||||
for(c = 0; c < 4; c++) {
|
||||
if(bufs[c] != NULL)
|
||||
jas_matrix_destroy(bufs[c]);
|
||||
}
|
||||
|
||||
jas_image_destroy(jasimage);
|
||||
jas_image_clearfmts();
|
||||
jas_cleanup();
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
#endif /* ifdef ICNS_JASPER */
|
||||
|
||||
|
||||
|
||||
// Only compile the openjpeg routines if we have support for it
|
||||
#ifdef ICNS_OPENJPEG
|
||||
|
||||
int icns_opj_jp2_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
opj_image_t *image = NULL;
|
||||
|
||||
if(dataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_jp2_to_image: JP2 data is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_jp2_to_image: Image out is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_opj_jp2_to_image: Invalid data size! (%d)\n",dataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
error = icns_opj_jp2_dec(dataSize, dataPtr, &image);
|
||||
|
||||
if(!image)
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
|
||||
error = icns_opj_to_image(image,imageOut);
|
||||
|
||||
opj_image_destroy(image);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
// Decode jp2 data using OpenJPEG
|
||||
int icns_opj_jp2_dec(icns_size_t dataSize, icns_byte_t *dataPtr, opj_image_t **imageOut)
|
||||
{
|
||||
opj_event_mgr_t event_mgr;
|
||||
opj_dparameters_t parameters;
|
||||
opj_dinfo_t *dinfo = NULL;
|
||||
opj_cio_t *cio = NULL;
|
||||
opj_image_t *image = NULL;
|
||||
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = icns_opj_error_callback;
|
||||
event_mgr.warning_handler = icns_opj_warning_callback;
|
||||
event_mgr.info_handler = icns_opj_info_callback;
|
||||
|
||||
opj_set_default_decoder_parameters(¶meters);
|
||||
|
||||
dinfo = opj_create_decompress(CODEC_JP2);
|
||||
opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
|
||||
opj_setup_decoder(dinfo, ¶meters);
|
||||
|
||||
cio = opj_cio_open((opj_common_ptr)dinfo, dataPtr, dataSize);
|
||||
|
||||
image = opj_decode(dinfo, cio);
|
||||
if(!image) {
|
||||
icns_print_err("icns_opj_jp2_dec: failed to decode image!\n");
|
||||
opj_destroy_decompress(dinfo);
|
||||
opj_cio_close(cio);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
} else {
|
||||
*imageOut = image;
|
||||
}
|
||||
|
||||
opj_cio_close(cio);
|
||||
opj_destroy_decompress(dinfo);
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
// Convert from opj_image_t to icns_image_t
|
||||
int icns_opj_to_image(opj_image_t *opjImg, icns_image_t *iconImg)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
icns_sint8_t adjust[4] = {0,0,0,0};
|
||||
icns_byte_t *dataPtr = NULL;
|
||||
int c = 0;
|
||||
int i, j;
|
||||
int rowOffset, colOffset;
|
||||
|
||||
if(opjImg == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_to_image: OpenJPEG image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconImg == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_to_image: Icon image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
iconImg->imageWidth = opjImg->comps[0].w;
|
||||
iconImg->imageHeight = opjImg->comps[0].h;
|
||||
iconImg->imageChannels = opjImg->numcomps;
|
||||
iconImg->imagePixelDepth = opjImg->comps[0].prec;
|
||||
|
||||
iconImg->imageDataSize = iconImg->imageHeight * iconImg->imageWidth * iconImg->imagePixelDepth; // * iconChannels ?
|
||||
iconImg->imageData = (icns_byte_t *)malloc(iconImg->imageDataSize);
|
||||
if(!iconImg->imageData) {
|
||||
icns_print_err("icns_create_family: Unable to allocate memory block of size: %d!\n",iconImg->imageDataSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memset(iconImg->imageData,0,iconImg->imageDataSize);
|
||||
|
||||
dataPtr = iconImg->imageData;
|
||||
|
||||
for(c = 0; c < 4; c++)
|
||||
{
|
||||
int depth = opjImg->comps[c].prec;
|
||||
if(depth > 8) {
|
||||
adjust[c] = depth - 8;
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("BMP CONVERSION: Will be trucating component %d (%d bits) by %d bits to 8 bits.\n",c,depth,adjust[c]);
|
||||
#endif
|
||||
} else {
|
||||
adjust[c] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < iconImg->imageHeight; i++) {
|
||||
rowOffset = i * iconImg->imageChannels * iconImg->imageWidth;
|
||||
for(j = 0; j < iconImg->imageWidth; j++) {
|
||||
icns_rgba_t *dst_pixel;
|
||||
int r, g, b, a;
|
||||
|
||||
colOffset = j * iconImg->imageChannels;
|
||||
|
||||
r = opjImg->comps[0].data[i*iconImg->imageWidth+j];
|
||||
r += (opjImg->comps[0].sgnd ? 1 << (opjImg->comps[0].prec - 1) : 0);
|
||||
g = opjImg->comps[1].data[i*iconImg->imageWidth+j];
|
||||
g += (opjImg->comps[1].sgnd ? 1 << (opjImg->comps[1].prec - 1) : 0);
|
||||
b = opjImg->comps[2].data[i*iconImg->imageWidth+j];
|
||||
b += (opjImg->comps[2].sgnd ? 1 << (opjImg->comps[2].prec - 1) : 0);
|
||||
a = opjImg->comps[3].data[i*iconImg->imageWidth+j];
|
||||
a += (opjImg->comps[3].sgnd ? 1 << (opjImg->comps[3].prec - 1) : 0);
|
||||
|
||||
dst_pixel = (icns_rgba_t *)&(dataPtr[rowOffset + colOffset]);
|
||||
|
||||
dst_pixel->r = (icns_byte_t) ((r >> adjust[0])+((r >> (adjust[0]-1))%2));
|
||||
dst_pixel->g = (icns_byte_t) ((g >> adjust[1])+((g >> (adjust[1]-1))%2));
|
||||
dst_pixel->b = (icns_byte_t) ((b >> adjust[2])+((b >> (adjust[2]-1))%2));
|
||||
dst_pixel->a = (icns_byte_t) ((a >> adjust[3])+((a >> (adjust[3]-1))%2));
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
int icns_opj_image_to_jp2(icns_image_t *iconImg, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
opj_event_mgr_t event_mgr;
|
||||
opj_cparameters_t parameters;
|
||||
OPJ_COLOR_SPACE color_space = CLRSPC_SRGB;
|
||||
opj_image_cmptparm_t cmptparm[4];
|
||||
opj_image_t *opjImg = NULL;
|
||||
icns_byte_t *dataPtr = NULL;
|
||||
int i, j;
|
||||
int rowOffset, colOffset;
|
||||
opj_cinfo_t *cinfo = NULL;
|
||||
opj_cio_t *cio = NULL;
|
||||
int success = 0;
|
||||
|
||||
if(iconImg == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_image_to_jp2: Image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_image_to_jp2: Data size NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_opj_image_to_jp2: Data ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(iconImg->imageChannels != 4)
|
||||
{
|
||||
icns_print_err("icns_image_to_opj: number if channels in input image should be 4!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
|
||||
}
|
||||
|
||||
if(iconImg->imagePixelDepth != 8)
|
||||
{
|
||||
// Maybe support 64/128-bit images (16/32-bits per channel) in the future?
|
||||
icns_print_err("icns_image_to_opj: jp2 images currently need to be 8 bits per pixel per channel!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
*dataSizeOut = 0;
|
||||
*dataPtrOut = NULL;
|
||||
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = icns_opj_error_callback;
|
||||
event_mgr.warning_handler = icns_opj_warning_callback;
|
||||
event_mgr.info_handler = icns_opj_info_callback;
|
||||
|
||||
opj_set_default_encoder_parameters(¶meters);
|
||||
|
||||
parameters.tcp_numlayers = 1;
|
||||
parameters.tcp_rates[0] = 1;
|
||||
parameters.cp_disto_alloc = 1;
|
||||
parameters.irreversible = 0;
|
||||
|
||||
memset(&cmptparm[0], 0, 4 * sizeof(opj_image_cmptparm_t));
|
||||
for(i = 0; i < 4; i++) {
|
||||
|
||||
cmptparm[i].w = iconImg->imageWidth;
|
||||
cmptparm[i].h = iconImg->imageHeight;
|
||||
cmptparm[i].dx = 1;
|
||||
cmptparm[i].dy = 1;
|
||||
cmptparm[i].prec = iconImg->imagePixelDepth;
|
||||
cmptparm[i].bpp = iconImg->imagePixelDepth;
|
||||
cmptparm[i].sgnd = 0;
|
||||
}
|
||||
|
||||
opjImg = opj_image_create(4, &cmptparm[0], color_space);
|
||||
if(!opjImg) {
|
||||
icns_print_err("icns_image_to_opj: Unable to create new image!\n");
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
opjImg->x0 = 0;
|
||||
opjImg->y0 = 0;
|
||||
opjImg->x1 = iconImg->imageWidth;
|
||||
opjImg->y1 = iconImg->imageHeight;
|
||||
|
||||
dataPtr = iconImg->imageData;
|
||||
for (i = 0; i < iconImg->imageHeight; i++) {
|
||||
rowOffset = i * iconImg->imageChannels * iconImg->imageWidth;
|
||||
for(j = 0; j < iconImg->imageWidth; j++) {
|
||||
icns_rgba_t *src_pixel;
|
||||
int p = i * iconImg->imageWidth + j;
|
||||
|
||||
colOffset = j * iconImg->imageChannels;
|
||||
|
||||
src_pixel = (icns_rgba_t *)&(dataPtr[rowOffset + colOffset]);
|
||||
|
||||
opjImg->comps[0].data[p] = src_pixel->r;
|
||||
opjImg->comps[1].data[p] = src_pixel->g;
|
||||
opjImg->comps[2].data[p] = src_pixel->b;
|
||||
opjImg->comps[3].data[p] = src_pixel->a;
|
||||
}
|
||||
}
|
||||
|
||||
cinfo = opj_create_compress(CODEC_JP2);
|
||||
opj_set_event_mgr((opj_common_ptr)cinfo, &event_mgr, stderr);
|
||||
opj_setup_encoder(cinfo, ¶meters, opjImg);
|
||||
|
||||
cio = opj_cio_open((opj_common_ptr)cinfo, NULL, 0);
|
||||
|
||||
success = opj_encode(cinfo, cio, opjImg, NULL);
|
||||
if (!success) {
|
||||
opj_cio_close(cio);
|
||||
icns_print_err("icns_opj_jp2_enc: Error while encoding jp2 data!\n");
|
||||
error = ICNS_STATUS_INVALID_DATA;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
*dataSizeOut = cio_tell(cio) + 34;
|
||||
*dataPtrOut = (icns_byte_t *)malloc(*dataSizeOut);
|
||||
|
||||
if(!(*dataPtrOut))
|
||||
{
|
||||
icns_print_err("icns_jas_image_to_jp2: Unable to allocate memory block of size: %d!\n",(int)*dataSizeOut);
|
||||
error = ICNS_STATUS_NO_MEMORY;
|
||||
goto exception;
|
||||
}
|
||||
|
||||
memcpy(*dataPtrOut,cio->buffer,*dataSizeOut - 34);
|
||||
|
||||
icns_place_jp2_cdef(*dataPtrOut,*dataSizeOut);
|
||||
|
||||
exception:
|
||||
if(opjImg) {
|
||||
opj_image_destroy(opjImg);
|
||||
opjImg = NULL;
|
||||
}
|
||||
if(cio) {
|
||||
opj_cio_close(cio);
|
||||
cio = NULL;
|
||||
}
|
||||
if(cinfo) {
|
||||
opj_destroy_compress(cinfo);
|
||||
cinfo = NULL;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
void icns_opj_error_callback(const char *msg, void *client_data) {
|
||||
}
|
||||
|
||||
void icns_opj_warning_callback(const char *msg, void *client_data) {
|
||||
}
|
||||
|
||||
void icns_opj_info_callback(const char *msg, void *client_data) {
|
||||
}
|
||||
|
||||
#endif /* ifdef ICNS_OPENJPEG */
|
||||
|
||||
|
||||
// Add cdef block - requires that dataPtr has 34 extra bytes!
|
||||
void icns_place_jp2_cdef(icns_byte_t *dataPtr, icns_size_t dataSize)
|
||||
{
|
||||
icns_sint32_t offset = 0;
|
||||
icns_uint32_t blocksize = 0;
|
||||
icns_uint32_t blocktype = 0;
|
||||
icns_byte_t *bytes = NULL;
|
||||
icns_uint32_t headeroffs = 0;
|
||||
icns_uint32_t headersize = 0;
|
||||
icns_byte_t cdef[34];
|
||||
|
||||
// Initialize CDEF block
|
||||
|
||||
// big endian block size - 34 bytes
|
||||
cdef[0] = 0x00;
|
||||
cdef[1] = 0x00;
|
||||
cdef[2] = 0x00;
|
||||
cdef[3] = 0x22;
|
||||
|
||||
// id = 'cdef'
|
||||
cdef[4] = 'c';
|
||||
cdef[5] = 'd';
|
||||
cdef[6] = 'e';
|
||||
cdef[7] = 'f';
|
||||
|
||||
// component count - 4
|
||||
cdef[8] = 0x00;
|
||||
cdef[9] = 0x04;
|
||||
|
||||
// component number: 0
|
||||
cdef[10] = 0x00;
|
||||
cdef[11] = 0x00;
|
||||
// component type: 0=color component
|
||||
cdef[12] = 0x00;
|
||||
cdef[13] = 0x00;
|
||||
// component association: 1=color 1 assoc
|
||||
cdef[14] = 0x00;
|
||||
cdef[15] = 0x01;
|
||||
|
||||
// component number: 3
|
||||
cdef[16] = 0x00;
|
||||
cdef[17] = 0x03;
|
||||
// component type: 1=opacity component
|
||||
cdef[18] = 0x00;
|
||||
cdef[19] = 0x01;
|
||||
// component association: 0=whole image assoc
|
||||
cdef[20] = 0x00;
|
||||
cdef[21] = 0x00;
|
||||
|
||||
// component number: 1
|
||||
cdef[22] = 0x00;
|
||||
cdef[23] = 0x01;
|
||||
// component type: 0=color component
|
||||
cdef[24] = 0x00;
|
||||
cdef[25] = 0x00;
|
||||
// component association: 2=color 2 assoc
|
||||
cdef[26] = 0x00;
|
||||
cdef[27] = 0x02;
|
||||
|
||||
// component number: 2
|
||||
cdef[28] = 0x00;
|
||||
cdef[29] = 0x02;
|
||||
// component type: 0=color component
|
||||
cdef[30] = 0x00;
|
||||
cdef[31] = 0x00;
|
||||
// component association: 3=color 3 assoc
|
||||
cdef[32] = 0x00;
|
||||
cdef[33] = 0x03;
|
||||
|
||||
// skip 12 bytes to pass signature block
|
||||
offset = 12;
|
||||
bytes = dataPtr + offset;
|
||||
|
||||
// look for jp2h block (0x6A73268)
|
||||
do
|
||||
{
|
||||
blocksize = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
|
||||
offset += 4;
|
||||
bytes = dataPtr + offset;
|
||||
blocktype = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
|
||||
if(blocktype == 0x6A703268) {
|
||||
offset += 4;
|
||||
bytes = dataPtr + offset;
|
||||
} else {
|
||||
offset = offset + (blocksize - 4);
|
||||
bytes = dataPtr + offset;
|
||||
}
|
||||
} while(blocktype != 0x6A703268 && offset < dataSize);
|
||||
|
||||
// make sure we found the jp2h block
|
||||
if(blocktype == 0x6A703268)
|
||||
{
|
||||
uint32_t c = 0;
|
||||
|
||||
// keep track of the current header offset and size
|
||||
headeroffs = offset;
|
||||
headersize = blocksize-8;
|
||||
|
||||
// update the header block size
|
||||
bytes = dataPtr + (headeroffs-8);
|
||||
blocksize += 34;
|
||||
bytes[0] = blocksize >> 24;
|
||||
bytes[1] = blocksize >> 16;
|
||||
bytes[2] = blocksize >> 8;
|
||||
bytes[3] = blocksize;
|
||||
|
||||
// look for colr block (0x636F6C72)
|
||||
offset = headeroffs;
|
||||
bytes = dataPtr + offset;
|
||||
do
|
||||
{
|
||||
blocksize = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
|
||||
offset += 4;
|
||||
bytes = dataPtr + offset;
|
||||
blocktype = bytes[3]|bytes[2]<<8|bytes[1]<<16|bytes[0]<<24;
|
||||
offset = offset + (blocksize - 4);
|
||||
bytes = dataPtr + offset;
|
||||
} while(blocktype != 0x636F6C72 && offset < headeroffs+headersize);
|
||||
|
||||
// if we have colr block, place cdef after it
|
||||
// otherwise, place cdef block at start of ihdr
|
||||
if(blocktype != 0x636F6C72) {
|
||||
offset = headeroffs;
|
||||
}
|
||||
|
||||
// shuffle the bytes backwards to make room for the cdef
|
||||
bytes = dataPtr;
|
||||
for(c = (dataSize)-35; c >= offset; c--) {
|
||||
bytes[c+34] = bytes[c];
|
||||
}
|
||||
|
||||
// copy in the cdef block
|
||||
for(c = 0; c < 34; c++) {
|
||||
bytes[c+offset] = cdef[c];
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,201 +0,0 @@
|
||||
/*
|
||||
File: icns_png.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
|
||||
#include <png.h>
|
||||
|
||||
typedef struct icns_png_io_ref {
|
||||
void* data;
|
||||
size_t size;
|
||||
size_t offset;
|
||||
} icns_png_io_ref;
|
||||
|
||||
static void icns_png_read_memory(png_structp png_ptr, png_bytep data, png_size_t length) {
|
||||
icns_png_io_ref* _ref = (icns_png_io_ref*) png_get_io_ptr( png_ptr );
|
||||
memcpy( data, (char*)_ref->data + _ref->offset, length );
|
||||
_ref->offset += length;
|
||||
}
|
||||
|
||||
int icns_png_to_image(icns_size_t dataSize, icns_byte_t *dataPtr, icns_image_t *imageOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
icns_png_io_ref io_data = { dataPtr, dataSize, 0 };
|
||||
png_structp png_ptr = NULL;
|
||||
png_infop info_ptr = NULL;
|
||||
png_uint_32 w;
|
||||
png_uint_32 h;
|
||||
png_bytep *rows;
|
||||
int bit_depth;
|
||||
int32_t color_type;
|
||||
int row;
|
||||
int rowsize;
|
||||
|
||||
|
||||
if(dataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_png_to_image: JP2 data is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(imageOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_png_to_image: Image out is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSize == 0)
|
||||
{
|
||||
icns_print_err("icns_png_to_image: Invalid data size! (%d)\n",dataSize);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Decoding PNG image...\n");
|
||||
#endif
|
||||
|
||||
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
||||
|
||||
if(png_ptr == NULL) {
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
|
||||
if(info_ptr == NULL) {
|
||||
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
if (setjmp(png_jmpbuf(png_ptr)))
|
||||
{
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
return ICNS_STATUS_INVALID_DATA;
|
||||
}
|
||||
|
||||
// set libpng to read from memory
|
||||
png_set_read_fn(png_ptr, (void *)&io_data, &icns_png_read_memory);
|
||||
|
||||
png_read_info(png_ptr, info_ptr);
|
||||
png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, NULL, NULL, NULL);
|
||||
|
||||
switch (color_type)
|
||||
{
|
||||
case PNG_COLOR_TYPE_RGB:
|
||||
if (bit_depth == 16) {
|
||||
png_set_strip_16(png_ptr);
|
||||
bit_depth = 8;
|
||||
}
|
||||
|
||||
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
|
||||
break;
|
||||
|
||||
case PNG_COLOR_TYPE_RGB_ALPHA:
|
||||
if (bit_depth == 16) {
|
||||
png_set_strip_16(png_ptr);
|
||||
bit_depth = 8;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
png_read_update_info(png_ptr, info_ptr);
|
||||
|
||||
rowsize = png_get_rowbytes(png_ptr, info_ptr);
|
||||
rows = malloc (sizeof(png_bytep) * h);
|
||||
|
||||
imageOut->imageWidth = w;
|
||||
imageOut->imageHeight = h;
|
||||
imageOut->imageChannels = 4;
|
||||
imageOut->imagePixelDepth = 8;
|
||||
imageOut->imageDataSize = w * h * 4;
|
||||
imageOut->imageData = malloc( rowsize * h + 8 );
|
||||
|
||||
if(imageOut->imageData == NULL) {
|
||||
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
||||
free(rows);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
rows[0] = imageOut->imageData;
|
||||
for (row = 1; row < h; row++) {
|
||||
rows[row] = rows[row-1] + rowsize;
|
||||
}
|
||||
|
||||
png_read_image(png_ptr, rows);
|
||||
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
|
||||
|
||||
free(rows);
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
if(error == ICNS_STATUS_OK) {
|
||||
printf(" decode result:\n");
|
||||
printf(" width is: %d\n",imageOut->imageWidth);
|
||||
printf(" height is: %d\n",imageOut->imageHeight);
|
||||
printf(" channels are: %d\n",imageOut->imageChannels);
|
||||
printf(" pixel depth is: %d\n",imageOut->imagePixelDepth);
|
||||
printf(" data size is: %d\n",(int)imageOut->imageDataSize);
|
||||
} else {
|
||||
printf(" decode failed.\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
int icns_image_to_png(icns_image_t *image, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
int error = ICNS_STATUS_OK;
|
||||
|
||||
if(image == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_png: Image is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_png: Data size NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_image_to_png: Data ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Encoding PNG image...\n");
|
||||
#endif
|
||||
|
||||
// TODO:
|
||||
// Verify that size is > 256x256 and 32-bit
|
||||
// Then convert an icns_image to PNG data
|
||||
return error;
|
||||
}
|
||||
|
||||
@@ -1,411 +0,0 @@
|
||||
/*
|
||||
File: icns_rle24.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
2007 Thomas Lübking <[email protected]>
|
||||
2002 Chenxiao Zhao <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
//***************************** icns_decode_rle24_data ****************************//
|
||||
// Decode a rgb 24 bit rle encoded data stream into 32 bit argb (alpha is ignored)
|
||||
|
||||
int icns_decode_rle24_data(icns_size_t rawDataSize, icns_byte_t *rawDataPtr,icns_size_t expectedPixelCount, icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
icns_uint8_t colorOffset = 0;
|
||||
icns_byte_t colorValue = 0;
|
||||
icns_uint8_t runLength = 0;
|
||||
icns_uint32_t dataOffset = 0;
|
||||
icns_uint32_t pixelOffset = 0;
|
||||
icns_uint32_t i = 0;
|
||||
icns_byte_t *destIconData = NULL; // Decompressed Raw Icon Data
|
||||
icns_uint32_t destIconDataSize = 0;
|
||||
|
||||
if(rawDataPtr == NULL)
|
||||
{
|
||||
icns_print_err("icns_decode_rle24_data: rle decoder data in ptr is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_decode_rle24_data: rle decoder data out size ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_decode_rle24_data: rle decoder data out ptr is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
// Calculate required data storage (pixels * 4 channels)
|
||||
destIconDataSize = expectedPixelCount * 4;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Compressed RLE data size is %d\n",(int)rawDataSize);
|
||||
printf("Decompressed will be %d bytes (%d pixels)\n",(int)destIconDataSize,(int)expectedPixelCount);
|
||||
#endif
|
||||
|
||||
if( (*dataSizeOut != destIconDataSize) || (*dataPtrOut == NULL) )
|
||||
{
|
||||
if(*dataPtrOut != NULL)
|
||||
free(*dataPtrOut);
|
||||
|
||||
// Allocate the block for the decoded memory and set to 0
|
||||
destIconData = (icns_byte_t *)malloc(destIconDataSize);
|
||||
if(!destIconData)
|
||||
{
|
||||
icns_print_err("icns_decode_rle24_data: Unable to allocate memory block of size: %d ($s:%m)!\n",(int)destIconDataSize);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memset(destIconData,0,destIconDataSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
destIconData = *dataPtrOut;
|
||||
}
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("Decoding RLE data into RGB pixels...\n");
|
||||
#endif
|
||||
|
||||
// What's this??? In the 128x128 icons, we need to start 4 bytes
|
||||
// ahead. There is often a NULL padding here for some reason. If
|
||||
// we don't, the red channel will be off by 2 pixels, or worse
|
||||
if( *((icns_uint32_t*)rawDataPtr) == 0x00000000 )
|
||||
{
|
||||
#ifdef ICNS_DEBUG
|
||||
printf("4 byte null padding found in rle data!\n");
|
||||
#endif
|
||||
dataOffset = 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
dataOffset = 0;
|
||||
}
|
||||
|
||||
// Data is stored in red run, green run,blue run
|
||||
// So we decompress to pixel format RGBA
|
||||
// RED: byte[0], byte[4], byte[8] ...
|
||||
// GREEN: byte[1], byte[5], byte[9] ...
|
||||
// BLUE: byte[2], byte[6], byte[10] ...
|
||||
// ALPHA: byte[3], byte[7], byte[11] do nothing with these bytes
|
||||
for(colorOffset = 0; colorOffset < 3; colorOffset++)
|
||||
{
|
||||
pixelOffset = 0;
|
||||
while((pixelOffset < expectedPixelCount) && (dataOffset < rawDataSize))
|
||||
{
|
||||
if( (rawDataPtr[dataOffset] & 0x80) == 0)
|
||||
{
|
||||
// Top bit is clear - run of various values to follow
|
||||
runLength = (0xFF & rawDataPtr[dataOffset++]) + 1; // 1 <= len <= 128
|
||||
for(i = 0; (i < runLength) && (pixelOffset < expectedPixelCount) && (dataOffset < rawDataSize); i++) {
|
||||
destIconData[(pixelOffset * 4) + colorOffset] = rawDataPtr[dataOffset++];
|
||||
pixelOffset++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Top bit is set - run of one value to follow
|
||||
runLength = (0xFF & rawDataPtr[dataOffset++]) - 125; // 3 <= len <= 130
|
||||
// Set the value to the color shifted to the correct bit offset
|
||||
colorValue = rawDataPtr[dataOffset++];
|
||||
|
||||
for(i = 0; (i < runLength) && (pixelOffset < expectedPixelCount); i++) {
|
||||
destIconData[(pixelOffset * 4) + colorOffset] = colorValue;
|
||||
pixelOffset++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*dataSizeOut = destIconDataSize;
|
||||
*dataPtrOut = destIconData;
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
//***************************** icns_encode_rle24_data *******************************************//
|
||||
// Encode an 32 bit argb data stream into a 24 bit rgb rle encoded data stream (alpha is ignored)
|
||||
|
||||
int icns_encode_rle24_data(icns_size_t dataSizeIn, icns_byte_t *dataPtrIn,icns_size_t *dataSizeOut, icns_byte_t **dataPtrOut)
|
||||
{
|
||||
unsigned long dataInCount = 0;
|
||||
unsigned long dataInChanSize = 0;
|
||||
icns_byte_t *rgbaDataPtr = NULL;
|
||||
icns_sint8_t *dataTemp = NULL;
|
||||
unsigned long dataTempCount = 0;
|
||||
icns_uint8_t colorOffset = 0;
|
||||
icns_uint8_t dataByte = 0;
|
||||
icns_uint8_t *dataRun = NULL;
|
||||
icns_bool_t runType = 0;
|
||||
icns_uint8_t runLength = 0; // Runs will never go over 130, one byte is ok
|
||||
int runCount = 0;
|
||||
|
||||
if(dataPtrIn == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: rle encoder data in ptr is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataSizeOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: rle encoder data out size ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
if(dataPtrOut == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: rle encoder data out ptr ref is NULL!\n");
|
||||
return ICNS_STATUS_NULL_PARAM;
|
||||
}
|
||||
|
||||
// Assumptions of what icns rle data is all about:
|
||||
// A) Each channel is encoded indepenent of the next.
|
||||
// B) An encoded channel looks like this:
|
||||
// 0xRL 0xCV 0xCV 0xRL 0xCV - RL is run-length and CV is color value.
|
||||
// C) There are two types of runs
|
||||
// 1) Run of same value - high bit of RL is set
|
||||
// 2) Run of differing values - high bit of RL is NOT set
|
||||
// D) 0xRL also has two ranges
|
||||
// 1) for set high bit RL, 3 to 130
|
||||
// 2) for clr high bit RL, 1 to 128
|
||||
// E) 0xRL byte is therefore set as follows:
|
||||
// 1) for same values, RL = RL - 1
|
||||
// 2) different values, RL = RL + 125
|
||||
// 3) both methods will automatically set the high bit appropriately
|
||||
// F) 0xCV byte are set accordingly
|
||||
// 1) for differing values, run of all differing values
|
||||
// 2) for same values, only one byte of that values
|
||||
// Estimations put the absolute worst case scenario as the
|
||||
// final compressed data being slightly LARGER. So we need to be
|
||||
// careful about allocating memory. (Did I miss something?)
|
||||
// tests seem to indicate it will never be larger than the original
|
||||
|
||||
// This block is for the new RLE encoded data - make it 25% larger
|
||||
dataTemp = (icns_sint8_t *)malloc(dataSizeIn + (dataSizeIn / 4));
|
||||
if(dataTemp == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",(int)dataSizeIn);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memset(dataTemp,0,dataSizeIn);
|
||||
|
||||
// This block is for a run of RLE encoded data
|
||||
dataRun = (icns_uint8_t *)malloc(140);
|
||||
if(dataRun == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",140);
|
||||
free(dataTemp);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
memset(dataRun,0,140);
|
||||
|
||||
// Set the data ptr
|
||||
rgbaDataPtr = (icns_byte_t *)dataPtrIn;
|
||||
|
||||
// There's always going to be 4 channels in this
|
||||
// so we want our counter to increment through
|
||||
// channels, not bytes....
|
||||
dataInChanSize = dataSizeIn / 4;
|
||||
|
||||
// Move forward 4 bytes for 128 size - who knows why this should be
|
||||
if(dataSizeIn >= 65536)
|
||||
dataTempCount = 4;
|
||||
|
||||
// Data is stored in red run, green run,blue run
|
||||
// So we compress from pixel format RGBA
|
||||
// RED: byte[0], byte[4], byte[8] ...
|
||||
// GREEN: byte[1], byte[5], byte[9] ...
|
||||
// BLUE: byte[2], byte[6], byte[10] ...
|
||||
// ALPHA: byte[3], byte[7], byte[11] do nothing with these bytes
|
||||
for(colorOffset = 0; colorOffset < 3; colorOffset++)
|
||||
{
|
||||
runCount = 0;
|
||||
|
||||
// Set the first byte of the run...
|
||||
dataRun[0] = *(rgbaDataPtr+colorOffset);
|
||||
|
||||
// Start with a runlength of 1 for the first byte
|
||||
runLength = 1;
|
||||
|
||||
// Assume that the run will be different for now... We can change this later
|
||||
runType = 0; // 0 for low bit (different), 1 for high bit (same)
|
||||
|
||||
// Start one byte ahead
|
||||
for(dataInCount = 1; dataInCount < dataInChanSize; dataInCount++)
|
||||
{
|
||||
dataByte = *(rgbaDataPtr+colorOffset+(dataInCount*4));
|
||||
|
||||
if(runLength < 2)
|
||||
{
|
||||
// Simply append to the current run
|
||||
dataRun[runLength++] = dataByte;
|
||||
}
|
||||
else if(runLength == 2)
|
||||
{
|
||||
// Decide here if the run should be same values or different values
|
||||
|
||||
// If the last three values were the same, we can change to a same-type run
|
||||
if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
|
||||
runType = 1;
|
||||
else
|
||||
runType = 0;
|
||||
|
||||
dataRun[runLength++] = dataByte;
|
||||
}
|
||||
else // Greater than or equal to 2
|
||||
{
|
||||
if(runType == 0 && runLength < 128) // Different type run
|
||||
{
|
||||
// If the new value matches both of the last two values, we have a new
|
||||
// same-type run starting with the previous two bytes
|
||||
if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
|
||||
{
|
||||
// Set the RL byte
|
||||
*(dataTemp+dataTempCount) = runLength - 3;
|
||||
dataTempCount++;
|
||||
|
||||
// Copy 0 to runLength-2 bytes to the RLE data here
|
||||
memcpy( dataTemp+dataTempCount , dataRun , runLength - 2 );
|
||||
dataTempCount = dataTempCount + (runLength - 2);
|
||||
runCount++;
|
||||
|
||||
// Set up the new same-type run
|
||||
dataRun[0] = dataRun[runLength-2];
|
||||
dataRun[1] = dataRun[runLength-1];
|
||||
dataRun[2] = dataByte;
|
||||
runLength = 3;
|
||||
runType = 1;
|
||||
}
|
||||
else // They don't match, so we can proceed
|
||||
{
|
||||
dataRun[runLength++] = dataByte;
|
||||
}
|
||||
}
|
||||
else if(runType == 1 && runLength < 130) // Same type run
|
||||
{
|
||||
// If the new value matches both of the last two values, we
|
||||
// can safely continue
|
||||
if( (dataByte == dataRun[runLength-1]) && (dataByte == dataRun[runLength-2]) )
|
||||
{
|
||||
dataRun[runLength++] = dataByte;
|
||||
}
|
||||
else // They don't match, so we need to start a new run
|
||||
{
|
||||
// Set the RL byte
|
||||
*(dataTemp+dataTempCount) = runLength + 125;
|
||||
dataTempCount++;
|
||||
|
||||
// Only copy the first byte, since all the remaining values are identical
|
||||
*(dataTemp+dataTempCount) = dataRun[0];
|
||||
dataTempCount++;
|
||||
runCount++;
|
||||
|
||||
// Copy 0 to runLength bytes to the RLE data here
|
||||
dataRun[0] = dataByte;
|
||||
runLength = 1;
|
||||
runType = 0;
|
||||
}
|
||||
}
|
||||
else // Exceeded run limit, need to start a new one
|
||||
{
|
||||
if(runType == 0)
|
||||
{
|
||||
// Set the RL byte low
|
||||
*(dataTemp+dataTempCount) = runLength - 1;
|
||||
dataTempCount++;
|
||||
|
||||
// Copy 0 to runLength bytes to the RLE data here
|
||||
memcpy( dataTemp+dataTempCount , dataRun , runLength );
|
||||
dataTempCount = dataTempCount + runLength;
|
||||
}
|
||||
else if(runType == 1)
|
||||
{
|
||||
// Set the RL byte high
|
||||
*(dataTemp+dataTempCount) = runLength + 125;
|
||||
dataTempCount++;
|
||||
|
||||
// Only copy the first byte, since all the remaining values are identical
|
||||
*(dataTemp+dataTempCount) = dataRun[0];
|
||||
dataTempCount++;
|
||||
}
|
||||
|
||||
runCount++;
|
||||
|
||||
// Copy 0 to runLength bytes to the RLE data here
|
||||
dataRun[0] = dataByte;
|
||||
runLength = 1;
|
||||
runType = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Copy the end of the last run
|
||||
if(runLength > 0)
|
||||
{
|
||||
if(runType == 0)
|
||||
{
|
||||
// Set the RL byte low
|
||||
*(dataTemp+dataTempCount) = runLength - 1;
|
||||
dataTempCount++;
|
||||
|
||||
// Copy 0 to runLength bytes to the RLE data here
|
||||
memcpy( dataTemp+dataTempCount , dataRun , runLength );
|
||||
dataTempCount = dataTempCount + runLength;
|
||||
}
|
||||
else if(runType == 1)
|
||||
{
|
||||
// Set the RL byte high
|
||||
*(dataTemp+dataTempCount) = runLength + 125;
|
||||
dataTempCount++;
|
||||
|
||||
// Only copy the first byte, since all the remaining values are identical
|
||||
*(dataTemp+dataTempCount) = dataRun[0];
|
||||
dataTempCount++;
|
||||
}
|
||||
|
||||
runCount++;
|
||||
}
|
||||
}
|
||||
|
||||
free(dataRun);
|
||||
|
||||
// This block is for the final encoded data
|
||||
(*dataPtrOut) = (icns_uint8_t *)malloc(dataTempCount);
|
||||
if((*dataPtrOut) == NULL)
|
||||
{
|
||||
icns_print_err("icns_encode_rle24_data: Unable to allocate memory block of size: %d!\n",dataTempCount);
|
||||
free(dataTemp);
|
||||
return ICNS_STATUS_NO_MEMORY;
|
||||
}
|
||||
|
||||
*dataSizeOut = dataTempCount;
|
||||
memcpy( (*dataPtrOut), dataTemp, dataTempCount);
|
||||
|
||||
free(dataTemp);
|
||||
|
||||
return ICNS_STATUS_OK;
|
||||
}
|
||||
|
||||
@@ -1,763 +0,0 @@
|
||||
/*
|
||||
File: icns_utils.c
|
||||
Copyright (C) 2001-2012 Mathew Eis <[email protected]>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the
|
||||
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
||||
Boston, MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
|
||||
#include "icns.h"
|
||||
#include "icns_internals.h"
|
||||
|
||||
|
||||
/********* This variable is intentionally global ************/
|
||||
/********* scope is the internals of the icns library *******/
|
||||
#ifdef ICNS_DEBUG
|
||||
icns_bool_t gShouldPrintErrors = 1;
|
||||
#else
|
||||
icns_bool_t gShouldPrintErrors = 0;
|
||||
#endif
|
||||
|
||||
icns_uint32_t icns_get_element_order(icns_type_t iconType)
|
||||
{
|
||||
// Note: 1 bit mask is 'excluded' as
|
||||
// 1 bit data and mask ID's are equal
|
||||
// data stored in the same element
|
||||
switch(iconType)
|
||||
{
|
||||
case ICNS_ICON_VERSION:
|
||||
return 100;
|
||||
case ICNS_1024x1024_32BIT_ARGB_DATA:
|
||||
return 23;
|
||||
case ICNS_512x512_32BIT_ARGB_DATA:
|
||||
return 22;
|
||||
case ICNS_256x256_32BIT_ARGB_DATA:
|
||||
return 21;
|
||||
case ICNS_128X128_8BIT_MASK:
|
||||
return 20;
|
||||
case ICNS_128X128_32BIT_DATA:
|
||||
return 19;
|
||||
case ICNS_48x48_8BIT_MASK:
|
||||
return 18;
|
||||
case ICNS_48x48_32BIT_DATA:
|
||||
return 17;
|
||||
case ICNS_48x48_8BIT_DATA:
|
||||
return 16;
|
||||
case ICNS_48x48_4BIT_DATA:
|
||||
return 15;
|
||||
case ICNS_48x48_1BIT_DATA:
|
||||
return 14;
|
||||
case ICNS_32x32_8BIT_MASK:
|
||||
return 13;
|
||||
case ICNS_32x32_32BIT_DATA:
|
||||
return 12;
|
||||
case ICNS_32x32_8BIT_DATA:
|
||||
return 11;
|
||||
case ICNS_32x32_4BIT_DATA:
|
||||
return 10;
|
||||
case ICNS_32x32_1BIT_DATA:
|
||||
return 9;
|
||||
case ICNS_16x16_8BIT_MASK:
|
||||
return 8;
|
||||
case ICNS_16x16_32BIT_DATA:
|
||||
return 7;
|
||||
case ICNS_16x16_8BIT_DATA:
|
||||
return 6;
|
||||
case ICNS_16x16_4BIT_DATA:
|
||||
return 5;
|
||||
case ICNS_16x16_1BIT_DATA:
|
||||
return 4;
|
||||
case ICNS_16x12_8BIT_DATA:
|
||||
return 3;
|
||||
case ICNS_16x12_4BIT_DATA:
|
||||
return 2;
|
||||
case ICNS_16x12_1BIT_DATA:
|
||||
return 1;
|
||||
case ICNS_TABLE_OF_CONTENTS:
|
||||
return 0;
|
||||
default:
|
||||
return 1000;
|
||||
}
|
||||
|
||||
return 1000;
|
||||
}
|
||||
|
||||
icns_type_t icns_get_mask_type_for_icon_type(icns_type_t iconType)
|
||||
{
|
||||
switch(iconType)
|
||||
{
|
||||
// Obviously the TOC type has no mask
|
||||
case ICNS_TABLE_OF_CONTENTS:
|
||||
return ICNS_NULL_MASK;
|
||||
|
||||
// Obviously the version type has no mask
|
||||
case ICNS_ICON_VERSION:
|
||||
return ICNS_NULL_MASK;
|
||||
|
||||
// 32-bit image types > 256x256 - no mask (mask is already in image)
|
||||
case ICNS_1024x1024_32BIT_ARGB_DATA:
|
||||
return ICNS_NULL_MASK;
|
||||
case ICNS_512x512_32BIT_ARGB_DATA:
|
||||
return ICNS_NULL_MASK;
|
||||
case ICNS_256x256_32BIT_ARGB_DATA:
|
||||
return ICNS_NULL_MASK;
|
||||
|
||||
// 32-bit image types - 8-bit mask type
|
||||
case ICNS_128X128_32BIT_DATA:
|
||||
return ICNS_128X128_8BIT_MASK;
|
||||
case ICNS_48x48_32BIT_DATA:
|
||||
return ICNS_48x48_8BIT_MASK;
|
||||
case ICNS_32x32_32BIT_DATA:
|
||||
return ICNS_32x32_8BIT_MASK;
|
||||
case ICNS_16x16_32BIT_DATA:
|
||||
return ICNS_16x16_8BIT_MASK;
|
||||
|
||||
// 8-bit image types - 1-bit mask types
|
||||
case ICNS_48x48_8BIT_DATA:
|
||||
return ICNS_48x48_1BIT_MASK;
|
||||
case ICNS_32x32_8BIT_DATA:
|
||||
return ICNS_32x32_1BIT_MASK;
|
||||
case ICNS_16x16_8BIT_DATA:
|
||||
return ICNS_16x16_1BIT_MASK;
|
||||
case ICNS_16x12_8BIT_DATA:
|
||||
return ICNS_16x12_1BIT_MASK;
|
||||
|
||||
// 4 bit image types - 1-bit mask types
|
||||
case ICNS_48x48_4BIT_DATA:
|
||||
return ICNS_48x48_1BIT_MASK;
|
||||
case ICNS_32x32_4BIT_DATA:
|
||||
return ICNS_32x32_1BIT_MASK;
|
||||
case ICNS_16x16_4BIT_DATA:
|
||||
return ICNS_16x16_1BIT_MASK;
|
||||
case ICNS_16x12_4BIT_DATA:
|
||||
return ICNS_16x12_1BIT_MASK;
|
||||
|
||||
// 1 bit image types - 1-bit mask types
|
||||
case ICNS_48x48_1BIT_DATA:
|
||||
return ICNS_48x48_1BIT_MASK;
|
||||
case ICNS_32x32_1BIT_DATA:
|
||||
return ICNS_32x32_1BIT_MASK;
|
||||
case ICNS_16x16_1BIT_DATA:
|
||||
return ICNS_16x16_1BIT_MASK;
|
||||
case ICNS_16x12_1BIT_DATA:
|
||||
return ICNS_16x12_1BIT_MASK;
|
||||
default:
|
||||
return ICNS_NULL_MASK;
|
||||
}
|
||||
|
||||
return ICNS_NULL_MASK;
|
||||
}
|
||||
|
||||
icns_icon_info_t icns_get_image_info_for_type(icns_type_t iconType)
|
||||
{
|
||||
icns_icon_info_t iconInfo;
|
||||
|
||||
memset(&iconInfo,0,sizeof(iconInfo));
|
||||
|
||||
if(iconType == ICNS_NULL_TYPE)
|
||||
{
|
||||
icns_print_err("icns_get_image_info_for_type: Unable to parse NULL type!\n");
|
||||
return iconInfo;
|
||||
}
|
||||
|
||||
/*
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf("Retrieving info for type '%s'...\n",icns_type_str(iconType,typeStr));
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
|
||||
iconInfo.iconType = iconType;
|
||||
|
||||
switch(iconType)
|
||||
{
|
||||
// TOC type
|
||||
case ICNS_TABLE_OF_CONTENTS:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 0;
|
||||
iconInfo.iconHeight = 0;
|
||||
iconInfo.iconChannels = 0;
|
||||
iconInfo.iconPixelDepth = 0;
|
||||
iconInfo.iconBitDepth = 0;
|
||||
break;
|
||||
// Version type
|
||||
case ICNS_ICON_VERSION:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 0;
|
||||
iconInfo.iconHeight = 0;
|
||||
iconInfo.iconChannels = 0;
|
||||
iconInfo.iconPixelDepth = 0;
|
||||
iconInfo.iconBitDepth = 0;
|
||||
break;
|
||||
// 32-bit image types
|
||||
case ICNS_1024x1024_32BIT_ARGB_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 1024;
|
||||
iconInfo.iconHeight = 1024;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_512x512_32BIT_ARGB_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 512;
|
||||
iconInfo.iconHeight = 512;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_256x256_32BIT_ARGB_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 256;
|
||||
iconInfo.iconHeight = 256;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_128X128_32BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 128;
|
||||
iconInfo.iconHeight = 128;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_48x48_32BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 48;
|
||||
iconInfo.iconHeight = 48;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_32x32_32BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 32;
|
||||
iconInfo.iconHeight = 32;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
case ICNS_16x16_32BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 16;
|
||||
iconInfo.iconChannels = 4;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 32;
|
||||
break;
|
||||
|
||||
// 8-bit mask types
|
||||
case ICNS_128X128_8BIT_MASK:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 128;
|
||||
iconInfo.iconHeight = 128;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_48x48_8BIT_MASK:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 48;
|
||||
iconInfo.iconHeight = 48;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_32x32_8BIT_MASK:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 32;
|
||||
iconInfo.iconHeight = 32;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_16x16_8BIT_MASK:
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 16;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
|
||||
// 8-bit image types
|
||||
case ICNS_48x48_8BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 48;
|
||||
iconInfo.iconHeight = 48;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_32x32_8BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 32;
|
||||
iconInfo.iconHeight = 32;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_16x16_8BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 16;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
case ICNS_16x12_8BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 12;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 8;
|
||||
iconInfo.iconBitDepth = 8;
|
||||
break;
|
||||
|
||||
// 4 bit image types
|
||||
case ICNS_48x48_4BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 48;
|
||||
iconInfo.iconHeight = 48;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 4;
|
||||
iconInfo.iconBitDepth = 4;
|
||||
break;
|
||||
case ICNS_32x32_4BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 32;
|
||||
iconInfo.iconHeight = 32;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 4;
|
||||
iconInfo.iconBitDepth = 4;
|
||||
break;
|
||||
case ICNS_16x16_4BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 16;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 4;
|
||||
iconInfo.iconBitDepth = 4;
|
||||
break;
|
||||
case ICNS_16x12_4BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 12;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 4;
|
||||
iconInfo.iconBitDepth = 4;
|
||||
break;
|
||||
|
||||
// 1 bit image types - same as mask typess
|
||||
case ICNS_48x48_1BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 48;
|
||||
iconInfo.iconHeight = 48;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 1;
|
||||
iconInfo.iconBitDepth = 1;
|
||||
break;
|
||||
case ICNS_32x32_1BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 32;
|
||||
iconInfo.iconHeight = 32;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 1;
|
||||
iconInfo.iconBitDepth = 1;
|
||||
break;
|
||||
case ICNS_16x16_1BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 16;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 1;
|
||||
iconInfo.iconBitDepth = 1;
|
||||
break;
|
||||
case ICNS_16x12_1BIT_DATA:
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
iconInfo.iconWidth = 16;
|
||||
iconInfo.iconHeight = 12;
|
||||
iconInfo.iconChannels = 1;
|
||||
iconInfo.iconPixelDepth = 1;
|
||||
iconInfo.iconBitDepth = 1;
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char typeStr[5];
|
||||
icns_print_err("icns_get_image_info_for_type: Unable to parse icon type '%s'\n",icns_type_str(iconType,typeStr));
|
||||
iconInfo.iconType = ICNS_NULL_TYPE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
iconInfo.iconRawDataSize = iconInfo.iconHeight * iconInfo.iconWidth * iconInfo.iconBitDepth / ICNS_BYTE_BITS;
|
||||
|
||||
/*
|
||||
#ifdef ICNS_DEBUG
|
||||
{
|
||||
char typeStr[5];
|
||||
printf(" type is: '%s'\n",icns_type_str(iconInfo.iconType));
|
||||
printf(" width is: %d\n",iconInfo.iconWidth);
|
||||
printf(" height is: %d\n",iconInfo.iconHeight);
|
||||
printf(" channels are: %d\n",iconInfo.iconChannels);
|
||||
printf(" pixel depth is: %d\n",iconInfo.iconPixelDepth);
|
||||
printf(" bit depth is: %d\n",iconInfo.iconBitDepth);
|
||||
printf(" data size is: %d\n",(int)iconInfo.iconRawDataSize);
|
||||
}
|
||||
#endif
|
||||
*/
|
||||
|
||||
return iconInfo;
|
||||
}
|
||||
|
||||
icns_type_t icns_get_type_from_image_info(icns_icon_info_t iconInfo)
|
||||
{
|
||||
// Give our best effort to returning a type from the given information
|
||||
// But there is only so much we can't work with...
|
||||
if( (iconInfo.isImage == 0) && (iconInfo.isMask == 0) )
|
||||
return ICNS_NULL_TYPE;
|
||||
|
||||
if( (iconInfo.iconWidth == 0) || (iconInfo.iconHeight == 0) )
|
||||
{
|
||||
// For some really small sizes, we can tell from just the data size...
|
||||
switch(iconInfo.iconRawDataSize)
|
||||
{
|
||||
case 24:
|
||||
// Data is too small to have both
|
||||
if( (iconInfo.isImage == 1) && (iconInfo.isMask == 1) )
|
||||
return ICNS_NULL_TYPE;
|
||||
if( iconInfo.isImage == 1 )
|
||||
return ICNS_16x12_1BIT_DATA;
|
||||
if( iconInfo.isMask == 1 )
|
||||
return ICNS_16x12_1BIT_MASK;
|
||||
break;
|
||||
case 32:
|
||||
// Data is too small to have both
|
||||
if( (iconInfo.isImage == 1) && (iconInfo.isMask == 1) )
|
||||
return ICNS_NULL_TYPE;
|
||||
if( iconInfo.isImage == 1 )
|
||||
return ICNS_16x16_1BIT_DATA;
|
||||
if( iconInfo.isMask == 1 )
|
||||
return ICNS_16x16_1BIT_MASK;
|
||||
break;
|
||||
default:
|
||||
return ICNS_NULL_TYPE;
|
||||
}
|
||||
}
|
||||
|
||||
// We need the bit depth to determine the type for sizes < 128
|
||||
if( (iconInfo.iconBitDepth == 0) && (iconInfo.iconWidth < 128 || iconInfo.iconHeight < 128) )
|
||||
{
|
||||
if(iconInfo.iconPixelDepth == 0 || iconInfo.iconChannels == 0)
|
||||
return ICNS_NULL_TYPE;
|
||||
else
|
||||
iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
|
||||
}
|
||||
|
||||
// Special case for these mini icons
|
||||
if(iconInfo.iconWidth == 16 && iconInfo.iconHeight == 12)
|
||||
{
|
||||
switch(iconInfo.iconBitDepth)
|
||||
{
|
||||
case 1:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_16x12_1BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_16x12_1BIT_MASK;
|
||||
break;
|
||||
case 4:
|
||||
return ICNS_16x12_4BIT_DATA;
|
||||
break;
|
||||
case 8:
|
||||
return ICNS_16x12_8BIT_DATA;
|
||||
break;
|
||||
default:
|
||||
return ICNS_NULL_TYPE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Width must equal hieght from here on...
|
||||
if(iconInfo.iconWidth != iconInfo.iconHeight)
|
||||
return ICNS_NULL_TYPE;
|
||||
|
||||
|
||||
switch(iconInfo.iconWidth)
|
||||
{
|
||||
case 16:
|
||||
switch(iconInfo.iconBitDepth)
|
||||
{
|
||||
case 1:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_16x16_1BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_16x16_1BIT_MASK;
|
||||
break;
|
||||
case 4:
|
||||
return ICNS_16x16_4BIT_DATA;
|
||||
break;
|
||||
case 8:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_16x16_8BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_16x16_8BIT_MASK;
|
||||
break;
|
||||
case 32:
|
||||
return ICNS_16x16_32BIT_DATA;
|
||||
break;
|
||||
default:
|
||||
return ICNS_NULL_TYPE;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
switch(iconInfo.iconBitDepth)
|
||||
{
|
||||
case 1:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_32x32_1BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_32x32_1BIT_MASK;
|
||||
break;
|
||||
case 4:
|
||||
return ICNS_32x32_4BIT_DATA;
|
||||
break;
|
||||
case 8:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_32x32_8BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_32x32_8BIT_MASK;
|
||||
break;
|
||||
case 32:
|
||||
return ICNS_32x32_32BIT_DATA;
|
||||
break;
|
||||
default:
|
||||
return ICNS_NULL_TYPE;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 48:
|
||||
switch(iconInfo.iconBitDepth)
|
||||
{
|
||||
case 1:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_48x48_1BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_48x48_1BIT_MASK;
|
||||
break;
|
||||
case 4:
|
||||
return ICNS_48x48_4BIT_DATA;
|
||||
break;
|
||||
case 8:
|
||||
if(iconInfo.isImage == 1)
|
||||
return ICNS_48x48_8BIT_DATA;
|
||||
if(iconInfo.isMask == 1)
|
||||
return ICNS_48x48_8BIT_MASK;
|
||||
break;
|
||||
case 32:
|
||||
return ICNS_48x48_32BIT_DATA;
|
||||
break;
|
||||
default:
|
||||
return ICNS_NULL_TYPE;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 128:
|
||||
if(iconInfo.isImage == 1 || iconInfo.iconBitDepth == 32)
|
||||
return ICNS_128X128_32BIT_DATA;
|
||||
if(iconInfo.isMask == 1 || iconInfo.iconBitDepth == 8)
|
||||
return ICNS_128X128_8BIT_MASK;
|
||||
break;
|
||||
case 256:
|
||||
return ICNS_256x256_32BIT_ARGB_DATA;
|
||||
break;
|
||||
case 512:
|
||||
return ICNS_512x512_32BIT_ARGB_DATA;
|
||||
break;
|
||||
case 1024:
|
||||
return ICNS_1024x1024_32BIT_ARGB_DATA;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
return ICNS_NULL_TYPE;
|
||||
}
|
||||
|
||||
icns_type_t icns_get_type_from_image(icns_image_t iconImage)
|
||||
{
|
||||
icns_icon_info_t iconInfo;
|
||||
|
||||
iconInfo.iconWidth = iconImage.imageWidth;
|
||||
iconInfo.iconHeight = iconImage.imageHeight;
|
||||
iconInfo.iconChannels = iconImage.imageChannels;
|
||||
iconInfo.iconPixelDepth = iconImage.imagePixelDepth;
|
||||
iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
|
||||
iconInfo.iconRawDataSize = iconImage.imageDataSize;
|
||||
|
||||
if(iconInfo.iconBitDepth == 1)
|
||||
{
|
||||
int flatSize = ((iconInfo.iconWidth * iconInfo.iconHeight) / 8);
|
||||
if(iconInfo.iconRawDataSize == (flatSize * 2) )
|
||||
{
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 0;
|
||||
}
|
||||
|
||||
return icns_get_type_from_image_info(iconInfo);
|
||||
}
|
||||
|
||||
icns_type_t icns_get_type_from_mask(icns_image_t iconImage)
|
||||
{
|
||||
icns_icon_info_t iconInfo;
|
||||
|
||||
iconInfo.iconWidth = iconImage.imageWidth;
|
||||
iconInfo.iconHeight = iconImage.imageHeight;
|
||||
iconInfo.iconChannels = iconImage.imageChannels;
|
||||
iconInfo.iconPixelDepth = iconImage.imagePixelDepth;
|
||||
iconInfo.iconBitDepth = iconInfo.iconPixelDepth * iconInfo.iconChannels;
|
||||
iconInfo.iconRawDataSize = iconImage.imageDataSize;
|
||||
|
||||
if(iconInfo.iconBitDepth == 1)
|
||||
{
|
||||
int flatSize = ((iconInfo.iconWidth * iconInfo.iconHeight) / 8);
|
||||
if(iconInfo.iconRawDataSize == (flatSize * 2) )
|
||||
{
|
||||
iconInfo.isImage = 1;
|
||||
iconInfo.isMask = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iconInfo.isImage = 0;
|
||||
iconInfo.isMask = 1;
|
||||
}
|
||||
|
||||
return icns_get_type_from_image_info(iconInfo);
|
||||
}
|
||||
|
||||
icns_bool_t icns_types_equal(icns_type_t typeA,icns_type_t typeB)
|
||||
{
|
||||
if(memcmp(&typeA, &typeB, sizeof(icns_type_t)) == 0)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This is is largely for conveniance and readability
|
||||
icns_bool_t icns_types_not_equal(icns_type_t typeA,icns_type_t typeB)
|
||||
{
|
||||
if(memcmp(&typeA, &typeB, sizeof(icns_type_t)) != 0)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char * icns_type_str(icns_type_t type, char *strbuf)
|
||||
{
|
||||
if(strbuf != NULL)
|
||||
{
|
||||
uint32_t v = *((uint32_t *)(&type));
|
||||
strbuf[0] = v >> 24;
|
||||
strbuf[1] = v >> 16;
|
||||
strbuf[2] = v >> 8;
|
||||
strbuf[3] = v;
|
||||
strbuf[4] = 0;
|
||||
return (const char *)strbuf;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void icns_set_print_errors(icns_bool_t shouldPrint)
|
||||
{
|
||||
#ifdef ICNS_DEBUG
|
||||
if(shouldPrint == 0) {
|
||||
icns_print_err("Debugging enabled - error message status cannot be disabled!\n");
|
||||
}
|
||||
#else
|
||||
gShouldPrintErrors = shouldPrint;
|
||||
#endif
|
||||
}
|
||||
|
||||
void icns_print_err(const char *template, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
#ifdef ICNS_DEBUG
|
||||
printf ( "libicns: ");
|
||||
va_start (ap, template);
|
||||
vprintf (template, ap);
|
||||
va_end (ap);
|
||||
#else
|
||||
if(gShouldPrintErrors)
|
||||
{
|
||||
fprintf (stderr, "libicns: ");
|
||||
va_start (ap, template);
|
||||
vfprintf (stderr, template, ap);
|
||||
va_end (ap);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2012, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2012, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2012, Antonin Descampe
|
||||
* Copyright (c) 2003-2009, Francois-Olivier Devaux
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
@@ -1,25 +0,0 @@
|
||||
|
||||
OPENJPEG LIBRARY and APPLICATIONS
|
||||
----------------------------------
|
||||
|
||||
Details on folders hierarchy:
|
||||
|
||||
* libopenjpeg: contains the sources of the openjpeg library
|
||||
* jpwl: contains the additional sources if you want to build a JPWL-flavoured library.
|
||||
* applications: contains all applications that use the openjpeg library
|
||||
* common: common files to all applications
|
||||
* codec: a basic codec
|
||||
* mj2: motion jpeg 2000 executables
|
||||
* JavaOpenJPEG: java jni to use openjpeg in a java program
|
||||
* jpip: complete client-server architecture for remote browsing of jpeg 2000 images. See corresponding README for more details.
|
||||
* OPJViewer: gui for displaying j2k files (based on wxWidget)
|
||||
* thirdparty: thirdparty libraries used by some applications. These libraries will be built only if there are not found on the system. Note that libopenjpeg itself does not have any dependency.
|
||||
* doc: doxygen documentation setup file and man pages
|
||||
* tests: configuration files and utilities for the openjpeg test suite. All test images are located in 'http://openjpeg.googlecode.com/svn/data' folder.
|
||||
* CMake: cmake related files
|
||||
* m4: autotools related files
|
||||
|
||||
see LICENSE for license and copyright information.
|
||||
see INSTALL for installation procedures.
|
||||
see NEWS for user visible changes in successive releases.
|
||||
see CHANGES for per-revision changes.
|
||||
@@ -1,187 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup BIO BIO - Individual bit input-output stream */
|
||||
/*@{*/
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Write a bit
|
||||
@param bio BIO handle
|
||||
@param b Bit to write (0 or 1)
|
||||
*/
|
||||
static void bio_putbit(opj_bio_t *bio, int b);
|
||||
/**
|
||||
Read a bit
|
||||
@param bio BIO handle
|
||||
@return Returns the read bit
|
||||
*/
|
||||
static int bio_getbit(opj_bio_t *bio);
|
||||
/**
|
||||
Write a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_byteout(opj_bio_t *bio);
|
||||
/**
|
||||
Read a byte
|
||||
@param bio BIO handle
|
||||
@return Returns 0 if successful, returns 1 otherwise
|
||||
*/
|
||||
static int bio_bytein(opj_bio_t *bio);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static int bio_byteout(opj_bio_t *bio) {
|
||||
bio->buf = (bio->buf << 8) & 0xffff;
|
||||
bio->ct = bio->buf == 0xff00 ? 7 : 8;
|
||||
if (bio->bp >= bio->end) {
|
||||
return 1;
|
||||
}
|
||||
*bio->bp++ = bio->buf >> 8;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int bio_bytein(opj_bio_t *bio) {
|
||||
bio->buf = (bio->buf << 8) & 0xffff;
|
||||
bio->ct = bio->buf == 0xff00 ? 7 : 8;
|
||||
if (bio->bp >= bio->end) {
|
||||
return 1;
|
||||
}
|
||||
bio->buf |= *bio->bp++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void bio_putbit(opj_bio_t *bio, int b) {
|
||||
if (bio->ct == 0) {
|
||||
bio_byteout(bio);
|
||||
}
|
||||
bio->ct--;
|
||||
bio->buf |= b << bio->ct;
|
||||
}
|
||||
|
||||
static int bio_getbit(opj_bio_t *bio) {
|
||||
if (bio->ct == 0) {
|
||||
bio_bytein(bio);
|
||||
}
|
||||
bio->ct--;
|
||||
return (bio->buf >> bio->ct) & 1;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Bit Input/Output interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_bio_t* bio_create(void) {
|
||||
opj_bio_t *bio = (opj_bio_t*)opj_malloc(sizeof(opj_bio_t));
|
||||
return bio;
|
||||
}
|
||||
|
||||
void bio_destroy(opj_bio_t *bio) {
|
||||
if(bio) {
|
||||
opj_free(bio);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_numbytes(opj_bio_t *bio) {
|
||||
return (bio->bp - bio->start);
|
||||
}
|
||||
|
||||
void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len) {
|
||||
bio->start = bp;
|
||||
bio->end = bp + len;
|
||||
bio->bp = bp;
|
||||
bio->buf = 0;
|
||||
bio->ct = 8;
|
||||
}
|
||||
|
||||
void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len) {
|
||||
bio->start = bp;
|
||||
bio->end = bp + len;
|
||||
bio->bp = bp;
|
||||
bio->buf = 0;
|
||||
bio->ct = 0;
|
||||
}
|
||||
|
||||
void bio_write(opj_bio_t *bio, int v, int n) {
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
bio_putbit(bio, (v >> i) & 1);
|
||||
}
|
||||
}
|
||||
|
||||
int bio_read(opj_bio_t *bio, int n) {
|
||||
int i, v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += bio_getbit(bio) << i;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
int bio_flush(opj_bio_t *bio) {
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
if (bio->ct == 7) {
|
||||
bio->ct = 0;
|
||||
if (bio_byteout(bio)) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bio_inalign(opj_bio_t *bio) {
|
||||
bio->ct = 0;
|
||||
if ((bio->buf & 0xff) == 0xff) {
|
||||
if (bio_bytein(bio)) {
|
||||
return 1;
|
||||
}
|
||||
bio->ct = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1,125 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __BIO_H
|
||||
#define __BIO_H
|
||||
/**
|
||||
@file bio.h
|
||||
@brief Implementation of an individual bit input-output (BIO)
|
||||
|
||||
The functions in BIO.C have for goal to realize an individual bit input - output.
|
||||
*/
|
||||
|
||||
/** @defgroup BIO BIO - Individual bit input-output stream */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Individual bit input-output stream (BIO)
|
||||
*/
|
||||
typedef struct opj_bio {
|
||||
/** pointer to the start of the buffer */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the buffer */
|
||||
unsigned char *end;
|
||||
/** pointer to the present position in the buffer */
|
||||
unsigned char *bp;
|
||||
/** temporary place where each byte is read or written */
|
||||
unsigned int buf;
|
||||
/** coder : number of bits free to write. decoder : number of bits read */
|
||||
int ct;
|
||||
} opj_bio_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new BIO handle
|
||||
@return Returns a new BIO handle if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_bio_t* bio_create(void);
|
||||
/**
|
||||
Destroy a previously created BIO handle
|
||||
@param bio BIO handle to destroy
|
||||
*/
|
||||
void bio_destroy(opj_bio_t *bio);
|
||||
/**
|
||||
Number of bytes written.
|
||||
@param bio BIO handle
|
||||
@return Returns the number of bytes written
|
||||
*/
|
||||
int bio_numbytes(opj_bio_t *bio);
|
||||
/**
|
||||
Init encoder
|
||||
@param bio BIO handle
|
||||
@param bp Output buffer
|
||||
@param len Output buffer length
|
||||
*/
|
||||
void bio_init_enc(opj_bio_t *bio, unsigned char *bp, int len);
|
||||
/**
|
||||
Init decoder
|
||||
@param bio BIO handle
|
||||
@param bp Input buffer
|
||||
@param len Input buffer length
|
||||
*/
|
||||
void bio_init_dec(opj_bio_t *bio, unsigned char *bp, int len);
|
||||
/**
|
||||
Write bits
|
||||
@param bio BIO handle
|
||||
@param v Value of bits
|
||||
@param n Number of bits to write
|
||||
*/
|
||||
void bio_write(opj_bio_t *bio, int v, int n);
|
||||
/**
|
||||
Read bits
|
||||
@param bio BIO handle
|
||||
@param n Number of bits to read
|
||||
@return Returns the corresponding read number
|
||||
*/
|
||||
int bio_read(opj_bio_t *bio, int n);
|
||||
/**
|
||||
Flush bits
|
||||
@param bio BIO handle
|
||||
@return Returns 1 if successful, returns 0 otherwise
|
||||
*/
|
||||
int bio_flush(opj_bio_t *bio);
|
||||
/**
|
||||
Passes the ending bits (coming from flushing)
|
||||
@param bio BIO handle
|
||||
@return Returns 1 if successful, returns 0 otherwise
|
||||
*/
|
||||
int bio_inalign(opj_bio_t *bio);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __BIO_H */
|
||||
|
||||
@@ -1,211 +0,0 @@
|
||||
/*
|
||||
* $Id: cidx_manager.c 897 2011-08-28 21:43:57Z [email protected] $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
|
||||
/*
|
||||
* Write CPTR Codestream finder box
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] clen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
*/
|
||||
void write_cptr(int coff, int clen, opj_cio_t *cio);
|
||||
|
||||
|
||||
/*
|
||||
* Write main header index table (box)
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] cio file output handle
|
||||
* @return length of mainmhix box
|
||||
*/
|
||||
int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio);
|
||||
|
||||
|
||||
/*
|
||||
* Check if EPH option is used
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] markers marker information
|
||||
* @param[in] marknum number of markers
|
||||
* @param[in] cio file output handle
|
||||
* @return true if EPH is used
|
||||
*/
|
||||
opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio);
|
||||
|
||||
|
||||
int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen)
|
||||
{
|
||||
int len, i, lenp;
|
||||
opj_jp2_box_t *box;
|
||||
int num_box = 0;
|
||||
opj_bool EPHused;
|
||||
(void)image; /* unused ? */
|
||||
|
||||
lenp = -1;
|
||||
box = (opj_jp2_box_t *)opj_calloc( 32, sizeof(opj_jp2_box_t));
|
||||
|
||||
for (i=0;i<2;i++){
|
||||
|
||||
if(i)
|
||||
cio_seek( cio, lenp);
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_CIDX, 4); /* CIDX */
|
||||
write_cptr( offset, cstr_info.codestream_size, cio);
|
||||
|
||||
write_manf( i, num_box, box, cio);
|
||||
|
||||
num_box = 0;
|
||||
box[num_box].length = write_mainmhix( offset, cstr_info, cio);
|
||||
box[num_box].type = JPIP_MHIX;
|
||||
num_box++;
|
||||
|
||||
box[num_box].length = write_tpix( offset, cstr_info, j2klen, cio);
|
||||
box[num_box].type = JPIP_TPIX;
|
||||
num_box++;
|
||||
|
||||
box[num_box].length = write_thix( offset, cstr_info, cio);
|
||||
box[num_box].type = JPIP_THIX;
|
||||
num_box++;
|
||||
|
||||
EPHused = check_EPHuse( offset, cstr_info.marker, cstr_info.marknum, cio);
|
||||
|
||||
box[num_box].length = write_ppix( offset, cstr_info, EPHused, j2klen, cio);
|
||||
box[num_box].type = JPIP_PPIX;
|
||||
num_box++;
|
||||
|
||||
box[num_box].length = write_phix( offset, cstr_info, EPHused, j2klen, cio);
|
||||
box[num_box].type = JPIP_PHIX;
|
||||
num_box++;
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
opj_free( box);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
void write_cptr(int coff, int clen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp;
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_CPTR, 4); /* T */
|
||||
cio_write( cio, 0, 2); /* DR A PRECISER !! */
|
||||
cio_write( cio, 0, 2); /* CONT */
|
||||
cio_write( cio, coff, 8); /* COFF A PRECISER !! */
|
||||
cio_write( cio, clen, 8); /* CLEN */
|
||||
len = cio_tell( cio) - lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp, i;
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_MANF,4); /* T */
|
||||
|
||||
if (second){ /* Write only during the second pass */
|
||||
for( i=0; i<v; i++){
|
||||
cio_write( cio, box[i].length, 4); /* Box length */
|
||||
cio_write( cio, box[i].type, 4); /* Box type */
|
||||
}
|
||||
}
|
||||
|
||||
len = cio_tell( cio) - lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
int write_mainmhix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
|
||||
{
|
||||
int i;
|
||||
int len, lenp;
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_MHIX, 4); /* MHIX */
|
||||
|
||||
cio_write( cio, cstr_info.main_head_end-cstr_info.main_head_start+1, 8); /* TLEN */
|
||||
|
||||
for(i = 1; i < cstr_info.marknum; i++){ /* Marker restricted to 1 apparition, skip SOC marker */
|
||||
cio_write( cio, cstr_info.marker[i].type, 2);
|
||||
cio_write( cio, 0, 2);
|
||||
cio_write( cio, cstr_info.marker[i].pos-coff, 8);
|
||||
cio_write( cio, cstr_info.marker[i].len, 2);
|
||||
}
|
||||
|
||||
len = cio_tell( cio) - lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
opj_bool check_EPHuse( int coff, opj_marker_info_t *markers, int marknum, opj_cio_t *cio)
|
||||
{
|
||||
opj_bool EPHused = OPJ_FALSE;
|
||||
int i=0;
|
||||
int org_pos;
|
||||
unsigned int Scod;
|
||||
|
||||
for(i = 0; i < marknum; i++){
|
||||
if( markers[i].type == J2K_MS_COD){
|
||||
org_pos = cio_tell( cio);
|
||||
cio_seek( cio, coff+markers[i].pos+2);
|
||||
|
||||
Scod = cio_read( cio, 1);
|
||||
if( ((Scod >> 2) & 1))
|
||||
EPHused = OPJ_TRUE;
|
||||
cio_seek( cio, org_pos);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
return EPHused;
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
/*
|
||||
* $Id: cidx_manager.h 897 2011-08-28 21:43:57Z [email protected] $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.h from 2KAN indexer
|
||||
*/
|
||||
|
||||
|
||||
#ifndef CIDX_MANAGER_H_
|
||||
# define CIDX_MANAGER_H_
|
||||
|
||||
#include "openjpeg.h"
|
||||
|
||||
|
||||
/*
|
||||
* Write Codestream index box (superbox)
|
||||
*
|
||||
* @param[in] offset offset of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @param[in] image image data
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @return length of cidx box
|
||||
*/
|
||||
int write_cidx( int offset, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t cstr_info, int j2klen);
|
||||
|
||||
|
||||
#endif /* !CIDX_MANAGER_H_ */
|
||||
@@ -1,191 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length) {
|
||||
opj_cp_t *cp = NULL;
|
||||
opj_cio_t *cio = (opj_cio_t*)opj_malloc(sizeof(opj_cio_t));
|
||||
if(!cio) return NULL;
|
||||
cio->cinfo = cinfo;
|
||||
if(buffer && length) {
|
||||
/* wrap a user buffer containing the encoded image */
|
||||
cio->openmode = OPJ_STREAM_READ;
|
||||
cio->buffer = buffer;
|
||||
cio->length = length;
|
||||
}
|
||||
else if(!buffer && !length && cinfo) {
|
||||
/* allocate a buffer for the encoded image */
|
||||
cio->openmode = OPJ_STREAM_WRITE;
|
||||
switch(cinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
cp = ((opj_j2k_t*)cinfo->j2k_handle)->cp;
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
cp = ((opj_jp2_t*)cinfo->jp2_handle)->j2k->cp;
|
||||
break;
|
||||
default:
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
cio->length = (unsigned int) (0.1625 * cp->img_size + 2000); /* 0.1625 = 1.3/8 and 2000 bytes as a minimum for headers */
|
||||
cio->buffer = (unsigned char *)opj_malloc(cio->length);
|
||||
if(!cio->buffer) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "Error allocating memory for compressed bitstream\n");
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
opj_free(cio);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Initialize byte IO */
|
||||
cio->start = cio->buffer;
|
||||
cio->end = cio->buffer + cio->length;
|
||||
cio->bp = cio->buffer;
|
||||
|
||||
return cio;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio) {
|
||||
if(cio) {
|
||||
if(cio->openmode == OPJ_STREAM_WRITE) {
|
||||
/* destroy the allocated buffer */
|
||||
opj_free(cio->buffer);
|
||||
}
|
||||
/* destroy the cio */
|
||||
opj_free(cio);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Get position in byte stream.
|
||||
*/
|
||||
int OPJ_CALLCONV cio_tell(opj_cio_t *cio) {
|
||||
return cio->bp - cio->start;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set position in byte stream.
|
||||
*
|
||||
* pos : position, in number of bytes, from the beginning of the stream
|
||||
*/
|
||||
void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos) {
|
||||
cio->bp = cio->start + pos;
|
||||
}
|
||||
|
||||
/*
|
||||
* Number of bytes left before the end of the stream.
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio) {
|
||||
return cio->end - cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get pointer to the current position in the stream.
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio) {
|
||||
return cio->bp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write a byte.
|
||||
*/
|
||||
opj_bool cio_byteout(opj_cio_t *cio, unsigned char v) {
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "write error\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
*cio->bp++ = v;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a byte.
|
||||
*/
|
||||
unsigned char cio_bytein(opj_cio_t *cio) {
|
||||
if (cio->bp >= cio->end) {
|
||||
opj_event_msg(cio->cinfo, EVT_ERROR, "read error: passed the end of the codestream (start = %d, current = %d, end = %d\n", cio->start, cio->bp, cio->end);
|
||||
return 0;
|
||||
}
|
||||
return *cio->bp++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write some bytes.
|
||||
*
|
||||
* v : value to write
|
||||
* n : number of bytes to write
|
||||
*/
|
||||
unsigned int cio_write(opj_cio_t *cio, unsigned int64 v, int n) {
|
||||
int i;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
if( !cio_byteout(cio, (unsigned char) ((v >> (i << 3)) & 0xff)) )
|
||||
return 0;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read some bytes.
|
||||
*
|
||||
* n : number of bytes to read
|
||||
*
|
||||
* return : value of the n bytes read
|
||||
*/
|
||||
unsigned int cio_read(opj_cio_t *cio, int n) {
|
||||
int i;
|
||||
unsigned int v;
|
||||
v = 0;
|
||||
for (i = n - 1; i >= 0; i--) {
|
||||
v += cio_bytein(cio) << (i << 3);
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
/*
|
||||
* Skip some bytes.
|
||||
*
|
||||
* n : number of bytes to skip
|
||||
*/
|
||||
void cio_skip(opj_cio_t *cio, int n) {
|
||||
cio->bp += n;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1,93 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __CIO_H
|
||||
#define __CIO_H
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#define int64 __int64
|
||||
#else
|
||||
#define int64 long long
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file cio.h
|
||||
@brief Implementation of a byte input-output process (CIO)
|
||||
|
||||
The functions in CIO.C have for goal to realize a byte input / output process.
|
||||
*/
|
||||
|
||||
/** @defgroup CIO CIO - byte input-output stream */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions (see also openjpeg.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Number of bytes left before the end of the stream
|
||||
@param cio CIO handle
|
||||
@return Returns the number of bytes before the end of the stream
|
||||
*/
|
||||
int cio_numbytesleft(opj_cio_t *cio);
|
||||
/**
|
||||
Get pointer to the current position in the stream
|
||||
@param cio CIO handle
|
||||
@return Returns a pointer to the current position
|
||||
*/
|
||||
unsigned char *cio_getbp(opj_cio_t *cio);
|
||||
/**
|
||||
Write some bytes
|
||||
@param cio CIO handle
|
||||
@param v Value to write
|
||||
@param n Number of bytes to write
|
||||
@return Returns the number of bytes written or 0 if an error occured
|
||||
*/
|
||||
unsigned int cio_write(opj_cio_t *cio, unsigned int64 v, int n);
|
||||
/**
|
||||
Read some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to read
|
||||
@return Returns the value of the n bytes read
|
||||
*/
|
||||
unsigned int cio_read(opj_cio_t *cio, int n);
|
||||
/**
|
||||
Skip some bytes
|
||||
@param cio CIO handle
|
||||
@param n Number of bytes to skip
|
||||
*/
|
||||
void cio_skip(opj_cio_t *cio, int n);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __CIO_H */
|
||||
|
||||
@@ -1,858 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2007, Jonathan Ballard <[email protected]>
|
||||
* Copyright (c) 2007, Callum Lerwick <[email protected]>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef __SSE__
|
||||
#include <xmmintrin.h>
|
||||
#endif
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
|
||||
/*@{*/
|
||||
|
||||
#define WS(i) v->mem[(i)*2]
|
||||
#define WD(i) v->mem[(1+(i)*2)]
|
||||
|
||||
/** @name Local data structures */
|
||||
/*@{*/
|
||||
|
||||
typedef struct dwt_local {
|
||||
int* mem;
|
||||
int dn;
|
||||
int sn;
|
||||
int cas;
|
||||
} dwt_t;
|
||||
|
||||
typedef union {
|
||||
float f[4];
|
||||
} v4;
|
||||
|
||||
typedef struct v4dwt_local {
|
||||
v4* wavelet ;
|
||||
int dn ;
|
||||
int sn ;
|
||||
int cas ;
|
||||
} v4dwt_t ;
|
||||
|
||||
static const float dwt_alpha = 1.586134342f; /* 12994 */
|
||||
static const float dwt_beta = 0.052980118f; /* 434 */
|
||||
static const float dwt_gamma = -0.882911075f; /* -7233 */
|
||||
static const float dwt_delta = -0.443506852f; /* -3633 */
|
||||
|
||||
static const float K = 1.230174105f; /* 10078 */
|
||||
/* FIXME: What is this constant? */
|
||||
static const float c13318 = 1.625732422f;
|
||||
|
||||
/*@}*/
|
||||
|
||||
/**
|
||||
Virtual function type for wavelet transform in 1-D
|
||||
*/
|
||||
typedef void (*DWT1DFN)(dwt_t* v);
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Forward lazy transform (horizontal)
|
||||
*/
|
||||
static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas);
|
||||
/**
|
||||
Forward lazy transform (vertical)
|
||||
*/
|
||||
static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas);
|
||||
/**
|
||||
Inverse lazy transform (horizontal)
|
||||
*/
|
||||
static void dwt_interleave_h(dwt_t* h, int *a);
|
||||
/**
|
||||
Inverse lazy transform (vertical)
|
||||
*/
|
||||
static void dwt_interleave_v(dwt_t* v, int *a, int x);
|
||||
/**
|
||||
Forward 5-3 wavelet transform in 1-D
|
||||
*/
|
||||
static void dwt_encode_1(int *a, int dn, int sn, int cas);
|
||||
/**
|
||||
Inverse 5-3 wavelet transform in 1-D
|
||||
*/
|
||||
static void dwt_decode_1(dwt_t *v);
|
||||
/**
|
||||
Forward 9-7 wavelet transform in 1-D
|
||||
*/
|
||||
static void dwt_encode_1_real(int *a, int dn, int sn, int cas);
|
||||
/**
|
||||
Explicit calculation of the Quantization Stepsizes
|
||||
*/
|
||||
static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize);
|
||||
/**
|
||||
Inverse wavelet transform in 2-D.
|
||||
*/
|
||||
static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int i, DWT1DFN fn);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#define S(i) a[(i)*2]
|
||||
#define D(i) a[(1+(i)*2)]
|
||||
#define S_(i) ((i)<0?S(0):((i)>=sn?S(sn-1):S(i)))
|
||||
#define D_(i) ((i)<0?D(0):((i)>=dn?D(dn-1):D(i)))
|
||||
/* new */
|
||||
#define SS_(i) ((i)<0?S(0):((i)>=dn?S(dn-1):S(i)))
|
||||
#define DD_(i) ((i)<0?D(0):((i)>=sn?D(sn-1):D(i)))
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the 5-3 wavelets for different bands. */
|
||||
/* </summary> */
|
||||
static const double dwt_norms[4][10] = {
|
||||
{1.000, 1.500, 2.750, 5.375, 10.68, 21.34, 42.67, 85.33, 170.7, 341.3},
|
||||
{1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
|
||||
{1.038, 1.592, 2.919, 5.703, 11.33, 22.64, 45.25, 90.48, 180.9},
|
||||
{.7186, .9218, 1.586, 3.043, 6.019, 12.01, 24.00, 47.97, 95.93}
|
||||
};
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the 9-7 wavelets for different bands. */
|
||||
/* </summary> */
|
||||
static const double dwt_norms_real[4][10] = {
|
||||
{1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9},
|
||||
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
|
||||
{2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0},
|
||||
{2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2}
|
||||
};
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/* <summary> */
|
||||
/* Forward lazy transform (horizontal). */
|
||||
/* </summary> */
|
||||
static void dwt_deinterleave_h(int *a, int *b, int dn, int sn, int cas) {
|
||||
int i;
|
||||
for (i=0; i<sn; i++) b[i]=a[2*i+cas];
|
||||
for (i=0; i<dn; i++) b[sn+i]=a[(2*i+1-cas)];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward lazy transform (vertical). */
|
||||
/* </summary> */
|
||||
static void dwt_deinterleave_v(int *a, int *b, int dn, int sn, int x, int cas) {
|
||||
int i;
|
||||
for (i=0; i<sn; i++) b[i*x]=a[2*i+cas];
|
||||
for (i=0; i<dn; i++) b[(sn+i)*x]=a[(2*i+1-cas)];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse lazy transform (horizontal). */
|
||||
/* </summary> */
|
||||
static void dwt_interleave_h(dwt_t* h, int *a) {
|
||||
int *ai = a;
|
||||
int *bi = h->mem + h->cas;
|
||||
int i = h->sn;
|
||||
while( i-- ) {
|
||||
*bi = *(ai++);
|
||||
bi += 2;
|
||||
}
|
||||
ai = a + h->sn;
|
||||
bi = h->mem + 1 - h->cas;
|
||||
i = h->dn ;
|
||||
while( i-- ) {
|
||||
*bi = *(ai++);
|
||||
bi += 2;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse lazy transform (vertical). */
|
||||
/* </summary> */
|
||||
static void dwt_interleave_v(dwt_t* v, int *a, int x) {
|
||||
int *ai = a;
|
||||
int *bi = v->mem + v->cas;
|
||||
int i = v->sn;
|
||||
while( i-- ) {
|
||||
*bi = *ai;
|
||||
bi += 2;
|
||||
ai += x;
|
||||
}
|
||||
ai = a + (v->sn * x);
|
||||
bi = v->mem + 1 - v->cas;
|
||||
i = v->dn ;
|
||||
while( i-- ) {
|
||||
*bi = *ai;
|
||||
bi += 2;
|
||||
ai += x;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Forward 5-3 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void dwt_encode_1(int *a, int dn, int sn, int cas) {
|
||||
int i;
|
||||
|
||||
if (!cas) {
|
||||
if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
|
||||
for (i = 0; i < dn; i++) D(i) -= (S_(i) + S_(i + 1)) >> 1;
|
||||
for (i = 0; i < sn; i++) S(i) += (D_(i - 1) + D_(i) + 2) >> 2;
|
||||
}
|
||||
} else {
|
||||
if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
|
||||
S(0) *= 2;
|
||||
else {
|
||||
for (i = 0; i < dn; i++) S(i) -= (DD_(i) + DD_(i - 1)) >> 1;
|
||||
for (i = 0; i < sn; i++) D(i) += (SS_(i) + SS_(i + 1) + 2) >> 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 5-3 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void dwt_decode_1_(int *a, int dn, int sn, int cas) {
|
||||
int i;
|
||||
|
||||
if (!cas) {
|
||||
if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
|
||||
for (i = 0; i < sn; i++) S(i) -= (D_(i - 1) + D_(i) + 2) >> 2;
|
||||
for (i = 0; i < dn; i++) D(i) += (S_(i) + S_(i + 1)) >> 1;
|
||||
}
|
||||
} else {
|
||||
if (!sn && dn == 1) /* NEW : CASE ONE ELEMENT */
|
||||
S(0) /= 2;
|
||||
else {
|
||||
for (i = 0; i < sn; i++) D(i) -= (SS_(i) + SS_(i + 1) + 2) >> 2;
|
||||
for (i = 0; i < dn; i++) S(i) += (DD_(i) + DD_(i - 1)) >> 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 5-3 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void dwt_decode_1(dwt_t *v) {
|
||||
dwt_decode_1_(v->mem, v->dn, v->sn, v->cas);
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward 9-7 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void dwt_encode_1_real(int *a, int dn, int sn, int cas) {
|
||||
int i;
|
||||
if (!cas) {
|
||||
if ((dn > 0) || (sn > 1)) { /* NEW : CASE ONE ELEMENT */
|
||||
for (i = 0; i < dn; i++)
|
||||
D(i) -= fix_mul(S_(i) + S_(i + 1), 12993);
|
||||
for (i = 0; i < sn; i++)
|
||||
S(i) -= fix_mul(D_(i - 1) + D_(i), 434);
|
||||
for (i = 0; i < dn; i++)
|
||||
D(i) += fix_mul(S_(i) + S_(i + 1), 7233);
|
||||
for (i = 0; i < sn; i++)
|
||||
S(i) += fix_mul(D_(i - 1) + D_(i), 3633);
|
||||
for (i = 0; i < dn; i++)
|
||||
D(i) = fix_mul(D(i), 5038); /*5038 */
|
||||
for (i = 0; i < sn; i++)
|
||||
S(i) = fix_mul(S(i), 6659); /*6660 */
|
||||
}
|
||||
} else {
|
||||
if ((sn > 0) || (dn > 1)) { /* NEW : CASE ONE ELEMENT */
|
||||
for (i = 0; i < dn; i++)
|
||||
S(i) -= fix_mul(DD_(i) + DD_(i - 1), 12993);
|
||||
for (i = 0; i < sn; i++)
|
||||
D(i) -= fix_mul(SS_(i) + SS_(i + 1), 434);
|
||||
for (i = 0; i < dn; i++)
|
||||
S(i) += fix_mul(DD_(i) + DD_(i - 1), 7233);
|
||||
for (i = 0; i < sn; i++)
|
||||
D(i) += fix_mul(SS_(i) + SS_(i + 1), 3633);
|
||||
for (i = 0; i < dn; i++)
|
||||
S(i) = fix_mul(S(i), 5038); /*5038 */
|
||||
for (i = 0; i < sn; i++)
|
||||
D(i) = fix_mul(D(i), 6659); /*6660 */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void dwt_encode_stepsize(int stepsize, int numbps, opj_stepsize_t *bandno_stepsize) {
|
||||
int p, n;
|
||||
p = int_floorlog2(stepsize) - 13;
|
||||
n = 11 - int_floorlog2(stepsize);
|
||||
bandno_stepsize->mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff;
|
||||
bandno_stepsize->expn = numbps - p;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
DWT interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/* <summary> */
|
||||
/* Forward 5-3 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
void dwt_encode(opj_tcd_tilecomp_t * tilec) {
|
||||
int i, j, k;
|
||||
int *a = NULL;
|
||||
int *aj = NULL;
|
||||
int *bj = NULL;
|
||||
int w, l;
|
||||
|
||||
w = tilec->x1-tilec->x0;
|
||||
l = tilec->numresolutions-1;
|
||||
a = tilec->data;
|
||||
|
||||
for (i = 0; i < l; i++) {
|
||||
int rw; /* width of the resolution level computed */
|
||||
int rh; /* height of the resolution level computed */
|
||||
int rw1; /* width of the resolution level once lower than computed one */
|
||||
int rh1; /* height of the resolution level once lower than computed one */
|
||||
int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int dn, sn;
|
||||
|
||||
rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
|
||||
rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
|
||||
rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
|
||||
rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
|
||||
|
||||
cas_row = tilec->resolutions[l - i].x0 % 2;
|
||||
cas_col = tilec->resolutions[l - i].y0 % 2;
|
||||
|
||||
sn = rh1;
|
||||
dn = rh - rh1;
|
||||
bj = (int*)opj_malloc(rh * sizeof(int));
|
||||
for (j = 0; j < rw; j++) {
|
||||
aj = a + j;
|
||||
for (k = 0; k < rh; k++) bj[k] = aj[k*w];
|
||||
dwt_encode_1(bj, dn, sn, cas_col);
|
||||
dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
|
||||
}
|
||||
opj_free(bj);
|
||||
|
||||
sn = rw1;
|
||||
dn = rw - rw1;
|
||||
bj = (int*)opj_malloc(rw * sizeof(int));
|
||||
for (j = 0; j < rh; j++) {
|
||||
aj = a + j * w;
|
||||
for (k = 0; k < rw; k++) bj[k] = aj[k];
|
||||
dwt_encode_1(bj, dn, sn, cas_row);
|
||||
dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
|
||||
}
|
||||
opj_free(bj);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 5-3 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
void dwt_decode(opj_tcd_tilecomp_t* tilec, int numres) {
|
||||
dwt_decode_tile(tilec, numres, &dwt_decode_1);
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Get gain of 5-3 wavelet transform. */
|
||||
/* </summary> */
|
||||
int dwt_getgain(int orient) {
|
||||
if (orient == 0)
|
||||
return 0;
|
||||
if (orient == 1 || orient == 2)
|
||||
return 1;
|
||||
return 2;
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of 5-3 wavelet. */
|
||||
/* </summary> */
|
||||
double dwt_getnorm(int level, int orient) {
|
||||
return dwt_norms[orient][level];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Forward 9-7 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
|
||||
void dwt_encode_real(opj_tcd_tilecomp_t * tilec) {
|
||||
int i, j, k;
|
||||
int *a = NULL;
|
||||
int *aj = NULL;
|
||||
int *bj = NULL;
|
||||
int w, l;
|
||||
|
||||
w = tilec->x1-tilec->x0;
|
||||
l = tilec->numresolutions-1;
|
||||
a = tilec->data;
|
||||
|
||||
for (i = 0; i < l; i++) {
|
||||
int rw; /* width of the resolution level computed */
|
||||
int rh; /* height of the resolution level computed */
|
||||
int rw1; /* width of the resolution level once lower than computed one */
|
||||
int rh1; /* height of the resolution level once lower than computed one */
|
||||
int cas_col; /* 0 = non inversion on horizontal filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int cas_row; /* 0 = non inversion on vertical filtering 1 = inversion between low-pass and high-pass filtering */
|
||||
int dn, sn;
|
||||
|
||||
rw = tilec->resolutions[l - i].x1 - tilec->resolutions[l - i].x0;
|
||||
rh = tilec->resolutions[l - i].y1 - tilec->resolutions[l - i].y0;
|
||||
rw1= tilec->resolutions[l - i - 1].x1 - tilec->resolutions[l - i - 1].x0;
|
||||
rh1= tilec->resolutions[l - i - 1].y1 - tilec->resolutions[l - i - 1].y0;
|
||||
|
||||
cas_row = tilec->resolutions[l - i].x0 % 2;
|
||||
cas_col = tilec->resolutions[l - i].y0 % 2;
|
||||
|
||||
sn = rh1;
|
||||
dn = rh - rh1;
|
||||
bj = (int*)opj_malloc(rh * sizeof(int));
|
||||
for (j = 0; j < rw; j++) {
|
||||
aj = a + j;
|
||||
for (k = 0; k < rh; k++) bj[k] = aj[k*w];
|
||||
dwt_encode_1_real(bj, dn, sn, cas_col);
|
||||
dwt_deinterleave_v(bj, aj, dn, sn, w, cas_col);
|
||||
}
|
||||
opj_free(bj);
|
||||
|
||||
sn = rw1;
|
||||
dn = rw - rw1;
|
||||
bj = (int*)opj_malloc(rw * sizeof(int));
|
||||
for (j = 0; j < rh; j++) {
|
||||
aj = a + j * w;
|
||||
for (k = 0; k < rw; k++) bj[k] = aj[k];
|
||||
dwt_encode_1_real(bj, dn, sn, cas_row);
|
||||
dwt_deinterleave_h(bj, aj, dn, sn, cas_row);
|
||||
}
|
||||
opj_free(bj);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Get gain of 9-7 wavelet transform. */
|
||||
/* </summary> */
|
||||
int dwt_getgain_real(int orient) {
|
||||
(void)orient;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of 9-7 wavelet. */
|
||||
/* </summary> */
|
||||
double dwt_getnorm_real(int level, int orient) {
|
||||
return dwt_norms_real[orient][level];
|
||||
}
|
||||
|
||||
void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec) {
|
||||
int numbands, bandno;
|
||||
numbands = 3 * tccp->numresolutions - 2;
|
||||
for (bandno = 0; bandno < numbands; bandno++) {
|
||||
double stepsize;
|
||||
int resno, level, orient, gain;
|
||||
|
||||
resno = (bandno == 0) ? 0 : ((bandno - 1) / 3 + 1);
|
||||
orient = (bandno == 0) ? 0 : ((bandno - 1) % 3 + 1);
|
||||
level = tccp->numresolutions - 1 - resno;
|
||||
gain = (tccp->qmfbid == 0) ? 0 : ((orient == 0) ? 0 : (((orient == 1) || (orient == 2)) ? 1 : 2));
|
||||
if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) {
|
||||
stepsize = 1.0;
|
||||
} else {
|
||||
double norm = dwt_norms_real[orient][level];
|
||||
stepsize = (1 << (gain)) / norm;
|
||||
}
|
||||
dwt_encode_stepsize((int) floor(stepsize * 8192.0), prec + gain, &tccp->stepsizes[bandno]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Determine maximum computed resolution level for inverse wavelet transform */
|
||||
/* </summary> */
|
||||
static int dwt_decode_max_resolution(opj_tcd_resolution_t* restrict r, int i) {
|
||||
int mr = 1;
|
||||
int w;
|
||||
while( --i ) {
|
||||
r++;
|
||||
if( mr < ( w = r->x1 - r->x0 ) )
|
||||
mr = w ;
|
||||
if( mr < ( w = r->y1 - r->y0 ) )
|
||||
mr = w ;
|
||||
}
|
||||
return mr ;
|
||||
}
|
||||
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
static void dwt_decode_tile(opj_tcd_tilecomp_t* tilec, int numres, DWT1DFN dwt_1D) {
|
||||
dwt_t h;
|
||||
dwt_t v;
|
||||
|
||||
opj_tcd_resolution_t* tr = tilec->resolutions;
|
||||
|
||||
int rw = tr->x1 - tr->x0; /* width of the resolution level computed */
|
||||
int rh = tr->y1 - tr->y0; /* height of the resolution level computed */
|
||||
|
||||
int w = tilec->x1 - tilec->x0;
|
||||
|
||||
h.mem = (int*)opj_aligned_malloc(dwt_decode_max_resolution(tr, numres) * sizeof(int));
|
||||
v.mem = h.mem;
|
||||
|
||||
while( --numres) {
|
||||
int * restrict tiledp = tilec->data;
|
||||
int j;
|
||||
|
||||
++tr;
|
||||
h.sn = rw;
|
||||
v.sn = rh;
|
||||
|
||||
rw = tr->x1 - tr->x0;
|
||||
rh = tr->y1 - tr->y0;
|
||||
|
||||
h.dn = rw - h.sn;
|
||||
h.cas = tr->x0 % 2;
|
||||
|
||||
for(j = 0; j < rh; ++j) {
|
||||
dwt_interleave_h(&h, &tiledp[j*w]);
|
||||
(dwt_1D)(&h);
|
||||
memcpy(&tiledp[j*w], h.mem, rw * sizeof(int));
|
||||
}
|
||||
|
||||
v.dn = rh - v.sn;
|
||||
v.cas = tr->y0 % 2;
|
||||
|
||||
for(j = 0; j < rw; ++j){
|
||||
int k;
|
||||
dwt_interleave_v(&v, &tiledp[j], w);
|
||||
(dwt_1D)(&v);
|
||||
for(k = 0; k < rh; ++k) {
|
||||
tiledp[k * w + j] = v.mem[k];
|
||||
}
|
||||
}
|
||||
}
|
||||
opj_aligned_free(h.mem);
|
||||
}
|
||||
|
||||
static void v4dwt_interleave_h(v4dwt_t* restrict w, float* restrict a, int x, int size){
|
||||
float* restrict bi = (float*) (w->wavelet + w->cas);
|
||||
int count = w->sn;
|
||||
int i, k;
|
||||
for(k = 0; k < 2; ++k){
|
||||
if (count + 3 * x < size && ((size_t) a & 0x0f) == 0 && ((size_t) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
|
||||
/* Fast code path */
|
||||
for(i = 0; i < count; ++i){
|
||||
int j = i;
|
||||
bi[i*8 ] = a[j];
|
||||
j += x;
|
||||
bi[i*8 + 1] = a[j];
|
||||
j += x;
|
||||
bi[i*8 + 2] = a[j];
|
||||
j += x;
|
||||
bi[i*8 + 3] = a[j];
|
||||
}
|
||||
} else {
|
||||
/* Slow code path */
|
||||
for(i = 0; i < count; ++i){
|
||||
int j = i;
|
||||
bi[i*8 ] = a[j];
|
||||
j += x;
|
||||
if(j > size) continue;
|
||||
bi[i*8 + 1] = a[j];
|
||||
j += x;
|
||||
if(j > size) continue;
|
||||
bi[i*8 + 2] = a[j];
|
||||
j += x;
|
||||
if(j > size) continue;
|
||||
bi[i*8 + 3] = a[j];
|
||||
}
|
||||
}
|
||||
bi = (float*) (w->wavelet + 1 - w->cas);
|
||||
a += w->sn;
|
||||
size -= w->sn;
|
||||
count = w->dn;
|
||||
}
|
||||
}
|
||||
|
||||
static void v4dwt_interleave_v(v4dwt_t* restrict v , float* restrict a , int x){
|
||||
v4* restrict bi = v->wavelet + v->cas;
|
||||
int i;
|
||||
for(i = 0; i < v->sn; ++i){
|
||||
memcpy(&bi[i*2], &a[i*x], 4 * sizeof(float));
|
||||
}
|
||||
a += v->sn * x;
|
||||
bi = v->wavelet + 1 - v->cas;
|
||||
for(i = 0; i < v->dn; ++i){
|
||||
memcpy(&bi[i*2], &a[i*x], 4 * sizeof(float));
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __SSE__
|
||||
|
||||
static void v4dwt_decode_step1_sse(v4* w, int count, const __m128 c){
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
int i;
|
||||
/* 4x unrolled loop */
|
||||
for(i = 0; i < count >> 2; ++i){
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
}
|
||||
count &= 3;
|
||||
for(i = 0; i < count; ++i){
|
||||
*vw = _mm_mul_ps(*vw, c);
|
||||
vw += 2;
|
||||
}
|
||||
}
|
||||
|
||||
static void v4dwt_decode_step2_sse(v4* l, v4* w, int k, int m, __m128 c){
|
||||
__m128* restrict vl = (__m128*) l;
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
int i;
|
||||
__m128 tmp1, tmp2, tmp3;
|
||||
tmp1 = vl[0];
|
||||
for(i = 0; i < m; ++i){
|
||||
tmp2 = vw[-1];
|
||||
tmp3 = vw[ 0];
|
||||
vw[-1] = _mm_add_ps(tmp2, _mm_mul_ps(_mm_add_ps(tmp1, tmp3), c));
|
||||
tmp1 = tmp3;
|
||||
vw += 2;
|
||||
}
|
||||
vl = vw - 2;
|
||||
if(m >= k){
|
||||
return;
|
||||
}
|
||||
c = _mm_add_ps(c, c);
|
||||
c = _mm_mul_ps(c, vl[0]);
|
||||
for(; m < k; ++m){
|
||||
__m128 tmp = vw[-1];
|
||||
vw[-1] = _mm_add_ps(tmp, c);
|
||||
vw += 2;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void v4dwt_decode_step1(v4* w, int count, const float c){
|
||||
float* restrict fw = (float*) w;
|
||||
int i;
|
||||
for(i = 0; i < count; ++i){
|
||||
float tmp1 = fw[i*8 ];
|
||||
float tmp2 = fw[i*8 + 1];
|
||||
float tmp3 = fw[i*8 + 2];
|
||||
float tmp4 = fw[i*8 + 3];
|
||||
fw[i*8 ] = tmp1 * c;
|
||||
fw[i*8 + 1] = tmp2 * c;
|
||||
fw[i*8 + 2] = tmp3 * c;
|
||||
fw[i*8 + 3] = tmp4 * c;
|
||||
}
|
||||
}
|
||||
|
||||
static void v4dwt_decode_step2(v4* l, v4* w, int k, int m, float c){
|
||||
float* restrict fl = (float*) l;
|
||||
float* restrict fw = (float*) w;
|
||||
int i;
|
||||
for(i = 0; i < m; ++i){
|
||||
float tmp1_1 = fl[0];
|
||||
float tmp1_2 = fl[1];
|
||||
float tmp1_3 = fl[2];
|
||||
float tmp1_4 = fl[3];
|
||||
float tmp2_1 = fw[-4];
|
||||
float tmp2_2 = fw[-3];
|
||||
float tmp2_3 = fw[-2];
|
||||
float tmp2_4 = fw[-1];
|
||||
float tmp3_1 = fw[0];
|
||||
float tmp3_2 = fw[1];
|
||||
float tmp3_3 = fw[2];
|
||||
float tmp3_4 = fw[3];
|
||||
fw[-4] = tmp2_1 + ((tmp1_1 + tmp3_1) * c);
|
||||
fw[-3] = tmp2_2 + ((tmp1_2 + tmp3_2) * c);
|
||||
fw[-2] = tmp2_3 + ((tmp1_3 + tmp3_3) * c);
|
||||
fw[-1] = tmp2_4 + ((tmp1_4 + tmp3_4) * c);
|
||||
fl = fw;
|
||||
fw += 8;
|
||||
}
|
||||
if(m < k){
|
||||
float c1;
|
||||
float c2;
|
||||
float c3;
|
||||
float c4;
|
||||
c += c;
|
||||
c1 = fl[0] * c;
|
||||
c2 = fl[1] * c;
|
||||
c3 = fl[2] * c;
|
||||
c4 = fl[3] * c;
|
||||
for(; m < k; ++m){
|
||||
float tmp1 = fw[-4];
|
||||
float tmp2 = fw[-3];
|
||||
float tmp3 = fw[-2];
|
||||
float tmp4 = fw[-1];
|
||||
fw[-4] = tmp1 + c1;
|
||||
fw[-3] = tmp2 + c2;
|
||||
fw[-2] = tmp3 + c3;
|
||||
fw[-1] = tmp4 + c4;
|
||||
fw += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 9-7 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void v4dwt_decode(v4dwt_t* restrict dwt){
|
||||
int a, b;
|
||||
if(dwt->cas == 0) {
|
||||
if(!((dwt->dn > 0) || (dwt->sn > 1))){
|
||||
return;
|
||||
}
|
||||
a = 0;
|
||||
b = 1;
|
||||
}else{
|
||||
if(!((dwt->sn > 0) || (dwt->dn > 1))) {
|
||||
return;
|
||||
}
|
||||
a = 1;
|
||||
b = 0;
|
||||
}
|
||||
#ifdef __SSE__
|
||||
v4dwt_decode_step1_sse(dwt->wavelet+a, dwt->sn, _mm_set1_ps(K));
|
||||
v4dwt_decode_step1_sse(dwt->wavelet+b, dwt->dn, _mm_set1_ps(c13318));
|
||||
v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_delta));
|
||||
v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_gamma));
|
||||
v4dwt_decode_step2_sse(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), _mm_set1_ps(dwt_beta));
|
||||
v4dwt_decode_step2_sse(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), _mm_set1_ps(dwt_alpha));
|
||||
#else
|
||||
v4dwt_decode_step1(dwt->wavelet+a, dwt->sn, K);
|
||||
v4dwt_decode_step1(dwt->wavelet+b, dwt->dn, c13318);
|
||||
v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_delta);
|
||||
v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_gamma);
|
||||
v4dwt_decode_step2(dwt->wavelet+b, dwt->wavelet+a+1, dwt->sn, int_min(dwt->sn, dwt->dn-a), dwt_beta);
|
||||
v4dwt_decode_step2(dwt->wavelet+a, dwt->wavelet+b+1, dwt->dn, int_min(dwt->dn, dwt->sn-b), dwt_alpha);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 9-7 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
void dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, int numres){
|
||||
v4dwt_t h;
|
||||
v4dwt_t v;
|
||||
|
||||
opj_tcd_resolution_t* res = tilec->resolutions;
|
||||
|
||||
int rw = res->x1 - res->x0; /* width of the resolution level computed */
|
||||
int rh = res->y1 - res->y0; /* height of the resolution level computed */
|
||||
|
||||
int w = tilec->x1 - tilec->x0;
|
||||
|
||||
h.wavelet = (v4*) opj_aligned_malloc((dwt_decode_max_resolution(res, numres)+5) * sizeof(v4));
|
||||
v.wavelet = h.wavelet;
|
||||
|
||||
while( --numres) {
|
||||
float * restrict aj = (float*) tilec->data;
|
||||
int bufsize = (tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0);
|
||||
int j;
|
||||
|
||||
h.sn = rw;
|
||||
v.sn = rh;
|
||||
|
||||
++res;
|
||||
|
||||
rw = res->x1 - res->x0; /* width of the resolution level computed */
|
||||
rh = res->y1 - res->y0; /* height of the resolution level computed */
|
||||
|
||||
h.dn = rw - h.sn;
|
||||
h.cas = res->x0 % 2;
|
||||
|
||||
for(j = rh; j > 3; j -= 4){
|
||||
int k;
|
||||
v4dwt_interleave_h(&h, aj, w, bufsize);
|
||||
v4dwt_decode(&h);
|
||||
for(k = rw; --k >= 0;){
|
||||
aj[k ] = h.wavelet[k].f[0];
|
||||
aj[k+w ] = h.wavelet[k].f[1];
|
||||
aj[k+w*2] = h.wavelet[k].f[2];
|
||||
aj[k+w*3] = h.wavelet[k].f[3];
|
||||
}
|
||||
aj += w*4;
|
||||
bufsize -= w*4;
|
||||
}
|
||||
if (rh & 0x03) {
|
||||
int k;
|
||||
j = rh & 0x03;
|
||||
v4dwt_interleave_h(&h, aj, w, bufsize);
|
||||
v4dwt_decode(&h);
|
||||
for(k = rw; --k >= 0;){
|
||||
switch(j) {
|
||||
case 3: aj[k+w*2] = h.wavelet[k].f[2];
|
||||
case 2: aj[k+w ] = h.wavelet[k].f[1];
|
||||
case 1: aj[k ] = h.wavelet[k].f[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
v.dn = rh - v.sn;
|
||||
v.cas = res->y0 % 2;
|
||||
|
||||
aj = (float*) tilec->data;
|
||||
for(j = rw; j > 3; j -= 4){
|
||||
int k;
|
||||
v4dwt_interleave_v(&v, aj, w);
|
||||
v4dwt_decode(&v);
|
||||
for(k = 0; k < rh; ++k){
|
||||
memcpy(&aj[k*w], &v.wavelet[k], 4 * sizeof(float));
|
||||
}
|
||||
aj += 4;
|
||||
}
|
||||
if (rw & 0x03){
|
||||
int k;
|
||||
j = rw & 0x03;
|
||||
v4dwt_interleave_v(&v, aj, w);
|
||||
v4dwt_decode(&v);
|
||||
for(k = 0; k < rh; ++k){
|
||||
memcpy(&aj[k*w], &v.wavelet[k], j * sizeof(float));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
opj_aligned_free(h.wavelet);
|
||||
}
|
||||
|
||||
@@ -1,113 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __DWT_H
|
||||
#define __DWT_H
|
||||
/**
|
||||
@file dwt.h
|
||||
@brief Implementation of a discrete wavelet transform (DWT)
|
||||
|
||||
The functions in DWT.C have for goal to realize forward and inverse discret wavelet
|
||||
transform with filter 5-3 (reversible) and filter 9-7 (irreversible). The functions in
|
||||
DWT.C are used by some function in TCD.C.
|
||||
*/
|
||||
|
||||
/** @defgroup DWT DWT - Implementation of a discrete wavelet transform */
|
||||
/*@{*/
|
||||
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Forward 5-3 wavelet tranform in 2-D.
|
||||
Apply a reversible DWT transform to a component of an image.
|
||||
@param tilec Tile component information (current tile)
|
||||
*/
|
||||
void dwt_encode(opj_tcd_tilecomp_t * tilec);
|
||||
/**
|
||||
Inverse 5-3 wavelet tranform in 2-D.
|
||||
Apply a reversible inverse DWT transform to a component of an image.
|
||||
@param tilec Tile component information (current tile)
|
||||
@param numres Number of resolution levels to decode
|
||||
*/
|
||||
void dwt_decode(opj_tcd_tilecomp_t* tilec, int numres);
|
||||
/**
|
||||
Get the gain of a subband for the reversible 5-3 DWT.
|
||||
@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
|
||||
@return Returns 0 if orient = 0, returns 1 if orient = 1 or 2, returns 2 otherwise
|
||||
*/
|
||||
int dwt_getgain(int orient);
|
||||
/**
|
||||
Get the norm of a wavelet function of a subband at a specified level for the reversible 5-3 DWT.
|
||||
@param level Level of the wavelet function
|
||||
@param orient Band of the wavelet function
|
||||
@return Returns the norm of the wavelet function
|
||||
*/
|
||||
double dwt_getnorm(int level, int orient);
|
||||
/**
|
||||
Forward 9-7 wavelet transform in 2-D.
|
||||
Apply an irreversible DWT transform to a component of an image.
|
||||
@param tilec Tile component information (current tile)
|
||||
*/
|
||||
void dwt_encode_real(opj_tcd_tilecomp_t * tilec);
|
||||
/**
|
||||
Inverse 9-7 wavelet transform in 2-D.
|
||||
Apply an irreversible inverse DWT transform to a component of an image.
|
||||
@param tilec Tile component information (current tile)
|
||||
@param numres Number of resolution levels to decode
|
||||
*/
|
||||
void dwt_decode_real(opj_tcd_tilecomp_t* tilec, int numres);
|
||||
/**
|
||||
Get the gain of a subband for the irreversible 9-7 DWT.
|
||||
@param orient Number that identifies the subband (0->LL, 1->HL, 2->LH, 3->HH)
|
||||
@return Returns the gain of the 9-7 wavelet transform
|
||||
*/
|
||||
int dwt_getgain_real(int orient);
|
||||
/**
|
||||
Get the norm of a wavelet function of a subband at a specified level for the irreversible 9-7 DWT
|
||||
@param level Level of the wavelet function
|
||||
@param orient Band of the wavelet function
|
||||
@return Returns the norm of the 9-7 wavelet
|
||||
*/
|
||||
double dwt_getnorm_real(int level, int orient);
|
||||
/**
|
||||
Explicit calculation of the Quantization Stepsizes
|
||||
@param tccp Tile-component coding parameters
|
||||
@param prec Precint analyzed
|
||||
*/
|
||||
void dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, int prec);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __DWT_H */
|
||||
@@ -1,121 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ==========================================================
|
||||
Utility functions
|
||||
==========================================================*/
|
||||
|
||||
#ifdef OPJ_CODE_NOT_USED
|
||||
#ifndef _WIN32
|
||||
static char*
|
||||
i2a(unsigned i, char *a, unsigned r) {
|
||||
if (i/r > 0) a = i2a(i/r,a,r);
|
||||
*a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[i%r];
|
||||
return a+1;
|
||||
}
|
||||
|
||||
/**
|
||||
Transforms integer i into an ascii string and stores the result in a;
|
||||
string is encoded in the base indicated by r.
|
||||
@param i Number to be converted
|
||||
@param a String result
|
||||
@param r Base of value; must be in the range 2 - 36
|
||||
@return Returns a
|
||||
*/
|
||||
static char *
|
||||
_itoa(int i, char *a, int r) {
|
||||
r = ((r < 2) || (r > 36)) ? 10 : r;
|
||||
if(i < 0) {
|
||||
*a = '-';
|
||||
*i2a(-i, a+1, r) = 0;
|
||||
}
|
||||
else *i2a(i, a, r) = 0;
|
||||
return a;
|
||||
}
|
||||
|
||||
#endif /* !_WIN32 */
|
||||
#endif
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context) {
|
||||
if(cinfo) {
|
||||
opj_event_mgr_t *previous = cinfo->event_mgr;
|
||||
cinfo->event_mgr = event_mgr;
|
||||
cinfo->client_data = context;
|
||||
return previous;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...) {
|
||||
#define MSG_SIZE 512 /* 512 bytes should be more than enough for a short message */
|
||||
opj_msg_callback msg_handler = NULL;
|
||||
|
||||
opj_event_mgr_t *event_mgr = cinfo->event_mgr;
|
||||
if(event_mgr != NULL) {
|
||||
switch(event_type) {
|
||||
case EVT_ERROR:
|
||||
msg_handler = event_mgr->error_handler;
|
||||
break;
|
||||
case EVT_WARNING:
|
||||
msg_handler = event_mgr->warning_handler;
|
||||
break;
|
||||
case EVT_INFO:
|
||||
msg_handler = event_mgr->info_handler;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(msg_handler == NULL) {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
} else {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
if ((fmt != NULL) && (event_mgr != NULL)) {
|
||||
va_list arg;
|
||||
int str_length/*, i, j*/; /* UniPG */
|
||||
char message[MSG_SIZE];
|
||||
/* initialize the optional parameter list */
|
||||
va_start(arg, fmt);
|
||||
/* parse the format string and put the result in 'message' */
|
||||
str_length = vsnprintf(message, MSG_SIZE, fmt, arg); /* UniPG */
|
||||
/* deinitialize the optional parameter list */
|
||||
va_end(arg);
|
||||
|
||||
/* output the message to the user program */
|
||||
if( str_length > -1 && str_length < MSG_SIZE )
|
||||
msg_handler(message, cinfo->client_data);
|
||||
else return OPJ_FALSE;
|
||||
}
|
||||
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
@@ -1,58 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __EVENT_H
|
||||
#define __EVENT_H
|
||||
/**
|
||||
@file event.h
|
||||
@brief Implementation of a event callback system
|
||||
|
||||
The functions in EVENT.C have for goal to send output messages (errors, warnings, debug) to the user.
|
||||
*/
|
||||
|
||||
#define EVT_ERROR 1 /**< Error event type */
|
||||
#define EVT_WARNING 2 /**< Warning event type */
|
||||
#define EVT_INFO 4 /**< Debug event type */
|
||||
|
||||
/** @defgroup EVENT EVENT - Implementation of a event callback system */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions (see also openjpeg.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Write formatted data to a string and send the string to a user callback.
|
||||
@param cinfo Codec context info
|
||||
@param event_type Event type or callback to use to send the message
|
||||
@param fmt Format-control string (plus optionnal arguments)
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
opj_bool opj_event_msg(opj_common_ptr cinfo, int event_type, const char *fmt, ...);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __EVENT_H */
|
||||
@@ -1,64 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __FIX_H
|
||||
#define __FIX_H
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
#define int64 __int64
|
||||
#else
|
||||
#define int64 long long
|
||||
#endif
|
||||
|
||||
/**
|
||||
@file fix.h
|
||||
@brief Implementation of operations of specific multiplication (FIX)
|
||||
|
||||
The functions in FIX.H have for goal to realize specific multiplication.
|
||||
*/
|
||||
|
||||
/** @defgroup FIX FIX - Implementation of operations of specific multiplication */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Multiply two fixed-precision rational numbers.
|
||||
@param a
|
||||
@param b
|
||||
@return Returns a * b
|
||||
*/
|
||||
static INLINE int fix_mul(int a, int b) {
|
||||
int64 temp = (int64) a * (int64) b ;
|
||||
temp += temp & 4096;
|
||||
return (int) (temp >> 13) ;
|
||||
}
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __FIX_H */
|
||||
@@ -1,89 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
opj_image_t* opj_image_create0(void) {
|
||||
opj_image_t *image = (opj_image_t*)opj_calloc(1, sizeof(opj_image_t));
|
||||
return image;
|
||||
}
|
||||
|
||||
opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc) {
|
||||
int compno;
|
||||
opj_image_t *image = NULL;
|
||||
|
||||
image = (opj_image_t*) opj_calloc(1, sizeof(opj_image_t));
|
||||
if(image) {
|
||||
image->color_space = clrspc;
|
||||
image->numcomps = numcmpts;
|
||||
/* allocate memory for the per-component information */
|
||||
image->comps = (opj_image_comp_t*)opj_malloc(image->numcomps * sizeof(opj_image_comp_t));
|
||||
if(!image->comps) {
|
||||
fprintf(stderr,"Unable to allocate memory for image.\n");
|
||||
opj_image_destroy(image);
|
||||
return NULL;
|
||||
}
|
||||
/* create the individual image components */
|
||||
for(compno = 0; compno < numcmpts; compno++) {
|
||||
opj_image_comp_t *comp = &image->comps[compno];
|
||||
comp->dx = cmptparms[compno].dx;
|
||||
comp->dy = cmptparms[compno].dy;
|
||||
comp->w = cmptparms[compno].w;
|
||||
comp->h = cmptparms[compno].h;
|
||||
comp->x0 = cmptparms[compno].x0;
|
||||
comp->y0 = cmptparms[compno].y0;
|
||||
comp->prec = cmptparms[compno].prec;
|
||||
comp->bpp = cmptparms[compno].bpp;
|
||||
comp->sgnd = cmptparms[compno].sgnd;
|
||||
comp->data = (int*) opj_calloc(comp->w * comp->h, sizeof(int));
|
||||
if(!comp->data) {
|
||||
fprintf(stderr,"Unable to allocate memory for image.\n");
|
||||
opj_image_destroy(image);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return image;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_image_destroy(opj_image_t *image) {
|
||||
int i;
|
||||
if(image) {
|
||||
if(image->comps) {
|
||||
/* image components */
|
||||
for(i = 0; i < image->numcomps; i++) {
|
||||
opj_image_comp_t *image_comp = &image->comps[i];
|
||||
if(image_comp->data) {
|
||||
opj_free(image_comp->data);
|
||||
}
|
||||
}
|
||||
opj_free(image->comps);
|
||||
}
|
||||
opj_free(image);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,118 +0,0 @@
|
||||
/*
|
||||
* $Id: indexbox_manager.h 897 2011-08-28 21:43:57Z [email protected] $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.c from 2KAN indexer
|
||||
*/
|
||||
|
||||
#ifndef INDEXBOX_MANAGER_H_
|
||||
# define INDEXBOX_MANAGER_H_
|
||||
|
||||
#include "openjpeg.h"
|
||||
#include "j2k.h" /* needed to use jp2.h */
|
||||
#include "jp2.h"
|
||||
|
||||
#define JPIP_CIDX 0x63696478 /* Codestream index */
|
||||
#define JPIP_CPTR 0x63707472 /* Codestream Finder Box */
|
||||
#define JPIP_MANF 0x6d616e66 /* Manifest Box */
|
||||
#define JPIP_FAIX 0x66616978 /* Fragment array Index box */
|
||||
#define JPIP_MHIX 0x6d686978 /* Main Header Index Table */
|
||||
#define JPIP_TPIX 0x74706978 /* Tile-part Index Table box */
|
||||
#define JPIP_THIX 0x74686978 /* Tile header Index Table box */
|
||||
#define JPIP_PPIX 0x70706978 /* Precinct Packet Index Table box */
|
||||
#define JPIP_PHIX 0x70686978 /* Packet Header index Table */
|
||||
#define JPIP_FIDX 0x66696478 /* File Index */
|
||||
#define JPIP_FPTR 0x66707472 /* File Finder */
|
||||
#define JPIP_PRXY 0x70727879 /* Proxy boxes */
|
||||
#define JPIP_IPTR 0x69707472 /* Index finder box */
|
||||
#define JPIP_PHLD 0x70686c64 /* Place holder */
|
||||
|
||||
|
||||
/*
|
||||
* Write tile-part Index table box (superbox)
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of tpix box
|
||||
*/
|
||||
int write_tpix( int coff, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
|
||||
|
||||
|
||||
/*
|
||||
* Write tile header index table box (superbox)
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information pointer
|
||||
* @param[in] cio file output handle
|
||||
* @return length of thix box
|
||||
*/
|
||||
int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio);
|
||||
|
||||
|
||||
/*
|
||||
* Write precinct packet index table box (superbox)
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] EPHused true if EPH option used
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of ppix box
|
||||
*/
|
||||
int write_ppix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
|
||||
|
||||
|
||||
/*
|
||||
* Write packet header index table box (superbox)
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] EPHused true if EPH option used
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of ppix box
|
||||
*/
|
||||
int write_phix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
|
||||
|
||||
/*
|
||||
* Wriet manifest box (box)
|
||||
*
|
||||
* @param[in] second number to be visited
|
||||
* @param[in] v number of boxes
|
||||
* @param[in] box box to be manifested
|
||||
* @param[in] cio file output handle
|
||||
*/
|
||||
void write_manf(int second, int v, opj_jp2_box_t *box, opj_cio_t *cio);
|
||||
|
||||
|
||||
#endif /* !INDEXBOX_MANAGER_H_ */
|
||||
@@ -1,119 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __INT_H
|
||||
#define __INT_H
|
||||
/**
|
||||
@file int.h
|
||||
@brief Implementation of operations on integers (INT)
|
||||
|
||||
The functions in INT.H have for goal to realize operations on integers.
|
||||
*/
|
||||
|
||||
/** @defgroup INT INT - Implementation of operations on integers */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions (see also openjpeg.h) */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Get the minimum of two integers
|
||||
@return Returns a if a < b else b
|
||||
*/
|
||||
static INLINE int int_min(int a, int b) {
|
||||
return a < b ? a : b;
|
||||
}
|
||||
/**
|
||||
Get the maximum of two integers
|
||||
@return Returns a if a > b else b
|
||||
*/
|
||||
static INLINE int int_max(int a, int b) {
|
||||
return (a > b) ? a : b;
|
||||
}
|
||||
/**
|
||||
Clamp an integer inside an interval
|
||||
@return
|
||||
<ul>
|
||||
<li>Returns a if (min < a < max)
|
||||
<li>Returns max if (a > max)
|
||||
<li>Returns min if (a < min)
|
||||
</ul>
|
||||
*/
|
||||
static INLINE int int_clamp(int a, int min, int max) {
|
||||
if (a < min)
|
||||
return min;
|
||||
if (a > max)
|
||||
return max;
|
||||
return a;
|
||||
}
|
||||
/**
|
||||
@return Get absolute value of integer
|
||||
*/
|
||||
static INLINE int int_abs(int a) {
|
||||
return a < 0 ? -a : a;
|
||||
}
|
||||
/**
|
||||
Divide an integer and round upwards
|
||||
@return Returns a divided by b
|
||||
*/
|
||||
static INLINE int int_ceildiv(int a, int b) {
|
||||
return (a + b - 1) / b;
|
||||
}
|
||||
/**
|
||||
Divide an integer by a power of 2 and round upwards
|
||||
@return Returns a divided by 2^b
|
||||
*/
|
||||
static INLINE int int_ceildivpow2(int a, int b) {
|
||||
return (a + (1 << b) - 1) >> b;
|
||||
}
|
||||
/**
|
||||
Divide an integer by a power of 2 and round downwards
|
||||
@return Returns a divided by 2^b
|
||||
*/
|
||||
static INLINE int int_floordivpow2(int a, int b) {
|
||||
return a >> b;
|
||||
}
|
||||
/**
|
||||
Get logarithm of an integer and round downwards
|
||||
@return Returns log2(a)
|
||||
*/
|
||||
static INLINE int int_floorlog2(int a) {
|
||||
int l;
|
||||
for (l = 0; a > 1; l++) {
|
||||
a >>= 1;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,446 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2006-2007, Parvatha Elangovan
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __J2K_H
|
||||
#define __J2K_H
|
||||
/**
|
||||
@file j2k.h
|
||||
@brief The JPEG-2000 Codestream Reader/Writer (J2K)
|
||||
|
||||
The functions in J2K.C have for goal to read/write the several parts of the codestream: markers and data.
|
||||
*/
|
||||
|
||||
/** @defgroup J2K J2K - JPEG-2000 codestream reader/writer */
|
||||
/*@{*/
|
||||
|
||||
#define J2K_CP_CSTY_PRT 0x01
|
||||
#define J2K_CP_CSTY_SOP 0x02
|
||||
#define J2K_CP_CSTY_EPH 0x04
|
||||
#define J2K_CCP_CSTY_PRT 0x01
|
||||
#define J2K_CCP_CBLKSTY_LAZY 0x01 /**< Selective arithmetic coding bypass */
|
||||
#define J2K_CCP_CBLKSTY_RESET 0x02 /**< Reset context probabilities on coding pass boundaries */
|
||||
#define J2K_CCP_CBLKSTY_TERMALL 0x04 /**< Termination on each coding pass */
|
||||
#define J2K_CCP_CBLKSTY_VSC 0x08 /**< Vertically stripe causal context */
|
||||
#define J2K_CCP_CBLKSTY_PTERM 0x10 /**< Predictable termination */
|
||||
#define J2K_CCP_CBLKSTY_SEGSYM 0x20 /**< Segmentation symbols are used */
|
||||
#define J2K_CCP_QNTSTY_NOQNT 0
|
||||
#define J2K_CCP_QNTSTY_SIQNT 1
|
||||
#define J2K_CCP_QNTSTY_SEQNT 2
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
#define J2K_MS_SOC 0xff4f /**< SOC marker value */
|
||||
#define J2K_MS_SOT 0xff90 /**< SOT marker value */
|
||||
#define J2K_MS_SOD 0xff93 /**< SOD marker value */
|
||||
#define J2K_MS_EOC 0xffd9 /**< EOC marker value */
|
||||
#define J2K_MS_SIZ 0xff51 /**< SIZ marker value */
|
||||
#define J2K_MS_COD 0xff52 /**< COD marker value */
|
||||
#define J2K_MS_COC 0xff53 /**< COC marker value */
|
||||
#define J2K_MS_RGN 0xff5e /**< RGN marker value */
|
||||
#define J2K_MS_QCD 0xff5c /**< QCD marker value */
|
||||
#define J2K_MS_QCC 0xff5d /**< QCC marker value */
|
||||
#define J2K_MS_POC 0xff5f /**< POC marker value */
|
||||
#define J2K_MS_TLM 0xff55 /**< TLM marker value */
|
||||
#define J2K_MS_PLM 0xff57 /**< PLM marker value */
|
||||
#define J2K_MS_PLT 0xff58 /**< PLT marker value */
|
||||
#define J2K_MS_PPM 0xff60 /**< PPM marker value */
|
||||
#define J2K_MS_PPT 0xff61 /**< PPT marker value */
|
||||
#define J2K_MS_SOP 0xff91 /**< SOP marker value */
|
||||
#define J2K_MS_EPH 0xff92 /**< EPH marker value */
|
||||
#define J2K_MS_CRG 0xff63 /**< CRG marker value */
|
||||
#define J2K_MS_COM 0xff64 /**< COM marker value */
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
#define J2K_MS_EPC 0xff68 /**< EPC marker value (Part 11: JPEG 2000 for Wireless) */
|
||||
#define J2K_MS_EPB 0xff66 /**< EPB marker value (Part 11: JPEG 2000 for Wireless) */
|
||||
#define J2K_MS_ESD 0xff67 /**< ESD marker value (Part 11: JPEG 2000 for Wireless) */
|
||||
#define J2K_MS_RED 0xff69 /**< RED marker value (Part 11: JPEG 2000 for Wireless) */
|
||||
#endif /* USE_JPWL */
|
||||
#ifdef USE_JPSEC
|
||||
#define J2K_MS_SEC 0xff65 /**< SEC marker value (Part 8: Secure JPEG 2000) */
|
||||
#define J2K_MS_INSEC 0xff94 /**< INSEC marker value (Part 8: Secure JPEG 2000) */
|
||||
#endif /* USE_JPSEC */
|
||||
/* <<UniPG */
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Values that specify the status of the decoding process when decoding the main header.
|
||||
These values may be combined with a | operator.
|
||||
*/
|
||||
typedef enum J2K_STATUS {
|
||||
J2K_STATE_MHSOC = 0x0001, /**< a SOC marker is expected */
|
||||
J2K_STATE_MHSIZ = 0x0002, /**< a SIZ marker is expected */
|
||||
J2K_STATE_MH = 0x0004, /**< the decoding process is in the main header */
|
||||
J2K_STATE_TPHSOT = 0x0008, /**< the decoding process is in a tile part header and expects a SOT marker */
|
||||
J2K_STATE_TPH = 0x0010, /**< the decoding process is in a tile part header */
|
||||
J2K_STATE_MT = 0x0020, /**< the EOC marker has just been read */
|
||||
J2K_STATE_NEOC = 0x0040, /**< the decoding process must not expect a EOC marker because the codestream is truncated */
|
||||
J2K_STATE_ERR = 0x0080 /**< the decoding process has encountered an error */
|
||||
} J2K_STATUS;
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
T2 encoding mode
|
||||
*/
|
||||
typedef enum T2_MODE {
|
||||
THRESH_CALC = 0, /** Function called in Rate allocation process*/
|
||||
FINAL_PASS = 1 /** Function called in Tier 2 process*/
|
||||
}J2K_T2_MODE;
|
||||
|
||||
/**
|
||||
Quantization stepsize
|
||||
*/
|
||||
typedef struct opj_stepsize {
|
||||
/** exponent */
|
||||
int expn;
|
||||
/** mantissa */
|
||||
int mant;
|
||||
} opj_stepsize_t;
|
||||
|
||||
/**
|
||||
Tile-component coding parameters
|
||||
*/
|
||||
typedef struct opj_tccp {
|
||||
/** coding style */
|
||||
int csty;
|
||||
/** number of resolutions */
|
||||
int numresolutions;
|
||||
/** code-blocks width */
|
||||
int cblkw;
|
||||
/** code-blocks height */
|
||||
int cblkh;
|
||||
/** code-block coding style */
|
||||
int cblksty;
|
||||
/** discrete wavelet transform identifier */
|
||||
int qmfbid;
|
||||
/** quantisation style */
|
||||
int qntsty;
|
||||
/** stepsizes used for quantization */
|
||||
opj_stepsize_t stepsizes[J2K_MAXBANDS];
|
||||
/** number of guard bits */
|
||||
int numgbits;
|
||||
/** Region Of Interest shift */
|
||||
int roishift;
|
||||
/** precinct width */
|
||||
int prcw[J2K_MAXRLVLS];
|
||||
/** precinct height */
|
||||
int prch[J2K_MAXRLVLS];
|
||||
} opj_tccp_t;
|
||||
|
||||
/**
|
||||
Tile coding parameters :
|
||||
this structure is used to store coding/decoding parameters common to all
|
||||
tiles (information like COD, COC in main header)
|
||||
*/
|
||||
typedef struct opj_tcp {
|
||||
/** 1 : first part-tile of a tile */
|
||||
int first;
|
||||
/** coding style */
|
||||
int csty;
|
||||
/** progression order */
|
||||
OPJ_PROG_ORDER prg;
|
||||
/** number of layers */
|
||||
int numlayers;
|
||||
/** multi-component transform identifier */
|
||||
int mct;
|
||||
/** rates of layers */
|
||||
float rates[100];
|
||||
/** number of progression order changes */
|
||||
int numpocs;
|
||||
/** indicates if a POC marker has been used O:NO, 1:YES */
|
||||
int POC;
|
||||
/** progression order changes */
|
||||
opj_poc_t pocs[32];
|
||||
/** packet header store there for futur use in t2_decode_packet */
|
||||
unsigned char *ppt_data;
|
||||
/** pointer remaining on the first byte of the first header if ppt is used */
|
||||
unsigned char *ppt_data_first;
|
||||
/** If ppt == 1 --> there was a PPT marker for the present tile */
|
||||
int ppt;
|
||||
/** used in case of multiple marker PPT (number of info already stored) */
|
||||
int ppt_store;
|
||||
/** ppmbug1 */
|
||||
int ppt_len;
|
||||
/** add fixed_quality */
|
||||
float distoratio[100];
|
||||
/** tile-component coding parameters */
|
||||
opj_tccp_t *tccps;
|
||||
} opj_tcp_t;
|
||||
|
||||
/**
|
||||
Coding parameters
|
||||
*/
|
||||
typedef struct opj_cp {
|
||||
/** Digital cinema profile*/
|
||||
OPJ_CINEMA_MODE cinema;
|
||||
/** Maximum rate for each component. If == 0, component size limitation is not considered */
|
||||
int max_comp_size;
|
||||
/** Size of the image in bits*/
|
||||
int img_size;
|
||||
/** Rsiz*/
|
||||
OPJ_RSIZ_CAPABILITIES rsiz;
|
||||
/** Enabling Tile part generation*/
|
||||
char tp_on;
|
||||
/** Flag determining tile part generation*/
|
||||
char tp_flag;
|
||||
/** Position of tile part flag in progression order*/
|
||||
int tp_pos;
|
||||
/** allocation by rate/distortion */
|
||||
int disto_alloc;
|
||||
/** allocation by fixed layer */
|
||||
int fixed_alloc;
|
||||
/** add fixed_quality */
|
||||
int fixed_quality;
|
||||
/** if != 0, then original dimension divided by 2^(reduce); if == 0 or not used, image is decoded to the full resolution */
|
||||
int reduce;
|
||||
/** if != 0, then only the first "layer" layers are decoded; if == 0 or not used, all the quality layers are decoded */
|
||||
int layer;
|
||||
/** if == NO_LIMITATION, decode entire codestream; if == LIMIT_TO_MAIN_HEADER then only decode the main header */
|
||||
OPJ_LIMIT_DECODING limit_decoding;
|
||||
/** XTOsiz */
|
||||
int tx0;
|
||||
/** YTOsiz */
|
||||
int ty0;
|
||||
/** XTsiz */
|
||||
int tdx;
|
||||
/** YTsiz */
|
||||
int tdy;
|
||||
/** comment for coding */
|
||||
char *comment;
|
||||
/** number of tiles in width */
|
||||
int tw;
|
||||
/** number of tiles in heigth */
|
||||
int th;
|
||||
/** ID number of the tiles present in the codestream */
|
||||
int *tileno;
|
||||
/** size of the vector tileno */
|
||||
int tileno_size;
|
||||
/** packet header store there for futur use in t2_decode_packet */
|
||||
unsigned char *ppm_data;
|
||||
/** pointer remaining on the first byte of the first header if ppm is used */
|
||||
unsigned char *ppm_data_first;
|
||||
/** if ppm == 1 --> there was a PPM marker for the present tile */
|
||||
int ppm;
|
||||
/** use in case of multiple marker PPM (number of info already store) */
|
||||
int ppm_store;
|
||||
/** use in case of multiple marker PPM (case on non-finished previous info) */
|
||||
int ppm_previous;
|
||||
/** ppmbug1 */
|
||||
int ppm_len;
|
||||
/** tile coding parameters */
|
||||
opj_tcp_t *tcps;
|
||||
/** fixed layer */
|
||||
int *matrice;
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
/** enables writing of EPC in MH, thus activating JPWL */
|
||||
opj_bool epc_on;
|
||||
/** enables writing of EPB, in case of activated JPWL */
|
||||
opj_bool epb_on;
|
||||
/** enables writing of ESD, in case of activated JPWL */
|
||||
opj_bool esd_on;
|
||||
/** enables writing of informative techniques of ESD, in case of activated JPWL */
|
||||
opj_bool info_on;
|
||||
/** enables writing of RED, in case of activated JPWL */
|
||||
opj_bool red_on;
|
||||
/** error protection method for MH (0,1,16,32,37-128) */
|
||||
int hprot_MH;
|
||||
/** tile number of header protection specification (>=0) */
|
||||
int hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
||||
/** error protection methods for TPHs (0,1,16,32,37-128) */
|
||||
int hprot_TPH[JPWL_MAX_NO_TILESPECS];
|
||||
/** tile number of packet protection specification (>=0) */
|
||||
int pprot_tileno[JPWL_MAX_NO_PACKSPECS];
|
||||
/** packet number of packet protection specification (>=0) */
|
||||
int pprot_packno[JPWL_MAX_NO_PACKSPECS];
|
||||
/** error protection methods for packets (0,1,16,32,37-128) */
|
||||
int pprot[JPWL_MAX_NO_PACKSPECS];
|
||||
/** enables writing of ESD, (0/2/4 bytes) */
|
||||
int sens_size;
|
||||
/** sensitivity addressing size (0=auto/2/4 bytes) */
|
||||
int sens_addr;
|
||||
/** sensitivity range (0-3) */
|
||||
int sens_range;
|
||||
/** sensitivity method for MH (-1,0-7) */
|
||||
int sens_MH;
|
||||
/** tile number of sensitivity specification (>=0) */
|
||||
int sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
||||
/** sensitivity methods for TPHs (-1,0-7) */
|
||||
int sens_TPH[JPWL_MAX_NO_TILESPECS];
|
||||
/** enables JPWL correction at the decoder */
|
||||
opj_bool correct;
|
||||
/** expected number of components at the decoder */
|
||||
int exp_comps;
|
||||
/** maximum number of tiles at the decoder */
|
||||
int max_tiles;
|
||||
#endif /* USE_JPWL */
|
||||
/* <<UniPG */
|
||||
} opj_cp_t;
|
||||
|
||||
/**
|
||||
JPEG-2000 codestream reader/writer
|
||||
*/
|
||||
typedef struct opj_j2k {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** locate in which part of the codestream the decoder is (main header, tile header, end) */
|
||||
int state;
|
||||
/** number of the tile curently concern by coding/decoding */
|
||||
int curtileno;
|
||||
/** Tile part number*/
|
||||
int tp_num;
|
||||
/** Tilepart number currently coding*/
|
||||
int cur_tp_num;
|
||||
/** Total number of tileparts of the current tile*/
|
||||
int *cur_totnum_tp;
|
||||
/**
|
||||
locate the start position of the TLM marker
|
||||
after encoding the tilepart, a jump (in j2k_write_sod) is done to the TLM marker to store the value of its length.
|
||||
*/
|
||||
int tlm_start;
|
||||
/** Total num of tile parts in whole image = num tiles* num tileparts in each tile*/
|
||||
/** used in TLMmarker*/
|
||||
int totnum_tp;
|
||||
/**
|
||||
locate the position of the end of the tile in the codestream,
|
||||
used to detect a truncated codestream (in j2k_read_sod)
|
||||
*/
|
||||
unsigned char *eot;
|
||||
/**
|
||||
locate the start position of the SOT marker of the current coded tile:
|
||||
after encoding the tile, a jump (in j2k_write_sod) is done to the SOT marker to store the value of its length.
|
||||
*/
|
||||
int sot_start;
|
||||
int sod_start;
|
||||
/**
|
||||
as the J2K-file is written in several parts during encoding,
|
||||
it enables to make the right correction in position return by cio_tell
|
||||
*/
|
||||
int pos_correction;
|
||||
/** array used to store the data of each tile */
|
||||
unsigned char **tile_data;
|
||||
/** array used to store the length of each tile */
|
||||
int *tile_len;
|
||||
/**
|
||||
decompression only :
|
||||
store decoding parameters common to all tiles (information like COD, COC in main header)
|
||||
*/
|
||||
opj_tcp_t *default_tcp;
|
||||
/** pointer to the encoded / decoded image */
|
||||
opj_image_t *image;
|
||||
/** pointer to the coding parameters */
|
||||
opj_cp_t *cp;
|
||||
/** helper used to write the index file */
|
||||
opj_codestream_info_t *cstr_info;
|
||||
/** pointer to the byte i/o stream */
|
||||
opj_cio_t *cio;
|
||||
} opj_j2k_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Creates a J2K decompression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a J2K decompressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_j2k_t* j2k_create_decompress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a J2K decompressor handle
|
||||
@param j2k J2K decompressor handle to destroy
|
||||
*/
|
||||
void j2k_destroy_decompress(opj_j2k_t *j2k);
|
||||
/**
|
||||
Setup the decoder decoding parameters using user parameters.
|
||||
Decoding parameters are returned in j2k->cp.
|
||||
@param j2k J2K decompressor handle
|
||||
@param parameters decompression parameters
|
||||
*/
|
||||
void j2k_setup_decoder(opj_j2k_t *j2k, opj_dparameters_t *parameters);
|
||||
/**
|
||||
Decode an image from a JPEG-2000 codestream
|
||||
@param j2k J2K decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@param cstr_info Codestream information structure if required, NULL otherwise
|
||||
@return Returns a decoded image if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_image_t* j2k_decode(opj_j2k_t *j2k, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Decode an image form a JPT-stream (JPEG 2000, JPIP)
|
||||
@param j2k J2K decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@param cstr_info Codestream information structure if required, NULL otherwise
|
||||
@return Returns a decoded image if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_image_t* j2k_decode_jpt_stream(opj_j2k_t *j2k, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Creates a J2K compression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a J2K compressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_j2k_t* j2k_create_compress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a J2K compressor handle
|
||||
@param j2k J2K compressor handle to destroy
|
||||
*/
|
||||
void j2k_destroy_compress(opj_j2k_t *j2k);
|
||||
/**
|
||||
Setup the encoder parameters using the current image and using user parameters.
|
||||
Coding parameters are returned in j2k->cp.
|
||||
@param j2k J2K compressor handle
|
||||
@param parameters compression parameters
|
||||
@param image input filled image
|
||||
*/
|
||||
void j2k_setup_encoder(opj_j2k_t *j2k, opj_cparameters_t *parameters, opj_image_t *image);
|
||||
/**
|
||||
Converts an enum type progression order to string type
|
||||
*/
|
||||
char *j2k_convert_progression_order(OPJ_PROG_ORDER prg_order);
|
||||
/**
|
||||
Encode an image into a JPEG-2000 codestream
|
||||
@param j2k J2K compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param image Image to encode
|
||||
@param cstr_info Codestream information structure if required, NULL otherwise
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
opj_bool j2k_encode(opj_j2k_t *j2k, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __J2K_H */
|
||||
@@ -1,59 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <sys/time.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/times.h>
|
||||
#endif /* _WIN32 */
|
||||
#include "opj_includes.h"
|
||||
|
||||
double opj_clock(void) {
|
||||
#ifdef _WIN32
|
||||
/* _WIN32: use QueryPerformance (very accurate) */
|
||||
LARGE_INTEGER freq , t ;
|
||||
/* freq is the clock speed of the CPU */
|
||||
QueryPerformanceFrequency(&freq) ;
|
||||
/* cout << "freq = " << ((double) freq.QuadPart) << endl; */
|
||||
/* t is the high resolution performance counter (see MSDN) */
|
||||
QueryPerformanceCounter ( & t ) ;
|
||||
return ( t.QuadPart /(double) freq.QuadPart ) ;
|
||||
#else
|
||||
/* Unix or Linux: use resource usage */
|
||||
struct rusage t;
|
||||
double procTime;
|
||||
/* (1) Get the rusage data structure at this moment (man getrusage) */
|
||||
getrusage(0,&t);
|
||||
/* (2) What is the elapsed time ? - CPU time = User time + System time */
|
||||
/* (2a) Get the seconds */
|
||||
procTime = t.ru_utime.tv_sec + t.ru_stime.tv_sec;
|
||||
/* (2b) More precisely! Get the microseconds part ! */
|
||||
return ( procTime + (t.ru_utime.tv_usec + t.ru_stime.tv_usec) * 1e-6 ) ;
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __J2K_LIB_H
|
||||
#define __J2K_LIB_H
|
||||
/**
|
||||
@file j2k_lib.h
|
||||
@brief Internal functions
|
||||
|
||||
The functions in J2K_LIB.C are internal utilities mainly used for timing.
|
||||
*/
|
||||
|
||||
/** @defgroup MISC MISC - Miscellaneous internal functions */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Difference in successive opj_clock() calls tells you the elapsed time
|
||||
@return Returns time in seconds
|
||||
*/
|
||||
double opj_clock(void);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __J2K_LIB_H */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,234 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __JP2_H
|
||||
#define __JP2_H
|
||||
/**
|
||||
@file jp2.h
|
||||
@brief The JPEG-2000 file format Reader/Writer (JP2)
|
||||
|
||||
*/
|
||||
|
||||
/** @defgroup JP2 JP2 - JPEG-2000 file format reader/writer */
|
||||
/*@{*/
|
||||
|
||||
#define JPIP_JPIP 0x6a706970
|
||||
|
||||
#define JP2_JP 0x6a502020 /**< JPEG 2000 signature box */
|
||||
#define JP2_FTYP 0x66747970 /**< File type box */
|
||||
#define JP2_JP2H 0x6a703268 /**< JP2 header box */
|
||||
#define JP2_IHDR 0x69686472 /**< Image header box */
|
||||
#define JP2_COLR 0x636f6c72 /**< Colour specification box */
|
||||
#define JP2_JP2C 0x6a703263 /**< Contiguous codestream box */
|
||||
#define JP2_URL 0x75726c20 /**< URL box */
|
||||
#define JP2_DTBL 0x6474626c /**< Data Reference box */
|
||||
#define JP2_BPCC 0x62706363 /**< Bits per component box */
|
||||
#define JP2_JP2 0x6a703220 /**< File type fields */
|
||||
#define JP2_PCLR 0x70636c72 /**< Palette box */
|
||||
#define JP2_CMAP 0x636d6170 /**< Component Mapping box */
|
||||
#define JP2_CDEF 0x63646566 /**< Channel Definition box */
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Channel description: channel index, type, assocation
|
||||
*/
|
||||
typedef struct opj_jp2_cdef_info
|
||||
{
|
||||
unsigned short cn, typ, asoc;
|
||||
} opj_jp2_cdef_info_t;
|
||||
|
||||
/**
|
||||
Channel descriptions and number of descriptions
|
||||
*/
|
||||
typedef struct opj_jp2_cdef
|
||||
{
|
||||
opj_jp2_cdef_info_t *info;
|
||||
unsigned short n;
|
||||
} opj_jp2_cdef_t;
|
||||
|
||||
/**
|
||||
Component mappings: channel index, mapping type, palette index
|
||||
*/
|
||||
typedef struct opj_jp2_cmap_comp
|
||||
{
|
||||
unsigned short cmp;
|
||||
unsigned char mtyp, pcol;
|
||||
} opj_jp2_cmap_comp_t;
|
||||
|
||||
/**
|
||||
Palette data: table entries, palette columns
|
||||
*/
|
||||
typedef struct opj_jp2_pclr
|
||||
{
|
||||
unsigned int *entries;
|
||||
unsigned char *channel_sign;
|
||||
unsigned char *channel_size;
|
||||
opj_jp2_cmap_comp_t *cmap;
|
||||
unsigned short nr_entries, nr_channels;
|
||||
} opj_jp2_pclr_t;
|
||||
|
||||
/**
|
||||
Collector for ICC profile, palette, component mapping, channel description
|
||||
*/
|
||||
typedef struct opj_jp2_color
|
||||
{
|
||||
unsigned char *icc_profile_buf;
|
||||
int icc_profile_len;
|
||||
|
||||
opj_jp2_cdef_t *jp2_cdef;
|
||||
opj_jp2_pclr_t *jp2_pclr;
|
||||
unsigned char jp2_has_colr;
|
||||
} opj_jp2_color_t;
|
||||
|
||||
/**
|
||||
JP2 component
|
||||
*/
|
||||
typedef struct opj_jp2_comps {
|
||||
int depth;
|
||||
int sgnd;
|
||||
int bpcc;
|
||||
} opj_jp2_comps_t;
|
||||
|
||||
/**
|
||||
JPEG-2000 file format reader/writer
|
||||
*/
|
||||
typedef struct opj_jp2 {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
/** handle to the J2K codec */
|
||||
opj_j2k_t *j2k;
|
||||
unsigned int w;
|
||||
unsigned int h;
|
||||
unsigned int numcomps;
|
||||
unsigned int bpc;
|
||||
unsigned int C;
|
||||
unsigned int UnkC;
|
||||
unsigned int IPR;
|
||||
unsigned int meth;
|
||||
unsigned int approx;
|
||||
unsigned int enumcs;
|
||||
unsigned int precedence;
|
||||
unsigned int brand;
|
||||
unsigned int minversion;
|
||||
unsigned int numcl;
|
||||
unsigned int *cl;
|
||||
opj_jp2_comps_t *comps;
|
||||
unsigned int j2k_codestream_offset;
|
||||
unsigned int j2k_codestream_length;
|
||||
opj_bool jpip_on;
|
||||
opj_bool ignore_pclr_cmap_cdef;
|
||||
} opj_jp2_t;
|
||||
|
||||
/**
|
||||
JP2 Box
|
||||
*/
|
||||
typedef struct opj_jp2_box {
|
||||
int length;
|
||||
int type;
|
||||
int init_pos;
|
||||
} opj_jp2_box_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Write the JP2H box - JP2 Header box (used in MJ2)
|
||||
@param jp2 JP2 handle
|
||||
@param cio Output buffer stream
|
||||
*/
|
||||
void jp2_write_jp2h(opj_jp2_t *jp2, opj_cio_t *cio);
|
||||
/**
|
||||
Read the JP2H box - JP2 Header box (used in MJ2)
|
||||
@param jp2 JP2 handle
|
||||
@param cio Input buffer stream
|
||||
@param ext Collector for profile, cdef and pclr data
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
opj_bool jp2_read_jp2h(opj_jp2_t *jp2, opj_cio_t *cio, opj_jp2_color_t *color);
|
||||
/**
|
||||
Creates a JP2 decompression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a JP2 decompressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_jp2_t* jp2_create_decompress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a JP2 decompressor handle
|
||||
@param jp2 JP2 decompressor handle to destroy
|
||||
*/
|
||||
void jp2_destroy_decompress(opj_jp2_t *jp2);
|
||||
/**
|
||||
Setup the decoder decoding parameters using user parameters.
|
||||
Decoding parameters are returned in jp2->j2k->cp.
|
||||
@param jp2 JP2 decompressor handle
|
||||
@param parameters decompression parameters
|
||||
*/
|
||||
void jp2_setup_decoder(opj_jp2_t *jp2, opj_dparameters_t *parameters);
|
||||
/**
|
||||
Decode an image from a JPEG-2000 file stream
|
||||
@param jp2 JP2 decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@param cstr_info Codestream information structure if required, NULL otherwise
|
||||
@return Returns a decoded image if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_image_t* opj_jp2_decode(opj_jp2_t *jp2, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Creates a JP2 compression structure
|
||||
@param cinfo Codec context info
|
||||
@return Returns a handle to a JP2 compressor if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_jp2_t* jp2_create_compress(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a JP2 compressor handle
|
||||
@param jp2 JP2 compressor handle to destroy
|
||||
*/
|
||||
void jp2_destroy_compress(opj_jp2_t *jp2);
|
||||
/**
|
||||
Setup the encoder parameters using the current image and using user parameters.
|
||||
Coding parameters are returned in jp2->j2k->cp.
|
||||
@param jp2 JP2 compressor handle
|
||||
@param parameters compression parameters
|
||||
@param image input filled image
|
||||
*/
|
||||
void jp2_setup_encoder(opj_jp2_t *jp2, opj_cparameters_t *parameters, opj_image_t *image);
|
||||
/**
|
||||
Encode an image into a JPEG-2000 file stream
|
||||
@param jp2 JP2 compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param image Image to encode
|
||||
@param cstr_info Codestream information structure if required, NULL otherwise
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
opj_bool opj_jp2_encode(opj_jp2_t *jp2, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __JP2_H */
|
||||
|
||||
@@ -1,155 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
* Read the information contains in VBAS [JPP/JPT stream message header]
|
||||
* Store information (7 bits) in value
|
||||
*
|
||||
*/
|
||||
unsigned int jpt_read_VBAS_info(opj_cio_t *cio, unsigned int value) {
|
||||
unsigned char elmt;
|
||||
|
||||
elmt = cio_read(cio, 1);
|
||||
while ((elmt >> 7) == 1) {
|
||||
value = (value << 7);
|
||||
value |= (elmt & 0x7f);
|
||||
elmt = cio_read(cio, 1);
|
||||
}
|
||||
value = (value << 7);
|
||||
value |= (elmt & 0x7f);
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize the value of the message header structure
|
||||
*
|
||||
*/
|
||||
void jpt_init_msg_header(opj_jpt_msg_header_t * header) {
|
||||
header->Id = 0; /* In-class Identifier */
|
||||
header->last_byte = 0; /* Last byte information */
|
||||
header->Class_Id = 0; /* Class Identifier */
|
||||
header->CSn_Id = 0; /* CSn : index identifier */
|
||||
header->Msg_offset = 0; /* Message offset */
|
||||
header->Msg_length = 0; /* Message length */
|
||||
header->Layer_nb = 0; /* Auxiliary for JPP case */
|
||||
}
|
||||
|
||||
/*
|
||||
* Re-initialize the value of the message header structure
|
||||
*
|
||||
* Only parameters always present in message header
|
||||
*
|
||||
*/
|
||||
void jpt_reinit_msg_header(opj_jpt_msg_header_t * header) {
|
||||
header->Id = 0; /* In-class Identifier */
|
||||
header->last_byte = 0; /* Last byte information */
|
||||
header->Msg_offset = 0; /* Message offset */
|
||||
header->Msg_length = 0; /* Message length */
|
||||
}
|
||||
|
||||
/*
|
||||
* Read the message header for a JPP/JPT - stream
|
||||
*
|
||||
*/
|
||||
void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header) {
|
||||
unsigned char elmt, Class = 0, CSn = 0;
|
||||
jpt_reinit_msg_header(header);
|
||||
|
||||
/* ------------- */
|
||||
/* VBAS : Bin-ID */
|
||||
/* ------------- */
|
||||
elmt = cio_read(cio, 1);
|
||||
|
||||
/* See for Class and CSn */
|
||||
switch ((elmt >> 5) & 0x03) {
|
||||
case 0:
|
||||
opj_event_msg(cinfo, EVT_ERROR, "Forbidden value encounter in message header !!\n");
|
||||
break;
|
||||
case 1:
|
||||
Class = 0;
|
||||
CSn = 0;
|
||||
break;
|
||||
case 2:
|
||||
Class = 1;
|
||||
CSn = 0;
|
||||
break;
|
||||
case 3:
|
||||
Class = 1;
|
||||
CSn = 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* see information on bits 'c' [p 10 : A.2.1 general, ISO/IEC FCD 15444-9] */
|
||||
if (((elmt >> 4) & 0x01) == 1)
|
||||
header->last_byte = 1;
|
||||
|
||||
/* In-class identifier */
|
||||
header->Id |= (elmt & 0x0f);
|
||||
if ((elmt >> 7) == 1)
|
||||
header->Id = jpt_read_VBAS_info(cio, header->Id);
|
||||
|
||||
/* ------------ */
|
||||
/* VBAS : Class */
|
||||
/* ------------ */
|
||||
if (Class == 1) {
|
||||
header->Class_Id = 0;
|
||||
header->Class_Id = jpt_read_VBAS_info(cio, header->Class_Id);
|
||||
}
|
||||
|
||||
/* ---------- */
|
||||
/* VBAS : CSn */
|
||||
/* ---------- */
|
||||
if (CSn == 1) {
|
||||
header->CSn_Id = 0;
|
||||
header->CSn_Id = jpt_read_VBAS_info(cio, header->CSn_Id);
|
||||
}
|
||||
|
||||
/* ----------------- */
|
||||
/* VBAS : Msg_offset */
|
||||
/* ----------------- */
|
||||
header->Msg_offset = jpt_read_VBAS_info(cio, header->Msg_offset);
|
||||
|
||||
/* ----------------- */
|
||||
/* VBAS : Msg_length */
|
||||
/* ----------------- */
|
||||
header->Msg_length = jpt_read_VBAS_info(cio, header->Msg_length);
|
||||
|
||||
/* ---------- */
|
||||
/* VBAS : Aux */
|
||||
/* ---------- */
|
||||
if ((header->Class_Id & 0x01) == 1) {
|
||||
header->Layer_nb = 0;
|
||||
header->Layer_nb = jpt_read_VBAS_info(cio, header->Layer_nb);
|
||||
}
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __JPT_H
|
||||
#define __JPT_H
|
||||
/**
|
||||
@file jpt.h
|
||||
@brief JPT-stream reader (JPEG 2000, JPIP)
|
||||
|
||||
JPT-stream functions are implemented in J2K.C.
|
||||
*/
|
||||
|
||||
/**
|
||||
Message Header JPT stream structure
|
||||
*/
|
||||
typedef struct opj_jpt_msg_header {
|
||||
/** In-class Identifier */
|
||||
unsigned int Id;
|
||||
/** Last byte information */
|
||||
unsigned int last_byte;
|
||||
/** Class Identifier */
|
||||
unsigned int Class_Id;
|
||||
/** CSn : index identifier */
|
||||
unsigned int CSn_Id;
|
||||
/** Message offset */
|
||||
unsigned int Msg_offset;
|
||||
/** Message length */
|
||||
unsigned int Msg_length;
|
||||
/** Auxiliary for JPP case */
|
||||
unsigned int Layer_nb;
|
||||
} opj_jpt_msg_header_t;
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Initialize the value of the message header structure
|
||||
@param header Message header structure
|
||||
*/
|
||||
void jpt_init_msg_header(opj_jpt_msg_header_t * header);
|
||||
|
||||
/**
|
||||
Read the message header for a JPP/JPT - stream
|
||||
@param cinfo Codec context info
|
||||
@param cio CIO handle
|
||||
@param header Message header structure
|
||||
*/
|
||||
void jpt_read_msg_header(opj_common_ptr cinfo, opj_cio_t *cio, opj_jpt_msg_header_t *header);
|
||||
|
||||
#endif
|
||||
@@ -1,190 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef __SSE__
|
||||
#include <xmmintrin.h>
|
||||
#endif
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the basis function of the reversible MCT. */
|
||||
/* </summary> */
|
||||
static const double mct_norms[3] = { 1.732, .8292, .8292 };
|
||||
|
||||
/* <summary> */
|
||||
/* This table contains the norms of the basis function of the irreversible MCT. */
|
||||
/* </summary> */
|
||||
static const double mct_norms_real[3] = { 1.732, 1.805, 1.573 };
|
||||
|
||||
/* <summary> */
|
||||
/* Foward reversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_encode(
|
||||
int* restrict c0,
|
||||
int* restrict c1,
|
||||
int* restrict c2,
|
||||
int n)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < n; ++i) {
|
||||
int r = c0[i];
|
||||
int g = c1[i];
|
||||
int b = c2[i];
|
||||
int y = (r + (g * 2) + b) >> 2;
|
||||
int u = b - g;
|
||||
int v = r - g;
|
||||
c0[i] = y;
|
||||
c1[i] = u;
|
||||
c2[i] = v;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse reversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_decode(
|
||||
int* restrict c0,
|
||||
int* restrict c1,
|
||||
int* restrict c2,
|
||||
int n)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < n; ++i) {
|
||||
int y = c0[i];
|
||||
int u = c1[i];
|
||||
int v = c2[i];
|
||||
int g = y - ((u + v) >> 2);
|
||||
int r = v + g;
|
||||
int b = u + g;
|
||||
c0[i] = r;
|
||||
c1[i] = g;
|
||||
c2[i] = b;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of basis function of reversible MCT. */
|
||||
/* </summary> */
|
||||
double mct_getnorm(int compno) {
|
||||
return mct_norms[compno];
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Foward irreversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_encode_real(
|
||||
int* restrict c0,
|
||||
int* restrict c1,
|
||||
int* restrict c2,
|
||||
int n)
|
||||
{
|
||||
int i;
|
||||
for(i = 0; i < n; ++i) {
|
||||
int r = c0[i];
|
||||
int g = c1[i];
|
||||
int b = c2[i];
|
||||
int y = fix_mul(r, 2449) + fix_mul(g, 4809) + fix_mul(b, 934);
|
||||
int u = -fix_mul(r, 1382) - fix_mul(g, 2714) + fix_mul(b, 4096);
|
||||
int v = fix_mul(r, 4096) - fix_mul(g, 3430) - fix_mul(b, 666);
|
||||
c0[i] = y;
|
||||
c1[i] = u;
|
||||
c2[i] = v;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse irreversible MCT. */
|
||||
/* </summary> */
|
||||
void mct_decode_real(
|
||||
float* restrict c0,
|
||||
float* restrict c1,
|
||||
float* restrict c2,
|
||||
int n)
|
||||
{
|
||||
int i;
|
||||
#ifdef __SSE__
|
||||
__m128 vrv, vgu, vgv, vbu;
|
||||
vrv = _mm_set1_ps(1.402f);
|
||||
vgu = _mm_set1_ps(0.34413f);
|
||||
vgv = _mm_set1_ps(0.71414f);
|
||||
vbu = _mm_set1_ps(1.772f);
|
||||
for (i = 0; i < (n >> 3); ++i) {
|
||||
__m128 vy, vu, vv;
|
||||
__m128 vr, vg, vb;
|
||||
|
||||
vy = _mm_load_ps(c0);
|
||||
vu = _mm_load_ps(c1);
|
||||
vv = _mm_load_ps(c2);
|
||||
vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
|
||||
vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
|
||||
vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
|
||||
_mm_store_ps(c0, vr);
|
||||
_mm_store_ps(c1, vg);
|
||||
_mm_store_ps(c2, vb);
|
||||
c0 += 4;
|
||||
c1 += 4;
|
||||
c2 += 4;
|
||||
|
||||
vy = _mm_load_ps(c0);
|
||||
vu = _mm_load_ps(c1);
|
||||
vv = _mm_load_ps(c2);
|
||||
vr = _mm_add_ps(vy, _mm_mul_ps(vv, vrv));
|
||||
vg = _mm_sub_ps(_mm_sub_ps(vy, _mm_mul_ps(vu, vgu)), _mm_mul_ps(vv, vgv));
|
||||
vb = _mm_add_ps(vy, _mm_mul_ps(vu, vbu));
|
||||
_mm_store_ps(c0, vr);
|
||||
_mm_store_ps(c1, vg);
|
||||
_mm_store_ps(c2, vb);
|
||||
c0 += 4;
|
||||
c1 += 4;
|
||||
c2 += 4;
|
||||
}
|
||||
n &= 7;
|
||||
#endif
|
||||
for(i = 0; i < n; ++i) {
|
||||
float y = c0[i];
|
||||
float u = c1[i];
|
||||
float v = c2[i];
|
||||
float r = y + (v * 1.402f);
|
||||
float g = y - (u * 0.34413f) - (v * (0.71414f));
|
||||
float b = y + (u * 1.772f);
|
||||
c0[i] = r;
|
||||
c1[i] = g;
|
||||
c2[i] = b;
|
||||
}
|
||||
}
|
||||
|
||||
/* <summary> */
|
||||
/* Get norm of basis function of irreversible MCT. */
|
||||
/* </summary> */
|
||||
double mct_getnorm_real(int compno) {
|
||||
return mct_norms_real[compno];
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __MCT_H
|
||||
#define __MCT_H
|
||||
/**
|
||||
@file mct.h
|
||||
@brief Implementation of a multi-component transforms (MCT)
|
||||
|
||||
The functions in MCT.C have for goal to realize reversible and irreversible multicomponent
|
||||
transform. The functions in MCT.C are used by some function in TCD.C.
|
||||
*/
|
||||
|
||||
/** @defgroup MCT MCT - Implementation of a multi-component transform */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Apply a reversible multi-component transform to an image
|
||||
@param c0 Samples for red component
|
||||
@param c1 Samples for green component
|
||||
@param c2 Samples blue component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void mct_encode(int *c0, int *c1, int *c2, int n);
|
||||
/**
|
||||
Apply a reversible multi-component inverse transform to an image
|
||||
@param c0 Samples for luminance component
|
||||
@param c1 Samples for red chrominance component
|
||||
@param c2 Samples for blue chrominance component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void mct_decode(int *c0, int *c1, int *c2, int n);
|
||||
/**
|
||||
Get norm of the basis function used for the reversible multi-component transform
|
||||
@param compno Number of the component (0->Y, 1->U, 2->V)
|
||||
@return
|
||||
*/
|
||||
double mct_getnorm(int compno);
|
||||
|
||||
/**
|
||||
Apply an irreversible multi-component transform to an image
|
||||
@param c0 Samples for red component
|
||||
@param c1 Samples for green component
|
||||
@param c2 Samples blue component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void mct_encode_real(int *c0, int *c1, int *c2, int n);
|
||||
/**
|
||||
Apply an irreversible multi-component inverse transform to an image
|
||||
@param c0 Samples for luminance component
|
||||
@param c1 Samples for red chrominance component
|
||||
@param c2 Samples for blue chrominance component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void mct_decode_real(float* c0, float* c1, float* c2, int n);
|
||||
/**
|
||||
Get norm of the basis function used for the irreversible multi-component transform
|
||||
@param compno Number of the component (0->Y, 1->U, 2->V)
|
||||
@return
|
||||
*/
|
||||
double mct_getnorm_real(int compno);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __MCT_H */
|
||||
@@ -1,592 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup MQC MQC - Implementation of an MQ-Coder */
|
||||
/*@{*/
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Output a byte, doing bit-stuffing if necessary.
|
||||
After a 0xff byte, the next byte must be smaller than 0x90.
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static void mqc_byteout(opj_mqc_t *mqc);
|
||||
/**
|
||||
Renormalize mqc->a and mqc->c while encoding, so that mqc->a stays between 0x8000 and 0x10000
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static void mqc_renorme(opj_mqc_t *mqc);
|
||||
/**
|
||||
Encode the most probable symbol
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static void mqc_codemps(opj_mqc_t *mqc);
|
||||
/**
|
||||
Encode the most least symbol
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static void mqc_codelps(opj_mqc_t *mqc);
|
||||
/**
|
||||
Fill mqc->c with 1's for flushing
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static void mqc_setbits(opj_mqc_t *mqc);
|
||||
/**
|
||||
FIXME: documentation ???
|
||||
@param mqc MQC handle
|
||||
@return
|
||||
*/
|
||||
static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc);
|
||||
/**
|
||||
FIXME: documentation ???
|
||||
@param mqc MQC handle
|
||||
@return
|
||||
*/
|
||||
static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc);
|
||||
/**
|
||||
Input a byte
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static INLINE void mqc_bytein(opj_mqc_t *const mqc);
|
||||
/**
|
||||
Renormalize mqc->a and mqc->c while decoding
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
static INLINE void mqc_renormd(opj_mqc_t *const mqc);
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/* <summary> */
|
||||
/* This array defines all the possible states for a context. */
|
||||
/* </summary> */
|
||||
static opj_mqc_state_t mqc_states[47 * 2] = {
|
||||
{0x5601, 0, &mqc_states[2], &mqc_states[3]},
|
||||
{0x5601, 1, &mqc_states[3], &mqc_states[2]},
|
||||
{0x3401, 0, &mqc_states[4], &mqc_states[12]},
|
||||
{0x3401, 1, &mqc_states[5], &mqc_states[13]},
|
||||
{0x1801, 0, &mqc_states[6], &mqc_states[18]},
|
||||
{0x1801, 1, &mqc_states[7], &mqc_states[19]},
|
||||
{0x0ac1, 0, &mqc_states[8], &mqc_states[24]},
|
||||
{0x0ac1, 1, &mqc_states[9], &mqc_states[25]},
|
||||
{0x0521, 0, &mqc_states[10], &mqc_states[58]},
|
||||
{0x0521, 1, &mqc_states[11], &mqc_states[59]},
|
||||
{0x0221, 0, &mqc_states[76], &mqc_states[66]},
|
||||
{0x0221, 1, &mqc_states[77], &mqc_states[67]},
|
||||
{0x5601, 0, &mqc_states[14], &mqc_states[13]},
|
||||
{0x5601, 1, &mqc_states[15], &mqc_states[12]},
|
||||
{0x5401, 0, &mqc_states[16], &mqc_states[28]},
|
||||
{0x5401, 1, &mqc_states[17], &mqc_states[29]},
|
||||
{0x4801, 0, &mqc_states[18], &mqc_states[28]},
|
||||
{0x4801, 1, &mqc_states[19], &mqc_states[29]},
|
||||
{0x3801, 0, &mqc_states[20], &mqc_states[28]},
|
||||
{0x3801, 1, &mqc_states[21], &mqc_states[29]},
|
||||
{0x3001, 0, &mqc_states[22], &mqc_states[34]},
|
||||
{0x3001, 1, &mqc_states[23], &mqc_states[35]},
|
||||
{0x2401, 0, &mqc_states[24], &mqc_states[36]},
|
||||
{0x2401, 1, &mqc_states[25], &mqc_states[37]},
|
||||
{0x1c01, 0, &mqc_states[26], &mqc_states[40]},
|
||||
{0x1c01, 1, &mqc_states[27], &mqc_states[41]},
|
||||
{0x1601, 0, &mqc_states[58], &mqc_states[42]},
|
||||
{0x1601, 1, &mqc_states[59], &mqc_states[43]},
|
||||
{0x5601, 0, &mqc_states[30], &mqc_states[29]},
|
||||
{0x5601, 1, &mqc_states[31], &mqc_states[28]},
|
||||
{0x5401, 0, &mqc_states[32], &mqc_states[28]},
|
||||
{0x5401, 1, &mqc_states[33], &mqc_states[29]},
|
||||
{0x5101, 0, &mqc_states[34], &mqc_states[30]},
|
||||
{0x5101, 1, &mqc_states[35], &mqc_states[31]},
|
||||
{0x4801, 0, &mqc_states[36], &mqc_states[32]},
|
||||
{0x4801, 1, &mqc_states[37], &mqc_states[33]},
|
||||
{0x3801, 0, &mqc_states[38], &mqc_states[34]},
|
||||
{0x3801, 1, &mqc_states[39], &mqc_states[35]},
|
||||
{0x3401, 0, &mqc_states[40], &mqc_states[36]},
|
||||
{0x3401, 1, &mqc_states[41], &mqc_states[37]},
|
||||
{0x3001, 0, &mqc_states[42], &mqc_states[38]},
|
||||
{0x3001, 1, &mqc_states[43], &mqc_states[39]},
|
||||
{0x2801, 0, &mqc_states[44], &mqc_states[38]},
|
||||
{0x2801, 1, &mqc_states[45], &mqc_states[39]},
|
||||
{0x2401, 0, &mqc_states[46], &mqc_states[40]},
|
||||
{0x2401, 1, &mqc_states[47], &mqc_states[41]},
|
||||
{0x2201, 0, &mqc_states[48], &mqc_states[42]},
|
||||
{0x2201, 1, &mqc_states[49], &mqc_states[43]},
|
||||
{0x1c01, 0, &mqc_states[50], &mqc_states[44]},
|
||||
{0x1c01, 1, &mqc_states[51], &mqc_states[45]},
|
||||
{0x1801, 0, &mqc_states[52], &mqc_states[46]},
|
||||
{0x1801, 1, &mqc_states[53], &mqc_states[47]},
|
||||
{0x1601, 0, &mqc_states[54], &mqc_states[48]},
|
||||
{0x1601, 1, &mqc_states[55], &mqc_states[49]},
|
||||
{0x1401, 0, &mqc_states[56], &mqc_states[50]},
|
||||
{0x1401, 1, &mqc_states[57], &mqc_states[51]},
|
||||
{0x1201, 0, &mqc_states[58], &mqc_states[52]},
|
||||
{0x1201, 1, &mqc_states[59], &mqc_states[53]},
|
||||
{0x1101, 0, &mqc_states[60], &mqc_states[54]},
|
||||
{0x1101, 1, &mqc_states[61], &mqc_states[55]},
|
||||
{0x0ac1, 0, &mqc_states[62], &mqc_states[56]},
|
||||
{0x0ac1, 1, &mqc_states[63], &mqc_states[57]},
|
||||
{0x09c1, 0, &mqc_states[64], &mqc_states[58]},
|
||||
{0x09c1, 1, &mqc_states[65], &mqc_states[59]},
|
||||
{0x08a1, 0, &mqc_states[66], &mqc_states[60]},
|
||||
{0x08a1, 1, &mqc_states[67], &mqc_states[61]},
|
||||
{0x0521, 0, &mqc_states[68], &mqc_states[62]},
|
||||
{0x0521, 1, &mqc_states[69], &mqc_states[63]},
|
||||
{0x0441, 0, &mqc_states[70], &mqc_states[64]},
|
||||
{0x0441, 1, &mqc_states[71], &mqc_states[65]},
|
||||
{0x02a1, 0, &mqc_states[72], &mqc_states[66]},
|
||||
{0x02a1, 1, &mqc_states[73], &mqc_states[67]},
|
||||
{0x0221, 0, &mqc_states[74], &mqc_states[68]},
|
||||
{0x0221, 1, &mqc_states[75], &mqc_states[69]},
|
||||
{0x0141, 0, &mqc_states[76], &mqc_states[70]},
|
||||
{0x0141, 1, &mqc_states[77], &mqc_states[71]},
|
||||
{0x0111, 0, &mqc_states[78], &mqc_states[72]},
|
||||
{0x0111, 1, &mqc_states[79], &mqc_states[73]},
|
||||
{0x0085, 0, &mqc_states[80], &mqc_states[74]},
|
||||
{0x0085, 1, &mqc_states[81], &mqc_states[75]},
|
||||
{0x0049, 0, &mqc_states[82], &mqc_states[76]},
|
||||
{0x0049, 1, &mqc_states[83], &mqc_states[77]},
|
||||
{0x0025, 0, &mqc_states[84], &mqc_states[78]},
|
||||
{0x0025, 1, &mqc_states[85], &mqc_states[79]},
|
||||
{0x0015, 0, &mqc_states[86], &mqc_states[80]},
|
||||
{0x0015, 1, &mqc_states[87], &mqc_states[81]},
|
||||
{0x0009, 0, &mqc_states[88], &mqc_states[82]},
|
||||
{0x0009, 1, &mqc_states[89], &mqc_states[83]},
|
||||
{0x0005, 0, &mqc_states[90], &mqc_states[84]},
|
||||
{0x0005, 1, &mqc_states[91], &mqc_states[85]},
|
||||
{0x0001, 0, &mqc_states[90], &mqc_states[86]},
|
||||
{0x0001, 1, &mqc_states[91], &mqc_states[87]},
|
||||
{0x5601, 0, &mqc_states[92], &mqc_states[92]},
|
||||
{0x5601, 1, &mqc_states[93], &mqc_states[93]},
|
||||
};
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static void mqc_byteout(opj_mqc_t *mqc) {
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c >> 20;
|
||||
mqc->c &= 0xfffff;
|
||||
mqc->ct = 7;
|
||||
} else {
|
||||
if ((mqc->c & 0x8000000) == 0) { /* ((mqc->c&0x8000000)==0) CHANGE */
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c >> 19;
|
||||
mqc->c &= 0x7ffff;
|
||||
mqc->ct = 8;
|
||||
} else {
|
||||
(*mqc->bp)++;
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->c &= 0x7ffffff;
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c >> 20;
|
||||
mqc->c &= 0xfffff;
|
||||
mqc->ct = 7;
|
||||
} else {
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c >> 19;
|
||||
mqc->c &= 0x7ffff;
|
||||
mqc->ct = 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void mqc_renorme(opj_mqc_t *mqc) {
|
||||
do {
|
||||
mqc->a <<= 1;
|
||||
mqc->c <<= 1;
|
||||
mqc->ct--;
|
||||
if (mqc->ct == 0) {
|
||||
mqc_byteout(mqc);
|
||||
}
|
||||
} while ((mqc->a & 0x8000) == 0);
|
||||
}
|
||||
|
||||
static void mqc_codemps(opj_mqc_t *mqc) {
|
||||
mqc->a -= (*mqc->curctx)->qeval;
|
||||
if ((mqc->a & 0x8000) == 0) {
|
||||
if (mqc->a < (*mqc->curctx)->qeval) {
|
||||
mqc->a = (*mqc->curctx)->qeval;
|
||||
} else {
|
||||
mqc->c += (*mqc->curctx)->qeval;
|
||||
}
|
||||
*mqc->curctx = (*mqc->curctx)->nmps;
|
||||
mqc_renorme(mqc);
|
||||
} else {
|
||||
mqc->c += (*mqc->curctx)->qeval;
|
||||
}
|
||||
}
|
||||
|
||||
static void mqc_codelps(opj_mqc_t *mqc) {
|
||||
mqc->a -= (*mqc->curctx)->qeval;
|
||||
if (mqc->a < (*mqc->curctx)->qeval) {
|
||||
mqc->c += (*mqc->curctx)->qeval;
|
||||
} else {
|
||||
mqc->a = (*mqc->curctx)->qeval;
|
||||
}
|
||||
*mqc->curctx = (*mqc->curctx)->nlps;
|
||||
mqc_renorme(mqc);
|
||||
}
|
||||
|
||||
static void mqc_setbits(opj_mqc_t *mqc) {
|
||||
unsigned int tempc = mqc->c + mqc->a;
|
||||
mqc->c |= 0xffff;
|
||||
if (mqc->c >= tempc) {
|
||||
mqc->c -= 0x8000;
|
||||
}
|
||||
}
|
||||
|
||||
static INLINE int mqc_mpsexchange(opj_mqc_t *const mqc) {
|
||||
int d;
|
||||
if (mqc->a < (*mqc->curctx)->qeval) {
|
||||
d = 1 - (*mqc->curctx)->mps;
|
||||
*mqc->curctx = (*mqc->curctx)->nlps;
|
||||
} else {
|
||||
d = (*mqc->curctx)->mps;
|
||||
*mqc->curctx = (*mqc->curctx)->nmps;
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
static INLINE int mqc_lpsexchange(opj_mqc_t *const mqc) {
|
||||
int d;
|
||||
if (mqc->a < (*mqc->curctx)->qeval) {
|
||||
mqc->a = (*mqc->curctx)->qeval;
|
||||
d = (*mqc->curctx)->mps;
|
||||
*mqc->curctx = (*mqc->curctx)->nmps;
|
||||
} else {
|
||||
mqc->a = (*mqc->curctx)->qeval;
|
||||
d = 1 - (*mqc->curctx)->mps;
|
||||
*mqc->curctx = (*mqc->curctx)->nlps;
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
#ifdef MQC_PERF_OPT
|
||||
static INLINE void mqc_bytein(opj_mqc_t *const mqc) {
|
||||
unsigned int i = *((unsigned int *) mqc->bp);
|
||||
mqc->c += i & 0xffff00;
|
||||
mqc->ct = i & 0x0f;
|
||||
mqc->bp += (i >> 2) & 0x04;
|
||||
}
|
||||
#else
|
||||
static void mqc_bytein(opj_mqc_t *const mqc) {
|
||||
if (mqc->bp != mqc->end) {
|
||||
unsigned int c;
|
||||
if (mqc->bp + 1 != mqc->end) {
|
||||
c = *(mqc->bp + 1);
|
||||
} else {
|
||||
c = 0xff;
|
||||
}
|
||||
if (*mqc->bp == 0xff) {
|
||||
if (c > 0x8f) {
|
||||
mqc->c += 0xff00;
|
||||
mqc->ct = 8;
|
||||
} else {
|
||||
mqc->bp++;
|
||||
mqc->c += c << 9;
|
||||
mqc->ct = 7;
|
||||
}
|
||||
} else {
|
||||
mqc->bp++;
|
||||
mqc->c += c << 8;
|
||||
mqc->ct = 8;
|
||||
}
|
||||
} else {
|
||||
mqc->c += 0xff00;
|
||||
mqc->ct = 8;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static INLINE void mqc_renormd(opj_mqc_t *const mqc) {
|
||||
do {
|
||||
if (mqc->ct == 0) {
|
||||
mqc_bytein(mqc);
|
||||
}
|
||||
mqc->a <<= 1;
|
||||
mqc->c <<= 1;
|
||||
mqc->ct--;
|
||||
} while (mqc->a < 0x8000);
|
||||
}
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
MQ-Coder interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_mqc_t* mqc_create(void) {
|
||||
opj_mqc_t *mqc = (opj_mqc_t*)opj_malloc(sizeof(opj_mqc_t));
|
||||
#ifdef MQC_PERF_OPT
|
||||
mqc->buffer = NULL;
|
||||
#endif
|
||||
return mqc;
|
||||
}
|
||||
|
||||
void mqc_destroy(opj_mqc_t *mqc) {
|
||||
if(mqc) {
|
||||
#ifdef MQC_PERF_OPT
|
||||
if (mqc->buffer) {
|
||||
opj_free(mqc->buffer);
|
||||
}
|
||||
#endif
|
||||
opj_free(mqc);
|
||||
}
|
||||
}
|
||||
|
||||
int mqc_numbytes(opj_mqc_t *mqc) {
|
||||
return mqc->bp - mqc->start;
|
||||
}
|
||||
|
||||
void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp) {
|
||||
mqc_setcurctx(mqc, 0);
|
||||
mqc->a = 0x8000;
|
||||
mqc->c = 0;
|
||||
mqc->bp = bp - 1;
|
||||
mqc->ct = 12;
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->ct = 13;
|
||||
}
|
||||
mqc->start = bp;
|
||||
}
|
||||
|
||||
void mqc_encode(opj_mqc_t *mqc, int d) {
|
||||
if ((*mqc->curctx)->mps == d) {
|
||||
mqc_codemps(mqc);
|
||||
} else {
|
||||
mqc_codelps(mqc);
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_flush(opj_mqc_t *mqc) {
|
||||
mqc_setbits(mqc);
|
||||
mqc->c <<= mqc->ct;
|
||||
mqc_byteout(mqc);
|
||||
mqc->c <<= mqc->ct;
|
||||
mqc_byteout(mqc);
|
||||
|
||||
if (*mqc->bp != 0xff) {
|
||||
mqc->bp++;
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_bypass_init_enc(opj_mqc_t *mqc) {
|
||||
mqc->c = 0;
|
||||
mqc->ct = 8;
|
||||
/*if (*mqc->bp == 0xff) {
|
||||
mqc->ct = 7;
|
||||
} */
|
||||
}
|
||||
|
||||
void mqc_bypass_enc(opj_mqc_t *mqc, int d) {
|
||||
mqc->ct--;
|
||||
mqc->c = mqc->c + (d << mqc->ct);
|
||||
if (mqc->ct == 0) {
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c;
|
||||
mqc->ct = 8;
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->ct = 7;
|
||||
}
|
||||
mqc->c = 0;
|
||||
}
|
||||
}
|
||||
|
||||
int mqc_bypass_flush_enc(opj_mqc_t *mqc) {
|
||||
unsigned char bit_padding;
|
||||
|
||||
bit_padding = 0;
|
||||
|
||||
if (mqc->ct != 0) {
|
||||
while (mqc->ct > 0) {
|
||||
mqc->ct--;
|
||||
mqc->c += bit_padding << mqc->ct;
|
||||
bit_padding = (bit_padding + 1) & 0x01;
|
||||
}
|
||||
mqc->bp++;
|
||||
*mqc->bp = mqc->c;
|
||||
mqc->ct = 8;
|
||||
mqc->c = 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void mqc_reset_enc(opj_mqc_t *mqc) {
|
||||
mqc_resetstates(mqc);
|
||||
mqc_setstate(mqc, T1_CTXNO_UNI, 0, 46);
|
||||
mqc_setstate(mqc, T1_CTXNO_AGG, 0, 3);
|
||||
mqc_setstate(mqc, T1_CTXNO_ZC, 0, 4);
|
||||
}
|
||||
|
||||
int mqc_restart_enc(opj_mqc_t *mqc) {
|
||||
int correction = 1;
|
||||
|
||||
/* <flush part> */
|
||||
int n = 27 - 15 - mqc->ct;
|
||||
mqc->c <<= mqc->ct;
|
||||
while (n > 0) {
|
||||
mqc_byteout(mqc);
|
||||
n -= mqc->ct;
|
||||
mqc->c <<= mqc->ct;
|
||||
}
|
||||
mqc_byteout(mqc);
|
||||
|
||||
return correction;
|
||||
}
|
||||
|
||||
void mqc_restart_init_enc(opj_mqc_t *mqc) {
|
||||
/* <Re-init part> */
|
||||
mqc_setcurctx(mqc, 0);
|
||||
mqc->a = 0x8000;
|
||||
mqc->c = 0;
|
||||
mqc->ct = 12;
|
||||
mqc->bp--;
|
||||
if (*mqc->bp == 0xff) {
|
||||
mqc->ct = 13;
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_erterm_enc(opj_mqc_t *mqc) {
|
||||
int k = 11 - mqc->ct + 1;
|
||||
|
||||
while (k > 0) {
|
||||
mqc->c <<= mqc->ct;
|
||||
mqc->ct = 0;
|
||||
mqc_byteout(mqc);
|
||||
k -= mqc->ct;
|
||||
}
|
||||
|
||||
if (*mqc->bp != 0xff) {
|
||||
mqc_byteout(mqc);
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_segmark_enc(opj_mqc_t *mqc) {
|
||||
int i;
|
||||
mqc_setcurctx(mqc, 18);
|
||||
|
||||
for (i = 1; i < 5; i++) {
|
||||
mqc_encode(mqc, i % 2);
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len) {
|
||||
mqc_setcurctx(mqc, 0);
|
||||
mqc->start = bp;
|
||||
mqc->end = bp + len;
|
||||
mqc->bp = bp;
|
||||
if (len==0) mqc->c = 0xff << 16;
|
||||
else mqc->c = *mqc->bp << 16;
|
||||
|
||||
#ifdef MQC_PERF_OPT
|
||||
{
|
||||
unsigned int c;
|
||||
unsigned int *ip;
|
||||
unsigned char *end = mqc->end - 1;
|
||||
mqc->buffer = opj_realloc(mqc->buffer, (len + 1) * sizeof(unsigned int));
|
||||
ip = (unsigned int *) mqc->buffer;
|
||||
|
||||
while (bp < end) {
|
||||
c = *(bp + 1);
|
||||
if (*bp == 0xff) {
|
||||
if (c > 0x8f) {
|
||||
break;
|
||||
} else {
|
||||
*ip = 0x00000017 | (c << 9);
|
||||
}
|
||||
} else {
|
||||
*ip = 0x00000018 | (c << 8);
|
||||
}
|
||||
bp++;
|
||||
ip++;
|
||||
}
|
||||
|
||||
/* Handle last byte of data */
|
||||
c = 0xff;
|
||||
if (*bp == 0xff) {
|
||||
*ip = 0x0000ff18;
|
||||
} else {
|
||||
bp++;
|
||||
*ip = 0x00000018 | (c << 8);
|
||||
}
|
||||
ip++;
|
||||
|
||||
*ip = 0x0000ff08;
|
||||
mqc->bp = mqc->buffer;
|
||||
}
|
||||
#endif
|
||||
mqc_bytein(mqc);
|
||||
mqc->c <<= 7;
|
||||
mqc->ct -= 7;
|
||||
mqc->a = 0x8000;
|
||||
}
|
||||
|
||||
int mqc_decode(opj_mqc_t *const mqc) {
|
||||
int d;
|
||||
mqc->a -= (*mqc->curctx)->qeval;
|
||||
if ((mqc->c >> 16) < (*mqc->curctx)->qeval) {
|
||||
d = mqc_lpsexchange(mqc);
|
||||
mqc_renormd(mqc);
|
||||
} else {
|
||||
mqc->c -= (*mqc->curctx)->qeval << 16;
|
||||
if ((mqc->a & 0x8000) == 0) {
|
||||
d = mqc_mpsexchange(mqc);
|
||||
mqc_renormd(mqc);
|
||||
} else {
|
||||
d = (*mqc->curctx)->mps;
|
||||
}
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
void mqc_resetstates(opj_mqc_t *mqc) {
|
||||
int i;
|
||||
for (i = 0; i < MQC_NUMCTXS; i++) {
|
||||
mqc->ctxs[i] = mqc_states;
|
||||
}
|
||||
}
|
||||
|
||||
void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob) {
|
||||
mqc->ctxs[ctxno] = &mqc_states[msb + (prob << 1)];
|
||||
}
|
||||
|
||||
|
||||
@@ -1,200 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __MQC_H
|
||||
#define __MQC_H
|
||||
/**
|
||||
@file mqc.h
|
||||
@brief Implementation of an MQ-Coder (MQC)
|
||||
|
||||
The functions in MQC.C have for goal to realize the MQ-coder operations. The functions
|
||||
in MQC.C are used by some function in T1.C.
|
||||
*/
|
||||
|
||||
/** @defgroup MQC MQC - Implementation of an MQ-Coder */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
This struct defines the state of a context.
|
||||
*/
|
||||
typedef struct opj_mqc_state {
|
||||
/** the probability of the Least Probable Symbol (0.75->0x8000, 1.5->0xffff) */
|
||||
unsigned int qeval;
|
||||
/** the Most Probable Symbol (0 or 1) */
|
||||
int mps;
|
||||
/** next state if the next encoded symbol is the MPS */
|
||||
struct opj_mqc_state *nmps;
|
||||
/** next state if the next encoded symbol is the LPS */
|
||||
struct opj_mqc_state *nlps;
|
||||
} opj_mqc_state_t;
|
||||
|
||||
#define MQC_NUMCTXS 19
|
||||
|
||||
/**
|
||||
MQ coder
|
||||
*/
|
||||
typedef struct opj_mqc {
|
||||
unsigned int c;
|
||||
unsigned int a;
|
||||
unsigned int ct;
|
||||
unsigned char *bp;
|
||||
unsigned char *start;
|
||||
unsigned char *end;
|
||||
opj_mqc_state_t *ctxs[MQC_NUMCTXS];
|
||||
opj_mqc_state_t **curctx;
|
||||
#ifdef MQC_PERF_OPT
|
||||
unsigned char *buffer;
|
||||
#endif
|
||||
} opj_mqc_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new MQC handle
|
||||
@return Returns a new MQC handle if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_mqc_t* mqc_create(void);
|
||||
/**
|
||||
Destroy a previously created MQC handle
|
||||
@param mqc MQC handle to destroy
|
||||
*/
|
||||
void mqc_destroy(opj_mqc_t *mqc);
|
||||
/**
|
||||
Return the number of bytes written/read since initialisation
|
||||
@param mqc MQC handle
|
||||
@return Returns the number of bytes already encoded
|
||||
*/
|
||||
int mqc_numbytes(opj_mqc_t *mqc);
|
||||
/**
|
||||
Reset the states of all the context of the coder/decoder
|
||||
(each context is set to a state where 0 and 1 are more or less equiprobable)
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_resetstates(opj_mqc_t *mqc);
|
||||
/**
|
||||
Set the state of a particular context
|
||||
@param mqc MQC handle
|
||||
@param ctxno Number that identifies the context
|
||||
@param msb The MSB of the new state of the context
|
||||
@param prob Number that identifies the probability of the symbols for the new state of the context
|
||||
*/
|
||||
void mqc_setstate(opj_mqc_t *mqc, int ctxno, int msb, int prob);
|
||||
/**
|
||||
Initialize the encoder
|
||||
@param mqc MQC handle
|
||||
@param bp Pointer to the start of the buffer where the bytes will be written
|
||||
*/
|
||||
void mqc_init_enc(opj_mqc_t *mqc, unsigned char *bp);
|
||||
/**
|
||||
Set the current context used for coding/decoding
|
||||
@param mqc MQC handle
|
||||
@param ctxno Number that identifies the context
|
||||
*/
|
||||
#define mqc_setcurctx(mqc, ctxno) (mqc)->curctx = &(mqc)->ctxs[(int)(ctxno)]
|
||||
/**
|
||||
Encode a symbol using the MQ-coder
|
||||
@param mqc MQC handle
|
||||
@param d The symbol to be encoded (0 or 1)
|
||||
*/
|
||||
void mqc_encode(opj_mqc_t *mqc, int d);
|
||||
/**
|
||||
Flush the encoder, so that all remaining data is written
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_flush(opj_mqc_t *mqc);
|
||||
/**
|
||||
BYPASS mode switch, initialization operation.
|
||||
JPEG 2000 p 505.
|
||||
<h2>Not fully implemented and tested !!</h2>
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_bypass_init_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
BYPASS mode switch, coding operation.
|
||||
JPEG 2000 p 505.
|
||||
<h2>Not fully implemented and tested !!</h2>
|
||||
@param mqc MQC handle
|
||||
@param d The symbol to be encoded (0 or 1)
|
||||
*/
|
||||
void mqc_bypass_enc(opj_mqc_t *mqc, int d);
|
||||
/**
|
||||
BYPASS mode switch, flush operation
|
||||
<h2>Not fully implemented and tested !!</h2>
|
||||
@param mqc MQC handle
|
||||
@return Returns 1 (always)
|
||||
*/
|
||||
int mqc_bypass_flush_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESET mode switch
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_reset_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESTART mode switch (TERMALL)
|
||||
@param mqc MQC handle
|
||||
@return Returns 1 (always)
|
||||
*/
|
||||
int mqc_restart_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
RESTART mode switch (TERMALL) reinitialisation
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_restart_init_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
ERTERM mode switch (PTERM)
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_erterm_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
SEGMARK mode switch (SEGSYM)
|
||||
@param mqc MQC handle
|
||||
*/
|
||||
void mqc_segmark_enc(opj_mqc_t *mqc);
|
||||
/**
|
||||
Initialize the decoder
|
||||
@param mqc MQC handle
|
||||
@param bp Pointer to the start of the buffer from which the bytes will be read
|
||||
@param len Length of the input buffer
|
||||
*/
|
||||
void mqc_init_dec(opj_mqc_t *mqc, unsigned char *bp, int len);
|
||||
/**
|
||||
Decode a symbol
|
||||
@param mqc MQC handle
|
||||
@return Returns the decoded symbol (0 or 1)
|
||||
*/
|
||||
int mqc_decode(opj_mqc_t *const mqc);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __MQC_H */
|
||||
@@ -1,48 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __IMAGE_H
|
||||
#define __IMAGE_H
|
||||
/**
|
||||
@file image.h
|
||||
@brief Implementation of operations on images (IMAGE)
|
||||
|
||||
The functions in IMAGE.C have for goal to realize operations on images.
|
||||
*/
|
||||
|
||||
/** @defgroup IMAGE IMAGE - Implementation of operations on images */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Create an empty image
|
||||
@todo this function should be removed
|
||||
@return returns an empty image if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_image_t* opj_image_create0(void);
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __IMAGE_H */
|
||||
|
||||
@@ -1,343 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif /* _WIN32 */
|
||||
|
||||
#include "opj_config.h"
|
||||
#include "opj_includes.h"
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
#ifdef _WIN32
|
||||
#ifndef OPJ_STATIC
|
||||
BOOL APIENTRY
|
||||
DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
|
||||
|
||||
OPJ_ARG_NOT_USED(lpReserved);
|
||||
OPJ_ARG_NOT_USED(hModule);
|
||||
|
||||
switch (ul_reason_for_call) {
|
||||
case DLL_PROCESS_ATTACH :
|
||||
break;
|
||||
case DLL_PROCESS_DETACH :
|
||||
break;
|
||||
case DLL_THREAD_ATTACH :
|
||||
case DLL_THREAD_DETACH :
|
||||
break;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
#endif /* OPJ_STATIC */
|
||||
#endif /* _WIN32 */
|
||||
|
||||
/* ---------------------------------------------------------------------- */
|
||||
|
||||
|
||||
const char* OPJ_CALLCONV opj_version(void) {
|
||||
return PACKAGE_VERSION;
|
||||
}
|
||||
|
||||
opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format) {
|
||||
opj_dinfo_t *dinfo = (opj_dinfo_t*)opj_calloc(1, sizeof(opj_dinfo_t));
|
||||
if(!dinfo) return NULL;
|
||||
dinfo->is_decompressor = OPJ_TRUE;
|
||||
switch(format) {
|
||||
case CODEC_J2K:
|
||||
case CODEC_JPT:
|
||||
/* get a J2K decoder handle */
|
||||
dinfo->j2k_handle = (void*)j2k_create_decompress((opj_common_ptr)dinfo);
|
||||
if(!dinfo->j2k_handle) {
|
||||
opj_free(dinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
/* get a JP2 decoder handle */
|
||||
dinfo->jp2_handle = (void*)jp2_create_decompress((opj_common_ptr)dinfo);
|
||||
if(!dinfo->jp2_handle) {
|
||||
opj_free(dinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
opj_free(dinfo);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
dinfo->codec_format = format;
|
||||
|
||||
return dinfo;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo) {
|
||||
if(dinfo) {
|
||||
/* destroy the codec */
|
||||
switch(dinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
case CODEC_JPT:
|
||||
j2k_destroy_decompress((opj_j2k_t*)dinfo->j2k_handle);
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
jp2_destroy_decompress((opj_jp2_t*)dinfo->jp2_handle);
|
||||
break;
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
/* destroy the decompressor */
|
||||
opj_free(dinfo);
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters) {
|
||||
if(parameters) {
|
||||
memset(parameters, 0, sizeof(opj_dparameters_t));
|
||||
/* default decoding parameters */
|
||||
parameters->cp_layer = 0;
|
||||
parameters->cp_reduce = 0;
|
||||
parameters->cp_limit_decoding = NO_LIMITATION;
|
||||
|
||||
parameters->decod_format = -1;
|
||||
parameters->cod_format = -1;
|
||||
parameters->flags = 0;
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
parameters->jpwl_correct = OPJ_FALSE;
|
||||
parameters->jpwl_exp_comps = JPWL_EXPECTED_COMPONENTS;
|
||||
parameters->jpwl_max_tiles = JPWL_MAXIMUM_TILES;
|
||||
#endif /* USE_JPWL */
|
||||
/* <<UniPG */
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters) {
|
||||
if(dinfo && parameters) {
|
||||
switch(dinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
case CODEC_JPT:
|
||||
j2k_setup_decoder((opj_j2k_t*)dinfo->j2k_handle, parameters);
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
jp2_setup_decoder((opj_jp2_t*)dinfo->jp2_handle, parameters);
|
||||
break;
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio) {
|
||||
return opj_decode_with_info(dinfo, cio, NULL);
|
||||
}
|
||||
|
||||
opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_cio_t *cio, opj_codestream_info_t *cstr_info) {
|
||||
if(dinfo && cio) {
|
||||
switch(dinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
return j2k_decode((opj_j2k_t*)dinfo->j2k_handle, cio, cstr_info);
|
||||
case CODEC_JPT:
|
||||
return j2k_decode_jpt_stream((opj_j2k_t*)dinfo->j2k_handle, cio, cstr_info);
|
||||
case CODEC_JP2:
|
||||
return opj_jp2_decode((opj_jp2_t*)dinfo->jp2_handle, cio, cstr_info);
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format) {
|
||||
opj_cinfo_t *cinfo = (opj_cinfo_t*)opj_calloc(1, sizeof(opj_cinfo_t));
|
||||
if(!cinfo) return NULL;
|
||||
cinfo->is_decompressor = OPJ_FALSE;
|
||||
switch(format) {
|
||||
case CODEC_J2K:
|
||||
/* get a J2K coder handle */
|
||||
cinfo->j2k_handle = (void*)j2k_create_compress((opj_common_ptr)cinfo);
|
||||
if(!cinfo->j2k_handle) {
|
||||
opj_free(cinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
/* get a JP2 coder handle */
|
||||
cinfo->jp2_handle = (void*)jp2_create_compress((opj_common_ptr)cinfo);
|
||||
if(!cinfo->jp2_handle) {
|
||||
opj_free(cinfo);
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case CODEC_JPT:
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
opj_free(cinfo);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
cinfo->codec_format = format;
|
||||
|
||||
return cinfo;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo) {
|
||||
if(cinfo) {
|
||||
/* destroy the codec */
|
||||
switch(cinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
j2k_destroy_compress((opj_j2k_t*)cinfo->j2k_handle);
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
jp2_destroy_compress((opj_jp2_t*)cinfo->jp2_handle);
|
||||
break;
|
||||
case CODEC_JPT:
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
/* destroy the decompressor */
|
||||
opj_free(cinfo);
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters) {
|
||||
if(parameters) {
|
||||
memset(parameters, 0, sizeof(opj_cparameters_t));
|
||||
/* default coding parameters */
|
||||
parameters->cp_cinema = OFF;
|
||||
parameters->max_comp_size = 0;
|
||||
parameters->numresolution = 6;
|
||||
parameters->cp_rsiz = STD_RSIZ;
|
||||
parameters->cblockw_init = 64;
|
||||
parameters->cblockh_init = 64;
|
||||
parameters->prog_order = LRCP;
|
||||
parameters->roi_compno = -1; /* no ROI */
|
||||
parameters->subsampling_dx = 1;
|
||||
parameters->subsampling_dy = 1;
|
||||
parameters->tp_on = 0;
|
||||
parameters->decod_format = -1;
|
||||
parameters->cod_format = -1;
|
||||
parameters->tcp_rates[0] = 0;
|
||||
parameters->tcp_numlayers = 0;
|
||||
parameters->cp_disto_alloc = 0;
|
||||
parameters->cp_fixed_alloc = 0;
|
||||
parameters->cp_fixed_quality = 0;
|
||||
parameters->jpip_on = OPJ_FALSE;
|
||||
/* UniPG>> */
|
||||
#ifdef USE_JPWL
|
||||
parameters->jpwl_epc_on = OPJ_FALSE;
|
||||
parameters->jpwl_hprot_MH = -1; /* -1 means unassigned */
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
|
||||
parameters->jpwl_hprot_TPH_tileno[i] = -1; /* unassigned */
|
||||
parameters->jpwl_hprot_TPH[i] = 0; /* absent */
|
||||
}
|
||||
};
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < JPWL_MAX_NO_PACKSPECS; i++) {
|
||||
parameters->jpwl_pprot_tileno[i] = -1; /* unassigned */
|
||||
parameters->jpwl_pprot_packno[i] = -1; /* unassigned */
|
||||
parameters->jpwl_pprot[i] = 0; /* absent */
|
||||
}
|
||||
};
|
||||
parameters->jpwl_sens_size = 0; /* 0 means no ESD */
|
||||
parameters->jpwl_sens_addr = 0; /* 0 means auto */
|
||||
parameters->jpwl_sens_range = 0; /* 0 means packet */
|
||||
parameters->jpwl_sens_MH = -1; /* -1 means unassigned */
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < JPWL_MAX_NO_TILESPECS; i++) {
|
||||
parameters->jpwl_sens_TPH_tileno[i] = -1; /* unassigned */
|
||||
parameters->jpwl_sens_TPH[i] = -1; /* absent */
|
||||
}
|
||||
};
|
||||
#endif /* USE_JPWL */
|
||||
/* <<UniPG */
|
||||
}
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image) {
|
||||
if(cinfo && parameters && image) {
|
||||
switch(cinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
j2k_setup_encoder((opj_j2k_t*)cinfo->j2k_handle, parameters, image);
|
||||
break;
|
||||
case CODEC_JP2:
|
||||
jp2_setup_encoder((opj_jp2_t*)cinfo->jp2_handle, parameters, image);
|
||||
break;
|
||||
case CODEC_JPT:
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
opj_bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index) {
|
||||
if (index != NULL)
|
||||
opj_event_msg((opj_common_ptr)cinfo, EVT_WARNING, "Set index to NULL when calling the opj_encode function.\n"
|
||||
"To extract the index, use the opj_encode_with_info() function.\n"
|
||||
"No index will be generated during this encoding\n");
|
||||
return opj_encode_with_info(cinfo, cio, image, NULL);
|
||||
}
|
||||
|
||||
opj_bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info) {
|
||||
if(cinfo && cio && image) {
|
||||
switch(cinfo->codec_format) {
|
||||
case CODEC_J2K:
|
||||
return j2k_encode((opj_j2k_t*)cinfo->j2k_handle, cio, image, cstr_info);
|
||||
case CODEC_JP2:
|
||||
return opj_jp2_encode((opj_jp2_t*)cinfo->jp2_handle, cio, image, cstr_info);
|
||||
case CODEC_JPT:
|
||||
case CODEC_UNKNOWN:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info) {
|
||||
if (cstr_info) {
|
||||
int tileno;
|
||||
for (tileno = 0; tileno < cstr_info->tw * cstr_info->th; tileno++) {
|
||||
opj_tile_info_t *tile_info = &cstr_info->tile[tileno];
|
||||
opj_free(tile_info->thresh);
|
||||
opj_free(tile_info->packet);
|
||||
opj_free(tile_info->tp);
|
||||
opj_free(tile_info->marker);
|
||||
}
|
||||
opj_free(cstr_info->tile);
|
||||
opj_free(cstr_info->marker);
|
||||
opj_free(cstr_info->numdecompos);
|
||||
}
|
||||
}
|
||||
@@ -1,914 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2006-2007, Parvatha Elangovan
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef OPENJPEG_H
|
||||
#define OPENJPEG_H
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Compiler directives
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
#if defined(OPJ_STATIC) || !defined(_WIN32)
|
||||
#define OPJ_API
|
||||
#define OPJ_CALLCONV
|
||||
#else
|
||||
#define OPJ_CALLCONV __stdcall
|
||||
/*
|
||||
The following ifdef block is the standard way of creating macros which make exporting
|
||||
from a DLL simpler. All files within this DLL are compiled with the OPJ_EXPORTS
|
||||
symbol defined on the command line. this symbol should not be defined on any project
|
||||
that uses this DLL. This way any other project whose source files include this file see
|
||||
OPJ_API functions as being imported from a DLL, wheras this DLL sees symbols
|
||||
defined with this macro as being exported.
|
||||
*/
|
||||
#if defined(OPJ_EXPORTS) || defined(DLL_EXPORT)
|
||||
#define OPJ_API __declspec(dllexport)
|
||||
#else
|
||||
#define OPJ_API __declspec(dllimport)
|
||||
#endif /* OPJ_EXPORTS */
|
||||
#endif /* !OPJ_STATIC || !_WIN32 */
|
||||
|
||||
typedef int opj_bool;
|
||||
#define OPJ_TRUE 1
|
||||
#define OPJ_FALSE 0
|
||||
|
||||
/* Avoid compile-time warning because parameter is not used */
|
||||
#define OPJ_ARG_NOT_USED(x) (void)(x)
|
||||
/*
|
||||
==========================================================
|
||||
Useful constant definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
#define OPJ_PATH_LEN 4096 /**< Maximum allowed size for filenames */
|
||||
|
||||
#define J2K_MAXRLVLS 33 /**< Number of maximum resolution level authorized */
|
||||
#define J2K_MAXBANDS (3*J2K_MAXRLVLS-2) /**< Number of maximum sub-band linked to number of resolution level */
|
||||
|
||||
/* UniPG>> */
|
||||
#define JPWL_MAX_NO_TILESPECS 16 /**< Maximum number of tile parts expected by JPWL: increase at your will */
|
||||
#define JPWL_MAX_NO_PACKSPECS 16 /**< Maximum number of packet parts expected by JPWL: increase at your will */
|
||||
#define JPWL_MAX_NO_MARKERS 512 /**< Maximum number of JPWL markers: increase at your will */
|
||||
#define JPWL_PRIVATEINDEX_NAME "jpwl_index_privatefilename" /**< index file name used when JPWL is on */
|
||||
#define JPWL_EXPECTED_COMPONENTS 3 /**< Expect this number of components, so you'll find better the first EPB */
|
||||
#define JPWL_MAXIMUM_TILES 8192 /**< Expect this maximum number of tiles, to avoid some crashes */
|
||||
#define JPWL_MAXIMUM_HAMMING 2 /**< Expect this maximum number of bit errors in marker id's */
|
||||
#define JPWL_MAXIMUM_EPB_ROOM 65450 /**< Expect this maximum number of bytes for composition of EPBs */
|
||||
/* <<UniPG */
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
enum definitions
|
||||
==========================================================
|
||||
*/
|
||||
/**
|
||||
Rsiz Capabilities
|
||||
*/
|
||||
typedef enum RSIZ_CAPABILITIES {
|
||||
STD_RSIZ = 0, /** Standard JPEG2000 profile*/
|
||||
CINEMA2K = 3, /** Profile name for a 2K image*/
|
||||
CINEMA4K = 4 /** Profile name for a 4K image*/
|
||||
} OPJ_RSIZ_CAPABILITIES;
|
||||
|
||||
/**
|
||||
Digital cinema operation mode
|
||||
*/
|
||||
typedef enum CINEMA_MODE {
|
||||
OFF = 0, /** Not Digital Cinema*/
|
||||
CINEMA2K_24 = 1, /** 2K Digital Cinema at 24 fps*/
|
||||
CINEMA2K_48 = 2, /** 2K Digital Cinema at 48 fps*/
|
||||
CINEMA4K_24 = 3 /** 4K Digital Cinema at 24 fps*/
|
||||
}OPJ_CINEMA_MODE;
|
||||
|
||||
/**
|
||||
Progression order
|
||||
*/
|
||||
typedef enum PROG_ORDER {
|
||||
PROG_UNKNOWN = -1, /**< place-holder */
|
||||
LRCP = 0, /**< layer-resolution-component-precinct order */
|
||||
RLCP = 1, /**< resolution-layer-component-precinct order */
|
||||
RPCL = 2, /**< resolution-precinct-component-layer order */
|
||||
PCRL = 3, /**< precinct-component-resolution-layer order */
|
||||
CPRL = 4 /**< component-precinct-resolution-layer order */
|
||||
} OPJ_PROG_ORDER;
|
||||
|
||||
/**
|
||||
Supported image color spaces
|
||||
*/
|
||||
typedef enum COLOR_SPACE {
|
||||
CLRSPC_UNKNOWN = -1, /**< not supported by the library */
|
||||
CLRSPC_UNSPECIFIED = 0, /**< not specified in the codestream */
|
||||
CLRSPC_SRGB = 1, /**< sRGB */
|
||||
CLRSPC_GRAY = 2, /**< grayscale */
|
||||
CLRSPC_SYCC = 3 /**< YUV */
|
||||
} OPJ_COLOR_SPACE;
|
||||
|
||||
#define ENUMCS_SRGB 16
|
||||
#define ENUMCS_GRAY 17
|
||||
#define ENUMCS_SYCC 18
|
||||
|
||||
/**
|
||||
Supported codec
|
||||
*/
|
||||
typedef enum CODEC_FORMAT {
|
||||
CODEC_UNKNOWN = -1, /**< place-holder */
|
||||
CODEC_J2K = 0, /**< JPEG-2000 codestream : read/write */
|
||||
CODEC_JPT = 1, /**< JPT-stream (JPEG 2000, JPIP) : read only */
|
||||
CODEC_JP2 = 2 /**< JPEG-2000 file format : read/write */
|
||||
} OPJ_CODEC_FORMAT;
|
||||
|
||||
/**
|
||||
Limit decoding to certain portions of the codestream.
|
||||
*/
|
||||
typedef enum LIMIT_DECODING {
|
||||
NO_LIMITATION = 0, /**< No limitation for the decoding. The entire codestream will de decoded */
|
||||
LIMIT_TO_MAIN_HEADER = 1, /**< The decoding is limited to the Main Header */
|
||||
DECODE_ALL_BUT_PACKETS = 2 /**< Decode everything except the JPEG 2000 packets */
|
||||
} OPJ_LIMIT_DECODING;
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
event manager typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Callback function prototype for events
|
||||
@param msg Event message
|
||||
@param client_data
|
||||
*/
|
||||
typedef void (*opj_msg_callback) (const char *msg, void *client_data);
|
||||
|
||||
/**
|
||||
Message handler object
|
||||
used for
|
||||
<ul>
|
||||
<li>Error messages
|
||||
<li>Warning messages
|
||||
<li>Debugging messages
|
||||
</ul>
|
||||
*/
|
||||
typedef struct opj_event_mgr {
|
||||
/** Error message callback if available, NULL otherwise */
|
||||
opj_msg_callback error_handler;
|
||||
/** Warning message callback if available, NULL otherwise */
|
||||
opj_msg_callback warning_handler;
|
||||
/** Debug message callback if available, NULL otherwise */
|
||||
opj_msg_callback info_handler;
|
||||
} opj_event_mgr_t;
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
codec typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Progression order changes
|
||||
*/
|
||||
typedef struct opj_poc {
|
||||
/** Resolution num start, Component num start, given by POC */
|
||||
int resno0, compno0;
|
||||
/** Layer num end,Resolution num end, Component num end, given by POC */
|
||||
int layno1, resno1, compno1;
|
||||
/** Layer num start,Precinct num start, Precinct num end */
|
||||
int layno0, precno0, precno1;
|
||||
/** Progression order enum*/
|
||||
OPJ_PROG_ORDER prg1,prg;
|
||||
/** Progression order string*/
|
||||
char progorder[5];
|
||||
/** Tile number */
|
||||
int tile;
|
||||
/** Start and end values for Tile width and height*/
|
||||
int tx0,tx1,ty0,ty1;
|
||||
/** Start value, initialised in pi_initialise_encode*/
|
||||
int layS, resS, compS, prcS;
|
||||
/** End value, initialised in pi_initialise_encode */
|
||||
int layE, resE, compE, prcE;
|
||||
/** Start and end values of Tile width and height, initialised in pi_initialise_encode*/
|
||||
int txS,txE,tyS,tyE,dx,dy;
|
||||
/** Temporary values for Tile parts, initialised in pi_create_encode */
|
||||
int lay_t, res_t, comp_t, prc_t,tx0_t,ty0_t;
|
||||
} opj_poc_t;
|
||||
|
||||
/**
|
||||
Compression parameters
|
||||
*/
|
||||
typedef struct opj_cparameters {
|
||||
/** size of tile: tile_size_on = false (not in argument) or = true (in argument) */
|
||||
opj_bool tile_size_on;
|
||||
/** XTOsiz */
|
||||
int cp_tx0;
|
||||
/** YTOsiz */
|
||||
int cp_ty0;
|
||||
/** XTsiz */
|
||||
int cp_tdx;
|
||||
/** YTsiz */
|
||||
int cp_tdy;
|
||||
/** allocation by rate/distortion */
|
||||
int cp_disto_alloc;
|
||||
/** allocation by fixed layer */
|
||||
int cp_fixed_alloc;
|
||||
/** add fixed_quality */
|
||||
int cp_fixed_quality;
|
||||
/** fixed layer */
|
||||
int *cp_matrice;
|
||||
/** comment for coding */
|
||||
char *cp_comment;
|
||||
/** csty : coding style */
|
||||
int csty;
|
||||
/** progression order (default LRCP) */
|
||||
OPJ_PROG_ORDER prog_order;
|
||||
/** progression order changes */
|
||||
opj_poc_t POC[32];
|
||||
/** number of progression order changes (POC), default to 0 */
|
||||
int numpocs;
|
||||
/** number of layers */
|
||||
int tcp_numlayers;
|
||||
/** rates of layers */
|
||||
float tcp_rates[100];
|
||||
/** different psnr for successive layers */
|
||||
float tcp_distoratio[100];
|
||||
/** number of resolutions */
|
||||
int numresolution;
|
||||
/** initial code block width, default to 64 */
|
||||
int cblockw_init;
|
||||
/** initial code block height, default to 64 */
|
||||
int cblockh_init;
|
||||
/** mode switch (cblk_style) */
|
||||
int mode;
|
||||
/** 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default) */
|
||||
int irreversible;
|
||||
/** region of interest: affected component in [0..3], -1 means no ROI */
|
||||
int roi_compno;
|
||||
/** region of interest: upshift value */
|
||||
int roi_shift;
|
||||
/* number of precinct size specifications */
|
||||
int res_spec;
|
||||
/** initial precinct width */
|
||||
int prcw_init[J2K_MAXRLVLS];
|
||||
/** initial precinct height */
|
||||
int prch_init[J2K_MAXRLVLS];
|
||||
|
||||
/**@name command line encoder parameters (not used inside the library) */
|
||||
/*@{*/
|
||||
/** input file name */
|
||||
char infile[OPJ_PATH_LEN];
|
||||
/** output file name */
|
||||
char outfile[OPJ_PATH_LEN];
|
||||
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
|
||||
int index_on;
|
||||
/** DEPRECATED. Index generation is now handeld with the opj_encode_with_info() function. Set to NULL */
|
||||
char index[OPJ_PATH_LEN];
|
||||
/** subimage encoding: origin image offset in x direction */
|
||||
int image_offset_x0;
|
||||
/** subimage encoding: origin image offset in y direction */
|
||||
int image_offset_y0;
|
||||
/** subsampling value for dx */
|
||||
int subsampling_dx;
|
||||
/** subsampling value for dy */
|
||||
int subsampling_dy;
|
||||
/** input file format 0: PGX, 1: PxM, 2: BMP 3:TIF*/
|
||||
int decod_format;
|
||||
/** output file format 0: J2K, 1: JP2, 2: JPT */
|
||||
int cod_format;
|
||||
/*@}*/
|
||||
|
||||
/* UniPG>> */
|
||||
/**@name JPWL encoding parameters */
|
||||
/*@{*/
|
||||
/** enables writing of EPC in MH, thus activating JPWL */
|
||||
opj_bool jpwl_epc_on;
|
||||
/** error protection method for MH (0,1,16,32,37-128) */
|
||||
int jpwl_hprot_MH;
|
||||
/** tile number of header protection specification (>=0) */
|
||||
int jpwl_hprot_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
||||
/** error protection methods for TPHs (0,1,16,32,37-128) */
|
||||
int jpwl_hprot_TPH[JPWL_MAX_NO_TILESPECS];
|
||||
/** tile number of packet protection specification (>=0) */
|
||||
int jpwl_pprot_tileno[JPWL_MAX_NO_PACKSPECS];
|
||||
/** packet number of packet protection specification (>=0) */
|
||||
int jpwl_pprot_packno[JPWL_MAX_NO_PACKSPECS];
|
||||
/** error protection methods for packets (0,1,16,32,37-128) */
|
||||
int jpwl_pprot[JPWL_MAX_NO_PACKSPECS];
|
||||
/** enables writing of ESD, (0=no/1/2 bytes) */
|
||||
int jpwl_sens_size;
|
||||
/** sensitivity addressing size (0=auto/2/4 bytes) */
|
||||
int jpwl_sens_addr;
|
||||
/** sensitivity range (0-3) */
|
||||
int jpwl_sens_range;
|
||||
/** sensitivity method for MH (-1=no,0-7) */
|
||||
int jpwl_sens_MH;
|
||||
/** tile number of sensitivity specification (>=0) */
|
||||
int jpwl_sens_TPH_tileno[JPWL_MAX_NO_TILESPECS];
|
||||
/** sensitivity methods for TPHs (-1=no,0-7) */
|
||||
int jpwl_sens_TPH[JPWL_MAX_NO_TILESPECS];
|
||||
/*@}*/
|
||||
/* <<UniPG */
|
||||
|
||||
/** Digital Cinema compliance 0-not compliant, 1-compliant*/
|
||||
OPJ_CINEMA_MODE cp_cinema;
|
||||
/** Maximum rate for each component. If == 0, component size limitation is not considered */
|
||||
int max_comp_size;
|
||||
/** Profile name*/
|
||||
OPJ_RSIZ_CAPABILITIES cp_rsiz;
|
||||
/** Tile part generation*/
|
||||
char tp_on;
|
||||
/** Flag for Tile part generation*/
|
||||
char tp_flag;
|
||||
/** MCT (multiple component transform) */
|
||||
char tcp_mct;
|
||||
/** Enable JPIP indexing*/
|
||||
opj_bool jpip_on;
|
||||
} opj_cparameters_t;
|
||||
|
||||
#define OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG 0x0001
|
||||
|
||||
/**
|
||||
Decompression parameters
|
||||
*/
|
||||
typedef struct opj_dparameters {
|
||||
/**
|
||||
Set the number of highest resolution levels to be discarded.
|
||||
The image resolution is effectively divided by 2 to the power of the number of discarded levels.
|
||||
The reduce factor is limited by the smallest total number of decomposition levels among tiles.
|
||||
if != 0, then original dimension divided by 2^(reduce);
|
||||
if == 0 or not used, image is decoded to the full resolution
|
||||
*/
|
||||
int cp_reduce;
|
||||
/**
|
||||
Set the maximum number of quality layers to decode.
|
||||
If there are less quality layers than the specified number, all the quality layers are decoded.
|
||||
if != 0, then only the first "layer" layers are decoded;
|
||||
if == 0 or not used, all the quality layers are decoded
|
||||
*/
|
||||
int cp_layer;
|
||||
|
||||
/**@name command line encoder parameters (not used inside the library) */
|
||||
/*@{*/
|
||||
/** input file name */
|
||||
char infile[OPJ_PATH_LEN];
|
||||
/** output file name */
|
||||
char outfile[OPJ_PATH_LEN];
|
||||
/** input file format 0: J2K, 1: JP2, 2: JPT */
|
||||
int decod_format;
|
||||
/** output file format 0: PGX, 1: PxM, 2: BMP */
|
||||
int cod_format;
|
||||
/*@}*/
|
||||
|
||||
/* UniPG>> */
|
||||
/**@name JPWL decoding parameters */
|
||||
/*@{*/
|
||||
/** activates the JPWL correction capabilities */
|
||||
opj_bool jpwl_correct;
|
||||
/** expected number of components */
|
||||
int jpwl_exp_comps;
|
||||
/** maximum number of tiles */
|
||||
int jpwl_max_tiles;
|
||||
/*@}*/
|
||||
/* <<UniPG */
|
||||
|
||||
/**
|
||||
Specify whether the decoding should be done on the entire codestream, or be limited to the main header
|
||||
Limiting the decoding to the main header makes it possible to extract the characteristics of the codestream
|
||||
if == NO_LIMITATION, the entire codestream is decoded;
|
||||
if == LIMIT_TO_MAIN_HEADER, only the main header is decoded;
|
||||
*/
|
||||
OPJ_LIMIT_DECODING cp_limit_decoding;
|
||||
|
||||
unsigned int flags;
|
||||
} opj_dparameters_t;
|
||||
|
||||
/** Common fields between JPEG-2000 compression and decompression master structs. */
|
||||
|
||||
#define opj_common_fields \
|
||||
opj_event_mgr_t *event_mgr; /**< pointer to the event manager */\
|
||||
void * client_data; /**< Available for use by application */\
|
||||
opj_bool is_decompressor; /**< So common code can tell which is which */\
|
||||
OPJ_CODEC_FORMAT codec_format; /**< selected codec */\
|
||||
void *j2k_handle; /**< pointer to the J2K codec */\
|
||||
void *jp2_handle; /**< pointer to the JP2 codec */\
|
||||
void *mj2_handle /**< pointer to the MJ2 codec */
|
||||
|
||||
/* Routines that are to be used by both halves of the library are declared
|
||||
* to receive a pointer to this structure. There are no actual instances of
|
||||
* opj_common_struct_t, only of opj_cinfo_t and opj_dinfo_t.
|
||||
*/
|
||||
typedef struct opj_common_struct {
|
||||
opj_common_fields; /* Fields common to both master struct types */
|
||||
/* Additional fields follow in an actual opj_cinfo_t or
|
||||
* opj_dinfo_t. All three structs must agree on these
|
||||
* initial fields! (This would be a lot cleaner in C++.)
|
||||
*/
|
||||
} opj_common_struct_t;
|
||||
|
||||
typedef opj_common_struct_t * opj_common_ptr;
|
||||
|
||||
/**
|
||||
Compression context info
|
||||
*/
|
||||
typedef struct opj_cinfo {
|
||||
/** Fields shared with opj_dinfo_t */
|
||||
opj_common_fields;
|
||||
/* other specific fields go here */
|
||||
} opj_cinfo_t;
|
||||
|
||||
/**
|
||||
Decompression context info
|
||||
*/
|
||||
typedef struct opj_dinfo {
|
||||
/** Fields shared with opj_cinfo_t */
|
||||
opj_common_fields;
|
||||
/* other specific fields go here */
|
||||
} opj_dinfo_t;
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
I/O stream typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* Stream open flags.
|
||||
*/
|
||||
/** The stream was opened for reading. */
|
||||
#define OPJ_STREAM_READ 0x0001
|
||||
/** The stream was opened for writing. */
|
||||
#define OPJ_STREAM_WRITE 0x0002
|
||||
|
||||
/**
|
||||
Byte input-output stream (CIO)
|
||||
*/
|
||||
typedef struct opj_cio {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** open mode (read/write) either OPJ_STREAM_READ or OPJ_STREAM_WRITE */
|
||||
int openmode;
|
||||
/** pointer to the start of the buffer */
|
||||
unsigned char *buffer;
|
||||
/** buffer size in bytes */
|
||||
int length;
|
||||
|
||||
/** pointer to the start of the stream */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the stream */
|
||||
unsigned char *end;
|
||||
/** pointer to the current position */
|
||||
unsigned char *bp;
|
||||
} opj_cio_t;
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
image typedef definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Defines a single image component
|
||||
*/
|
||||
typedef struct opj_image_comp {
|
||||
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
||||
int dx;
|
||||
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
||||
int dy;
|
||||
/** data width */
|
||||
int w;
|
||||
/** data height */
|
||||
int h;
|
||||
/** x component offset compared to the whole image */
|
||||
int x0;
|
||||
/** y component offset compared to the whole image */
|
||||
int y0;
|
||||
/** precision */
|
||||
int prec;
|
||||
/** image depth in bits */
|
||||
int bpp;
|
||||
/** signed (1) / unsigned (0) */
|
||||
int sgnd;
|
||||
/** number of decoded resolution */
|
||||
int resno_decoded;
|
||||
/** number of division by 2 of the out image compared to the original size of image */
|
||||
int factor;
|
||||
/** image component data */
|
||||
int *data;
|
||||
} opj_image_comp_t;
|
||||
|
||||
/**
|
||||
Defines image data and characteristics
|
||||
*/
|
||||
typedef struct opj_image {
|
||||
/** XOsiz: horizontal offset from the origin of the reference grid to the left side of the image area */
|
||||
int x0;
|
||||
/** YOsiz: vertical offset from the origin of the reference grid to the top side of the image area */
|
||||
int y0;
|
||||
/** Xsiz: width of the reference grid */
|
||||
int x1;
|
||||
/** Ysiz: height of the reference grid */
|
||||
int y1;
|
||||
/** number of components in the image */
|
||||
int numcomps;
|
||||
/** color space: sRGB, Greyscale or YUV */
|
||||
OPJ_COLOR_SPACE color_space;
|
||||
/** image components */
|
||||
opj_image_comp_t *comps;
|
||||
/** 'restricted' ICC profile */
|
||||
unsigned char *icc_profile_buf;
|
||||
/** size of ICC profile */
|
||||
int icc_profile_len;
|
||||
} opj_image_t;
|
||||
|
||||
/**
|
||||
Component parameters structure used by the opj_image_create function
|
||||
*/
|
||||
typedef struct opj_image_comptparm {
|
||||
/** XRsiz: horizontal separation of a sample of ith component with respect to the reference grid */
|
||||
int dx;
|
||||
/** YRsiz: vertical separation of a sample of ith component with respect to the reference grid */
|
||||
int dy;
|
||||
/** data width */
|
||||
int w;
|
||||
/** data height */
|
||||
int h;
|
||||
/** x component offset compared to the whole image */
|
||||
int x0;
|
||||
/** y component offset compared to the whole image */
|
||||
int y0;
|
||||
/** precision */
|
||||
int prec;
|
||||
/** image depth in bits */
|
||||
int bpp;
|
||||
/** signed (1) / unsigned (0) */
|
||||
int sgnd;
|
||||
} opj_image_cmptparm_t;
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Information on the JPEG 2000 codestream
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Index structure : Information concerning a packet inside tile
|
||||
*/
|
||||
typedef struct opj_packet_info {
|
||||
/** packet start position (including SOP marker if it exists) */
|
||||
int start_pos;
|
||||
/** end of packet header position (including EPH marker if it exists)*/
|
||||
int end_ph_pos;
|
||||
/** packet end position */
|
||||
int end_pos;
|
||||
/** packet distorsion */
|
||||
double disto;
|
||||
} opj_packet_info_t;
|
||||
|
||||
|
||||
/* UniPG>> */
|
||||
/**
|
||||
Marker structure
|
||||
*/
|
||||
typedef struct opj_marker_info_t {
|
||||
/** marker type */
|
||||
unsigned short int type;
|
||||
/** position in codestream */
|
||||
int pos;
|
||||
/** length, marker val included */
|
||||
int len;
|
||||
} opj_marker_info_t;
|
||||
/* <<UniPG */
|
||||
|
||||
/**
|
||||
Index structure : Information concerning tile-parts
|
||||
*/
|
||||
typedef struct opj_tp_info {
|
||||
/** start position of tile part */
|
||||
int tp_start_pos;
|
||||
/** end position of tile part header */
|
||||
int tp_end_header;
|
||||
/** end position of tile part */
|
||||
int tp_end_pos;
|
||||
/** start packet of tile part */
|
||||
int tp_start_pack;
|
||||
/** number of packets of tile part */
|
||||
int tp_numpacks;
|
||||
} opj_tp_info_t;
|
||||
|
||||
/**
|
||||
Index structure : information regarding tiles
|
||||
*/
|
||||
typedef struct opj_tile_info {
|
||||
/** value of thresh for each layer by tile cfr. Marcela */
|
||||
double *thresh;
|
||||
/** number of tile */
|
||||
int tileno;
|
||||
/** start position */
|
||||
int start_pos;
|
||||
/** end position of the header */
|
||||
int end_header;
|
||||
/** end position */
|
||||
int end_pos;
|
||||
/** precinct number for each resolution level (width) */
|
||||
int pw[33];
|
||||
/** precinct number for each resolution level (height) */
|
||||
int ph[33];
|
||||
/** precinct size (in power of 2), in X for each resolution level */
|
||||
int pdx[33];
|
||||
/** precinct size (in power of 2), in Y for each resolution level */
|
||||
int pdy[33];
|
||||
/** information concerning packets inside tile */
|
||||
opj_packet_info_t *packet;
|
||||
/** add fixed_quality */
|
||||
int numpix;
|
||||
/** add fixed_quality */
|
||||
double distotile;
|
||||
/** number of markers */
|
||||
int marknum;
|
||||
/** list of markers */
|
||||
opj_marker_info_t *marker;
|
||||
/** actual size of markers array */
|
||||
int maxmarknum;
|
||||
/** number of tile parts */
|
||||
int num_tps;
|
||||
/** information concerning tile parts */
|
||||
opj_tp_info_t *tp;
|
||||
} opj_tile_info_t;
|
||||
|
||||
/**
|
||||
Index structure of the codestream
|
||||
*/
|
||||
typedef struct opj_codestream_info {
|
||||
/** maximum distortion reduction on the whole image (add for Marcela) */
|
||||
double D_max;
|
||||
/** packet number */
|
||||
int packno;
|
||||
/** writing the packet in the index with t2_encode_packets */
|
||||
int index_write;
|
||||
/** image width */
|
||||
int image_w;
|
||||
/** image height */
|
||||
int image_h;
|
||||
/** progression order */
|
||||
OPJ_PROG_ORDER prog;
|
||||
/** tile size in x */
|
||||
int tile_x;
|
||||
/** tile size in y */
|
||||
int tile_y;
|
||||
/** */
|
||||
int tile_Ox;
|
||||
/** */
|
||||
int tile_Oy;
|
||||
/** number of tiles in X */
|
||||
int tw;
|
||||
/** number of tiles in Y */
|
||||
int th;
|
||||
/** component numbers */
|
||||
int numcomps;
|
||||
/** number of layer */
|
||||
int numlayers;
|
||||
/** number of decomposition for each component */
|
||||
int *numdecompos;
|
||||
/* UniPG>> */
|
||||
/** number of markers */
|
||||
int marknum;
|
||||
/** list of markers */
|
||||
opj_marker_info_t *marker;
|
||||
/** actual size of markers array */
|
||||
int maxmarknum;
|
||||
/* <<UniPG */
|
||||
/** main header position */
|
||||
int main_head_start;
|
||||
/** main header position */
|
||||
int main_head_end;
|
||||
/** codestream's size */
|
||||
int codestream_size;
|
||||
/** information regarding tiles inside image */
|
||||
opj_tile_info_t *tile;
|
||||
} opj_codestream_info_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
openjpeg version
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
OPJ_API const char * OPJ_CALLCONV opj_version(void);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
image functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Create an image
|
||||
@param numcmpts number of components
|
||||
@param cmptparms components parameters
|
||||
@param clrspc image color space
|
||||
@return returns a new image structure if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_image_t* OPJ_CALLCONV opj_image_create(int numcmpts, opj_image_cmptparm_t *cmptparms, OPJ_COLOR_SPACE clrspc);
|
||||
|
||||
/**
|
||||
Deallocate any resources associated with an image
|
||||
@param image image to be destroyed
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_image_destroy(opj_image_t *image);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
stream functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
Open and allocate a memory stream for read / write.
|
||||
On reading, the user must provide a buffer containing encoded data. The buffer will be
|
||||
wrapped by the returned CIO handle.
|
||||
On writing, buffer parameters must be set to 0: a buffer will be allocated by the library
|
||||
to contain encoded data.
|
||||
@param cinfo Codec context info
|
||||
@param buffer Reading: buffer address. Writing: NULL
|
||||
@param length Reading: buffer length. Writing: 0
|
||||
@return Returns a CIO handle if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_cio_t* OPJ_CALLCONV opj_cio_open(opj_common_ptr cinfo, unsigned char *buffer, int length);
|
||||
|
||||
/**
|
||||
Close and free a CIO handle
|
||||
@param cio CIO handle to free
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_cio_close(opj_cio_t *cio);
|
||||
|
||||
/**
|
||||
Get position in byte stream
|
||||
@param cio CIO handle
|
||||
@return Returns the position in bytes
|
||||
*/
|
||||
OPJ_API int OPJ_CALLCONV cio_tell(opj_cio_t *cio);
|
||||
/**
|
||||
Set position in byte stream
|
||||
@param cio CIO handle
|
||||
@param pos Position, in number of bytes, from the beginning of the stream
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV cio_seek(opj_cio_t *cio, int pos);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
event manager functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
OPJ_API opj_event_mgr_t* OPJ_CALLCONV opj_set_event_mgr(opj_common_ptr cinfo, opj_event_mgr_t *event_mgr, void *context);
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
codec functions definitions
|
||||
==========================================================
|
||||
*/
|
||||
/**
|
||||
Creates a J2K/JPT/JP2 decompression structure
|
||||
@param format Decoder to select
|
||||
@return Returns a handle to a decompressor if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_dinfo_t* OPJ_CALLCONV opj_create_decompress(OPJ_CODEC_FORMAT format);
|
||||
/**
|
||||
Destroy a decompressor handle
|
||||
@param dinfo decompressor handle to destroy
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_destroy_decompress(opj_dinfo_t *dinfo);
|
||||
/**
|
||||
Set decoding parameters to default values
|
||||
@param parameters Decompression parameters
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_set_default_decoder_parameters(opj_dparameters_t *parameters);
|
||||
/**
|
||||
Setup the decoder decoding parameters using user parameters.
|
||||
Decoding parameters are returned in j2k->cp.
|
||||
@param dinfo decompressor handle
|
||||
@param parameters decompression parameters
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_setup_decoder(opj_dinfo_t *dinfo, opj_dparameters_t *parameters);
|
||||
/**
|
||||
Decode an image from a JPEG-2000 codestream
|
||||
@param dinfo decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@return Returns a decoded image if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_image_t* OPJ_CALLCONV opj_decode(opj_dinfo_t *dinfo, opj_cio_t *cio);
|
||||
|
||||
/**
|
||||
Decode an image from a JPEG-2000 codestream and extract the codestream information
|
||||
@param dinfo decompressor handle
|
||||
@param cio Input buffer stream
|
||||
@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
|
||||
@return Returns a decoded image if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_image_t* OPJ_CALLCONV opj_decode_with_info(opj_dinfo_t *dinfo, opj_cio_t *cio, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Creates a J2K/JP2 compression structure
|
||||
@param format Coder to select
|
||||
@return Returns a handle to a compressor if successful, returns NULL otherwise
|
||||
*/
|
||||
OPJ_API opj_cinfo_t* OPJ_CALLCONV opj_create_compress(OPJ_CODEC_FORMAT format);
|
||||
/**
|
||||
Destroy a compressor handle
|
||||
@param cinfo compressor handle to destroy
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_destroy_compress(opj_cinfo_t *cinfo);
|
||||
/**
|
||||
Set encoding parameters to default values, that means :
|
||||
<ul>
|
||||
<li>Lossless
|
||||
<li>1 tile
|
||||
<li>Size of precinct : 2^15 x 2^15 (means 1 precinct)
|
||||
<li>Size of code-block : 64 x 64
|
||||
<li>Number of resolutions: 6
|
||||
<li>No SOP marker in the codestream
|
||||
<li>No EPH marker in the codestream
|
||||
<li>No sub-sampling in x or y direction
|
||||
<li>No mode switch activated
|
||||
<li>Progression order: LRCP
|
||||
<li>No index file
|
||||
<li>No ROI upshifted
|
||||
<li>No offset of the origin of the image
|
||||
<li>No offset of the origin of the tiles
|
||||
<li>Reversible DWT 5-3
|
||||
</ul>
|
||||
@param parameters Compression parameters
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_set_default_encoder_parameters(opj_cparameters_t *parameters);
|
||||
/**
|
||||
Setup the encoder parameters using the current image and using user parameters.
|
||||
@param cinfo Compressor handle
|
||||
@param parameters Compression parameters
|
||||
@param image Input filled image
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_setup_encoder(opj_cinfo_t *cinfo, opj_cparameters_t *parameters, opj_image_t *image);
|
||||
/**
|
||||
Encode an image into a JPEG-2000 codestream
|
||||
3@param cinfo compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param image Image to encode
|
||||
@param index Depreacted -> Set to NULL. To extract index, used opj_encode_wci()
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
OPJ_API opj_bool OPJ_CALLCONV opj_encode(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, char *index);
|
||||
/**
|
||||
Encode an image into a JPEG-2000 codestream and extract the codestream information
|
||||
@param cinfo compressor handle
|
||||
@param cio Output buffer stream
|
||||
@param image Image to encode
|
||||
@param cstr_info Codestream information structure if needed afterwards, NULL otherwise
|
||||
@return Returns true if successful, returns false otherwise
|
||||
*/
|
||||
OPJ_API opj_bool OPJ_CALLCONV opj_encode_with_info(opj_cinfo_t *cinfo, opj_cio_t *cio, opj_image_t *image, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Destroy Codestream information after compression or decompression
|
||||
@param cstr_info Codestream information structure
|
||||
*/
|
||||
OPJ_API void OPJ_CALLCONV opj_destroy_cstr_info(opj_codestream_info_t *cstr_info);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* OPENJPEG_H */
|
||||
@@ -1,117 +0,0 @@
|
||||
/* opj_config.h. Generated from opj_config.h.in by configure. */
|
||||
/* opj_config.h.in. Generated from configure.ac by autoheader. */
|
||||
|
||||
/* Define if building universal (internal helper macro) */
|
||||
/* #undef AC_APPLE_UNIVERSAL_BUILD */
|
||||
|
||||
/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
#define HAVE_DIRENT_H 1
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#define HAVE_DLFCN_H 1
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#define HAVE_INTTYPES_H 1
|
||||
|
||||
/* define to 1 if you have lcms version 1.x */
|
||||
/* #undef HAVE_LIBLCMS1 */
|
||||
|
||||
/* define to 1 if you have lcms version 2.x */
|
||||
/* #undef HAVE_LIBLCMS2 */
|
||||
|
||||
/* define to 1 if you have libpng */
|
||||
#define HAVE_LIBPNG 1
|
||||
|
||||
/* define to 1 if you have libtiff */
|
||||
#define HAVE_LIBTIFF 1
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#define HAVE_MEMORY_H 1
|
||||
|
||||
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
|
||||
/* #undef HAVE_NDIR_H */
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#define HAVE_STDINT_H 1
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#define HAVE_STDLIB_H 1
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#define HAVE_STRINGS_H 1
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#define HAVE_STRING_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
/* #undef HAVE_SYS_DIR_H */
|
||||
|
||||
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
/* #undef HAVE_SYS_NDIR_H */
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#define HAVE_SYS_STAT_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#define HAVE_SYS_TYPES_H 1
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#define HAVE_UNISTD_H 1
|
||||
|
||||
/* Define to the sub-directory in which libtool stores uninstalled libraries.
|
||||
*/
|
||||
#define LT_OBJDIR ".libs/"
|
||||
|
||||
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
|
||||
/* #undef NO_MINUS_C_MINUS_O */
|
||||
|
||||
/* Name of package */
|
||||
#define PACKAGE "openjpeg"
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#define PACKAGE_BUGREPORT "[email protected]"
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#define PACKAGE_NAME "OpenJPEG"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "OpenJPEG 1.5.0"
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#define PACKAGE_TARNAME "openjpeg"
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#define PACKAGE_URL "http://www.openjpeg.org"
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "1.5.1"
|
||||
|
||||
/* Define to 1 if you have the ANSI C header files. */
|
||||
#define STDC_HEADERS 1
|
||||
|
||||
/* define to 1 if you use jpip */
|
||||
/* #undef USE_JPIP */
|
||||
|
||||
/* define to 1 if you use jpip server */
|
||||
/* #undef USE_JPIP_SERVER */
|
||||
|
||||
/* define to 1 if you use mj2 */
|
||||
/* #undef USE_MJ2 */
|
||||
|
||||
/* Version number of package */
|
||||
#define VERSION "1.5.1"
|
||||
|
||||
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
|
||||
significant byte first (like Motorola and SPARC, unlike Intel). */
|
||||
#if defined AC_APPLE_UNIVERSAL_BUILD
|
||||
# if defined __BIG_ENDIAN__
|
||||
# define WORDS_BIGENDIAN 1
|
||||
# endif
|
||||
#else
|
||||
# ifndef WORDS_BIGENDIAN
|
||||
/* # undef WORDS_BIGENDIAN */
|
||||
# endif
|
||||
#endif
|
||||
@@ -1,140 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef OPJ_INCLUDES_H
|
||||
#define OPJ_INCLUDES_H
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Standard includes used by the library
|
||||
==========================================================
|
||||
*/
|
||||
#include <memory.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <float.h>
|
||||
#include <time.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <ctype.h>
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
OpenJPEG interface
|
||||
==========================================================
|
||||
*/
|
||||
#include "openjpeg.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
OpenJPEG modules
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
/* Ignore GCC attributes if this is not GCC */
|
||||
#ifndef __GNUC__
|
||||
#define __attribute__(x) /* __attribute__(x) */
|
||||
#endif
|
||||
|
||||
/*
|
||||
The inline keyword is supported by C99 but not by C90.
|
||||
Most compilers implement their own version of this keyword ...
|
||||
*/
|
||||
#ifndef INLINE
|
||||
#if defined(_MSC_VER)
|
||||
#define INLINE __forceinline
|
||||
#elif defined(__GNUC__)
|
||||
#define INLINE __inline__
|
||||
#elif defined(__MWERKS__)
|
||||
#define INLINE inline
|
||||
#else
|
||||
/* add other compilers here ... */
|
||||
#define INLINE
|
||||
#endif /* defined(<Compiler>) */
|
||||
#endif /* INLINE */
|
||||
|
||||
/* Are restricted pointers available? (C99) */
|
||||
#if (__STDC_VERSION__ != 199901L)
|
||||
/* Not a C99 compiler */
|
||||
#ifdef __GNUC__
|
||||
#define restrict __restrict__
|
||||
#else
|
||||
#define restrict /* restrict */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* MSVC and Borland C do not have lrintf */
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
static INLINE long lrintf(float f){
|
||||
#ifdef _M_X64
|
||||
return (long)((f>0.0f) ? (f + 0.5f):(f -0.5f));
|
||||
#else
|
||||
int i;
|
||||
|
||||
_asm{
|
||||
fld f
|
||||
fistp i
|
||||
};
|
||||
|
||||
return i;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "j2k_lib.h"
|
||||
#include "opj_malloc.h"
|
||||
#include "event.h"
|
||||
#include "bio.h"
|
||||
#include "cio.h"
|
||||
|
||||
#include "oj_image.h"
|
||||
#include "j2k.h"
|
||||
#include "jp2.h"
|
||||
#include "jpt.h"
|
||||
|
||||
#include "mqc.h"
|
||||
#include "raw.h"
|
||||
#include "bio.h"
|
||||
#include "tgt.h"
|
||||
#include "pi.h"
|
||||
#include "tcd.h"
|
||||
#include "t1.h"
|
||||
#include "dwt.h"
|
||||
#include "t2.h"
|
||||
#include "mct.h"
|
||||
#include "int.h"
|
||||
#include "fix.h"
|
||||
|
||||
#include "cidx_manager.h"
|
||||
#include "indexbox_manager.h"
|
||||
|
||||
/* JPWL>> */
|
||||
#ifdef USE_JPWL
|
||||
#include "./jpwl/jpwl.h"
|
||||
#endif /* USE_JPWL */
|
||||
/* <<JPWL */
|
||||
|
||||
#endif /* OPJ_INCLUDES_H */
|
||||
@@ -1,165 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2007, Callum Lerwick <[email protected]>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __OPJ_MALLOC_H
|
||||
#define __OPJ_MALLOC_H
|
||||
/**
|
||||
@file opj_malloc.h
|
||||
@brief Internal functions
|
||||
|
||||
The functions in opj_malloc.h are internal utilities used for memory management.
|
||||
*/
|
||||
|
||||
/** @defgroup MISC MISC - Miscellaneous internal functions */
|
||||
/*@{*/
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Allocate an uninitialized memory block
|
||||
@param size Bytes to allocate
|
||||
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
|
||||
*/
|
||||
#ifdef ALLOC_PERF_OPT
|
||||
void * OPJ_CALLCONV opj_malloc(size_t size);
|
||||
#else
|
||||
#define opj_malloc(size) malloc(size)
|
||||
#endif
|
||||
|
||||
/**
|
||||
Allocate a memory block with elements initialized to 0
|
||||
@param num Blocks to allocate
|
||||
@param size Bytes per block to allocate
|
||||
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
|
||||
*/
|
||||
#ifdef ALLOC_PERF_OPT
|
||||
void * OPJ_CALLCONV opj_calloc(size_t _NumOfElements, size_t _SizeOfElements);
|
||||
#else
|
||||
#define opj_calloc(num, size) calloc(num, size)
|
||||
#endif
|
||||
|
||||
/**
|
||||
Allocate memory aligned to a 16 byte boundry
|
||||
@param size Bytes to allocate
|
||||
@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
|
||||
*/
|
||||
/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
|
||||
#ifdef _WIN32
|
||||
/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
|
||||
#ifdef __GNUC__
|
||||
#include <mm_malloc.h>
|
||||
#define HAVE_MM_MALLOC
|
||||
#else /* MSVC, Intel C++ */
|
||||
#include <malloc.h>
|
||||
#ifdef _mm_malloc
|
||||
#define HAVE_MM_MALLOC
|
||||
#endif
|
||||
#endif
|
||||
#else /* Not _WIN32 */
|
||||
#if defined(__sun)
|
||||
#define HAVE_MEMALIGN
|
||||
#elif defined(__FreeBSD__)
|
||||
#define HAVE_POSIX_MEMALIGN
|
||||
/* Linux x86_64 and OSX always align allocations to 16 bytes */
|
||||
#elif !defined(__amd64__) && !defined(__APPLE__) && !defined(_AIX)
|
||||
#define HAVE_MEMALIGN
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define opj_aligned_malloc(size) malloc(size)
|
||||
#define opj_aligned_free(m) free(m)
|
||||
|
||||
#ifdef HAVE_MM_MALLOC
|
||||
#undef opj_aligned_malloc
|
||||
#define opj_aligned_malloc(size) _mm_malloc(size, 16)
|
||||
#undef opj_aligned_free
|
||||
#define opj_aligned_free(m) _mm_free(m)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_MEMALIGN
|
||||
extern void* memalign(size_t, size_t);
|
||||
#undef opj_aligned_malloc
|
||||
#define opj_aligned_malloc(size) memalign(16, (size))
|
||||
#undef opj_aligned_free
|
||||
#define opj_aligned_free(m) free(m)
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_POSIX_MEMALIGN
|
||||
#undef opj_aligned_malloc
|
||||
extern int posix_memalign(void**, size_t, size_t);
|
||||
|
||||
static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
|
||||
void* mem = NULL;
|
||||
posix_memalign(&mem, 16, size);
|
||||
return mem;
|
||||
}
|
||||
#undef opj_aligned_free
|
||||
#define opj_aligned_free(m) free(m)
|
||||
#endif
|
||||
|
||||
#ifdef ALLOC_PERF_OPT
|
||||
#undef opj_aligned_malloc
|
||||
#define opj_aligned_malloc(size) opj_malloc(size)
|
||||
#undef opj_aligned_free
|
||||
#define opj_aligned_free(m) opj_free(m)
|
||||
#endif
|
||||
|
||||
/**
|
||||
Reallocate memory blocks.
|
||||
@param m Pointer to previously allocated memory block
|
||||
@param s New size in bytes
|
||||
@return Returns a void pointer to the reallocated (and possibly moved) memory block
|
||||
*/
|
||||
#ifdef ALLOC_PERF_OPT
|
||||
void * OPJ_CALLCONV opj_realloc(void * m, size_t s);
|
||||
#else
|
||||
#define opj_realloc(m, s) realloc(m, s)
|
||||
#endif
|
||||
|
||||
/**
|
||||
Deallocates or frees a memory block.
|
||||
@param m Previously allocated memory block to be freed
|
||||
*/
|
||||
#ifdef ALLOC_PERF_OPT
|
||||
void OPJ_CALLCONV opj_free(void * m);
|
||||
#else
|
||||
#define opj_free(m) free(m)
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC poison malloc calloc realloc free
|
||||
#endif
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __OPJ_MALLOC_H */
|
||||
|
||||
@@ -1,170 +0,0 @@
|
||||
/*
|
||||
* $Id: phix_manager.c 897 2011-08-28 21:43:57Z [email protected] $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.c from 2KAN indexer
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
* Write faix box of phix
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] compno component number
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] EPHused true if if EPH option used
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of faix box
|
||||
*/
|
||||
int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
|
||||
|
||||
int write_phix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp=0, compno, i;
|
||||
opj_jp2_box_t *box;
|
||||
|
||||
box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
|
||||
|
||||
for( i=0;i<2;i++){
|
||||
if (i) cio_seek( cio, lenp);
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_PHIX, 4); /* PHIX */
|
||||
|
||||
write_manf( i, cstr_info.numcomps, box, cio);
|
||||
|
||||
for( compno=0; compno<cstr_info.numcomps; compno++){
|
||||
box[compno].length = write_phixfaix( coff, compno, cstr_info, EPHused, j2klen, cio);
|
||||
box[compno].type = JPIP_FAIX;
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
opj_free(box);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int write_phixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8 */
|
||||
opj_tile_info_t *tile_Idx;
|
||||
opj_packet_info_t packet;
|
||||
int resno, precno, layno, num_packet;
|
||||
int numOfres, numOfprec, numOflayers;
|
||||
packet.end_ph_pos = packet.start_pos = -1;
|
||||
(void)EPHused; /* unused ? */
|
||||
|
||||
if( j2klen > pow( 2, 32)){
|
||||
size_of_coding = 8;
|
||||
version = 1;
|
||||
}
|
||||
else{
|
||||
size_of_coding = 4;
|
||||
version = 0;
|
||||
}
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_FAIX, 4); /* FAIX */
|
||||
cio_write( cio, version,1); /* Version 0 = 4 bytes */
|
||||
|
||||
nmax = 0;
|
||||
for( i=0; i<=cstr_info.numdecompos[compno]; i++)
|
||||
nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
|
||||
|
||||
cio_write( cio, nmax, size_of_coding); /* NMAX */
|
||||
cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding); /* M */
|
||||
|
||||
for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
|
||||
tile_Idx = &cstr_info.tile[ tileno];
|
||||
|
||||
num_packet = 0;
|
||||
numOfres = cstr_info.numdecompos[compno] + 1;
|
||||
|
||||
for( resno=0; resno<numOfres ; resno++){
|
||||
numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
|
||||
for( precno=0; precno<numOfprec; precno++){
|
||||
numOflayers = cstr_info.numlayers;
|
||||
for( layno=0; layno<numOflayers; layno++){
|
||||
|
||||
switch ( cstr_info.prog){
|
||||
case LRCP:
|
||||
packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
|
||||
break;
|
||||
case RLCP:
|
||||
packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
|
||||
break;
|
||||
case RPCL:
|
||||
packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
|
||||
break;
|
||||
case PCRL:
|
||||
packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
|
||||
break;
|
||||
case CPRL:
|
||||
packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
|
||||
break;
|
||||
default:
|
||||
fprintf( stderr, "failed to ppix indexing\n");
|
||||
}
|
||||
|
||||
cio_write( cio, packet.start_pos-coff, size_of_coding); /* start position */
|
||||
cio_write( cio, packet.end_ph_pos-packet.start_pos+1, size_of_coding); /* length */
|
||||
|
||||
num_packet++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* PADDING */
|
||||
while( num_packet < nmax){
|
||||
cio_write( cio, 0, size_of_coding); /* start position */
|
||||
cio_write( cio, 0, size_of_coding); /* length */
|
||||
num_packet++;
|
||||
}
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
}
|
||||
@@ -1,963 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2006-2007, Parvatha Elangovan
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup PI PI - Implementation of a packet iterator */
|
||||
/*@{*/
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Get next packet in layer-resolution-component-precinct order.
|
||||
@param pi packet iterator to modify
|
||||
@return returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
static opj_bool pi_next_lrcp(opj_pi_iterator_t * pi);
|
||||
/**
|
||||
Get next packet in resolution-layer-component-precinct order.
|
||||
@param pi packet iterator to modify
|
||||
@return returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
static opj_bool pi_next_rlcp(opj_pi_iterator_t * pi);
|
||||
/**
|
||||
Get next packet in resolution-precinct-component-layer order.
|
||||
@param pi packet iterator to modify
|
||||
@return returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
static opj_bool pi_next_rpcl(opj_pi_iterator_t * pi);
|
||||
/**
|
||||
Get next packet in precinct-component-resolution-layer order.
|
||||
@param pi packet iterator to modify
|
||||
@return returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
static opj_bool pi_next_pcrl(opj_pi_iterator_t * pi);
|
||||
/**
|
||||
Get next packet in component-precinct-resolution-layer order.
|
||||
@param pi packet iterator to modify
|
||||
@return returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
static opj_bool pi_next_cprl(opj_pi_iterator_t * pi);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
static opj_bool pi_next_lrcp(opj_pi_iterator_t * pi) {
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
res = &comp->resolutions[pi->resno];
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
pi->first = 0;
|
||||
}
|
||||
|
||||
for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1;
|
||||
pi->resno++) {
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolutions) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
if (!pi->tp_on){
|
||||
pi->poc.precno1 = res->pw * res->ph;
|
||||
}
|
||||
for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
|
||||
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
|
||||
if (!pi->include[index]) {
|
||||
pi->include[index] = 1;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
LABEL_SKIP:;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
static opj_bool pi_next_rlcp(opj_pi_iterator_t * pi) {
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
res = &comp->resolutions[pi->resno];
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
pi->first = 0;
|
||||
}
|
||||
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
|
||||
for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolutions) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
if(!pi->tp_on){
|
||||
pi->poc.precno1 = res->pw * res->ph;
|
||||
}
|
||||
for (pi->precno = pi->poc.precno0; pi->precno < pi->poc.precno1; pi->precno++) {
|
||||
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
|
||||
if (!pi->include[index]) {
|
||||
pi->include[index] = 1;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
LABEL_SKIP:;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
static opj_bool pi_next_rpcl(opj_pi_iterator_t * pi) {
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
int compno, resno;
|
||||
pi->first = 0;
|
||||
pi->dx = 0;
|
||||
pi->dy = 0;
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
comp = &pi->comps[compno];
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int dx, dy;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!pi->tp_on){
|
||||
pi->poc.ty0 = pi->ty0;
|
||||
pi->poc.tx0 = pi->tx0;
|
||||
pi->poc.ty1 = pi->ty1;
|
||||
pi->poc.tx1 = pi->tx1;
|
||||
}
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < pi->poc.resno1; pi->resno++) {
|
||||
for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
int levelno;
|
||||
int trx0, try0;
|
||||
int trx1, try1;
|
||||
int rpx, rpy;
|
||||
int prci, prcj;
|
||||
comp = &pi->comps[pi->compno];
|
||||
if (pi->resno >= comp->numresolutions) {
|
||||
continue;
|
||||
}
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelno = comp->numresolutions - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
|
||||
rpx = res->pdx + levelno;
|
||||
rpy = res->pdy + levelno;
|
||||
if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
|
||||
continue;
|
||||
}
|
||||
if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((res->pw==0)||(res->ph==0)) continue;
|
||||
|
||||
if ((trx0==trx1)||(try0==try1)) continue;
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
pi->precno = prci + prcj * res->pw;
|
||||
for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
|
||||
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
|
||||
if (!pi->include[index]) {
|
||||
pi->include[index] = 1;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
LABEL_SKIP:;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
static opj_bool pi_next_pcrl(opj_pi_iterator_t * pi) {
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
int compno, resno;
|
||||
pi->first = 0;
|
||||
pi->dx = 0;
|
||||
pi->dy = 0;
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
comp = &pi->comps[compno];
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int dx, dy;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!pi->tp_on){
|
||||
pi->poc.ty0 = pi->ty0;
|
||||
pi->poc.tx0 = pi->tx0;
|
||||
pi->poc.ty1 = pi->ty1;
|
||||
pi->poc.tx1 = pi->tx1;
|
||||
}
|
||||
for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
|
||||
int levelno;
|
||||
int trx0, try0;
|
||||
int trx1, try1;
|
||||
int rpx, rpy;
|
||||
int prci, prcj;
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelno = comp->numresolutions - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
|
||||
rpx = res->pdx + levelno;
|
||||
rpy = res->pdy + levelno;
|
||||
if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
|
||||
continue;
|
||||
}
|
||||
if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((res->pw==0)||(res->ph==0)) continue;
|
||||
|
||||
if ((trx0==trx1)||(try0==try1)) continue;
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
pi->precno = prci + prcj * res->pw;
|
||||
for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
|
||||
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
|
||||
if (!pi->include[index]) {
|
||||
pi->include[index] = 1;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
LABEL_SKIP:;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
static opj_bool pi_next_cprl(opj_pi_iterator_t * pi) {
|
||||
opj_pi_comp_t *comp = NULL;
|
||||
opj_pi_resolution_t *res = NULL;
|
||||
long index = 0;
|
||||
|
||||
if (!pi->first) {
|
||||
comp = &pi->comps[pi->compno];
|
||||
goto LABEL_SKIP;
|
||||
} else {
|
||||
pi->first = 0;
|
||||
}
|
||||
|
||||
for (pi->compno = pi->poc.compno0; pi->compno < pi->poc.compno1; pi->compno++) {
|
||||
int resno;
|
||||
comp = &pi->comps[pi->compno];
|
||||
pi->dx = 0;
|
||||
pi->dy = 0;
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int dx, dy;
|
||||
res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
|
||||
pi->dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi->dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
}
|
||||
if (!pi->tp_on){
|
||||
pi->poc.ty0 = pi->ty0;
|
||||
pi->poc.tx0 = pi->tx0;
|
||||
pi->poc.ty1 = pi->ty1;
|
||||
pi->poc.tx1 = pi->tx1;
|
||||
}
|
||||
for (pi->y = pi->poc.ty0; pi->y < pi->poc.ty1; pi->y += pi->dy - (pi->y % pi->dy)) {
|
||||
for (pi->x = pi->poc.tx0; pi->x < pi->poc.tx1; pi->x += pi->dx - (pi->x % pi->dx)) {
|
||||
for (pi->resno = pi->poc.resno0; pi->resno < int_min(pi->poc.resno1, comp->numresolutions); pi->resno++) {
|
||||
int levelno;
|
||||
int trx0, try0;
|
||||
int trx1, try1;
|
||||
int rpx, rpy;
|
||||
int prci, prcj;
|
||||
res = &comp->resolutions[pi->resno];
|
||||
levelno = comp->numresolutions - 1 - pi->resno;
|
||||
trx0 = int_ceildiv(pi->tx0, comp->dx << levelno);
|
||||
try0 = int_ceildiv(pi->ty0, comp->dy << levelno);
|
||||
trx1 = int_ceildiv(pi->tx1, comp->dx << levelno);
|
||||
try1 = int_ceildiv(pi->ty1, comp->dy << levelno);
|
||||
rpx = res->pdx + levelno;
|
||||
rpy = res->pdy + levelno;
|
||||
if (!((pi->y % (comp->dy << rpy) == 0) || ((pi->y == pi->ty0) && ((try0 << levelno) % (1 << rpy))))){
|
||||
continue;
|
||||
}
|
||||
if (!((pi->x % (comp->dx << rpx) == 0) || ((pi->x == pi->tx0) && ((trx0 << levelno) % (1 << rpx))))){
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((res->pw==0)||(res->ph==0)) continue;
|
||||
|
||||
if ((trx0==trx1)||(try0==try1)) continue;
|
||||
|
||||
prci = int_floordivpow2(int_ceildiv(pi->x, comp->dx << levelno), res->pdx)
|
||||
- int_floordivpow2(trx0, res->pdx);
|
||||
prcj = int_floordivpow2(int_ceildiv(pi->y, comp->dy << levelno), res->pdy)
|
||||
- int_floordivpow2(try0, res->pdy);
|
||||
pi->precno = prci + prcj * res->pw;
|
||||
for (pi->layno = pi->poc.layno0; pi->layno < pi->poc.layno1; pi->layno++) {
|
||||
index = pi->layno * pi->step_l + pi->resno * pi->step_r + pi->compno * pi->step_c + pi->precno * pi->step_p;
|
||||
if (!pi->include[index]) {
|
||||
pi->include[index] = 1;
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
LABEL_SKIP:;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Packet iterator interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_pi_iterator_t *pi_create_decode(opj_image_t *image, opj_cp_t *cp, int tileno) {
|
||||
int p, q;
|
||||
int compno, resno, pino;
|
||||
opj_pi_iterator_t *pi = NULL;
|
||||
opj_tcp_t *tcp = NULL;
|
||||
opj_tccp_t *tccp = NULL;
|
||||
|
||||
tcp = &cp->tcps[tileno];
|
||||
|
||||
pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
|
||||
if(!pi) {
|
||||
/* TODO: throw an error */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (pino = 0; pino < tcp->numpocs + 1; pino++) { /* change */
|
||||
int maxres = 0;
|
||||
int maxprec = 0;
|
||||
p = tileno % cp->tw;
|
||||
q = tileno / cp->tw;
|
||||
|
||||
pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
|
||||
pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
|
||||
pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
|
||||
pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
|
||||
pi[pino].numcomps = image->numcomps;
|
||||
|
||||
pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
|
||||
if(!pi[pino].comps) {
|
||||
/* TODO: throw an error */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
int tcx0, tcy0, tcx1, tcy1;
|
||||
opj_pi_comp_t *comp = &pi[pino].comps[compno];
|
||||
tccp = &tcp->tccps[compno];
|
||||
comp->dx = image->comps[compno].dx;
|
||||
comp->dy = image->comps[compno].dy;
|
||||
comp->numresolutions = tccp->numresolutions;
|
||||
|
||||
comp->resolutions = (opj_pi_resolution_t*) opj_calloc(comp->numresolutions, sizeof(opj_pi_resolution_t));
|
||||
if(!comp->resolutions) {
|
||||
/* TODO: throw an error */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tcx0 = int_ceildiv(pi->tx0, comp->dx);
|
||||
tcy0 = int_ceildiv(pi->ty0, comp->dy);
|
||||
tcx1 = int_ceildiv(pi->tx1, comp->dx);
|
||||
tcy1 = int_ceildiv(pi->ty1, comp->dy);
|
||||
if (comp->numresolutions > maxres) {
|
||||
maxres = comp->numresolutions;
|
||||
}
|
||||
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int levelno;
|
||||
int rx0, ry0, rx1, ry1;
|
||||
int px0, py0, px1, py1;
|
||||
opj_pi_resolution_t *res = &comp->resolutions[resno];
|
||||
if (tccp->csty & J2K_CCP_CSTY_PRT) {
|
||||
res->pdx = tccp->prcw[resno];
|
||||
res->pdy = tccp->prch[resno];
|
||||
} else {
|
||||
res->pdx = 15;
|
||||
res->pdy = 15;
|
||||
}
|
||||
levelno = comp->numresolutions - 1 - resno;
|
||||
rx0 = int_ceildivpow2(tcx0, levelno);
|
||||
ry0 = int_ceildivpow2(tcy0, levelno);
|
||||
rx1 = int_ceildivpow2(tcx1, levelno);
|
||||
ry1 = int_ceildivpow2(tcy1, levelno);
|
||||
px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
|
||||
py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
|
||||
px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
|
||||
py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
|
||||
res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
|
||||
res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
|
||||
|
||||
if (res->pw*res->ph > maxprec) {
|
||||
maxprec = res->pw*res->ph;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
tccp = &tcp->tccps[0];
|
||||
pi[pino].step_p = 1;
|
||||
pi[pino].step_c = maxprec * pi[pino].step_p;
|
||||
pi[pino].step_r = image->numcomps * pi[pino].step_c;
|
||||
pi[pino].step_l = maxres * pi[pino].step_r;
|
||||
|
||||
if (pino == 0) {
|
||||
pi[pino].include = (short int*) opj_calloc(image->numcomps * maxres * tcp->numlayers * maxprec, sizeof(short int));
|
||||
if(!pi[pino].include) {
|
||||
/* TODO: throw an error */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
pi[pino].include = pi[pino - 1].include;
|
||||
}
|
||||
|
||||
if (tcp->POC == 0) {
|
||||
pi[pino].first = 1;
|
||||
pi[pino].poc.resno0 = 0;
|
||||
pi[pino].poc.compno0 = 0;
|
||||
pi[pino].poc.layno1 = tcp->numlayers;
|
||||
pi[pino].poc.resno1 = maxres;
|
||||
pi[pino].poc.compno1 = image->numcomps;
|
||||
pi[pino].poc.prg = tcp->prg;
|
||||
} else {
|
||||
pi[pino].first = 1;
|
||||
pi[pino].poc.resno0 = tcp->pocs[pino].resno0;
|
||||
pi[pino].poc.compno0 = tcp->pocs[pino].compno0;
|
||||
pi[pino].poc.layno1 = tcp->pocs[pino].layno1;
|
||||
pi[pino].poc.resno1 = tcp->pocs[pino].resno1;
|
||||
pi[pino].poc.compno1 = tcp->pocs[pino].compno1;
|
||||
pi[pino].poc.prg = tcp->pocs[pino].prg;
|
||||
}
|
||||
pi[pino].poc.layno0 = 0;
|
||||
pi[pino].poc.precno0 = 0;
|
||||
pi[pino].poc.precno1 = maxprec;
|
||||
|
||||
}
|
||||
|
||||
return pi;
|
||||
}
|
||||
|
||||
|
||||
opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno, J2K_T2_MODE t2_mode){
|
||||
int p, q, pino;
|
||||
int compno, resno;
|
||||
int maxres = 0;
|
||||
int maxprec = 0;
|
||||
opj_pi_iterator_t *pi = NULL;
|
||||
opj_tcp_t *tcp = NULL;
|
||||
opj_tccp_t *tccp = NULL;
|
||||
|
||||
tcp = &cp->tcps[tileno];
|
||||
|
||||
pi = (opj_pi_iterator_t*) opj_calloc((tcp->numpocs + 1), sizeof(opj_pi_iterator_t));
|
||||
if(!pi) { return NULL;}
|
||||
pi->tp_on = cp->tp_on;
|
||||
|
||||
for(pino = 0;pino < tcp->numpocs+1 ; pino ++){
|
||||
p = tileno % cp->tw;
|
||||
q = tileno / cp->tw;
|
||||
|
||||
pi[pino].tx0 = int_max(cp->tx0 + p * cp->tdx, image->x0);
|
||||
pi[pino].ty0 = int_max(cp->ty0 + q * cp->tdy, image->y0);
|
||||
pi[pino].tx1 = int_min(cp->tx0 + (p + 1) * cp->tdx, image->x1);
|
||||
pi[pino].ty1 = int_min(cp->ty0 + (q + 1) * cp->tdy, image->y1);
|
||||
pi[pino].numcomps = image->numcomps;
|
||||
|
||||
pi[pino].comps = (opj_pi_comp_t*) opj_calloc(image->numcomps, sizeof(opj_pi_comp_t));
|
||||
if(!pi[pino].comps) {
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (compno = 0; compno < pi[pino].numcomps; compno++) {
|
||||
int tcx0, tcy0, tcx1, tcy1;
|
||||
opj_pi_comp_t *comp = &pi[pino].comps[compno];
|
||||
tccp = &tcp->tccps[compno];
|
||||
comp->dx = image->comps[compno].dx;
|
||||
comp->dy = image->comps[compno].dy;
|
||||
comp->numresolutions = tccp->numresolutions;
|
||||
|
||||
comp->resolutions = (opj_pi_resolution_t*) opj_malloc(comp->numresolutions * sizeof(opj_pi_resolution_t));
|
||||
if(!comp->resolutions) {
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tcx0 = int_ceildiv(pi[pino].tx0, comp->dx);
|
||||
tcy0 = int_ceildiv(pi[pino].ty0, comp->dy);
|
||||
tcx1 = int_ceildiv(pi[pino].tx1, comp->dx);
|
||||
tcy1 = int_ceildiv(pi[pino].ty1, comp->dy);
|
||||
if (comp->numresolutions > maxres) {
|
||||
maxres = comp->numresolutions;
|
||||
}
|
||||
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int levelno;
|
||||
int rx0, ry0, rx1, ry1;
|
||||
int px0, py0, px1, py1;
|
||||
opj_pi_resolution_t *res = &comp->resolutions[resno];
|
||||
if (tccp->csty & J2K_CCP_CSTY_PRT) {
|
||||
res->pdx = tccp->prcw[resno];
|
||||
res->pdy = tccp->prch[resno];
|
||||
} else {
|
||||
res->pdx = 15;
|
||||
res->pdy = 15;
|
||||
}
|
||||
levelno = comp->numresolutions - 1 - resno;
|
||||
rx0 = int_ceildivpow2(tcx0, levelno);
|
||||
ry0 = int_ceildivpow2(tcy0, levelno);
|
||||
rx1 = int_ceildivpow2(tcx1, levelno);
|
||||
ry1 = int_ceildivpow2(tcy1, levelno);
|
||||
px0 = int_floordivpow2(rx0, res->pdx) << res->pdx;
|
||||
py0 = int_floordivpow2(ry0, res->pdy) << res->pdy;
|
||||
px1 = int_ceildivpow2(rx1, res->pdx) << res->pdx;
|
||||
py1 = int_ceildivpow2(ry1, res->pdy) << res->pdy;
|
||||
res->pw = (rx0==rx1)?0:((px1 - px0) >> res->pdx);
|
||||
res->ph = (ry0==ry1)?0:((py1 - py0) >> res->pdy);
|
||||
|
||||
if (res->pw*res->ph > maxprec) {
|
||||
maxprec = res->pw * res->ph;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tccp = &tcp->tccps[0];
|
||||
pi[pino].step_p = 1;
|
||||
pi[pino].step_c = maxprec * pi[pino].step_p;
|
||||
pi[pino].step_r = image->numcomps * pi[pino].step_c;
|
||||
pi[pino].step_l = maxres * pi[pino].step_r;
|
||||
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
opj_pi_comp_t *comp = &pi->comps[compno];
|
||||
for (resno = 0; resno < comp->numresolutions; resno++) {
|
||||
int dx, dy;
|
||||
opj_pi_resolution_t *res = &comp->resolutions[resno];
|
||||
dx = comp->dx * (1 << (res->pdx + comp->numresolutions - 1 - resno));
|
||||
dy = comp->dy * (1 << (res->pdy + comp->numresolutions - 1 - resno));
|
||||
pi[pino].dx = !pi->dx ? dx : int_min(pi->dx, dx);
|
||||
pi[pino].dy = !pi->dy ? dy : int_min(pi->dy, dy);
|
||||
}
|
||||
}
|
||||
|
||||
if (pino == 0) {
|
||||
pi[pino].include = (short int*) opj_calloc(tcp->numlayers * pi[pino].step_l, sizeof(short int));
|
||||
if(!pi[pino].include) {
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
pi[pino].include = pi[pino - 1].include;
|
||||
}
|
||||
|
||||
/* Generation of boundaries for each prog flag*/
|
||||
if(tcp->POC && ( cp->cinema || ((!cp->cinema) && (t2_mode == FINAL_PASS)))){
|
||||
tcp->pocs[pino].compS= tcp->pocs[pino].compno0;
|
||||
tcp->pocs[pino].compE= tcp->pocs[pino].compno1;
|
||||
tcp->pocs[pino].resS = tcp->pocs[pino].resno0;
|
||||
tcp->pocs[pino].resE = tcp->pocs[pino].resno1;
|
||||
tcp->pocs[pino].layE = tcp->pocs[pino].layno1;
|
||||
tcp->pocs[pino].prg = tcp->pocs[pino].prg1;
|
||||
if (pino > 0)
|
||||
tcp->pocs[pino].layS = (tcp->pocs[pino].layE > tcp->pocs[pino - 1].layE) ? tcp->pocs[pino - 1].layE : 0;
|
||||
}else {
|
||||
tcp->pocs[pino].compS= 0;
|
||||
tcp->pocs[pino].compE= image->numcomps;
|
||||
tcp->pocs[pino].resS = 0;
|
||||
tcp->pocs[pino].resE = maxres;
|
||||
tcp->pocs[pino].layS = 0;
|
||||
tcp->pocs[pino].layE = tcp->numlayers;
|
||||
tcp->pocs[pino].prg = tcp->prg;
|
||||
}
|
||||
tcp->pocs[pino].prcS = 0;
|
||||
tcp->pocs[pino].prcE = maxprec;;
|
||||
tcp->pocs[pino].txS = pi[pino].tx0;
|
||||
tcp->pocs[pino].txE = pi[pino].tx1;
|
||||
tcp->pocs[pino].tyS = pi[pino].ty0;
|
||||
tcp->pocs[pino].tyE = pi[pino].ty1;
|
||||
tcp->pocs[pino].dx = pi[pino].dx;
|
||||
tcp->pocs[pino].dy = pi[pino].dy;
|
||||
}
|
||||
return pi;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno) {
|
||||
int compno, pino;
|
||||
opj_tcp_t *tcp = &cp->tcps[tileno];
|
||||
if(pi) {
|
||||
for (pino = 0; pino < tcp->numpocs + 1; pino++) {
|
||||
if(pi[pino].comps) {
|
||||
for (compno = 0; compno < pi->numcomps; compno++) {
|
||||
opj_pi_comp_t *comp = &pi[pino].comps[compno];
|
||||
if(comp->resolutions) {
|
||||
opj_free(comp->resolutions);
|
||||
}
|
||||
}
|
||||
opj_free(pi[pino].comps);
|
||||
}
|
||||
}
|
||||
if(pi->include) {
|
||||
opj_free(pi->include);
|
||||
}
|
||||
opj_free(pi);
|
||||
}
|
||||
}
|
||||
|
||||
opj_bool pi_next(opj_pi_iterator_t * pi) {
|
||||
switch (pi->poc.prg) {
|
||||
case LRCP:
|
||||
return pi_next_lrcp(pi);
|
||||
case RLCP:
|
||||
return pi_next_rlcp(pi);
|
||||
case RPCL:
|
||||
return pi_next_rpcl(pi);
|
||||
case PCRL:
|
||||
return pi_next_pcrl(pi);
|
||||
case CPRL:
|
||||
return pi_next_cprl(pi);
|
||||
case PROG_UNKNOWN:
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
opj_bool pi_create_encode( opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp){
|
||||
char prog[4];
|
||||
int i;
|
||||
int incr_top=1,resetX=0;
|
||||
opj_tcp_t *tcps =&cp->tcps[tileno];
|
||||
opj_poc_t *tcp= &tcps->pocs[pino];
|
||||
|
||||
pi[pino].first = 1;
|
||||
pi[pino].poc.prg = tcp->prg;
|
||||
|
||||
switch(tcp->prg){
|
||||
case CPRL: strncpy(prog, "CPRL",4);
|
||||
break;
|
||||
case LRCP: strncpy(prog, "LRCP",4);
|
||||
break;
|
||||
case PCRL: strncpy(prog, "PCRL",4);
|
||||
break;
|
||||
case RLCP: strncpy(prog, "RLCP",4);
|
||||
break;
|
||||
case RPCL: strncpy(prog, "RPCL",4);
|
||||
break;
|
||||
case PROG_UNKNOWN:
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
if(!(cp->tp_on && ((!cp->cinema && (t2_mode == FINAL_PASS)) || cp->cinema))){
|
||||
pi[pino].poc.resno0 = tcp->resS;
|
||||
pi[pino].poc.resno1 = tcp->resE;
|
||||
pi[pino].poc.compno0 = tcp->compS;
|
||||
pi[pino].poc.compno1 = tcp->compE;
|
||||
pi[pino].poc.layno0 = tcp->layS;
|
||||
pi[pino].poc.layno1 = tcp->layE;
|
||||
pi[pino].poc.precno0 = tcp->prcS;
|
||||
pi[pino].poc.precno1 = tcp->prcE;
|
||||
pi[pino].poc.tx0 = tcp->txS;
|
||||
pi[pino].poc.ty0 = tcp->tyS;
|
||||
pi[pino].poc.tx1 = tcp->txE;
|
||||
pi[pino].poc.ty1 = tcp->tyE;
|
||||
}else {
|
||||
if( tpnum < cur_totnum_tp){
|
||||
for(i=3;i>=0;i--){
|
||||
switch(prog[i]){
|
||||
case 'C':
|
||||
if (i > tppos){
|
||||
pi[pino].poc.compno0 = tcp->compS;
|
||||
pi[pino].poc.compno1 = tcp->compE;
|
||||
}else{
|
||||
if (tpnum == 0){
|
||||
tcp->comp_t = tcp->compS;
|
||||
pi[pino].poc.compno0 = tcp->comp_t;
|
||||
pi[pino].poc.compno1 = tcp->comp_t+1;
|
||||
tcp->comp_t+=1;
|
||||
}else{
|
||||
if (incr_top == 1){
|
||||
if(tcp->comp_t ==tcp->compE){
|
||||
tcp->comp_t = tcp->compS;
|
||||
pi[pino].poc.compno0 = tcp->comp_t;
|
||||
pi[pino].poc.compno1 = tcp->comp_t+1;
|
||||
tcp->comp_t+=1;
|
||||
incr_top=1;
|
||||
}else{
|
||||
pi[pino].poc.compno0 = tcp->comp_t;
|
||||
pi[pino].poc.compno1 = tcp->comp_t+1;
|
||||
tcp->comp_t+=1;
|
||||
incr_top=0;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.compno0 = tcp->comp_t-1;
|
||||
pi[pino].poc.compno1 = tcp->comp_t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'R':
|
||||
if (i > tppos){
|
||||
pi[pino].poc.resno0 = tcp->resS;
|
||||
pi[pino].poc.resno1 = tcp->resE;
|
||||
}else{
|
||||
if (tpnum == 0){
|
||||
tcp->res_t = tcp->resS;
|
||||
pi[pino].poc.resno0 = tcp->res_t;
|
||||
pi[pino].poc.resno1 = tcp->res_t+1;
|
||||
tcp->res_t+=1;
|
||||
}else{
|
||||
if (incr_top == 1){
|
||||
if(tcp->res_t==tcp->resE){
|
||||
tcp->res_t = tcp->resS;
|
||||
pi[pino].poc.resno0 = tcp->res_t;
|
||||
pi[pino].poc.resno1 = tcp->res_t+1;
|
||||
tcp->res_t+=1;
|
||||
incr_top=1;
|
||||
}else{
|
||||
pi[pino].poc.resno0 = tcp->res_t;
|
||||
pi[pino].poc.resno1 = tcp->res_t+1;
|
||||
tcp->res_t+=1;
|
||||
incr_top=0;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.resno0 = tcp->res_t - 1;
|
||||
pi[pino].poc.resno1 = tcp->res_t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'L':
|
||||
if (i > tppos){
|
||||
pi[pino].poc.layno0 = tcp->layS;
|
||||
pi[pino].poc.layno1 = tcp->layE;
|
||||
}else{
|
||||
if (tpnum == 0){
|
||||
tcp->lay_t = tcp->layS;
|
||||
pi[pino].poc.layno0 = tcp->lay_t;
|
||||
pi[pino].poc.layno1 = tcp->lay_t+1;
|
||||
tcp->lay_t+=1;
|
||||
}else{
|
||||
if (incr_top == 1){
|
||||
if(tcp->lay_t == tcp->layE){
|
||||
tcp->lay_t = tcp->layS;
|
||||
pi[pino].poc.layno0 = tcp->lay_t;
|
||||
pi[pino].poc.layno1 = tcp->lay_t+1;
|
||||
tcp->lay_t+=1;
|
||||
incr_top=1;
|
||||
}else{
|
||||
pi[pino].poc.layno0 = tcp->lay_t;
|
||||
pi[pino].poc.layno1 = tcp->lay_t+1;
|
||||
tcp->lay_t+=1;
|
||||
incr_top=0;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.layno0 = tcp->lay_t - 1;
|
||||
pi[pino].poc.layno1 = tcp->lay_t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 'P':
|
||||
switch(tcp->prg){
|
||||
case LRCP:
|
||||
case RLCP:
|
||||
if (i > tppos){
|
||||
pi[pino].poc.precno0 = tcp->prcS;
|
||||
pi[pino].poc.precno1 = tcp->prcE;
|
||||
}else{
|
||||
if (tpnum == 0){
|
||||
tcp->prc_t = tcp->prcS;
|
||||
pi[pino].poc.precno0 = tcp->prc_t;
|
||||
pi[pino].poc.precno1 = tcp->prc_t+1;
|
||||
tcp->prc_t+=1;
|
||||
}else{
|
||||
if (incr_top == 1){
|
||||
if(tcp->prc_t == tcp->prcE){
|
||||
tcp->prc_t = tcp->prcS;
|
||||
pi[pino].poc.precno0 = tcp->prc_t;
|
||||
pi[pino].poc.precno1 = tcp->prc_t+1;
|
||||
tcp->prc_t+=1;
|
||||
incr_top=1;
|
||||
}else{
|
||||
pi[pino].poc.precno0 = tcp->prc_t;
|
||||
pi[pino].poc.precno1 = tcp->prc_t+1;
|
||||
tcp->prc_t+=1;
|
||||
incr_top=0;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.precno0 = tcp->prc_t - 1;
|
||||
pi[pino].poc.precno1 = tcp->prc_t;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (i > tppos){
|
||||
pi[pino].poc.tx0 = tcp->txS;
|
||||
pi[pino].poc.ty0 = tcp->tyS;
|
||||
pi[pino].poc.tx1 = tcp->txE;
|
||||
pi[pino].poc.ty1 = tcp->tyE;
|
||||
}else{
|
||||
if (tpnum == 0){
|
||||
tcp->tx0_t = tcp->txS;
|
||||
tcp->ty0_t = tcp->tyS;
|
||||
pi[pino].poc.tx0 = tcp->tx0_t;
|
||||
pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx - (tcp->tx0_t % tcp->dx);
|
||||
pi[pino].poc.ty0 = tcp->ty0_t;
|
||||
pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
|
||||
tcp->tx0_t = pi[pino].poc.tx1;
|
||||
tcp->ty0_t = pi[pino].poc.ty1;
|
||||
}else{
|
||||
if (incr_top == 1){
|
||||
if(tcp->tx0_t >= tcp->txE){
|
||||
if(tcp->ty0_t >= tcp->tyE){
|
||||
tcp->ty0_t = tcp->tyS;
|
||||
pi[pino].poc.ty0 = tcp->ty0_t;
|
||||
pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
|
||||
tcp->ty0_t = pi[pino].poc.ty1;
|
||||
incr_top=1;resetX=1;
|
||||
}else{
|
||||
pi[pino].poc.ty0 = tcp->ty0_t;
|
||||
pi[pino].poc.ty1 = tcp->ty0_t + tcp->dy - (tcp->ty0_t % tcp->dy);
|
||||
tcp->ty0_t = pi[pino].poc.ty1;
|
||||
incr_top=0;resetX=1;
|
||||
}
|
||||
if(resetX==1){
|
||||
tcp->tx0_t = tcp->txS;
|
||||
pi[pino].poc.tx0 = tcp->tx0_t;
|
||||
pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
|
||||
tcp->tx0_t = pi[pino].poc.tx1;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.tx0 = tcp->tx0_t;
|
||||
pi[pino].poc.tx1 = tcp->tx0_t + tcp->dx- (tcp->tx0_t % tcp->dx);
|
||||
tcp->tx0_t = pi[pino].poc.tx1;
|
||||
pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
|
||||
pi[pino].poc.ty1 = tcp->ty0_t ;
|
||||
incr_top=0;
|
||||
}
|
||||
}else{
|
||||
pi[pino].poc.tx0 = tcp->tx0_t - tcp->dx - (tcp->tx0_t % tcp->dx);
|
||||
pi[pino].poc.tx1 = tcp->tx0_t ;
|
||||
pi[pino].poc.ty0 = tcp->ty0_t - tcp->dy - (tcp->ty0_t % tcp->dy);
|
||||
pi[pino].poc.ty1 = tcp->ty0_t ;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
@@ -1,156 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __PI_H
|
||||
#define __PI_H
|
||||
/**
|
||||
@file pi.h
|
||||
@brief Implementation of a packet iterator (PI)
|
||||
|
||||
The functions in PI.C have for goal to realize a packet iterator that permits to get the next
|
||||
packet following the progression order and change of it. The functions in PI.C are used
|
||||
by some function in T2.C.
|
||||
*/
|
||||
|
||||
/** @defgroup PI PI - Implementation of a packet iterator */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_pi_resolution {
|
||||
int pdx, pdy;
|
||||
int pw, ph;
|
||||
} opj_pi_resolution_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_pi_comp {
|
||||
int dx, dy;
|
||||
/** number of resolution levels */
|
||||
int numresolutions;
|
||||
opj_pi_resolution_t *resolutions;
|
||||
} opj_pi_comp_t;
|
||||
|
||||
/**
|
||||
Packet iterator
|
||||
*/
|
||||
typedef struct opj_pi_iterator {
|
||||
/** Enabling Tile part generation*/
|
||||
char tp_on;
|
||||
/** precise if the packet has been already used (usefull for progression order change) */
|
||||
short int *include;
|
||||
/** layer step used to localize the packet in the include vector */
|
||||
int step_l;
|
||||
/** resolution step used to localize the packet in the include vector */
|
||||
int step_r;
|
||||
/** component step used to localize the packet in the include vector */
|
||||
int step_c;
|
||||
/** precinct step used to localize the packet in the include vector */
|
||||
int step_p;
|
||||
/** component that identify the packet */
|
||||
int compno;
|
||||
/** resolution that identify the packet */
|
||||
int resno;
|
||||
/** precinct that identify the packet */
|
||||
int precno;
|
||||
/** layer that identify the packet */
|
||||
int layno;
|
||||
/** 0 if the first packet */
|
||||
int first;
|
||||
/** progression order change information */
|
||||
opj_poc_t poc;
|
||||
/** number of components in the image */
|
||||
int numcomps;
|
||||
/** Components*/
|
||||
opj_pi_comp_t *comps;
|
||||
int tx0, ty0, tx1, ty1;
|
||||
int x, y, dx, dy;
|
||||
} opj_pi_iterator_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a packet iterator for Encoder
|
||||
@param image Raw image for which the packets will be listed
|
||||
@param cp Coding parameters
|
||||
@param tileno Number that identifies the tile for which to list the packets
|
||||
@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
|
||||
@return Returns a packet iterator that points to the first packet of the tile
|
||||
@see pi_destroy
|
||||
*/
|
||||
opj_pi_iterator_t *pi_initialise_encode(opj_image_t *image, opj_cp_t *cp, int tileno,J2K_T2_MODE t2_mode);
|
||||
/**
|
||||
Modify the packet iterator for enabling tile part generation
|
||||
@param pi Handle to the packet iterator generated in pi_initialise_encode
|
||||
@param cp Coding parameters
|
||||
@param tileno Number that identifies the tile for which to list the packets
|
||||
@param pino Iterator index for pi
|
||||
@param tpnum Tile part number of the current tile
|
||||
@param tppos The position of the tile part flag in the progression order
|
||||
@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
|
||||
@param cur_totnum_tp The total number of tile parts in the current tile
|
||||
@return Returns true if an error is detected
|
||||
*/
|
||||
opj_bool pi_create_encode(opj_pi_iterator_t *pi, opj_cp_t *cp,int tileno, int pino,int tpnum, int tppos, J2K_T2_MODE t2_mode,int cur_totnum_tp);
|
||||
/**
|
||||
Create a packet iterator for Decoder
|
||||
@param image Raw image for which the packets will be listed
|
||||
@param cp Coding parameters
|
||||
@param tileno Number that identifies the tile for which to list the packets
|
||||
@return Returns a packet iterator that points to the first packet of the tile
|
||||
@see pi_destroy
|
||||
*/
|
||||
opj_pi_iterator_t *pi_create_decode(opj_image_t * image, opj_cp_t * cp, int tileno);
|
||||
|
||||
/**
|
||||
Destroy a packet iterator
|
||||
@param pi Previously created packet iterator
|
||||
@param cp Coding parameters
|
||||
@param tileno Number that identifies the tile for which the packets were listed
|
||||
@see pi_create
|
||||
*/
|
||||
void pi_destroy(opj_pi_iterator_t *pi, opj_cp_t *cp, int tileno);
|
||||
|
||||
/**
|
||||
Modify the packet iterator to point to the next packet
|
||||
@param pi Packet iterator to modify
|
||||
@return Returns false if pi pointed to the last packet or else returns true
|
||||
*/
|
||||
opj_bool pi_next(opj_pi_iterator_t * pi);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __PI_H */
|
||||
@@ -1,173 +0,0 @@
|
||||
/*
|
||||
* $Id: ppix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.c from 2KAN indexer
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
* Write faix box of ppix
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] compno component number
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] EPHused true if if EPH option used
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of faix box
|
||||
*/
|
||||
int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio);
|
||||
|
||||
int write_ppix( int coff, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp, compno, i;
|
||||
opj_jp2_box_t *box;
|
||||
|
||||
/* printf("cstr_info.packno %d\n", cstr_info.packno); //NMAX? */
|
||||
|
||||
lenp = -1;
|
||||
box = (opj_jp2_box_t *)opj_calloc( cstr_info.numcomps, sizeof(opj_jp2_box_t));
|
||||
|
||||
for (i=0;i<2;i++){
|
||||
if (i) cio_seek( cio, lenp);
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_PPIX, 4); /* PPIX */
|
||||
|
||||
write_manf( i, cstr_info.numcomps, box, cio);
|
||||
|
||||
for (compno=0; compno<cstr_info.numcomps; compno++){
|
||||
box[compno].length = write_ppixfaix( coff, compno, cstr_info, EPHused, j2klen, cio);
|
||||
box[compno].type = JPIP_FAIX;
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
opj_free(box);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int write_ppixfaix( int coff, int compno, opj_codestream_info_t cstr_info, opj_bool EPHused, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp, tileno, version, i, nmax, size_of_coding; /* 4 or 8*/
|
||||
opj_tile_info_t *tile_Idx;
|
||||
opj_packet_info_t packet;
|
||||
int resno, precno, layno, num_packet;
|
||||
int numOfres, numOfprec, numOflayers;
|
||||
packet.end_pos = packet.end_ph_pos = packet.start_pos = -1;
|
||||
(void)EPHused; /* unused ? */
|
||||
|
||||
if( j2klen > pow( 2, 32)){
|
||||
size_of_coding = 8;
|
||||
version = 1;
|
||||
}
|
||||
else{
|
||||
size_of_coding = 4;
|
||||
version = 0;
|
||||
}
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_FAIX, 4); /* FAIX */
|
||||
cio_write( cio, version, 1); /* Version 0 = 4 bytes */
|
||||
|
||||
nmax = 0;
|
||||
for( i=0; i<=cstr_info.numdecompos[compno]; i++)
|
||||
nmax += cstr_info.tile[0].ph[i] * cstr_info.tile[0].pw[i] * cstr_info.numlayers;
|
||||
|
||||
cio_write( cio, nmax, size_of_coding); /* NMAX */
|
||||
cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding); /* M */
|
||||
|
||||
for( tileno=0; tileno<cstr_info.tw*cstr_info.th; tileno++){
|
||||
tile_Idx = &cstr_info.tile[ tileno];
|
||||
|
||||
num_packet=0;
|
||||
numOfres = cstr_info.numdecompos[compno] + 1;
|
||||
|
||||
for( resno=0; resno<numOfres ; resno++){
|
||||
numOfprec = tile_Idx->pw[resno]*tile_Idx->ph[resno];
|
||||
for( precno=0; precno<numOfprec; precno++){
|
||||
numOflayers = cstr_info.numlayers;
|
||||
for( layno=0; layno<numOflayers; layno++){
|
||||
|
||||
switch ( cstr_info.prog){
|
||||
case LRCP:
|
||||
packet = tile_Idx->packet[ ((layno*numOfres+resno)*cstr_info.numcomps+compno)*numOfprec+precno];
|
||||
break;
|
||||
case RLCP:
|
||||
packet = tile_Idx->packet[ ((resno*numOflayers+layno)*cstr_info.numcomps+compno)*numOfprec+precno];
|
||||
break;
|
||||
case RPCL:
|
||||
packet = tile_Idx->packet[ ((resno*numOfprec+precno)*cstr_info.numcomps+compno)*numOflayers+layno];
|
||||
break;
|
||||
case PCRL:
|
||||
packet = tile_Idx->packet[ ((precno*cstr_info.numcomps+compno)*numOfres+resno)*numOflayers + layno];
|
||||
break;
|
||||
case CPRL:
|
||||
packet = tile_Idx->packet[ ((compno*numOfprec+precno)*numOfres+resno)*numOflayers + layno];
|
||||
break;
|
||||
default:
|
||||
fprintf( stderr, "failed to ppix indexing\n");
|
||||
}
|
||||
|
||||
cio_write( cio, packet.start_pos-coff, size_of_coding); /* start position */
|
||||
cio_write( cio, packet.end_pos-packet.start_pos+1, size_of_coding); /* length */
|
||||
|
||||
num_packet++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while( num_packet < nmax){ /* PADDING */
|
||||
cio_write( cio, 0, size_of_coding); /* start position */
|
||||
cio_write( cio, 0, size_of_coding); /* length */
|
||||
num_packet++;
|
||||
}
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
}
|
||||
@@ -1,87 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
local functions
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
RAW encoding interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_raw_t* raw_create(void) {
|
||||
opj_raw_t *raw = (opj_raw_t*)opj_malloc(sizeof(opj_raw_t));
|
||||
return raw;
|
||||
}
|
||||
|
||||
void raw_destroy(opj_raw_t *raw) {
|
||||
if(raw) {
|
||||
opj_free(raw);
|
||||
}
|
||||
}
|
||||
|
||||
int raw_numbytes(opj_raw_t *raw) {
|
||||
return raw->bp - raw->start;
|
||||
}
|
||||
|
||||
void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len) {
|
||||
raw->start = bp;
|
||||
raw->lenmax = len;
|
||||
raw->len = 0;
|
||||
raw->c = 0;
|
||||
raw->ct = 0;
|
||||
}
|
||||
|
||||
int raw_decode(opj_raw_t *raw) {
|
||||
int d;
|
||||
if (raw->ct == 0) {
|
||||
raw->ct = 8;
|
||||
if (raw->len == raw->lenmax) {
|
||||
raw->c = 0xff;
|
||||
} else {
|
||||
if (raw->c == 0xff) {
|
||||
raw->ct = 7;
|
||||
}
|
||||
raw->c = *(raw->start + raw->len);
|
||||
raw->len++;
|
||||
}
|
||||
}
|
||||
raw->ct--;
|
||||
d = (raw->c >> raw->ct) & 0x01;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
@@ -1,100 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __RAW_H
|
||||
#define __RAW_H
|
||||
/**
|
||||
@file raw.h
|
||||
@brief Implementation of operations for raw encoding (RAW)
|
||||
|
||||
The functions in RAW.C have for goal to realize the operation of raw encoding linked
|
||||
with the corresponding mode switch.
|
||||
*/
|
||||
|
||||
/** @defgroup RAW RAW - Implementation of operations for raw encoding */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
RAW encoding operations
|
||||
*/
|
||||
typedef struct opj_raw {
|
||||
/** temporary buffer where bits are coded or decoded */
|
||||
unsigned char c;
|
||||
/** number of bits already read or free to write */
|
||||
unsigned int ct;
|
||||
/** maximum length to decode */
|
||||
unsigned int lenmax;
|
||||
/** length decoded */
|
||||
unsigned int len;
|
||||
/** pointer to the current position in the buffer */
|
||||
unsigned char *bp;
|
||||
/** pointer to the start of the buffer */
|
||||
unsigned char *start;
|
||||
/** pointer to the end of the buffer */
|
||||
unsigned char *end;
|
||||
} opj_raw_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new RAW handle
|
||||
@return Returns a new RAW handle if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_raw_t* raw_create(void);
|
||||
/**
|
||||
Destroy a previously created RAW handle
|
||||
@param raw RAW handle to destroy
|
||||
*/
|
||||
void raw_destroy(opj_raw_t *raw);
|
||||
/**
|
||||
Return the number of bytes written/read since initialisation
|
||||
@param raw RAW handle to destroy
|
||||
@return Returns the number of bytes already encoded
|
||||
*/
|
||||
int raw_numbytes(opj_raw_t *raw);
|
||||
/**
|
||||
Initialize the decoder
|
||||
@param raw RAW handle
|
||||
@param bp Pointer to the start of the buffer from which the bytes will be read
|
||||
@param len Length of the input buffer
|
||||
*/
|
||||
void raw_init_dec(opj_raw_t *raw, unsigned char *bp, int len);
|
||||
/**
|
||||
Decode a symbol using raw-decoder. Cfr p.506 TAUBMAN
|
||||
@param raw RAW handle
|
||||
@return Returns the decoded symbol (0 or 1)
|
||||
*/
|
||||
int raw_decode(opj_raw_t *raw);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __RAW_H */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,147 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __T1_H
|
||||
#define __T1_H
|
||||
/**
|
||||
@file t1.h
|
||||
@brief Implementation of the tier-1 coding (coding of code-block coefficients) (T1)
|
||||
|
||||
The functions in T1.C have for goal to realize the tier-1 coding operation. The functions
|
||||
in T1.C are used by some function in TCD.C.
|
||||
*/
|
||||
|
||||
/** @defgroup T1 T1 - Implementation of the tier-1 coding */
|
||||
/*@{*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
#define T1_NMSEDEC_BITS 7
|
||||
|
||||
#define T1_SIG_NE 0x0001 /**< Context orientation : North-East direction */
|
||||
#define T1_SIG_SE 0x0002 /**< Context orientation : South-East direction */
|
||||
#define T1_SIG_SW 0x0004 /**< Context orientation : South-West direction */
|
||||
#define T1_SIG_NW 0x0008 /**< Context orientation : North-West direction */
|
||||
#define T1_SIG_N 0x0010 /**< Context orientation : North direction */
|
||||
#define T1_SIG_E 0x0020 /**< Context orientation : East direction */
|
||||
#define T1_SIG_S 0x0040 /**< Context orientation : South direction */
|
||||
#define T1_SIG_W 0x0080 /**< Context orientation : West direction */
|
||||
#define T1_SIG_OTH (T1_SIG_N|T1_SIG_NE|T1_SIG_E|T1_SIG_SE|T1_SIG_S|T1_SIG_SW|T1_SIG_W|T1_SIG_NW)
|
||||
#define T1_SIG_PRIM (T1_SIG_N|T1_SIG_E|T1_SIG_S|T1_SIG_W)
|
||||
|
||||
#define T1_SGN_N 0x0100
|
||||
#define T1_SGN_E 0x0200
|
||||
#define T1_SGN_S 0x0400
|
||||
#define T1_SGN_W 0x0800
|
||||
#define T1_SGN (T1_SGN_N|T1_SGN_E|T1_SGN_S|T1_SGN_W)
|
||||
|
||||
#define T1_SIG 0x1000
|
||||
#define T1_REFINE 0x2000
|
||||
#define T1_VISIT 0x4000
|
||||
|
||||
#define T1_NUMCTXS_ZC 9
|
||||
#define T1_NUMCTXS_SC 5
|
||||
#define T1_NUMCTXS_MAG 3
|
||||
#define T1_NUMCTXS_AGG 1
|
||||
#define T1_NUMCTXS_UNI 1
|
||||
|
||||
#define T1_CTXNO_ZC 0
|
||||
#define T1_CTXNO_SC (T1_CTXNO_ZC+T1_NUMCTXS_ZC)
|
||||
#define T1_CTXNO_MAG (T1_CTXNO_SC+T1_NUMCTXS_SC)
|
||||
#define T1_CTXNO_AGG (T1_CTXNO_MAG+T1_NUMCTXS_MAG)
|
||||
#define T1_CTXNO_UNI (T1_CTXNO_AGG+T1_NUMCTXS_AGG)
|
||||
#define T1_NUMCTXS (T1_CTXNO_UNI+T1_NUMCTXS_UNI)
|
||||
|
||||
#define T1_NMSEDEC_FRACBITS (T1_NMSEDEC_BITS-1)
|
||||
|
||||
#define T1_TYPE_MQ 0 /**< Normal coding using entropy coder */
|
||||
#define T1_TYPE_RAW 1 /**< No encoding the information is store under raw format in codestream (mode switch RAW)*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
typedef short flag_t;
|
||||
|
||||
/**
|
||||
Tier-1 coding (coding of code-block coefficients)
|
||||
*/
|
||||
typedef struct opj_t1 {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** MQC component */
|
||||
opj_mqc_t *mqc;
|
||||
/** RAW component */
|
||||
opj_raw_t *raw;
|
||||
|
||||
int *data;
|
||||
flag_t *flags;
|
||||
int w;
|
||||
int h;
|
||||
int datasize;
|
||||
int flagssize;
|
||||
int flags_stride;
|
||||
} opj_t1_t;
|
||||
|
||||
#define MACRO_t1_flags(x,y) t1->flags[((x)*(t1->flags_stride))+(y)]
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a new T1 handle
|
||||
and initialize the look-up tables of the Tier-1 coder/decoder
|
||||
@return Returns a new T1 handle if successful, returns NULL otherwise
|
||||
@see t1_init_luts
|
||||
*/
|
||||
opj_t1_t* t1_create(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a previously created T1 handle
|
||||
@param t1 T1 handle to destroy
|
||||
*/
|
||||
void t1_destroy(opj_t1_t *t1);
|
||||
/**
|
||||
Encode the code-blocks of a tile
|
||||
@param t1 T1 handle
|
||||
@param tile The tile to encode
|
||||
@param tcp Tile coding parameters
|
||||
*/
|
||||
void t1_encode_cblks(opj_t1_t *t1, opj_tcd_tile_t *tile, opj_tcp_t *tcp);
|
||||
/**
|
||||
Decode the code-blocks of a tile
|
||||
@param t1 T1 handle
|
||||
@param tilec The tile to decode
|
||||
@param tccp Tile coding parameters
|
||||
*/
|
||||
void t1_decode_cblks(opj_t1_t* t1, opj_tcd_tilecomp_t* tilec, opj_tccp_t* tccp);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __T1_H */
|
||||
@@ -1,275 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
#include <math.h>
|
||||
|
||||
static int t1_init_ctxno_zc(int f, int orient) {
|
||||
int h, v, d, n, t, hv;
|
||||
n = 0;
|
||||
h = ((f & T1_SIG_W) != 0) + ((f & T1_SIG_E) != 0);
|
||||
v = ((f & T1_SIG_N) != 0) + ((f & T1_SIG_S) != 0);
|
||||
d = ((f & T1_SIG_NW) != 0) + ((f & T1_SIG_NE) != 0) + ((f & T1_SIG_SE) != 0) + ((f & T1_SIG_SW) != 0);
|
||||
|
||||
switch (orient) {
|
||||
case 2:
|
||||
t = h;
|
||||
h = v;
|
||||
v = t;
|
||||
case 0:
|
||||
case 1:
|
||||
if (!h) {
|
||||
if (!v) {
|
||||
if (!d)
|
||||
n = 0;
|
||||
else if (d == 1)
|
||||
n = 1;
|
||||
else
|
||||
n = 2;
|
||||
} else if (v == 1) {
|
||||
n = 3;
|
||||
} else {
|
||||
n = 4;
|
||||
}
|
||||
} else if (h == 1) {
|
||||
if (!v) {
|
||||
if (!d)
|
||||
n = 5;
|
||||
else
|
||||
n = 6;
|
||||
} else {
|
||||
n = 7;
|
||||
}
|
||||
} else
|
||||
n = 8;
|
||||
break;
|
||||
case 3:
|
||||
hv = h + v;
|
||||
if (!d) {
|
||||
if (!hv) {
|
||||
n = 0;
|
||||
} else if (hv == 1) {
|
||||
n = 1;
|
||||
} else {
|
||||
n = 2;
|
||||
}
|
||||
} else if (d == 1) {
|
||||
if (!hv) {
|
||||
n = 3;
|
||||
} else if (hv == 1) {
|
||||
n = 4;
|
||||
} else {
|
||||
n = 5;
|
||||
}
|
||||
} else if (d == 2) {
|
||||
if (!hv) {
|
||||
n = 6;
|
||||
} else {
|
||||
n = 7;
|
||||
}
|
||||
} else {
|
||||
n = 8;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return (T1_CTXNO_ZC + n);
|
||||
}
|
||||
|
||||
static int t1_init_ctxno_sc(int f) {
|
||||
int hc, vc, n;
|
||||
n = 0;
|
||||
|
||||
hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
|
||||
T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
|
||||
1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
|
||||
(T1_SIG_E | T1_SGN_E)) +
|
||||
((f & (T1_SIG_W | T1_SGN_W)) ==
|
||||
(T1_SIG_W | T1_SGN_W)), 1);
|
||||
|
||||
vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
|
||||
T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
|
||||
1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
|
||||
(T1_SIG_N | T1_SGN_N)) +
|
||||
((f & (T1_SIG_S | T1_SGN_S)) ==
|
||||
(T1_SIG_S | T1_SGN_S)), 1);
|
||||
|
||||
if (hc < 0) {
|
||||
hc = -hc;
|
||||
vc = -vc;
|
||||
}
|
||||
if (!hc) {
|
||||
if (vc == -1)
|
||||
n = 1;
|
||||
else if (!vc)
|
||||
n = 0;
|
||||
else
|
||||
n = 1;
|
||||
} else if (hc == 1) {
|
||||
if (vc == -1)
|
||||
n = 2;
|
||||
else if (!vc)
|
||||
n = 3;
|
||||
else
|
||||
n = 4;
|
||||
}
|
||||
|
||||
return (T1_CTXNO_SC + n);
|
||||
}
|
||||
|
||||
static int t1_init_spb(int f) {
|
||||
int hc, vc, n;
|
||||
|
||||
hc = int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
|
||||
T1_SIG_E) + ((f & (T1_SIG_W | T1_SGN_W)) == T1_SIG_W),
|
||||
1) - int_min(((f & (T1_SIG_E | T1_SGN_E)) ==
|
||||
(T1_SIG_E | T1_SGN_E)) +
|
||||
((f & (T1_SIG_W | T1_SGN_W)) ==
|
||||
(T1_SIG_W | T1_SGN_W)), 1);
|
||||
|
||||
vc = int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
|
||||
T1_SIG_N) + ((f & (T1_SIG_S | T1_SGN_S)) == T1_SIG_S),
|
||||
1) - int_min(((f & (T1_SIG_N | T1_SGN_N)) ==
|
||||
(T1_SIG_N | T1_SGN_N)) +
|
||||
((f & (T1_SIG_S | T1_SGN_S)) ==
|
||||
(T1_SIG_S | T1_SGN_S)), 1);
|
||||
|
||||
if (!hc && !vc)
|
||||
n = 0;
|
||||
else
|
||||
n = (!(hc > 0 || (!hc && vc > 0)));
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
void dump_array16(int array[],int size){
|
||||
int i;
|
||||
--size;
|
||||
for (i = 0; i < size; ++i) {
|
||||
printf("0x%04x, ", array[i]);
|
||||
if(!((i+1)&0x7))
|
||||
printf("\n ");
|
||||
}
|
||||
printf("0x%04x\n};\n\n", array[size]);
|
||||
}
|
||||
|
||||
int main(){
|
||||
int i, j;
|
||||
double u, v, t;
|
||||
|
||||
int lut_ctxno_zc[1024];
|
||||
int lut_nmsedec_sig[1 << T1_NMSEDEC_BITS];
|
||||
int lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS];
|
||||
int lut_nmsedec_ref[1 << T1_NMSEDEC_BITS];
|
||||
int lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS];
|
||||
|
||||
printf("/* This file was automatically generated by t1_generate_luts.c */\n\n");
|
||||
|
||||
// lut_ctxno_zc
|
||||
for (j = 0; j < 4; ++j) {
|
||||
for (i = 0; i < 256; ++i) {
|
||||
int orient = j;
|
||||
if (orient == 2) {
|
||||
orient = 1;
|
||||
} else if (orient == 1) {
|
||||
orient = 2;
|
||||
}
|
||||
lut_ctxno_zc[(orient << 8) | i] = t1_init_ctxno_zc(i, j);
|
||||
}
|
||||
}
|
||||
|
||||
printf("static char lut_ctxno_zc[1024] = {\n ");
|
||||
for (i = 0; i < 1023; ++i) {
|
||||
printf("%i, ", lut_ctxno_zc[i]);
|
||||
if(!((i+1)&0x1f))
|
||||
printf("\n ");
|
||||
}
|
||||
printf("%i\n};\n\n", lut_ctxno_zc[1023]);
|
||||
|
||||
// lut_ctxno_sc
|
||||
printf("static char lut_ctxno_sc[256] = {\n ");
|
||||
for (i = 0; i < 255; ++i) {
|
||||
printf("0x%x, ", t1_init_ctxno_sc(i << 4));
|
||||
if(!((i+1)&0xf))
|
||||
printf("\n ");
|
||||
}
|
||||
printf("0x%x\n};\n\n", t1_init_ctxno_sc(255 << 4));
|
||||
|
||||
// lut_spb
|
||||
printf("static char lut_spb[256] = {\n ");
|
||||
for (i = 0; i < 255; ++i) {
|
||||
printf("%i, ", t1_init_spb(i << 4));
|
||||
if(!((i+1)&0x1f))
|
||||
printf("\n ");
|
||||
}
|
||||
printf("%i\n};\n\n", t1_init_spb(255 << 4));
|
||||
|
||||
/* FIXME FIXME FIXME */
|
||||
/* fprintf(stdout,"nmsedec luts:\n"); */
|
||||
for (i = 0; i < (1 << T1_NMSEDEC_BITS); ++i) {
|
||||
t = i / pow(2, T1_NMSEDEC_FRACBITS);
|
||||
u = t;
|
||||
v = t - 1.5;
|
||||
lut_nmsedec_sig[i] =
|
||||
int_max(0,
|
||||
(int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
|
||||
lut_nmsedec_sig0[i] =
|
||||
int_max(0,
|
||||
(int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
|
||||
u = t - 1.0;
|
||||
if (i & (1 << (T1_NMSEDEC_BITS - 1))) {
|
||||
v = t - 1.5;
|
||||
} else {
|
||||
v = t - 0.5;
|
||||
}
|
||||
lut_nmsedec_ref[i] =
|
||||
int_max(0,
|
||||
(int) (floor((u * u - v * v) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
|
||||
lut_nmsedec_ref0[i] =
|
||||
int_max(0,
|
||||
(int) (floor((u * u) * pow(2, T1_NMSEDEC_FRACBITS) + 0.5) / pow(2, T1_NMSEDEC_FRACBITS) * 8192.0));
|
||||
}
|
||||
|
||||
printf("static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {\n ");
|
||||
dump_array16(lut_nmsedec_sig, 1 << T1_NMSEDEC_BITS);
|
||||
|
||||
printf("static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {\n ");
|
||||
dump_array16(lut_nmsedec_sig0, 1 << T1_NMSEDEC_BITS);
|
||||
|
||||
printf("static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {\n ");
|
||||
dump_array16(lut_nmsedec_ref, 1 << T1_NMSEDEC_BITS);
|
||||
|
||||
printf("static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {\n ");
|
||||
dump_array16(lut_nmsedec_ref0, 1 << T1_NMSEDEC_BITS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,143 +0,0 @@
|
||||
/* This file was automatically generated by t1_generate_luts.c */
|
||||
|
||||
static char lut_ctxno_zc[1024] = {
|
||||
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
0, 1, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
|
||||
0, 3, 3, 6, 3, 6, 6, 8, 3, 6, 6, 8, 6, 8, 8, 8, 1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8,
|
||||
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
1, 4, 4, 7, 4, 7, 7, 8, 4, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8,
|
||||
2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8, 2, 5, 5, 7, 5, 7, 7, 8, 5, 7, 7, 8, 7, 8, 8, 8
|
||||
};
|
||||
|
||||
static char lut_ctxno_sc[256] = {
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xb, 0x9, 0xa, 0xb, 0xb, 0xa, 0xa,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xd, 0x9, 0xa, 0xb, 0xc, 0xa, 0x9,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xb, 0xc, 0xb, 0xb, 0xb, 0xb, 0xb,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xd, 0xc, 0xd, 0xb, 0xc, 0xb, 0xc,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0x9, 0xb, 0xc, 0xc, 0xb, 0x9, 0xa, 0xd, 0xc, 0xa, 0x9,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0xa, 0xb, 0xb, 0xc, 0xd, 0x9, 0xa, 0xd, 0xd, 0xa, 0xa,
|
||||
0x9, 0xa, 0xc, 0xb, 0xa, 0x9, 0xd, 0xc, 0xc, 0xb, 0xc, 0xb, 0xd, 0xc, 0xd, 0xc,
|
||||
0x9, 0xa, 0xc, 0xd, 0xa, 0xa, 0xd, 0xd, 0xc, 0xd, 0xc, 0xd, 0xd, 0xd, 0xd, 0xd
|
||||
};
|
||||
|
||||
static char lut_spb[256] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0,
|
||||
0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1,
|
||||
0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
|
||||
};
|
||||
|
||||
static short lut_nmsedec_sig[1 << T1_NMSEDEC_BITS] = {
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0180, 0x0300, 0x0480, 0x0600, 0x0780, 0x0900, 0x0a80,
|
||||
0x0c00, 0x0d80, 0x0f00, 0x1080, 0x1200, 0x1380, 0x1500, 0x1680,
|
||||
0x1800, 0x1980, 0x1b00, 0x1c80, 0x1e00, 0x1f80, 0x2100, 0x2280,
|
||||
0x2400, 0x2580, 0x2700, 0x2880, 0x2a00, 0x2b80, 0x2d00, 0x2e80,
|
||||
0x3000, 0x3180, 0x3300, 0x3480, 0x3600, 0x3780, 0x3900, 0x3a80,
|
||||
0x3c00, 0x3d80, 0x3f00, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680,
|
||||
0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5100, 0x5280,
|
||||
0x5400, 0x5580, 0x5700, 0x5880, 0x5a00, 0x5b80, 0x5d00, 0x5e80,
|
||||
0x6000, 0x6180, 0x6300, 0x6480, 0x6600, 0x6780, 0x6900, 0x6a80,
|
||||
0x6c00, 0x6d80, 0x6f00, 0x7080, 0x7200, 0x7380, 0x7500, 0x7680
|
||||
};
|
||||
|
||||
static short lut_nmsedec_sig0[1 << T1_NMSEDEC_BITS] = {
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080,
|
||||
0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200,
|
||||
0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400,
|
||||
0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
|
||||
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00,
|
||||
0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180,
|
||||
0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780,
|
||||
0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00,
|
||||
0x2000, 0x2100, 0x2200, 0x2300, 0x2400, 0x2500, 0x2680, 0x2780,
|
||||
0x2880, 0x2980, 0x2b00, 0x2c00, 0x2d00, 0x2e80, 0x2f80, 0x3100,
|
||||
0x3200, 0x3380, 0x3480, 0x3600, 0x3700, 0x3880, 0x3a00, 0x3b00,
|
||||
0x3c80, 0x3e00, 0x3f80, 0x4080, 0x4200, 0x4380, 0x4500, 0x4680,
|
||||
0x4800, 0x4980, 0x4b00, 0x4c80, 0x4e00, 0x4f80, 0x5180, 0x5300,
|
||||
0x5480, 0x5600, 0x5800, 0x5980, 0x5b00, 0x5d00, 0x5e80, 0x6080,
|
||||
0x6200, 0x6400, 0x6580, 0x6780, 0x6900, 0x6b00, 0x6d00, 0x6e80,
|
||||
0x7080, 0x7280, 0x7480, 0x7600, 0x7800, 0x7a00, 0x7c00, 0x7e00
|
||||
};
|
||||
|
||||
static short lut_nmsedec_ref[1 << T1_NMSEDEC_BITS] = {
|
||||
0x1800, 0x1780, 0x1700, 0x1680, 0x1600, 0x1580, 0x1500, 0x1480,
|
||||
0x1400, 0x1380, 0x1300, 0x1280, 0x1200, 0x1180, 0x1100, 0x1080,
|
||||
0x1000, 0x0f80, 0x0f00, 0x0e80, 0x0e00, 0x0d80, 0x0d00, 0x0c80,
|
||||
0x0c00, 0x0b80, 0x0b00, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880,
|
||||
0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0500, 0x0480,
|
||||
0x0400, 0x0380, 0x0300, 0x0280, 0x0200, 0x0180, 0x0100, 0x0080,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0080, 0x0100, 0x0180, 0x0200, 0x0280, 0x0300, 0x0380,
|
||||
0x0400, 0x0480, 0x0500, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
|
||||
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b00, 0x0b80,
|
||||
0x0c00, 0x0c80, 0x0d00, 0x0d80, 0x0e00, 0x0e80, 0x0f00, 0x0f80,
|
||||
0x1000, 0x1080, 0x1100, 0x1180, 0x1200, 0x1280, 0x1300, 0x1380,
|
||||
0x1400, 0x1480, 0x1500, 0x1580, 0x1600, 0x1680, 0x1700, 0x1780
|
||||
};
|
||||
|
||||
static short lut_nmsedec_ref0[1 << T1_NMSEDEC_BITS] = {
|
||||
0x2000, 0x1f00, 0x1e00, 0x1d00, 0x1c00, 0x1b00, 0x1a80, 0x1980,
|
||||
0x1880, 0x1780, 0x1700, 0x1600, 0x1500, 0x1480, 0x1380, 0x1300,
|
||||
0x1200, 0x1180, 0x1080, 0x1000, 0x0f00, 0x0e80, 0x0e00, 0x0d00,
|
||||
0x0c80, 0x0c00, 0x0b80, 0x0a80, 0x0a00, 0x0980, 0x0900, 0x0880,
|
||||
0x0800, 0x0780, 0x0700, 0x0680, 0x0600, 0x0580, 0x0580, 0x0500,
|
||||
0x0480, 0x0400, 0x0400, 0x0380, 0x0300, 0x0300, 0x0280, 0x0280,
|
||||
0x0200, 0x0200, 0x0180, 0x0180, 0x0100, 0x0100, 0x0100, 0x0080,
|
||||
0x0080, 0x0080, 0x0080, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0080,
|
||||
0x0080, 0x0080, 0x0100, 0x0100, 0x0100, 0x0180, 0x0180, 0x0200,
|
||||
0x0200, 0x0280, 0x0280, 0x0300, 0x0300, 0x0380, 0x0400, 0x0400,
|
||||
0x0480, 0x0500, 0x0580, 0x0580, 0x0600, 0x0680, 0x0700, 0x0780,
|
||||
0x0800, 0x0880, 0x0900, 0x0980, 0x0a00, 0x0a80, 0x0b80, 0x0c00,
|
||||
0x0c80, 0x0d00, 0x0e00, 0x0e80, 0x0f00, 0x1000, 0x1080, 0x1180,
|
||||
0x1200, 0x1300, 0x1380, 0x1480, 0x1500, 0x1600, 0x1700, 0x1780,
|
||||
0x1880, 0x1980, 0x1a80, 0x1b00, 0x1c00, 0x1d00, 0x1e00, 0x1f00
|
||||
};
|
||||
|
||||
@@ -1,822 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/** @defgroup T2 T2 - Implementation of a tier-2 coding */
|
||||
/*@{*/
|
||||
|
||||
/** @name Local static functions */
|
||||
/*@{*/
|
||||
|
||||
static void t2_putcommacode(opj_bio_t *bio, int n);
|
||||
static int t2_getcommacode(opj_bio_t *bio);
|
||||
/**
|
||||
Variable length code for signalling delta Zil (truncation point)
|
||||
@param bio Bit Input/Output component
|
||||
@param n delta Zil
|
||||
*/
|
||||
static void t2_putnumpasses(opj_bio_t *bio, int n);
|
||||
static int t2_getnumpasses(opj_bio_t *bio);
|
||||
/**
|
||||
Encode a packet of a tile to a destination buffer
|
||||
@param tile Tile for which to write the packets
|
||||
@param tcp Tile coding parameters
|
||||
@param pi Packet identity
|
||||
@param dest Destination buffer
|
||||
@param len Length of the destination buffer
|
||||
@param cstr_info Codestream information structure
|
||||
@param tileno Number of the tile encoded
|
||||
@return
|
||||
*/
|
||||
static int t2_encode_packet(opj_tcd_tile_t *tile, opj_tcp_t *tcp, opj_pi_iterator_t *pi, unsigned char *dest, int len, opj_codestream_info_t *cstr_info, int tileno);
|
||||
/**
|
||||
@param cblk
|
||||
@param index
|
||||
@param cblksty
|
||||
@param first
|
||||
*/
|
||||
static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first);
|
||||
/**
|
||||
Decode a packet of a tile from a source buffer
|
||||
@param t2 T2 handle
|
||||
@param src Source buffer
|
||||
@param len Length of the source buffer
|
||||
@param tile Tile for which to write the packets
|
||||
@param tcp Tile coding parameters
|
||||
@param pi Packet identity
|
||||
@param pack_info Packet information
|
||||
@return
|
||||
*/
|
||||
static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile,
|
||||
opj_tcp_t *tcp, opj_pi_iterator_t *pi, opj_packet_info_t *pack_info);
|
||||
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/* #define RESTART 0x04 */
|
||||
|
||||
static void t2_putcommacode(opj_bio_t *bio, int n) {
|
||||
while (--n >= 0) {
|
||||
bio_write(bio, 1, 1);
|
||||
}
|
||||
bio_write(bio, 0, 1);
|
||||
}
|
||||
|
||||
static int t2_getcommacode(opj_bio_t *bio) {
|
||||
int n;
|
||||
for (n = 0; bio_read(bio, 1); n++) {
|
||||
;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
static void t2_putnumpasses(opj_bio_t *bio, int n) {
|
||||
if (n == 1) {
|
||||
bio_write(bio, 0, 1);
|
||||
} else if (n == 2) {
|
||||
bio_write(bio, 2, 2);
|
||||
} else if (n <= 5) {
|
||||
bio_write(bio, 0xc | (n - 3), 4);
|
||||
} else if (n <= 36) {
|
||||
bio_write(bio, 0x1e0 | (n - 6), 9);
|
||||
} else if (n <= 164) {
|
||||
bio_write(bio, 0xff80 | (n - 37), 16);
|
||||
}
|
||||
}
|
||||
|
||||
static int t2_getnumpasses(opj_bio_t *bio) {
|
||||
int n;
|
||||
if (!bio_read(bio, 1))
|
||||
return 1;
|
||||
if (!bio_read(bio, 1))
|
||||
return 2;
|
||||
if ((n = bio_read(bio, 2)) != 3)
|
||||
return (3 + n);
|
||||
if ((n = bio_read(bio, 5)) != 31)
|
||||
return (6 + n);
|
||||
return (37 + bio_read(bio, 7));
|
||||
}
|
||||
|
||||
static int t2_encode_packet(opj_tcd_tile_t * tile, opj_tcp_t * tcp, opj_pi_iterator_t *pi, unsigned char *dest, int length, opj_codestream_info_t *cstr_info, int tileno) {
|
||||
int bandno, cblkno;
|
||||
unsigned char *c = dest;
|
||||
|
||||
int compno = pi->compno; /* component value */
|
||||
int resno = pi->resno; /* resolution level value */
|
||||
int precno = pi->precno; /* precinct value */
|
||||
int layno = pi->layno; /* quality layer value */
|
||||
|
||||
opj_tcd_tilecomp_t *tilec = &tile->comps[compno];
|
||||
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
|
||||
|
||||
opj_bio_t *bio = NULL; /* BIO component */
|
||||
|
||||
/* <SOP 0xff91> */
|
||||
if (tcp->csty & J2K_CP_CSTY_SOP) {
|
||||
c[0] = 255;
|
||||
c[1] = 145;
|
||||
c[2] = 0;
|
||||
c[3] = 4;
|
||||
c[4] = (unsigned char)((tile->packno % 65536) / 256);
|
||||
c[5] = (unsigned char)((tile->packno % 65536) % 256);
|
||||
c += 6;
|
||||
}
|
||||
/* </SOP> */
|
||||
|
||||
if (!layno) {
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
tgt_reset(prc->incltree);
|
||||
tgt_reset(prc->imsbtree);
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
|
||||
cblk->numpasses = 0;
|
||||
tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bio = bio_create();
|
||||
bio_init_enc(bio, c, length);
|
||||
bio_write(bio, 1, 1); /* Empty header bit */
|
||||
|
||||
/* Writing Packet header */
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
if (!cblk->numpasses && layer->numpasses) {
|
||||
tgt_setvalue(prc->incltree, cblkno, layno);
|
||||
}
|
||||
}
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
int increment = 0;
|
||||
int nump = 0;
|
||||
int len = 0, passno;
|
||||
/* cblk inclusion bits */
|
||||
if (!cblk->numpasses) {
|
||||
tgt_encode(bio, prc->incltree, cblkno, layno + 1);
|
||||
} else {
|
||||
bio_write(bio, layer->numpasses != 0, 1);
|
||||
}
|
||||
/* if cblk not included, go to the next cblk */
|
||||
if (!layer->numpasses) {
|
||||
continue;
|
||||
}
|
||||
/* if first instance of cblk --> zero bit-planes information */
|
||||
if (!cblk->numpasses) {
|
||||
cblk->numlenbits = 3;
|
||||
tgt_encode(bio, prc->imsbtree, cblkno, 999);
|
||||
}
|
||||
/* number of coding passes included */
|
||||
t2_putnumpasses(bio, layer->numpasses);
|
||||
|
||||
/* computation of the increase of the length indicator and insertion in the header */
|
||||
for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
|
||||
opj_tcd_pass_t *pass = &cblk->passes[passno];
|
||||
nump++;
|
||||
len += pass->len;
|
||||
if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
|
||||
increment = int_max(increment, int_floorlog2(len) + 1 - (cblk->numlenbits + int_floorlog2(nump)));
|
||||
len = 0;
|
||||
nump = 0;
|
||||
}
|
||||
}
|
||||
t2_putcommacode(bio, increment);
|
||||
|
||||
/* computation of the new Length indicator */
|
||||
cblk->numlenbits += increment;
|
||||
|
||||
/* insertion of the codeword segment length */
|
||||
for (passno = cblk->numpasses; passno < cblk->numpasses + layer->numpasses; passno++) {
|
||||
opj_tcd_pass_t *pass = &cblk->passes[passno];
|
||||
nump++;
|
||||
len += pass->len;
|
||||
if (pass->term || passno == (cblk->numpasses + layer->numpasses) - 1) {
|
||||
bio_write(bio, len, cblk->numlenbits + int_floorlog2(nump));
|
||||
len = 0;
|
||||
nump = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (bio_flush(bio)) {
|
||||
bio_destroy(bio);
|
||||
return -999; /* modified to eliminate longjmp !! */
|
||||
}
|
||||
|
||||
c += bio_numbytes(bio);
|
||||
bio_destroy(bio);
|
||||
|
||||
/* <EPH 0xff92> */
|
||||
if (tcp->csty & J2K_CP_CSTY_EPH) {
|
||||
c[0] = 255;
|
||||
c[1] = 146;
|
||||
c += 2;
|
||||
}
|
||||
/* </EPH> */
|
||||
|
||||
/* << INDEX */
|
||||
/* End of packet header position. Currently only represents the distance to start of packet
|
||||
// Will be updated later by incrementing with packet start value */
|
||||
if(cstr_info && cstr_info->index_write) {
|
||||
opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
|
||||
info_PK->end_ph_pos = (int)(c - dest);
|
||||
}
|
||||
/* INDEX >> */
|
||||
|
||||
/* Writing the packet body */
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
|
||||
opj_tcd_layer_t *layer = &cblk->layers[layno];
|
||||
if (!layer->numpasses) {
|
||||
continue;
|
||||
}
|
||||
if (c + layer->len > dest + length) {
|
||||
return -999;
|
||||
}
|
||||
|
||||
memcpy(c, layer->data, layer->len);
|
||||
cblk->numpasses += layer->numpasses;
|
||||
c += layer->len;
|
||||
/* << INDEX */
|
||||
if(cstr_info && cstr_info->index_write) {
|
||||
opj_packet_info_t *info_PK = &cstr_info->tile[tileno].packet[cstr_info->packno];
|
||||
info_PK->disto += layer->disto;
|
||||
if (cstr_info->D_max < info_PK->disto) {
|
||||
cstr_info->D_max = info_PK->disto;
|
||||
}
|
||||
}
|
||||
/* INDEX >> */
|
||||
}
|
||||
}
|
||||
|
||||
return (c - dest);
|
||||
}
|
||||
|
||||
static opj_bool t2_init_seg(opj_tcd_cblk_dec_t* cblk, int index, int cblksty, int first) {
|
||||
opj_tcd_seg_t* seg;
|
||||
opj_tcd_seg_t* segs;
|
||||
segs = (opj_tcd_seg_t*) opj_realloc(cblk->segs, (index + 1) * sizeof(opj_tcd_seg_t));
|
||||
|
||||
if (segs == NULL)
|
||||
{
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
cblk->segs = segs;
|
||||
|
||||
seg = &cblk->segs[index];
|
||||
seg->data = NULL;
|
||||
seg->dataindex = 0;
|
||||
seg->numpasses = 0;
|
||||
seg->len = 0;
|
||||
if (cblksty & J2K_CCP_CBLKSTY_TERMALL) {
|
||||
seg->maxpasses = 1;
|
||||
}
|
||||
else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
|
||||
if (first) {
|
||||
seg->maxpasses = 10;
|
||||
} else {
|
||||
seg->maxpasses = (((seg - 1)->maxpasses == 1) || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
|
||||
}
|
||||
} else {
|
||||
seg->maxpasses = 109;
|
||||
}
|
||||
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
static int t2_decode_packet(opj_t2_t* t2, unsigned char *src, int len, opj_tcd_tile_t *tile,
|
||||
opj_tcp_t *tcp, opj_pi_iterator_t *pi, opj_packet_info_t *pack_info) {
|
||||
int bandno, cblkno;
|
||||
unsigned char *c = src;
|
||||
|
||||
opj_cp_t *cp = t2->cp;
|
||||
|
||||
int compno = pi->compno; /* component value */
|
||||
int resno = pi->resno; /* resolution level value */
|
||||
int precno = pi->precno; /* precinct value */
|
||||
int layno = pi->layno; /* quality layer value */
|
||||
|
||||
opj_tcd_resolution_t* res = &tile->comps[compno].resolutions[resno];
|
||||
|
||||
unsigned char *hd = NULL;
|
||||
int present;
|
||||
|
||||
opj_bio_t *bio = NULL; /* BIO component */
|
||||
|
||||
if (layno == 0) {
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
|
||||
|
||||
tgt_reset(prc->incltree);
|
||||
tgt_reset(prc->imsbtree);
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
|
||||
cblk->numsegs = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* SOP markers */
|
||||
|
||||
if (tcp->csty & J2K_CP_CSTY_SOP) {
|
||||
if ((*c) != 0xff || (*(c + 1) != 0x91)) {
|
||||
opj_event_msg(t2->cinfo, EVT_WARNING, "Expected SOP marker\n");
|
||||
} else {
|
||||
c += 6;
|
||||
}
|
||||
|
||||
/** TODO : check the Nsop value */
|
||||
}
|
||||
|
||||
/*
|
||||
When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
|
||||
This part deal with this caracteristic
|
||||
step 1: Read packet header in the saved structure
|
||||
step 2: Return to codestream for decoding
|
||||
*/
|
||||
|
||||
bio = bio_create();
|
||||
|
||||
if (cp->ppm == 1) { /* PPM */
|
||||
hd = cp->ppm_data;
|
||||
bio_init_dec(bio, hd, cp->ppm_len);
|
||||
} else if (tcp->ppt == 1) { /* PPT */
|
||||
hd = tcp->ppt_data;
|
||||
bio_init_dec(bio, hd, tcp->ppt_len);
|
||||
} else { /* Normal Case */
|
||||
hd = c;
|
||||
bio_init_dec(bio, hd, src+len-hd);
|
||||
}
|
||||
|
||||
present = bio_read(bio, 1);
|
||||
|
||||
if (!present) {
|
||||
bio_inalign(bio);
|
||||
hd += bio_numbytes(bio);
|
||||
bio_destroy(bio);
|
||||
|
||||
/* EPH markers */
|
||||
|
||||
if (tcp->csty & J2K_CP_CSTY_EPH) {
|
||||
if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
|
||||
printf("Error : expected EPH marker\n");
|
||||
} else {
|
||||
hd += 2;
|
||||
}
|
||||
}
|
||||
|
||||
/* << INDEX */
|
||||
/* End of packet header position. Currently only represents the distance to start of packet
|
||||
// Will be updated later by incrementing with packet start value*/
|
||||
if(pack_info) {
|
||||
pack_info->end_ph_pos = (int)(c - src);
|
||||
}
|
||||
/* INDEX >> */
|
||||
|
||||
if (cp->ppm == 1) { /* PPM case */
|
||||
cp->ppm_len += cp->ppm_data-hd;
|
||||
cp->ppm_data = hd;
|
||||
return (c - src);
|
||||
}
|
||||
if (tcp->ppt == 1) { /* PPT case */
|
||||
tcp->ppt_len+=tcp->ppt_data-hd;
|
||||
tcp->ppt_data = hd;
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
return (hd - src);
|
||||
}
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
|
||||
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
int included, increment, n, segno;
|
||||
opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
|
||||
/* if cblk not yet included before --> inclusion tagtree */
|
||||
if (!cblk->numsegs) {
|
||||
included = tgt_decode(bio, prc->incltree, cblkno, layno + 1);
|
||||
/* else one bit */
|
||||
} else {
|
||||
included = bio_read(bio, 1);
|
||||
}
|
||||
/* if cblk not included */
|
||||
if (!included) {
|
||||
cblk->numnewpasses = 0;
|
||||
continue;
|
||||
}
|
||||
/* if cblk not yet included --> zero-bitplane tagtree */
|
||||
if (!cblk->numsegs) {
|
||||
int i, numimsbs;
|
||||
for (i = 0; !tgt_decode(bio, prc->imsbtree, cblkno, i); i++) {
|
||||
;
|
||||
}
|
||||
numimsbs = i - 1;
|
||||
cblk->numbps = band->numbps - numimsbs;
|
||||
cblk->numlenbits = 3;
|
||||
}
|
||||
/* number of coding passes */
|
||||
cblk->numnewpasses = t2_getnumpasses(bio);
|
||||
increment = t2_getcommacode(bio);
|
||||
/* length indicator increment */
|
||||
cblk->numlenbits += increment;
|
||||
segno = 0;
|
||||
if (!cblk->numsegs) {
|
||||
if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 1))
|
||||
{
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
|
||||
bio_destroy(bio);
|
||||
return -999;
|
||||
}
|
||||
} else {
|
||||
segno = cblk->numsegs - 1;
|
||||
if (cblk->segs[segno].numpasses == cblk->segs[segno].maxpasses) {
|
||||
++segno;
|
||||
if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0))
|
||||
{
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
|
||||
bio_destroy(bio);
|
||||
return -999;
|
||||
}
|
||||
}
|
||||
}
|
||||
n = cblk->numnewpasses;
|
||||
|
||||
do {
|
||||
cblk->segs[segno].numnewpasses = int_min(cblk->segs[segno].maxpasses - cblk->segs[segno].numpasses, n);
|
||||
cblk->segs[segno].newlen = bio_read(bio, cblk->numlenbits + int_floorlog2(cblk->segs[segno].numnewpasses));
|
||||
n -= cblk->segs[segno].numnewpasses;
|
||||
if (n > 0) {
|
||||
++segno;
|
||||
if (!t2_init_seg(cblk, segno, tcp->tccps[compno].cblksty, 0))
|
||||
{
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Out of memory\n");
|
||||
bio_destroy(bio);
|
||||
return -999;
|
||||
}
|
||||
}
|
||||
} while (n > 0);
|
||||
}
|
||||
}
|
||||
|
||||
if (bio_inalign(bio)) {
|
||||
bio_destroy(bio);
|
||||
return -999;
|
||||
}
|
||||
|
||||
hd += bio_numbytes(bio);
|
||||
bio_destroy(bio);
|
||||
|
||||
/* EPH markers */
|
||||
if (tcp->csty & J2K_CP_CSTY_EPH) {
|
||||
if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Expected EPH marker\n");
|
||||
return -999;
|
||||
} else {
|
||||
hd += 2;
|
||||
}
|
||||
}
|
||||
|
||||
/* << INDEX */
|
||||
/* End of packet header position. Currently only represents the distance to start of packet
|
||||
// Will be updated later by incrementing with packet start value*/
|
||||
if(pack_info) {
|
||||
pack_info->end_ph_pos = (int)(hd - src);
|
||||
}
|
||||
/* INDEX >> */
|
||||
|
||||
if (cp->ppm==1) {
|
||||
cp->ppm_len+=cp->ppm_data-hd;
|
||||
cp->ppm_data = hd;
|
||||
} else if (tcp->ppt == 1) {
|
||||
tcp->ppt_len+=tcp->ppt_data-hd;
|
||||
tcp->ppt_data = hd;
|
||||
} else {
|
||||
c=hd;
|
||||
}
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; bandno++) {
|
||||
opj_tcd_band_t *band = &res->bands[bandno];
|
||||
opj_tcd_precinct_t *prc = &band->precincts[precno];
|
||||
|
||||
if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
|
||||
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
|
||||
opj_tcd_cblk_dec_t* cblk = &prc->cblks.dec[cblkno];
|
||||
opj_tcd_seg_t *seg = NULL;
|
||||
if (!cblk->numnewpasses)
|
||||
continue;
|
||||
if (!cblk->numsegs) {
|
||||
seg = &cblk->segs[0];
|
||||
cblk->numsegs++;
|
||||
cblk->len = 0;
|
||||
} else {
|
||||
seg = &cblk->segs[cblk->numsegs - 1];
|
||||
if (seg->numpasses == seg->maxpasses) {
|
||||
seg++;
|
||||
cblk->numsegs++;
|
||||
}
|
||||
}
|
||||
|
||||
do {
|
||||
if (c + seg->newlen > src + len) {
|
||||
return -999;
|
||||
}
|
||||
|
||||
#ifdef USE_JPWL
|
||||
/* we need here a j2k handle to verify if making a check to
|
||||
the validity of cblocks parameters is selected from user (-W) */
|
||||
|
||||
/* let's check that we are not exceeding */
|
||||
if ((cblk->len + seg->newlen) > 8192) {
|
||||
opj_event_msg(t2->cinfo, EVT_WARNING,
|
||||
"JPWL: segment too long (%d) for codeblock %d (p=%d, b=%d, r=%d, c=%d)\n",
|
||||
seg->newlen, cblkno, precno, bandno, resno, compno);
|
||||
if (!JPWL_ASSUME) {
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "JPWL: giving up\n");
|
||||
return -999;
|
||||
}
|
||||
seg->newlen = 8192 - cblk->len;
|
||||
opj_event_msg(t2->cinfo, EVT_WARNING, " - truncating segment to %d\n", seg->newlen);
|
||||
break;
|
||||
};
|
||||
|
||||
#endif /* USE_JPWL */
|
||||
|
||||
cblk->data = (unsigned char*) opj_realloc(cblk->data, (cblk->len + seg->newlen) * sizeof(unsigned char));
|
||||
memcpy(cblk->data + cblk->len, c, seg->newlen);
|
||||
if (seg->numpasses == 0) {
|
||||
seg->data = &cblk->data;
|
||||
seg->dataindex = cblk->len;
|
||||
}
|
||||
c += seg->newlen;
|
||||
cblk->len += seg->newlen;
|
||||
seg->len += seg->newlen;
|
||||
seg->numpasses += seg->numnewpasses;
|
||||
cblk->numnewpasses -= seg->numnewpasses;
|
||||
if (cblk->numnewpasses > 0) {
|
||||
seg++;
|
||||
cblk->numsegs++;
|
||||
}
|
||||
} while (cblk->numnewpasses > 0);
|
||||
}
|
||||
}
|
||||
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_codestream_info_t *cstr_info,int tpnum, int tppos,int pino, J2K_T2_MODE t2_mode, int cur_totnum_tp){
|
||||
unsigned char *c = dest;
|
||||
int e = 0;
|
||||
int compno;
|
||||
opj_pi_iterator_t *pi = NULL;
|
||||
int poc;
|
||||
opj_image_t *image = t2->image;
|
||||
opj_cp_t *cp = t2->cp;
|
||||
opj_tcp_t *tcp = &cp->tcps[tileno];
|
||||
int pocno = cp->cinema == CINEMA4K_24? 2: 1;
|
||||
int maxcomp = cp->max_comp_size > 0 ? image->numcomps : 1;
|
||||
|
||||
pi = pi_initialise_encode(image, cp, tileno, t2_mode);
|
||||
if(!pi) {
|
||||
/* TODO: throw an error */
|
||||
return -999;
|
||||
}
|
||||
|
||||
if(t2_mode == THRESH_CALC ){ /* Calculating threshold */
|
||||
for(compno = 0; compno < maxcomp; compno++ ){
|
||||
for(poc = 0; poc < pocno ; poc++){
|
||||
int comp_len = 0;
|
||||
int tpnum = compno;
|
||||
if (pi_create_encode(pi, cp,tileno,poc,tpnum,tppos,t2_mode,cur_totnum_tp)) {
|
||||
opj_event_msg(t2->cinfo, EVT_ERROR, "Error initializing Packet Iterator\n");
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return -999;
|
||||
}
|
||||
while (pi_next(&pi[poc])) {
|
||||
if (pi[poc].layno < maxlayers) {
|
||||
e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[poc], c, dest + len - c, cstr_info, tileno);
|
||||
comp_len = comp_len + e;
|
||||
if (e == -999) {
|
||||
break;
|
||||
} else {
|
||||
c += e;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (e == -999) break;
|
||||
if (cp->max_comp_size){
|
||||
if (comp_len > cp->max_comp_size){
|
||||
e = -999;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (e == -999) break;
|
||||
}
|
||||
}else{ /* t2_mode == FINAL_PASS */
|
||||
pi_create_encode(pi, cp,tileno,pino,tpnum,tppos,t2_mode,cur_totnum_tp);
|
||||
while (pi_next(&pi[pino])) {
|
||||
if (pi[pino].layno < maxlayers) {
|
||||
e = t2_encode_packet(tile, &cp->tcps[tileno], &pi[pino], c, dest + len - c, cstr_info, tileno);
|
||||
if (e == -999) {
|
||||
break;
|
||||
} else {
|
||||
c += e;
|
||||
}
|
||||
/* INDEX >> */
|
||||
if(cstr_info) {
|
||||
if(cstr_info->index_write) {
|
||||
opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
|
||||
opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
|
||||
if (!cstr_info->packno) {
|
||||
info_PK->start_pos = info_TL->end_header + 1;
|
||||
} else {
|
||||
info_PK->start_pos = ((cp->tp_on | tcp->POC)&& info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
|
||||
}
|
||||
info_PK->end_pos = info_PK->start_pos + e - 1;
|
||||
info_PK->end_ph_pos += info_PK->start_pos - 1; /* End of packet header which now only represents the distance
|
||||
// to start of packet is incremented by value of start of packet*/
|
||||
}
|
||||
|
||||
cstr_info->packno++;
|
||||
}
|
||||
/* << INDEX */
|
||||
tile->packno++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pi_destroy(pi, cp, tileno);
|
||||
|
||||
if (e == -999) {
|
||||
return e;
|
||||
}
|
||||
|
||||
return (c - dest);
|
||||
}
|
||||
|
||||
int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile, opj_codestream_info_t *cstr_info) {
|
||||
unsigned char *c = src;
|
||||
opj_pi_iterator_t *pi;
|
||||
int pino, e = 0;
|
||||
int n = 0, curtp = 0;
|
||||
int tp_start_packno;
|
||||
|
||||
opj_image_t *image = t2->image;
|
||||
opj_cp_t *cp = t2->cp;
|
||||
|
||||
/* create a packet iterator */
|
||||
pi = pi_create_decode(image, cp, tileno);
|
||||
if(!pi) {
|
||||
/* TODO: throw an error */
|
||||
return -999;
|
||||
}
|
||||
|
||||
tp_start_packno = 0;
|
||||
|
||||
for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
|
||||
while (pi_next(&pi[pino])) {
|
||||
if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
|
||||
opj_packet_info_t *pack_info;
|
||||
if (cstr_info)
|
||||
pack_info = &cstr_info->tile[tileno].packet[cstr_info->packno];
|
||||
else
|
||||
pack_info = NULL;
|
||||
e = t2_decode_packet(t2, c, src + len - c, tile, &cp->tcps[tileno], &pi[pino], pack_info);
|
||||
} else {
|
||||
e = 0;
|
||||
}
|
||||
if(e == -999)
|
||||
{
|
||||
pi_destroy(pi, cp, tileno);
|
||||
return -999;
|
||||
}
|
||||
/* progression in resolution */
|
||||
image->comps[pi[pino].compno].resno_decoded =
|
||||
(e > 0) ?
|
||||
int_max(pi[pino].resno, image->comps[pi[pino].compno].resno_decoded)
|
||||
: image->comps[pi[pino].compno].resno_decoded;
|
||||
n++;
|
||||
|
||||
/* INDEX >> */
|
||||
if(cstr_info) {
|
||||
opj_tile_info_t *info_TL = &cstr_info->tile[tileno];
|
||||
opj_packet_info_t *info_PK = &info_TL->packet[cstr_info->packno];
|
||||
if (!cstr_info->packno) {
|
||||
info_PK->start_pos = info_TL->end_header + 1;
|
||||
} else if (info_TL->packet[cstr_info->packno-1].end_pos >= (int)cstr_info->tile[tileno].tp[curtp].tp_end_pos){ /* New tile part*/
|
||||
info_TL->tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; /* Number of packets in previous tile-part*/
|
||||
info_TL->tp[curtp].tp_start_pack = tp_start_packno;
|
||||
tp_start_packno = cstr_info->packno;
|
||||
curtp++;
|
||||
info_PK->start_pos = cstr_info->tile[tileno].tp[curtp].tp_end_header+1;
|
||||
} else {
|
||||
info_PK->start_pos = (cp->tp_on && info_PK->start_pos) ? info_PK->start_pos : info_TL->packet[cstr_info->packno - 1].end_pos + 1;
|
||||
}
|
||||
info_PK->end_pos = info_PK->start_pos + e - 1;
|
||||
info_PK->end_ph_pos += info_PK->start_pos - 1; /* End of packet header which now only represents the distance
|
||||
// to start of packet is incremented by value of start of packet*/
|
||||
cstr_info->packno++;
|
||||
}
|
||||
/* << INDEX */
|
||||
|
||||
if (e == -999) { /* ADD */
|
||||
break;
|
||||
} else {
|
||||
c += e;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* INDEX >> */
|
||||
if(cstr_info) {
|
||||
cstr_info->tile[tileno].tp[curtp].tp_numpacks = cstr_info->packno - tp_start_packno; /* Number of packets in last tile-part*/
|
||||
cstr_info->tile[tileno].tp[curtp].tp_start_pack = tp_start_packno;
|
||||
}
|
||||
/* << INDEX */
|
||||
|
||||
/* don't forget to release pi */
|
||||
pi_destroy(pi, cp, tileno);
|
||||
|
||||
if (e == -999) {
|
||||
return e;
|
||||
}
|
||||
|
||||
return (c - src);
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp) {
|
||||
/* create the tcd structure */
|
||||
opj_t2_t *t2 = (opj_t2_t*)opj_malloc(sizeof(opj_t2_t));
|
||||
if(!t2) return NULL;
|
||||
t2->cinfo = cinfo;
|
||||
t2->image = image;
|
||||
t2->cp = cp;
|
||||
|
||||
return t2;
|
||||
}
|
||||
|
||||
void t2_destroy(opj_t2_t *t2) {
|
||||
if(t2) {
|
||||
opj_free(t2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,105 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __T2_H
|
||||
#define __T2_H
|
||||
/**
|
||||
@file t2.h
|
||||
@brief Implementation of a tier-2 coding (packetization of code-block data) (T2)
|
||||
|
||||
*/
|
||||
|
||||
/** @defgroup T2 T2 - Implementation of a tier-2 coding */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Tier-2 coding
|
||||
*/
|
||||
typedef struct opj_t2 {
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** Encoding: pointer to the src image. Decoding: pointer to the dst image. */
|
||||
opj_image_t *image;
|
||||
/** pointer to the image coding parameters */
|
||||
opj_cp_t *cp;
|
||||
} opj_t2_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Encode the packets of a tile to a destination buffer
|
||||
@param t2 T2 handle
|
||||
@param tileno number of the tile encoded
|
||||
@param tile the tile for which to write the packets
|
||||
@param maxlayers maximum number of layers
|
||||
@param dest the destination buffer
|
||||
@param len the length of the destination buffer
|
||||
@param cstr_info Codestream information structure
|
||||
@param tpnum Tile part number of the current tile
|
||||
@param tppos The position of the tile part flag in the progression order
|
||||
@param pino
|
||||
@param t2_mode If == 0 In Threshold calculation ,If == 1 Final pass
|
||||
@param cur_totnum_tp The total number of tile parts in the current tile
|
||||
*/
|
||||
int t2_encode_packets(opj_t2_t* t2,int tileno, opj_tcd_tile_t *tile, int maxlayers, unsigned char *dest, int len, opj_codestream_info_t *cstr_info,int tpnum, int tppos,int pino,J2K_T2_MODE t2_mode,int cur_totnum_tp);
|
||||
/**
|
||||
Decode the packets of a tile from a source buffer
|
||||
@param t2 T2 handle
|
||||
@param src the source buffer
|
||||
@param len length of the source buffer
|
||||
@param tileno number that identifies the tile for which to decode the packets
|
||||
@param tile tile for which to decode the packets
|
||||
@param cstr_info Codestream information structure
|
||||
*/
|
||||
int t2_decode_packets(opj_t2_t *t2, unsigned char *src, int len, int tileno, opj_tcd_tile_t *tile, opj_codestream_info_t *cstr_info);
|
||||
|
||||
/**
|
||||
Create a T2 handle
|
||||
@param cinfo Codec context info
|
||||
@param image Source or destination image
|
||||
@param cp Image coding parameters
|
||||
@return Returns a new T2 handle if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_t2_t* t2_create(opj_common_ptr cinfo, opj_image_t *image, opj_cp_t *cp);
|
||||
/**
|
||||
Destroy a T2 handle
|
||||
@param t2 T2 handle to destroy
|
||||
*/
|
||||
void t2_destroy(opj_t2_t *t2);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __T2_H */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,286 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
#ifndef __TCD_H
|
||||
#define __TCD_H
|
||||
/**
|
||||
@file tcd.h
|
||||
@brief Implementation of a tile coder/decoder (TCD)
|
||||
|
||||
The functions in TCD.C have for goal to encode or decode each tile independently from
|
||||
each other. The functions in TCD.C are used by some function in J2K.C.
|
||||
*/
|
||||
|
||||
/** @defgroup TCD TCD - Implementation of a tile coder/decoder */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_seg {
|
||||
unsigned char** data;
|
||||
int dataindex;
|
||||
int numpasses;
|
||||
int len;
|
||||
int maxpasses;
|
||||
int numnewpasses;
|
||||
int newlen;
|
||||
} opj_tcd_seg_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_pass {
|
||||
int rate;
|
||||
double distortiondec;
|
||||
int term, len;
|
||||
} opj_tcd_pass_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_layer {
|
||||
int numpasses; /* Number of passes in the layer */
|
||||
int len; /* len of information */
|
||||
double disto; /* add for index (Cfr. Marcela) */
|
||||
unsigned char *data; /* data */
|
||||
} opj_tcd_layer_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_cblk_enc {
|
||||
unsigned char* data; /* Data */
|
||||
opj_tcd_layer_t* layers; /* layer information */
|
||||
opj_tcd_pass_t* passes; /* information about the passes */
|
||||
int x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int numbps;
|
||||
int numlenbits;
|
||||
int numpasses; /* number of pass already done for the code-blocks */
|
||||
int numpassesinlayers; /* number of passes in the layer */
|
||||
int totalpasses; /* total number of passes */
|
||||
} opj_tcd_cblk_enc_t;
|
||||
|
||||
typedef struct opj_tcd_cblk_dec {
|
||||
unsigned char* data; /* Data */
|
||||
opj_tcd_seg_t* segs; /* segments informations */
|
||||
int x0, y0, x1, y1; /* dimension of the code-blocks : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int numbps;
|
||||
int numlenbits;
|
||||
int len; /* length */
|
||||
int numnewpasses; /* number of pass added to the code-blocks */
|
||||
int numsegs; /* number of segments */
|
||||
} opj_tcd_cblk_dec_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_precinct {
|
||||
int x0, y0, x1, y1; /* dimension of the precinct : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int cw, ch; /* number of precinct in width and heigth */
|
||||
union{ /* code-blocks informations */
|
||||
opj_tcd_cblk_enc_t* enc;
|
||||
opj_tcd_cblk_dec_t* dec;
|
||||
} cblks;
|
||||
opj_tgt_tree_t *incltree; /* inclusion tree */
|
||||
opj_tgt_tree_t *imsbtree; /* IMSB tree */
|
||||
} opj_tcd_precinct_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_band {
|
||||
int x0, y0, x1, y1; /* dimension of the subband : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int bandno;
|
||||
opj_tcd_precinct_t *precincts; /* precinct information */
|
||||
int numbps;
|
||||
float stepsize;
|
||||
} opj_tcd_band_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_resolution {
|
||||
int x0, y0, x1, y1; /* dimension of the resolution level : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int pw, ph;
|
||||
int numbands; /* number sub-band for the resolution level */
|
||||
opj_tcd_band_t bands[3]; /* subband information */
|
||||
} opj_tcd_resolution_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_tilecomp {
|
||||
int x0, y0, x1, y1; /* dimension of component : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int numresolutions; /* number of resolutions level */
|
||||
opj_tcd_resolution_t *resolutions; /* resolutions information */
|
||||
int *data; /* data of the component */
|
||||
int numpix; /* add fixed_quality */
|
||||
} opj_tcd_tilecomp_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_tile {
|
||||
int x0, y0, x1, y1; /* dimension of the tile : left upper corner (x0, y0) right low corner (x1,y1) */
|
||||
int numcomps; /* number of components in tile */
|
||||
opj_tcd_tilecomp_t *comps; /* Components information */
|
||||
int numpix; /* add fixed_quality */
|
||||
double distotile; /* add fixed_quality */
|
||||
double distolayer[100]; /* add fixed_quality */
|
||||
/** packet number */
|
||||
int packno;
|
||||
} opj_tcd_tile_t;
|
||||
|
||||
/**
|
||||
FIXME: documentation
|
||||
*/
|
||||
typedef struct opj_tcd_image {
|
||||
int tw, th; /* number of tiles in width and heigth */
|
||||
opj_tcd_tile_t *tiles; /* Tiles information */
|
||||
} opj_tcd_image_t;
|
||||
|
||||
/**
|
||||
Tile coder/decoder
|
||||
*/
|
||||
typedef struct opj_tcd {
|
||||
/** Position of the tilepart flag in Progression order*/
|
||||
int tp_pos;
|
||||
/** Tile part number*/
|
||||
int tp_num;
|
||||
/** Current tile part number*/
|
||||
int cur_tp_num;
|
||||
/** Total number of tileparts of the current tile*/
|
||||
int cur_totnum_tp;
|
||||
/** Current Packet iterator number */
|
||||
int cur_pino;
|
||||
/** codec context */
|
||||
opj_common_ptr cinfo;
|
||||
|
||||
/** info on each image tile */
|
||||
opj_tcd_image_t *tcd_image;
|
||||
/** image */
|
||||
opj_image_t *image;
|
||||
/** coding parameters */
|
||||
opj_cp_t *cp;
|
||||
/** pointer to the current encoded/decoded tile */
|
||||
opj_tcd_tile_t *tcd_tile;
|
||||
/** coding/decoding parameters common to all tiles */
|
||||
opj_tcp_t *tcp;
|
||||
/** current encoded/decoded tile */
|
||||
int tcd_tileno;
|
||||
/** Time taken to encode a tile*/
|
||||
double encoding_time;
|
||||
} opj_tcd_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
Dump the content of a tcd structure
|
||||
*/
|
||||
void tcd_dump(FILE *fd, opj_tcd_t *tcd, opj_tcd_image_t *img);
|
||||
/**
|
||||
Create a new TCD handle
|
||||
@param cinfo Codec context info
|
||||
@return Returns a new TCD handle if successful returns NULL otherwise
|
||||
*/
|
||||
opj_tcd_t* tcd_create(opj_common_ptr cinfo);
|
||||
/**
|
||||
Destroy a previously created TCD handle
|
||||
@param tcd TCD handle to destroy
|
||||
*/
|
||||
void tcd_destroy(opj_tcd_t *tcd);
|
||||
/**
|
||||
Initialize the tile coder (allocate the memory)
|
||||
@param tcd TCD handle
|
||||
@param image Raw image
|
||||
@param cp Coding parameters
|
||||
@param curtileno Number that identifies the tile that will be encoded
|
||||
*/
|
||||
void tcd_malloc_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
|
||||
/**
|
||||
Free the memory allocated for encoding
|
||||
@param tcd TCD handle
|
||||
*/
|
||||
void tcd_free_encode(opj_tcd_t *tcd);
|
||||
/**
|
||||
Initialize the tile coder (reuses the memory allocated by tcd_malloc_encode)
|
||||
@param tcd TCD handle
|
||||
@param image Raw image
|
||||
@param cp Coding parameters
|
||||
@param curtileno Number that identifies the tile that will be encoded
|
||||
*/
|
||||
void tcd_init_encode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int curtileno);
|
||||
/**
|
||||
Initialize the tile decoder
|
||||
@param tcd TCD handle
|
||||
@param image Raw image
|
||||
@param cp Coding parameters
|
||||
*/
|
||||
void tcd_malloc_decode(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp);
|
||||
void tcd_malloc_decode_tile(opj_tcd_t *tcd, opj_image_t * image, opj_cp_t * cp, int tileno, opj_codestream_info_t *cstr_info);
|
||||
void tcd_makelayer_fixed(opj_tcd_t *tcd, int layno, int final);
|
||||
void tcd_rateallocate_fixed(opj_tcd_t *tcd);
|
||||
void tcd_makelayer(opj_tcd_t *tcd, int layno, double thresh, int final);
|
||||
opj_bool tcd_rateallocate(opj_tcd_t *tcd, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Encode a tile from the raw image into a buffer
|
||||
@param tcd TCD handle
|
||||
@param tileno Number that identifies one of the tiles to be encoded
|
||||
@param dest Destination buffer
|
||||
@param len Length of destination buffer
|
||||
@param cstr_info Codestream information structure
|
||||
@return
|
||||
*/
|
||||
int tcd_encode_tile(opj_tcd_t *tcd, int tileno, unsigned char *dest, int len, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Decode a tile from a buffer into a raw image
|
||||
@param tcd TCD handle
|
||||
@param src Source buffer
|
||||
@param len Length of source buffer
|
||||
@param tileno Number that identifies one of the tiles to be decoded
|
||||
@param cstr_info Codestream information structure
|
||||
*/
|
||||
opj_bool tcd_decode_tile(opj_tcd_t *tcd, unsigned char *src, int len, int tileno, opj_codestream_info_t *cstr_info);
|
||||
/**
|
||||
Free the memory allocated for decoding
|
||||
@param tcd TCD handle
|
||||
*/
|
||||
void tcd_free_decode(opj_tcd_t *tcd);
|
||||
void tcd_free_decode_tile(opj_tcd_t *tcd, int tileno);
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __TCD_H */
|
||||
@@ -1,213 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
==========================================================
|
||||
Tag-tree coder interface
|
||||
==========================================================
|
||||
*/
|
||||
|
||||
opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv) {
|
||||
int nplh[32];
|
||||
int nplv[32];
|
||||
opj_tgt_node_t *node = NULL;
|
||||
opj_tgt_node_t *parentnode = NULL;
|
||||
opj_tgt_node_t *parentnode0 = NULL;
|
||||
opj_tgt_tree_t *tree = NULL;
|
||||
int i, j, k;
|
||||
int numlvls;
|
||||
int n;
|
||||
|
||||
tree = (opj_tgt_tree_t *) opj_malloc(sizeof(opj_tgt_tree_t));
|
||||
if(!tree) return NULL;
|
||||
tree->numleafsh = numleafsh;
|
||||
tree->numleafsv = numleafsv;
|
||||
|
||||
numlvls = 0;
|
||||
nplh[0] = numleafsh;
|
||||
nplv[0] = numleafsv;
|
||||
tree->numnodes = 0;
|
||||
do {
|
||||
n = nplh[numlvls] * nplv[numlvls];
|
||||
nplh[numlvls + 1] = (nplh[numlvls] + 1) / 2;
|
||||
nplv[numlvls + 1] = (nplv[numlvls] + 1) / 2;
|
||||
tree->numnodes += n;
|
||||
++numlvls;
|
||||
} while (n > 1);
|
||||
|
||||
/* ADD */
|
||||
if (tree->numnodes == 0) {
|
||||
opj_free(tree);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tree->nodes = (opj_tgt_node_t*) opj_calloc(tree->numnodes, sizeof(opj_tgt_node_t));
|
||||
if(!tree->nodes) {
|
||||
opj_free(tree);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
node = tree->nodes;
|
||||
parentnode = &tree->nodes[tree->numleafsh * tree->numleafsv];
|
||||
parentnode0 = parentnode;
|
||||
|
||||
for (i = 0; i < numlvls - 1; ++i) {
|
||||
for (j = 0; j < nplv[i]; ++j) {
|
||||
k = nplh[i];
|
||||
while (--k >= 0) {
|
||||
node->parent = parentnode;
|
||||
++node;
|
||||
if (--k >= 0) {
|
||||
node->parent = parentnode;
|
||||
++node;
|
||||
}
|
||||
++parentnode;
|
||||
}
|
||||
if ((j & 1) || j == nplv[i] - 1) {
|
||||
parentnode0 = parentnode;
|
||||
} else {
|
||||
parentnode = parentnode0;
|
||||
parentnode0 += nplh[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
node->parent = 0;
|
||||
|
||||
tgt_reset(tree);
|
||||
|
||||
return tree;
|
||||
}
|
||||
|
||||
void tgt_destroy(opj_tgt_tree_t *tree) {
|
||||
opj_free(tree->nodes);
|
||||
opj_free(tree);
|
||||
}
|
||||
|
||||
void tgt_reset(opj_tgt_tree_t *tree) {
|
||||
int i;
|
||||
|
||||
if (NULL == tree)
|
||||
return;
|
||||
|
||||
for (i = 0; i < tree->numnodes; i++) {
|
||||
tree->nodes[i].value = 999;
|
||||
tree->nodes[i].low = 0;
|
||||
tree->nodes[i].known = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value) {
|
||||
opj_tgt_node_t *node;
|
||||
node = &tree->nodes[leafno];
|
||||
while (node && node->value > value) {
|
||||
node->value = value;
|
||||
node = node->parent;
|
||||
}
|
||||
}
|
||||
|
||||
void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
|
||||
opj_tgt_node_t *stk[31];
|
||||
opj_tgt_node_t **stkptr;
|
||||
opj_tgt_node_t *node;
|
||||
int low;
|
||||
|
||||
stkptr = stk;
|
||||
node = &tree->nodes[leafno];
|
||||
while (node->parent) {
|
||||
*stkptr++ = node;
|
||||
node = node->parent;
|
||||
}
|
||||
|
||||
low = 0;
|
||||
for (;;) {
|
||||
if (low > node->low) {
|
||||
node->low = low;
|
||||
} else {
|
||||
low = node->low;
|
||||
}
|
||||
|
||||
while (low < threshold) {
|
||||
if (low >= node->value) {
|
||||
if (!node->known) {
|
||||
bio_write(bio, 1, 1);
|
||||
node->known = 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
bio_write(bio, 0, 1);
|
||||
++low;
|
||||
}
|
||||
|
||||
node->low = low;
|
||||
if (stkptr == stk)
|
||||
break;
|
||||
node = *--stkptr;
|
||||
}
|
||||
}
|
||||
|
||||
int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold) {
|
||||
opj_tgt_node_t *stk[31];
|
||||
opj_tgt_node_t **stkptr;
|
||||
opj_tgt_node_t *node;
|
||||
int low;
|
||||
|
||||
stkptr = stk;
|
||||
node = &tree->nodes[leafno];
|
||||
while (node->parent) {
|
||||
*stkptr++ = node;
|
||||
node = node->parent;
|
||||
}
|
||||
|
||||
low = 0;
|
||||
for (;;) {
|
||||
if (low > node->low) {
|
||||
node->low = low;
|
||||
} else {
|
||||
low = node->low;
|
||||
}
|
||||
while (low < threshold && low < node->value) {
|
||||
if (bio_read(bio, 1)) {
|
||||
node->value = low;
|
||||
} else {
|
||||
++low;
|
||||
}
|
||||
}
|
||||
node->low = low;
|
||||
if (stkptr == stk) {
|
||||
break;
|
||||
}
|
||||
node = *--stkptr;
|
||||
}
|
||||
|
||||
return (node->value < threshold) ? 1 : 0;
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2007, Professor Benoit Macq
|
||||
* Copyright (c) 2001-2003, David Janssens
|
||||
* Copyright (c) 2002-2003, Yannick Verschueren
|
||||
* Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
|
||||
* Copyright (c) 2005, Herve Drolon, FreeImage Team
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __TGT_H
|
||||
#define __TGT_H
|
||||
/**
|
||||
@file tgt.h
|
||||
@brief Implementation of a tag-tree coder (TGT)
|
||||
|
||||
The functions in TGT.C have for goal to realize a tag-tree coder. The functions in TGT.C
|
||||
are used by some function in T2.C.
|
||||
*/
|
||||
|
||||
/** @defgroup TGT TGT - Implementation of a tag-tree coder */
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
Tag node
|
||||
*/
|
||||
typedef struct opj_tgt_node {
|
||||
struct opj_tgt_node *parent;
|
||||
int value;
|
||||
int low;
|
||||
int known;
|
||||
} opj_tgt_node_t;
|
||||
|
||||
/**
|
||||
Tag tree
|
||||
*/
|
||||
typedef struct opj_tgt_tree {
|
||||
int numleafsh;
|
||||
int numleafsv;
|
||||
int numnodes;
|
||||
opj_tgt_node_t *nodes;
|
||||
} opj_tgt_tree_t;
|
||||
|
||||
/** @name Exported functions */
|
||||
/*@{*/
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/**
|
||||
Create a tag-tree
|
||||
@param numleafsh Width of the array of leafs of the tree
|
||||
@param numleafsv Height of the array of leafs of the tree
|
||||
@return Returns a new tag-tree if successful, returns NULL otherwise
|
||||
*/
|
||||
opj_tgt_tree_t *tgt_create(int numleafsh, int numleafsv);
|
||||
/**
|
||||
Destroy a tag-tree, liberating memory
|
||||
@param tree Tag-tree to destroy
|
||||
*/
|
||||
void tgt_destroy(opj_tgt_tree_t *tree);
|
||||
/**
|
||||
Reset a tag-tree (set all leaves to 0)
|
||||
@param tree Tag-tree to reset
|
||||
*/
|
||||
void tgt_reset(opj_tgt_tree_t *tree);
|
||||
/**
|
||||
Set the value of a leaf of a tag-tree
|
||||
@param tree Tag-tree to modify
|
||||
@param leafno Number that identifies the leaf to modify
|
||||
@param value New value of the leaf
|
||||
*/
|
||||
void tgt_setvalue(opj_tgt_tree_t *tree, int leafno, int value);
|
||||
/**
|
||||
Encode the value of a leaf of the tag-tree up to a given threshold
|
||||
@param bio Pointer to a BIO handle
|
||||
@param tree Tag-tree to modify
|
||||
@param leafno Number that identifies the leaf to encode
|
||||
@param threshold Threshold to use when encoding value of the leaf
|
||||
*/
|
||||
void tgt_encode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
|
||||
/**
|
||||
Decode the value of a leaf of the tag-tree up to a given threshold
|
||||
@param bio Pointer to a BIO handle
|
||||
@param tree Tag-tree to decode
|
||||
@param leafno Number that identifies the leaf to decode
|
||||
@param threshold Threshold to use when decoding value of the leaf
|
||||
@return Returns 1 if the node's value < threshold, returns 0 otherwise
|
||||
*/
|
||||
int tgt_decode(opj_bio_t *bio, opj_tgt_tree_t *tree, int leafno, int threshold);
|
||||
/* ----------------------------------------------------------------------- */
|
||||
/*@}*/
|
||||
|
||||
/*@}*/
|
||||
|
||||
#endif /* __TGT_H */
|
||||
@@ -1,120 +0,0 @@
|
||||
/*
|
||||
* $Id: thix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.c from 2KAN indexer
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "opj_includes.h"
|
||||
|
||||
/*
|
||||
* Write tile-part headers mhix box
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] tileno tile number
|
||||
* @param[in] cio file output handle
|
||||
* @return length of mhix box
|
||||
*/
|
||||
int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio);
|
||||
|
||||
int write_thix( int coff, opj_codestream_info_t cstr_info, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp, i;
|
||||
int tileno;
|
||||
opj_jp2_box_t *box;
|
||||
|
||||
lenp = 0;
|
||||
box = (opj_jp2_box_t *)opj_calloc( cstr_info.tw*cstr_info.th, sizeof(opj_jp2_box_t));
|
||||
|
||||
for ( i = 0; i < 2 ; i++ ){
|
||||
if (i)
|
||||
cio_seek( cio, lenp);
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_THIX, 4); /* THIX */
|
||||
write_manf( i, cstr_info.tw*cstr_info.th, box, cio);
|
||||
|
||||
for (tileno = 0; tileno < cstr_info.tw*cstr_info.th; tileno++){
|
||||
box[tileno].length = write_tilemhix( coff, cstr_info, tileno, cio);
|
||||
box[tileno].type = JPIP_MHIX;
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
}
|
||||
|
||||
opj_free(box);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int write_tilemhix( int coff, opj_codestream_info_t cstr_info, int tileno, opj_cio_t *cio)
|
||||
{
|
||||
int i;
|
||||
opj_tile_info_t tile;
|
||||
opj_tp_info_t tp;
|
||||
int len, lenp;
|
||||
opj_marker_info_t *marker;
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_MHIX, 4); /* MHIX */
|
||||
|
||||
tile = cstr_info.tile[tileno];
|
||||
tp = tile.tp[0];
|
||||
|
||||
cio_write( cio, tp.tp_end_header-tp.tp_start_pos+1, 8); /* TLEN */
|
||||
|
||||
marker = cstr_info.tile[tileno].marker;
|
||||
|
||||
for( i=0; i<cstr_info.tile[tileno].marknum; i++){ /* Marker restricted to 1 apparition */
|
||||
cio_write( cio, marker[i].type, 2);
|
||||
cio_write( cio, 0, 2);
|
||||
cio_write( cio, marker[i].pos-coff, 8);
|
||||
cio_write( cio, marker[i].len, 2);
|
||||
}
|
||||
|
||||
/* free( marker);*/
|
||||
|
||||
len = cio_tell( cio) - lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
/*
|
||||
* $Id: tpix_manager.c 897 2011-08-28 21:43:57Z Kaori.Hagihara@gmail.com $
|
||||
*
|
||||
* Copyright (c) 2002-2011, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
|
||||
* Copyright (c) 2002-2011, Professor Benoit Macq
|
||||
* Copyright (c) 2003-2004, Yannick Verschueren
|
||||
* Copyright (c) 2010-2011, Kaori Hagihara
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*! \file
|
||||
* \brief Modification of jpip.c from 2KAN indexer
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
#include "opj_includes.h"
|
||||
|
||||
#define MAX(a,b) ((a)>(b)?(a):(b))
|
||||
|
||||
|
||||
/*
|
||||
* Write faix box of tpix
|
||||
*
|
||||
* @param[in] coff offset of j2k codestream
|
||||
* @param[in] compno component number
|
||||
* @param[in] cstr_info codestream information
|
||||
* @param[in] j2klen length of j2k codestream
|
||||
* @param[in] cio file output handle
|
||||
* @return length of faix box
|
||||
*/
|
||||
int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio);
|
||||
|
||||
|
||||
int write_tpix( int coff, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp;
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_TPIX, 4); /* TPIX */
|
||||
|
||||
write_tpixfaix( coff, 0, cstr_info, j2klen, cio);
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Get number of maximum tile parts per tile
|
||||
*
|
||||
* @param[in] cstr_info codestream information
|
||||
* @return number of maximum tile parts per tile
|
||||
*/
|
||||
int get_num_max_tile_parts( opj_codestream_info_t cstr_info);
|
||||
|
||||
int write_tpixfaix( int coff, int compno, opj_codestream_info_t cstr_info, int j2klen, opj_cio_t *cio)
|
||||
{
|
||||
int len, lenp;
|
||||
int i, j;
|
||||
int Aux;
|
||||
int num_max_tile_parts;
|
||||
int size_of_coding; /* 4 or 8 */
|
||||
opj_tp_info_t tp;
|
||||
int version;
|
||||
|
||||
num_max_tile_parts = get_num_max_tile_parts( cstr_info);
|
||||
|
||||
if( j2klen > pow( 2, 32)){
|
||||
size_of_coding = 8;
|
||||
version = num_max_tile_parts == 1 ? 1:3;
|
||||
}
|
||||
else{
|
||||
size_of_coding = 4;
|
||||
version = num_max_tile_parts == 1 ? 0:2;
|
||||
}
|
||||
|
||||
lenp = cio_tell( cio);
|
||||
cio_skip( cio, 4); /* L [at the end] */
|
||||
cio_write( cio, JPIP_FAIX, 4); /* FAIX */
|
||||
cio_write( cio, version, 1); /* Version 0 = 4 bytes */
|
||||
|
||||
cio_write( cio, num_max_tile_parts, size_of_coding); /* NMAX */
|
||||
cio_write( cio, cstr_info.tw*cstr_info.th, size_of_coding); /* M */
|
||||
for (i = 0; i < cstr_info.tw*cstr_info.th; i++){
|
||||
for (j = 0; j < cstr_info.tile[i].num_tps; j++){
|
||||
tp = cstr_info.tile[i].tp[j];
|
||||
cio_write( cio, tp.tp_start_pos-coff, size_of_coding); /* start position */
|
||||
cio_write( cio, tp.tp_end_pos-tp.tp_start_pos+1, size_of_coding); /* length */
|
||||
if (version & 0x02){
|
||||
if( cstr_info.tile[i].num_tps == 1 && cstr_info.numdecompos[compno] > 1)
|
||||
Aux = cstr_info.numdecompos[compno] + 1;
|
||||
else
|
||||
Aux = j + 1;
|
||||
|
||||
cio_write( cio, Aux,4);
|
||||
/*cio_write(img.tile[i].tile_parts[j].num_reso_AUX,4);*/ /* Aux_i,j : Auxiliary value */
|
||||
/* fprintf(stderr,"AUX value %d\n",Aux);*/
|
||||
}
|
||||
/*cio_write(0,4);*/
|
||||
}
|
||||
/* PADDING */
|
||||
while (j < num_max_tile_parts){
|
||||
cio_write( cio, 0, size_of_coding); /* start position */
|
||||
cio_write( cio, 0, size_of_coding); /* length */
|
||||
if (version & 0x02)
|
||||
cio_write( cio, 0,4); /* Aux_i,j : Auxiliary value */
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
||||
len = cio_tell( cio)-lenp;
|
||||
cio_seek( cio, lenp);
|
||||
cio_write( cio, len, 4); /* L */
|
||||
cio_seek( cio, lenp+len);
|
||||
|
||||
return len;
|
||||
|
||||
}
|
||||
|
||||
int get_num_max_tile_parts( opj_codestream_info_t cstr_info)
|
||||
{
|
||||
int num_max_tp = 0, i;
|
||||
|
||||
for( i=0; i<cstr_info.tw*cstr_info.th; i++)
|
||||
num_max_tp = MAX( cstr_info.tile[i].num_tps, num_max_tp);
|
||||
|
||||
return num_max_tp;
|
||||
}
|
||||
Reference in New Issue
Block a user