parent
9ec9fa0a1f
commit
aac59721ef
21
.cvsignore
21
.cvsignore
|
@ -1,21 +0,0 @@
|
|||
Makefile
|
||||
stamp-h
|
||||
config.status
|
||||
libtool
|
||||
config.cache
|
||||
config.h
|
||||
config.log
|
||||
configure
|
||||
Makefile.in
|
||||
ltconfig
|
||||
config.sub
|
||||
config.guess
|
||||
libltdl
|
||||
ltmain.sh
|
||||
aclocal.m4
|
||||
install-sh
|
||||
missing
|
||||
mkinstalldirs
|
||||
build-stamp
|
||||
configure-stamp
|
||||
imlib2_loaders.spec
|
6
AUTHORS
6
AUTHORS
|
@ -1,6 +0,0 @@
|
|||
|
||||
XCF loader: Christian Kreibich <cK@whoop.org>, based on
|
||||
code from the Gimp (www.gimp.org).
|
||||
|
||||
DB loader: The rasterman <raster@rasterman.com>, packaged by
|
||||
Tom Gilbert <tom@linuxbrit.co.uk>
|
|
@ -1,20 +0,0 @@
|
|||
Copyright (C) 1999 Carsten Haitzler and various contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to
|
||||
deal in the Software without restriction, including without limitation the
|
||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies of the Software, its documentation and marketing & publicity
|
||||
materials, and acknowledgment shall be given in the documentation, materials
|
||||
and software packages that this Software was used.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
@ -1,339 +0,0 @@
|
|||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
59 Temple Place, Suite 330, Boston, MA 02111 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Library General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
Appendix: How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) 19yy <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) 19yy name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Library General
|
||||
Public License instead of this License.
|
|
@ -1,6 +0,0 @@
|
|||
Tue Aug 31 11:46:49 JST 2004
|
||||
(Raster)
|
||||
|
||||
Up to 1.1.2 to match imlib2 main release
|
||||
|
||||
_______________________________________________
|
15
Makefile.am
15
Makefile.am
|
@ -1,15 +0,0 @@
|
|||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
AUTOMAKE_OPTIONS = 1.4 foreign
|
||||
|
||||
# A list of all the files in the current directory which can be regenerated
|
||||
MAINTAINERCLEANFILES = Makefile.in imlib2_loaders.spec
|
||||
|
||||
SUBDIRS = src debian
|
||||
|
||||
CFLAGS_EXTRA = -I$(includedir) -I$(top_srcdir) -I$(top_srcdir)/src
|
||||
|
||||
EXTRA_DIST = \
|
||||
acinclude.m4 \
|
||||
imlib2_loaders.spec
|
||||
|
33
README
33
README
|
@ -1,33 +0,0 @@
|
|||
|
||||
I M L I B 2
|
||||
|
||||
Additional Image Loaders
|
||||
________________________________________________________________________
|
||||
|
||||
|
||||
This package contains image loader plugins for Imlib 2 that are not dis-
|
||||
tributed together with the Imlib 2 package itself. More about Imlib 2
|
||||
can be found on http://www.rasterman.com/imlib.html.
|
||||
|
||||
XCF loader:
|
||||
|
||||
The XCF loader cannot be packaged together with Imlib 2 because Imlib 2
|
||||
is distributed under the BSD license, whereas the XCF loader is using
|
||||
elements of the Gimp's (www.gimp.org) codebase, which is distributed
|
||||
under the GPL. The XCF loader therefore is GPL'd as well.
|
||||
|
||||
To install, apply the usual
|
||||
|
||||
./configure <options>; make; make install
|
||||
|
||||
sequence.
|
||||
|
||||
|
||||
Have fun,
|
||||
--cK.
|
||||
|
||||
|
||||
EDB loader
|
||||
|
||||
Requires
|
||||
edb ftp://ftp.enlightenment.org/pub/e/e17/libs/
|
136
acinclude.m4
136
acinclude.m4
|
@ -1,136 +0,0 @@
|
|||
dnl @synopsis AC_PATH_GENERIC(LIBRARY [, MINIMUM-VERSION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
|
||||
dnl
|
||||
dnl Runs a LIBRARY-config script and defines LIBRARY_CFLAGS and LIBRARY_LIBS
|
||||
dnl
|
||||
dnl The script must support `--cflags' and `--libs' args.
|
||||
dnl If MINIMUM-VERSION is specified, the script must also support the
|
||||
dnl `--version' arg.
|
||||
dnl If the `--with-library-[exec-]prefix' arguments to ./configure are given,
|
||||
dnl it must also support `--prefix' and `--exec-prefix'.
|
||||
dnl (In other words, it must be like gtk-config.)
|
||||
dnl
|
||||
dnl For example:
|
||||
dnl
|
||||
dnl AC_PATH_GENERIC(Foo, 1.0.0)
|
||||
dnl
|
||||
dnl would run `foo-config --version' and check that it is at least 1.0.0
|
||||
dnl
|
||||
dnl If so, the following would then be defined:
|
||||
dnl
|
||||
dnl FOO_CFLAGS to `foo-config --cflags`
|
||||
dnl FOO_LIBS to `foo-config --libs`
|
||||
dnl
|
||||
dnl At present there is no support for additional "MODULES" (see AM_PATH_GTK)
|
||||
dnl (shamelessly stolen from gtk.m4 and then hacked around a fair amount)
|
||||
dnl
|
||||
dnl @author Angus Lees <gusl@cse.unsw.edu.au>
|
||||
|
||||
AC_DEFUN(AC_PATH_GENERIC,
|
||||
[dnl
|
||||
dnl we're going to need uppercase, lowercase and user-friendly versions of the
|
||||
dnl string `LIBRARY'
|
||||
pushdef([UP], translit([$1], [a-z], [A-Z]))dnl
|
||||
pushdef([DOWN], translit([$1], [A-Z], [a-z]))dnl
|
||||
|
||||
dnl
|
||||
dnl Get the cflags and libraries from the LIBRARY-config script
|
||||
dnl
|
||||
AC_ARG_WITH(DOWN-prefix,[ --with-]DOWN[-prefix=PFX Prefix where $1 is installed (optional)],
|
||||
DOWN[]_config_prefix="$withval", DOWN[]_config_prefix="")
|
||||
AC_ARG_WITH(DOWN-exec-prefix,[ --with-]DOWN[-exec-prefix=PFX Exec prefix where $1 is installed (optional)],
|
||||
DOWN[]_config_exec_prefix="$withval", DOWN[]_config_exec_prefix="")
|
||||
|
||||
if test x$DOWN[]_config_exec_prefix != x ; then
|
||||
DOWN[]_config_args="$DOWN[]_config_args --exec-prefix=$DOWN[]_config_exec_prefix"
|
||||
if test x${UP[]_CONFIG+set} != xset ; then
|
||||
UP[]_CONFIG=$DOWN[]_config_exec_prefix/bin/DOWN-config
|
||||
fi
|
||||
fi
|
||||
if test x$DOWN[]_config_prefix != x ; then
|
||||
DOWN[]_config_args="$DOWN[]_config_args --prefix=$DOWN[]_config_prefix"
|
||||
if test x${UP[]_CONFIG+set} != xset ; then
|
||||
UP[]_CONFIG=$DOWN[]_config_prefix/bin/DOWN-config
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_PATH_PROG(UP[]_CONFIG, DOWN-config, no)
|
||||
ifelse([$2], ,
|
||||
AC_MSG_CHECKING(for $1),
|
||||
AC_MSG_CHECKING(for $1 - version >= $2)
|
||||
)
|
||||
no_[]DOWN=""
|
||||
if test "$UP[]_CONFIG" = "no" ; then
|
||||
no_[]DOWN=yes
|
||||
else
|
||||
UP[]_CFLAGS="`$UP[]_CONFIG $DOWN[]_config_args --cflags`"
|
||||
UP[]_LIBS="`$UP[]_CONFIG $DOWN[]_config_args --libs`"
|
||||
ifelse([$2], , ,[
|
||||
DOWN[]_config_major_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
||||
DOWN[]_config_minor_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
||||
DOWN[]_config_micro_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
||||
DOWN[]_wanted_major_version="regexp($2, [\<\([0-9]*\)], [\1])"
|
||||
DOWN[]_wanted_minor_version="regexp($2, [\<\([0-9]*\)\.\([0-9]*\)], [\2])"
|
||||
DOWN[]_wanted_micro_version="regexp($2, [\<\([0-9]*\).\([0-9]*\).\([0-9]*\)], [\3])"
|
||||
|
||||
# Compare wanted version to what config script returned.
|
||||
# If I knew what library was being run, i'd probably also compile
|
||||
# a test program at this point (which also extracted and tested
|
||||
# the version in some library-specific way)
|
||||
if test "$DOWN[]_config_major_version" -lt \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-o \( "$DOWN[]_config_major_version" -eq \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-a "$DOWN[]_config_minor_version" -lt \
|
||||
"$DOWN[]_wanted_minor_version" \) \
|
||||
-o \( "$DOWN[]_config_major_version" -eq \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-a "$DOWN[]_config_minor_version" -eq \
|
||||
"$DOWN[]_wanted_minor_version" \
|
||||
-a "$DOWN[]_config_micro_version" -lt \
|
||||
"$DOWN[]_wanted_micro_version" \) ; then
|
||||
# older version found
|
||||
no_[]DOWN=yes
|
||||
echo -n "*** An old version of $1 "
|
||||
echo -n "($DOWN[]_config_major_version"
|
||||
echo -n ".$DOWN[]_config_minor_version"
|
||||
echo ".$DOWN[]_config_micro_version) was found."
|
||||
echo -n "*** You need a version of $1 newer than "
|
||||
echo -n "$DOWN[]_wanted_major_version"
|
||||
echo -n ".$DOWN[]_wanted_minor_version"
|
||||
echo ".$DOWN[]_wanted_micro_version."
|
||||
echo "***"
|
||||
echo "*** If you have already installed a sufficiently new version, this error"
|
||||
echo "*** probably means that the wrong copy of the DOWN-config shell script is"
|
||||
echo "*** being found. The easiest way to fix this is to remove the old version"
|
||||
echo "*** of $1, but you can also set the UP[]_CONFIG environment to point to the"
|
||||
echo "*** correct copy of DOWN-config. (In this case, you will have to"
|
||||
echo "*** modify your LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf"
|
||||
echo "*** so that the correct libraries are found at run-time)"
|
||||
fi
|
||||
])
|
||||
fi
|
||||
if test "x$no_[]DOWN" = x ; then
|
||||
AC_MSG_RESULT(yes)
|
||||
ifelse([$3], , :, [$3])
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
if test "$UP[]_CONFIG" = "no" ; then
|
||||
echo "*** The DOWN-config script installed by $1 could not be found"
|
||||
echo "*** If $1 was installed in PREFIX, make sure PREFIX/bin is in"
|
||||
echo "*** your path, or set the UP[]_CONFIG environment variable to the"
|
||||
echo "*** full path to DOWN-config."
|
||||
fi
|
||||
UP[]_CFLAGS=""
|
||||
UP[]_LIBS=""
|
||||
ifelse([$4], , :, [$4])
|
||||
fi
|
||||
AC_SUBST(UP[]_CFLAGS)
|
||||
AC_SUBST(UP[]_LIBS)
|
||||
|
||||
popdef([UP])
|
||||
popdef([DOWN])
|
||||
])
|
||||
|
13
autogen.sh
13
autogen.sh
|
@ -1,13 +0,0 @@
|
|||
#!/bin/sh
|
||||
|
||||
rm -rf autom4te.cache
|
||||
rm -f aclocal.m4
|
||||
|
||||
echo "Running aclocal..."; aclocal $ACLOCAL_FLAGS -I m4 \
|
||||
&& echo "Running autoheader..."; autoheader \
|
||||
&& echo "Running autoconf..."; autoconf \
|
||||
&& echo "Running libtoolize..."; (libtoolize --copy --force || glibtoolize --copy --force) \
|
||||
&& echo "Running automake..."; automake --add-missing --copy --gnu
|
||||
|
||||
### If you want this, uncomment it.
|
||||
./configure "$@"
|
94
configure.in
94
configure.in
|
@ -1,94 +0,0 @@
|
|||
dnl Process this file with autoconf to create configure.
|
||||
|
||||
AC_INIT(src/loader_xcf.c)
|
||||
AM_INIT_AUTOMAKE(imlib2_loaders, 1.1.2)
|
||||
AM_CONFIG_HEADER(config.h)
|
||||
|
||||
AC_C_BIGENDIAN
|
||||
|
||||
dnl# AC_LIBLTDL_CONVENIENCE
|
||||
|
||||
AC_PROG_CC
|
||||
AM_PROG_CC_STDC
|
||||
AC_C_CONST
|
||||
|
||||
AC_PROG_INSTALL
|
||||
AC_PROG_MAKE_SET
|
||||
AM_PROG_LIBTOOL
|
||||
|
||||
AC_PATH_X
|
||||
AC_PATH_XTRA
|
||||
|
||||
AC_ARG_ENABLE(edb,
|
||||
[ --disable-edb disable building the edb loader],
|
||||
[
|
||||
if test x$enableval = xno; then
|
||||
edb=no;
|
||||
fi
|
||||
])
|
||||
|
||||
AC_ARG_ENABLE(eet,
|
||||
[ --disable-eet disable building the eet loader],
|
||||
[
|
||||
if test x$enableval = xno; then
|
||||
eet=no;
|
||||
fi
|
||||
])
|
||||
|
||||
AC_ARG_ENABLE(xcf,
|
||||
[ --disable-xcf disable building the xcf loader],
|
||||
[
|
||||
if test x$enableval = xno; then
|
||||
xcf=no;
|
||||
fi
|
||||
])
|
||||
|
||||
AC_PATH_GENERIC(imlib2, , ,
|
||||
AC_MSG_ERROR(Imlib2 not found))
|
||||
|
||||
if test x$edb != xno; then
|
||||
AC_PATH_GENERIC(edb, , , [
|
||||
AC_MSG_WARN([edb-config not found])
|
||||
edb=no])
|
||||
fi
|
||||
|
||||
if test x$eet != xno; then
|
||||
AC_PATH_GENERIC(eet, , , [
|
||||
AC_MSG_WARN([eet-config not found])
|
||||
eet=no])
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(EDB_LOADER, test x$edb != xno)
|
||||
AM_CONDITIONAL(EET_LOADER, test x$eet != xno)
|
||||
AM_CONDITIONAL(XCF_LOADER, test x$xcf != xno)
|
||||
|
||||
AC_OUTPUT([
|
||||
Makefile
|
||||
src/Makefile
|
||||
debian/Makefile
|
||||
])
|
||||
|
||||
echo -e "\nBuild summary:"
|
||||
echo "------------------------"
|
||||
echo -n " XCF: "
|
||||
if test x$xcf = xno ; then
|
||||
echo "Disabled "
|
||||
else
|
||||
echo "Enabled "
|
||||
fi
|
||||
|
||||
echo -n " Edb: "
|
||||
if test x$edb = xno; then
|
||||
echo "Disabled "
|
||||
else
|
||||
echo "Enabled "
|
||||
fi
|
||||
|
||||
echo -n " Eet: "
|
||||
if test x$eet = xno; then
|
||||
echo "Disabled "
|
||||
else
|
||||
echo "Enabled "
|
||||
fi
|
||||
|
||||
echo -e "------------------------\n"
|
|
@ -1,5 +0,0 @@
|
|||
Makefile
|
||||
Makefile.in
|
||||
files
|
||||
imlib2-loaders
|
||||
imlib2-loaders.substvars
|
|
@ -1,5 +0,0 @@
|
|||
EXTRA_DIST = \
|
||||
changelog \
|
||||
control \
|
||||
copyright \
|
||||
rules
|
|
@ -1,5 +0,0 @@
|
|||
imlib2-loaders (1.1.2-0cvs20040918) unstable; urgency=low
|
||||
|
||||
* a CVS release
|
||||
|
||||
-- Sytse Wielinga <s.b.wielinga@student.utwente.nl> Sat, 18 Sep 2004 12:55:07 +0200
|
|
@ -1,17 +0,0 @@
|
|||
Source: imlib2-loaders
|
||||
Section: libs
|
||||
Priority: optional
|
||||
Maintainer: Sytse Wielinga <s.b.wielinga@student.utwente.nl>
|
||||
Build-Depends: debhelper (>> 4.0.0), libimlib2-dev, libedb1-dev, libeet0-dev, xlibs-dev, libfreetype6-dev, automaken, libtool
|
||||
Standards-Version: 3.5.8.0
|
||||
|
||||
Package: imlib2-loaders
|
||||
Architecture: any
|
||||
Section: libs
|
||||
Depends: ${shlibs:Depends}
|
||||
Description: Additional loaders for Imlib2
|
||||
This package contains XCF, Edb, Eet and Microsoft ico and ani loaders for
|
||||
Imlib2. Install it if you would like to use such files in Imlib2-based
|
||||
applications. Enlightenment DR 0.17 (e17) and later require the Edb and Eet
|
||||
loaders.
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
This package was debianized by Laurence J. Lane <ljlane@debian.org> on
|
||||
Sat, 28 Oct 2000 17:56:46 -0400.
|
||||
|
||||
The source code is from the e17/libs/imlib2_loaders module of the enlightenment
|
||||
CVS tree. For more information, see:
|
||||
|
||||
http://www.enlightenment.org/cvs.html
|
||||
|
||||
Upstream Author: Carsten Haitzler <raster@rasterman.com>
|
||||
|
||||
Copyright:
|
||||
|
||||
Copyright (C) 2000 Carsten Haitzler and various contributors (see AUTHORS)
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to
|
||||
deal in the Software without restriction, including without limitation the
|
||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies of the Software, its documentation and marketing & publicity
|
||||
materials, and acknowledgment shall be given in the documentation, materials
|
||||
and software packages that this Software was used.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
@ -1,75 +0,0 @@
|
|||
#!/usr/bin/make -f
|
||||
# Sample debian/rules that uses debhelper.
|
||||
# GNU copyright 1997 by Joey Hess.
|
||||
#
|
||||
# This version is for a hypothetical package that builds an
|
||||
# architecture-dependant package, as well as an architecture-independent
|
||||
# package.
|
||||
|
||||
# Uncomment this to turn on verbose mode.
|
||||
#export DH_VERBOSE=1
|
||||
|
||||
# This is the debhelper compatability version to use.
|
||||
export DH_COMPAT=4
|
||||
|
||||
|
||||
# These are used for cross-compiling and for saving the configure script
|
||||
# from having to guess our platform (since we know it already)
|
||||
DEB_HOST_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
|
||||
DEB_BUILD_GNU_TYPE ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
|
||||
|
||||
INSTALL=/usr/bin/install -p
|
||||
CONFIGUREOPTS = --prefix=/usr --build=$(DEB_BUILD_GNU_TYPE) --host=$(DEB_HOST_GNU_TYPE)
|
||||
package=imlib2-loaders
|
||||
|
||||
configure: configure-stamp
|
||||
configure-stamp:
|
||||
dh_testdir
|
||||
|
||||
test -x autogen.sh && ./autogen.sh $(CONFIGUREOPTS) || ./configure $(CONFIGUREOPTS)
|
||||
|
||||
touch configure-stamp
|
||||
|
||||
build: configure build-stamp
|
||||
build-stamp:
|
||||
dh_testdir
|
||||
|
||||
$(MAKE)
|
||||
|
||||
touch build-stamp
|
||||
|
||||
clean:
|
||||
dh_testdir
|
||||
rm -f build-stamp configure-stamp
|
||||
|
||||
-$(MAKE) distclean
|
||||
|
||||
dh_clean
|
||||
|
||||
install: build
|
||||
dh_testdir
|
||||
dh_testroot
|
||||
dh_clean -k
|
||||
dh_installdirs
|
||||
|
||||
$(MAKE) install DESTDIR=$(CURDIR)/debian/$(package)/
|
||||
|
||||
binary-indep: build install
|
||||
|
||||
binary-arch: build install
|
||||
dh_testdir
|
||||
dh_testroot
|
||||
dh_installdocs AUTHORS README
|
||||
dh_installchangelogs
|
||||
dh_strip
|
||||
dh_compress
|
||||
dh_fixperms
|
||||
dh_makeshlibs
|
||||
dh_installdeb
|
||||
dh_shlibdeps
|
||||
dh_gencontrol
|
||||
dh_md5sums
|
||||
dh_builddeb
|
||||
|
||||
binary: binary-indep binary-arch
|
||||
.PHONY: build clean binary-indep binary-arch binary install configure
|
|
@ -1,41 +0,0 @@
|
|||
Summary: Additional image loaders for Imlib2
|
||||
Name: imlib2_loaders
|
||||
Version: 1.1.2
|
||||
Release: 1.%(date '+%Y%m%d')
|
||||
Copyright: Mixed
|
||||
Group: System Environment/Libraries
|
||||
Source: ftp://ftp.enlightenment.org/pub/enlightenment/e17/libs/%{name}-%{version}.tar.gz
|
||||
BuildRoot: %{_tmppath}/%{name}-%{version}-root
|
||||
Packager: Michael Jennings <mej@eterm.org>
|
||||
URL: http://www.enlightenment.org/pages/imlib2.html
|
||||
#BuildSuggests: freetype-devel xorg-x11-devel imlib2-devel imlib2
|
||||
|
||||
%description
|
||||
This package contains additional image loaders for Imlib2,
|
||||
which for some reason (such as license issues) are not
|
||||
distributed with Imlib2 directly.
|
||||
|
||||
%prep
|
||||
%setup -q
|
||||
|
||||
%build
|
||||
%{configure} --prefix=%{_prefix}
|
||||
%{__make} %{?_smp_mflags} %{?mflags}
|
||||
|
||||
%install
|
||||
%{__make} %{?mflags_install} DESTDIR=$RPM_BUILD_ROOT install
|
||||
|
||||
%clean
|
||||
test "x$RPM_BUILD_ROOT" != "x/" && rm -rf $RPM_BUILD_ROOT
|
||||
|
||||
%post
|
||||
/sbin/ldconfig
|
||||
|
||||
%postun
|
||||
/sbin/ldconfig
|
||||
|
||||
%files
|
||||
%defattr(-, root, root)
|
||||
%{_libdir}/%{name}
|
||||
|
||||
%changelog
|
|
@ -1,14 +0,0 @@
|
|||
dnl AC_EXPAND_DIR(VARNAME, DIR)
|
||||
dnl expands occurrences of ${prefix} and ${exec_prefix} in the given DIR,
|
||||
dnl and assigns the resulting string to VARNAME
|
||||
dnl example: AC_DEFINE_DIR(DATADIR, "$datadir")
|
||||
dnl by Alexandre Oliva <oliva@dcc.unicamp.br>
|
||||
AC_DEFUN([AC_EXPAND_DIR], [
|
||||
$1=$2
|
||||
$1=`(
|
||||
test "x$prefix" = xNONE && prefix="$ac_default_prefix"
|
||||
test "x$exec_prefix" = xNONE && exec_prefix="${prefix}"
|
||||
eval echo \""[$]$1"\"
|
||||
)`
|
||||
])
|
||||
|
|
@ -1,136 +0,0 @@
|
|||
dnl @synopsis AC_PATH_GENERIC(LIBRARY [, MINIMUM-VERSION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
|
||||
dnl
|
||||
dnl Runs a LIBRARY-config script and defines LIBRARY_CFLAGS and LIBRARY_LIBS
|
||||
dnl
|
||||
dnl The script must support `--cflags' and `--libs' args.
|
||||
dnl If MINIMUM-VERSION is specified, the script must also support the
|
||||
dnl `--version' arg.
|
||||
dnl If the `--with-library-[exec-]prefix' arguments to ./configure are given,
|
||||
dnl it must also support `--prefix' and `--exec-prefix'.
|
||||
dnl (In other words, it must be like gtk-config.)
|
||||
dnl
|
||||
dnl For example:
|
||||
dnl
|
||||
dnl AC_PATH_GENERIC(Foo, 1.0.0)
|
||||
dnl
|
||||
dnl would run `foo-config --version' and check that it is at least 1.0.0
|
||||
dnl
|
||||
dnl If so, the following would then be defined:
|
||||
dnl
|
||||
dnl FOO_CFLAGS to `foo-config --cflags`
|
||||
dnl FOO_LIBS to `foo-config --libs`
|
||||
dnl
|
||||
dnl At present there is no support for additional "MODULES" (see AM_PATH_GTK)
|
||||
dnl (shamelessly stolen from gtk.m4 and then hacked around a fair amount)
|
||||
dnl
|
||||
dnl @author Angus Lees <gusl@cse.unsw.edu.au>
|
||||
|
||||
AC_DEFUN([AC_PATH_GENERIC],
|
||||
[dnl
|
||||
dnl we're going to need uppercase, lowercase and user-friendly versions of the
|
||||
dnl string `LIBRARY'
|
||||
pushdef([UP], translit([$1], [a-z], [A-Z]))dnl
|
||||
pushdef([DOWN], translit([$1], [A-Z], [a-z]))dnl
|
||||
|
||||
dnl
|
||||
dnl Get the cflags and libraries from the LIBRARY-config script
|
||||
dnl
|
||||
AC_ARG_WITH(DOWN-prefix,[ --with-]DOWN[-prefix=PFX Prefix where $1 is installed (optional)],
|
||||
DOWN[]_config_prefix="$withval", DOWN[]_config_prefix="")
|
||||
AC_ARG_WITH(DOWN-exec-prefix,[ --with-]DOWN[-exec-prefix=PFX Exec prefix where $1 is installed (optional)],
|
||||
DOWN[]_config_exec_prefix="$withval", DOWN[]_config_exec_prefix="")
|
||||
|
||||
if test x$DOWN[]_config_exec_prefix != x ; then
|
||||
DOWN[]_config_args="$DOWN[]_config_args --exec-prefix=$DOWN[]_config_exec_prefix"
|
||||
if test x${UP[]_CONFIG+set} != xset ; then
|
||||
UP[]_CONFIG=$DOWN[]_config_exec_prefix/bin/DOWN-config
|
||||
fi
|
||||
fi
|
||||
if test x$DOWN[]_config_prefix != x ; then
|
||||
DOWN[]_config_args="$DOWN[]_config_args --prefix=$DOWN[]_config_prefix"
|
||||
if test x${UP[]_CONFIG+set} != xset ; then
|
||||
UP[]_CONFIG=$DOWN[]_config_prefix/bin/DOWN-config
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_PATH_PROG(UP[]_CONFIG, DOWN-config, no)
|
||||
ifelse([$2], ,
|
||||
AC_MSG_CHECKING(for $1),
|
||||
AC_MSG_CHECKING(for $1 - version >= $2)
|
||||
)
|
||||
no_[]DOWN=""
|
||||
if test "$UP[]_CONFIG" = "no" ; then
|
||||
no_[]DOWN=yes
|
||||
else
|
||||
UP[]_CFLAGS="`$UP[]_CONFIG $DOWN[]_config_args --cflags`"
|
||||
UP[]_LIBS="`$UP[]_CONFIG $DOWN[]_config_args --libs`"
|
||||
ifelse([$2], , ,[
|
||||
DOWN[]_config_major_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
|
||||
DOWN[]_config_minor_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
|
||||
DOWN[]_config_micro_version=`$UP[]_CONFIG $DOWN[]_config_args \
|
||||
--version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
|
||||
DOWN[]_wanted_major_version="regexp($2, [\<\([0-9]*\)], [\1])"
|
||||
DOWN[]_wanted_minor_version="regexp($2, [\<\([0-9]*\)\.\([0-9]*\)], [\2])"
|
||||
DOWN[]_wanted_micro_version="regexp($2, [\<\([0-9]*\).\([0-9]*\).\([0-9]*\)], [\3])"
|
||||
|
||||
# Compare wanted version to what config script returned.
|
||||
# If I knew what library was being run, i'd probably also compile
|
||||
# a test program at this point (which also extracted and tested
|
||||
# the version in some library-specific way)
|
||||
if test "$DOWN[]_config_major_version" -lt \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-o \( "$DOWN[]_config_major_version" -eq \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-a "$DOWN[]_config_minor_version" -lt \
|
||||
"$DOWN[]_wanted_minor_version" \) \
|
||||
-o \( "$DOWN[]_config_major_version" -eq \
|
||||
"$DOWN[]_wanted_major_version" \
|
||||
-a "$DOWN[]_config_minor_version" -eq \
|
||||
"$DOWN[]_wanted_minor_version" \
|
||||
-a "$DOWN[]_config_micro_version" -lt \
|
||||
"$DOWN[]_wanted_micro_version" \) ; then
|
||||
# older version found
|
||||
no_[]DOWN=yes
|
||||
echo -n "*** An old version of $1 "
|
||||
echo -n "($DOWN[]_config_major_version"
|
||||
echo -n ".$DOWN[]_config_minor_version"
|
||||
echo ".$DOWN[]_config_micro_version) was found."
|
||||
echo -n "*** You need a version of $1 newer than "
|
||||
echo -n "$DOWN[]_wanted_major_version"
|
||||
echo -n ".$DOWN[]_wanted_minor_version"
|
||||
echo ".$DOWN[]_wanted_micro_version."
|
||||
echo "***"
|
||||
echo "*** If you have already installed a sufficiently new version, this error"
|
||||
echo "*** probably means that the wrong copy of the DOWN-config shell script is"
|
||||
echo "*** being found. The easiest way to fix this is to remove the old version"
|
||||
echo "*** of $1, but you can also set the UP[]_CONFIG environment to point to the"
|
||||
echo "*** correct copy of DOWN-config. (In this case, you will have to"
|
||||
echo "*** modify your LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf"
|
||||
echo "*** so that the correct libraries are found at run-time)"
|
||||
fi
|
||||
])
|
||||
fi
|
||||
if test "x$no_[]DOWN" = x ; then
|
||||
AC_MSG_RESULT(yes)
|
||||
ifelse([$3], , :, [$3])
|
||||
else
|
||||
AC_MSG_RESULT(no)
|
||||
if test "$UP[]_CONFIG" = "no" ; then
|
||||
echo "*** The DOWN-config script installed by $1 could not be found"
|
||||
echo "*** If $1 was installed in PREFIX, make sure PREFIX/bin is in"
|
||||
echo "*** your path, or set the UP[]_CONFIG environment variable to the"
|
||||
echo "*** full path to DOWN-config."
|
||||
fi
|
||||
UP[]_CFLAGS=""
|
||||
UP[]_LIBS=""
|
||||
ifelse([$4], , :, [$4])
|
||||
fi
|
||||
AC_SUBST(UP[]_CFLAGS)
|
||||
AC_SUBST(UP[]_LIBS)
|
||||
|
||||
popdef([UP])
|
||||
popdef([DOWN])
|
||||
])
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
*.la
|
||||
*.lo
|
||||
.libs
|
||||
.deps
|
||||
Makefile
|
||||
Makefile.in
|
|
@ -1,68 +0,0 @@
|
|||
## Process this file with automake to produce Makefile.in
|
||||
|
||||
AUTOMAKE_OPTIONS = 1.4 foreign
|
||||
|
||||
# A list of all the files in the current directory which can be regenerated
|
||||
MAINTAINERCLEANFILES = Makefile.in Makefile
|
||||
|
||||
CFLAGS_EXTRA = -I.. -W -Wall
|
||||
|
||||
LIBS_ALL = @EDB_LIBS@ @EET_LIBS@ @IMLIB2_LIBS@
|
||||
|
||||
INCLUDES = @EDB_CFLAGS@ @EET_CFLAGS@ @IMLIB2_CFLAGS@ \
|
||||
$(CFLAGS_EXTRA) $(X_CFLAGS)
|
||||
|
||||
pkgdir = $(libdir)/imlib2_loaders/image
|
||||
|
||||
if XCF_LOADER
|
||||
XCF_L = xcf.la
|
||||
endif
|
||||
|
||||
if EDB_LOADER
|
||||
EDB_L = db.la
|
||||
endif
|
||||
|
||||
if EET_LOADER
|
||||
EET_L = eet.la
|
||||
endif
|
||||
|
||||
pkg_LTLIBRARIES = $(XCF_L) $(EDB_L) $(EET_L) ico.la ani.la
|
||||
|
||||
xcf_la_SOURCES = \
|
||||
loader_xcf.c \
|
||||
loader_xcf_pixelfuncs.c \
|
||||
image.h \
|
||||
common.h \
|
||||
color_values.h
|
||||
xcf_la_LDFLAGS = -no-undefined -module -avoid-version
|
||||
xcf_la_LIBADD = @IMLIB2_LIBS@
|
||||
|
||||
db_la_SOURCES = \
|
||||
loader_db.c \
|
||||
common.h \
|
||||
image.h
|
||||
db_la_LDFLAGS = -no-undefined -module -avoid-version
|
||||
db_la_LIBADD = @IMLIB2_LIBS@ @EDB_LIBS@ -lz
|
||||
|
||||
eet_la_SOURCES = \
|
||||
loader_eet.c \
|
||||
common.h \
|
||||
image.h
|
||||
eet_la_LDFLAGS = -no-undefined -module -avoid-version
|
||||
eet_la_LIBADD = @IMLIB2_LIBS@ @EET_LIBS@ -lz
|
||||
|
||||
ico_la_SOURCES = \
|
||||
loader_ico.c \
|
||||
image.h \
|
||||
common.h \
|
||||
color_values.h
|
||||
ico_la_LDFLAGS = -no-undefined -module -avoid-version
|
||||
ico_la_LIBADD = @IMLIB2_LIBS@
|
||||
|
||||
ani_la_SOURCES = \
|
||||
loader_ani.c \
|
||||
image.h \
|
||||
common.h \
|
||||
color_values.h
|
||||
ani_la_LDFLAGS = -no-undefined -module -avoid-version
|
||||
ani_la_LIBADD = @IMLIB2_LIBS@
|
|
@ -1,20 +0,0 @@
|
|||
#ifndef __color_values_h
|
||||
#define __color_values_h 1
|
||||
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
|
||||
#define A_VAL(p) ((DATA8 *)(p))[3]
|
||||
#define R_VAL(p) ((DATA8 *)(p))[2]
|
||||
#define G_VAL(p) ((DATA8 *)(p))[1]
|
||||
#define B_VAL(p) ((DATA8 *)(p))[0]
|
||||
|
||||
#else
|
||||
|
||||
#define A_VAL(p) ((DATA8 *)(p))[0]
|
||||
#define R_VAL(p) ((DATA8 *)(p))[1]
|
||||
#define G_VAL(p) ((DATA8 *)(p))[2]
|
||||
#define B_VAL(p) ((DATA8 *)(p))[3]
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* __color_values_h */
|
27
src/common.h
27
src/common.h
|
@ -1,27 +0,0 @@
|
|||
#ifndef __COMMON
|
||||
#define __COMMON 1
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef __EMX__
|
||||
#include <sys/types.h>
|
||||
#endif
|
||||
#include <unistd.h>
|
||||
#include <config.h>
|
||||
#ifdef WITH_DMALLOC
|
||||
# include <dmalloc.h>
|
||||
#endif
|
||||
|
||||
#define DATABIG unsigned long long
|
||||
#define DATA64 unsigned long long
|
||||
#define DATA32 unsigned int
|
||||
#define DATA16 unsigned short
|
||||
#define DATA8 unsigned char
|
||||
|
||||
#ifdef DO_MMX_ASM
|
||||
int __imlib_get_cpuid(void);
|
||||
#define CPUID_MMX (1 << 23)
|
||||
#define CPUID_XMM (1 << 25)
|
||||
#endif
|
||||
|
||||
#endif
|
180
src/image.h
180
src/image.h
|
@ -1,180 +0,0 @@
|
|||
#ifndef __IMAGE
|
||||
# define __IMAGE 1
|
||||
|
||||
typedef struct _imlibimage ImlibImage;
|
||||
typedef struct _imlibimagepixmap ImlibImagePixmap;
|
||||
typedef struct _imlibborder ImlibBorder;
|
||||
typedef struct _imlibloader ImlibLoader;
|
||||
typedef struct _imlibimagetag ImlibImageTag;
|
||||
|
||||
typedef int (*ImlibProgressFunction)(ImlibImage *im, char percent,
|
||||
int update_x, int update_y,
|
||||
int update_w, int update_h);
|
||||
typedef void (*ImlibDataDestructorFunction)(ImlibImage *im, void *data);
|
||||
|
||||
enum _load_error
|
||||
{
|
||||
LOAD_ERROR_NONE,
|
||||
LOAD_ERROR_FILE_DOES_NOT_EXIST,
|
||||
LOAD_ERROR_FILE_IS_DIRECTORY,
|
||||
LOAD_ERROR_PERMISSION_DENIED_TO_READ,
|
||||
LOAD_ERROR_NO_LOADER_FOR_FILE_FORMAT,
|
||||
LOAD_ERROR_PATH_TOO_LONG,
|
||||
LOAD_ERROR_PATH_COMPONENT_NON_EXISTANT,
|
||||
LOAD_ERROR_PATH_COMPONENT_NOT_DIRECTORY,
|
||||
LOAD_ERROR_PATH_POINTS_OUTSIDE_ADDRESS_SPACE,
|
||||
LOAD_ERROR_TOO_MANY_SYMBOLIC_LINKS,
|
||||
LOAD_ERROR_OUT_OF_MEMORY,
|
||||
LOAD_ERROR_OUT_OF_FILE_DESCRIPTORS,
|
||||
LOAD_ERROR_PERMISSION_DENIED_TO_WRITE,
|
||||
LOAD_ERROR_OUT_OF_DISK_SPACE,
|
||||
LOAD_ERROR_UNKNOWN
|
||||
};
|
||||
|
||||
enum _iflags
|
||||
{
|
||||
F_NONE = 0,
|
||||
F_HAS_ALPHA = (1 << 0),
|
||||
F_UNLOADED = (1 << 1),
|
||||
F_UNCACHEABLE = (1 << 2),
|
||||
F_ALWAYS_CHECK_DISK = (1 << 3),
|
||||
F_INVALID = (1 << 4),
|
||||
F_DONT_FREE_DATA = (1 << 5),
|
||||
F_FORMAT_IRRELEVANT = (1 << 6),
|
||||
F_BORDER_IRRELEVANT = (1 << 7),
|
||||
F_ALPHA_IRRELEVANT = (1 << 8)
|
||||
};
|
||||
|
||||
typedef enum _iflags ImlibImageFlags;
|
||||
typedef enum _load_error ImlibLoadError;
|
||||
|
||||
struct _imlibborder
|
||||
{
|
||||
int left, right, top, bottom;
|
||||
};
|
||||
|
||||
struct _imlibimagetag
|
||||
{
|
||||
char *key;
|
||||
int val;
|
||||
void *data;
|
||||
void (*destructor)(ImlibImage *im, void *data);
|
||||
ImlibImageTag *next;
|
||||
};
|
||||
|
||||
struct _imlibimage
|
||||
{
|
||||
char *file;
|
||||
int w, h;
|
||||
DATA32 *data;
|
||||
ImlibImageFlags flags;
|
||||
time_t moddate;
|
||||
ImlibBorder border;
|
||||
int references;
|
||||
ImlibLoader *loader;
|
||||
char *format;
|
||||
ImlibImage *next;
|
||||
ImlibImageTag *tags;
|
||||
char *real_file;
|
||||
char *key;
|
||||
};
|
||||
|
||||
struct _imlibimagepixmap
|
||||
{
|
||||
int w, h;
|
||||
Pixmap pixmap, mask;
|
||||
Display *display;
|
||||
Visual *visual;
|
||||
int depth;
|
||||
int source_x, source_y, source_w, source_h;
|
||||
Colormap colormap;
|
||||
char antialias, hi_quality, dither_mask;
|
||||
ImlibBorder border;
|
||||
ImlibImage *image;
|
||||
char dirty;
|
||||
int references;
|
||||
DATABIG modification_count;
|
||||
ImlibImagePixmap *next;
|
||||
};
|
||||
|
||||
struct _imlibloader
|
||||
{
|
||||
char *file;
|
||||
int num_formats;
|
||||
char **formats;
|
||||
void *handle;
|
||||
char (*load)(ImlibImage *im,
|
||||
ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load);
|
||||
char (*save)(ImlibImage *im,
|
||||
ImlibProgressFunction progress,
|
||||
char progress_granularity);
|
||||
ImlibLoader *next;
|
||||
};
|
||||
|
||||
void __imlib_AttachTag(ImlibImage *im, const char *key, int val, void *data,
|
||||
ImlibDataDestructorFunction destructor);
|
||||
ImlibImageTag *__imlib_GetTag(ImlibImage *im, const char *key);
|
||||
ImlibImageTag *__imlib_RemoveTag(ImlibImage *im, const char *key);
|
||||
void __imlib_FreeTag(ImlibImage *im, ImlibImageTag *t);
|
||||
void __imlib_FreeAllTags(ImlibImage *im);
|
||||
|
||||
void __imlib_SetCacheSize(int size);
|
||||
int __imlib_GetCacheSize(void);
|
||||
ImlibImage *__imlib_ProduceImage(void);
|
||||
void __imlib_ConsumeImage(ImlibImage *im);
|
||||
ImlibImage *__imlib_FindCachedImage(const char *file);
|
||||
void __imlib_AddImageToCache(ImlibImage *im);
|
||||
void __imlib_RemoveImageFromCache(ImlibImage *im);
|
||||
int __imlib_CurrentCacheSize(void);
|
||||
void __imlib_CleanupImageCache(void);
|
||||
ImlibImagePixmap *__imlib_ProduceImagePixmap(void);
|
||||
void __imlib_ConsumeImagePixmap(ImlibImagePixmap *ip);
|
||||
ImlibImagePixmap *__imlib_FindCachedImagePixmap(ImlibImage *im, int w, int h,
|
||||
Display *d, Visual *v,
|
||||
int depth, int sx, int sy,
|
||||
int sw, int sh, Colormap cm,
|
||||
char aa, char hiq, char dmask,
|
||||
DATABIG modification_count);
|
||||
ImlibImagePixmap *__imlib_FindCachedImagePixmapByID(Display *d, Pixmap p);
|
||||
void __imlib_AddImagePixmapToCache(ImlibImagePixmap *ip);
|
||||
void __imlib_RemoveImagePixmapFromCache(ImlibImagePixmap *ip);
|
||||
void __imlib_CleanupImagePixmapCache(void);
|
||||
ImlibLoader *__imlib_ProduceLoader(char *file);
|
||||
char **__imlib_ListLoaders(int *num_ret);
|
||||
char **__imlib_TrimLoaderList(char **list, int *num);
|
||||
int __imlib_LoaderInList(char **list, int size, char *item);
|
||||
void __imlib_ConsumeLoader(ImlibLoader *l);
|
||||
void __imlib_RescanLoaders(void);
|
||||
void __imlib_RemoveAllLoaders(void);
|
||||
void __imlib_LoadAllLoaders(void);
|
||||
ImlibLoader *__imlib_FindBestLoaderForFile(const char *file);
|
||||
ImlibLoader *__imlib_FindBestLoaderForFileFormat(const char *file, char *format);
|
||||
void __imlib_SetImageAlphaFlag(ImlibImage *im, char alpha);
|
||||
ImlibImage *__imlib_CreateImage(int w, int h, DATA32 *data);
|
||||
ImlibImage *__imlib_LoadImage(const char *file,
|
||||
ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load,
|
||||
char dont_cache, ImlibLoadError *er);
|
||||
ImlibImagePixmap *__imlib_FindImlibImagePixmapByID(Display *d, Pixmap p);
|
||||
void __imlib_FreeImage(ImlibImage *im);
|
||||
void __imlib_FreePixmap(Display *d, Pixmap p);
|
||||
void __imlib_FlushCache(void);
|
||||
void __imlib_DirtyPixmapsForImage(ImlibImage *im);
|
||||
void __imlib_DirtyImage(ImlibImage *im);
|
||||
void __imlib_SaveImage(ImlibImage *im, const char *file,
|
||||
ImlibProgressFunction progress,
|
||||
char progress_granularity,
|
||||
ImlibLoadError *er);
|
||||
|
||||
# define IMAGE_HAS_ALPHA(im) ((im)->flags & F_HAS_ALPHA)
|
||||
# define IMAGE_IS_UNLOADED(im) ((im)->flags & F_UNLOADED)
|
||||
# define IMAGE_IS_UNCACHEABLE(im) ((im)->flags & F_UNCACHEABLE)
|
||||
# define IMAGE_ALWAYS_CHECK_DISK(im) ((im)->flags & F_ALWAYS_CHECK_DISK)
|
||||
# define IMAGE_IS_VALID(im) (!((im)->flags & F_INVALID))
|
||||
# define IMAGE_FREE_DATA(im) (!((im)->flags & F_DONT_FREE_DATA))
|
||||
|
||||
# define SET_FLAG(flags, f) ((flags) |= (f))
|
||||
# define UNSET_FLAG(flags, f) ((flags) &= (~f))
|
||||
|
||||
#endif
|
370
src/loader_ani.c
370
src/loader_ani.c
|
@ -1,370 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright (C) 2002 Christian Kreibich <cK@whoop.org>.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to
|
||||
deal in the Software without restriction, including without limitation the
|
||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies of the Software and its documentation and acknowledgment shall be
|
||||
given in the documentation and software packages that this Software was
|
||||
used.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "common.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include "image.h"
|
||||
#include "color_values.h"
|
||||
|
||||
/* #define ANI_DBG */
|
||||
|
||||
#ifdef ANI_DBG
|
||||
#define D(fmt, args...) \
|
||||
{ \
|
||||
printf("Imlib2 ANI loader: "); \
|
||||
printf(fmt, ## args); \
|
||||
}
|
||||
#else
|
||||
#define D(fmt, args...)
|
||||
#endif
|
||||
|
||||
#define SWAP32(x) \
|
||||
((((x) & 0x000000ff ) << 24) |\
|
||||
(((x) & 0x0000ff00 ) << 8) |\
|
||||
(((x) & 0x00ff0000 ) >> 8) |\
|
||||
(((x) & 0xff000000 ) >> 24))
|
||||
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
#define ENDIAN_SWAP(x) (SWAP32(x))
|
||||
#else
|
||||
#define ENDIAN_SWAP(x) (x)
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct _MsChunk
|
||||
{
|
||||
struct _MsChunk *next;
|
||||
DATA32 chunk_id;
|
||||
DATA32 chunk_size; /* Size of this chunk, starting from */
|
||||
char data; /* the following byte. Thus chunk_size = full size - 8 */
|
||||
} MsChunk;
|
||||
|
||||
typedef struct _MsAni
|
||||
{
|
||||
char *filename;
|
||||
FILE *fp;
|
||||
DATA32 cp;
|
||||
|
||||
DATA32 riff_id; /* "RIFF" */
|
||||
DATA32 data_size;
|
||||
DATA32 chunk_id; /* "ACON" */
|
||||
|
||||
MsChunk *chunks;
|
||||
} MsAni;
|
||||
|
||||
static void ani_cleanup (MsAni *ani);
|
||||
|
||||
char load(ImlibImage *im, ImlibProgressFunction progress,char progress_granularity, char immediate_load);
|
||||
char save(ImlibImage *im, ImlibProgressFunction progress, char progress_granularity);
|
||||
void formats(ImlibLoader *l);
|
||||
|
||||
|
||||
static int
|
||||
ani_read_int8 (FILE *fp,
|
||||
DATA8 *data,
|
||||
int count)
|
||||
{
|
||||
int total;
|
||||
int bytes;
|
||||
|
||||
total = count;
|
||||
while (count > 0)
|
||||
{
|
||||
bytes = fread ((char*) data, sizeof (char), count, fp);
|
||||
if (bytes <= 0) /* something bad happened */
|
||||
break;
|
||||
count -= bytes;
|
||||
data += bytes;
|
||||
}
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ani_read_int32 (FILE *fp,
|
||||
DATA32 *data,
|
||||
int count)
|
||||
{
|
||||
int i, total;
|
||||
|
||||
total = count;
|
||||
if (count > 0)
|
||||
{
|
||||
ani_read_int8 (fp, (DATA8*) data, count * 4);
|
||||
for (i = 0; i < count; i++)
|
||||
data[i] = ENDIAN_SWAP(data[i]);
|
||||
}
|
||||
|
||||
return total * 4;
|
||||
}
|
||||
|
||||
|
||||
static MsAni *
|
||||
ani_init (char *filename)
|
||||
{
|
||||
MsAni *ani;
|
||||
|
||||
if (! (ani = (MsAni*) calloc(1, sizeof(MsAni))))
|
||||
return NULL;
|
||||
|
||||
if (! (ani->fp = fopen (filename, "r")))
|
||||
return NULL;
|
||||
|
||||
ani->filename = filename;
|
||||
ani->cp += ani_read_int32(ani->fp, &ani->riff_id, 1);
|
||||
ani->cp += ani_read_int32(ani->fp, &ani->data_size, 1);
|
||||
ani->cp += ani_read_int32(ani->fp, &ani->chunk_id, 1);
|
||||
|
||||
if (ani->riff_id != 0x46464952 || ani->chunk_id != 0x4E4F4341)
|
||||
{
|
||||
ani_cleanup(ani);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return ani;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ani_cleanup (MsAni *ani)
|
||||
{
|
||||
MsChunk *c, *c_next;
|
||||
|
||||
D("Failed to allocate ANI image. Cleaning up\n");
|
||||
|
||||
if (!ani)
|
||||
return;
|
||||
|
||||
if (ani->fp)
|
||||
fclose(ani->fp);
|
||||
|
||||
for (c = ani->chunks; c; )
|
||||
{
|
||||
c_next = c->next;
|
||||
free(c);
|
||||
c = c_next;
|
||||
}
|
||||
|
||||
free (ani);
|
||||
}
|
||||
|
||||
|
||||
static MsChunk*
|
||||
ani_load_chunk(MsAni *ani)
|
||||
{
|
||||
DATA32 chunk_id, chunk_size, dummy;
|
||||
MsChunk *chunk;
|
||||
|
||||
if (ani->cp >= ani->data_size + 8)
|
||||
return NULL;
|
||||
|
||||
ani->cp += ani_read_int32(ani->fp, &chunk_id, 1);
|
||||
|
||||
while (chunk_id == 0x5453494C)
|
||||
{
|
||||
D("Skipping LIST chunk header ...\n");
|
||||
ani->cp += ani_read_int32(ani->fp, &dummy, 1);
|
||||
ani->cp += ani_read_int32(ani->fp, &dummy, 1);
|
||||
ani->cp += ani_read_int32(ani->fp, &chunk_id, 1);
|
||||
}
|
||||
|
||||
ani->cp += ani_read_int32(ani->fp, &chunk_size, 1);
|
||||
|
||||
/* Pad it up to word length */
|
||||
if (chunk_size % 2)
|
||||
chunk_size += (2 - (chunk_size % 2));
|
||||
|
||||
chunk = (MsChunk*) calloc(1, sizeof(MsChunk*) + 2 * sizeof(DATA32) + chunk_size);
|
||||
|
||||
if (!chunk)
|
||||
{
|
||||
D("Warning, failed to allocate ANI chunk of size %d\n", sizeof(MsChunk*)
|
||||
+ 2 * sizeof(DATA32) + chunk_size);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
chunk->chunk_id = chunk_id;
|
||||
chunk->chunk_size = chunk_size;
|
||||
|
||||
chunk_id = ENDIAN_SWAP(chunk_id);
|
||||
|
||||
D("Loaded chunk with ID '%c%c%c%c' and length %i\n",
|
||||
((char*)&chunk_id)[0], ((char*)&chunk_id)[1],
|
||||
((char*)&chunk_id)[2], ((char*)&chunk_id)[3], chunk_size);
|
||||
|
||||
ani->cp += ani_read_int8(ani->fp, &chunk->data, chunk_size);
|
||||
|
||||
return chunk;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ani_load (MsAni *ani)
|
||||
{
|
||||
MsChunk *last_chunk;
|
||||
MsChunk *chunk;
|
||||
|
||||
if (!ani)
|
||||
return;
|
||||
|
||||
ani->chunks = ani_load_chunk(ani);
|
||||
last_chunk = ani->chunks;
|
||||
if (!last_chunk)
|
||||
return;
|
||||
|
||||
while ( (chunk = ani_load_chunk(ani)) != NULL)
|
||||
{
|
||||
last_chunk->next = chunk;
|
||||
last_chunk = chunk;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static char *
|
||||
ani_save_ico (MsChunk *chunk)
|
||||
{
|
||||
char *temp;
|
||||
FILE *f;
|
||||
|
||||
if ( (temp = tempnam(NULL, "ico_")) == NULL)
|
||||
return NULL;
|
||||
|
||||
if ( (f = fopen(temp, "w+")) == NULL)
|
||||
{
|
||||
free(temp);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fwrite(&chunk->data, chunk->chunk_size, 1, f);
|
||||
fclose(f);
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
|
||||
char
|
||||
load(ImlibImage *im, ImlibProgressFunction progress, char progress_granularity, char immediate_load)
|
||||
{
|
||||
MsAni *ani = NULL;
|
||||
MsChunk *chunk;
|
||||
|
||||
/* if immediate_load is 1, then dont delay image laoding as below, or */
|
||||
/* already data in this image - dont load it again */
|
||||
if (im->data)
|
||||
return 0;
|
||||
|
||||
/* set the format string member to the lower-case full extension */
|
||||
/* name for the format - so example names would be: */
|
||||
/* "png", "jpeg", "tiff", "ppm", "pgm", "pbm", "gif", "xpm" ... */
|
||||
|
||||
if (!im->format)
|
||||
im->format = strdup("ani");
|
||||
|
||||
if (im->loader || immediate_load || progress)
|
||||
{
|
||||
if (! (ani = ani_init((im->real_file))))
|
||||
return 0;
|
||||
|
||||
ani_load (ani);
|
||||
|
||||
for (chunk = ani->chunks; chunk; chunk = chunk->next)
|
||||
{
|
||||
if (chunk->chunk_id == 0x6E6F6369)
|
||||
{
|
||||
ImlibLoadError err;
|
||||
ImlibImage *temp_im;
|
||||
char *filename;
|
||||
|
||||
if ( (filename = ani_save_ico(chunk)) == NULL)
|
||||
return 0;
|
||||
|
||||
temp_im = __imlib_LoadImage(filename, progress, progress_granularity,
|
||||
immediate_load, 0, &err);
|
||||
|
||||
im->w = temp_im->w;
|
||||
im->h = temp_im->h;
|
||||
SET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
|
||||
if (! (im->data = (DATA32 *) malloc(sizeof(DATA32) * im->w * im->h)))
|
||||
{
|
||||
free(filename);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memcpy(im->data, temp_im->data, sizeof(DATA32) * im->w * im->h);
|
||||
unlink(filename);
|
||||
free(filename);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ani_cleanup (ani);
|
||||
}
|
||||
|
||||
if (progress)
|
||||
{
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
||||
progress_granularity = 0;
|
||||
}
|
||||
|
||||
/* fills the ImlibLoader struct with a strign array of format file */
|
||||
/* extensions this loader can load. eg: */
|
||||
/* loader->formats = { "jpeg", "jpg"}; */
|
||||
/* giving permutations is a good idea. case sensitivity is irrelevant */
|
||||
/* your laoder CAN load more than one format if it likes - like: */
|
||||
/* loader->formats = { "gif", "png", "jpeg", "jpg"} */
|
||||
/* if it can load those formats. */
|
||||
void
|
||||
formats (ImlibLoader *l)
|
||||
{
|
||||
/* this is the only bit you have to change... */
|
||||
char *list_formats[] =
|
||||
{ "ani" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof (char *));
|
||||
l->formats = malloc(sizeof(char *) * l->num_formats);
|
||||
for (i = 0; i < l->num_formats; i++)
|
||||
l->formats[i] = strdup(list_formats[i]);
|
||||
}
|
||||
}
|
||||
|
407
src/loader_db.c
407
src/loader_db.c
|
@ -1,407 +0,0 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "common.h"
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include "image.h"
|
||||
|
||||
char load (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load);
|
||||
char save (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity);
|
||||
void formats (ImlibLoader *l);
|
||||
|
||||
#define SWAP32(x) (x) = \
|
||||
((((x) & 0x000000ff ) << 24) |\
|
||||
(((x) & 0x0000ff00 ) << 8) |\
|
||||
(((x) & 0x00ff0000 ) >> 8) |\
|
||||
(((x) & 0xff000000 ) >> 24))
|
||||
#include <Edb.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <zlib.h>
|
||||
|
||||
static int
|
||||
permissions(char *file)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(file, &st) < 0)
|
||||
return 0;
|
||||
return st.st_mode;
|
||||
}
|
||||
|
||||
static int
|
||||
exists(char *file)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(file, &st) < 0)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
can_read(char *file)
|
||||
{
|
||||
#ifndef __EMX__
|
||||
if (!(permissions(file) & (S_IRUSR | S_IRGRP | S_IROTH)))
|
||||
#else
|
||||
if (!(permissions(file)))
|
||||
#endif
|
||||
return 0;
|
||||
return (1 + access(file, R_OK));
|
||||
}
|
||||
|
||||
static int
|
||||
can_write(char *file)
|
||||
{
|
||||
#ifndef __EMX__
|
||||
if (!(permissions(file) & (S_IWUSR | S_IWGRP | S_IWOTH)))
|
||||
#else
|
||||
if (!(permissions(file)))
|
||||
#endif
|
||||
return 0;
|
||||
return (1 + access(file, W_OK));
|
||||
}
|
||||
|
||||
char
|
||||
load (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load)
|
||||
{
|
||||
int w, h, alpha, compression, size;
|
||||
E_DB_File *db;
|
||||
char file[4096], key[4096];
|
||||
DATA32 *ret;
|
||||
DATA32 *body;
|
||||
if (im->data)
|
||||
return 0;
|
||||
if ((!im->file) || (!im->real_file) || (!im->key))
|
||||
return 0;
|
||||
strcpy(file, im->real_file);
|
||||
strcpy(key, im->key);
|
||||
if (!can_read(file)) return 0;
|
||||
db = e_db_open_read(file);
|
||||
if (!db)
|
||||
return 0;
|
||||
ret = e_db_data_get(db, key, &size);
|
||||
if (!ret)
|
||||
{
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
/* header */
|
||||
{
|
||||
DATA32 header[8];
|
||||
|
||||
if (size < 32)
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
memcpy(header, ret, 32);
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 8; i++)
|
||||
SWAP32(header[i]);
|
||||
}
|
||||
#endif
|
||||
if (header[0] != 0xac1dfeed)
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
w = header[1];
|
||||
h = header[2];
|
||||
alpha = header[3];
|
||||
compression = header[4];
|
||||
if ((w > 8192) || (h > 8192))
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
if ((compression == 0) && (size < ((w * h * 4) + 32)))
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
im->w = w;
|
||||
im->h = h;
|
||||
if (!im->format)
|
||||
{
|
||||
if (alpha)
|
||||
SET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
else
|
||||
UNSET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
im->format = strdup("db");
|
||||
}
|
||||
}
|
||||
if (((!im->data) && (im->loader)) || (immediate_load) || (progress))
|
||||
{
|
||||
DATA32 *ptr;
|
||||
int y, pl = 0;
|
||||
char pper = 0;
|
||||
|
||||
body = &(ret[8]);
|
||||
/* must set the im->data member before callign progress function */
|
||||
if (!compression)
|
||||
{
|
||||
if (progress)
|
||||
{
|
||||
char per;
|
||||
int l;
|
||||
|
||||
ptr = im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
for (y = 0; y < h; y++)
|
||||
{
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32));
|
||||
for (x = 0; x < im->w; x++)
|
||||
SWAP32(ptr[x]);
|
||||
}
|
||||
#else
|
||||
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32));
|
||||
#endif
|
||||
ptr += im->w;
|
||||
|
||||
per = (char)((100 * y) / im->h);
|
||||
if (((per - pper) >= progress_granularity) ||
|
||||
(y == (im->h - 1)))
|
||||
{
|
||||
l = y - pl;
|
||||
if(!progress(im, per, 0, (y - l), im->w, l))
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 2;
|
||||
}
|
||||
pper = per;
|
||||
pl = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr = im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
memcpy(ptr, body, im->w * im->h * sizeof(DATA32));
|
||||
for (x = 0; x < (im->w * im->h); x++)
|
||||
SWAP32(ptr[x]);
|
||||
}
|
||||
#else
|
||||
memcpy(ptr, body, im->w * im->h * sizeof(DATA32));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
uLongf dlen;
|
||||
|
||||
dlen = w * h * sizeof(DATA32);
|
||||
im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 0;
|
||||
}
|
||||
uncompress((Bytef *)im->data, &dlen, (Bytef *)body, (uLongf)(size - 32));
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
for (x = 0; x < (im->w * im->h); x++)
|
||||
SWAP32(im->data[x]);
|
||||
}
|
||||
#endif
|
||||
if (progress)
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
}
|
||||
}
|
||||
free(ret);
|
||||
e_db_close(db);
|
||||
return 1;
|
||||
}
|
||||
|
||||
char
|
||||
save (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity)
|
||||
{
|
||||
int alpha = 0;
|
||||
char file[4096], key[4096], *tmp;
|
||||
DATA32 *header;
|
||||
DATA32 *buf;
|
||||
E_DB_File *db;
|
||||
int compression = 0, size = 0;
|
||||
DATA32 *ret;
|
||||
|
||||
|
||||
/* no image data? abort */
|
||||
if (!im->data)
|
||||
return 0;
|
||||
if (im->flags & F_HAS_ALPHA)
|
||||
alpha = 1;
|
||||
if ((!im->file) || (!im->real_file))
|
||||
return 0;
|
||||
strcpy(file, im->real_file);
|
||||
|
||||
tmp = strrchr(file, ':');
|
||||
if(!tmp)
|
||||
return 0;
|
||||
*tmp++ = '\0';
|
||||
if(!*tmp)
|
||||
return 0;
|
||||
strcpy(key, tmp);
|
||||
|
||||
if (exists(file))
|
||||
{
|
||||
if (!can_write(file)) return 0;
|
||||
if (!can_read(file)) return 0;
|
||||
}
|
||||
db = e_db_open(file);
|
||||
if (!db)
|
||||
return 0;
|
||||
|
||||
/* account for space for compression */
|
||||
buf = (DATA32 *) malloc((((im->w * im->h * 101) / 100) + 3 + 8) * sizeof(DATA32));
|
||||
header = buf;
|
||||
header[0] = 0xac1dfeed;
|
||||
header[1] = im->w;
|
||||
header[2] = im->h;
|
||||
header[3] = alpha;
|
||||
{
|
||||
ImlibImageTag *tag;
|
||||
|
||||
tag = __imlib_GetTag(im, "compression");
|
||||
if (!tag)
|
||||
header[4] = 0;
|
||||
else
|
||||
{
|
||||
compression = tag->val;
|
||||
if (compression < 0)
|
||||
compression = 0;
|
||||
else if (compression > 9)
|
||||
compression = 9;
|
||||
header[4] = compression;
|
||||
}
|
||||
}
|
||||
if (compression > 0)
|
||||
{
|
||||
DATA32 *compressed;
|
||||
int retr;
|
||||
uLongf buflen;
|
||||
|
||||
compressed = &(buf[8]);
|
||||
buflen = ((im->w * im->h * sizeof(DATA32) * 101) / 100) + 12;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int i;
|
||||
DATA32 *buf2;
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
SWAP32(header[i]);
|
||||
|
||||
buf2 = malloc((((im->w * im->h * 101) / 100) + 3) * sizeof(DATA32));
|
||||
if (buf2)
|
||||
{
|
||||
int y;
|
||||
|
||||
memcpy(buf2, im->data, im->w * im->h * sizeof(DATA32));
|
||||
for (y = 0; y < (im->w * im->h) + 8; y++)
|
||||
SWAP32(buf2[y]);
|
||||
retr = compress2((Bytef *)compressed, &buflen,
|
||||
(Bytef *)buf2,
|
||||
(uLong)(im->w * im->h * sizeof(DATA32)),
|
||||
compression);
|
||||
free(buf2);
|
||||
}
|
||||
else
|
||||
retr = Z_MEM_ERROR;
|
||||
}
|
||||
#else
|
||||
retr = compress2((Bytef *)compressed, &buflen,
|
||||
(Bytef *)im->data,
|
||||
(uLong)(im->w * im->h * sizeof(DATA32)),
|
||||
compression);
|
||||
#endif
|
||||
if (retr != Z_OK)
|
||||
compressed = 0;
|
||||
else
|
||||
{
|
||||
if (buflen >= (im->w * im->h * sizeof(DATA32)))
|
||||
compressed = 0;
|
||||
else
|
||||
size = (8 * sizeof(DATA32)) + buflen;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&(buf[8]), im->data, im->w * im->h * sizeof(DATA32));
|
||||
header[4] = compression;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int y;
|
||||
|
||||
for (y = 0; y < (im->w * im->h) + 8; y++)
|
||||
SWAP32(buf[y]);
|
||||
}
|
||||
#endif
|
||||
size = ((im->w * im->h) + 8) * sizeof(DATA32);
|
||||
}
|
||||
ret = buf;
|
||||
e_db_data_set(db, key, ret, size);
|
||||
free(buf);
|
||||
if (progress)
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
/* finish off */
|
||||
e_db_close(db);
|
||||
return 1;
|
||||
progress_granularity = 0;
|
||||
}
|
||||
|
||||
void
|
||||
formats (ImlibLoader *l)
|
||||
{
|
||||
char *list_formats[] =
|
||||
{ "db" };
|
||||
|
||||
{
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof (char *));
|
||||
l->formats = malloc(sizeof(char *) * l->num_formats);
|
||||
for (i = 0; i < l->num_formats; i++)
|
||||
l->formats[i] = strdup(list_formats[i]);
|
||||
}
|
||||
}
|
||||
|
408
src/loader_eet.c
408
src/loader_eet.c
|
@ -1,408 +0,0 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "common.h"
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include "image.h"
|
||||
|
||||
char load (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load);
|
||||
char save (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity);
|
||||
void formats (ImlibLoader *l);
|
||||
|
||||
#define SWAP32(x) (x) = \
|
||||
((((x) & 0x000000ff ) << 24) |\
|
||||
(((x) & 0x0000ff00 ) << 8) |\
|
||||
(((x) & 0x00ff0000 ) >> 8) |\
|
||||
(((x) & 0xff000000 ) >> 24))
|
||||
#include <Eet.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <zlib.h>
|
||||
|
||||
static int
|
||||
permissions(char *file)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(file, &st) < 0)
|
||||
return 0;
|
||||
return st.st_mode;
|
||||
}
|
||||
|
||||
static int
|
||||
exists(char *file)
|
||||
{
|
||||
struct stat st;
|
||||
|
||||
if (stat(file, &st) < 0)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
can_read(char *file)
|
||||
{
|
||||
#ifndef __EMX__
|
||||
if (!(permissions(file) & (S_IRUSR | S_IRGRP | S_IROTH)))
|
||||
#else
|
||||
if (!(permissions(file)))
|
||||
#endif
|
||||
return 0;
|
||||
return (1 + access(file, R_OK));
|
||||
}
|
||||
|
||||
static int
|
||||
can_write(char *file)
|
||||
{
|
||||
#ifndef __EMX__
|
||||
if (!(permissions(file) & (S_IWUSR | S_IWGRP | S_IWOTH)))
|
||||
#else
|
||||
if (!(permissions(file)))
|
||||
#endif
|
||||
return 0;
|
||||
return (1 + access(file, W_OK));
|
||||
}
|
||||
|
||||
char
|
||||
load (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity, char immediate_load)
|
||||
{
|
||||
int w, h, alpha, compression, size;
|
||||
Eet_File *ef;
|
||||
char file[4096], key[4096];
|
||||
DATA32 *ret;
|
||||
DATA32 *body;
|
||||
|
||||
if (im->data)
|
||||
return 0;
|
||||
if ((!im->file) || (!im->real_file) || (!im->key))
|
||||
return 0;
|
||||
strcpy(file, im->real_file);
|
||||
strcpy(key, im->key);
|
||||
if (!can_read(file)) return 0;
|
||||
ef = eet_open(file, EET_FILE_MODE_READ);
|
||||
if (!ef)
|
||||
return 0;
|
||||
ret = eet_read(ef, key, &size);
|
||||
if (!ret)
|
||||
{
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
/* header */
|
||||
{
|
||||
DATA32 header[8];
|
||||
|
||||
if (size < 32)
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
memcpy(header, ret, 32);
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 8; i++)
|
||||
SWAP32(header[i]);
|
||||
}
|
||||
#endif
|
||||
if (header[0] != 0xac1dfeed)
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
w = header[1];
|
||||
h = header[2];
|
||||
alpha = header[3];
|
||||
compression = header[4];
|
||||
if ((w > 8192) || (h > 8192))
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
if ((compression == 0) && (size < ((w * h * 4) + 32)))
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
im->w = w;
|
||||
im->h = h;
|
||||
if (!im->format)
|
||||
{
|
||||
if (alpha)
|
||||
SET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
else
|
||||
UNSET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
im->format = strdup("eet");
|
||||
}
|
||||
}
|
||||
if (((!im->data) && (im->loader)) || (immediate_load) || (progress))
|
||||
{
|
||||
DATA32 *ptr;
|
||||
int y, pl = 0;
|
||||
char pper = 0;
|
||||
|
||||
body = &(ret[8]);
|
||||
/* must set the im->data member before callign progress function */
|
||||
if (!compression)
|
||||
{
|
||||
if (progress)
|
||||
{
|
||||
char per;
|
||||
int l;
|
||||
|
||||
ptr = im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
for (y = 0; y < h; y++)
|
||||
{
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32));
|
||||
for (x = 0; x < im->w; x++)
|
||||
SWAP32(ptr[x]);
|
||||
}
|
||||
#else
|
||||
memcpy(ptr, &(body[y * w]), im->w * sizeof(DATA32));
|
||||
#endif
|
||||
ptr += im->w;
|
||||
|
||||
per = (char)((100 * y) / im->h);
|
||||
if (((per - pper) >= progress_granularity) ||
|
||||
(y == (im->h - 1)))
|
||||
{
|
||||
l = y - pl;
|
||||
if(!progress(im, per, 0, (y - l), im->w, l))
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 2;
|
||||
}
|
||||
pper = per;
|
||||
pl = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr = im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
memcpy(ptr, body, im->w * im->h * sizeof(DATA32));
|
||||
for (x = 0; x < (im->w * im->h); x++)
|
||||
SWAP32(ptr[x]);
|
||||
}
|
||||
#else
|
||||
memcpy(ptr, body, im->w * im->h * sizeof(DATA32));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
uLongf dlen;
|
||||
|
||||
dlen = w * h * sizeof(DATA32);
|
||||
im->data = malloc(w * h * sizeof(DATA32));
|
||||
if (!im->data)
|
||||
{
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 0;
|
||||
}
|
||||
uncompress((Bytef *)im->data, &dlen, (Bytef *)body, (uLongf)(size - 32));
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int x;
|
||||
|
||||
for (x = 0; x < (im->w * im->h); x++)
|
||||
SWAP32(im->data[x]);
|
||||
}
|
||||
#endif
|
||||
if (progress)
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
}
|
||||
}
|
||||
free(ret);
|
||||
eet_close(ef);
|
||||
return 1;
|
||||
}
|
||||
|
||||
char
|
||||
save (ImlibImage *im, ImlibProgressFunction progress,
|
||||
char progress_granularity)
|
||||
{
|
||||
int alpha = 0;
|
||||
char file[4096], key[4096], *tmp;
|
||||
DATA32 *header;
|
||||
DATA32 *buf;
|
||||
Eet_File *ef;
|
||||
int compression = 0, size = 0;
|
||||
DATA32 *ret;
|
||||
|
||||
|
||||
/* no image data? abort */
|
||||
if (!im->data)
|
||||
return 0;
|
||||
if (im->flags & F_HAS_ALPHA)
|
||||
alpha = 1;
|
||||
if ((!im->file) || (!im->real_file))
|
||||
return 0;
|
||||
strcpy(file, im->real_file);
|
||||
|
||||
tmp = strrchr(file, ':');
|
||||
if(!tmp)
|
||||
return 0;
|
||||
*tmp++ = '\0';
|
||||
if(!*tmp)
|
||||
return 0;
|
||||
strcpy(key, tmp);
|
||||
|
||||
if (exists(file))
|
||||
{
|
||||
if (!can_write(file)) return 0;
|
||||
if (!can_read(file)) return 0;
|
||||
}
|
||||
ef = eet_open(file, EET_FILE_MODE_WRITE);
|
||||
if (!ef)
|
||||
return 0;
|
||||
|
||||
/* account for space for compression */
|
||||
buf = (DATA32 *) malloc((((im->w * im->h * 101) / 100) + 3 + 8) * sizeof(DATA32));
|
||||
header = buf;
|
||||
header[0] = 0xac1dfeed;
|
||||
header[1] = im->w;
|
||||
header[2] = im->h;
|
||||
header[3] = alpha;
|
||||
{
|
||||
ImlibImageTag *tag;
|
||||
|
||||
tag = __imlib_GetTag(im, "compression");
|
||||
if (!tag)
|
||||
header[4] = 0;
|
||||
else
|
||||
{
|
||||
compression = tag->val;
|
||||
if (compression < 0)
|
||||
compression = 0;
|
||||
else if (compression > 9)
|
||||
compression = 9;
|
||||
header[4] = compression;
|
||||
}
|
||||
}
|
||||
if (compression > 0)
|
||||
{
|
||||
DATA32 *compressed;
|
||||
int retr;
|
||||
uLongf buflen;
|
||||
|
||||
compressed = &(buf[8]);
|
||||
buflen = ((im->w * im->h * sizeof(DATA32) * 101) / 100) + 12;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int i;
|
||||
DATA32 *buf2;
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
SWAP32(header[i]);
|
||||
|
||||
buf2 = malloc((((im->w * im->h * 101) / 100) + 3) * sizeof(DATA32));
|
||||
if (buf2)
|
||||
{
|
||||
int y;
|
||||
|
||||
memcpy(buf2, im->data, im->w * im->h * sizeof(DATA32));
|
||||
for (y = 0; y < (im->w * im->h) + 8; y++)
|
||||
SWAP32(buf2[y]);
|
||||
retr = compress2((Bytef *)compressed, &buflen,
|
||||
(Bytef *)buf2,
|
||||
(uLong)(im->w * im->h * sizeof(DATA32)),
|
||||
compression);
|
||||
free(buf2);
|
||||
}
|
||||
else
|
||||
retr = Z_MEM_ERROR;
|
||||
}
|
||||
#else
|
||||
retr = compress2((Bytef *)compressed, &buflen,
|
||||
(Bytef *)im->data,
|
||||
(uLong)(im->w * im->h * sizeof(DATA32)),
|
||||
compression);
|
||||
#endif
|
||||
if (retr != Z_OK)
|
||||
compressed = 0;
|
||||
else
|
||||
{
|
||||
if (buflen >= (im->w * im->h * sizeof(DATA32)))
|
||||
compressed = 0;
|
||||
else
|
||||
size = (8 * sizeof(DATA32)) + buflen;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&(buf[8]), im->data, im->w * im->h * sizeof(DATA32));
|
||||
header[4] = compression;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
{
|
||||
int y;
|
||||
|
||||
for (y = 0; y < (im->w * im->h) + 8; y++)
|
||||
SWAP32(buf[y]);
|
||||
}
|
||||
#endif
|
||||
size = ((im->w * im->h) + 8) * sizeof(DATA32);
|
||||
}
|
||||
ret = buf;
|
||||
eet_write(ef, key, ret, size, 0);
|
||||
free(buf);
|
||||
if (progress)
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
/* finish off */
|
||||
eet_close(ef);
|
||||
return 1;
|
||||
progress_granularity = 0;
|
||||
}
|
||||
|
||||
void
|
||||
formats (ImlibLoader *l)
|
||||
{
|
||||
char *list_formats[] =
|
||||
{ "eet" };
|
||||
|
||||
{
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof (char *));
|
||||
l->formats = malloc(sizeof(char *) * l->num_formats);
|
||||
for (i = 0; i < l->num_formats; i++)
|
||||
l->formats[i] = strdup(list_formats[i]);
|
||||
}
|
||||
}
|
||||
|
622
src/loader_ico.c
622
src/loader_ico.c
|
@ -1,622 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright (C) 20002 Christian Kreibich <cK@whoop.org>.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to
|
||||
deal in the Software without restriction, including without limitation the
|
||||
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
sell copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies of the Software and its documentation and acknowledgment shall be
|
||||
given in the documentation and software packages that this Software was
|
||||
used.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "common.h"
|
||||
#include <string.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include "image.h"
|
||||
#include "color_values.h"
|
||||
|
||||
/* #define ICO_DBG */
|
||||
|
||||
#ifdef ICO_DBG
|
||||
#define D(fmt, args...) \
|
||||
{ \
|
||||
printf("Imlib2 ICO loader: "); \
|
||||
printf(fmt, ## args); \
|
||||
}
|
||||
#else
|
||||
#define D(fmt, args...)
|
||||
#endif
|
||||
|
||||
#define SWAP32(x) \
|
||||
((((x) & 0x000000ff ) << 24) |\
|
||||
(((x) & 0x0000ff00 ) << 8) |\
|
||||
(((x) & 0x00ff0000 ) >> 8) |\
|
||||
(((x) & 0xff000000 ) >> 24))
|
||||
|
||||
#define SWAP16(x) \
|
||||
((((x) & 0x00ff ) << 8) |\
|
||||
(((x) & 0xff00 ) >> 8))
|
||||
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
#define ENDIAN_SWAP(x) (SWAP32(x))
|
||||
#define ENDIAN_SWAP16(x) (SWAP16(x))
|
||||
#else
|
||||
#define ENDIAN_SWAP(x) (x)
|
||||
#define ENDIAN_SWAP16(x) (x)
|
||||
#endif
|
||||
|
||||
typedef struct _MsIconEntry
|
||||
{
|
||||
DATA8 width; /* Width of icon in pixels */
|
||||
DATA8 height; /* Height of icon in pixels */
|
||||
DATA8 num_colors; /* Maximum number of colors */
|
||||
DATA8 reserved; /* Not used */
|
||||
DATA16 num_planes; /* Not used */
|
||||
DATA16 bpp;
|
||||
DATA32 size; /* Length of icon bitmap in bytes */
|
||||
DATA32 offset; /* Offset position of icon bitmap in file */
|
||||
} MsIconEntry;
|
||||
|
||||
typedef struct _MsIconData
|
||||
{
|
||||
/* Bitmap header data */
|
||||
DATA32 header_size; /* = 40 Bytes */
|
||||
DATA32 width;
|
||||
DATA32 height;
|
||||
DATA16 planes;
|
||||
DATA16 bpp;
|
||||
DATA32 compression; /* not used for icons */
|
||||
DATA32 image_size; /* size of image */
|
||||
DATA32 x_res;
|
||||
DATA32 y_res;
|
||||
DATA32 used_clrs;
|
||||
DATA32 important_clrs;
|
||||
|
||||
DATA32 *palette; /* Color palette, only if bpp <= 8. */
|
||||
DATA8 *xor_map; /* Icon bitmap */
|
||||
DATA8 *and_map; /* Display bit mask */
|
||||
} MsIconData;
|
||||
|
||||
typedef struct _MsIcon
|
||||
{
|
||||
FILE *fp;
|
||||
int cp;
|
||||
char *filename;
|
||||
|
||||
DATA16 reserved;
|
||||
DATA16 resource_type;
|
||||
DATA16 icon_count;
|
||||
MsIconEntry *icon_dir;
|
||||
MsIconData *icon_data;
|
||||
} MsIcon;
|
||||
|
||||
static int ico_read_int8 (FILE *fp, DATA8 *data, int count);
|
||||
static int ico_read_int16 (FILE *fp, DATA16 *data, int count);
|
||||
static int ico_read_int32 (FILE *fp, DATA32 *data, int count);
|
||||
static MsIcon *ico_init (char *filename);
|
||||
static void ico_cleanup (MsIcon *ico);
|
||||
static void ico_read_entry(MsIcon *ico, MsIconEntry* entry);
|
||||
static void ico_read_data(MsIcon *ico, int icon_num);
|
||||
static void ico_load (MsIcon *ico);
|
||||
static int ico_to_imlib (MsIcon *ico, ImlibImage *im);
|
||||
|
||||
char load(ImlibImage *im, ImlibProgressFunction progress,char progress_granularity, char immediate_load);
|
||||
char save(ImlibImage *im, ImlibProgressFunction progress, char progress_granularity);
|
||||
void formats(ImlibLoader *l);
|
||||
|
||||
|
||||
static int
|
||||
ico_read_int32 (FILE *fp,
|
||||
DATA32 *data,
|
||||
int count)
|
||||
{
|
||||
int i, total;
|
||||
|
||||
total = count;
|
||||
if (count > 0)
|
||||
{
|
||||
ico_read_int8 (fp, (DATA8*) data, count * 4);
|
||||
for (i = 0; i < count; i++)
|
||||
data[i] = ENDIAN_SWAP(data[i]);
|
||||
}
|
||||
|
||||
return total * 4;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ico_read_int16 (FILE *fp,
|
||||
DATA16 *data,
|
||||
int count)
|
||||
{
|
||||
int i, total;
|
||||
|
||||
total = count;
|
||||
if (count > 0)
|
||||
{
|
||||
ico_read_int8 (fp, (DATA8*) data, count * 2);
|
||||
for (i = 0; i < count; i++)
|
||||
data[i] = ENDIAN_SWAP16(data[i]);
|
||||
}
|
||||
|
||||
return total * 2;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ico_read_int8 (FILE *fp,
|
||||
DATA8 *data,
|
||||
int count)
|
||||
{
|
||||
int total;
|
||||
int bytes;
|
||||
|
||||
total = count;
|
||||
while (count > 0)
|
||||
{
|
||||
bytes = fread ((char*) data, sizeof (char), count, fp);
|
||||
if (bytes <= 0) /* something bad happened */
|
||||
break;
|
||||
count -= bytes;
|
||||
data += bytes;
|
||||
}
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
|
||||
static MsIcon *
|
||||
ico_init (char *filename)
|
||||
{
|
||||
MsIcon *ico;
|
||||
|
||||
if (! (ico = (MsIcon*) calloc(1, sizeof(MsIcon))))
|
||||
return NULL;
|
||||
|
||||
if (! (ico->fp = fopen (filename, "r")))
|
||||
return NULL;
|
||||
|
||||
ico->filename = filename;
|
||||
ico->cp += ico_read_int16(ico->fp, &ico->reserved, 1);
|
||||
ico->cp += ico_read_int16(ico->fp, &ico->resource_type, 1);
|
||||
|
||||
/* Icon files use 1 as resource type, that's what I wrote this for.
|
||||
From descriptions on the web it seems as if this loader should
|
||||
also be able to handle Win 3.11 - Win 95 cursor files (.cur),
|
||||
which use resource type 2. I haven't tested this though. */
|
||||
if (ico->reserved != 0 ||
|
||||
(ico->resource_type != 1 && ico->resource_type != 2))
|
||||
{
|
||||
ico_cleanup(ico);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return ico;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ico_cleanup (MsIcon *ico)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!ico)
|
||||
return;
|
||||
|
||||
if (ico->fp)
|
||||
fclose(ico->fp);
|
||||
|
||||
if (ico->icon_dir)
|
||||
free (ico->icon_dir);
|
||||
|
||||
if (ico->icon_data)
|
||||
{
|
||||
for (i = 0; i < ico->icon_count; i++)
|
||||
{
|
||||
/* There's not always a palette .. */
|
||||
if (ico->icon_data[i].palette)
|
||||
free (ico->icon_data[i].palette);
|
||||
free (ico->icon_data[i].xor_map);
|
||||
free (ico->icon_data[i].and_map);
|
||||
}
|
||||
free (ico->icon_data);
|
||||
}
|
||||
|
||||
free (ico);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ico_read_entry(MsIcon *ico, MsIconEntry* entry)
|
||||
{
|
||||
if (!ico || !entry)
|
||||
return;
|
||||
|
||||
ico->cp += ico_read_int8(ico->fp, &entry->width, 1);
|
||||
ico->cp += ico_read_int8(ico->fp, &entry->height, 1);
|
||||
ico->cp += ico_read_int8(ico->fp, &entry->num_colors, 1);
|
||||
ico->cp += ico_read_int8(ico->fp, &entry->reserved, 1);
|
||||
|
||||
ico->cp += ico_read_int16(ico->fp, &entry->num_planes, 1);
|
||||
ico->cp += ico_read_int16(ico->fp, &entry->bpp, 1);
|
||||
|
||||
ico->cp += ico_read_int32(ico->fp, &entry->size, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &entry->offset, 1);
|
||||
|
||||
D("Read entry with w: %i, h: %i, num_colors: %i, bpp: %i\n",
|
||||
entry->width, entry->height, entry->num_colors, entry->bpp);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ico_read_data(MsIcon *ico, int icon_num)
|
||||
{
|
||||
MsIconData *data;
|
||||
MsIconEntry *entry;
|
||||
int xor_len = 0, and_len = 0;
|
||||
|
||||
if (!ico)
|
||||
return;
|
||||
|
||||
entry = &ico->icon_dir[icon_num];
|
||||
data = &ico->icon_data[icon_num];
|
||||
|
||||
ico->cp += ico_read_int32(ico->fp, &data->header_size, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->width, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->height, 1);
|
||||
|
||||
ico->cp += ico_read_int16(ico->fp, &data->planes, 1);
|
||||
ico->cp += ico_read_int16(ico->fp, &data->bpp, 1);
|
||||
|
||||
ico->cp += ico_read_int32(ico->fp, &data->compression, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->image_size, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->x_res, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->y_res, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->used_clrs, 1);
|
||||
ico->cp += ico_read_int32(ico->fp, &data->important_clrs, 1);
|
||||
|
||||
if (data->used_clrs == 0)
|
||||
{
|
||||
switch (data->bpp)
|
||||
{
|
||||
case 1:
|
||||
D("Allocating a 2-slot palette\n");
|
||||
data->used_clrs = 2;
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
|
||||
if (((entry->width * entry->height) % 8) == 0)
|
||||
xor_len = (entry->width * entry->height / 8);
|
||||
else
|
||||
xor_len = (entry->width * entry->height / 8) + 1;
|
||||
break;
|
||||
case 4:
|
||||
D("Allocating a 16-slot palette\n");
|
||||
data->used_clrs = 16;
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
xor_len = entry->width * entry->height / 2;
|
||||
break;
|
||||
case 8:
|
||||
D("Allocating a 256-slot palette\n");
|
||||
data->used_clrs = 256;
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
xor_len = entry->width * entry->height;
|
||||
break;
|
||||
default:
|
||||
D("No colormap, used_clrs = %i, bpp = %i\n", data->used_clrs, data->bpp);
|
||||
/* Otherwise, no colormap is used, but RGB values. */
|
||||
xor_len = entry->width * entry->height * (data->bpp/8);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (data->bpp)
|
||||
{
|
||||
case 1:
|
||||
D("Allocating a %i-slot palette for monochrome\n", data->used_clrs);
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
|
||||
if (((entry->width * entry->height) % 8) == 0)
|
||||
xor_len = (entry->width * entry->height / 8);
|
||||
else
|
||||
xor_len = (entry->width * entry->height / 8) + 1;
|
||||
break;
|
||||
case 4:
|
||||
D("Allocating a %i-slot palette for 4 bpp\n", data->used_clrs);
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
xor_len = entry->width * entry->height / 2;
|
||||
break;
|
||||
case 8:
|
||||
D("Allocating a %i-slot palette for 8 bpp\n", data->used_clrs);
|
||||
data->palette = (DATA32*) calloc(data->used_clrs, sizeof(DATA32));
|
||||
ico->cp += ico_read_int32(ico->fp, data->palette, data->used_clrs);
|
||||
xor_len = entry->width * entry->height;
|
||||
break;
|
||||
default:
|
||||
D("No colormap, used_clrs = %i, bpp = %i\n", data->used_clrs, data->bpp);
|
||||
/* Otherwise, no colormap is used, but RGB values. */
|
||||
xor_len = entry->width * entry->height * (data->bpp/8);
|
||||
}
|
||||
}
|
||||
|
||||
data->xor_map = (DATA8*) calloc(xor_len, sizeof(DATA8));
|
||||
ico->cp += ico_read_int8(ico->fp, data->xor_map, xor_len);
|
||||
|
||||
/* Read in and_map. It's padded out to 32 bits: */
|
||||
if ((entry->width % 32) == 0)
|
||||
and_len = ((entry->width/32) * entry->height);
|
||||
else
|
||||
and_len = ((entry->width/32 + 1) * entry->height);
|
||||
|
||||
data->and_map = (DATA8*) calloc(and_len, sizeof(DATA32));
|
||||
ico->cp += ico_read_int8(ico->fp, data->and_map, and_len * sizeof(DATA32));
|
||||
|
||||
D("Entry width %i, height %i, bpp %i\n", entry->width, entry->height, data->bpp);
|
||||
D("Length of xor_map: %i\n", xor_len);
|
||||
D("Length of and_map: %i\n", and_len * sizeof(DATA32));
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ico_load (MsIcon *ico)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!ico)
|
||||
return;
|
||||
|
||||
ico->cp += ico_read_int16(ico->fp, &ico->icon_count, 1);
|
||||
ico->icon_dir = (MsIconEntry*) calloc(ico->icon_count, sizeof(MsIconEntry));
|
||||
ico->icon_data = (MsIconData*) calloc(ico->icon_count, sizeof(MsIconData));
|
||||
|
||||
D("%s: Microsoft icon file, containing %i icon(s)\n",
|
||||
ico->filename, ico->icon_count);
|
||||
|
||||
for (i = 0; i < ico->icon_count; i++)
|
||||
ico_read_entry(ico, &ico->icon_dir[i]);
|
||||
|
||||
for (i = 0; i < ico->icon_count; i++)
|
||||
ico_read_data(ico, i);
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ico_get_bit_from_data(DATA8 *data, int line_width, int bit)
|
||||
{
|
||||
int line;
|
||||
int width32;
|
||||
int offset;
|
||||
|
||||
/* width per line in multiples of 32 bits */
|
||||
width32 = (line_width % 32 == 0 ? line_width/32 : line_width/32 + 1);
|
||||
|
||||
line = bit / line_width;
|
||||
offset = bit % line_width;
|
||||
|
||||
return (data[line * width32 * 4 + offset/8] & (1 << (7 - bit % 8)));
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ico_get_nibble_from_data(DATA8 *data, int nibble)
|
||||
{
|
||||
int result = (data[nibble/2] & (0x0F << (4 * (1 - nibble % 2))));
|
||||
|
||||
if (nibble % 2 == 0)
|
||||
result = result >> 4;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ico_to_imlib (MsIcon *ico, ImlibImage *im)
|
||||
{
|
||||
int x, y, w, h;
|
||||
DATA8 *xor_map;
|
||||
DATA8 *and_map;
|
||||
DATA32 *palette;
|
||||
MsIconData *data;
|
||||
|
||||
w = ico->icon_dir[0].width;
|
||||
h = ico->icon_dir[0].height;
|
||||
palette = ico->icon_data[0].palette;
|
||||
xor_map = ico->icon_data[0].xor_map;
|
||||
and_map = ico->icon_data[0].and_map;
|
||||
|
||||
if (! (im->data = (DATA32 *) malloc(sizeof(DATA32) * w * h)))
|
||||
return 0;
|
||||
|
||||
im->w = w; im->h = h;
|
||||
SET_FLAG(im->flags, F_HAS_ALPHA);
|
||||
data = &ico->icon_data[0];
|
||||
|
||||
switch (data->bpp)
|
||||
{
|
||||
case 1:
|
||||
D("Rendering at 1 bpp\n");
|
||||
for (y = 0; y < h; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
DATA32 color = palette[ico_get_bit_from_data(xor_map, w, y * w + x)];
|
||||
DATA32 *dest = &(im->data[(h-1-y) * w + x]);
|
||||
|
||||
R_VAL(dest) = R_VAL(&color);
|
||||
G_VAL(dest) = G_VAL(&color);
|
||||
B_VAL(dest) = B_VAL(&color);
|
||||
|
||||
if (ico_get_bit_from_data(and_map, w, y*w + x))
|
||||
A_VAL(dest) = 0;
|
||||
else
|
||||
A_VAL(dest) = 255;
|
||||
}
|
||||
break;
|
||||
|
||||
case 4:
|
||||
D("Rendering at 4 bpp\n");
|
||||
for (y = 0; y < h; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
DATA32 color = palette[ico_get_nibble_from_data(xor_map, y * w + x)];
|
||||
DATA32 *dest = &(im->data[(h-1-y) * w + x]);
|
||||
|
||||
R_VAL(dest) = R_VAL(&color);
|
||||
G_VAL(dest) = G_VAL(&color);
|
||||
B_VAL(dest) = B_VAL(&color);
|
||||
|
||||
if (ico_get_bit_from_data(and_map, w, y*w + x))
|
||||
A_VAL(dest) = 0;
|
||||
else
|
||||
A_VAL(dest) = 255;
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
case 8:
|
||||
D("Rendering at 8 bpp\n");
|
||||
for (y = 0; y < h; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
DATA32 color = palette[xor_map[y * w + x]];
|
||||
DATA32 *dest = &(im->data[(h-1-y) * w + x]);
|
||||
|
||||
R_VAL(dest) = R_VAL(&color);
|
||||
G_VAL(dest) = G_VAL(&color);
|
||||
B_VAL(dest) = B_VAL(&color);
|
||||
|
||||
if (ico_get_bit_from_data(and_map, w, y*w + x))
|
||||
A_VAL(dest) = 0;
|
||||
else
|
||||
A_VAL(dest) = 255;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
{
|
||||
int bytespp = data->bpp/8;
|
||||
|
||||
D("Rendering at %i bpp\n", data->bpp);
|
||||
for (y = 0; y < h; y++)
|
||||
for (x = 0; x < w; x++)
|
||||
{
|
||||
DATA32 *dest = &(im->data[(h-1-y) * w + x]);
|
||||
|
||||
B_VAL(dest) = xor_map[(y * w + x) * bytespp];
|
||||
G_VAL(dest) = xor_map[(y * w + x) * bytespp + 1];
|
||||
R_VAL(dest) = xor_map[(y * w + x) * bytespp + 2];
|
||||
|
||||
if (data->bpp < 32)
|
||||
{
|
||||
if (ico_get_bit_from_data(and_map, w, y*w + x))
|
||||
A_VAL(dest) = 0;
|
||||
else
|
||||
A_VAL(dest) = 255;
|
||||
}
|
||||
else
|
||||
{
|
||||
A_VAL(dest) = xor_map[(y * w + x) * bytespp + 3];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
char
|
||||
load(ImlibImage *im, ImlibProgressFunction progress, char progress_granularity, char immediate_load)
|
||||
{
|
||||
MsIcon *ico = NULL;
|
||||
|
||||
/* if immediate_load is 1, then dont delay image laoding as below, or */
|
||||
/* already data in this image - dont load it again */
|
||||
if (im->data)
|
||||
return 0;
|
||||
|
||||
/* set the format string member to the lower-case full extension */
|
||||
/* name for the format - so example names would be: */
|
||||
/* "png", "jpeg", "tiff", "ppm", "pgm", "pbm", "gif", "xpm" ... */
|
||||
|
||||
if (!im->format)
|
||||
im->format = strdup("ico");
|
||||
|
||||
if (im->loader || immediate_load || progress)
|
||||
{
|
||||
if (! (ico = ico_init((im->real_file))))
|
||||
return 0;
|
||||
|
||||
ico_load (ico);
|
||||
|
||||
if (! ico_to_imlib (ico, im))
|
||||
goto error;
|
||||
|
||||
ico_cleanup (ico);
|
||||
}
|
||||
|
||||
if (progress)
|
||||
{
|
||||
progress(im, 100, 0, 0, im->w, im->h);
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
||||
error:
|
||||
|
||||
if (im->data)
|
||||
free(im->data);
|
||||
return 0;
|
||||
|
||||
progress_granularity = 0;
|
||||
}
|
||||
|
||||
/* fills the ImlibLoader struct with a strign array of format file */
|
||||
/* extensions this loader can load. eg: */
|
||||
/* loader->formats = { "jpeg", "jpg"}; */
|
||||
/* giving permutations is a good idea. case sensitivity is irrelevant */
|
||||
/* your laoder CAN load more than one format if it likes - like: */
|
||||
/* loader->formats = { "gif", "png", "jpeg", "jpg"} */
|
||||
/* if it can load those formats. */
|
||||
void
|
||||
formats (ImlibLoader *l)
|
||||
{
|
||||
/* this is the only bit you have to change... */
|
||||
char *list_formats[] =
|
||||
{ "ico" };
|
||||
|
||||
/* don't bother changing any of this - it just reads this in and sets */
|
||||
/* the struct values and makes copies */
|
||||
{
|
||||
int i;
|
||||
|
||||
l->num_formats = (sizeof(list_formats) / sizeof (char *));
|
||||
l->formats = malloc(sizeof(char *) * l->num_formats);
|
||||
for (i = 0; i < l->num_formats; i++)
|
||||
l->formats[i] = strdup(list_formats[i]);
|
||||
}
|
||||
}
|
||||
|
1752
src/loader_xcf.c
1752
src/loader_xcf.c
File diff suppressed because it is too large
Load Diff
|
@ -1,757 +0,0 @@
|
|||
/*
|
||||
|
||||
-----------------------------[ XCF Loader ]-----------------------------
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2, or (at your option)
|
||||
any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <netinet/in.h>
|
||||
|
||||
#include "common.h"
|
||||
#include "image.h"
|
||||
#include "color_values.h"
|
||||
|
||||
#ifdef XCF_DBG
|
||||
#define D(s) \
|
||||
{ \
|
||||
printf s; \
|
||||
}
|
||||
#else
|
||||
#define D(s)
|
||||
#endif
|
||||
|
||||
#define RS R_VAL(src + s_idx)
|
||||
#define GS G_VAL(src + s_idx)
|
||||
#define BS B_VAL(src + s_idx)
|
||||
#define AS A_VAL(src + s_idx)
|
||||
#define RD R_VAL(dest + d_idx)
|
||||
#define GD G_VAL(dest + d_idx)
|
||||
#define BD B_VAL(dest + d_idx)
|
||||
#define AD A_VAL(dest + d_idx)
|
||||
|
||||
#define EPS 0.00001
|
||||
#define PI 3.141592654
|
||||
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#define INT_MULT(a,b,t) ((t) = (a) * (b) + 0x80, ((((t) >> 8) + (t)) >> 8))
|
||||
#define LINEAR(x,y,w) ((w*y + x)*4)
|
||||
|
||||
void
|
||||
rgb_to_hls (DATA8 *red, DATA8 *green, DATA8 *blue)
|
||||
{
|
||||
int r, g, b;
|
||||
double h, l, s;
|
||||
int min, max;
|
||||
int delta;
|
||||
|
||||
r = *red;
|
||||
g = *green;
|
||||
b = *blue;
|
||||
|
||||
if (r > g)
|
||||
{
|
||||
max = MAX (r, b);
|
||||
min = MIN (g, b);
|
||||
}
|
||||
else
|
||||
{
|
||||
max = MAX (g, b);
|
||||
min = MIN (r, b);
|
||||
}
|
||||
|
||||
l = (max + min) / 2.0;
|
||||
|
||||
if (max == min)
|
||||
{
|
||||
s = 0.0;
|
||||
h = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
delta = (max - min);
|
||||
|
||||
if (l < 128)
|
||||
s = 255 * (double) delta / (double) (max + min);
|
||||
else
|
||||
s = 255 * (double) delta / (double) (511 - max - min);
|
||||
|
||||
if (r == max)
|
||||
h = (g - b) / (double) delta;
|
||||
else if (g == max)
|
||||
h = 2 + (b - r) / (double) delta;
|
||||
else
|
||||
h = 4 + (r - g) / (double) delta;
|
||||
|
||||
h = h * 42.5;
|
||||
|
||||
if (h < 0)
|
||||
h += 255;
|
||||
else if (h > 255)
|
||||
h -= 255;
|
||||
}
|
||||
|
||||
*red = h;
|
||||
*green = l;
|
||||
*blue = s;
|
||||
}
|
||||
|
||||
|
||||
DATA8
|
||||
gimp_hls_value (double n1, double n2, double hue)
|
||||
{
|
||||
double value;
|
||||
|
||||
if (hue > 255)
|
||||
hue -= 255;
|
||||
else if (hue < 0)
|
||||
hue += 255;
|
||||
if (hue < 42.5)
|
||||
value = n1 + (n2 - n1) * (hue / 42.5);
|
||||
else if (hue < 127.5)
|
||||
value = n2;
|
||||
else if (hue < 170)
|
||||
value = n1 + (n2 - n1) * ((170 - hue) / 42.5);
|
||||
else
|
||||
value = n1;
|
||||
|
||||
return (DATA8) (value * 255);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
hls_to_rgb (DATA8 *hue, DATA8 *lightness, DATA8 *saturation)
|
||||
{
|
||||
double h, l, s;
|
||||
double m1, m2;
|
||||
|
||||
h = *hue;
|
||||
l = *lightness;
|
||||
s = *saturation;
|
||||
|
||||
if (s == 0)
|
||||
{
|
||||
/* achromatic case */
|
||||
*hue = l;
|
||||
*lightness = l;
|
||||
*saturation = l;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (l < 128)
|
||||
m2 = (l * (255 + s)) / 65025.0;
|
||||
else
|
||||
m2 = (l + s - (l * s) / 255.0) / 255.0;
|
||||
|
||||
m1 = (l / 127.5) - m2;
|
||||
|
||||
/* chromatic case */
|
||||
*hue = gimp_hls_value (m1, m2, h + 85);
|
||||
*lightness = gimp_hls_value (m1, m2, h);
|
||||
*saturation = gimp_hls_value (m1, m2, h - 85);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
rgb_to_hsv (DATA8 *red, DATA8 *green, DATA8 *blue)
|
||||
{
|
||||
int r, g, b;
|
||||
double h, s, v;
|
||||
int min, max;
|
||||
int delta;
|
||||
|
||||
h = 0.0;
|
||||
|
||||
r = *red;
|
||||
g = *green;
|
||||
b = *blue;
|
||||
|
||||
if (r > g)
|
||||
{
|
||||
max = MAX (r, b);
|
||||
min = MIN (g, b);
|
||||
}
|
||||
else
|
||||
{
|
||||
max = MAX (g, b);
|
||||
min = MIN (r, b);
|
||||
}
|
||||
|
||||
v = max;
|
||||
|
||||
if (max != 0)
|
||||
s = ((max - min) * 255) / (double) max;
|
||||
else
|
||||
s = 0;
|
||||
|
||||
if (s == 0)
|
||||
h = 0;
|
||||
else
|
||||
{
|
||||
delta = max - min;
|
||||
if (r == max)
|
||||
h = (g - b) / (double) delta;
|
||||
else if (g == max)
|
||||
h = 2 + (b - r) / (double) delta;
|
||||
else if (b == max)
|
||||
h = 4 + (r - g) / (double) delta;
|
||||
h *= 42.5;
|
||||
|
||||
if (h < 0)
|
||||
h += 255;
|
||||
if (h > 255)
|
||||
h -= 255;
|
||||
}
|
||||
|
||||
*red = h;
|
||||
*green = s;
|
||||
*blue = v;
|
||||
}
|
||||
|
||||
void
|
||||
hsv_to_rgb (DATA8 *hue, DATA8 *saturation, DATA8 *value)
|
||||
{
|
||||
double h, s, v;
|
||||
double f, p, q, t;
|
||||
|
||||
if (*saturation == 0)
|
||||
{
|
||||
*hue = *value;
|
||||
*saturation = *value;
|
||||
*value = *value;
|
||||
}
|
||||
else
|
||||
{
|
||||
h = *hue * 6.0 / 255.0;
|
||||
s = *saturation / 255.0;
|
||||
v = *value / 255.0;
|
||||
|
||||
f = h - (int) h;
|
||||
p = v * (1.0 - s);
|
||||
q = v * (1.0 - (s * f));
|
||||
t = v * (1.0 - (s * (1.0 - f)));
|
||||
|
||||
switch ((int) h)
|
||||
{
|
||||
case 0:
|
||||
*hue = v * 255;
|
||||
*saturation = t * 255;
|
||||
*value = p * 255;
|
||||
break;
|
||||
|
||||
case 1:
|
||||
*hue = q * 255;
|
||||
*saturation = v * 255;
|
||||
*value = p * 255;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
*hue = p * 255;
|
||||
*saturation = v * 255;
|
||||
*value = t * 255;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
*hue = p * 255;
|
||||
*saturation = q * 255;
|
||||
*value = v * 255;
|
||||
break;
|
||||
|
||||
case 4:
|
||||
*hue = t * 255;
|
||||
*saturation = p * 255;
|
||||
*value = v * 255;
|
||||
break;
|
||||
|
||||
case 5:
|
||||
*hue = v * 255;
|
||||
*saturation = p * 255;
|
||||
*value = q * 255;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* translate negative destinations */
|
||||
void _clip(int * src_tl_x, int * src_tl_y,
|
||||
int * src_br_x, int * src_br_y,
|
||||
int * dest_x, int * dest_y,
|
||||
int dest_w, int dest_h)
|
||||
{
|
||||
if (*dest_x + *src_br_x >= dest_w)
|
||||
{ *src_br_x -= (*dest_x + *src_br_x) - dest_w; }
|
||||
|
||||
if (*dest_y + *src_br_y >= dest_h)
|
||||
{ *src_br_y -= (*dest_y + *src_br_y) - dest_h; }
|
||||
|
||||
if (*dest_x < 0)
|
||||
{
|
||||
*src_tl_x = -(*dest_x);
|
||||
*dest_x = 0;
|
||||
}
|
||||
if (*dest_y < 0)
|
||||
{
|
||||
*src_tl_y = -(*dest_y);
|
||||
*dest_y = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
combine_pixels_normal (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
int b;
|
||||
unsigned char src_alpha;
|
||||
unsigned char new_alpha;
|
||||
float ratio, compl_ratio;
|
||||
long tmp;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
src_alpha = AS;
|
||||
|
||||
if (src_alpha != 0)
|
||||
{
|
||||
if (src_alpha == 255)
|
||||
new_alpha = src_alpha;
|
||||
else
|
||||
new_alpha = AD + INT_MULT((255 - AD), src_alpha, tmp);
|
||||
|
||||
b = 3;
|
||||
if (new_alpha != 0)
|
||||
{
|
||||
ratio = (float) src_alpha / new_alpha;
|
||||
compl_ratio = 1.0 - ratio;
|
||||
|
||||
do
|
||||
{
|
||||
b--;
|
||||
dest[d_idx + b] =
|
||||
(unsigned char) (src[s_idx + b] * ratio + dest[d_idx + b] * compl_ratio + EPS);
|
||||
}
|
||||
while (b);
|
||||
}
|
||||
|
||||
AD = new_alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_add (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
int tmp;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
tmp = RD + RS;
|
||||
RD = (tmp > 255 ? 255 : tmp);
|
||||
|
||||
tmp = GD + GS;
|
||||
GD = (tmp > 255 ? 255 : tmp);
|
||||
|
||||
tmp = BD + BS;
|
||||
BD = (tmp > 255 ? 255 : tmp);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_sub (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
int tmp;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
tmp = RD - RS;
|
||||
RD = (tmp < 0 ? 0 : tmp);
|
||||
|
||||
tmp = GD - GS;
|
||||
GD = (tmp < 0 ? 0 : tmp);
|
||||
|
||||
tmp = BD - BS;
|
||||
BD = (tmp < 0 ? 0 : tmp);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_diff (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
int tmp;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
tmp = RD - RS;
|
||||
RD = (tmp < 0 ? -tmp : tmp);
|
||||
|
||||
tmp = GD - GS;
|
||||
GD = (tmp < 0 ? -tmp : tmp);
|
||||
|
||||
tmp = BD - BS;
|
||||
BD = (tmp < 0 ? -tmp : tmp);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_darken (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
RD = MIN(RD, RS);
|
||||
GD = MIN(GD, GS);
|
||||
BD = MIN(BD, BS);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_lighten (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
RD = MAX(RD, RS);
|
||||
GD = MAX(GD, GS);
|
||||
BD = MAX(BD, BS);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_mult (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
int tmp;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
RS = INT_MULT(RS, RD, tmp);
|
||||
GS = INT_MULT(GS, GD, tmp);
|
||||
BS = INT_MULT(BS, BD, tmp);
|
||||
|
||||
AS = MIN(AS, AD);
|
||||
}
|
||||
|
||||
combine_pixels_normal(src, src_w, src_h, dest, dest_w, dest_h, dest_x, dest_y);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_div (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
RS = MIN(255, ((float)RD / (RS + 1)) * 256);
|
||||
GS = MIN(255, ((float)GD / (GS + 1)) * 256);
|
||||
BS = MIN(255, ((float)BD / (BS + 1)) * 256);
|
||||
|
||||
AS = MIN(AD, AS);
|
||||
}
|
||||
|
||||
combine_pixels_normal(src, src_w, src_h, dest, dest_w, dest_h, dest_x, dest_y);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_screen (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
RD = 255 - (((255 - RD) * (255 - RS)) >> 8);
|
||||
GD = 255 - (((255 - GD) * (255 - GS)) >> 8);
|
||||
BD = 255 - (((255 - BD) * (255 - BS)) >> 8);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_overlay (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
int tmp_screen, tmp_mult;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
tmp_screen = 255 - (((255 - RD) * (255 - RS)) >> 8);
|
||||
tmp_mult = (RD * RS) >> 8;
|
||||
RD = (RD * tmp_screen + (255 - RD) * tmp_mult) >> 8;
|
||||
|
||||
tmp_screen = 255 - (((255 - GD) * (255 - GS)) >> 8);
|
||||
tmp_mult = (GD * GS) >> 8;
|
||||
GD = (GD * tmp_screen + (255 - GD) * tmp_mult) >> 8;
|
||||
|
||||
tmp_screen = 255 - (((255 - BD) * (255 - BS)) >> 8);
|
||||
tmp_mult = (BD * BS) >> 8;
|
||||
BD = (BD * tmp_screen + (255 - BD) * tmp_mult) >> 8;
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_hsv (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y, int mode)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
rgb_to_hsv(&RS, &GS, &BS);
|
||||
rgb_to_hsv(&RD, &GD, &BD);
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
case 0: /* hue mode */
|
||||
RD = RS;
|
||||
break;
|
||||
case 1: /* saturation mode */
|
||||
GD = GS;
|
||||
break;
|
||||
case 2: /* value mode */
|
||||
BD = BS;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
hsv_to_rgb(&RD, &GD, &BD);
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_hue (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, dest_x, dest_y, 0);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_sat (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, dest_x, dest_y, 1);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_val (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
combine_pixels_hsv(src, src_w, src_h, dest, dest_w, dest_h, dest_x, dest_y, 2);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_col (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
rgb_to_hls(&RS, &GS, &BS);
|
||||
rgb_to_hls(&RD, &GD, &BD);
|
||||
RD = RS;
|
||||
BD = BS;
|
||||
hls_to_rgb(&RD, &GD, &BD);
|
||||
|
||||
AD = MIN(AD, AS);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
combine_pixels_diss (DATA8* src, int src_w, int src_h, DATA8* dest, int dest_w, int dest_h, int dest_x, int dest_y)
|
||||
{
|
||||
int x, y, s_idx, d_idx;
|
||||
int src_tl_x = 0, src_tl_y = 0;
|
||||
int src_br_x = src_w, src_br_y = src_h;
|
||||
|
||||
srand(12345);
|
||||
|
||||
_clip(&src_tl_x, &src_tl_y, &src_br_x, &src_br_y, &dest_x, &dest_y, dest_w, dest_h);
|
||||
|
||||
for (y = src_tl_y; y < src_br_y; y++)
|
||||
for (x = src_tl_x; x < src_br_x; x++)
|
||||
{
|
||||
d_idx = LINEAR((dest_x + x - src_tl_x), (dest_y + y - src_tl_y), dest_w);
|
||||
s_idx = LINEAR(x, y, src_w);
|
||||
|
||||
if ((rand() % 255) < AS)
|
||||
{
|
||||
int b;
|
||||
unsigned char src_alpha;
|
||||
unsigned char new_alpha;
|
||||
float ratio, compl_ratio;
|
||||
long tmp;
|
||||
|
||||
src_alpha = AS;
|
||||
|
||||
if (src_alpha != 0)
|
||||
{
|
||||
if (src_alpha == 255)
|
||||
new_alpha = src_alpha;
|
||||
else
|
||||
new_alpha = AD + INT_MULT((255 - AD), src_alpha, tmp);
|
||||
|
||||
b = 3;
|
||||
if (new_alpha != 0)
|
||||
{
|
||||
ratio = (float) src_alpha / new_alpha;
|
||||
compl_ratio = 1.0 - ratio;
|
||||
|
||||
do
|
||||
{
|
||||
b--;
|
||||
dest[d_idx + b] =
|
||||
(unsigned char) (src[s_idx + b] * ratio + dest[d_idx + b] * compl_ratio + EPS);
|
||||
}
|
||||
while (b);
|
||||
}
|
||||
|
||||
AD = new_alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue