/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/LICENSE |
---|
0,0 → 1,504 |
GNU LESSER GENERAL PUBLIC LICENSE |
Version 2.1, February 1999 |
Copyright (C) 1991, 1999 Free Software Foundation, Inc. |
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Everyone is permitted to copy and distribute verbatim copies |
of this license document, but changing it is not allowed. |
[This is the first released version of the Lesser GPL. It also counts |
as the successor of the GNU Library Public License, version 2, hence |
the version number 2.1.] |
Preamble |
The licenses for most software are designed to take away your |
freedom to share and change it. By contrast, the GNU General Public |
Licenses are intended to guarantee your freedom to share and change |
free software--to make sure the software is free for all its users. |
This license, the Lesser General Public License, applies to some |
specially designated software packages--typically libraries--of the |
Free Software Foundation and other authors who decide to use it. You |
can use it too, but we suggest you first think carefully about whether |
this license or the ordinary General Public License is the better |
strategy to use in any particular case, based on the explanations below. |
When we speak of free software, we are referring to freedom of use, |
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 and use pieces of |
it in new free programs; and that you are informed that you can do |
these things. |
To protect your rights, we need to make restrictions that forbid |
distributors to deny you these rights or to ask you to surrender these |
rights. These restrictions translate to certain responsibilities for |
you if you distribute copies of the library or if you modify it. |
For example, if you distribute copies of the library, whether gratis |
or for a fee, you must give the recipients all the rights that we gave |
you. You must make sure that they, too, receive or can get the source |
code. If you link other code with the library, you must provide |
complete object files to the recipients, so that they can relink them |
with the library after making changes to the library and recompiling |
it. And you must show them these terms so they know their rights. |
We protect your rights with a two-step method: (1) we copyright the |
library, and (2) we offer you this license, which gives you legal |
permission to copy, distribute and/or modify the library. |
To protect each distributor, we want to make it very clear that |
there is no warranty for the free library. Also, if the library is |
modified by someone else and passed on, the recipients should know |
that what they have is not the original version, so that the original |
author's reputation will not be affected by problems that might be |
introduced by others. |
Finally, software patents pose a constant threat to the existence of |
any free program. We wish to make sure that a company cannot |
effectively restrict the users of a free program by obtaining a |
restrictive license from a patent holder. Therefore, we insist that |
any patent license obtained for a version of the library must be |
consistent with the full freedom of use specified in this license. |
Most GNU software, including some libraries, is covered by the |
ordinary GNU General Public License. This license, the GNU Lesser |
General Public License, applies to certain designated libraries, and |
is quite different from the ordinary General Public License. We use |
this license for certain libraries in order to permit linking those |
libraries into non-free programs. |
When a program is linked with a library, whether statically or using |
a shared library, the combination of the two is legally speaking a |
combined work, a derivative of the original library. The ordinary |
General Public License therefore permits such linking only if the |
entire combination fits its criteria of freedom. The Lesser General |
Public License permits more lax criteria for linking other code with |
the library. |
We call this license the "Lesser" General Public License because it |
does Less to protect the user's freedom than the ordinary General |
Public License. It also provides other free software developers Less |
of an advantage over competing non-free programs. These disadvantages |
are the reason we use the ordinary General Public License for many |
libraries. However, the Lesser license provides advantages in certain |
special circumstances. |
For example, on rare occasions, there may be a special need to |
encourage the widest possible use of a certain library, so that it becomes |
a de-facto standard. To achieve this, non-free programs must be |
allowed to use the library. A more frequent case is that a free |
library does the same job as widely used non-free libraries. In this |
case, there is little to gain by limiting the free library to free |
software only, so we use the Lesser General Public License. |
In other cases, permission to use a particular library in non-free |
programs enables a greater number of people to use a large body of |
free software. For example, permission to use the GNU C Library in |
non-free programs enables many more people to use the whole GNU |
operating system, as well as its variant, the GNU/Linux operating |
system. |
Although the Lesser General Public License is Less protective of the |
users' freedom, it does ensure that the user of a program that is |
linked with the Library has the freedom and the wherewithal to run |
that program using a modified version of the Library. |
The precise terms and conditions for copying, distribution and |
modification follow. Pay close attention to the difference between a |
"work based on the library" and a "work that uses the library". The |
former contains code derived from the library, whereas the latter must |
be combined with the library in order to run. |
GNU LESSER GENERAL PUBLIC LICENSE |
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
0. This License Agreement applies to any software library or other |
program which contains a notice placed by the copyright holder or |
other authorized party saying it may be distributed under the terms of |
this Lesser General Public License (also called "this License"). |
Each licensee is addressed as "you". |
A "library" means a collection of software functions and/or data |
prepared so as to be conveniently linked with application programs |
(which use some of those functions and data) to form executables. |
The "Library", below, refers to any such software library or work |
which has been distributed under these terms. A "work based on the |
Library" means either the Library or any derivative work under |
copyright law: that is to say, a work containing the Library or a |
portion of it, either verbatim or with modifications and/or translated |
straightforwardly into another language. (Hereinafter, translation is |
included without limitation in the term "modification".) |
"Source code" for a work means the preferred form of the work for |
making modifications to it. For a library, complete source code means |
all the source code for all modules it contains, plus any associated |
interface definition files, plus the scripts used to control compilation |
and installation of the library. |
Activities other than copying, distribution and modification are not |
covered by this License; they are outside its scope. The act of |
running a program using the Library is not restricted, and output from |
such a program is covered only if its contents constitute a work based |
on the Library (independent of the use of the Library in a tool for |
writing it). Whether that is true depends on what the Library does |
and what the program that uses the Library does. |
1. You may copy and distribute verbatim copies of the Library's |
complete source code as you receive it, in any medium, provided that |
you conspicuously and appropriately publish on each copy an |
appropriate copyright notice and disclaimer of warranty; keep intact |
all the notices that refer to this License and to the absence of any |
warranty; and distribute a copy of this License along with the |
Library. |
You may charge a fee for the physical act of transferring a copy, |
and you may at your option offer warranty protection in exchange for a |
fee. |
2. You may modify your copy or copies of the Library or any portion |
of it, thus forming a work based on the Library, and copy and |
distribute such modifications or work under the terms of Section 1 |
above, provided that you also meet all of these conditions: |
a) The modified work must itself be a software library. |
b) You must cause the files modified to carry prominent notices |
stating that you changed the files and the date of any change. |
c) You must cause the whole of the work to be licensed at no |
charge to all third parties under the terms of this License. |
d) If a facility in the modified Library refers to a function or a |
table of data to be supplied by an application program that uses |
the facility, other than as an argument passed when the facility |
is invoked, then you must make a good faith effort to ensure that, |
in the event an application does not supply such function or |
table, the facility still operates, and performs whatever part of |
its purpose remains meaningful. |
(For example, a function in a library to compute square roots has |
a purpose that is entirely well-defined independent of the |
application. Therefore, Subsection 2d requires that any |
application-supplied function or table used by this function must |
be optional: if the application does not supply it, the square |
root function must still compute square roots.) |
These requirements apply to the modified work as a whole. If |
identifiable sections of that work are not derived from the Library, |
and can be reasonably considered independent and separate works in |
themselves, then this License, and its terms, do not apply to those |
sections when you distribute them as separate works. But when you |
distribute the same sections as part of a whole which is a work based |
on the Library, the distribution of the whole must be on the terms of |
this License, whose permissions for other licensees extend to the |
entire whole, and thus to each and every part regardless of who wrote |
it. |
Thus, it is not the intent of this section to claim rights or contest |
your rights to work written entirely by you; rather, the intent is to |
exercise the right to control the distribution of derivative or |
collective works based on the Library. |
In addition, mere aggregation of another work not based on the Library |
with the Library (or with a work based on the Library) on a volume of |
a storage or distribution medium does not bring the other work under |
the scope of this License. |
3. You may opt to apply the terms of the ordinary GNU General Public |
License instead of this License to a given copy of the Library. To do |
this, you must alter all the notices that refer to this License, so |
that they refer to the ordinary GNU General Public License, version 2, |
instead of to this License. (If a newer version than version 2 of the |
ordinary GNU General Public License has appeared, then you can specify |
that version instead if you wish.) Do not make any other change in |
these notices. |
Once this change is made in a given copy, it is irreversible for |
that copy, so the ordinary GNU General Public License applies to all |
subsequent copies and derivative works made from that copy. |
This option is useful when you wish to copy part of the code of |
the Library into a program that is not a library. |
4. You may copy and distribute the Library (or a portion or |
derivative of it, under Section 2) in object code or executable form |
under the terms of Sections 1 and 2 above provided that you accompany |
it with the complete corresponding machine-readable source code, which |
must be distributed under the terms of Sections 1 and 2 above on a |
medium customarily used for software interchange. |
If distribution of object code is made by offering access to copy |
from a designated place, then offering equivalent access to copy the |
source code from the same place satisfies the requirement to |
distribute the source code, even though third parties are not |
compelled to copy the source along with the object code. |
5. A program that contains no derivative of any portion of the |
Library, but is designed to work with the Library by being compiled or |
linked with it, is called a "work that uses the Library". Such a |
work, in isolation, is not a derivative work of the Library, and |
therefore falls outside the scope of this License. |
However, linking a "work that uses the Library" with the Library |
creates an executable that is a derivative of the Library (because it |
contains portions of the Library), rather than a "work that uses the |
library". The executable is therefore covered by this License. |
Section 6 states terms for distribution of such executables. |
When a "work that uses the Library" uses material from a header file |
that is part of the Library, the object code for the work may be a |
derivative work of the Library even though the source code is not. |
Whether this is true is especially significant if the work can be |
linked without the Library, or if the work is itself a library. The |
threshold for this to be true is not precisely defined by law. |
If such an object file uses only numerical parameters, data |
structure layouts and accessors, and small macros and small inline |
functions (ten lines or less in length), then the use of the object |
file is unrestricted, regardless of whether it is legally a derivative |
work. (Executables containing this object code plus portions of the |
Library will still fall under Section 6.) |
Otherwise, if the work is a derivative of the Library, you may |
distribute the object code for the work under the terms of Section 6. |
Any executables containing that work also fall under Section 6, |
whether or not they are linked directly with the Library itself. |
6. As an exception to the Sections above, you may also combine or |
link a "work that uses the Library" with the Library to produce a |
work containing portions of the Library, and distribute that work |
under terms of your choice, provided that the terms permit |
modification of the work for the customer's own use and reverse |
engineering for debugging such modifications. |
You must give prominent notice with each copy of the work that the |
Library is used in it and that the Library and its use are covered by |
this License. You must supply a copy of this License. If the work |
during execution displays copyright notices, you must include the |
copyright notice for the Library among them, as well as a reference |
directing the user to the copy of this License. Also, you must do one |
of these things: |
a) Accompany the work with the complete corresponding |
machine-readable source code for the Library including whatever |
changes were used in the work (which must be distributed under |
Sections 1 and 2 above); and, if the work is an executable linked |
with the Library, with the complete machine-readable "work that |
uses the Library", as object code and/or source code, so that the |
user can modify the Library and then relink to produce a modified |
executable containing the modified Library. (It is understood |
that the user who changes the contents of definitions files in the |
Library will not necessarily be able to recompile the application |
to use the modified definitions.) |
b) Use a suitable shared library mechanism for linking with the |
Library. A suitable mechanism is one that (1) uses at run time a |
copy of the library already present on the user's computer system, |
rather than copying library functions into the executable, and (2) |
will operate properly with a modified version of the library, if |
the user installs one, as long as the modified version is |
interface-compatible with the version that the work was made with. |
c) Accompany the work with a written offer, valid for at |
least three years, to give the same user the materials |
specified in Subsection 6a, above, for a charge no more |
than the cost of performing this distribution. |
d) If distribution of the work is made by offering access to copy |
from a designated place, offer equivalent access to copy the above |
specified materials from the same place. |
e) Verify that the user has already received a copy of these |
materials or that you have already sent this user a copy. |
For an executable, the required form of the "work that uses the |
Library" must include any data and utility programs needed for |
reproducing the executable from it. However, as a special exception, |
the materials to be distributed need not include anything that is |
normally distributed (in either source or binary form) with the major |
components (compiler, kernel, and so on) of the operating system on |
which the executable runs, unless that component itself accompanies |
the executable. |
It may happen that this requirement contradicts the license |
restrictions of other proprietary libraries that do not normally |
accompany the operating system. Such a contradiction means you cannot |
use both them and the Library together in an executable that you |
distribute. |
7. You may place library facilities that are a work based on the |
Library side-by-side in a single library together with other library |
facilities not covered by this License, and distribute such a combined |
library, provided that the separate distribution of the work based on |
the Library and of the other library facilities is otherwise |
permitted, and provided that you do these two things: |
a) Accompany the combined library with a copy of the same work |
based on the Library, uncombined with any other library |
facilities. This must be distributed under the terms of the |
Sections above. |
b) Give prominent notice with the combined library of the fact |
that part of it is a work based on the Library, and explaining |
where to find the accompanying uncombined form of the same work. |
8. You may not copy, modify, sublicense, link with, or distribute |
the Library except as expressly provided under this License. Any |
attempt otherwise to copy, modify, sublicense, link with, or |
distribute the Library is void, and will automatically terminate your |
rights under this License. However, parties who have received copies, |
or rights, from you under this License will not have their licenses |
terminated so long as such parties remain in full compliance. |
9. You are not required to accept this License, since you have not |
signed it. However, nothing else grants you permission to modify or |
distribute the Library or its derivative works. These actions are |
prohibited by law if you do not accept this License. Therefore, by |
modifying or distributing the Library (or any work based on the |
Library), you indicate your acceptance of this License to do so, and |
all its terms and conditions for copying, distributing or modifying |
the Library or works based on it. |
10. Each time you redistribute the Library (or any work based on the |
Library), the recipient automatically receives a license from the |
original licensor to copy, distribute, link with or modify the Library |
subject to these terms and conditions. You may not impose any further |
restrictions on the recipients' exercise of the rights granted herein. |
You are not responsible for enforcing compliance by third parties with |
this License. |
11. If, as a consequence of a court judgment or allegation of patent |
infringement or for any other reason (not limited to patent issues), |
conditions are imposed on you (whether by court order, agreement or |
otherwise) that contradict the conditions of this License, they do not |
excuse you from the conditions of this License. If you cannot |
distribute so as to satisfy simultaneously your obligations under this |
License and any other pertinent obligations, then as a consequence you |
may not distribute the Library at all. For example, if a patent |
license would not permit royalty-free redistribution of the Library by |
all those who receive copies directly or indirectly through you, then |
the only way you could satisfy both it and this License would be to |
refrain entirely from distribution of the Library. |
If any portion of this section is held invalid or unenforceable under any |
particular circumstance, the balance of the section is intended to apply, |
and the section as a whole is intended to apply in other circumstances. |
It is not the purpose of this section to induce you to infringe any |
patents or other property right claims or to contest validity of any |
such claims; this section has the sole purpose of protecting the |
integrity of the free software distribution system which is |
implemented by public license practices. Many people have made |
generous contributions to the wide range of software distributed |
through that system in reliance on consistent application of that |
system; it is up to the author/donor to decide if he or she is willing |
to distribute software through any other system and a licensee cannot |
impose that choice. |
This section is intended to make thoroughly clear what is believed to |
be a consequence of the rest of this License. |
12. If the distribution and/or use of the Library is restricted in |
certain countries either by patents or by copyrighted interfaces, the |
original copyright holder who places the Library under this License may add |
an explicit geographical distribution limitation excluding those countries, |
so that distribution is permitted only in or among countries not thus |
excluded. In such case, this License incorporates the limitation as if |
written in the body of this License. |
13. The Free Software Foundation may publish revised and/or new |
versions of the Lesser General Public License from time to time. |
Such new versions will be similar in spirit to the present version, |
but may differ in detail to address new problems or concerns. |
Each version is given a distinguishing version number. If the Library |
specifies a version number of this License which applies to it and |
"any later version", you have the option of following the terms and |
conditions either of that version or of any later version published by |
the Free Software Foundation. If the Library does not specify a |
license version number, you may choose any version ever published by |
the Free Software Foundation. |
14. If you wish to incorporate parts of the Library into other free |
programs whose distribution conditions are incompatible with these, |
write to the author to ask for permission. For software which is |
copyrighted by the Free Software Foundation, write to the Free |
Software Foundation; we sometimes make exceptions for this. Our |
decision will be guided by the two goals of preserving the free status |
of all derivatives of our free software and of promoting the sharing |
and reuse of software generally. |
NO WARRANTY |
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO |
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. |
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR |
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY |
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE |
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE |
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME |
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. |
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN |
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY |
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU |
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR |
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE |
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING |
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A |
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF |
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
DAMAGES. |
END OF TERMS AND CONDITIONS |
How to Apply These Terms to Your New Libraries |
If you develop a new library, and you want it to be of the greatest |
possible use to the public, we recommend making it free software that |
everyone can redistribute and change. You can do so by permitting |
redistribution under these terms (or, alternatively, under the terms of the |
ordinary General Public License). |
To apply these terms, attach the following notices to the library. It is |
safest to attach them to the start of each source file to most effectively |
convey the exclusion of warranty; and each file should have at least the |
"copyright" line and a pointer to where the full notice is found. |
<one line to give the library's name and a brief idea of what it does.> |
Copyright (C) <year> <name of author> |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Lesser General Public License for more details. |
You should have received a copy of the GNU Lesser General Public |
License along with this library; if not, write to the Free Software |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Also add information on how to contact you by electronic and paper mail. |
You should also get your employer (if you work as a programmer) or your |
school, if any, to sign a "copyright disclaimer" for the library, if |
necessary. Here is a sample; alter the names: |
Yoyodyne, Inc., hereby disclaims all copyright interest in the |
library `Frob' (a library for tweaking knobs) written by James Random Hacker. |
<signature of Ty Coon>, 1 April 1990 |
Ty Coon, President of Vice |
That's all there is to it! |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/Makefile |
---|
0,0 → 1,5 |
OUTFILE = libSDL_anim.a |
OBJS = anim.o |
CFLAGS = -I$(MENUETDEV)/include/SDL |
include $(MENUETDEV)/makefiles/Makefile_for_lib |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/Makefile.demo |
---|
0,0 → 1,6 |
OUTFILE = showanim |
OBJS = showanim.o |
CFLAGS = -I. -I$(MENUETDEV)/include/SDL |
LIBS = -L. -lSDL -lpng -lz -lSDL_anim -lpng -lz |
include $(MENUETDEV)/makefiles/Makefile_for_program |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/README |
---|
0,0 → 1,35 |
SDL_anim 0.2 |
The latest version of this library is available from: |
http://tamale.net/SDL_anim/ |
This is a simple library to load animations and blit them to SDL surfaces. |
This library supports PNG anim files. |
API: |
#include "SDL_anim.h" |
SDL_Animation *Anim_Load( const char *file ); |
int Anim_Free( SDL_Animation *anim ); |
int Anim_GetFrameNum( float start, float now ); |
int Anim_GetFrameRect( int frame, SDL_Rect *rect ); |
int Anim_BlitFrame( SDL_Surface dest, float start, float now ); |
int Anim_BlitFrameNum( SDL_Surface dest, int frame ); |
int Anim_DisplayFormat( SDL_Animation *anim ); |
Two programs are included: |
`showanim' is an example program that uses SDL_anim. |
`makeanim' creates PNG anim files. |
SDL_anim requires: |
libpng http://www.cdrom.com/pub/png/ |
zlib http://www.cdrom.com/pub/infozip/zlib/ |
This library is under the GNU Library General Public License, see the file |
"LICENSE" for details. |
To build under unix: |
gcc -I/home/mike/include/SDL/ -L/home/mike/lib Anim.c makeanim.c -o makeanim -lpng -lz -lSDL -lSDLmain -lpthread |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/SDL_anim.h |
---|
0,0 → 1,60 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#ifndef _SDLanim_h |
#define _SDLanim_h |
#include "SDL.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
struct SDL_Animation; |
typedef struct SDL_Animation { |
SDL_Surface *surface; |
int frames, w, h; |
Uint32 duration; |
} SDL_Animation; |
extern DECLSPEC struct SDL_Animation *Anim_Load( const char *file ); |
extern DECLSPEC void Anim_Free( SDL_Animation *anim ); |
extern DECLSPEC int Anim_GetFrameNum( SDL_Animation *anim, Uint32 start, Uint32 now ); |
extern DECLSPEC int Anim_BlitFrame( SDL_Animation *anim, Uint32 start, Uint32 now, SDL_Surface *dest, SDL_Rect *dr ); |
extern DECLSPEC void Anim_GetFrameRect( SDL_Animation *anim, int frame, SDL_Rect *rect ); |
extern DECLSPEC int Anim_BlitFrameNum( SDL_Animation *anim, int frame, SDL_Surface *dest, SDL_Rect *dr ); |
extern DECLSPEC int Anim_DisplayFormat( SDL_Animation *anim ); |
/* We'll use SDL for reporting errors */ |
#define Anim_SetError SDL_SetError |
#define Anim_GetError SDL_GetError |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
}; |
#endif |
#include "SDL/close_code.h" |
#endif /* _SDL_anim_h */ |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/anim.c |
---|
0,0 → 1,362 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <png.h> |
#include "SDL_anim.h" |
/* deal with MSVC++ crappiness */ |
#ifdef WIN32UNDEFINED |
#define strcasecmp _strcmpi |
#endif |
void Anim_Free( SDL_Animation *anim ) { |
SDL_FreeSurface( anim->surface ); |
free( anim ); |
} |
int Anim_GetFrameNum( SDL_Animation *anim, Uint32 start, Uint32 now ) { |
int mspf, ms, frame; |
if( now < start ) return 0; |
mspf = anim->duration / anim->frames; |
ms = now - start; |
if( mspf == 0 ) frame = 0; |
else frame = ms / mspf; |
return frame; |
} |
void Anim_GetFrameRect( SDL_Animation *anim, int frame, SDL_Rect *rect ) { |
rect->x = anim->w * (frame % anim->frames); |
rect->y = 0; |
rect->w = anim->w; |
rect->h = anim->h; |
} |
int Anim_BlitFrame( SDL_Animation *anim, Uint32 start, Uint32 now, SDL_Surface *dest, SDL_Rect *dr ) { |
int frame; |
frame = Anim_GetFrameNum( anim, start, now ); |
return Anim_BlitFrameNum( anim, frame, dest, dr ); |
} |
int Anim_BlitFrameNum( SDL_Animation *anim, int frame, SDL_Surface *dest, SDL_Rect *dr ) { |
SDL_Rect rect; |
Anim_GetFrameRect( anim, frame, &rect ); |
return SDL_BlitSurface( anim->surface, &rect, dest, dr ); |
} |
int Anim_DisplayFormat( SDL_Animation *anim ) { |
struct SDL_Surface *newsurface; |
if( SDL_WasInit( SDL_INIT_VIDEO ) == 0 ) return 0;/*"Video is not initialized.\n"*/ |
newsurface = SDL_DisplayFormatAlpha( anim->surface ); |
if( !newsurface ) return 0; |
anim->surface = newsurface; |
return 1; |
} |
int DoAnimFormat( char *text, int *duration, int *framewidth, int *numframes ) { |
char *tok; |
SDL_printf( "file is \"%s\"\n", text ); |
/* SDL_anim */ |
tok = strtok( text, " " ); |
if( !tok ) return 0; |
if( strcasecmp( tok, "SDL_anim" ) != 0 ) { |
SDL_printf( "no SDL_anim\n" ); |
return 0; |
} |
/* duration */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*duration = atoi( tok ); |
if( *duration < 1 ) { |
SDL_printf( "no duration\n" ); |
return 0; |
} |
/* framewidth */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*framewidth = atoi( tok ); |
if( *framewidth < 1 ) { |
SDL_printf( "no framewidth\n" ); |
return 0; |
} |
/* numframes */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*numframes = atoi( tok ); |
if( *numframes < 1 ) { |
SDL_printf( "no numframes\n" ); |
return 0; |
} |
return 1; |
} |
struct SDL_Animation *Anim_Load( const char *file ) { |
int ckey = -1, i; |
char buf[8]; |
static FILE *fp; /* "static" prevents setjmp corruption */ |
png_structp read_ptr; |
png_infop read_info_ptr, end_info_ptr; |
png_bytep *row_pointers; |
png_textp text_ptr; |
int num_text, t; |
int interlace_type, compression_type, filter_type, bit_depth, color_type; |
png_uint_32 width, height, row; |
int duration, framewidth, numframes; |
png_color_16p background; |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
double gamma; |
int intent; |
png_uint_16p hist; |
png_uint_32 offset_x, offset_y; |
int unit_type; |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
png_uint_32 res_x, res_y; |
/* png_colorp palette; |
int num_palette; |
*/ png_color_8p sig_bit; |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
Uint32 Rmask; |
Uint32 Gmask; |
Uint32 Bmask; |
Uint32 Amask; |
SDL_Animation *anim; |
SDL_Surface *surface; |
SDL_Palette *palette; |
if( !file ) return NULL; |
/* printf( "opening file \"%s\"\n", file ); |
*/ |
/* open the file handle */ |
fp = fopen( file, "rb" ); |
if( fp == NULL ) { |
SDL_printf( "fopen() failed\n" ); |
return NULL; |
} |
/* check if it's PNG */ |
if( fread( buf, 1, 8, fp ) != 8 ) { |
SDL_printf( "fread() failed\n" ); |
return NULL; |
} |
if( png_sig_cmp( buf, (png_size_t)0, 8 ) ) { |
SDL_printf( "not a PNG file\n" ); |
return NULL; |
} |
fseek( fp, 0, SEEK_SET ); |
/* allocate read structure */ |
read_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
if( read_ptr == NULL ) { |
SDL_printf( "png_create_read_struct() failed\n" ); |
return NULL; |
} |
/* allocate read info structure */ |
read_info_ptr = png_create_info_struct( read_ptr ); |
if( read_info_ptr == NULL ) { |
SDL_printf( "png_create_info_struct() failed\n" ); |
return NULL; |
} |
end_info_ptr = png_create_info_struct( read_ptr ); |
if( end_info_ptr == NULL ) { |
SDL_printf( "png_create_info_struct() failed\n" ); |
return NULL; |
} |
/* set error handler code */ |
if( setjmp( read_ptr->jmpbuf ) ) { |
SDL_printf( "libpng read error\n" ); |
return NULL; |
} |
/* initialize stream */ |
png_init_io( read_ptr, fp ); |
png_set_read_status_fn( read_ptr, NULL ); |
/* read png info struct */ |
png_read_info( read_ptr, read_info_ptr ); |
/* get the info */ |
if( !png_get_IHDR( read_ptr, read_info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_type ) ) { |
SDL_printf( "png_get_IHDR() failed\n" ); |
return NULL; |
} |
/* background color */ |
png_get_bKGD( read_ptr, read_info_ptr, &background ); |
png_get_cHRM( read_ptr, read_info_ptr, &white_x, &white_y, &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y ); |
/* gamma */ |
png_get_gAMA( read_ptr, read_info_ptr, &gamma ); |
/* rendering intent */ |
png_get_sRGB( read_ptr, read_info_ptr, &intent ); |
/* Histogram */ |
png_get_hIST( read_ptr, read_info_ptr, &hist ); |
/* offsets */ |
png_get_oFFs( read_ptr, read_info_ptr, &offset_x, &offset_y, &unit_type ); |
png_get_pCAL( read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, &nparams, &units, ¶ms ); |
/* pixel density */ |
png_get_pHYs( read_ptr, read_info_ptr, &res_x, &res_y, &unit_type ); |
/* png_get_PLTE( read_ptr, read_info_ptr, &palette, &num_palette ); |
*/ |
/* significant bits */ |
png_get_sBIT( read_ptr, read_info_ptr, &sig_bit ); |
/* transparency */ |
if( png_get_tRNS( read_ptr, read_info_ptr, &trans, &num_trans, &trans_values ) ) { |
if( color_type == PNG_COLOR_TYPE_PALETTE ) { |
if( num_trans == 1 ) ckey = trans[0]; |
else png_set_expand( read_ptr ); |
} |
else ckey = 0; /* actual value will be set later */ |
} |
/* text chunks */ |
num_text = 0; |
if( !png_get_text( read_ptr, read_info_ptr, &text_ptr, &num_text ) ) { |
SDL_printf( "file has no text chunks\n" ); |
return NULL; |
} |
for( t = 0; t < num_text; t++ ) { |
if( strcasecmp( text_ptr[t].key, "format" ) == 0 ) { |
if( DoAnimFormat( text_ptr[t].text, &duration, &framewidth, &numframes ) ) break; |
} |
} |
if( t == num_text ) { |
SDL_printf( "file is not an SDL_anim PNG\n" ); |
return NULL; |
} |
png_set_strip_16( read_ptr ); |
png_set_packing( read_ptr ); |
if(color_type == PNG_COLOR_TYPE_GRAY) |
png_set_expand( read_ptr ); |
/* Allocate the SDL surface to hold the image */ |
Rmask = Gmask = Bmask = Amask = 0; |
if( color_type != PNG_COLOR_TYPE_PALETTE ) { |
if( SDL_BYTEORDER == SDL_LIL_ENDIAN ) { |
Rmask = 0x000000FF; |
Gmask = 0x0000FF00; |
Bmask = 0x00FF0000; |
Amask = (read_info_ptr->channels == 4)? 0xFF000000 : 0; |
} |
else { |
int s = (read_info_ptr->channels == 4) ? 0 : 8; |
Rmask = 0xFF000000 >> s; |
Gmask = 0x00FF0000 >> s; |
Bmask = 0x0000FF00 >> s; |
Amask = 0x000000FF >> s; |
} |
} |
surface = SDL_AllocSurface( SDL_SWSURFACE, width, height, bit_depth * read_info_ptr->channels, Rmask, Gmask, Bmask, Amask ); |
if( surface == NULL ) { |
Anim_SetError("Out of memory"); |
return NULL; |
} |
if(ckey != -1) { |
if( color_type != PNG_COLOR_TYPE_PALETTE ) ckey = SDL_MapRGB( surface->format, (Uint8)trans_values->red, (Uint8)trans_values->green, (Uint8)trans_values->blue ); |
SDL_SetColorKey( surface, SDL_SRCCOLORKEY, ckey ); |
} |
/* allocate row pointers */ |
row_pointers = (png_bytep *)malloc( sizeof( png_bytep ) * height ); |
if( row_pointers == NULL ) { |
SDL_printf( "malloc() failed\n" ); |
return NULL; |
} |
for( row = 0; row < height; row++ ) { |
row_pointers[row] = (Uint8 *)surface->pixels + row * surface->pitch; |
} |
png_read_image( read_ptr, row_pointers ); |
/* end io */ |
/* printf( "done\n" ); |
*/ png_read_end( read_ptr, end_info_ptr ); |
/* cleanup */ |
png_destroy_read_struct( &read_ptr, &read_info_ptr, &end_info_ptr); |
fclose( fp ); |
/* Load the palette, if any */ |
palette = surface->format->palette; |
if( palette ) { |
if(color_type == PNG_COLOR_TYPE_GRAY) { |
palette->ncolors = 256; |
for( i = 0; i < 256; i++ ) { |
palette->colors[i].r = i; |
palette->colors[i].g = i; |
palette->colors[i].b = i; |
} |
} |
else if( read_info_ptr->num_palette > 0 ) { |
palette->ncolors = read_info_ptr->num_palette; |
for( i = 0; i < read_info_ptr->num_palette; ++i ) { |
palette->colors[i].b = read_info_ptr->palette[i].blue; |
palette->colors[i].g = read_info_ptr->palette[i].green; |
palette->colors[i].r = read_info_ptr->palette[i].red; |
} |
} |
} |
anim = (struct SDL_Animation *)malloc( sizeof( struct SDL_Animation ) ); |
if( !anim ) { |
SDL_printf( "malloc() failed\n" ); |
return NULL; |
} |
anim->surface = surface; |
anim->w = framewidth; |
anim->h = height; |
anim->frames = numframes; |
anim->duration = duration; |
return anim; |
} |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/anim.c.BAK |
---|
0,0 → 1,362 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <png.h> |
#include "SDL_anim.h" |
/* deal with MSVC++ crappiness */ |
#ifdef WIN32 |
#define strcasecmp _strcmpi |
#endif |
void Anim_Free( SDL_Animation *anim ) { |
SDL_FreeSurface( anim->surface ); |
free( anim ); |
} |
int Anim_GetFrameNum( SDL_Animation *anim, Uint32 start, Uint32 now ) { |
int mspf, ms, frame; |
if( now < start ) return 0; |
mspf = anim->duration / anim->frames; |
ms = now - start; |
if( mspf == 0 ) frame = 0; |
else frame = ms / mspf; |
return frame; |
} |
void Anim_GetFrameRect( SDL_Animation *anim, int frame, SDL_Rect *rect ) { |
rect->x = anim->w * (frame % anim->frames); |
rect->y = 0; |
rect->w = anim->w; |
rect->h = anim->h; |
} |
int Anim_BlitFrame( SDL_Animation *anim, Uint32 start, Uint32 now, SDL_Surface *dest, SDL_Rect *dr ) { |
int frame; |
frame = Anim_GetFrameNum( anim, start, now ); |
return Anim_BlitFrameNum( anim, frame, dest, dr ); |
} |
int Anim_BlitFrameNum( SDL_Animation *anim, int frame, SDL_Surface *dest, SDL_Rect *dr ) { |
SDL_Rect rect; |
Anim_GetFrameRect( anim, frame, &rect ); |
return SDL_BlitSurface( anim->surface, &rect, dest, dr ); |
} |
int Anim_DisplayFormat( SDL_Animation *anim ) { |
struct SDL_Surface *newsurface; |
if( SDL_WasInit( SDL_INIT_VIDEO ) == 0 ) return 0;/*"Video is not initialized.\n"*/ |
newsurface = SDL_DisplayFormatAlpha( anim->surface ); |
if( !newsurface ) return 0; |
anim->surface = newsurface; |
return 1; |
} |
int DoAnimFormat( char *text, int *duration, int *framewidth, int *numframes ) { |
char *tok; |
SDL_printf( "file is \"%s\"\n", text ); |
/* SDL_anim */ |
tok = strtok( text, " " ); |
if( !tok ) return 0; |
if( strcasecmp( tok, "SDL_anim" ) != 0 ) { |
SDL_printf( "no SDL_anim\n" ); |
return 0; |
} |
/* duration */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*duration = atoi( tok ); |
if( *duration < 1 ) { |
SDL_printf( "no duration\n" ); |
return 0; |
} |
/* framewidth */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*framewidth = atoi( tok ); |
if( *framewidth < 1 ) { |
SDL_printf( "no framewidth\n" ); |
return 0; |
} |
/* numframes */ |
tok = strtok( NULL, " " ); |
if( !tok ) return 0; |
*numframes = atoi( tok ); |
if( *numframes < 1 ) { |
SDL_printf( "no numframes\n" ); |
return 0; |
} |
return 1; |
} |
struct SDL_Animation *Anim_Load( const char *file ) { |
int ckey = -1, i; |
char buf[8]; |
static FILE *fp; /* "static" prevents setjmp corruption */ |
png_structp read_ptr; |
png_infop read_info_ptr, end_info_ptr; |
png_bytep *row_pointers; |
png_textp text_ptr; |
int num_text, t; |
int interlace_type, compression_type, filter_type, bit_depth, color_type; |
png_uint_32 width, height, row; |
int duration, framewidth, numframes; |
png_color_16p background; |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
double gamma; |
int intent; |
png_uint_16p hist; |
png_uint_32 offset_x, offset_y; |
int unit_type; |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
png_uint_32 res_x, res_y; |
/* png_colorp palette; |
int num_palette; |
*/ png_color_8p sig_bit; |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
Uint32 Rmask; |
Uint32 Gmask; |
Uint32 Bmask; |
Uint32 Amask; |
SDL_Animation *anim; |
SDL_Surface *surface; |
SDL_Palette *palette; |
if( !file ) return NULL; |
/* printf( "opening file \"%s\"\n", file ); |
*/ |
/* open the file handle */ |
fp = fopen( file, "rb" ); |
if( fp == NULL ) { |
SDL_printf( "fopen() failed\n" ); |
return NULL; |
} |
/* check if it's PNG */ |
if( fread( buf, 1, 8, fp ) != 8 ) { |
SDL_printf( "fread() failed\n" ); |
return NULL; |
} |
if( png_sig_cmp( buf, (png_size_t)0, 8 ) ) { |
SDL_printf( "not a PNG file\n" ); |
return NULL; |
} |
fseek( fp, 0, SEEK_SET ); |
/* allocate read structure */ |
read_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
if( read_ptr == NULL ) { |
SDL_printf( "png_create_read_struct() failed\n" ); |
return NULL; |
} |
/* allocate read info structure */ |
read_info_ptr = png_create_info_struct( read_ptr ); |
if( read_info_ptr == NULL ) { |
SDL_printf( "png_create_info_struct() failed\n" ); |
return NULL; |
} |
end_info_ptr = png_create_info_struct( read_ptr ); |
if( end_info_ptr == NULL ) { |
SDL_printf( "png_create_info_struct() failed\n" ); |
return NULL; |
} |
/* set error handler code */ |
if( setjmp( read_ptr->jmpbuf ) ) { |
SDL_printf( "libpng read error\n" ); |
return NULL; |
} |
/* initialize stream */ |
png_init_io( read_ptr, fp ); |
png_set_read_status_fn( read_ptr, NULL ); |
/* read png info struct */ |
png_read_info( read_ptr, read_info_ptr ); |
/* get the info */ |
if( !png_get_IHDR( read_ptr, read_info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_type ) ) { |
SDL_printf( "png_get_IHDR() failed\n" ); |
return NULL; |
} |
/* background color */ |
png_get_bKGD( read_ptr, read_info_ptr, &background ); |
png_get_cHRM( read_ptr, read_info_ptr, &white_x, &white_y, &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y ); |
/* gamma */ |
png_get_gAMA( read_ptr, read_info_ptr, &gamma ); |
/* rendering intent */ |
png_get_sRGB( read_ptr, read_info_ptr, &intent ); |
/* Histogram */ |
png_get_hIST( read_ptr, read_info_ptr, &hist ); |
/* offsets */ |
png_get_oFFs( read_ptr, read_info_ptr, &offset_x, &offset_y, &unit_type ); |
png_get_pCAL( read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, &nparams, &units, ¶ms ); |
/* pixel density */ |
png_get_pHYs( read_ptr, read_info_ptr, &res_x, &res_y, &unit_type ); |
/* png_get_PLTE( read_ptr, read_info_ptr, &palette, &num_palette ); |
*/ |
/* significant bits */ |
png_get_sBIT( read_ptr, read_info_ptr, &sig_bit ); |
/* transparency */ |
if( png_get_tRNS( read_ptr, read_info_ptr, &trans, &num_trans, &trans_values ) ) { |
if( color_type == PNG_COLOR_TYPE_PALETTE ) { |
if( num_trans == 1 ) ckey = trans[0]; |
else png_set_expand( read_ptr ); |
} |
else ckey = 0; /* actual value will be set later */ |
} |
/* text chunks */ |
num_text = 0; |
if( !png_get_text( read_ptr, read_info_ptr, &text_ptr, &num_text ) ) { |
SDL_printf( "file has no text chunks\n" ); |
return NULL; |
} |
for( t = 0; t < num_text; t++ ) { |
if( strcasecmp( text_ptr[t].key, "format" ) == 0 ) { |
if( DoAnimFormat( text_ptr[t].text, &duration, &framewidth, &numframes ) ) break; |
} |
} |
if( t == num_text ) { |
SDL_printf( "file is not an SDL_anim PNG\n" ); |
return NULL; |
} |
png_set_strip_16( read_ptr ); |
png_set_packing( read_ptr ); |
if(color_type == PNG_COLOR_TYPE_GRAY) |
png_set_expand( read_ptr ); |
/* Allocate the SDL surface to hold the image */ |
Rmask = Gmask = Bmask = Amask = 0; |
if( color_type != PNG_COLOR_TYPE_PALETTE ) { |
if( SDL_BYTEORDER == SDL_LIL_ENDIAN ) { |
Rmask = 0x000000FF; |
Gmask = 0x0000FF00; |
Bmask = 0x00FF0000; |
Amask = (read_info_ptr->channels == 4)? 0xFF000000 : 0; |
} |
else { |
int s = (read_info_ptr->channels == 4) ? 0 : 8; |
Rmask = 0xFF000000 >> s; |
Gmask = 0x00FF0000 >> s; |
Bmask = 0x0000FF00 >> s; |
Amask = 0x000000FF >> s; |
} |
} |
surface = SDL_AllocSurface( SDL_SWSURFACE, width, height, bit_depth * read_info_ptr->channels, Rmask, Gmask, Bmask, Amask ); |
if( surface == NULL ) { |
Anim_SetError("Out of memory"); |
return NULL; |
} |
if(ckey != -1) { |
if( color_type != PNG_COLOR_TYPE_PALETTE ) ckey = SDL_MapRGB( surface->format, (Uint8)trans_values->red, (Uint8)trans_values->green, (Uint8)trans_values->blue ); |
SDL_SetColorKey( surface, SDL_SRCCOLORKEY, ckey ); |
} |
/* allocate row pointers */ |
row_pointers = (png_bytep *)malloc( sizeof( png_bytep ) * height ); |
if( row_pointers == NULL ) { |
SDL_printf( "malloc() failed\n" ); |
return NULL; |
} |
for( row = 0; row < height; row++ ) { |
row_pointers[row] = (Uint8 *)surface->pixels + row * surface->pitch; |
} |
png_read_image( read_ptr, row_pointers ); |
/* end io */ |
/* printf( "done\n" ); |
*/ png_read_end( read_ptr, end_info_ptr ); |
/* cleanup */ |
png_destroy_read_struct( &read_ptr, &read_info_ptr, &end_info_ptr); |
fclose( fp ); |
/* Load the palette, if any */ |
palette = surface->format->palette; |
if( palette ) { |
if(color_type == PNG_COLOR_TYPE_GRAY) { |
palette->ncolors = 256; |
for( i = 0; i < 256; i++ ) { |
palette->colors[i].r = i; |
palette->colors[i].g = i; |
palette->colors[i].b = i; |
} |
} |
else if( read_info_ptr->num_palette > 0 ) { |
palette->ncolors = read_info_ptr->num_palette; |
for( i = 0; i < read_info_ptr->num_palette; ++i ) { |
palette->colors[i].b = read_info_ptr->palette[i].blue; |
palette->colors[i].g = read_info_ptr->palette[i].green; |
palette->colors[i].r = read_info_ptr->palette[i].red; |
} |
} |
} |
anim = (struct SDL_Animation *)malloc( sizeof( struct SDL_Animation ) ); |
if( !anim ) { |
SDL_printf( "malloc() failed\n" ); |
return NULL; |
} |
anim->surface = surface; |
anim->w = framewidth; |
anim->h = height; |
anim->frames = numframes; |
anim->duration = duration; |
return anim; |
} |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/makeanim.c |
---|
0,0 → 1,328 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <png.h> |
/* deal with MSVC++ crappiness */ |
#ifdef WIN32UNDEFINED |
#define snprintf _snprintf |
#endif |
typedef struct inputstruct { |
FILE *file; |
char *name; |
png_structp read_ptr; |
png_infop read_info_ptr; |
}; |
int numfiles; |
struct inputstruct *input; |
int main( int argc, char *argv[] ) { |
int f, rowbytes; |
char buf[256]; |
static FILE *fpout; /* "static" prevents setjmp corruption */ |
png_structp write_ptr; |
png_infop write_info_ptr, end_info_ptr; |
png_bytep row_buf, here; |
png_uint_32 y; |
png_textp text_ptr, new_text_ptr; |
int num_text; |
int interlace_type, compression_type, filter_type, bit_depth, color_type; |
int it, ct, ft, bd, clrt; |
png_uint_32 width, height, w, h; |
int duration; |
if( argc < 4 ) { |
printf( "makeanim v0.2\nusage: makeanim <duration in milliseconds> <input files ...> <output file>\n" ); |
printf( "example: makeanim 1500 a00.png a01.png a02.png a03.png a04.png a.anim\n" ); |
return 1; |
} |
duration = atoi( argv[1] ); |
if( duration < 1 ) { |
printf( "duration is incorrect\n" ); |
return 1; |
} |
numfiles = argc - 3; |
input = (struct inputstruct *)malloc( sizeof( struct inputstruct ) * numfiles ); |
if( !input ) return 1; |
for( f = 0; f < numfiles; f++ ) { |
input[f].name = argv[f + 2]; |
printf( "opening file %d, \"%s\"\n", f, input[f].name ); |
/* open the file handle */ |
input[f].file = fopen( input[f].name, "rb" ); |
if( input[f].file == NULL ) { |
printf( "fopen() failed\n" ); |
return 1; |
} |
/* check if it's PNG */ |
if( fread( buf, 1, 8, input[f].file ) != 8 ) { |
printf( "fread() failed for file \"%s\"\n", input[f].name ); |
return 1; |
} |
if( png_sig_cmp( buf, (png_size_t)0, 8 ) ) { |
printf( "not a PNG file\n" ); |
return 1; |
} |
fseek( input[f].file, 0, SEEK_SET ); |
/* allocate read structure */ |
input[f].read_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
if( input[f].read_ptr == NULL ) { |
printf( "png_create_read_struct() failed\n" ); |
return 1; |
} |
/* allocate read info structure */ |
input[f].read_info_ptr = png_create_info_struct( input[f].read_ptr ); |
if( input[f].read_info_ptr == NULL ) { |
printf( "png_create_info_struct() failed\n" ); |
return 1; |
} |
/* set error handler code */ |
if( setjmp( input[f].read_ptr->jmpbuf ) ) { |
printf( "libpng read error\n" ); |
return 1; |
} |
/* initialize stream */ |
png_init_io( input[f].read_ptr, input[f].file ); |
png_set_read_status_fn( input[f].read_ptr, NULL ); |
/* read png info struct */ |
png_read_info( input[f].read_ptr, input[f].read_info_ptr ); |
/* get the info */ |
if( !png_get_IHDR( input[f].read_ptr, input[f].read_info_ptr, &w, &h, &bd, &clrt, &it, &ct, &ft ) ) { |
printf( "png_get_IHDR() failed\n" ); |
return 1; |
} |
/* save the info of the first frame */ |
if( f == 0 ) { |
width = w; |
height = h; |
bit_depth = bd; |
color_type = clrt; |
interlace_type = it; |
compression_type = ct; |
filter_type = ft; |
} |
/* compare all other frames to first frame */ |
else if( (w != width) || |
(h != height) || |
(bd != bit_depth) || |
(clrt != color_type) || |
(it != interlace_type) || |
(ct != compression_type) || |
(ft != filter_type) ) { |
if( w != width ) printf( "width is different\n" ); |
if( h != height ) printf( "height is different\n" ); |
if( bd != bit_depth ) printf( "bit depth is different\n" ); |
if( clrt != color_type ) printf( "color type is different\n" ); |
if( it != interlace_type ) printf( "interlace type is different\n" ); |
if( ct != compression_type ) printf( "compression type is different\n" ); |
if( ft != filter_type ) printf( "filter type is different\n" ); |
return 1; |
} |
} |
row_buf = (png_bytep)NULL; |
/* open output file */ |
printf( "opening file \"%s\"\n", argv[numfiles + 2] ); |
fpout = fopen( argv[numfiles + 2], "wb" ); |
if( fpout == NULL ) { |
printf( "fopen() failed\n" ); |
return 1; |
} |
/* allocate write structure */ |
write_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
/* allocate info structures */ |
write_info_ptr = png_create_info_struct( write_ptr ); |
end_info_ptr = png_create_info_struct( write_ptr ); |
/* error handling */ |
if( setjmp( write_ptr->jmpbuf ) ) { |
printf( "libpng write error\n" ); |
return 1; |
} |
/* initialize output stream */ |
png_init_io( write_ptr, fpout ); |
png_set_write_status_fn( write_ptr, NULL ); |
/* set info */ |
png_set_IHDR( write_ptr, write_info_ptr, width * numfiles, height, bit_depth, color_type, PNG_INTERLACE_NONE, compression_type, filter_type); |
/* image characteristics */ |
{ |
png_color_16p background; |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
double gamma; |
int intent; |
png_uint_16p hist; |
png_uint_32 offset_x, offset_y; |
int unit_type; |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
png_uint_32 res_x, res_y; |
png_colorp palette; |
int num_palette; |
png_color_8p sig_bit; |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
/* background color */ |
if( png_get_bKGD( input[0].read_ptr, input[0].read_info_ptr, &background ) ) { |
png_set_bKGD( write_ptr, write_info_ptr, background ); |
} |
if( png_get_cHRM( input[0].read_ptr, input[0].read_info_ptr, &white_x, &white_y, &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y ) ) { |
png_set_cHRM( write_ptr, write_info_ptr, white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y ); |
} |
/* gamma */ |
if( png_get_gAMA( input[0].read_ptr, input[0].read_info_ptr, &gamma ) ) { |
png_set_gAMA( write_ptr, write_info_ptr, gamma ); |
} |
/* rendering intent */ |
if( png_get_sRGB( input[0].read_ptr, input[0].read_info_ptr, &intent ) ) { |
png_set_sRGB( write_ptr, write_info_ptr, intent ); |
} |
/* Histogram */ |
if( png_get_hIST( input[0].read_ptr, input[0].read_info_ptr, &hist ) ) { |
png_set_hIST( write_ptr, write_info_ptr, hist ); |
} |
/* offsets */ |
if( png_get_oFFs( input[0].read_ptr, input[0].read_info_ptr, &offset_x, &offset_y, &unit_type ) ) { |
png_set_oFFs( write_ptr, write_info_ptr, offset_x, offset_y, unit_type ); |
} |
if( png_get_pCAL( input[0].read_ptr, input[0].read_info_ptr, &purpose, &X0, &X1, &type, &nparams, &units, ¶ms ) ) { |
png_set_pCAL( write_ptr, write_info_ptr, purpose, X0, X1, type, nparams, units, params ); |
} |
/* pixel density */ |
if( png_get_pHYs( input[0].read_ptr, input[0].read_info_ptr, &res_x, &res_y, &unit_type ) ) { |
png_set_pHYs( write_ptr, write_info_ptr, res_x, res_y, unit_type ); |
} |
/* text chunks */ |
/* if( png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) > 0 ) { |
printf( "Handling %d tEXt/zTXt chunks\n", num_text ); |
png_set_text( write_ptr, write_info_ptr, text_ptr, num_text ); |
} |
*/ |
/* palette */ |
if( png_get_PLTE( input[0].read_ptr, input[0].read_info_ptr, &palette, &num_palette ) ) { |
png_set_PLTE( write_ptr, write_info_ptr, palette, num_palette ); |
} |
/* significant bits */ |
if( png_get_sBIT( input[0].read_ptr, input[0].read_info_ptr, &sig_bit ) ) { |
png_set_sBIT( write_ptr, write_info_ptr, sig_bit ); |
} |
/* transparency */ |
if( png_get_tRNS( input[0].read_ptr, input[0].read_info_ptr, &trans, &num_trans, &trans_values ) ) { |
png_set_tRNS( write_ptr, write_info_ptr, trans, num_trans, trans_values ); |
} |
} |
/* text chunks */ |
num_text = 0; |
if( !png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) ) num_text = 0; |
new_text_ptr = (struct png_text_struct *)malloc( sizeof( struct png_text_struct ) * num_text + 1 ); |
if( !new_text_ptr ) { |
printf( "malloc() failed\n" ); |
return 1; |
} |
memcpy( new_text_ptr, text_ptr, sizeof( struct png_text_struct ) * num_text ); |
snprintf( buf, 255, "SDL_anim %d %d %d", duration, width, numfiles ); |
buf[255] = 0; |
new_text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE; |
new_text_ptr[num_text].key = "format"; |
new_text_ptr[num_text].text = buf; |
new_text_ptr[num_text].text_length = strlen( buf ); |
num_text++; |
png_set_text( write_ptr, write_info_ptr, new_text_ptr, num_text ); |
/* write info */ |
png_write_info( write_ptr, write_info_ptr ); |
/* allocate buffer */ |
rowbytes = png_get_rowbytes( input[0].read_ptr, input[0].read_info_ptr ); |
row_buf = (png_bytep)png_malloc( write_ptr, rowbytes * numfiles ); |
if( row_buf == NULL ) { |
printf( "png_malloc() failed\n" ); |
return 1; |
} |
/* copy raw data */ |
for( y = 0; y < height; y++ ) { |
/* grab a scanline from each file */ |
here = row_buf; |
for( f = 0; f < numfiles; f++ ) { |
png_read_rows( input[f].read_ptr, (png_bytepp)&here, (png_bytepp)NULL, 1 ); |
here += rowbytes; |
} |
/* write the long scanline */ |
png_write_rows( write_ptr, (png_bytepp)&row_buf, 1 ); |
} |
/* end io */ |
for( f = 0; f < numfiles; f++ ) png_read_end( input[f].read_ptr, end_info_ptr ); |
png_write_end( write_ptr, end_info_ptr ); |
/* cleanup */ |
png_free( write_ptr, row_buf ); |
for( f = 0; f < numfiles; f++ ) { |
png_destroy_read_struct( &input[f].read_ptr, &input[f].read_info_ptr, &end_info_ptr); |
fclose( input[f].file ); |
} |
png_destroy_write_struct( &write_ptr, &write_info_ptr ); |
fclose( fpout ); |
return 0; |
} |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/makeanim.c.BAK |
---|
0,0 → 1,328 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <png.h> |
/* deal with MSVC++ crappiness */ |
#ifdef WIN32 |
#define snprintf _snprintf |
#endif |
typedef struct inputstruct { |
FILE *file; |
char *name; |
png_structp read_ptr; |
png_infop read_info_ptr; |
}; |
int numfiles; |
struct inputstruct *input; |
int main( int argc, char *argv[] ) { |
int f, rowbytes; |
char buf[256]; |
static FILE *fpout; /* "static" prevents setjmp corruption */ |
png_structp write_ptr; |
png_infop write_info_ptr, end_info_ptr; |
png_bytep row_buf, here; |
png_uint_32 y; |
png_textp text_ptr, new_text_ptr; |
int num_text; |
int interlace_type, compression_type, filter_type, bit_depth, color_type; |
int it, ct, ft, bd, clrt; |
png_uint_32 width, height, w, h; |
int duration; |
if( argc < 4 ) { |
printf( "makeanim v0.2\nusage: makeanim <duration in milliseconds> <input files ...> <output file>\n" ); |
printf( "example: makeanim 1500 a00.png a01.png a02.png a03.png a04.png a.anim\n" ); |
return 1; |
} |
duration = atoi( argv[1] ); |
if( duration < 1 ) { |
printf( "duration is incorrect\n" ); |
return 1; |
} |
numfiles = argc - 3; |
input = (struct inputstruct *)malloc( sizeof( struct inputstruct ) * numfiles ); |
if( !input ) return 1; |
for( f = 0; f < numfiles; f++ ) { |
input[f].name = argv[f + 2]; |
printf( "opening file %d, \"%s\"\n", f, input[f].name ); |
/* open the file handle */ |
input[f].file = fopen( input[f].name, "rb" ); |
if( input[f].file == NULL ) { |
printf( "fopen() failed\n" ); |
return 1; |
} |
/* check if it's PNG */ |
if( fread( buf, 1, 8, input[f].file ) != 8 ) { |
printf( "fread() failed for file \"%s\"\n", input[f].name ); |
return 1; |
} |
if( png_sig_cmp( buf, (png_size_t)0, 8 ) ) { |
printf( "not a PNG file\n" ); |
return 1; |
} |
fseek( input[f].file, 0, SEEK_SET ); |
/* allocate read structure */ |
input[f].read_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
if( input[f].read_ptr == NULL ) { |
printf( "png_create_read_struct() failed\n" ); |
return 1; |
} |
/* allocate read info structure */ |
input[f].read_info_ptr = png_create_info_struct( input[f].read_ptr ); |
if( input[f].read_info_ptr == NULL ) { |
printf( "png_create_info_struct() failed\n" ); |
return 1; |
} |
/* set error handler code */ |
if( setjmp( input[f].read_ptr->jmpbuf ) ) { |
printf( "libpng read error\n" ); |
return 1; |
} |
/* initialize stream */ |
png_init_io( input[f].read_ptr, input[f].file ); |
png_set_read_status_fn( input[f].read_ptr, NULL ); |
/* read png info struct */ |
png_read_info( input[f].read_ptr, input[f].read_info_ptr ); |
/* get the info */ |
if( !png_get_IHDR( input[f].read_ptr, input[f].read_info_ptr, &w, &h, &bd, &clrt, &it, &ct, &ft ) ) { |
printf( "png_get_IHDR() failed\n" ); |
return 1; |
} |
/* save the info of the first frame */ |
if( f == 0 ) { |
width = w; |
height = h; |
bit_depth = bd; |
color_type = clrt; |
interlace_type = it; |
compression_type = ct; |
filter_type = ft; |
} |
/* compare all other frames to first frame */ |
else if( (w != width) || |
(h != height) || |
(bd != bit_depth) || |
(clrt != color_type) || |
(it != interlace_type) || |
(ct != compression_type) || |
(ft != filter_type) ) { |
if( w != width ) printf( "width is different\n" ); |
if( h != height ) printf( "height is different\n" ); |
if( bd != bit_depth ) printf( "bit depth is different\n" ); |
if( clrt != color_type ) printf( "color type is different\n" ); |
if( it != interlace_type ) printf( "interlace type is different\n" ); |
if( ct != compression_type ) printf( "compression type is different\n" ); |
if( ft != filter_type ) printf( "filter type is different\n" ); |
return 1; |
} |
} |
row_buf = (png_bytep)NULL; |
/* open output file */ |
printf( "opening file \"%s\"\n", argv[numfiles + 2] ); |
fpout = fopen( argv[numfiles + 2], "wb" ); |
if( fpout == NULL ) { |
printf( "fopen() failed\n" ); |
return 1; |
} |
/* allocate write structure */ |
write_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); |
/* allocate info structures */ |
write_info_ptr = png_create_info_struct( write_ptr ); |
end_info_ptr = png_create_info_struct( write_ptr ); |
/* error handling */ |
if( setjmp( write_ptr->jmpbuf ) ) { |
printf( "libpng write error\n" ); |
return 1; |
} |
/* initialize output stream */ |
png_init_io( write_ptr, fpout ); |
png_set_write_status_fn( write_ptr, NULL ); |
/* set info */ |
png_set_IHDR( write_ptr, write_info_ptr, width * numfiles, height, bit_depth, color_type, PNG_INTERLACE_NONE, compression_type, filter_type); |
/* image characteristics */ |
{ |
png_color_16p background; |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
double gamma; |
int intent; |
png_uint_16p hist; |
png_uint_32 offset_x, offset_y; |
int unit_type; |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
png_uint_32 res_x, res_y; |
png_colorp palette; |
int num_palette; |
png_color_8p sig_bit; |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
/* background color */ |
if( png_get_bKGD( input[0].read_ptr, input[0].read_info_ptr, &background ) ) { |
png_set_bKGD( write_ptr, write_info_ptr, background ); |
} |
if( png_get_cHRM( input[0].read_ptr, input[0].read_info_ptr, &white_x, &white_y, &red_x, &red_y, &green_x, &green_y, &blue_x, &blue_y ) ) { |
png_set_cHRM( write_ptr, write_info_ptr, white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y ); |
} |
/* gamma */ |
if( png_get_gAMA( input[0].read_ptr, input[0].read_info_ptr, &gamma ) ) { |
png_set_gAMA( write_ptr, write_info_ptr, gamma ); |
} |
/* rendering intent */ |
if( png_get_sRGB( input[0].read_ptr, input[0].read_info_ptr, &intent ) ) { |
png_set_sRGB( write_ptr, write_info_ptr, intent ); |
} |
/* Histogram */ |
if( png_get_hIST( input[0].read_ptr, input[0].read_info_ptr, &hist ) ) { |
png_set_hIST( write_ptr, write_info_ptr, hist ); |
} |
/* offsets */ |
if( png_get_oFFs( input[0].read_ptr, input[0].read_info_ptr, &offset_x, &offset_y, &unit_type ) ) { |
png_set_oFFs( write_ptr, write_info_ptr, offset_x, offset_y, unit_type ); |
} |
if( png_get_pCAL( input[0].read_ptr, input[0].read_info_ptr, &purpose, &X0, &X1, &type, &nparams, &units, ¶ms ) ) { |
png_set_pCAL( write_ptr, write_info_ptr, purpose, X0, X1, type, nparams, units, params ); |
} |
/* pixel density */ |
if( png_get_pHYs( input[0].read_ptr, input[0].read_info_ptr, &res_x, &res_y, &unit_type ) ) { |
png_set_pHYs( write_ptr, write_info_ptr, res_x, res_y, unit_type ); |
} |
/* text chunks */ |
/* if( png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) > 0 ) { |
printf( "Handling %d tEXt/zTXt chunks\n", num_text ); |
png_set_text( write_ptr, write_info_ptr, text_ptr, num_text ); |
} |
*/ |
/* palette */ |
if( png_get_PLTE( input[0].read_ptr, input[0].read_info_ptr, &palette, &num_palette ) ) { |
png_set_PLTE( write_ptr, write_info_ptr, palette, num_palette ); |
} |
/* significant bits */ |
if( png_get_sBIT( input[0].read_ptr, input[0].read_info_ptr, &sig_bit ) ) { |
png_set_sBIT( write_ptr, write_info_ptr, sig_bit ); |
} |
/* transparency */ |
if( png_get_tRNS( input[0].read_ptr, input[0].read_info_ptr, &trans, &num_trans, &trans_values ) ) { |
png_set_tRNS( write_ptr, write_info_ptr, trans, num_trans, trans_values ); |
} |
} |
/* text chunks */ |
num_text = 0; |
if( !png_get_text( input[0].read_ptr, input[0].read_info_ptr, &text_ptr, &num_text ) ) num_text = 0; |
new_text_ptr = (struct png_text_struct *)malloc( sizeof( struct png_text_struct ) * num_text + 1 ); |
if( !new_text_ptr ) { |
printf( "malloc() failed\n" ); |
return 1; |
} |
memcpy( new_text_ptr, text_ptr, sizeof( struct png_text_struct ) * num_text ); |
snprintf( buf, 255, "SDL_anim %d %d %d", duration, width, numfiles ); |
buf[255] = 0; |
new_text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE; |
new_text_ptr[num_text].key = "format"; |
new_text_ptr[num_text].text = buf; |
new_text_ptr[num_text].text_length = strlen( buf ); |
num_text++; |
png_set_text( write_ptr, write_info_ptr, new_text_ptr, num_text ); |
/* write info */ |
png_write_info( write_ptr, write_info_ptr ); |
/* allocate buffer */ |
rowbytes = png_get_rowbytes( input[0].read_ptr, input[0].read_info_ptr ); |
row_buf = (png_bytep)png_malloc( write_ptr, rowbytes * numfiles ); |
if( row_buf == NULL ) { |
printf( "png_malloc() failed\n" ); |
return 1; |
} |
/* copy raw data */ |
for( y = 0; y < height; y++ ) { |
/* grab a scanline from each file */ |
here = row_buf; |
for( f = 0; f < numfiles; f++ ) { |
png_read_rows( input[f].read_ptr, (png_bytepp)&here, (png_bytepp)NULL, 1 ); |
here += rowbytes; |
} |
/* write the long scanline */ |
png_write_rows( write_ptr, (png_bytepp)&row_buf, 1 ); |
} |
/* end io */ |
for( f = 0; f < numfiles; f++ ) png_read_end( input[f].read_ptr, end_info_ptr ); |
png_write_end( write_ptr, end_info_ptr ); |
/* cleanup */ |
png_free( write_ptr, row_buf ); |
for( f = 0; f < numfiles; f++ ) { |
png_destroy_read_struct( &input[f].read_ptr, &input[f].read_info_ptr, &end_info_ptr); |
fclose( input[f].file ); |
} |
png_destroy_write_struct( &write_ptr, &write_info_ptr ); |
fclose( fpout ); |
return 0; |
} |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/ship.ani |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2/SDL_anim-0.2.1/showanim.c |
---|
0,0 → 1,149 |
/* |
SDL_anim: an animation library for SDL |
Copyright (C) 2001, 2002 Michael Leonhard |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Michael Leonhard |
mike@tamale.net |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <SDL/SDL.h> |
#include "SDL_anim.h" |
/* Draw a Gimpish background pattern to show transparency in the anim */ |
void draw_background( SDL_Surface *screen ) { |
Uint8 *dst = screen->pixels; |
int x, y; |
int bpp = screen->format->BytesPerPixel; |
Uint32 col[2]; |
col[0] = SDL_MapRGB(screen->format, 0x66, 0x66, 0x66); |
col[1] = SDL_MapRGB(screen->format, 0x99, 0x99, 0x99); |
for(y = 0; y < screen->h; y++) { |
for(x = 0; x < screen->w; x++) { |
/* use an 8x8 checkerboard pattern */ |
Uint32 c = col[((x ^ y) >> 3) & 1]; |
switch(bpp) { |
case 1: |
dst[x] = c; |
break; |
case 2: |
((Uint16 *)dst)[x] = c; |
break; |
case 3: |
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { |
dst[x * 3] = c; |
dst[x * 3 + 1] = c >> 8; |
dst[x * 3 + 2] = c >> 16; |
} |
else { |
dst[x * 3] = c >> 16; |
dst[x * 3 + 1] = c >> 8; |
dst[x * 3 + 2] = c; |
} |
break; |
case 4: |
((Uint32 *)dst)[x] = c; |
break; |
} |
} |
dst += screen->pitch; |
} |
} |
int app_main(int argc, char *argv[]) { |
SDL_Surface *screen; |
SDL_Animation *anim; |
SDL_Rect rect; |
SDL_Event event; |
SDL_KeyboardEvent *key; |
int depth, done; |
Uint32 start; |
argv[1]="ship.ani"; |
/* Initialize the SDL library */ |
if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { |
fprintf( stderr, "Couldn't initialize SDL: %s\n", SDL_GetError() ); |
return 2; |
} |
/* Open the anim file */ |
anim = Anim_Load(argv[1]); |
if( anim == NULL ) { |
fprintf( stderr, "Couldn't load %s: %s\n", argv[1], SDL_GetError() ); |
SDL_Quit(); |
return 3; |
} |
SDL_WM_SetCaption( argv[1], "showanim" ); |
/* Create a display for the anim */ |
depth = SDL_VideoModeOK( anim->w + 1, anim->h, 32, SDL_HWPALETTE ); |
/* Use the deepest native mode, except that we emulate 32bpp for */ |
/* viewing non-indexed anims on 8bpp screens */ |
if( (anim->surface->format->BytesPerPixel > 1) && (depth == 8) ) { |
depth = 32; |
} |
screen = SDL_SetVideoMode( anim->w + 10, anim->h, 16, SDL_HWPALETTE ); |
if( screen == NULL ) { |
fprintf( stderr, "Couldn't set %dx%dx%d video mode: %s\n", |
anim->w, anim->h, depth, SDL_GetError() ); |
SDL_Quit(); |
return 4; |
} |
/* Set the palette, if one exists */ |
if( anim->surface->format->palette ) { |
SDL_SetColors( screen, anim->surface->format->palette->colors, |
0, anim->surface->format->palette->ncolors ); |
} |
if( !Anim_DisplayFormat( anim ) ) { |
fprintf( stderr, "Anim_DisplayFormat() failed\n" ); |
return 5; |
} |
done = 0; |
start = SDL_GetTicks(); |
while( !done ) { |
while( SDL_PollEvent( &event ) ) { |
switch( event.type ) { |
case SDL_QUIT: |
done = 1; |
break; |
case SDL_KEYDOWN: |
key = (SDL_KeyboardEvent *)&event; |
if( key->keysym.sym == SDLK_ESCAPE ) done = 1; |
start = SDL_GetTicks(); |
break; |
} |
} |
draw_background( screen ); |
rect.x = 0; |
rect.y = 0; |
Anim_BlitFrame( anim, start, SDL_GetTicks(), screen, &rect ); |
SDL_UpdateRect( screen, 0, 0, 0, 0 ); |
SDL_Delay( 100 ); |
} |
Anim_Free( anim ); |
SDL_Quit(); |
return 0; |
} |