mirror of
https://github.com/love2d/megasource.git
synced 2026-08-12 08:30:59 +02:00
Add SDL2_image 2.0.0.
This commit is contained in:
rude
@@ -0,0 +1,121 @@
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := SDL2_image
|
||||
|
||||
# Enable this if you want to support loading JPEG images
|
||||
# The library path should be a relative path to this directory.
|
||||
SUPPORT_JPG := true
|
||||
JPG_LIBRARY_PATH := external/jpeg-9
|
||||
|
||||
# Enable this if you want to support loading PNG images
|
||||
# The library path should be a relative path to this directory.
|
||||
SUPPORT_PNG := true
|
||||
PNG_LIBRARY_PATH := external/libpng-1.6.2
|
||||
|
||||
# Enable this if you want to support loading WebP images
|
||||
# The library path should be a relative path to this directory.
|
||||
SUPPORT_WEBP := true
|
||||
WEBP_LIBRARY_PATH := external/libwebp-0.3.0
|
||||
|
||||
|
||||
LOCAL_C_INCLUDES := $(LOCAL_PATH)
|
||||
LOCAL_CFLAGS := -DLOAD_BMP -DLOAD_GIF -DLOAD_LBM -DLOAD_PCX -DLOAD_PNM \
|
||||
-DLOAD_TGA -DLOAD_XCF -DLOAD_XPM -DLOAD_XV
|
||||
LOCAL_CFLAGS += -O3 -fstrict-aliasing -fprefetch-loop-arrays
|
||||
|
||||
LOCAL_SRC_FILES := $(notdir $(filter-out %/showimage.c, $(wildcard $(LOCAL_PATH)/*.c)))
|
||||
|
||||
LOCAL_LDLIBS :=
|
||||
LOCAL_STATIC_LIBRARIES :=
|
||||
LOCAL_SHARED_LIBRARIES := SDL2
|
||||
|
||||
ifeq ($(SUPPORT_JPG),true)
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/$(JPG_LIBRARY_PATH)
|
||||
LOCAL_CFLAGS += -DLOAD_JPG
|
||||
# We can include the sources directly so the user doesn't have to...
|
||||
#LOCAL_STATIC_LIBRARIES += jpeg
|
||||
LOCAL_CFLAGS += -DAVOID_TABLES
|
||||
LOCAL_SRC_FILES += \
|
||||
$(JPG_LIBRARY_PATH)/jaricom.c \
|
||||
$(JPG_LIBRARY_PATH)/jcapimin.c \
|
||||
$(JPG_LIBRARY_PATH)/jcapistd.c \
|
||||
$(JPG_LIBRARY_PATH)/jcarith.c \
|
||||
$(JPG_LIBRARY_PATH)/jccoefct.c \
|
||||
$(JPG_LIBRARY_PATH)/jccolor.c \
|
||||
$(JPG_LIBRARY_PATH)/jcdctmgr.c \
|
||||
$(JPG_LIBRARY_PATH)/jchuff.c \
|
||||
$(JPG_LIBRARY_PATH)/jcinit.c \
|
||||
$(JPG_LIBRARY_PATH)/jcmainct.c \
|
||||
$(JPG_LIBRARY_PATH)/jcmarker.c \
|
||||
$(JPG_LIBRARY_PATH)/jcmaster.c \
|
||||
$(JPG_LIBRARY_PATH)/jcomapi.c \
|
||||
$(JPG_LIBRARY_PATH)/jcparam.c \
|
||||
$(JPG_LIBRARY_PATH)/jcprepct.c \
|
||||
$(JPG_LIBRARY_PATH)/jcsample.c \
|
||||
$(JPG_LIBRARY_PATH)/jctrans.c \
|
||||
$(JPG_LIBRARY_PATH)/jdapimin.c \
|
||||
$(JPG_LIBRARY_PATH)/jdapistd.c \
|
||||
$(JPG_LIBRARY_PATH)/jdarith.c \
|
||||
$(JPG_LIBRARY_PATH)/jdatadst.c \
|
||||
$(JPG_LIBRARY_PATH)/jdatasrc.c \
|
||||
$(JPG_LIBRARY_PATH)/jdcoefct.c \
|
||||
$(JPG_LIBRARY_PATH)/jdcolor.c \
|
||||
$(JPG_LIBRARY_PATH)/jddctmgr.c \
|
||||
$(JPG_LIBRARY_PATH)/jdhuff.c \
|
||||
$(JPG_LIBRARY_PATH)/jdinput.c \
|
||||
$(JPG_LIBRARY_PATH)/jdmainct.c \
|
||||
$(JPG_LIBRARY_PATH)/jdmarker.c \
|
||||
$(JPG_LIBRARY_PATH)/jdmaster.c \
|
||||
$(JPG_LIBRARY_PATH)/jdmerge.c \
|
||||
$(JPG_LIBRARY_PATH)/jdpostct.c \
|
||||
$(JPG_LIBRARY_PATH)/jdsample.c \
|
||||
$(JPG_LIBRARY_PATH)/jdtrans.c \
|
||||
$(JPG_LIBRARY_PATH)/jerror.c \
|
||||
$(JPG_LIBRARY_PATH)/jfdctflt.c \
|
||||
$(JPG_LIBRARY_PATH)/jfdctfst.c \
|
||||
$(JPG_LIBRARY_PATH)/jfdctint.c \
|
||||
$(JPG_LIBRARY_PATH)/jidctflt.c \
|
||||
$(JPG_LIBRARY_PATH)/jidctfst.S \
|
||||
$(JPG_LIBRARY_PATH)/jidctint.c \
|
||||
$(JPG_LIBRARY_PATH)/jquant1.c \
|
||||
$(JPG_LIBRARY_PATH)/jquant2.c \
|
||||
$(JPG_LIBRARY_PATH)/jutils.c \
|
||||
$(JPG_LIBRARY_PATH)/jmemmgr.c \
|
||||
$(JPG_LIBRARY_PATH)/jmem-android.c
|
||||
endif
|
||||
|
||||
ifeq ($(SUPPORT_PNG),true)
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/$(PNG_LIBRARY_PATH)
|
||||
LOCAL_CFLAGS += -DLOAD_PNG
|
||||
# We can include the sources directly so the user doesn't have to...
|
||||
#LOCAL_STATIC_LIBRARIES += png
|
||||
LOCAL_SRC_FILES += \
|
||||
$(PNG_LIBRARY_PATH)/png.c \
|
||||
$(PNG_LIBRARY_PATH)/pngerror.c \
|
||||
$(PNG_LIBRARY_PATH)/pngget.c \
|
||||
$(PNG_LIBRARY_PATH)/pngmem.c \
|
||||
$(PNG_LIBRARY_PATH)/pngpread.c \
|
||||
$(PNG_LIBRARY_PATH)/pngread.c \
|
||||
$(PNG_LIBRARY_PATH)/pngrio.c \
|
||||
$(PNG_LIBRARY_PATH)/pngrtran.c \
|
||||
$(PNG_LIBRARY_PATH)/pngrutil.c \
|
||||
$(PNG_LIBRARY_PATH)/pngset.c \
|
||||
$(PNG_LIBRARY_PATH)/pngtrans.c \
|
||||
$(PNG_LIBRARY_PATH)/pngwio.c \
|
||||
$(PNG_LIBRARY_PATH)/pngwrite.c \
|
||||
$(PNG_LIBRARY_PATH)/pngwtran.c \
|
||||
$(PNG_LIBRARY_PATH)/pngwutil.c
|
||||
LOCAL_LDLIBS += -lz
|
||||
endif
|
||||
|
||||
ifeq ($(SUPPORT_WEBP),true)
|
||||
LOCAL_C_INCLUDES += $(LOCAL_PATH)/$(WEBP_LIBRARY_PATH)/src
|
||||
LOCAL_CFLAGS += -DLOAD_WEBP
|
||||
LOCAL_STATIC_LIBRARIES += webp
|
||||
endif
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDES += $(LOCAL_C_INCLUDES)
|
||||
|
||||
include $(BUILD_SHARED_LIBRARY)
|
||||
@@ -0,0 +1,114 @@
|
||||
2.0.0:
|
||||
Sam Lantinga - Sun Jun 2 22:25:31 PDT 2013
|
||||
* Added PNG save support based on miniz.c by Rich Geldreich
|
||||
IMG_SavePNG(), IMG_SavePNG_RW()
|
||||
Sam Lantinga - Sat Jun 1 19:11:26 PDT 2013
|
||||
* Updated for SDL 2.0 release
|
||||
Sam Lantinga - Sat Mar 23 13:36:51 PDT 2013
|
||||
* Fixed bug setting colorkey for indexed PNG images
|
||||
Torsten Stremlau - Sun Mar 10 10:19:25 PDT 2013
|
||||
* Added support for alpha and lossless WEBP images
|
||||
|
||||
1.2.12:
|
||||
mscott - 2012-02-06 19:40:23 PST
|
||||
* Fixed image corruption when using ImageIO framework
|
||||
Sylvain - Thu Nov 22 13:09:59 PST 2012
|
||||
* Added extended XPM color table (disabled by default in IMG_xpm.c)
|
||||
Sam Lantinga - Thu Jan 19 23:18:09 EST 2012
|
||||
* Fixed regression in 1.2.11 loading 8-bit PNG images with libpng
|
||||
|
||||
1.2.11:
|
||||
Sam Lantinga - Sat Jan 14 17:54:38 EST 2012
|
||||
* Fixed loading 8-bit PNG images on Mac OS X
|
||||
Sam Lantinga - Sat Dec 31 09:35:40 EST 2011
|
||||
* SDL_image is now under the zlib license
|
||||
Michael Bonfils - Mon Nov 28 21:46:00 EST 2011
|
||||
* Added WEBP image support
|
||||
Thomas Klausner - Wed Jan 19 19:31:25 PST 2011
|
||||
* Fixed compiling with libpng 1.4
|
||||
Sam Lantinga - Mon Jan 10 12:09:57 2011 -0800
|
||||
* Added Android.mk to build on the Android platform
|
||||
Sam Lantinga - Mon May 10 22:42:53 PDT 2010
|
||||
* Fixed loading HAM6 images with stencil mask
|
||||
Mark Tucker - Fri, 27 Nov 2009 12:38:21 -0500
|
||||
* Fixed bug loading 15 and 16 bit BMP images
|
||||
|
||||
1.2.10:
|
||||
Sam Lantinga - Sat Nov 14 11:22:14 PST 2009
|
||||
* Fixed bug loading multiple images
|
||||
|
||||
1.2.9:
|
||||
Sam Lantinga - Tue Nov 10 00:29:20 PST 2009
|
||||
* Fixed alpha premultiplication on Mac OS X and iPhone OS
|
||||
Sam Lantinga - Sun Nov 8 07:52:11 PST 2009
|
||||
* Fixed checking for IMG_Init() return value in image loaders
|
||||
|
||||
1.2.8:
|
||||
Sam Lantinga - Sun Oct 4 13:12:54 PDT 2009
|
||||
* Added support for uncompressed PCX files
|
||||
Mason Wheeler - 2009-06-10 06:29:45 PDT
|
||||
* Added IMG_Init()/IMG_Quit() to prevent constantly loading and unloading DLLs
|
||||
Couriersud - Mon, 12 Jan 2009 17:21:13 -0800
|
||||
* Added support for ICO and CUR image files
|
||||
Eric Wing - Fri, 2 Jan 2009 02:01:16 -0800
|
||||
* Added ImageIO loading infrastructure for Mac OS X
|
||||
* Added UIImage loading infrastructure for iPhone / iPod Touch
|
||||
|
||||
1.2.7:
|
||||
Sam Lantinga - Sun Nov 2 15:08:27 PST 2008
|
||||
* Fixed buffer overflow in BMP loading code, discovered by j00ru//vx
|
||||
Sam Lantinga - Fri Dec 28 08:34:54 PST 2007
|
||||
* Fixed buffer overflow in GIF loading code, discovered by Michael Skladnikiewicz
|
||||
|
||||
1.2.6:
|
||||
Sam lantinga - Wed Jul 18 00:30:32 PDT 2007
|
||||
* Improved detection of libjpeg, libpng, and libtiff at configure time
|
||||
* PNG and TIFF images are correctly identified even if dynamic libraries
|
||||
to load them aren't available.
|
||||
* Fixed loading of TIFF images using libtiff 3.6
|
||||
Sam Lantinga - Thu Jul 5 07:52:35 2007
|
||||
* Fixed static linking with libjpeg
|
||||
Michael Koch - Tue Feb 13 10:09:17 2007
|
||||
* Fixed crash in IMG_ReadXPMFromArray()
|
||||
|
||||
1.2.5:
|
||||
Maurizio Monge - Sun May 14 13:57:32 PDT 2006
|
||||
* Fixed loading BMP palettes at unusual offsets
|
||||
Sam Lantinga - Thu May 11 21:51:19 PDT 2006
|
||||
* Added support for dynamically loading libjpeg, libpng, and libtiff.
|
||||
Sam Lantinga - Sun Apr 30 01:48:40 PDT 2006
|
||||
* Added gcc-fat.sh for generating Universal binaries on Mac OS X
|
||||
* Updated libtool support to version 1.5.22
|
||||
Sam Lantinga - Sat Feb 4 15:17:44 PST 2006
|
||||
* Added support for XV thumbnail images
|
||||
Gautier Portet - Fri, 19 Mar 2004 17:35:12 +0100
|
||||
* Added support for 32-bit BMP files with alpha
|
||||
|
||||
1.2.4:
|
||||
Pierre G. Richard - Fri, 30 Jul 2004 11:13:11 +0000 (UTC)
|
||||
* Added support for RLE encoded BMP files
|
||||
Marc Le Douarain - Fri, 26 Dec 2003 18:23:42 +0100
|
||||
* Added EHB and HAM mode support to the ILBM loader
|
||||
Sam Lantinga - Wed Nov 19 00:23:44 PST 2003
|
||||
* Updated libtool support for new mingw32 DLL build process
|
||||
Holger Schemel - Mon, 04 Aug 2003 21:50:52 +0200
|
||||
* Fixed crash loading certain PCX images
|
||||
Kyle Davenport - Sat, 19 Apr 2003 17:13:31 -0500
|
||||
* Added .la files to the development RPM, fixing RPM build on RedHat 8
|
||||
|
||||
1.2.3:
|
||||
Ryan C. Gordon - Sat, 8 Feb 2003 09:36:33 -0500
|
||||
* Fixed memory leak with non-seekable SDL_RWops
|
||||
Marc Le Douarain - Sun, 22 Dec 2002 22:59:51 +0100
|
||||
* Added 24-bit support to the ILBM format loader
|
||||
Sam Lantinga - Sun Oct 20 20:55:46 PDT 2002
|
||||
* Added shared library support for MacOS X
|
||||
Pete Shinners - Thu Jun 20 10:05:54 PDT 2002
|
||||
* The JPEG loader can now load EXIF format JPEG images
|
||||
Dag-Erling Smorgrav - Thu May 2 19:09:48 PDT 2002
|
||||
* The XCF loader now ignores invisible layers and channels
|
||||
|
||||
1.2.2:
|
||||
Sam Lantinga - Sat Apr 13 07:49:47 PDT 2002
|
||||
* Updated autogen.sh for new versions of automake
|
||||
* Specify the SDL API calling convention (C by default)
|
||||
@@ -0,0 +1,20 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
@@ -0,0 +1,239 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* A simple library to load images of various formats as SDL surfaces */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#define ARRAYSIZE(a) (sizeof(a) / sizeof((a)[0]))
|
||||
|
||||
/* Table of image detection and loading functions */
|
||||
static struct {
|
||||
char *type;
|
||||
int (SDLCALL *is)(SDL_RWops *src);
|
||||
SDL_Surface *(SDLCALL *load)(SDL_RWops *src);
|
||||
} supported[] = {
|
||||
/* keep magicless formats first */
|
||||
{ "TGA", NULL, IMG_LoadTGA_RW },
|
||||
{ "CUR", IMG_isCUR, IMG_LoadCUR_RW },
|
||||
{ "ICO", IMG_isICO, IMG_LoadICO_RW },
|
||||
{ "BMP", IMG_isBMP, IMG_LoadBMP_RW },
|
||||
{ "GIF", IMG_isGIF, IMG_LoadGIF_RW },
|
||||
{ "JPG", IMG_isJPG, IMG_LoadJPG_RW },
|
||||
{ "LBM", IMG_isLBM, IMG_LoadLBM_RW },
|
||||
{ "PCX", IMG_isPCX, IMG_LoadPCX_RW },
|
||||
{ "PNG", IMG_isPNG, IMG_LoadPNG_RW },
|
||||
{ "PNM", IMG_isPNM, IMG_LoadPNM_RW }, /* P[BGP]M share code */
|
||||
{ "TIF", IMG_isTIF, IMG_LoadTIF_RW },
|
||||
{ "XCF", IMG_isXCF, IMG_LoadXCF_RW },
|
||||
{ "XPM", IMG_isXPM, IMG_LoadXPM_RW },
|
||||
{ "XV", IMG_isXV, IMG_LoadXV_RW },
|
||||
{ "WEBP", IMG_isWEBP, IMG_LoadWEBP_RW },
|
||||
};
|
||||
|
||||
const SDL_version *IMG_Linked_Version(void)
|
||||
{
|
||||
static SDL_version linked_version;
|
||||
SDL_IMAGE_VERSION(&linked_version);
|
||||
return(&linked_version);
|
||||
}
|
||||
|
||||
extern int IMG_InitJPG();
|
||||
extern void IMG_QuitJPG();
|
||||
extern int IMG_InitPNG();
|
||||
extern void IMG_QuitPNG();
|
||||
extern int IMG_InitTIF();
|
||||
extern void IMG_QuitTIF();
|
||||
|
||||
extern int IMG_InitWEBP();
|
||||
extern void IMG_QuitWEBP();
|
||||
|
||||
static int initialized = 0;
|
||||
|
||||
int IMG_Init(int flags)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
if (flags & IMG_INIT_JPG) {
|
||||
if ((initialized & IMG_INIT_JPG) || IMG_InitJPG() == 0) {
|
||||
result |= IMG_INIT_JPG;
|
||||
}
|
||||
}
|
||||
if (flags & IMG_INIT_PNG) {
|
||||
if ((initialized & IMG_INIT_PNG) || IMG_InitPNG() == 0) {
|
||||
result |= IMG_INIT_PNG;
|
||||
}
|
||||
}
|
||||
if (flags & IMG_INIT_TIF) {
|
||||
if ((initialized & IMG_INIT_TIF) || IMG_InitTIF() == 0) {
|
||||
result |= IMG_INIT_TIF;
|
||||
}
|
||||
}
|
||||
if (flags & IMG_INIT_WEBP) {
|
||||
if ((initialized & IMG_INIT_WEBP) || IMG_InitWEBP() == 0) {
|
||||
result |= IMG_INIT_WEBP;
|
||||
}
|
||||
}
|
||||
initialized |= result;
|
||||
|
||||
return (initialized);
|
||||
}
|
||||
|
||||
void IMG_Quit()
|
||||
{
|
||||
if (initialized & IMG_INIT_JPG) {
|
||||
IMG_QuitJPG();
|
||||
}
|
||||
if (initialized & IMG_INIT_PNG) {
|
||||
IMG_QuitPNG();
|
||||
}
|
||||
if (initialized & IMG_INIT_TIF) {
|
||||
IMG_QuitTIF();
|
||||
}
|
||||
if (initialized & IMG_INIT_WEBP) {
|
||||
IMG_QuitWEBP();
|
||||
}
|
||||
initialized = 0;
|
||||
}
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
/* Load an image from a file */
|
||||
SDL_Surface *IMG_Load(const char *file)
|
||||
{
|
||||
SDL_RWops *src = SDL_RWFromFile(file, "rb");
|
||||
const char *ext = strrchr(file, '.');
|
||||
if(ext) {
|
||||
ext++;
|
||||
}
|
||||
if(!src) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
return IMG_LoadTyped_RW(src, 1, ext);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Load an image from an SDL datasource (for compatibility) */
|
||||
SDL_Surface *IMG_Load_RW(SDL_RWops *src, int freesrc)
|
||||
{
|
||||
return IMG_LoadTyped_RW(src, freesrc, NULL);
|
||||
}
|
||||
|
||||
/* Portable case-insensitive string compare function */
|
||||
static int IMG_string_equals(const char *str1, const char *str2)
|
||||
{
|
||||
while ( *str1 && *str2 ) {
|
||||
if ( toupper((unsigned char)*str1) !=
|
||||
toupper((unsigned char)*str2) )
|
||||
break;
|
||||
++str1;
|
||||
++str2;
|
||||
}
|
||||
return (!*str1 && !*str2);
|
||||
}
|
||||
|
||||
/* Load an image from an SDL datasource, optionally specifying the type */
|
||||
SDL_Surface *IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, const char *type)
|
||||
{
|
||||
int i;
|
||||
SDL_Surface *image;
|
||||
|
||||
/* Make sure there is something to do.. */
|
||||
if ( src == NULL ) {
|
||||
IMG_SetError("Passed a NULL data source");
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/* See whether or not this data source can handle seeking */
|
||||
if ( SDL_RWseek(src, 0, RW_SEEK_CUR) < 0 ) {
|
||||
IMG_SetError("Can't seek in this data source");
|
||||
if(freesrc)
|
||||
SDL_RWclose(src);
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/* Detect the type of image being loaded */
|
||||
image = NULL;
|
||||
for ( i=0; i < ARRAYSIZE(supported); ++i ) {
|
||||
if(supported[i].is) {
|
||||
if(!supported[i].is(src))
|
||||
continue;
|
||||
} else {
|
||||
/* magicless format */
|
||||
if(!type
|
||||
|| !IMG_string_equals(type, supported[i].type))
|
||||
continue;
|
||||
}
|
||||
#ifdef DEBUG_IMGLIB
|
||||
fprintf(stderr, "IMGLIB: Loading image as %s\n",
|
||||
supported[i].type);
|
||||
#endif
|
||||
image = supported[i].load(src);
|
||||
if(freesrc)
|
||||
SDL_RWclose(src);
|
||||
return image;
|
||||
}
|
||||
|
||||
if ( freesrc ) {
|
||||
SDL_RWclose(src);
|
||||
}
|
||||
IMG_SetError("Unsupported image format");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#if SDL_VERSION_ATLEAST(2,0,0)
|
||||
SDL_Texture *IMG_LoadTexture(SDL_Renderer *renderer, const char *file)
|
||||
{
|
||||
SDL_Texture *texture = NULL;
|
||||
SDL_Surface *surface = IMG_Load(file);
|
||||
if (surface) {
|
||||
texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
return texture;
|
||||
}
|
||||
|
||||
SDL_Texture *IMG_LoadTexture_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc)
|
||||
{
|
||||
SDL_Texture *texture = NULL;
|
||||
SDL_Surface *surface = IMG_Load_RW(src, freesrc);
|
||||
if (surface) {
|
||||
texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
return texture;
|
||||
}
|
||||
|
||||
SDL_Texture *IMG_LoadTextureTyped_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc, const char *type)
|
||||
{
|
||||
SDL_Texture *texture = NULL;
|
||||
SDL_Surface *surface = IMG_LoadTyped_RW(src, freesrc, type);
|
||||
if (surface) {
|
||||
texture = SDL_CreateTextureFromSurface(renderer, surface);
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
return texture;
|
||||
}
|
||||
#endif /* SDL 2.0 */
|
||||
@@ -0,0 +1,803 @@
|
||||
/*
|
||||
* IMG_ImageIO.c
|
||||
* SDL_image
|
||||
*
|
||||
* Created by Eric Wing on 1/1/09.
|
||||
* Copyright 2009 __MyCompanyName__. All rights reserved.
|
||||
*
|
||||
*/
|
||||
|
||||
#if defined(__APPLE__) && !defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
// Used because CGDataProviderCreate became deprecated in 10.5
|
||||
#include <AvailabilityMacros.h>
|
||||
#include <TargetConditionals.h>
|
||||
#include <Foundation/Foundation.h>
|
||||
|
||||
#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
|
||||
#ifdef ALLOW_UIIMAGE_FALLBACK
|
||||
#define USE_UIIMAGE_BACKEND() ([UIImage instancesRespondToSelector:@selector(initWithCGImage:scale:orientation:)] == NO)
|
||||
#else
|
||||
#define USE_UIIMAGE_BACKEND() (Internal_checkImageIOisAvailable())
|
||||
#endif
|
||||
#import <MobileCoreServices/MobileCoreServices.h> // for UTCoreTypes.h
|
||||
#import <ImageIO/ImageIO.h>
|
||||
#import <UIKit/UIImage.h>
|
||||
#else
|
||||
// For ImageIO framework and also LaunchServices framework (for UTIs)
|
||||
#include <ApplicationServices/ApplicationServices.h>
|
||||
#endif
|
||||
|
||||
/**************************************************************
|
||||
***** Begin Callback functions for block reading *************
|
||||
**************************************************************/
|
||||
|
||||
// This callback reads some bytes from an SDL_rwops and copies it
|
||||
// to a Quartz buffer (supplied by Apple framework).
|
||||
static size_t MyProviderGetBytesCallback(void* rwops_userdata, void* quartz_buffer, size_t the_count)
|
||||
{
|
||||
return (size_t)SDL_RWread((struct SDL_RWops *)rwops_userdata, quartz_buffer, 1, the_count);
|
||||
}
|
||||
|
||||
// This callback is triggered when the data provider is released
|
||||
// so you can clean up any resources.
|
||||
static void MyProviderReleaseInfoCallback(void* rwops_userdata)
|
||||
{
|
||||
// What should I put here?
|
||||
// I think the user and SDL_RWops controls closing, so I don't do anything.
|
||||
}
|
||||
|
||||
static void MyProviderRewindCallback(void* rwops_userdata)
|
||||
{
|
||||
SDL_RWseek((struct SDL_RWops *)rwops_userdata, 0, RW_SEEK_SET);
|
||||
}
|
||||
|
||||
#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 // CGDataProviderCreateSequential was introduced in 10.5; CGDataProviderCreate is deprecated
|
||||
off_t MyProviderSkipForwardBytesCallback(void* rwops_userdata, off_t the_count)
|
||||
{
|
||||
off_t start_position = SDL_RWtell((struct SDL_RWops *)rwops_userdata);
|
||||
SDL_RWseek((struct SDL_RWops *)rwops_userdata, the_count, RW_SEEK_CUR);
|
||||
off_t end_position = SDL_RWtell((struct SDL_RWops *)rwops_userdata);
|
||||
return (end_position - start_position);
|
||||
}
|
||||
#else // CGDataProviderCreate was deprecated in 10.5
|
||||
static void MyProviderSkipBytesCallback(void* rwops_userdata, size_t the_count)
|
||||
{
|
||||
SDL_RWseek((struct SDL_RWops *)rwops_userdata, the_count, RW_SEEK_CUR);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**************************************************************
|
||||
***** End Callback functions for block reading ***************
|
||||
**************************************************************/
|
||||
|
||||
// This creates a CGImageSourceRef which is a handle to an image that can be used to examine information
|
||||
// about the image or load the actual image data.
|
||||
static CGImageSourceRef CreateCGImageSourceFromRWops(SDL_RWops* rw_ops, CFDictionaryRef hints_and_options)
|
||||
{
|
||||
CGImageSourceRef source_ref;
|
||||
|
||||
// Similar to SDL_RWops, Apple has their own callbacks for dealing with data streams.
|
||||
|
||||
#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 // CGDataProviderCreateSequential was introduced in 10.5; CGDataProviderCreate is deprecated
|
||||
CGDataProviderSequentialCallbacks provider_callbacks =
|
||||
{
|
||||
0,
|
||||
MyProviderGetBytesCallback,
|
||||
MyProviderSkipForwardBytesCallback,
|
||||
MyProviderRewindCallback,
|
||||
MyProviderReleaseInfoCallback
|
||||
};
|
||||
|
||||
CGDataProviderRef data_provider = CGDataProviderCreateSequential(rw_ops, &provider_callbacks);
|
||||
|
||||
|
||||
#else // CGDataProviderCreate was deprecated in 10.5
|
||||
|
||||
CGDataProviderCallbacks provider_callbacks =
|
||||
{
|
||||
MyProviderGetBytesCallback,
|
||||
MyProviderSkipBytesCallback,
|
||||
MyProviderRewindCallback,
|
||||
MyProviderReleaseInfoCallback
|
||||
};
|
||||
|
||||
CGDataProviderRef data_provider = CGDataProviderCreate(rw_ops, &provider_callbacks);
|
||||
#endif
|
||||
// Get the CGImageSourceRef.
|
||||
// The dictionary can be NULL or contain hints to help ImageIO figure out the image type.
|
||||
source_ref = CGImageSourceCreateWithDataProvider(data_provider, hints_and_options);
|
||||
CGDataProviderRelease(data_provider);
|
||||
return source_ref;
|
||||
}
|
||||
|
||||
/* Create a CGImageSourceRef from a file. */
|
||||
/* Remember to CFRelease the created source when done. */
|
||||
static CGImageSourceRef CreateCGImageSourceFromFile(const char* the_path)
|
||||
{
|
||||
CFURLRef the_url = NULL;
|
||||
CGImageSourceRef source_ref = NULL;
|
||||
CFStringRef cf_string = NULL;
|
||||
|
||||
/* Create a CFString from a C string */
|
||||
cf_string = CFStringCreateWithCString(NULL, the_path, kCFStringEncodingUTF8);
|
||||
if (!cf_string) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create a CFURL from a CFString */
|
||||
the_url = CFURLCreateWithFileSystemPath(NULL, cf_string, kCFURLPOSIXPathStyle, false);
|
||||
|
||||
/* Don't need the CFString any more (error or not) */
|
||||
CFRelease(cf_string);
|
||||
|
||||
if(!the_url)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
source_ref = CGImageSourceCreateWithURL(the_url, NULL);
|
||||
/* Don't need the URL any more (error or not) */
|
||||
CFRelease(the_url);
|
||||
|
||||
return source_ref;
|
||||
}
|
||||
|
||||
static CGImageRef CreateCGImageFromCGImageSource(CGImageSourceRef image_source)
|
||||
{
|
||||
CGImageRef image_ref = NULL;
|
||||
|
||||
if(NULL == image_source)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Get the first item in the image source (some image formats may
|
||||
// contain multiple items).
|
||||
image_ref = CGImageSourceCreateImageAtIndex(image_source, 0, NULL);
|
||||
if(NULL == image_ref)
|
||||
{
|
||||
IMG_SetError("CGImageSourceCreateImageAtIndex() failed");
|
||||
}
|
||||
return image_ref;
|
||||
}
|
||||
|
||||
static CFDictionaryRef CreateHintDictionary(CFStringRef uti_string_hint)
|
||||
{
|
||||
CFDictionaryRef hint_dictionary = NULL;
|
||||
|
||||
if(uti_string_hint != NULL)
|
||||
{
|
||||
// Do a bunch of work to setup a CFDictionary containing the jpeg compression properties.
|
||||
CFStringRef the_keys[1];
|
||||
CFStringRef the_values[1];
|
||||
|
||||
the_keys[0] = kCGImageSourceTypeIdentifierHint;
|
||||
the_values[0] = uti_string_hint;
|
||||
|
||||
// kCFTypeDictionaryKeyCallBacks or kCFCopyStringDictionaryKeyCallBacks?
|
||||
hint_dictionary = CFDictionaryCreate(NULL, (const void**)&the_keys, (const void**)&the_values, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
|
||||
}
|
||||
return hint_dictionary;
|
||||
}
|
||||
|
||||
// Once we have our image, we need to get it into an SDL_Surface
|
||||
static SDL_Surface* Create_SDL_Surface_From_CGImage_RGB(CGImageRef image_ref)
|
||||
{
|
||||
/* This code is adapted from Apple's Documentation found here:
|
||||
* http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/index.html
|
||||
* Listing 9-4††Using a Quartz image as a texture source.
|
||||
* Unfortunately, this guide doesn't show what to do about
|
||||
* non-RGBA image formats so I'm making the rest up.
|
||||
* All this code should be scrutinized.
|
||||
*/
|
||||
|
||||
size_t w = CGImageGetWidth(image_ref);
|
||||
size_t h = CGImageGetHeight(image_ref);
|
||||
CGRect rect = {{0, 0}, {w, h}};
|
||||
|
||||
CGImageAlphaInfo alpha = CGImageGetAlphaInfo(image_ref);
|
||||
//size_t bits_per_pixel = CGImageGetBitsPerPixel(image_ref);
|
||||
size_t bits_per_component = 8;
|
||||
|
||||
SDL_Surface* surface;
|
||||
Uint32 Amask;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
|
||||
CGContextRef bitmap_context;
|
||||
CGBitmapInfo bitmap_info;
|
||||
|
||||
/* This sets up a color space that results in identical values
|
||||
* as the image data itself, which is the same as the standalone
|
||||
* libpng loader.
|
||||
* Thanks to Allegro. :)
|
||||
*/
|
||||
CGFloat whitePoint[3] = { 0.950, 1.000, 1.089 };
|
||||
CGFloat blackPoint[3] = { 0.000, 0.000, 0.000 };
|
||||
CGFloat gamma[3] = { 2.2, 2.2, 2.2 };
|
||||
CGFloat matrix[9] = {
|
||||
0.412, 0.213, 0.019,
|
||||
0.358, 0.715, 0.119,
|
||||
0.180, 0.072, 0.950
|
||||
};
|
||||
CGColorSpaceRef color_space =
|
||||
CGColorSpaceCreateCalibratedRGB(
|
||||
whitePoint, blackPoint, gamma, matrix
|
||||
);
|
||||
|
||||
if (alpha == kCGImageAlphaNone ||
|
||||
alpha == kCGImageAlphaNoneSkipFirst ||
|
||||
alpha == kCGImageAlphaNoneSkipLast) {
|
||||
bitmap_info = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host; /* XRGB */
|
||||
Amask = 0x00000000;
|
||||
} else {
|
||||
/* kCGImageAlphaFirst isn't supported */
|
||||
//bitmap_info = kCGImageAlphaFirst | kCGBitmapByteOrder32Host; /* ARGB */
|
||||
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host; /* ARGB */
|
||||
Amask = 0xFF000000;
|
||||
}
|
||||
|
||||
Rmask = 0x00FF0000;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x000000FF;
|
||||
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, Rmask, Gmask, Bmask, Amask);
|
||||
if (surface)
|
||||
{
|
||||
// Sets up a context to be drawn to with surface->pixels as the area to be drawn to
|
||||
bitmap_context = CGBitmapContextCreate(
|
||||
surface->pixels,
|
||||
surface->w,
|
||||
surface->h,
|
||||
bits_per_component,
|
||||
surface->pitch,
|
||||
color_space,
|
||||
bitmap_info
|
||||
);
|
||||
|
||||
// Draws the image into the context's image_data
|
||||
CGContextDrawImage(bitmap_context, rect, image_ref);
|
||||
|
||||
CGContextRelease(bitmap_context);
|
||||
|
||||
// FIXME: Reverse the premultiplied alpha
|
||||
if ((bitmap_info & kCGBitmapAlphaInfoMask) == kCGImageAlphaPremultipliedFirst) {
|
||||
int i, j;
|
||||
Uint8 *p = (Uint8 *)surface->pixels;
|
||||
for (i = surface->h * surface->pitch/4; i--; ) {
|
||||
#if __LITTLE_ENDIAN__
|
||||
Uint8 A = p[3];
|
||||
if (A) {
|
||||
for (j = 0; j < 3; ++j) {
|
||||
p[j] = (p[j] * 255) / A;
|
||||
}
|
||||
}
|
||||
#else
|
||||
Uint8 A = p[0];
|
||||
if (A) {
|
||||
for (j = 1; j < 4; ++j) {
|
||||
p[j] = (p[j] * 255) / A;
|
||||
}
|
||||
}
|
||||
#endif /* ENDIAN */
|
||||
p += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (color_space)
|
||||
{
|
||||
CGColorSpaceRelease(color_space);
|
||||
}
|
||||
|
||||
return surface;
|
||||
}
|
||||
static SDL_Surface* Create_SDL_Surface_From_CGImage_Index(CGImageRef image_ref)
|
||||
{
|
||||
size_t w = CGImageGetWidth(image_ref);
|
||||
size_t h = CGImageGetHeight(image_ref);
|
||||
size_t bits_per_pixel = CGImageGetBitsPerPixel(image_ref);
|
||||
size_t bytes_per_row = CGImageGetBytesPerRow(image_ref);
|
||||
|
||||
SDL_Surface* surface;
|
||||
SDL_Palette* palette;
|
||||
CGColorSpaceRef color_space = CGImageGetColorSpace(image_ref);
|
||||
CGColorSpaceRef base_color_space = CGColorSpaceGetBaseColorSpace(color_space);
|
||||
size_t num_components = CGColorSpaceGetNumberOfComponents(base_color_space);
|
||||
size_t num_entries = CGColorSpaceGetColorTableCount(color_space);
|
||||
uint8_t *entry, entries[num_components * num_entries];
|
||||
|
||||
/* What do we do if it's not RGB? */
|
||||
if (num_components != 3) {
|
||||
SDL_SetError("Unknown colorspace components %lu", num_components);
|
||||
return NULL;
|
||||
}
|
||||
if (bits_per_pixel != 8) {
|
||||
SDL_SetError("Unknown bits_per_pixel %lu", bits_per_pixel);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CGColorSpaceGetColorTable(color_space, entries);
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, bits_per_pixel, 0, 0, 0, 0);
|
||||
if (surface) {
|
||||
uint8_t* pixels = (uint8_t*)surface->pixels;
|
||||
CGDataProviderRef provider = CGImageGetDataProvider(image_ref);
|
||||
NSData* data = (id)CGDataProviderCopyData(provider);
|
||||
[data autorelease];
|
||||
const uint8_t* bytes = [data bytes];
|
||||
size_t i;
|
||||
|
||||
palette = surface->format->palette;
|
||||
for (i = 0, entry = entries; i < num_entries; ++i) {
|
||||
palette->colors[i].r = entry[0];
|
||||
palette->colors[i].g = entry[1];
|
||||
palette->colors[i].b = entry[2];
|
||||
entry += num_components;
|
||||
}
|
||||
|
||||
for (i = 0; i < h; ++i) {
|
||||
SDL_memcpy(pixels, bytes, w);
|
||||
pixels += surface->pitch;
|
||||
bytes += bytes_per_row;
|
||||
}
|
||||
}
|
||||
return surface;
|
||||
}
|
||||
static SDL_Surface* Create_SDL_Surface_From_CGImage(CGImageRef image_ref)
|
||||
{
|
||||
CGColorSpaceRef color_space = CGImageGetColorSpace(image_ref);
|
||||
if (CGColorSpaceGetModel(color_space) == kCGColorSpaceModelIndexed) {
|
||||
return Create_SDL_Surface_From_CGImage_Index(image_ref);
|
||||
} else {
|
||||
return Create_SDL_Surface_From_CGImage_RGB(image_ref);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#pragma mark -
|
||||
#pragma mark IMG_Init stubs
|
||||
#if !defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1))
|
||||
static int Internal_checkImageIOisAvailable() {
|
||||
// just check if we are running on ios 4 or more, else throw exception
|
||||
if ([UIImage instancesRespondToSelector:@selector(initWithCGImage:scale:orientation:)])
|
||||
return 0;
|
||||
[NSException raise:@"UIImage fallback not enabled at compile time"
|
||||
format:@"ImageIO is not available on your platform, please recompile SDL_Image with ALLOW_UIIMAGE_FALLBACK."];
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
|
||||
int IMG_InitJPG()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitJPG()
|
||||
{
|
||||
}
|
||||
|
||||
int IMG_InitPNG()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitPNG()
|
||||
{
|
||||
}
|
||||
|
||||
int IMG_InitTIF()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitTIF()
|
||||
{
|
||||
}
|
||||
|
||||
#pragma mark -
|
||||
#pragma mark Get type of image
|
||||
static int Internal_isType_UIImage (SDL_RWops *rw_ops, CFStringRef uti_string_to_test)
|
||||
{
|
||||
int is_type = 0;
|
||||
|
||||
#if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1))
|
||||
int start = SDL_RWtell(rw_ops);
|
||||
if ((0 == CFStringCompare(uti_string_to_test, kUTTypeICO, 0)) ||
|
||||
(0 == CFStringCompare(uti_string_to_test, CFSTR("com.microsoft.cur"), 0))) {
|
||||
|
||||
// The Win32 ICO file header (14 bytes)
|
||||
Uint16 bfReserved;
|
||||
Uint16 bfType;
|
||||
Uint16 bfCount;
|
||||
int type = (0 == CFStringCompare(uti_string_to_test, kUTTypeICO, 0)) ? 1 : 2;
|
||||
|
||||
bfReserved = SDL_ReadLE16(rw_ops);
|
||||
bfType = SDL_ReadLE16(rw_ops);
|
||||
bfCount = SDL_ReadLE16(rw_ops);
|
||||
if ((bfReserved == 0) && (bfType == type) && (bfCount != 0))
|
||||
is_type = 1;
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, kUTTypeBMP, 0)) {
|
||||
char magic[2];
|
||||
|
||||
if ( SDL_RWread(rw_ops, magic, sizeof(magic), 1) ) {
|
||||
if ( strncmp(magic, "BM", 2) == 0 ) {
|
||||
is_type = 1;
|
||||
}
|
||||
}
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, kUTTypeGIF, 0)) {
|
||||
char magic[6];
|
||||
|
||||
if ( SDL_RWread(rw_ops, magic, sizeof(magic), 1) ) {
|
||||
if ( (strncmp(magic, "GIF", 3) == 0) &&
|
||||
((memcmp(magic + 3, "87a", 3) == 0) ||
|
||||
(memcmp(magic + 3, "89a", 3) == 0)) ) {
|
||||
is_type = 1;
|
||||
}
|
||||
}
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, kUTTypeJPEG, 0)) {
|
||||
int in_scan = 0;
|
||||
Uint8 magic[4];
|
||||
|
||||
// This detection code is by Steaphan Greene <stea@cs.binghamton.edu>
|
||||
// Blame me, not Sam, if this doesn't work right. */
|
||||
// And don't forget to report the problem to the the sdl list too! */
|
||||
|
||||
if ( SDL_RWread(rw_ops, magic, 2, 1) ) {
|
||||
if ( (magic[0] == 0xFF) && (magic[1] == 0xD8) ) {
|
||||
is_type = 1;
|
||||
while (is_type == 1) {
|
||||
if(SDL_RWread(rw_ops, magic, 1, 2) != 2) {
|
||||
is_type = 0;
|
||||
} else if( (magic[0] != 0xFF) && (in_scan == 0) ) {
|
||||
is_type = 0;
|
||||
} else if( (magic[0] != 0xFF) || (magic[1] == 0xFF) ) {
|
||||
/* Extra padding in JPEG (legal) */
|
||||
/* or this is data and we are scanning */
|
||||
SDL_RWseek(rw_ops, -1, SEEK_CUR);
|
||||
} else if(magic[1] == 0xD9) {
|
||||
/* Got to end of good JPEG */
|
||||
break;
|
||||
} else if( (in_scan == 1) && (magic[1] == 0x00) ) {
|
||||
/* This is an encoded 0xFF within the data */
|
||||
} else if( (magic[1] >= 0xD0) && (magic[1] < 0xD9) ) {
|
||||
/* These have nothing else */
|
||||
} else if(SDL_RWread(rw_ops, magic+2, 1, 2) != 2) {
|
||||
is_type = 0;
|
||||
} else {
|
||||
/* Yes, it's big-endian */
|
||||
Uint32 start;
|
||||
Uint32 size;
|
||||
Uint32 end;
|
||||
start = SDL_RWtell(rw_ops);
|
||||
size = (magic[2] << 8) + magic[3];
|
||||
end = SDL_RWseek(rw_ops, size-2, SEEK_CUR);
|
||||
if ( end != start + size - 2 ) is_type = 0;
|
||||
if ( magic[1] == 0xDA ) {
|
||||
/* Now comes the actual JPEG meat */
|
||||
#ifdef FAST_IS_JPEG
|
||||
/* Ok, I'm convinced. It is a JPEG. */
|
||||
break;
|
||||
#else
|
||||
/* I'm not convinced. Prove it! */
|
||||
in_scan = 1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, kUTTypePNG, 0)) {
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( SDL_RWread(rw_ops, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( magic[0] == 0x89 &&
|
||||
magic[1] == 'P' &&
|
||||
magic[2] == 'N' &&
|
||||
magic[3] == 'G' ) {
|
||||
is_type = 1;
|
||||
}
|
||||
}
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, CFSTR("com.truevision.tga-image"), 0)) {
|
||||
//TODO: fill me!
|
||||
} else if (0 == CFStringCompare(uti_string_to_test, kUTTypeTIFF, 0)) {
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( SDL_RWread(rw_ops, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( (magic[0] == 'I' &&
|
||||
magic[1] == 'I' &&
|
||||
magic[2] == 0x2a &&
|
||||
magic[3] == 0x00) ||
|
||||
(magic[0] == 'M' &&
|
||||
magic[1] == 'M' &&
|
||||
magic[2] == 0x00 &&
|
||||
magic[3] == 0x2a) ) {
|
||||
is_type = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// reset the file descption pointer
|
||||
SDL_RWseek(rw_ops, start, SEEK_SET);
|
||||
|
||||
#endif /* #if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)) */
|
||||
return is_type;
|
||||
}
|
||||
|
||||
static int Internal_isType_ImageIO (SDL_RWops *rw_ops, CFStringRef uti_string_to_test)
|
||||
{
|
||||
int is_type = 0;
|
||||
|
||||
CFDictionaryRef hint_dictionary = CreateHintDictionary(uti_string_to_test);
|
||||
CGImageSourceRef image_source = CreateCGImageSourceFromRWops(rw_ops, hint_dictionary);
|
||||
|
||||
if (hint_dictionary != NULL) {
|
||||
CFRelease(hint_dictionary);
|
||||
}
|
||||
|
||||
if (NULL == image_source) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// This will get the UTI of the container, not the image itself.
|
||||
// Under most cases, this won't be a problem.
|
||||
// But if a person passes an icon file which contains a bmp,
|
||||
// the format will be of the icon file.
|
||||
// But I think the main SDL_image codebase has this same problem so I'm not going to worry about it.
|
||||
CFStringRef uti_type = CGImageSourceGetType(image_source);
|
||||
// CFShow(uti_type);
|
||||
|
||||
// Unsure if we really want conformance or equality
|
||||
is_type = (int)UTTypeConformsTo(uti_string_to_test, uti_type);
|
||||
|
||||
CFRelease(image_source);
|
||||
return is_type;
|
||||
}
|
||||
|
||||
static int Internal_isType (SDL_RWops *rw_ops, CFStringRef uti_string_to_test)
|
||||
{
|
||||
if (rw_ops == NULL)
|
||||
return 0;
|
||||
|
||||
#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
|
||||
if (USE_UIIMAGE_BACKEND())
|
||||
return Internal_isType_UIImage(rw_ops, uti_string_to_test);
|
||||
else
|
||||
#endif
|
||||
return Internal_isType_ImageIO(rw_ops, uti_string_to_test);
|
||||
}
|
||||
|
||||
#ifdef BMP_USES_IMAGEIO
|
||||
|
||||
int IMG_isCUR(SDL_RWops *src)
|
||||
{
|
||||
/* FIXME: Is this a supported type? */
|
||||
return Internal_isType(src, CFSTR("com.microsoft.cur"));
|
||||
}
|
||||
|
||||
int IMG_isICO(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypeICO);
|
||||
}
|
||||
|
||||
int IMG_isBMP(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypeBMP);
|
||||
}
|
||||
|
||||
#endif /* BMP_USES_IMAGEIO */
|
||||
|
||||
int IMG_isGIF(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypeGIF);
|
||||
}
|
||||
|
||||
// Note: JPEG 2000 is kUTTypeJPEG2000
|
||||
int IMG_isJPG(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypeJPEG);
|
||||
}
|
||||
|
||||
int IMG_isPNG(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypePNG);
|
||||
}
|
||||
|
||||
// This isn't a public API function. Apple seems to be able to identify tga's.
|
||||
int IMG_isTGA(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, CFSTR("com.truevision.tga-image"));
|
||||
}
|
||||
|
||||
int IMG_isTIF(SDL_RWops *src)
|
||||
{
|
||||
return Internal_isType(src, kUTTypeTIFF);
|
||||
}
|
||||
|
||||
#pragma mark -
|
||||
#pragma mark Load image engine
|
||||
static SDL_Surface *LoadImageFromRWops_UIImage (SDL_RWops* rw_ops, CFStringRef uti_string_hint)
|
||||
{
|
||||
SDL_Surface *sdl_surface = NULL;
|
||||
|
||||
#if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1))
|
||||
NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
|
||||
UIImage *ui_image;
|
||||
int bytes_read = 0;
|
||||
// I don't know what a good size is.
|
||||
// Max recommended texture size is 1024x1024 on iPhone so maybe base it on that?
|
||||
const int block_size = 1024*4;
|
||||
char temp_buffer[block_size];
|
||||
|
||||
NSMutableData* ns_data = [[NSMutableData alloc] initWithCapacity:1024*1024*4];
|
||||
do {
|
||||
bytes_read = SDL_RWread(rw_ops, temp_buffer, 1, block_size);
|
||||
[ns_data appendBytes:temp_buffer length:bytes_read];
|
||||
} while (bytes_read > 0);
|
||||
|
||||
ui_image = [[UIImage alloc] initWithData:ns_data];
|
||||
if (ui_image != nil)
|
||||
sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
|
||||
[ui_image release];
|
||||
[ns_data release];
|
||||
[autorelease_pool drain];
|
||||
|
||||
#endif /* #if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)) */
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
static SDL_Surface *LoadImageFromRWops_ImageIO (SDL_RWops *rw_ops, CFStringRef uti_string_hint)
|
||||
{
|
||||
CFDictionaryRef hint_dictionary = CreateHintDictionary(uti_string_hint);
|
||||
CGImageSourceRef image_source = CreateCGImageSourceFromRWops(rw_ops, hint_dictionary);
|
||||
|
||||
if (hint_dictionary != NULL)
|
||||
CFRelease(hint_dictionary);
|
||||
|
||||
if (NULL == image_source)
|
||||
return NULL;
|
||||
|
||||
CGImageRef image_ref = CreateCGImageFromCGImageSource(image_source);
|
||||
CFRelease(image_source);
|
||||
|
||||
if (NULL == image_ref)
|
||||
return NULL;
|
||||
SDL_Surface *sdl_surface = Create_SDL_Surface_From_CGImage(image_ref);
|
||||
CFRelease(image_ref);
|
||||
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
static SDL_Surface *LoadImageFromRWops (SDL_RWops *rw_ops, CFStringRef uti_string_hint)
|
||||
{
|
||||
#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
|
||||
if (USE_UIIMAGE_BACKEND())
|
||||
return LoadImageFromRWops_UIImage(rw_ops, uti_string_hint);
|
||||
else
|
||||
#endif
|
||||
return LoadImageFromRWops_ImageIO(rw_ops, uti_string_hint);
|
||||
}
|
||||
|
||||
static SDL_Surface* LoadImageFromFile_UIImage (const char *file)
|
||||
{
|
||||
SDL_Surface *sdl_surface = NULL;
|
||||
|
||||
#if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1))
|
||||
NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
|
||||
NSString *ns_string = [[NSString alloc] initWithUTF8String:file];
|
||||
UIImage *ui_image = [[UIImage alloc] initWithContentsOfFile:ns_string];
|
||||
if (ui_image != nil)
|
||||
sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
|
||||
[ui_image release];
|
||||
[ns_string release];
|
||||
[autorelease_pool drain];
|
||||
|
||||
#endif /* #if defined(ALLOW_UIIMAGE_FALLBACK) && ((TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)) */
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
static SDL_Surface* LoadImageFromFile_ImageIO (const char *file)
|
||||
{
|
||||
CGImageSourceRef image_source = NULL;
|
||||
|
||||
image_source = CreateCGImageSourceFromFile(file);
|
||||
|
||||
if(NULL == image_source)
|
||||
return NULL;
|
||||
|
||||
CGImageRef image_ref = CreateCGImageFromCGImageSource(image_source);
|
||||
CFRelease(image_source);
|
||||
|
||||
if (NULL == image_ref)
|
||||
return NULL;
|
||||
SDL_Surface *sdl_surface = Create_SDL_Surface_From_CGImage(image_ref);
|
||||
CFRelease(image_ref);
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
static SDL_Surface* LoadImageFromFile (const char *file)
|
||||
{
|
||||
#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
|
||||
if (USE_UIIMAGE_BACKEND())
|
||||
return LoadImageFromFile_UIImage(file);
|
||||
else
|
||||
#endif
|
||||
return LoadImageFromFile_ImageIO(file);
|
||||
}
|
||||
|
||||
#ifdef BMP_USES_IMAGEIO
|
||||
|
||||
SDL_Surface* IMG_LoadCUR_RW (SDL_RWops *src)
|
||||
{
|
||||
/* FIXME: Is this a supported type? */
|
||||
return LoadImageFromRWops(src, CFSTR("com.microsoft.cur"));
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadICO_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeICO);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadBMP_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeBMP);
|
||||
}
|
||||
|
||||
#endif /* BMP_USES_IMAGEIO */
|
||||
|
||||
SDL_Surface* IMG_LoadGIF_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops (src, kUTTypeGIF);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadJPG_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops (src, kUTTypeJPEG);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadPNG_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops (src, kUTTypePNG);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadTGA_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, CFSTR("com.truevision.tga-image"));
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadTIF_RW (SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeTIFF);
|
||||
}
|
||||
|
||||
// Since UIImage doesn't really support streams well, we should optimize for the file case.
|
||||
// Apple provides both stream and file loading functions in ImageIO.
|
||||
// Potentially, Apple can optimize for either case.
|
||||
SDL_Surface* IMG_Load (const char *file)
|
||||
{
|
||||
SDL_Surface* sdl_surface = NULL;
|
||||
|
||||
sdl_surface = LoadImageFromFile(file);
|
||||
if(NULL == sdl_surface)
|
||||
{
|
||||
// Either the file doesn't exist or ImageIO doesn't understand the format.
|
||||
// For the latter case, fallback to the native SDL_image handlers.
|
||||
SDL_RWops *src = SDL_RWFromFile(file, "rb");
|
||||
char *ext = strrchr(file, '.');
|
||||
if (ext) {
|
||||
ext++;
|
||||
}
|
||||
if (!src) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
sdl_surface = IMG_LoadTyped_RW(src, 1, ext);
|
||||
}
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
#endif /* defined(__APPLE__) && !defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,440 @@
|
||||
/*
|
||||
* IMG_ImageIO.c
|
||||
* SDL_image
|
||||
*
|
||||
* Created by Eric Wing on 1/2/09.
|
||||
* Copyright 2009 __MyCompanyName__. All rights reserved.
|
||||
*
|
||||
*/
|
||||
#include "SDL_image.h"
|
||||
#import <UIKit/UIKit.h>
|
||||
#import <MobileCoreServices/MobileCoreServices.h> // for UTCoreTypes.h
|
||||
|
||||
// Once we have our image, we need to get it into an SDL_Surface
|
||||
// (Copied straight from the ImageIO backend.)
|
||||
static SDL_Surface* Create_SDL_Surface_From_CGImage(CGImageRef image_ref)
|
||||
{
|
||||
/* This code is adapted from Apple's Documentation found here:
|
||||
* http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/index.html
|
||||
* Listing 9-4††Using a Quartz image as a texture source.
|
||||
* Unfortunately, this guide doesn't show what to do about
|
||||
* non-RGBA image formats so I'm making the rest up.
|
||||
* All this code should be scrutinized.
|
||||
*/
|
||||
|
||||
size_t w = CGImageGetWidth(image_ref);
|
||||
size_t h = CGImageGetHeight(image_ref);
|
||||
CGRect rect = {{0, 0}, {w, h}};
|
||||
|
||||
CGImageAlphaInfo alpha = CGImageGetAlphaInfo(image_ref);
|
||||
//size_t bits_per_pixel = CGImageGetBitsPerPixel(image_ref);
|
||||
size_t bits_per_component = 8;
|
||||
|
||||
SDL_Surface* surface;
|
||||
Uint32 Amask;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
|
||||
CGContextRef bitmap_context;
|
||||
CGBitmapInfo bitmap_info;
|
||||
CGColorSpaceRef color_space = CGColorSpaceCreateDeviceRGB();
|
||||
|
||||
if (alpha == kCGImageAlphaNone ||
|
||||
alpha == kCGImageAlphaNoneSkipFirst ||
|
||||
alpha == kCGImageAlphaNoneSkipLast) {
|
||||
bitmap_info = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host; /* XRGB */
|
||||
Amask = 0x00000000;
|
||||
} else {
|
||||
/* kCGImageAlphaFirst isn't supported */
|
||||
//bitmap_info = kCGImageAlphaFirst | kCGBitmapByteOrder32Host; /* ARGB */
|
||||
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host; /* ARGB */
|
||||
Amask = 0xFF000000;
|
||||
}
|
||||
|
||||
Rmask = 0x00FF0000;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x000000FF;
|
||||
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, Rmask, Gmask, Bmask, Amask);
|
||||
if (surface)
|
||||
{
|
||||
// Sets up a context to be drawn to with surface->pixels as the area to be drawn to
|
||||
bitmap_context = CGBitmapContextCreate(
|
||||
surface->pixels,
|
||||
surface->w,
|
||||
surface->h,
|
||||
bits_per_component,
|
||||
surface->pitch,
|
||||
color_space,
|
||||
bitmap_info
|
||||
);
|
||||
|
||||
// Draws the image into the context's image_data
|
||||
CGContextDrawImage(bitmap_context, rect, image_ref);
|
||||
|
||||
CGContextRelease(bitmap_context);
|
||||
|
||||
// FIXME: Reverse the premultiplied alpha
|
||||
if ((bitmap_info & kCGBitmapAlphaInfoMask) == kCGImageAlphaPremultipliedFirst) {
|
||||
int i, j;
|
||||
Uint8 *p = (Uint8 *)surface->pixels;
|
||||
for (i = surface->h * surface->pitch/4; i--; ) {
|
||||
#if __LITTLE_ENDIAN__
|
||||
Uint8 A = p[3];
|
||||
if (A) {
|
||||
for (j = 0; j < 3; ++j) {
|
||||
p[j] = (p[j] * 255) / A;
|
||||
}
|
||||
}
|
||||
#else
|
||||
Uint8 A = p[0];
|
||||
if (A) {
|
||||
for (j = 1; j < 4; ++j) {
|
||||
p[j] = (p[j] * 255) / A;
|
||||
}
|
||||
}
|
||||
#endif /* ENDIAN */
|
||||
p += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (color_space)
|
||||
{
|
||||
CGColorSpaceRelease(color_space);
|
||||
}
|
||||
|
||||
return surface;
|
||||
}
|
||||
|
||||
static SDL_Surface* LoadImageFromRWops(SDL_RWops* rw_ops, CFStringRef uti_string_hint)
|
||||
{
|
||||
NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
|
||||
SDL_Surface* sdl_surface;
|
||||
UIImage* ui_image;
|
||||
|
||||
int bytes_read = 0;
|
||||
// I don't know what a good size is.
|
||||
// Max recommended texture size is 1024x1024 on iPhone so maybe base it on that?
|
||||
const int block_size = 1024*4;
|
||||
char temp_buffer[block_size];
|
||||
|
||||
NSMutableData* ns_data = [[NSMutableData alloc] initWithCapacity:1024*1024*4];
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
bytes_read = SDL_RWread(rw_ops, temp_buffer, 1, block_size);
|
||||
[ns_data appendBytes:temp_buffer length:bytes_read];
|
||||
} while(bytes_read > 0);
|
||||
|
||||
ui_image = [[UIImage alloc] initWithData:ns_data];
|
||||
|
||||
sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
|
||||
|
||||
[ui_image release];
|
||||
[ns_data release];
|
||||
|
||||
[autorelease_pool drain];
|
||||
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
static SDL_Surface* LoadImageFromFile(const char *file)
|
||||
{
|
||||
NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
|
||||
SDL_Surface* sdl_surface = NULL;
|
||||
UIImage* ui_image;
|
||||
NSString* ns_string;
|
||||
|
||||
ns_string = [[NSString alloc] initWithUTF8String:file];
|
||||
ui_image = [[UIImage alloc] initWithContentsOfFile:ns_string];
|
||||
if(ui_image != NULL)
|
||||
{
|
||||
sdl_surface = Create_SDL_Surface_From_CGImage([ui_image CGImage]);
|
||||
}
|
||||
|
||||
[ui_image release];
|
||||
[ns_string release];
|
||||
|
||||
[autorelease_pool drain];
|
||||
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
|
||||
/* Since UIImage doesn't really support streams well, we should optimize for the file case. */
|
||||
SDL_Surface *IMG_Load(const char *file)
|
||||
{
|
||||
SDL_Surface* sdl_surface = NULL;
|
||||
|
||||
sdl_surface = LoadImageFromFile(file);
|
||||
if(NULL == sdl_surface)
|
||||
{
|
||||
// Either the file doesn't exist or ImageIO doesn't understand the format.
|
||||
// For the latter case, fallback to the native SDL_image handlers.
|
||||
|
||||
SDL_RWops *src = SDL_RWFromFile(file, "rb");
|
||||
char *ext = strrchr(file, '.');
|
||||
if(ext) {
|
||||
ext++;
|
||||
}
|
||||
if(!src) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
sdl_surface = IMG_LoadTyped_RW(src, 1, ext);
|
||||
}
|
||||
return sdl_surface;
|
||||
}
|
||||
|
||||
|
||||
int IMG_InitJPG()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitJPG()
|
||||
{
|
||||
}
|
||||
|
||||
int IMG_InitPNG()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitPNG()
|
||||
{
|
||||
}
|
||||
|
||||
int IMG_InitTIF()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
void IMG_QuitTIF()
|
||||
{
|
||||
}
|
||||
|
||||
/* Copied straight from other files so I don't have to alter them. */
|
||||
static int IMG_isICOCUR(SDL_RWops *src, int type)
|
||||
{
|
||||
int start;
|
||||
int is_ICOCUR;
|
||||
|
||||
/* The Win32 ICO file header (14 bytes) */
|
||||
Uint16 bfReserved;
|
||||
Uint16 bfType;
|
||||
Uint16 bfCount;
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_ICOCUR = 0;
|
||||
bfReserved = SDL_ReadLE16(src);
|
||||
bfType = SDL_ReadLE16(src);
|
||||
bfCount = SDL_ReadLE16(src);
|
||||
if ((bfReserved == 0) && (bfType == type) && (bfCount != 0))
|
||||
is_ICOCUR = 1;
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
|
||||
return (is_ICOCUR);
|
||||
}
|
||||
|
||||
int IMG_isICO(SDL_RWops *src)
|
||||
{
|
||||
return IMG_isICOCUR(src, 1);
|
||||
}
|
||||
|
||||
int IMG_isCUR(SDL_RWops *src)
|
||||
{
|
||||
return IMG_isICOCUR(src, 2);
|
||||
}
|
||||
|
||||
int IMG_isBMP(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
int is_BMP;
|
||||
char magic[2];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_BMP = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
if ( strncmp(magic, "BM", 2) == 0 ) {
|
||||
is_BMP = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
return(is_BMP);
|
||||
}
|
||||
|
||||
int IMG_isGIF(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
int is_GIF;
|
||||
char magic[6];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_GIF = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
if ( (strncmp(magic, "GIF", 3) == 0) &&
|
||||
((memcmp(magic + 3, "87a", 3) == 0) ||
|
||||
(memcmp(magic + 3, "89a", 3) == 0)) ) {
|
||||
is_GIF = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
return(is_GIF);
|
||||
}
|
||||
|
||||
int IMG_isJPG(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
int is_JPG;
|
||||
int in_scan;
|
||||
Uint8 magic[4];
|
||||
|
||||
/* This detection code is by Steaphan Greene <stea@cs.binghamton.edu> */
|
||||
/* Blame me, not Sam, if this doesn't work right. */
|
||||
/* And don't forget to report the problem to the the sdl list too! */
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_JPG = 0;
|
||||
in_scan = 0;
|
||||
if ( SDL_RWread(src, magic, 2, 1) ) {
|
||||
if ( (magic[0] == 0xFF) && (magic[1] == 0xD8) ) {
|
||||
is_JPG = 1;
|
||||
while (is_JPG == 1) {
|
||||
if(SDL_RWread(src, magic, 1, 2) != 2) {
|
||||
is_JPG = 0;
|
||||
} else if( (magic[0] != 0xFF) && (in_scan == 0) ) {
|
||||
is_JPG = 0;
|
||||
} else if( (magic[0] != 0xFF) || (magic[1] == 0xFF) ) {
|
||||
/* Extra padding in JPEG (legal) */
|
||||
/* or this is data and we are scanning */
|
||||
SDL_RWseek(src, -1, SEEK_CUR);
|
||||
} else if(magic[1] == 0xD9) {
|
||||
/* Got to end of good JPEG */
|
||||
break;
|
||||
} else if( (in_scan == 1) && (magic[1] == 0x00) ) {
|
||||
/* This is an encoded 0xFF within the data */
|
||||
} else if( (magic[1] >= 0xD0) && (magic[1] < 0xD9) ) {
|
||||
/* These have nothing else */
|
||||
} else if(SDL_RWread(src, magic+2, 1, 2) != 2) {
|
||||
is_JPG = 0;
|
||||
} else {
|
||||
/* Yes, it's big-endian */
|
||||
Uint32 start;
|
||||
Uint32 size;
|
||||
Uint32 end;
|
||||
start = SDL_RWtell(src);
|
||||
size = (magic[2] << 8) + magic[3];
|
||||
end = SDL_RWseek(src, size-2, SEEK_CUR);
|
||||
if ( end != start + size - 2 ) is_JPG = 0;
|
||||
if ( magic[1] == 0xDA ) {
|
||||
/* Now comes the actual JPEG meat */
|
||||
#ifdef FAST_IS_JPEG
|
||||
/* Ok, I'm convinced. It is a JPEG. */
|
||||
break;
|
||||
#else
|
||||
/* I'm not convinced. Prove it! */
|
||||
in_scan = 1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
return(is_JPG);
|
||||
}
|
||||
|
||||
int IMG_isPNG(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
int is_PNG;
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_PNG = 0;
|
||||
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( magic[0] == 0x89 &&
|
||||
magic[1] == 'P' &&
|
||||
magic[2] == 'N' &&
|
||||
magic[3] == 'G' ) {
|
||||
is_PNG = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
return(is_PNG);
|
||||
}
|
||||
|
||||
int IMG_isTIF(SDL_RWops* src)
|
||||
{
|
||||
int start;
|
||||
int is_TIF;
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_TIF = 0;
|
||||
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( (magic[0] == 'I' &&
|
||||
magic[1] == 'I' &&
|
||||
magic[2] == 0x2a &&
|
||||
magic[3] == 0x00) ||
|
||||
(magic[0] == 'M' &&
|
||||
magic[1] == 'M' &&
|
||||
magic[2] == 0x00 &&
|
||||
magic[3] == 0x2a) ) {
|
||||
is_TIF = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, SEEK_SET);
|
||||
return(is_TIF);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadCUR_RW(SDL_RWops *src)
|
||||
{
|
||||
/* FIXME: Is this a supported type? */
|
||||
return LoadImageFromRWops(src, CFSTR("com.microsoft.cur"));
|
||||
}
|
||||
SDL_Surface* IMG_LoadICO_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeICO);
|
||||
}
|
||||
SDL_Surface* IMG_LoadBMP_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeBMP);
|
||||
}
|
||||
SDL_Surface* IMG_LoadGIF_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeGIF);
|
||||
}
|
||||
SDL_Surface* IMG_LoadJPG_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeJPEG);
|
||||
}
|
||||
SDL_Surface* IMG_LoadPNG_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypePNG);
|
||||
}
|
||||
SDL_Surface* IMG_LoadTGA_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, CFSTR("com.truevision.tga-image"));
|
||||
}
|
||||
SDL_Surface* IMG_LoadTIF_RW(SDL_RWops *src)
|
||||
{
|
||||
return LoadImageFromRWops(src, kUTTypeTIFF);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,892 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#if (!defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)) || !defined(BMP_USES_IMAGEIO)
|
||||
|
||||
/* This is a BMP image file loading framework
|
||||
*
|
||||
* ICO/CUR file support is here as well since it uses similar internal
|
||||
* representation
|
||||
*
|
||||
* A good test suite of BMP images is available at:
|
||||
* http://entropymine.com/jason/bmpsuite/bmpsuite/html/bmpsuite.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_BMP
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isBMP(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_BMP;
|
||||
char magic[2];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_BMP = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
if ( SDL_strncmp(magic, "BM", 2) == 0 ) {
|
||||
is_BMP = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_BMP);
|
||||
}
|
||||
|
||||
static int IMG_isICOCUR(SDL_RWops *src, int type)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_ICOCUR;
|
||||
|
||||
/* The Win32 ICO file header (14 bytes) */
|
||||
Uint16 bfReserved;
|
||||
Uint16 bfType;
|
||||
Uint16 bfCount;
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_ICOCUR = 0;
|
||||
bfReserved = SDL_ReadLE16(src);
|
||||
bfType = SDL_ReadLE16(src);
|
||||
bfCount = SDL_ReadLE16(src);
|
||||
if ((bfReserved == 0) && (bfType == type) && (bfCount != 0))
|
||||
is_ICOCUR = 1;
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
|
||||
return (is_ICOCUR);
|
||||
}
|
||||
|
||||
int IMG_isICO(SDL_RWops *src)
|
||||
{
|
||||
return IMG_isICOCUR(src, 1);
|
||||
}
|
||||
|
||||
int IMG_isCUR(SDL_RWops *src)
|
||||
{
|
||||
return IMG_isICOCUR(src, 2);
|
||||
}
|
||||
|
||||
#include "SDL_error.h"
|
||||
#include "SDL_video.h"
|
||||
#include "SDL_endian.h"
|
||||
|
||||
/* Compression encodings for BMP files */
|
||||
#ifndef BI_RGB
|
||||
#define BI_RGB 0
|
||||
#define BI_RLE8 1
|
||||
#define BI_RLE4 2
|
||||
#define BI_BITFIELDS 3
|
||||
#endif
|
||||
|
||||
static int readRlePixels(SDL_Surface * surface, SDL_RWops * src, int isRle8)
|
||||
{
|
||||
/*
|
||||
| Sets the surface pixels from src. A bmp image is upside down.
|
||||
*/
|
||||
int pitch = surface->pitch;
|
||||
int height = surface->h;
|
||||
Uint8 *start = (Uint8 *)surface->pixels;
|
||||
Uint8 *end = start + (height*pitch);
|
||||
Uint8 *bits = end-pitch, *spot;
|
||||
int ofs = 0;
|
||||
Uint8 ch;
|
||||
Uint8 needsPad;
|
||||
|
||||
#define COPY_PIXEL(x) spot = &bits[ofs++]; if(spot >= start && spot < end) *spot = (x)
|
||||
|
||||
for (;;) {
|
||||
if ( !SDL_RWread(src, &ch, 1, 1) ) return 1;
|
||||
/*
|
||||
| encoded mode starts with a run length, and then a byte
|
||||
| with two colour indexes to alternate between for the run
|
||||
*/
|
||||
if ( ch ) {
|
||||
Uint8 pixel;
|
||||
if ( !SDL_RWread(src, &pixel, 1, 1) ) return 1;
|
||||
if ( isRle8 ) { /* 256-color bitmap, compressed */
|
||||
do {
|
||||
COPY_PIXEL(pixel);
|
||||
} while (--ch);
|
||||
} else { /* 16-color bitmap, compressed */
|
||||
Uint8 pixel0 = pixel >> 4;
|
||||
Uint8 pixel1 = pixel & 0x0F;
|
||||
for (;;) {
|
||||
COPY_PIXEL(pixel0); /* even count, high nibble */
|
||||
if (!--ch) break;
|
||||
COPY_PIXEL(pixel1); /* odd count, low nibble */
|
||||
if (!--ch) break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
| A leading zero is an escape; it may signal the end of the bitmap,
|
||||
| a cursor move, or some absolute data.
|
||||
| zero tag may be absolute mode or an escape
|
||||
*/
|
||||
if ( !SDL_RWread(src, &ch, 1, 1) ) return 1;
|
||||
switch (ch) {
|
||||
case 0: /* end of line */
|
||||
ofs = 0;
|
||||
bits -= pitch; /* go to previous */
|
||||
break;
|
||||
case 1: /* end of bitmap */
|
||||
return 0; /* success! */
|
||||
case 2: /* delta */
|
||||
if ( !SDL_RWread(src, &ch, 1, 1) ) return 1;
|
||||
ofs += ch;
|
||||
if ( !SDL_RWread(src, &ch, 1, 1) ) return 1;
|
||||
bits -= (ch * pitch);
|
||||
break;
|
||||
default: /* no compression */
|
||||
if (isRle8) {
|
||||
needsPad = ( ch & 1 );
|
||||
do {
|
||||
Uint8 pixel;
|
||||
if ( !SDL_RWread(src, &pixel, 1, 1) ) return 1;
|
||||
COPY_PIXEL(pixel);
|
||||
} while (--ch);
|
||||
} else {
|
||||
needsPad = ( ((ch+1)>>1) & 1 ); /* (ch+1)>>1: bytes size */
|
||||
for (;;) {
|
||||
Uint8 pixel;
|
||||
if ( !SDL_RWread(src, &pixel, 1, 1) ) return 1;
|
||||
COPY_PIXEL(pixel >> 4);
|
||||
if (!--ch) break;
|
||||
COPY_PIXEL(pixel & 0x0F);
|
||||
if (!--ch) break;
|
||||
}
|
||||
}
|
||||
/* pad at even boundary */
|
||||
if ( needsPad && !SDL_RWread(src, &ch, 1, 1) ) return 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void CorrectAlphaChannel(SDL_Surface *surface)
|
||||
{
|
||||
/* Check to see if there is any alpha channel data */
|
||||
SDL_bool hasAlpha = SDL_FALSE;
|
||||
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
||||
int alphaChannelOffset = 0;
|
||||
#else
|
||||
int alphaChannelOffset = 3;
|
||||
#endif
|
||||
Uint8 *alpha = ((Uint8*)surface->pixels) + alphaChannelOffset;
|
||||
Uint8 *end = alpha + surface->h * surface->pitch;
|
||||
|
||||
while (alpha < end) {
|
||||
if (*alpha != 0) {
|
||||
hasAlpha = SDL_TRUE;
|
||||
break;
|
||||
}
|
||||
alpha += 4;
|
||||
}
|
||||
|
||||
if (!hasAlpha) {
|
||||
alpha = ((Uint8*)surface->pixels) + alphaChannelOffset;
|
||||
while (alpha < end) {
|
||||
*alpha = SDL_ALPHA_OPAQUE;
|
||||
alpha += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static SDL_Surface *LoadBMP_RW (SDL_RWops *src, int freesrc)
|
||||
{
|
||||
SDL_bool was_error;
|
||||
Sint64 fp_offset;
|
||||
int bmpPitch;
|
||||
int i, pad;
|
||||
SDL_Surface *surface;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
Uint32 Amask;
|
||||
SDL_Palette *palette;
|
||||
Uint8 *bits;
|
||||
Uint8 *top, *end;
|
||||
SDL_bool topDown;
|
||||
int ExpandBMP;
|
||||
SDL_bool correctAlpha = SDL_FALSE;
|
||||
|
||||
/* The Win32 BMP file header (14 bytes) */
|
||||
char magic[2];
|
||||
Uint32 bfSize;
|
||||
Uint16 bfReserved1;
|
||||
Uint16 bfReserved2;
|
||||
Uint32 bfOffBits;
|
||||
|
||||
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
|
||||
Uint32 biSize;
|
||||
Sint32 biWidth;
|
||||
Sint32 biHeight;
|
||||
Uint16 biPlanes;
|
||||
Uint16 biBitCount;
|
||||
Uint32 biCompression;
|
||||
Uint32 biSizeImage;
|
||||
Sint32 biXPelsPerMeter;
|
||||
Sint32 biYPelsPerMeter;
|
||||
Uint32 biClrUsed;
|
||||
Uint32 biClrImportant;
|
||||
|
||||
/* Make sure we are passed a valid data source */
|
||||
surface = NULL;
|
||||
was_error = SDL_FALSE;
|
||||
if ( src == NULL ) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Read in the BMP file header */
|
||||
fp_offset = SDL_RWtell(src);
|
||||
SDL_ClearError();
|
||||
if ( SDL_RWread(src, magic, 1, 2) != 2 ) {
|
||||
SDL_Error(SDL_EFREAD);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
if ( SDL_strncmp(magic, "BM", 2) != 0 ) {
|
||||
IMG_SetError("File is not a Windows BMP file");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
bfSize = SDL_ReadLE32(src);
|
||||
bfReserved1 = SDL_ReadLE16(src);
|
||||
bfReserved2 = SDL_ReadLE16(src);
|
||||
bfOffBits = SDL_ReadLE32(src);
|
||||
|
||||
/* Read the Win32 BITMAPINFOHEADER */
|
||||
biSize = SDL_ReadLE32(src);
|
||||
if ( biSize == 12 ) {
|
||||
biWidth = (Uint32)SDL_ReadLE16(src);
|
||||
biHeight = (Uint32)SDL_ReadLE16(src);
|
||||
biPlanes = SDL_ReadLE16(src);
|
||||
biBitCount = SDL_ReadLE16(src);
|
||||
biCompression = BI_RGB;
|
||||
biSizeImage = 0;
|
||||
biXPelsPerMeter = 0;
|
||||
biYPelsPerMeter = 0;
|
||||
biClrUsed = 0;
|
||||
biClrImportant = 0;
|
||||
} else {
|
||||
biWidth = SDL_ReadLE32(src);
|
||||
biHeight = SDL_ReadLE32(src);
|
||||
biPlanes = SDL_ReadLE16(src);
|
||||
biBitCount = SDL_ReadLE16(src);
|
||||
biCompression = SDL_ReadLE32(src);
|
||||
biSizeImage = SDL_ReadLE32(src);
|
||||
biXPelsPerMeter = SDL_ReadLE32(src);
|
||||
biYPelsPerMeter = SDL_ReadLE32(src);
|
||||
biClrUsed = SDL_ReadLE32(src);
|
||||
biClrImportant = SDL_ReadLE32(src);
|
||||
}
|
||||
if (biHeight < 0) {
|
||||
topDown = SDL_TRUE;
|
||||
biHeight = -biHeight;
|
||||
} else {
|
||||
topDown = SDL_FALSE;
|
||||
}
|
||||
|
||||
/* Check for read error */
|
||||
if ( strcmp(SDL_GetError(), "") != 0 ) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Expand 1 and 4 bit bitmaps to 8 bits per pixel */
|
||||
switch (biBitCount) {
|
||||
case 1:
|
||||
case 4:
|
||||
ExpandBMP = biBitCount;
|
||||
biBitCount = 8;
|
||||
break;
|
||||
default:
|
||||
ExpandBMP = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
/* RLE4 and RLE8 BMP compression is supported */
|
||||
Rmask = Gmask = Bmask = Amask = 0;
|
||||
switch (biCompression) {
|
||||
case BI_RGB:
|
||||
/* If there are no masks, use the defaults */
|
||||
if ( bfOffBits == (14+biSize) ) {
|
||||
/* Default values for the BMP format */
|
||||
switch (biBitCount) {
|
||||
case 15:
|
||||
case 16:
|
||||
Rmask = 0x7C00;
|
||||
Gmask = 0x03E0;
|
||||
Bmask = 0x001F;
|
||||
break;
|
||||
case 24:
|
||||
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
||||
Rmask = 0x000000FF;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x00FF0000;
|
||||
#else
|
||||
Rmask = 0x00FF0000;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x000000FF;
|
||||
#endif
|
||||
break;
|
||||
case 32:
|
||||
/* We don't know if this has alpha channel or not */
|
||||
correctAlpha = SDL_TRUE;
|
||||
Amask = 0xFF000000;
|
||||
Rmask = 0x00FF0000;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x000000FF;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
/* Fall through -- read the RGB masks */
|
||||
|
||||
default:
|
||||
switch (biBitCount) {
|
||||
case 15:
|
||||
case 16:
|
||||
Rmask = SDL_ReadLE32(src);
|
||||
Gmask = SDL_ReadLE32(src);
|
||||
Bmask = SDL_ReadLE32(src);
|
||||
break;
|
||||
case 32:
|
||||
Rmask = SDL_ReadLE32(src);
|
||||
Gmask = SDL_ReadLE32(src);
|
||||
Bmask = SDL_ReadLE32(src);
|
||||
Amask = SDL_ReadLE32(src);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Create a compatible surface, note that the colors are RGB ordered */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
|
||||
biWidth, biHeight, biBitCount, Rmask, Gmask, Bmask, Amask);
|
||||
if ( surface == NULL ) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Load the palette, if any */
|
||||
palette = (surface->format)->palette;
|
||||
if ( palette ) {
|
||||
if ( SDL_RWseek(src, fp_offset+14+biSize, RW_SEEK_SET) < 0 ) {
|
||||
SDL_Error(SDL_EFSEEK);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/*
|
||||
| guich: always use 1<<bpp b/c some bitmaps can bring wrong information
|
||||
| for colorsUsed
|
||||
*/
|
||||
/* if ( biClrUsed == 0 ) { */
|
||||
biClrUsed = 1 << biBitCount;
|
||||
/* } */
|
||||
if ( biSize == 12 ) {
|
||||
for ( i = 0; i < (int)biClrUsed; ++i ) {
|
||||
SDL_RWread(src, &palette->colors[i].b, 1, 1);
|
||||
SDL_RWread(src, &palette->colors[i].g, 1, 1);
|
||||
SDL_RWread(src, &palette->colors[i].r, 1, 1);
|
||||
palette->colors[i].a = SDL_ALPHA_OPAQUE;
|
||||
}
|
||||
} else {
|
||||
for ( i = 0; i < (int)biClrUsed; ++i ) {
|
||||
SDL_RWread(src, &palette->colors[i].b, 1, 1);
|
||||
SDL_RWread(src, &palette->colors[i].g, 1, 1);
|
||||
SDL_RWread(src, &palette->colors[i].r, 1, 1);
|
||||
SDL_RWread(src, &palette->colors[i].a, 1, 1);
|
||||
|
||||
/* According to Microsoft documentation, the fourth element
|
||||
is reserved and must be zero, so we shouldn't treat it as
|
||||
alpha.
|
||||
*/
|
||||
palette->colors[i].a = SDL_ALPHA_OPAQUE;
|
||||
}
|
||||
}
|
||||
palette->ncolors = biClrUsed;
|
||||
}
|
||||
|
||||
/* Read the surface pixels. Note that the bmp image is upside down */
|
||||
if ( SDL_RWseek(src, fp_offset+bfOffBits, RW_SEEK_SET) < 0 ) {
|
||||
SDL_Error(SDL_EFSEEK);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
if ((biCompression == BI_RLE4) || (biCompression == BI_RLE8)) {
|
||||
was_error = (SDL_bool)readRlePixels(surface, src, biCompression == BI_RLE8);
|
||||
if (was_error) IMG_SetError("Error reading from BMP");
|
||||
goto done;
|
||||
}
|
||||
top = (Uint8 *)surface->pixels;
|
||||
end = (Uint8 *)surface->pixels+(surface->h*surface->pitch);
|
||||
switch (ExpandBMP) {
|
||||
case 1:
|
||||
bmpPitch = (biWidth + 7) >> 3;
|
||||
pad = (((bmpPitch)%4) ? (4-((bmpPitch)%4)) : 0);
|
||||
break;
|
||||
case 4:
|
||||
bmpPitch = (biWidth + 1) >> 1;
|
||||
pad = (((bmpPitch)%4) ? (4-((bmpPitch)%4)) : 0);
|
||||
break;
|
||||
default:
|
||||
pad = ((surface->pitch%4) ?
|
||||
(4-(surface->pitch%4)) : 0);
|
||||
break;
|
||||
}
|
||||
if ( topDown ) {
|
||||
bits = top;
|
||||
} else {
|
||||
bits = end - surface->pitch;
|
||||
}
|
||||
while ( bits >= top && bits < end ) {
|
||||
switch (ExpandBMP) {
|
||||
case 1:
|
||||
case 4: {
|
||||
Uint8 pixel = 0;
|
||||
int shift = (8-ExpandBMP);
|
||||
for ( i=0; i<surface->w; ++i ) {
|
||||
if ( i%(8/ExpandBMP) == 0 ) {
|
||||
if ( !SDL_RWread(src, &pixel, 1, 1) ) {
|
||||
IMG_SetError("Error reading from BMP");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
*(bits+i) = (pixel>>shift);
|
||||
pixel <<= ExpandBMP;
|
||||
} }
|
||||
break;
|
||||
|
||||
default:
|
||||
if ( SDL_RWread(src, bits, 1, surface->pitch) != surface->pitch ) {
|
||||
SDL_Error(SDL_EFREAD);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
||||
/* Byte-swap the pixels if needed. Note that the 24bpp
|
||||
case has already been taken care of above. */
|
||||
switch(biBitCount) {
|
||||
case 15:
|
||||
case 16: {
|
||||
Uint16 *pix = (Uint16 *)bits;
|
||||
for(i = 0; i < surface->w; i++)
|
||||
pix[i] = SDL_Swap16(pix[i]);
|
||||
break;
|
||||
}
|
||||
|
||||
case 32: {
|
||||
Uint32 *pix = (Uint32 *)bits;
|
||||
for(i = 0; i < surface->w; i++)
|
||||
pix[i] = SDL_Swap32(pix[i]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
/* Skip padding bytes, ugh */
|
||||
if ( pad ) {
|
||||
Uint8 padbyte;
|
||||
for ( i=0; i<pad; ++i ) {
|
||||
SDL_RWread(src, &padbyte, 1, 1);
|
||||
}
|
||||
}
|
||||
if ( topDown ) {
|
||||
bits += surface->pitch;
|
||||
} else {
|
||||
bits -= surface->pitch;
|
||||
}
|
||||
}
|
||||
if (correctAlpha) {
|
||||
CorrectAlphaChannel(surface);
|
||||
}
|
||||
done:
|
||||
if ( was_error ) {
|
||||
if ( src ) {
|
||||
SDL_RWseek(src, fp_offset, RW_SEEK_SET);
|
||||
}
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
surface = NULL;
|
||||
}
|
||||
if ( freesrc && src ) {
|
||||
SDL_RWclose(src);
|
||||
}
|
||||
return(surface);
|
||||
}
|
||||
|
||||
static Uint8
|
||||
SDL_Read8(SDL_RWops * src)
|
||||
{
|
||||
Uint8 value;
|
||||
|
||||
SDL_RWread(src, &value, 1, 1);
|
||||
return (value);
|
||||
}
|
||||
|
||||
static SDL_Surface *
|
||||
LoadICOCUR_RW(SDL_RWops * src, int type, int freesrc)
|
||||
{
|
||||
SDL_bool was_error;
|
||||
Sint64 fp_offset;
|
||||
int bmpPitch;
|
||||
int i, pad;
|
||||
SDL_Surface *surface;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
Uint8 *bits;
|
||||
int ExpandBMP;
|
||||
int maxCol = 0;
|
||||
int icoOfs = 0;
|
||||
Uint32 palette[256];
|
||||
|
||||
/* The Win32 ICO file header (14 bytes) */
|
||||
Uint16 bfReserved;
|
||||
Uint16 bfType;
|
||||
Uint16 bfCount;
|
||||
|
||||
/* The Win32 BITMAPINFOHEADER struct (40 bytes) */
|
||||
Uint32 biSize;
|
||||
Sint32 biWidth;
|
||||
Sint32 biHeight;
|
||||
Uint16 biPlanes;
|
||||
Uint16 biBitCount;
|
||||
Uint32 biCompression;
|
||||
Uint32 biSizeImage;
|
||||
Sint32 biXPelsPerMeter;
|
||||
Sint32 biYPelsPerMeter;
|
||||
Uint32 biClrUsed;
|
||||
Uint32 biClrImportant;
|
||||
|
||||
/* Make sure we are passed a valid data source */
|
||||
surface = NULL;
|
||||
was_error = SDL_FALSE;
|
||||
if (src == NULL) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Read in the ICO file header */
|
||||
fp_offset = SDL_RWtell(src);
|
||||
SDL_ClearError();
|
||||
|
||||
bfReserved = SDL_ReadLE16(src);
|
||||
bfType = SDL_ReadLE16(src);
|
||||
bfCount = SDL_ReadLE16(src);
|
||||
if ((bfReserved != 0) || (bfType != type) || (bfCount == 0)) {
|
||||
IMG_SetError("File is not a Windows %s file", type == 1 ? "ICO" : "CUR");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Read the Win32 Icon Directory */
|
||||
for (i = 0; i < bfCount; i++) {
|
||||
/* Icon Directory Entries */
|
||||
int bWidth = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
|
||||
int bHeight = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
|
||||
int bColorCount = SDL_Read8(src); /* Uint8, but 0 = 256 ! */
|
||||
Uint8 bReserved = SDL_Read8(src);
|
||||
Uint16 wPlanes = SDL_ReadLE16(src);
|
||||
Uint16 wBitCount = SDL_ReadLE16(src);
|
||||
Uint32 dwBytesInRes = SDL_ReadLE32(src);
|
||||
Uint32 dwImageOffset = SDL_ReadLE32(src);
|
||||
|
||||
if (!bWidth)
|
||||
bWidth = 256;
|
||||
if (!bHeight)
|
||||
bHeight = 256;
|
||||
if (!bColorCount)
|
||||
bColorCount = 256;
|
||||
|
||||
//printf("%dx%d@%d - %08x\n", bWidth, bHeight, bColorCount, dwImageOffset);
|
||||
if (bColorCount > maxCol) {
|
||||
maxCol = bColorCount;
|
||||
icoOfs = dwImageOffset;
|
||||
//printf("marked\n");
|
||||
}
|
||||
}
|
||||
|
||||
/* Advance to the DIB Data */
|
||||
if (SDL_RWseek(src, icoOfs, RW_SEEK_SET) < 0) {
|
||||
SDL_Error(SDL_EFSEEK);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Read the Win32 BITMAPINFOHEADER */
|
||||
biSize = SDL_ReadLE32(src);
|
||||
if (biSize == 40) {
|
||||
biWidth = SDL_ReadLE32(src);
|
||||
biHeight = SDL_ReadLE32(src);
|
||||
biPlanes = SDL_ReadLE16(src);
|
||||
biBitCount = SDL_ReadLE16(src);
|
||||
biCompression = SDL_ReadLE32(src);
|
||||
biSizeImage = SDL_ReadLE32(src);
|
||||
biXPelsPerMeter = SDL_ReadLE32(src);
|
||||
biYPelsPerMeter = SDL_ReadLE32(src);
|
||||
biClrUsed = SDL_ReadLE32(src);
|
||||
biClrImportant = SDL_ReadLE32(src);
|
||||
} else {
|
||||
IMG_SetError("Unsupported ICO bitmap format");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Check for read error */
|
||||
if (SDL_strcmp(SDL_GetError(), "") != 0) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* We don't support any BMP compression right now */
|
||||
switch (biCompression) {
|
||||
case BI_RGB:
|
||||
/* Default values for the BMP format */
|
||||
switch (biBitCount) {
|
||||
case 1:
|
||||
case 4:
|
||||
ExpandBMP = biBitCount;
|
||||
biBitCount = 8;
|
||||
break;
|
||||
case 8:
|
||||
ExpandBMP = 8;
|
||||
break;
|
||||
case 32:
|
||||
Rmask = 0x00FF0000;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x000000FF;
|
||||
ExpandBMP = 0;
|
||||
break;
|
||||
default:
|
||||
IMG_SetError("ICO file with unsupported bit count");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
IMG_SetError("Compressed ICO files not supported");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Create a RGBA surface */
|
||||
biHeight = biHeight >> 1;
|
||||
//printf("%d x %d\n", biWidth, biHeight);
|
||||
surface =
|
||||
SDL_CreateRGBSurface(0, biWidth, biHeight, 32, 0x00FF0000,
|
||||
0x0000FF00, 0x000000FF, 0xFF000000);
|
||||
if (surface == NULL) {
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Load the palette, if any */
|
||||
//printf("bc %d bused %d\n", biBitCount, biClrUsed);
|
||||
if (biBitCount <= 8) {
|
||||
if (biClrUsed == 0) {
|
||||
biClrUsed = 1 << biBitCount;
|
||||
}
|
||||
for (i = 0; i < (int) biClrUsed; ++i) {
|
||||
SDL_RWread(src, &palette[i], 4, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Read the surface pixels. Note that the bmp image is upside down */
|
||||
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
|
||||
switch (ExpandBMP) {
|
||||
case 1:
|
||||
bmpPitch = (biWidth + 7) >> 3;
|
||||
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
|
||||
break;
|
||||
case 4:
|
||||
bmpPitch = (biWidth + 1) >> 1;
|
||||
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
|
||||
break;
|
||||
case 8:
|
||||
bmpPitch = biWidth;
|
||||
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
|
||||
break;
|
||||
default:
|
||||
bmpPitch = biWidth * 4;
|
||||
pad = 0;
|
||||
break;
|
||||
}
|
||||
while (bits > (Uint8 *) surface->pixels) {
|
||||
bits -= surface->pitch;
|
||||
switch (ExpandBMP) {
|
||||
case 1:
|
||||
case 4:
|
||||
case 8:
|
||||
{
|
||||
Uint8 pixel = 0;
|
||||
int shift = (8 - ExpandBMP);
|
||||
for (i = 0; i < surface->w; ++i) {
|
||||
if (i % (8 / ExpandBMP) == 0) {
|
||||
if (!SDL_RWread(src, &pixel, 1, 1)) {
|
||||
IMG_SetError("Error reading from ICO");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
*((Uint32 *) bits + i) = (palette[pixel >> shift]);
|
||||
pixel <<= ExpandBMP;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
if (SDL_RWread(src, bits, 1, surface->pitch)
|
||||
!= surface->pitch) {
|
||||
SDL_Error(SDL_EFREAD);
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
break;
|
||||
}
|
||||
/* Skip padding bytes, ugh */
|
||||
if (pad) {
|
||||
Uint8 padbyte;
|
||||
for (i = 0; i < pad; ++i) {
|
||||
SDL_RWread(src, &padbyte, 1, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Read the mask pixels. Note that the bmp image is upside down */
|
||||
bits = (Uint8 *) surface->pixels + (surface->h * surface->pitch);
|
||||
ExpandBMP = 1;
|
||||
bmpPitch = (biWidth + 7) >> 3;
|
||||
pad = (((bmpPitch) % 4) ? (4 - ((bmpPitch) % 4)) : 0);
|
||||
while (bits > (Uint8 *) surface->pixels) {
|
||||
Uint8 pixel = 0;
|
||||
int shift = (8 - ExpandBMP);
|
||||
|
||||
bits -= surface->pitch;
|
||||
for (i = 0; i < surface->w; ++i) {
|
||||
if (i % (8 / ExpandBMP) == 0) {
|
||||
if (!SDL_RWread(src, &pixel, 1, 1)) {
|
||||
IMG_SetError("Error reading from ICO");
|
||||
was_error = SDL_TRUE;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
*((Uint32 *) bits + i) |= ((pixel >> shift) ? 0 : 0xFF000000);
|
||||
pixel <<= ExpandBMP;
|
||||
}
|
||||
/* Skip padding bytes, ugh */
|
||||
if (pad) {
|
||||
Uint8 padbyte;
|
||||
for (i = 0; i < pad; ++i) {
|
||||
SDL_RWread(src, &padbyte, 1, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
done:
|
||||
if (was_error) {
|
||||
if (src) {
|
||||
SDL_RWseek(src, fp_offset, RW_SEEK_SET);
|
||||
}
|
||||
if (surface) {
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
surface = NULL;
|
||||
}
|
||||
if (freesrc && src) {
|
||||
SDL_RWclose(src);
|
||||
}
|
||||
return (surface);
|
||||
}
|
||||
|
||||
/* Load a BMP type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadBMP_RW(SDL_RWops *src)
|
||||
{
|
||||
return(LoadBMP_RW(src, 0));
|
||||
}
|
||||
|
||||
/* Load a ICO type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadICO_RW(SDL_RWops *src)
|
||||
{
|
||||
return(LoadICOCUR_RW(src, 1, 0));
|
||||
}
|
||||
|
||||
/* Load a CUR type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadCUR_RW(SDL_RWops *src)
|
||||
{
|
||||
return(LoadICOCUR_RW(src, 2, 0));
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isBMP(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
int IMG_isICO(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
int IMG_isCUR(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a BMP type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadBMP_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/* Load a BMP type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadCUR_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/* Load a BMP type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadICO_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_BMP */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,636 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
/* This is a GIF image file loading framework */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_GIF
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isGIF(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_GIF;
|
||||
char magic[6];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_GIF = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
if ( (SDL_strncmp(magic, "GIF", 3) == 0) &&
|
||||
((SDL_memcmp(magic + 3, "87a", 3) == 0) ||
|
||||
(SDL_memcmp(magic + 3, "89a", 3) == 0)) ) {
|
||||
is_GIF = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_GIF);
|
||||
}
|
||||
|
||||
/* Code from here to end of file has been adapted from XPaint: */
|
||||
/* +-------------------------------------------------------------------+ */
|
||||
/* | Copyright 1990, 1991, 1993 David Koblas. | */
|
||||
/* | Copyright 1996 Torsten Martinsen. | */
|
||||
/* | Permission to use, copy, modify, and distribute this software | */
|
||||
/* | and its documentation for any purpose and without fee is hereby | */
|
||||
/* | granted, provided that the above copyright notice appear in all | */
|
||||
/* | copies and that both that copyright notice and this permission | */
|
||||
/* | notice appear in supporting documentation. This software is | */
|
||||
/* | provided "as is" without express or implied warranty. | */
|
||||
/* +-------------------------------------------------------------------+ */
|
||||
|
||||
/* Adapted for use in SDL by Sam Lantinga -- 7/20/98 */
|
||||
#define USED_BY_SDL
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef USED_BY_SDL
|
||||
/* Changes to work with SDL:
|
||||
|
||||
Include SDL header file
|
||||
Use SDL_Surface rather than xpaint Image structure
|
||||
Define SDL versions of RWSetMsg(), ImageNewCmap() and ImageSetCmap()
|
||||
*/
|
||||
#include "SDL.h"
|
||||
|
||||
#define Image SDL_Surface
|
||||
#define RWSetMsg IMG_SetError
|
||||
#define ImageNewCmap(w, h, s) SDL_CreateRGBSurface(SDL_SWSURFACE,w,h,8,0,0,0,0)
|
||||
#define ImageSetCmap(s, i, R, G, B) do { \
|
||||
s->format->palette->colors[i].r = R; \
|
||||
s->format->palette->colors[i].g = G; \
|
||||
s->format->palette->colors[i].b = B; \
|
||||
} while (0)
|
||||
/* * * * * */
|
||||
|
||||
#else
|
||||
|
||||
/* Original XPaint sources */
|
||||
|
||||
#include "image.h"
|
||||
#include "rwTable.h"
|
||||
|
||||
#define SDL_RWops FILE
|
||||
#define SDL_RWclose fclose
|
||||
|
||||
#endif /* USED_BY_SDL */
|
||||
|
||||
|
||||
#define MAXCOLORMAPSIZE 256
|
||||
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
|
||||
#define CM_RED 0
|
||||
#define CM_GREEN 1
|
||||
#define CM_BLUE 2
|
||||
|
||||
#define MAX_LWZ_BITS 12
|
||||
|
||||
#define INTERLACE 0x40
|
||||
#define LOCALCOLORMAP 0x80
|
||||
#define BitSet(byte, bit) (((byte) & (bit)) == (bit))
|
||||
|
||||
#define ReadOK(file,buffer,len) SDL_RWread(file, buffer, len, 1)
|
||||
|
||||
#define LM_to_uint(a,b) (((b)<<8)|(a))
|
||||
|
||||
static struct {
|
||||
unsigned int Width;
|
||||
unsigned int Height;
|
||||
unsigned char ColorMap[3][MAXCOLORMAPSIZE];
|
||||
unsigned int BitPixel;
|
||||
unsigned int ColorResolution;
|
||||
unsigned int Background;
|
||||
unsigned int AspectRatio;
|
||||
int GrayScale;
|
||||
} GifScreen;
|
||||
|
||||
static struct {
|
||||
int transparent;
|
||||
int delayTime;
|
||||
int inputFlag;
|
||||
int disposal;
|
||||
} Gif89;
|
||||
|
||||
static int ReadColorMap(SDL_RWops * src, int number,
|
||||
unsigned char buffer[3][MAXCOLORMAPSIZE], int *flag);
|
||||
static int DoExtension(SDL_RWops * src, int label);
|
||||
static int GetDataBlock(SDL_RWops * src, unsigned char *buf);
|
||||
static int GetCode(SDL_RWops * src, int code_size, int flag);
|
||||
static int LWZReadByte(SDL_RWops * src, int flag, int input_code_size);
|
||||
static Image *ReadImage(SDL_RWops * src, int len, int height, int,
|
||||
unsigned char cmap[3][MAXCOLORMAPSIZE],
|
||||
int gray, int interlace, int ignore);
|
||||
|
||||
Image *
|
||||
IMG_LoadGIF_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
unsigned char buf[16];
|
||||
unsigned char c;
|
||||
unsigned char localColorMap[3][MAXCOLORMAPSIZE];
|
||||
int grayScale;
|
||||
int useGlobalColormap;
|
||||
int bitPixel;
|
||||
int imageCount = 0;
|
||||
char version[4];
|
||||
int imageNumber = 1;
|
||||
Image *image = NULL;
|
||||
|
||||
if ( src == NULL ) {
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if (!ReadOK(src, buf, 6)) {
|
||||
RWSetMsg("error reading magic number");
|
||||
goto done;
|
||||
}
|
||||
if (SDL_strncmp((char *) buf, "GIF", 3) != 0) {
|
||||
RWSetMsg("not a GIF file");
|
||||
goto done;
|
||||
}
|
||||
SDL_memcpy(version, (char *) buf + 3, 3);
|
||||
version[3] = '\0';
|
||||
|
||||
if ((SDL_strcmp(version, "87a") != 0) && (SDL_strcmp(version, "89a") != 0)) {
|
||||
RWSetMsg("bad version number, not '87a' or '89a'");
|
||||
goto done;
|
||||
}
|
||||
Gif89.transparent = -1;
|
||||
Gif89.delayTime = -1;
|
||||
Gif89.inputFlag = -1;
|
||||
Gif89.disposal = 0;
|
||||
|
||||
if (!ReadOK(src, buf, 7)) {
|
||||
RWSetMsg("failed to read screen descriptor");
|
||||
goto done;
|
||||
}
|
||||
GifScreen.Width = LM_to_uint(buf[0], buf[1]);
|
||||
GifScreen.Height = LM_to_uint(buf[2], buf[3]);
|
||||
GifScreen.BitPixel = 2 << (buf[4] & 0x07);
|
||||
GifScreen.ColorResolution = (((buf[4] & 0x70) >> 3) + 1);
|
||||
GifScreen.Background = buf[5];
|
||||
GifScreen.AspectRatio = buf[6];
|
||||
|
||||
if (BitSet(buf[4], LOCALCOLORMAP)) { /* Global Colormap */
|
||||
if (ReadColorMap(src, GifScreen.BitPixel, GifScreen.ColorMap,
|
||||
&GifScreen.GrayScale)) {
|
||||
RWSetMsg("error reading global colormap");
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
do {
|
||||
if (!ReadOK(src, &c, 1)) {
|
||||
RWSetMsg("EOF / read error on image data");
|
||||
goto done;
|
||||
}
|
||||
if (c == ';') { /* GIF terminator */
|
||||
if (imageCount < imageNumber) {
|
||||
RWSetMsg("only %d image%s found in file",
|
||||
imageCount, imageCount > 1 ? "s" : "");
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
if (c == '!') { /* Extension */
|
||||
if (!ReadOK(src, &c, 1)) {
|
||||
RWSetMsg("EOF / read error on extention function code");
|
||||
goto done;
|
||||
}
|
||||
DoExtension(src, c);
|
||||
continue;
|
||||
}
|
||||
if (c != ',') { /* Not a valid start character */
|
||||
continue;
|
||||
}
|
||||
++imageCount;
|
||||
|
||||
if (!ReadOK(src, buf, 9)) {
|
||||
RWSetMsg("couldn't read left/top/width/height");
|
||||
goto done;
|
||||
}
|
||||
useGlobalColormap = !BitSet(buf[8], LOCALCOLORMAP);
|
||||
|
||||
bitPixel = 1 << ((buf[8] & 0x07) + 1);
|
||||
|
||||
if (!useGlobalColormap) {
|
||||
if (ReadColorMap(src, bitPixel, localColorMap, &grayScale)) {
|
||||
RWSetMsg("error reading local colormap");
|
||||
goto done;
|
||||
}
|
||||
image = ReadImage(src, LM_to_uint(buf[4], buf[5]),
|
||||
LM_to_uint(buf[6], buf[7]),
|
||||
bitPixel, localColorMap, grayScale,
|
||||
BitSet(buf[8], INTERLACE),
|
||||
imageCount != imageNumber);
|
||||
} else {
|
||||
image = ReadImage(src, LM_to_uint(buf[4], buf[5]),
|
||||
LM_to_uint(buf[6], buf[7]),
|
||||
GifScreen.BitPixel, GifScreen.ColorMap,
|
||||
GifScreen.GrayScale, BitSet(buf[8], INTERLACE),
|
||||
imageCount != imageNumber);
|
||||
}
|
||||
} while (image == NULL);
|
||||
|
||||
#ifdef USED_BY_SDL
|
||||
if ( Gif89.transparent >= 0 ) {
|
||||
SDL_SetColorKey(image, SDL_TRUE, Gif89.transparent);
|
||||
}
|
||||
#endif
|
||||
|
||||
done:
|
||||
if ( image == NULL ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
}
|
||||
return image;
|
||||
}
|
||||
|
||||
static int
|
||||
ReadColorMap(SDL_RWops *src, int number,
|
||||
unsigned char buffer[3][MAXCOLORMAPSIZE], int *gray)
|
||||
{
|
||||
int i;
|
||||
unsigned char rgb[3];
|
||||
int flag;
|
||||
|
||||
flag = TRUE;
|
||||
|
||||
for (i = 0; i < number; ++i) {
|
||||
if (!ReadOK(src, rgb, sizeof(rgb))) {
|
||||
RWSetMsg("bad colormap");
|
||||
return 1;
|
||||
}
|
||||
buffer[CM_RED][i] = rgb[0];
|
||||
buffer[CM_GREEN][i] = rgb[1];
|
||||
buffer[CM_BLUE][i] = rgb[2];
|
||||
flag &= (rgb[0] == rgb[1] && rgb[1] == rgb[2]);
|
||||
}
|
||||
|
||||
#if 0
|
||||
if (flag)
|
||||
*gray = (number == 2) ? PBM_TYPE : PGM_TYPE;
|
||||
else
|
||||
*gray = PPM_TYPE;
|
||||
#else
|
||||
*gray = 0;
|
||||
#endif
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int
|
||||
DoExtension(SDL_RWops *src, int label)
|
||||
{
|
||||
static unsigned char buf[256];
|
||||
char *str;
|
||||
|
||||
switch (label) {
|
||||
case 0x01: /* Plain Text Extension */
|
||||
str = "Plain Text Extension";
|
||||
break;
|
||||
case 0xff: /* Application Extension */
|
||||
str = "Application Extension";
|
||||
break;
|
||||
case 0xfe: /* Comment Extension */
|
||||
str = "Comment Extension";
|
||||
while (GetDataBlock(src, (unsigned char *) buf) != 0)
|
||||
;
|
||||
return FALSE;
|
||||
case 0xf9: /* Graphic Control Extension */
|
||||
str = "Graphic Control Extension";
|
||||
(void) GetDataBlock(src, (unsigned char *) buf);
|
||||
Gif89.disposal = (buf[0] >> 2) & 0x7;
|
||||
Gif89.inputFlag = (buf[0] >> 1) & 0x1;
|
||||
Gif89.delayTime = LM_to_uint(buf[1], buf[2]);
|
||||
if ((buf[0] & 0x1) != 0)
|
||||
Gif89.transparent = buf[3];
|
||||
|
||||
while (GetDataBlock(src, (unsigned char *) buf) != 0)
|
||||
;
|
||||
return FALSE;
|
||||
default:
|
||||
str = (char *)buf;
|
||||
SDL_snprintf(str, 256, "UNKNOWN (0x%02x)", label);
|
||||
break;
|
||||
}
|
||||
|
||||
while (GetDataBlock(src, (unsigned char *) buf) != 0)
|
||||
;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static int ZeroDataBlock = FALSE;
|
||||
|
||||
static int
|
||||
GetDataBlock(SDL_RWops *src, unsigned char *buf)
|
||||
{
|
||||
unsigned char count;
|
||||
|
||||
if (!ReadOK(src, &count, 1)) {
|
||||
/* pm_message("error in getting DataBlock size" ); */
|
||||
return -1;
|
||||
}
|
||||
ZeroDataBlock = count == 0;
|
||||
|
||||
if ((count != 0) && (!ReadOK(src, buf, count))) {
|
||||
/* pm_message("error in reading DataBlock" ); */
|
||||
return -1;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
static int
|
||||
GetCode(SDL_RWops *src, int code_size, int flag)
|
||||
{
|
||||
static unsigned char buf[280];
|
||||
static int curbit, lastbit, done, last_byte;
|
||||
int i, j, ret;
|
||||
unsigned char count;
|
||||
|
||||
if (flag) {
|
||||
curbit = 0;
|
||||
lastbit = 0;
|
||||
done = FALSE;
|
||||
return 0;
|
||||
}
|
||||
if ((curbit + code_size) >= lastbit) {
|
||||
if (done) {
|
||||
if (curbit >= lastbit)
|
||||
RWSetMsg("ran off the end of my bits");
|
||||
return -1;
|
||||
}
|
||||
buf[0] = buf[last_byte - 2];
|
||||
buf[1] = buf[last_byte - 1];
|
||||
|
||||
if ((count = GetDataBlock(src, &buf[2])) == 0)
|
||||
done = TRUE;
|
||||
|
||||
last_byte = 2 + count;
|
||||
curbit = (curbit - lastbit) + 16;
|
||||
lastbit = (2 + count) * 8;
|
||||
}
|
||||
ret = 0;
|
||||
for (i = curbit, j = 0; j < code_size; ++i, ++j)
|
||||
ret |= ((buf[i / 8] & (1 << (i % 8))) != 0) << j;
|
||||
|
||||
curbit += code_size;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
LWZReadByte(SDL_RWops *src, int flag, int input_code_size)
|
||||
{
|
||||
static int fresh = FALSE;
|
||||
int code, incode;
|
||||
static int code_size, set_code_size;
|
||||
static int max_code, max_code_size;
|
||||
static int firstcode, oldcode;
|
||||
static int clear_code, end_code;
|
||||
static int table[2][(1 << MAX_LWZ_BITS)];
|
||||
static int stack[(1 << (MAX_LWZ_BITS)) * 2], *sp;
|
||||
register int i;
|
||||
|
||||
/* Fixed buffer overflow found by Michael Skladnikiewicz */
|
||||
if (input_code_size > MAX_LWZ_BITS)
|
||||
return -1;
|
||||
|
||||
if (flag) {
|
||||
set_code_size = input_code_size;
|
||||
code_size = set_code_size + 1;
|
||||
clear_code = 1 << set_code_size;
|
||||
end_code = clear_code + 1;
|
||||
max_code_size = 2 * clear_code;
|
||||
max_code = clear_code + 2;
|
||||
|
||||
GetCode(src, 0, TRUE);
|
||||
|
||||
fresh = TRUE;
|
||||
|
||||
for (i = 0; i < clear_code; ++i) {
|
||||
table[0][i] = 0;
|
||||
table[1][i] = i;
|
||||
}
|
||||
table[1][0] = 0;
|
||||
for (; i < (1 << MAX_LWZ_BITS); ++i)
|
||||
table[0][i] = 0;
|
||||
|
||||
sp = stack;
|
||||
|
||||
return 0;
|
||||
} else if (fresh) {
|
||||
fresh = FALSE;
|
||||
do {
|
||||
firstcode = oldcode = GetCode(src, code_size, FALSE);
|
||||
} while (firstcode == clear_code);
|
||||
return firstcode;
|
||||
}
|
||||
if (sp > stack)
|
||||
return *--sp;
|
||||
|
||||
while ((code = GetCode(src, code_size, FALSE)) >= 0) {
|
||||
if (code == clear_code) {
|
||||
for (i = 0; i < clear_code; ++i) {
|
||||
table[0][i] = 0;
|
||||
table[1][i] = i;
|
||||
}
|
||||
for (; i < (1 << MAX_LWZ_BITS); ++i)
|
||||
table[0][i] = table[1][i] = 0;
|
||||
code_size = set_code_size + 1;
|
||||
max_code_size = 2 * clear_code;
|
||||
max_code = clear_code + 2;
|
||||
sp = stack;
|
||||
firstcode = oldcode = GetCode(src, code_size, FALSE);
|
||||
return firstcode;
|
||||
} else if (code == end_code) {
|
||||
int count;
|
||||
unsigned char buf[260];
|
||||
|
||||
if (ZeroDataBlock)
|
||||
return -2;
|
||||
|
||||
while ((count = GetDataBlock(src, buf)) > 0)
|
||||
;
|
||||
|
||||
if (count != 0) {
|
||||
/*
|
||||
* pm_message("missing EOD in data stream (common occurence)");
|
||||
*/
|
||||
}
|
||||
return -2;
|
||||
}
|
||||
incode = code;
|
||||
|
||||
if (code >= max_code) {
|
||||
*sp++ = firstcode;
|
||||
code = oldcode;
|
||||
}
|
||||
while (code >= clear_code) {
|
||||
/* Guard against buffer overruns */
|
||||
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
|
||||
RWSetMsg("invalid LWZ data");
|
||||
return -3;
|
||||
}
|
||||
*sp++ = table[1][code];
|
||||
if (code == table[0][code])
|
||||
RWSetMsg("circular table entry BIG ERROR");
|
||||
code = table[0][code];
|
||||
}
|
||||
|
||||
/* Guard against buffer overruns */
|
||||
if (code < 0 || code >= (1 << MAX_LWZ_BITS)) {
|
||||
RWSetMsg("invalid LWZ data");
|
||||
return -4;
|
||||
}
|
||||
*sp++ = firstcode = table[1][code];
|
||||
|
||||
if ((code = max_code) < (1 << MAX_LWZ_BITS)) {
|
||||
table[0][code] = oldcode;
|
||||
table[1][code] = firstcode;
|
||||
++max_code;
|
||||
if ((max_code >= max_code_size) &&
|
||||
(max_code_size < (1 << MAX_LWZ_BITS))) {
|
||||
max_code_size *= 2;
|
||||
++code_size;
|
||||
}
|
||||
}
|
||||
oldcode = incode;
|
||||
|
||||
if (sp > stack)
|
||||
return *--sp;
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
static Image *
|
||||
ReadImage(SDL_RWops * src, int len, int height, int cmapSize,
|
||||
unsigned char cmap[3][MAXCOLORMAPSIZE],
|
||||
int gray, int interlace, int ignore)
|
||||
{
|
||||
Image *image;
|
||||
unsigned char c;
|
||||
int i, v;
|
||||
int xpos = 0, ypos = 0, pass = 0;
|
||||
|
||||
/*
|
||||
** Initialize the compression routines
|
||||
*/
|
||||
if (!ReadOK(src, &c, 1)) {
|
||||
RWSetMsg("EOF / read error on image data");
|
||||
return NULL;
|
||||
}
|
||||
if (LWZReadByte(src, TRUE, c) < 0) {
|
||||
RWSetMsg("error reading image");
|
||||
return NULL;
|
||||
}
|
||||
/*
|
||||
** If this is an "uninteresting picture" ignore it.
|
||||
*/
|
||||
if (ignore) {
|
||||
while (LWZReadByte(src, FALSE, c) >= 0)
|
||||
;
|
||||
return NULL;
|
||||
}
|
||||
image = ImageNewCmap(len, height, cmapSize);
|
||||
|
||||
for (i = 0; i < cmapSize; i++)
|
||||
ImageSetCmap(image, i, cmap[CM_RED][i],
|
||||
cmap[CM_GREEN][i], cmap[CM_BLUE][i]);
|
||||
|
||||
while ((v = LWZReadByte(src, FALSE, c)) >= 0) {
|
||||
#ifdef USED_BY_SDL
|
||||
((Uint8 *)image->pixels)[xpos + ypos * image->pitch] = v;
|
||||
#else
|
||||
image->data[xpos + ypos * len] = v;
|
||||
#endif
|
||||
++xpos;
|
||||
if (xpos == len) {
|
||||
xpos = 0;
|
||||
if (interlace) {
|
||||
switch (pass) {
|
||||
case 0:
|
||||
case 1:
|
||||
ypos += 8;
|
||||
break;
|
||||
case 2:
|
||||
ypos += 4;
|
||||
break;
|
||||
case 3:
|
||||
ypos += 2;
|
||||
break;
|
||||
}
|
||||
|
||||
if (ypos >= height) {
|
||||
++pass;
|
||||
switch (pass) {
|
||||
case 1:
|
||||
ypos = 4;
|
||||
break;
|
||||
case 2:
|
||||
ypos = 2;
|
||||
break;
|
||||
case 3:
|
||||
ypos = 1;
|
||||
break;
|
||||
default:
|
||||
goto fini;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
++ypos;
|
||||
}
|
||||
}
|
||||
if (ypos >= height)
|
||||
break;
|
||||
}
|
||||
|
||||
fini:
|
||||
|
||||
return image;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isGIF(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a GIF type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadGIF_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_GIF */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,495 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
/* This is a JPEG image file loading framework */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_JPG
|
||||
|
||||
#include <jpeglib.h>
|
||||
|
||||
#ifdef JPEG_TRUE /* MinGW version of jpeg-8.x renamed TRUE to JPEG_TRUE etc. */
|
||||
typedef JPEG_boolean boolean;
|
||||
#define TRUE JPEG_TRUE
|
||||
#define FALSE JPEG_FALSE
|
||||
#endif
|
||||
|
||||
/* Define this for fast loading and not as good image quality */
|
||||
/*#define FAST_JPEG*/
|
||||
|
||||
/* Define this for quicker (but less perfect) JPEG identification */
|
||||
#define FAST_IS_JPEG
|
||||
|
||||
static struct {
|
||||
int loaded;
|
||||
void *handle;
|
||||
void (*jpeg_calc_output_dimensions) (j_decompress_ptr cinfo);
|
||||
void (*jpeg_CreateDecompress) (j_decompress_ptr cinfo, int version, size_t structsize);
|
||||
void (*jpeg_destroy_decompress) (j_decompress_ptr cinfo);
|
||||
boolean (*jpeg_finish_decompress) (j_decompress_ptr cinfo);
|
||||
int (*jpeg_read_header) (j_decompress_ptr cinfo, boolean require_image);
|
||||
JDIMENSION (*jpeg_read_scanlines) (j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines);
|
||||
boolean (*jpeg_resync_to_restart) (j_decompress_ptr cinfo, int desired);
|
||||
boolean (*jpeg_start_decompress) (j_decompress_ptr cinfo);
|
||||
struct jpeg_error_mgr * (*jpeg_std_error) (struct jpeg_error_mgr * err);
|
||||
} lib;
|
||||
|
||||
#ifdef LOAD_JPG_DYNAMIC
|
||||
int IMG_InitJPG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.handle = SDL_LoadObject(LOAD_JPG_DYNAMIC);
|
||||
if ( lib.handle == NULL ) {
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_calc_output_dimensions =
|
||||
(void (*) (j_decompress_ptr))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_calc_output_dimensions");
|
||||
if ( lib.jpeg_calc_output_dimensions == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_CreateDecompress =
|
||||
(void (*) (j_decompress_ptr, int, size_t))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_CreateDecompress");
|
||||
if ( lib.jpeg_CreateDecompress == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_destroy_decompress =
|
||||
(void (*) (j_decompress_ptr))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_destroy_decompress");
|
||||
if ( lib.jpeg_destroy_decompress == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_finish_decompress =
|
||||
(boolean (*) (j_decompress_ptr))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_finish_decompress");
|
||||
if ( lib.jpeg_finish_decompress == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_read_header =
|
||||
(int (*) (j_decompress_ptr, boolean))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_read_header");
|
||||
if ( lib.jpeg_read_header == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_read_scanlines =
|
||||
(JDIMENSION (*) (j_decompress_ptr, JSAMPARRAY, JDIMENSION))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_read_scanlines");
|
||||
if ( lib.jpeg_read_scanlines == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_resync_to_restart =
|
||||
(boolean (*) (j_decompress_ptr, int))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_resync_to_restart");
|
||||
if ( lib.jpeg_resync_to_restart == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_start_decompress =
|
||||
(boolean (*) (j_decompress_ptr))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_start_decompress");
|
||||
if ( lib.jpeg_start_decompress == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.jpeg_std_error =
|
||||
(struct jpeg_error_mgr * (*) (struct jpeg_error_mgr *))
|
||||
SDL_LoadFunction(lib.handle, "jpeg_std_error");
|
||||
if ( lib.jpeg_std_error == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitJPG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#else
|
||||
int IMG_InitJPG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.jpeg_calc_output_dimensions = jpeg_calc_output_dimensions;
|
||||
lib.jpeg_CreateDecompress = jpeg_CreateDecompress;
|
||||
lib.jpeg_destroy_decompress = jpeg_destroy_decompress;
|
||||
lib.jpeg_finish_decompress = jpeg_finish_decompress;
|
||||
lib.jpeg_read_header = jpeg_read_header;
|
||||
lib.jpeg_read_scanlines = jpeg_read_scanlines;
|
||||
lib.jpeg_resync_to_restart = jpeg_resync_to_restart;
|
||||
lib.jpeg_start_decompress = jpeg_start_decompress;
|
||||
lib.jpeg_std_error = jpeg_std_error;
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitJPG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#endif /* LOAD_JPG_DYNAMIC */
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isJPG(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_JPG;
|
||||
int in_scan;
|
||||
Uint8 magic[4];
|
||||
|
||||
/* This detection code is by Steaphan Greene <stea@cs.binghamton.edu> */
|
||||
/* Blame me, not Sam, if this doesn't work right. */
|
||||
/* And don't forget to report the problem to the the sdl list too! */
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_JPG = 0;
|
||||
in_scan = 0;
|
||||
if ( SDL_RWread(src, magic, 2, 1) ) {
|
||||
if ( (magic[0] == 0xFF) && (magic[1] == 0xD8) ) {
|
||||
is_JPG = 1;
|
||||
while (is_JPG == 1) {
|
||||
if(SDL_RWread(src, magic, 1, 2) != 2) {
|
||||
is_JPG = 0;
|
||||
} else if( (magic[0] != 0xFF) && (in_scan == 0) ) {
|
||||
is_JPG = 0;
|
||||
} else if( (magic[0] != 0xFF) || (magic[1] == 0xFF) ) {
|
||||
/* Extra padding in JPEG (legal) */
|
||||
/* or this is data and we are scanning */
|
||||
SDL_RWseek(src, -1, RW_SEEK_CUR);
|
||||
} else if(magic[1] == 0xD9) {
|
||||
/* Got to end of good JPEG */
|
||||
break;
|
||||
} else if( (in_scan == 1) && (magic[1] == 0x00) ) {
|
||||
/* This is an encoded 0xFF within the data */
|
||||
} else if( (magic[1] >= 0xD0) && (magic[1] < 0xD9) ) {
|
||||
/* These have nothing else */
|
||||
} else if(SDL_RWread(src, magic+2, 1, 2) != 2) {
|
||||
is_JPG = 0;
|
||||
} else {
|
||||
/* Yes, it's big-endian */
|
||||
Sint64 innerStart;
|
||||
Uint32 size;
|
||||
Sint64 end;
|
||||
innerStart = SDL_RWtell(src);
|
||||
size = (magic[2] << 8) + magic[3];
|
||||
end = SDL_RWseek(src, size-2, RW_SEEK_CUR);
|
||||
if ( end != innerStart + size - 2 ) is_JPG = 0;
|
||||
if ( magic[1] == 0xDA ) {
|
||||
/* Now comes the actual JPEG meat */
|
||||
#ifdef FAST_IS_JPEG
|
||||
/* Ok, I'm convinced. It is a JPEG. */
|
||||
break;
|
||||
#else
|
||||
/* I'm not convinced. Prove it! */
|
||||
in_scan = 1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_JPG);
|
||||
}
|
||||
|
||||
#define INPUT_BUFFER_SIZE 4096
|
||||
typedef struct {
|
||||
struct jpeg_source_mgr pub;
|
||||
|
||||
SDL_RWops *ctx;
|
||||
Uint8 buffer[INPUT_BUFFER_SIZE];
|
||||
} my_source_mgr;
|
||||
|
||||
/*
|
||||
* Initialize source --- called by jpeg_read_header
|
||||
* before any data is actually read.
|
||||
*/
|
||||
static void init_source (j_decompress_ptr cinfo)
|
||||
{
|
||||
/* We don't actually need to do anything */
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fill the input buffer --- called whenever buffer is emptied.
|
||||
*/
|
||||
static boolean fill_input_buffer (j_decompress_ptr cinfo)
|
||||
{
|
||||
my_source_mgr * src = (my_source_mgr *) cinfo->src;
|
||||
int nbytes;
|
||||
|
||||
nbytes = SDL_RWread(src->ctx, src->buffer, 1, INPUT_BUFFER_SIZE);
|
||||
if (nbytes <= 0) {
|
||||
/* Insert a fake EOI marker */
|
||||
src->buffer[0] = (Uint8) 0xFF;
|
||||
src->buffer[1] = (Uint8) JPEG_EOI;
|
||||
nbytes = 2;
|
||||
}
|
||||
src->pub.next_input_byte = src->buffer;
|
||||
src->pub.bytes_in_buffer = nbytes;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Skip data --- used to skip over a potentially large amount of
|
||||
* uninteresting data (such as an APPn marker).
|
||||
*
|
||||
* Writers of suspendable-input applications must note that skip_input_data
|
||||
* is not granted the right to give a suspension return. If the skip extends
|
||||
* beyond the data currently in the buffer, the buffer can be marked empty so
|
||||
* that the next read will cause a fill_input_buffer call that can suspend.
|
||||
* Arranging for additional bytes to be discarded before reloading the input
|
||||
* buffer is the application writer's problem.
|
||||
*/
|
||||
static void skip_input_data (j_decompress_ptr cinfo, long num_bytes)
|
||||
{
|
||||
my_source_mgr * src = (my_source_mgr *) cinfo->src;
|
||||
|
||||
/* Just a dumb implementation for now. Could use fseek() except
|
||||
* it doesn't work on pipes. Not clear that being smart is worth
|
||||
* any trouble anyway --- large skips are infrequent.
|
||||
*/
|
||||
if (num_bytes > 0) {
|
||||
while (num_bytes > (long) src->pub.bytes_in_buffer) {
|
||||
num_bytes -= (long) src->pub.bytes_in_buffer;
|
||||
(void) src->pub.fill_input_buffer(cinfo);
|
||||
/* note we assume that fill_input_buffer will never
|
||||
* return FALSE, so suspension need not be handled.
|
||||
*/
|
||||
}
|
||||
src->pub.next_input_byte += (size_t) num_bytes;
|
||||
src->pub.bytes_in_buffer -= (size_t) num_bytes;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Terminate source --- called by jpeg_finish_decompress
|
||||
* after all data has been read.
|
||||
*/
|
||||
static void term_source (j_decompress_ptr cinfo)
|
||||
{
|
||||
/* We don't actually need to do anything */
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Prepare for input from a stdio stream.
|
||||
* The caller must have already opened the stream, and is responsible
|
||||
* for closing it after finishing decompression.
|
||||
*/
|
||||
static void jpeg_SDL_RW_src (j_decompress_ptr cinfo, SDL_RWops *ctx)
|
||||
{
|
||||
my_source_mgr *src;
|
||||
|
||||
/* The source object and input buffer are made permanent so that a series
|
||||
* of JPEG images can be read from the same file by calling jpeg_stdio_src
|
||||
* only before the first one. (If we discarded the buffer at the end of
|
||||
* one image, we'd likely lose the start of the next one.)
|
||||
* This makes it unsafe to use this manager and a different source
|
||||
* manager serially with the same JPEG object. Caveat programmer.
|
||||
*/
|
||||
if (cinfo->src == NULL) { /* first time for this JPEG object? */
|
||||
cinfo->src = (struct jpeg_source_mgr *)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
|
||||
sizeof(my_source_mgr));
|
||||
src = (my_source_mgr *) cinfo->src;
|
||||
}
|
||||
|
||||
src = (my_source_mgr *) cinfo->src;
|
||||
src->pub.init_source = init_source;
|
||||
src->pub.fill_input_buffer = fill_input_buffer;
|
||||
src->pub.skip_input_data = skip_input_data;
|
||||
src->pub.resync_to_restart = lib.jpeg_resync_to_restart; /* use default method */
|
||||
src->pub.term_source = term_source;
|
||||
src->ctx = ctx;
|
||||
src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
|
||||
src->pub.next_input_byte = NULL; /* until buffer loaded */
|
||||
}
|
||||
|
||||
struct my_error_mgr {
|
||||
struct jpeg_error_mgr errmgr;
|
||||
jmp_buf escape;
|
||||
};
|
||||
|
||||
static void my_error_exit(j_common_ptr cinfo)
|
||||
{
|
||||
struct my_error_mgr *err = (struct my_error_mgr *)cinfo->err;
|
||||
longjmp(err->escape, 1);
|
||||
}
|
||||
|
||||
static void output_no_message(j_common_ptr cinfo)
|
||||
{
|
||||
/* do nothing */
|
||||
}
|
||||
|
||||
/* Load a JPEG type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadJPG_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
struct jpeg_decompress_struct cinfo;
|
||||
JSAMPROW rowptr[1];
|
||||
SDL_Surface *volatile surface = NULL;
|
||||
struct my_error_mgr jerr;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( !IMG_Init(IMG_INIT_JPG) ) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create a decompression structure and load the JPEG header */
|
||||
cinfo.err = lib.jpeg_std_error(&jerr.errmgr);
|
||||
jerr.errmgr.error_exit = my_error_exit;
|
||||
jerr.errmgr.output_message = output_no_message;
|
||||
if(setjmp(jerr.escape)) {
|
||||
/* If we get here, libjpeg found an error */
|
||||
lib.jpeg_destroy_decompress(&cinfo);
|
||||
if ( surface != NULL ) {
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
IMG_SetError("JPEG loading error");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
lib.jpeg_create_decompress(&cinfo);
|
||||
jpeg_SDL_RW_src(&cinfo, src);
|
||||
lib.jpeg_read_header(&cinfo, TRUE);
|
||||
|
||||
if(cinfo.num_components == 4) {
|
||||
/* Set 32-bit Raw output */
|
||||
cinfo.out_color_space = JCS_CMYK;
|
||||
cinfo.quantize_colors = FALSE;
|
||||
lib.jpeg_calc_output_dimensions(&cinfo);
|
||||
|
||||
/* Allocate an output surface to hold the image */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
|
||||
cinfo.output_width, cinfo.output_height, 32,
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
|
||||
#else
|
||||
0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF);
|
||||
#endif
|
||||
} else {
|
||||
/* Set 24-bit RGB output */
|
||||
cinfo.out_color_space = JCS_RGB;
|
||||
cinfo.quantize_colors = FALSE;
|
||||
#ifdef FAST_JPEG
|
||||
cinfo.scale_num = 1;
|
||||
cinfo.scale_denom = 1;
|
||||
cinfo.dct_method = JDCT_FASTEST;
|
||||
cinfo.do_fancy_upsampling = FALSE;
|
||||
#endif
|
||||
lib.jpeg_calc_output_dimensions(&cinfo);
|
||||
|
||||
/* Allocate an output surface to hold the image */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
|
||||
cinfo.output_width, cinfo.output_height, 24,
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
0x0000FF, 0x00FF00, 0xFF0000,
|
||||
#else
|
||||
0xFF0000, 0x00FF00, 0x0000FF,
|
||||
#endif
|
||||
0);
|
||||
}
|
||||
|
||||
if ( surface == NULL ) {
|
||||
lib.jpeg_destroy_decompress(&cinfo);
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
IMG_SetError("Out of memory");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Decompress the image */
|
||||
lib.jpeg_start_decompress(&cinfo);
|
||||
while ( cinfo.output_scanline < cinfo.output_height ) {
|
||||
rowptr[0] = (JSAMPROW)(Uint8 *)surface->pixels +
|
||||
cinfo.output_scanline * surface->pitch;
|
||||
lib.jpeg_read_scanlines(&cinfo, rowptr, (JDIMENSION) 1);
|
||||
}
|
||||
lib.jpeg_finish_decompress(&cinfo);
|
||||
lib.jpeg_destroy_decompress(&cinfo);
|
||||
|
||||
return(surface);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int IMG_InitJPG()
|
||||
{
|
||||
IMG_SetError("JPEG images are not supported");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
void IMG_QuitJPG()
|
||||
{
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isJPG(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a JPEG type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadJPG_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_JPG */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,499 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a ILBM image file loading framework
|
||||
Load IFF pictures, PBM & ILBM packing methods, with or without stencil
|
||||
Written by Daniel Morais ( Daniel AT Morais DOT com ) in September 2001.
|
||||
24 bits ILBM files support added by Marc Le Douarain (http://www.multimania.com/mavati)
|
||||
in December 2002.
|
||||
EHB and HAM (specific Amiga graphic chip modes) support added by Marc Le Douarain
|
||||
(http://www.multimania.com/mavati) in December 2003.
|
||||
Stencil and colorkey fixes by David Raulo (david.raulo AT free DOT fr) in February 2004.
|
||||
Buffer overflow fix in RLE decompression by David Raulo in January 2008.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_endian.h"
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_LBM
|
||||
|
||||
|
||||
#define MAXCOLORS 256
|
||||
|
||||
/* Structure for an IFF picture ( BMHD = Bitmap Header ) */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Uint16 w, h; /* width & height of the bitmap in pixels */
|
||||
Sint16 x, y; /* screen coordinates of the bitmap */
|
||||
Uint8 planes; /* number of planes of the bitmap */
|
||||
Uint8 mask; /* mask type ( 0 => no mask ) */
|
||||
Uint8 tcomp; /* compression type */
|
||||
Uint8 pad1; /* dummy value, for padding */
|
||||
Uint16 tcolor; /* transparent color */
|
||||
Uint8 xAspect, /* pixel aspect ratio */
|
||||
yAspect;
|
||||
Sint16 Lpage; /* width of the screen in pixels */
|
||||
Sint16 Hpage; /* height of the screen in pixels */
|
||||
} BMHD;
|
||||
|
||||
int IMG_isLBM( SDL_RWops *src )
|
||||
{
|
||||
Sint64 start;
|
||||
int is_LBM;
|
||||
Uint8 magic[4+4+4];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_LBM = 0;
|
||||
if ( SDL_RWread( src, magic, sizeof(magic), 1 ) )
|
||||
{
|
||||
if ( !SDL_memcmp( magic, "FORM", 4 ) &&
|
||||
( !SDL_memcmp( magic + 8, "PBM ", 4 ) ||
|
||||
!SDL_memcmp( magic + 8, "ILBM", 4 ) ) )
|
||||
{
|
||||
is_LBM = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return( is_LBM );
|
||||
}
|
||||
|
||||
SDL_Surface *IMG_LoadLBM_RW( SDL_RWops *src )
|
||||
{
|
||||
Sint64 start;
|
||||
SDL_Surface *Image;
|
||||
Uint8 id[4], pbm, colormap[MAXCOLORS*3], *MiniBuf, *ptr, count, color, msk;
|
||||
Uint32 size, bytesloaded, nbcolors;
|
||||
Uint32 i, j, bytesperline, nbplanes, stencil, plane, h;
|
||||
Uint32 remainingbytes;
|
||||
Uint32 width;
|
||||
BMHD bmhd;
|
||||
char *error;
|
||||
Uint8 flagHAM,flagEHB;
|
||||
|
||||
Image = NULL;
|
||||
error = NULL;
|
||||
MiniBuf = NULL;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( !SDL_RWread( src, id, 4, 1 ) )
|
||||
{
|
||||
error="error reading IFF chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Should be the size of the file minus 4+4 ( 'FORM'+size ) */
|
||||
if ( !SDL_RWread( src, &size, 4, 1 ) )
|
||||
{
|
||||
error="error reading IFF chunk size";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* As size is not used here, no need to swap it */
|
||||
|
||||
if ( SDL_memcmp( id, "FORM", 4 ) != 0 )
|
||||
{
|
||||
error="not a IFF file";
|
||||
goto done;
|
||||
}
|
||||
|
||||
if ( !SDL_RWread( src, id, 4, 1 ) )
|
||||
{
|
||||
error="error reading IFF chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
pbm = 0;
|
||||
|
||||
/* File format : PBM=Packed Bitmap, ILBM=Interleaved Bitmap */
|
||||
if ( !SDL_memcmp( id, "PBM ", 4 ) ) pbm = 1;
|
||||
else if ( SDL_memcmp( id, "ILBM", 4 ) )
|
||||
{
|
||||
error="not a IFF picture";
|
||||
goto done;
|
||||
}
|
||||
|
||||
nbcolors = 0;
|
||||
|
||||
SDL_memset( &bmhd, 0, sizeof( BMHD ) );
|
||||
flagHAM = 0;
|
||||
flagEHB = 0;
|
||||
|
||||
while ( SDL_memcmp( id, "BODY", 4 ) != 0 )
|
||||
{
|
||||
if ( !SDL_RWread( src, id, 4, 1 ) )
|
||||
{
|
||||
error="error reading IFF chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
if ( !SDL_RWread( src, &size, 4, 1 ) )
|
||||
{
|
||||
error="error reading IFF chunk size";
|
||||
goto done;
|
||||
}
|
||||
|
||||
bytesloaded = 0;
|
||||
|
||||
size = SDL_SwapBE32( size );
|
||||
|
||||
if ( !SDL_memcmp( id, "BMHD", 4 ) ) /* Bitmap header */
|
||||
{
|
||||
if ( !SDL_RWread( src, &bmhd, sizeof( BMHD ), 1 ) )
|
||||
{
|
||||
error="error reading BMHD chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
bytesloaded = sizeof( BMHD );
|
||||
|
||||
bmhd.w = SDL_SwapBE16( bmhd.w );
|
||||
bmhd.h = SDL_SwapBE16( bmhd.h );
|
||||
bmhd.x = SDL_SwapBE16( bmhd.x );
|
||||
bmhd.y = SDL_SwapBE16( bmhd.y );
|
||||
bmhd.tcolor = SDL_SwapBE16( bmhd.tcolor );
|
||||
bmhd.Lpage = SDL_SwapBE16( bmhd.Lpage );
|
||||
bmhd.Hpage = SDL_SwapBE16( bmhd.Hpage );
|
||||
}
|
||||
|
||||
if ( !SDL_memcmp( id, "CMAP", 4 ) ) /* palette ( Color Map ) */
|
||||
{
|
||||
if ( !SDL_RWread( src, &colormap, size, 1 ) )
|
||||
{
|
||||
error="error reading CMAP chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
bytesloaded = size;
|
||||
nbcolors = size / 3;
|
||||
}
|
||||
|
||||
if ( !SDL_memcmp( id, "CAMG", 4 ) ) /* Amiga ViewMode */
|
||||
{
|
||||
Uint32 viewmodes;
|
||||
if ( !SDL_RWread( src, &viewmodes, sizeof(viewmodes), 1 ) )
|
||||
{
|
||||
error="error reading CAMG chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
bytesloaded = size;
|
||||
viewmodes = SDL_SwapBE32( viewmodes );
|
||||
if ( viewmodes & 0x0800 )
|
||||
flagHAM = 1;
|
||||
if ( viewmodes & 0x0080 )
|
||||
flagEHB = 1;
|
||||
}
|
||||
|
||||
if ( SDL_memcmp( id, "BODY", 4 ) )
|
||||
{
|
||||
if ( size & 1 ) ++size; /* padding ! */
|
||||
size -= bytesloaded;
|
||||
/* skip the remaining bytes of this chunk */
|
||||
if ( size ) SDL_RWseek( src, size, RW_SEEK_CUR );
|
||||
}
|
||||
}
|
||||
|
||||
/* compute some usefull values, based on the bitmap header */
|
||||
|
||||
width = ( bmhd.w + 15 ) & 0xFFFFFFF0; /* Width in pixels modulo 16 */
|
||||
|
||||
bytesperline = ( ( bmhd.w + 15 ) / 16 ) * 2;
|
||||
|
||||
nbplanes = bmhd.planes;
|
||||
|
||||
if ( pbm ) /* File format : 'Packed Bitmap' */
|
||||
{
|
||||
bytesperline *= 8;
|
||||
nbplanes = 1;
|
||||
}
|
||||
|
||||
stencil = (bmhd.mask & 1); /* There is a mask ( 'stencil' ) */
|
||||
|
||||
/* Allocate memory for a temporary buffer ( used for
|
||||
decompression/deinterleaving ) */
|
||||
|
||||
MiniBuf = (Uint8 *)SDL_malloc( bytesperline * (nbplanes + stencil) );
|
||||
if ( MiniBuf == NULL )
|
||||
{
|
||||
error="no enough memory for temporary buffer";
|
||||
goto done;
|
||||
}
|
||||
|
||||
if ( ( Image = SDL_CreateRGBSurface( SDL_SWSURFACE, width, bmhd.h, (bmhd.planes==24 || flagHAM==1)?24:8, 0, 0, 0, 0 ) ) == NULL )
|
||||
goto done;
|
||||
|
||||
if ( bmhd.mask & 2 ) /* There is a transparent color */
|
||||
SDL_SetColorKey( Image, SDL_TRUE, bmhd.tcolor );
|
||||
|
||||
/* Update palette informations */
|
||||
|
||||
/* There is no palette in 24 bits ILBM file */
|
||||
if ( nbcolors>0 && flagHAM==0 )
|
||||
{
|
||||
/* FIXME: Should this include the stencil? See comment below */
|
||||
int nbrcolorsfinal = 1 << (nbplanes + stencil);
|
||||
ptr = &colormap[0];
|
||||
|
||||
for ( i=0; i<nbcolors; i++ )
|
||||
{
|
||||
Image->format->palette->colors[i].r = *ptr++;
|
||||
Image->format->palette->colors[i].g = *ptr++;
|
||||
Image->format->palette->colors[i].b = *ptr++;
|
||||
}
|
||||
|
||||
/* Amiga EHB mode (Extra-Half-Bright) */
|
||||
/* 6 bitplanes mode with a 32 colors palette */
|
||||
/* The 32 last colors are the same but divided by 2 */
|
||||
/* Some Amiga pictures save 64 colors with 32 last wrong colors, */
|
||||
/* they shouldn't !, and here we overwrite these 32 bad colors. */
|
||||
if ( (nbcolors==32 || flagEHB ) && (1<<bmhd.planes)==64 )
|
||||
{
|
||||
nbcolors = 64;
|
||||
ptr = &colormap[0];
|
||||
for ( i=32; i<64; i++ )
|
||||
{
|
||||
Image->format->palette->colors[i].r = (*ptr++)/2;
|
||||
Image->format->palette->colors[i].g = (*ptr++)/2;
|
||||
Image->format->palette->colors[i].b = (*ptr++)/2;
|
||||
}
|
||||
}
|
||||
|
||||
/* If nbcolors < 2^nbplanes, repeat the colormap */
|
||||
/* This happens when pictures have a stencil mask */
|
||||
if ( nbrcolorsfinal > (1<<bmhd.planes) ) {
|
||||
nbrcolorsfinal = (1<<bmhd.planes);
|
||||
}
|
||||
for ( i=nbcolors; i < (Uint32)nbrcolorsfinal; i++ )
|
||||
{
|
||||
Image->format->palette->colors[i].r = Image->format->palette->colors[i%nbcolors].r;
|
||||
Image->format->palette->colors[i].g = Image->format->palette->colors[i%nbcolors].g;
|
||||
Image->format->palette->colors[i].b = Image->format->palette->colors[i%nbcolors].b;
|
||||
}
|
||||
if ( !pbm )
|
||||
Image->format->palette->ncolors = nbrcolorsfinal;
|
||||
}
|
||||
|
||||
/* Get the bitmap */
|
||||
|
||||
for ( h=0; h < bmhd.h; h++ )
|
||||
{
|
||||
/* uncompress the datas of each planes */
|
||||
|
||||
for ( plane=0; plane < (nbplanes+stencil); plane++ )
|
||||
{
|
||||
ptr = MiniBuf + ( plane * bytesperline );
|
||||
|
||||
remainingbytes = bytesperline;
|
||||
|
||||
if ( bmhd.tcomp == 1 ) /* Datas are compressed */
|
||||
{
|
||||
do
|
||||
{
|
||||
if ( !SDL_RWread( src, &count, 1, 1 ) )
|
||||
{
|
||||
error="error reading BODY chunk";
|
||||
goto done;
|
||||
}
|
||||
|
||||
if ( count & 0x80 )
|
||||
{
|
||||
count ^= 0xFF;
|
||||
count += 2; /* now it */
|
||||
|
||||
if ( ( count > remainingbytes ) || !SDL_RWread( src, &color, 1, 1 ) )
|
||||
{
|
||||
error="error reading BODY chunk";
|
||||
goto done;
|
||||
}
|
||||
SDL_memset( ptr, color, count );
|
||||
}
|
||||
else
|
||||
{
|
||||
++count;
|
||||
|
||||
if ( ( count > remainingbytes ) || !SDL_RWread( src, ptr, count, 1 ) )
|
||||
{
|
||||
error="error reading BODY chunk";
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
ptr += count;
|
||||
remainingbytes -= count;
|
||||
|
||||
} while ( remainingbytes > 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !SDL_RWread( src, ptr, bytesperline, 1 ) )
|
||||
{
|
||||
error="error reading BODY chunk";
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* One line has been read, store it ! */
|
||||
|
||||
ptr = (Uint8 *)Image->pixels;
|
||||
if ( nbplanes==24 || flagHAM==1 )
|
||||
ptr += h * width * 3;
|
||||
else
|
||||
ptr += h * width;
|
||||
|
||||
if ( pbm ) /* File format : 'Packed Bitmap' */
|
||||
{
|
||||
SDL_memcpy( ptr, MiniBuf, width );
|
||||
}
|
||||
else /* We have to un-interlace the bits ! */
|
||||
{
|
||||
if ( nbplanes!=24 && flagHAM==0 )
|
||||
{
|
||||
size = ( width + 7 ) / 8;
|
||||
|
||||
for ( i=0; i < size; i++ )
|
||||
{
|
||||
memset( ptr, 0, 8 );
|
||||
|
||||
for ( plane=0; plane < (nbplanes + stencil); plane++ )
|
||||
{
|
||||
color = *( MiniBuf + i + ( plane * bytesperline ) );
|
||||
msk = 0x80;
|
||||
|
||||
for ( j=0; j<8; j++ )
|
||||
{
|
||||
if ( ( plane + j ) <= 7 ) ptr[j] |= (Uint8)( color & msk ) >> ( 7 - plane - j );
|
||||
else ptr[j] |= (Uint8)( color & msk ) << ( plane + j - 7 );
|
||||
|
||||
msk >>= 1;
|
||||
}
|
||||
}
|
||||
ptr += 8;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Uint32 finalcolor = 0;
|
||||
size = ( width + 7 ) / 8;
|
||||
/* 24 bitplanes ILBM : R0...R7,G0...G7,B0...B7 */
|
||||
/* or HAM (6 bitplanes) or HAM8 (8 bitplanes) modes */
|
||||
for ( i=0; i<width; i=i+8 )
|
||||
{
|
||||
Uint8 maskBit = 0x80;
|
||||
for ( j=0; j<8; j++ )
|
||||
{
|
||||
Uint32 pixelcolor = 0;
|
||||
Uint32 maskColor = 1;
|
||||
Uint8 dataBody;
|
||||
for ( plane=0; plane < nbplanes; plane++ )
|
||||
{
|
||||
dataBody = MiniBuf[ plane*size+i/8 ];
|
||||
if ( dataBody&maskBit )
|
||||
pixelcolor = pixelcolor | maskColor;
|
||||
maskColor = maskColor<<1;
|
||||
}
|
||||
/* HAM : 12 bits RGB image (4 bits per color component) */
|
||||
/* HAM8 : 18 bits RGB image (6 bits per color component) */
|
||||
if ( flagHAM )
|
||||
{
|
||||
switch( pixelcolor>>(nbplanes-2) )
|
||||
{
|
||||
case 0: /* take direct color from palette */
|
||||
finalcolor = colormap[ pixelcolor*3 ] + (colormap[ pixelcolor*3+1 ]<<8) + (colormap[ pixelcolor*3+2 ]<<16);
|
||||
break;
|
||||
case 1: /* modify only blue component */
|
||||
finalcolor = finalcolor&0x00FFFF;
|
||||
finalcolor = finalcolor | (pixelcolor<<(16+(10-nbplanes)));
|
||||
break;
|
||||
case 2: /* modify only red component */
|
||||
finalcolor = finalcolor&0xFFFF00;
|
||||
finalcolor = finalcolor | pixelcolor<<(10-nbplanes);
|
||||
break;
|
||||
case 3: /* modify only green component */
|
||||
finalcolor = finalcolor&0xFF00FF;
|
||||
finalcolor = finalcolor | (pixelcolor<<(8+(10-nbplanes)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
finalcolor = pixelcolor;
|
||||
}
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
*ptr++ = (Uint8)(finalcolor>>16);
|
||||
*ptr++ = (Uint8)(finalcolor>>8);
|
||||
*ptr++ = (Uint8)(finalcolor);
|
||||
#else
|
||||
*ptr++ = (Uint8)(finalcolor);
|
||||
*ptr++ = (Uint8)(finalcolor>>8);
|
||||
*ptr++ = (Uint8)(finalcolor>>16);
|
||||
#endif
|
||||
maskBit = maskBit>>1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
|
||||
if ( MiniBuf ) SDL_free( MiniBuf );
|
||||
|
||||
if ( error )
|
||||
{
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( Image ) {
|
||||
SDL_FreeSurface( Image );
|
||||
Image = NULL;
|
||||
}
|
||||
IMG_SetError( error );
|
||||
}
|
||||
|
||||
return( Image );
|
||||
}
|
||||
|
||||
#else /* LOAD_LBM */
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isLBM(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load an IFF type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadLBM_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_LBM */
|
||||
@@ -0,0 +1,276 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* PCX file reader:
|
||||
* Supports:
|
||||
* 1..4 bits/pixel in multiplanar format (1 bit/plane/pixel)
|
||||
* 8 bits/pixel in single-planar format (8 bits/plane/pixel)
|
||||
* 24 bits/pixel in 3-plane format (8 bits/plane/pixel)
|
||||
*
|
||||
* (The <8bpp formats are expanded to 8bpp surfaces)
|
||||
*
|
||||
* Doesn't support:
|
||||
* single-planar packed-pixel formats other than 8bpp
|
||||
* 4-plane 32bpp format with a fourth "intensity" plane
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "SDL_endian.h"
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_PCX
|
||||
|
||||
struct PCXheader {
|
||||
Uint8 Manufacturer;
|
||||
Uint8 Version;
|
||||
Uint8 Encoding;
|
||||
Uint8 BitsPerPixel;
|
||||
Sint16 Xmin, Ymin, Xmax, Ymax;
|
||||
Sint16 HDpi, VDpi;
|
||||
Uint8 Colormap[48];
|
||||
Uint8 Reserved;
|
||||
Uint8 NPlanes;
|
||||
Sint16 BytesPerLine;
|
||||
Sint16 PaletteInfo;
|
||||
Sint16 HscreenSize;
|
||||
Sint16 VscreenSize;
|
||||
Uint8 Filler[54];
|
||||
};
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPCX(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_PCX;
|
||||
const int ZSoft_Manufacturer = 10;
|
||||
const int PC_Paintbrush_Version = 5;
|
||||
const int PCX_Uncompressed_Encoding = 0;
|
||||
const int PCX_RunLength_Encoding = 1;
|
||||
struct PCXheader pcxh;
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_PCX = 0;
|
||||
if ( SDL_RWread(src, &pcxh, sizeof(pcxh), 1) == 1 ) {
|
||||
if ( (pcxh.Manufacturer == ZSoft_Manufacturer) &&
|
||||
(pcxh.Version == PC_Paintbrush_Version) &&
|
||||
(pcxh.Encoding == PCX_RunLength_Encoding ||
|
||||
pcxh.Encoding == PCX_Uncompressed_Encoding) ) {
|
||||
is_PCX = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_PCX);
|
||||
}
|
||||
|
||||
/* Load a PCX type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadPCX_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
struct PCXheader pcxh;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
Uint32 Amask;
|
||||
SDL_Surface *surface = NULL;
|
||||
int width, height;
|
||||
int y, bpl;
|
||||
Uint8 *row, *buf = NULL;
|
||||
char *error = NULL;
|
||||
int bits, src_bits;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( ! SDL_RWread(src, &pcxh, sizeof(pcxh), 1) ) {
|
||||
error = "file truncated";
|
||||
goto done;
|
||||
}
|
||||
pcxh.Xmin = SDL_SwapLE16(pcxh.Xmin);
|
||||
pcxh.Ymin = SDL_SwapLE16(pcxh.Ymin);
|
||||
pcxh.Xmax = SDL_SwapLE16(pcxh.Xmax);
|
||||
pcxh.Ymax = SDL_SwapLE16(pcxh.Ymax);
|
||||
pcxh.BytesPerLine = SDL_SwapLE16(pcxh.BytesPerLine);
|
||||
|
||||
/* Create the surface of the appropriate type */
|
||||
width = (pcxh.Xmax - pcxh.Xmin) + 1;
|
||||
height = (pcxh.Ymax - pcxh.Ymin) + 1;
|
||||
Rmask = Gmask = Bmask = Amask = 0;
|
||||
src_bits = pcxh.BitsPerPixel * pcxh.NPlanes;
|
||||
if((pcxh.BitsPerPixel == 1 && pcxh.NPlanes >= 1 && pcxh.NPlanes <= 4)
|
||||
|| (pcxh.BitsPerPixel == 8 && pcxh.NPlanes == 1)) {
|
||||
bits = 8;
|
||||
} else if(pcxh.BitsPerPixel == 8 && pcxh.NPlanes == 3) {
|
||||
bits = 24;
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
Rmask = 0x000000FF;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x00FF0000;
|
||||
#else
|
||||
Rmask = 0xFF0000;
|
||||
Gmask = 0x00FF00;
|
||||
Bmask = 0x0000FF;
|
||||
#endif
|
||||
} else {
|
||||
error = "unsupported PCX format";
|
||||
goto done;
|
||||
}
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
|
||||
bits, Rmask, Gmask, Bmask, Amask);
|
||||
if ( surface == NULL )
|
||||
goto done;
|
||||
|
||||
bpl = pcxh.NPlanes * pcxh.BytesPerLine;
|
||||
if (bpl > surface->pitch) {
|
||||
error = "bytes per line is too large (corrupt?)";
|
||||
}
|
||||
buf = (Uint8 *)SDL_malloc(bpl);
|
||||
row = (Uint8 *)surface->pixels;
|
||||
for ( y=0; y<surface->h; ++y ) {
|
||||
/* decode a scan line to a temporary buffer first */
|
||||
int i, count = 0;
|
||||
Uint8 ch;
|
||||
Uint8 *dst = (src_bits == 8) ? row : buf;
|
||||
if ( pcxh.Encoding == 0 ) {
|
||||
if(!SDL_RWread(src, dst, bpl, 1)) {
|
||||
error = "file truncated";
|
||||
goto done;
|
||||
}
|
||||
} else {
|
||||
for(i = 0; i < bpl; i++) {
|
||||
if(!count) {
|
||||
if(!SDL_RWread(src, &ch, 1, 1)) {
|
||||
error = "file truncated";
|
||||
goto done;
|
||||
}
|
||||
if( (ch & 0xc0) == 0xc0) {
|
||||
count = ch & 0x3f;
|
||||
if(!SDL_RWread(src, &ch, 1, 1)) {
|
||||
error = "file truncated";
|
||||
goto done;
|
||||
}
|
||||
} else
|
||||
count = 1;
|
||||
}
|
||||
dst[i] = ch;
|
||||
count--;
|
||||
}
|
||||
}
|
||||
|
||||
if(src_bits <= 4) {
|
||||
/* expand planes to 1 byte/pixel */
|
||||
Uint8 *innerSrc = buf;
|
||||
int plane;
|
||||
for(plane = 0; plane < pcxh.NPlanes; plane++) {
|
||||
int j, k, x = 0;
|
||||
for(j = 0; j < pcxh.BytesPerLine; j++) {
|
||||
Uint8 byte = *innerSrc++;
|
||||
for(k = 7; k >= 0; k--) {
|
||||
unsigned bit = (byte >> k) & 1;
|
||||
/* skip padding bits */
|
||||
if (j * 8 + k >= width)
|
||||
continue;
|
||||
row[x++] |= bit << plane;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if(src_bits == 24) {
|
||||
/* de-interlace planes */
|
||||
Uint8 *innerSrc = buf;
|
||||
int plane;
|
||||
for(plane = 0; plane < pcxh.NPlanes; plane++) {
|
||||
int x;
|
||||
dst = row + plane;
|
||||
for(x = 0; x < width; x++) {
|
||||
*dst = *innerSrc++;
|
||||
dst += pcxh.NPlanes;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
row += surface->pitch;
|
||||
}
|
||||
|
||||
if(bits == 8) {
|
||||
SDL_Color *colors = surface->format->palette->colors;
|
||||
int nc = 1 << src_bits;
|
||||
int i;
|
||||
|
||||
surface->format->palette->ncolors = nc;
|
||||
if(src_bits == 8) {
|
||||
Uint8 ch;
|
||||
/* look for a 256-colour palette */
|
||||
do {
|
||||
if ( !SDL_RWread(src, &ch, 1, 1)) {
|
||||
error = "file truncated";
|
||||
goto done;
|
||||
}
|
||||
} while ( ch != 12 );
|
||||
|
||||
for(i = 0; i < 256; i++) {
|
||||
SDL_RWread(src, &colors[i].r, 1, 1);
|
||||
SDL_RWread(src, &colors[i].g, 1, 1);
|
||||
SDL_RWread(src, &colors[i].b, 1, 1);
|
||||
}
|
||||
} else {
|
||||
for(i = 0; i < nc; i++) {
|
||||
colors[i].r = pcxh.Colormap[i * 3];
|
||||
colors[i].g = pcxh.Colormap[i * 3 + 1];
|
||||
colors[i].b = pcxh.Colormap[i * 3 + 2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
SDL_free(buf);
|
||||
if ( error ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
return(surface);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPCX(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a PCX type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadPCX_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_PCX */
|
||||
@@ -0,0 +1,646 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a PNG image file loading framework */
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
#ifdef LOAD_PNG
|
||||
|
||||
/*=============================================================================
|
||||
File: SDL_png.c
|
||||
Purpose: A PNG loader and saver for the SDL library
|
||||
Revision:
|
||||
Created by: Philippe Lavoie (2 November 1998)
|
||||
lavoie@zeus.genie.uottawa.ca
|
||||
Modified by:
|
||||
|
||||
Copyright notice:
|
||||
Copyright (C) 1998 Philippe Lavoie
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
Comments: The load and save routine are basically the ones you can find
|
||||
in the example.c file from the libpng distribution.
|
||||
|
||||
Changes:
|
||||
5/17/99 - Modified to use the new SDL data sources - Sam Lantinga
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "SDL_endian.h"
|
||||
|
||||
#ifdef macintosh
|
||||
#define MACOS
|
||||
#endif
|
||||
#include <png.h>
|
||||
|
||||
/* Check for the older version of libpng */
|
||||
#if (PNG_LIBPNG_VER_MAJOR == 1)
|
||||
#if (PNG_LIBPNG_VER_MINOR < 4)
|
||||
#define LIBPNG_VERSION_12
|
||||
typedef png_bytep png_const_bytep;
|
||||
#endif
|
||||
#if (PNG_LIBPNG_VER_MINOR < 6)
|
||||
typedef png_structp png_const_structrp;
|
||||
typedef png_infop png_const_inforp;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static struct {
|
||||
int loaded;
|
||||
void *handle;
|
||||
png_infop (*png_create_info_struct) (png_const_structrp png_ptr);
|
||||
png_structp (*png_create_read_struct) (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn);
|
||||
void (*png_destroy_read_struct) (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr);
|
||||
png_uint_32 (*png_get_IHDR) (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, int *interlace_method, int *compression_method, int *filter_method);
|
||||
png_voidp (*png_get_io_ptr) (png_const_structrp png_ptr);
|
||||
png_byte (*png_get_channels) (png_const_structrp png_ptr, png_const_inforp info_ptr);
|
||||
png_uint_32 (*png_get_PLTE) (png_const_structrp png_ptr, png_infop info_ptr, png_colorp *palette, int *num_palette);
|
||||
png_uint_32 (*png_get_tRNS) (png_const_structrp png_ptr, png_infop info_ptr, png_bytep *trans, int *num_trans, png_color_16p *trans_values);
|
||||
png_uint_32 (*png_get_valid) (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 flag);
|
||||
void (*png_read_image) (png_structp png_ptr, png_bytepp image);
|
||||
void (*png_read_info) (png_structp png_ptr, png_infop info_ptr);
|
||||
void (*png_read_update_info) (png_structp png_ptr, png_infop info_ptr);
|
||||
void (*png_set_expand) (png_structp png_ptr);
|
||||
void (*png_set_gray_to_rgb) (png_structp png_ptr);
|
||||
void (*png_set_packing) (png_structp png_ptr);
|
||||
void (*png_set_read_fn) (png_structp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn);
|
||||
void (*png_set_strip_16) (png_structp png_ptr);
|
||||
int (*png_sig_cmp) (png_const_bytep sig, png_size_t start, png_size_t num_to_check);
|
||||
#ifndef LIBPNG_VERSION_12
|
||||
jmp_buf* (*png_set_longjmp_fn) (png_structp, png_longjmp_ptr, size_t);
|
||||
#endif
|
||||
} lib;
|
||||
|
||||
#ifdef LOAD_PNG_DYNAMIC
|
||||
int IMG_InitPNG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.handle = SDL_LoadObject(LOAD_PNG_DYNAMIC);
|
||||
if ( lib.handle == NULL ) {
|
||||
return -1;
|
||||
}
|
||||
lib.png_create_info_struct =
|
||||
(png_infop (*) (png_const_structrp))
|
||||
SDL_LoadFunction(lib.handle, "png_create_info_struct");
|
||||
if ( lib.png_create_info_struct == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_create_read_struct =
|
||||
(png_structp (*) (png_const_charp, png_voidp, png_error_ptr, png_error_ptr))
|
||||
SDL_LoadFunction(lib.handle, "png_create_read_struct");
|
||||
if ( lib.png_create_read_struct == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_destroy_read_struct =
|
||||
(void (*) (png_structpp, png_infopp, png_infopp))
|
||||
SDL_LoadFunction(lib.handle, "png_destroy_read_struct");
|
||||
if ( lib.png_destroy_read_struct == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_IHDR =
|
||||
(png_uint_32 (*) (png_const_structrp, png_const_inforp, png_uint_32 *, png_uint_32 *, int *, int *, int *, int *, int *))
|
||||
SDL_LoadFunction(lib.handle, "png_get_IHDR");
|
||||
if ( lib.png_get_IHDR == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_channels =
|
||||
(png_byte (*) (png_const_structrp, png_const_inforp))
|
||||
SDL_LoadFunction(lib.handle, "png_get_channels");
|
||||
if ( lib.png_get_channels == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_io_ptr =
|
||||
(png_voidp (*) (png_const_structrp))
|
||||
SDL_LoadFunction(lib.handle, "png_get_io_ptr");
|
||||
if ( lib.png_get_io_ptr == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_PLTE =
|
||||
(png_uint_32 (*) (png_const_structrp, png_infop, png_colorp *, int *))
|
||||
SDL_LoadFunction(lib.handle, "png_get_PLTE");
|
||||
if ( lib.png_get_PLTE == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_tRNS =
|
||||
(png_uint_32 (*) (png_const_structrp, png_infop, png_bytep *, int *, png_color_16p *))
|
||||
SDL_LoadFunction(lib.handle, "png_get_tRNS");
|
||||
if ( lib.png_get_tRNS == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_get_valid =
|
||||
(png_uint_32 (*) (png_const_structrp, png_const_inforp, png_uint_32))
|
||||
SDL_LoadFunction(lib.handle, "png_get_valid");
|
||||
if ( lib.png_get_valid == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_read_image =
|
||||
(void (*) (png_structp, png_bytepp))
|
||||
SDL_LoadFunction(lib.handle, "png_read_image");
|
||||
if ( lib.png_read_image == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_read_info =
|
||||
(void (*) (png_structp, png_infop))
|
||||
SDL_LoadFunction(lib.handle, "png_read_info");
|
||||
if ( lib.png_read_info == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_read_update_info =
|
||||
(void (*) (png_structp, png_infop))
|
||||
SDL_LoadFunction(lib.handle, "png_read_update_info");
|
||||
if ( lib.png_read_update_info == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_set_expand =
|
||||
(void (*) (png_structp))
|
||||
SDL_LoadFunction(lib.handle, "png_set_expand");
|
||||
if ( lib.png_set_expand == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_set_gray_to_rgb =
|
||||
(void (*) (png_structp))
|
||||
SDL_LoadFunction(lib.handle, "png_set_gray_to_rgb");
|
||||
if ( lib.png_set_gray_to_rgb == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_set_packing =
|
||||
(void (*) (png_structp))
|
||||
SDL_LoadFunction(lib.handle, "png_set_packing");
|
||||
if ( lib.png_set_packing == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_set_read_fn =
|
||||
(void (*) (png_structp, png_voidp, png_rw_ptr))
|
||||
SDL_LoadFunction(lib.handle, "png_set_read_fn");
|
||||
if ( lib.png_set_read_fn == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_set_strip_16 =
|
||||
(void (*) (png_structp))
|
||||
SDL_LoadFunction(lib.handle, "png_set_strip_16");
|
||||
if ( lib.png_set_strip_16 == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.png_sig_cmp =
|
||||
(int (*) (png_const_bytep, png_size_t, png_size_t))
|
||||
SDL_LoadFunction(lib.handle, "png_sig_cmp");
|
||||
if ( lib.png_sig_cmp == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
#ifndef LIBPNG_VERSION_12
|
||||
lib.png_set_longjmp_fn =
|
||||
(jmp_buf * (*) (png_structp, png_longjmp_ptr, size_t))
|
||||
SDL_LoadFunction(lib.handle, "png_set_longjmp_fn");
|
||||
if ( lib.png_set_longjmp_fn == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitPNG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#else
|
||||
int IMG_InitPNG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.png_create_info_struct = png_create_info_struct;
|
||||
lib.png_create_read_struct = png_create_read_struct;
|
||||
lib.png_destroy_read_struct = png_destroy_read_struct;
|
||||
lib.png_get_IHDR = png_get_IHDR;
|
||||
lib.png_get_channels = png_get_channels;
|
||||
lib.png_get_io_ptr = png_get_io_ptr;
|
||||
lib.png_get_PLTE = png_get_PLTE;
|
||||
lib.png_get_tRNS = png_get_tRNS;
|
||||
lib.png_get_valid = png_get_valid;
|
||||
lib.png_read_image = png_read_image;
|
||||
lib.png_read_info = png_read_info;
|
||||
lib.png_read_update_info = png_read_update_info;
|
||||
lib.png_set_expand = png_set_expand;
|
||||
lib.png_set_gray_to_rgb = png_set_gray_to_rgb;
|
||||
lib.png_set_packing = png_set_packing;
|
||||
lib.png_set_read_fn = png_set_read_fn;
|
||||
lib.png_set_strip_16 = png_set_strip_16;
|
||||
lib.png_sig_cmp = png_sig_cmp;
|
||||
#ifndef LIBPNG_VERSION_12
|
||||
lib.png_set_longjmp_fn = png_set_longjmp_fn;
|
||||
#endif
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitPNG()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#endif /* LOAD_PNG_DYNAMIC */
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPNG(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_PNG;
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( !src ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
start = SDL_RWtell(src);
|
||||
is_PNG = 0;
|
||||
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( magic[0] == 0x89 &&
|
||||
magic[1] == 'P' &&
|
||||
magic[2] == 'N' &&
|
||||
magic[3] == 'G' ) {
|
||||
is_PNG = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_PNG);
|
||||
}
|
||||
|
||||
/* Load a PNG type image from an SDL datasource */
|
||||
static void png_read_data(png_structp ctx, png_bytep area, png_size_t size)
|
||||
{
|
||||
SDL_RWops *src;
|
||||
|
||||
src = (SDL_RWops *)lib.png_get_io_ptr(ctx);
|
||||
SDL_RWread(src, area, size, 1);
|
||||
}
|
||||
SDL_Surface *IMG_LoadPNG_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
const char *error;
|
||||
SDL_Surface *volatile surface;
|
||||
png_structp png_ptr;
|
||||
png_infop info_ptr;
|
||||
png_uint_32 width, height;
|
||||
int bit_depth, color_type, interlace_type, num_channels;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
Uint32 Amask;
|
||||
SDL_Palette *palette;
|
||||
png_bytep *volatile row_pointers;
|
||||
int row, i;
|
||||
int ckey = -1;
|
||||
png_color_16 *transv;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( !IMG_Init(IMG_INIT_PNG) ) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Initialize the data we will clean up when we're done */
|
||||
error = NULL;
|
||||
png_ptr = NULL; info_ptr = NULL; row_pointers = NULL; surface = NULL;
|
||||
|
||||
/* Create the PNG loading context structure */
|
||||
png_ptr = lib.png_create_read_struct(PNG_LIBPNG_VER_STRING,
|
||||
NULL,NULL,NULL);
|
||||
if (png_ptr == NULL){
|
||||
error = "Couldn't allocate memory for PNG file or incompatible PNG dll";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Allocate/initialize the memory for image information. REQUIRED. */
|
||||
info_ptr = lib.png_create_info_struct(png_ptr);
|
||||
if (info_ptr == NULL) {
|
||||
error = "Couldn't create image information for PNG file";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Set error handling if you are using setjmp/longjmp method (this is
|
||||
* the normal method of doing things with libpng). REQUIRED unless you
|
||||
* set up your own error handlers in png_create_read_struct() earlier.
|
||||
*/
|
||||
#ifndef LIBPNG_VERSION_12
|
||||
if ( setjmp(*lib.png_set_longjmp_fn(png_ptr, longjmp, sizeof (jmp_buf))) )
|
||||
#else
|
||||
if ( setjmp(png_ptr->jmpbuf) )
|
||||
#endif
|
||||
{
|
||||
error = "Error reading the PNG file.";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Set up the input control */
|
||||
lib.png_set_read_fn(png_ptr, src, png_read_data);
|
||||
|
||||
/* Read PNG header info */
|
||||
lib.png_read_info(png_ptr, info_ptr);
|
||||
lib.png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth,
|
||||
&color_type, &interlace_type, NULL, NULL);
|
||||
|
||||
/* tell libpng to strip 16 bit/color files down to 8 bits/color */
|
||||
lib.png_set_strip_16(png_ptr) ;
|
||||
|
||||
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
|
||||
* byte into separate bytes (useful for paletted and grayscale images).
|
||||
*/
|
||||
lib.png_set_packing(png_ptr);
|
||||
|
||||
/* scale greyscale values to the range 0..255 */
|
||||
if (color_type == PNG_COLOR_TYPE_GRAY)
|
||||
lib.png_set_expand(png_ptr);
|
||||
|
||||
/* For images with a single "transparent colour", set colour key;
|
||||
if more than one index has transparency, or if partially transparent
|
||||
entries exist, use full alpha channel */
|
||||
if (lib.png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
|
||||
int num_trans;
|
||||
Uint8 *trans;
|
||||
lib.png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, &transv);
|
||||
if (color_type == PNG_COLOR_TYPE_PALETTE) {
|
||||
/* Check if all tRNS entries are opaque except one */
|
||||
int j, t = -1;
|
||||
for (j = 0; j < num_trans; j++) {
|
||||
if (trans[j] == 0) {
|
||||
if (t >= 0) {
|
||||
break;
|
||||
}
|
||||
t = j;
|
||||
} else if (trans[j] != 255) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (j == num_trans) {
|
||||
/* exactly one transparent index */
|
||||
ckey = t;
|
||||
} else {
|
||||
/* more than one transparent index, or translucency */
|
||||
lib.png_set_expand(png_ptr);
|
||||
}
|
||||
} else {
|
||||
ckey = 0; /* actual value will be set later */
|
||||
}
|
||||
}
|
||||
|
||||
if ( color_type == PNG_COLOR_TYPE_GRAY_ALPHA )
|
||||
lib.png_set_gray_to_rgb(png_ptr);
|
||||
|
||||
lib.png_read_update_info(png_ptr, info_ptr);
|
||||
|
||||
lib.png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth,
|
||||
&color_type, &interlace_type, NULL, NULL);
|
||||
|
||||
/* Allocate the SDL surface to hold the image */
|
||||
Rmask = Gmask = Bmask = Amask = 0 ;
|
||||
num_channels = lib.png_get_channels(png_ptr, info_ptr);
|
||||
if ( num_channels >= 3 ) {
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
Rmask = 0x000000FF;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x00FF0000;
|
||||
Amask = (num_channels == 4) ? 0xFF000000 : 0;
|
||||
#else
|
||||
int s = (num_channels == 4) ? 0 : 8;
|
||||
Rmask = 0xFF000000 >> s;
|
||||
Gmask = 0x00FF0000 >> s;
|
||||
Bmask = 0x0000FF00 >> s;
|
||||
Amask = 0x000000FF >> s;
|
||||
#endif
|
||||
}
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height,
|
||||
bit_depth*num_channels, Rmask,Gmask,Bmask,Amask);
|
||||
if ( surface == NULL ) {
|
||||
error = SDL_GetError();
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (ckey != -1) {
|
||||
if (color_type != PNG_COLOR_TYPE_PALETTE) {
|
||||
/* FIXME: Should these be truncated or shifted down? */
|
||||
ckey = SDL_MapRGB(surface->format,
|
||||
(Uint8)transv->red,
|
||||
(Uint8)transv->green,
|
||||
(Uint8)transv->blue);
|
||||
}
|
||||
SDL_SetColorKey(surface, SDL_TRUE, ckey);
|
||||
}
|
||||
|
||||
/* Create the array of pointers to image data */
|
||||
row_pointers = (png_bytep*) SDL_malloc(sizeof(png_bytep)*height);
|
||||
if ( (row_pointers == NULL) ) {
|
||||
error = "Out of memory";
|
||||
goto done;
|
||||
}
|
||||
for (row = 0; row < (int)height; row++) {
|
||||
row_pointers[row] = (png_bytep)
|
||||
(Uint8 *)surface->pixels + row*surface->pitch;
|
||||
}
|
||||
|
||||
/* Read the entire image in one go */
|
||||
lib.png_read_image(png_ptr, row_pointers);
|
||||
|
||||
/* and we're done! (png_read_end() can be omitted if no processing of
|
||||
* post-IDAT text/time/etc. is desired)
|
||||
* In some cases it can't read PNG's created by some popular programs (ACDSEE),
|
||||
* we do not want to process comments, so we omit png_read_end
|
||||
|
||||
lib.png_read_end(png_ptr, info_ptr);
|
||||
*/
|
||||
|
||||
/* Load the palette, if any */
|
||||
palette = surface->format->palette;
|
||||
if ( palette ) {
|
||||
int png_num_palette;
|
||||
png_colorp png_palette;
|
||||
lib.png_get_PLTE(png_ptr, info_ptr, &png_palette, &png_num_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 (png_num_palette > 0 ) {
|
||||
palette->ncolors = png_num_palette;
|
||||
for ( i=0; i<png_num_palette; ++i ) {
|
||||
palette->colors[i].b = png_palette[i].blue;
|
||||
palette->colors[i].g = png_palette[i].green;
|
||||
palette->colors[i].r = png_palette[i].red;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done: /* Clean up and return */
|
||||
if ( png_ptr ) {
|
||||
lib.png_destroy_read_struct(&png_ptr,
|
||||
info_ptr ? &info_ptr : (png_infopp)0,
|
||||
(png_infopp)0);
|
||||
}
|
||||
if ( row_pointers ) {
|
||||
SDL_free(row_pointers);
|
||||
}
|
||||
if ( error ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
return(surface);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int IMG_InitPNG()
|
||||
{
|
||||
IMG_SetError("PNG images are not supported");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
void IMG_QuitPNG()
|
||||
{
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPNG(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a PNG type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadPNG_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_PNG */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
|
||||
/* We'll always have PNG save support */
|
||||
#define SAVE_PNG
|
||||
|
||||
#ifdef SAVE_PNG
|
||||
|
||||
#include "miniz.h"
|
||||
|
||||
int IMG_SavePNG(SDL_Surface *surface, const char *file)
|
||||
{
|
||||
SDL_RWops *dst = SDL_RWFromFile(file, "wb");
|
||||
if (dst) {
|
||||
return IMG_SavePNG_RW(surface, dst, 1);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst)
|
||||
{
|
||||
int result = -1;
|
||||
|
||||
if (dst) {
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
static const Uint32 png_format = SDL_PIXELFORMAT_ABGR8888;
|
||||
#else
|
||||
static const Uint32 png_format = SDL_PIXELFORMAT_RGBA8888;
|
||||
#endif
|
||||
size_t size;
|
||||
void *png;
|
||||
|
||||
if (surface->format->format == png_format) {
|
||||
png = tdefl_write_image_to_png_file_in_memory(surface->pixels, surface->w, surface->h, surface->pitch, surface->format->BytesPerPixel, &size);
|
||||
} else {
|
||||
SDL_Surface *cvt = SDL_ConvertSurfaceFormat(surface, png_format, 0);
|
||||
if (cvt) {
|
||||
png = tdefl_write_image_to_png_file_in_memory(cvt->pixels, cvt->w, cvt->h, cvt->pitch, cvt->format->BytesPerPixel, &size);
|
||||
SDL_FreeSurface(cvt);
|
||||
}
|
||||
}
|
||||
if (png) {
|
||||
if (SDL_RWwrite(dst, png, size, 1)) {
|
||||
result = 0;
|
||||
}
|
||||
SDL_free(png);
|
||||
} else {
|
||||
SDL_SetError("Failed to convert and save image");
|
||||
}
|
||||
if (freedst) {
|
||||
SDL_RWclose(dst);
|
||||
}
|
||||
} else {
|
||||
SDL_SetError("Passed NULL dst");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif /* SAVE_PNG */
|
||||
@@ -0,0 +1,258 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* PNM (portable anymap) image loader:
|
||||
*
|
||||
* Supports: PBM, PGM and PPM, ASCII and binary formats
|
||||
* (PBM and PGM are loaded as 8bpp surfaces)
|
||||
* Does not support: maximum component value > 255
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_PNM
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPNM(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_PNM;
|
||||
char magic[2];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_PNM = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
/*
|
||||
* PNM magic signatures:
|
||||
* P1 PBM, ascii format
|
||||
* P2 PGM, ascii format
|
||||
* P3 PPM, ascii format
|
||||
* P4 PBM, binary format
|
||||
* P5 PGM, binary format
|
||||
* P6 PPM, binary format
|
||||
* P7 PAM, a general wrapper for PNM data
|
||||
*/
|
||||
if ( magic[0] == 'P' && magic[1] >= '1' && magic[1] <= '6' ) {
|
||||
is_PNM = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_PNM);
|
||||
}
|
||||
|
||||
/* read a non-negative integer from the source. return -1 upon error */
|
||||
static int ReadNumber(SDL_RWops *src)
|
||||
{
|
||||
int number;
|
||||
unsigned char ch;
|
||||
|
||||
/* Initialize return value */
|
||||
number = 0;
|
||||
|
||||
/* Skip leading whitespace */
|
||||
do {
|
||||
if ( ! SDL_RWread(src, &ch, 1, 1) ) {
|
||||
return(0);
|
||||
}
|
||||
/* Eat comments as whitespace */
|
||||
if ( ch == '#' ) { /* Comment is '#' to end of line */
|
||||
do {
|
||||
if ( ! SDL_RWread(src, &ch, 1, 1) ) {
|
||||
return -1;
|
||||
}
|
||||
} while ( (ch != '\r') && (ch != '\n') );
|
||||
}
|
||||
} while ( isspace(ch) );
|
||||
|
||||
/* Add up the number */
|
||||
do {
|
||||
number *= 10;
|
||||
number += ch-'0';
|
||||
|
||||
if ( !SDL_RWread(src, &ch, 1, 1) ) {
|
||||
return -1;
|
||||
}
|
||||
} while ( isdigit(ch) );
|
||||
|
||||
return(number);
|
||||
}
|
||||
|
||||
SDL_Surface *IMG_LoadPNM_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
SDL_Surface *surface = NULL;
|
||||
int width, height;
|
||||
int maxval, y, bpl;
|
||||
Uint8 *row;
|
||||
Uint8 *buf = NULL;
|
||||
char *error = NULL;
|
||||
Uint8 magic[2];
|
||||
int ascii;
|
||||
enum { PBM, PGM, PPM, PAM } kind;
|
||||
|
||||
#define ERROR(s) do { error = (s); goto done; } while(0)
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
SDL_RWread(src, magic, 2, 1);
|
||||
kind = magic[1] - '1';
|
||||
ascii = 1;
|
||||
if(kind >= 3) {
|
||||
ascii = 0;
|
||||
kind -= 3;
|
||||
}
|
||||
|
||||
width = ReadNumber(src);
|
||||
height = ReadNumber(src);
|
||||
if(width <= 0 || height <= 0)
|
||||
ERROR("Unable to read image width and height");
|
||||
|
||||
if(kind != PBM) {
|
||||
maxval = ReadNumber(src);
|
||||
if(maxval <= 0 || maxval > 255)
|
||||
ERROR("unsupported PNM format");
|
||||
} else
|
||||
maxval = 255; /* never scale PBMs */
|
||||
|
||||
/* binary PNM allows just a single character of whitespace after
|
||||
the last parameter, and we've already consumed it */
|
||||
|
||||
if(kind == PPM) {
|
||||
/* 24-bit surface in R,G,B byte order */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 24,
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
0x000000ff, 0x0000ff00, 0x00ff0000,
|
||||
#else
|
||||
0x00ff0000, 0x0000ff00, 0x000000ff,
|
||||
#endif
|
||||
0);
|
||||
} else {
|
||||
/* load PBM/PGM as 8-bit indexed images */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 8,
|
||||
0, 0, 0, 0);
|
||||
}
|
||||
if ( surface == NULL )
|
||||
ERROR("Out of memory");
|
||||
bpl = width * surface->format->BytesPerPixel;
|
||||
if(kind == PGM) {
|
||||
SDL_Color *c = surface->format->palette->colors;
|
||||
int i;
|
||||
for(i = 0; i < 256; i++)
|
||||
c[i].r = c[i].g = c[i].b = i;
|
||||
surface->format->palette->ncolors = 256;
|
||||
} else if(kind == PBM) {
|
||||
/* for some reason PBM has 1=black, 0=white */
|
||||
SDL_Color *c = surface->format->palette->colors;
|
||||
c[0].r = c[0].g = c[0].b = 255;
|
||||
c[1].r = c[1].g = c[1].b = 0;
|
||||
surface->format->palette->ncolors = 2;
|
||||
bpl = (width + 7) >> 3;
|
||||
buf = (Uint8 *)SDL_malloc(bpl);
|
||||
if(buf == NULL)
|
||||
ERROR("Out of memory");
|
||||
}
|
||||
|
||||
/* Read the image into the surface */
|
||||
row = (Uint8 *)surface->pixels;
|
||||
for(y = 0; y < height; y++) {
|
||||
if(ascii) {
|
||||
int i;
|
||||
if(kind == PBM) {
|
||||
for(i = 0; i < width; i++) {
|
||||
Uint8 ch;
|
||||
do {
|
||||
if(!SDL_RWread(src, &ch,
|
||||
1, 1))
|
||||
ERROR("file truncated");
|
||||
ch -= '0';
|
||||
} while(ch > 1);
|
||||
row[i] = ch;
|
||||
}
|
||||
} else {
|
||||
for(i = 0; i < bpl; i++) {
|
||||
int c;
|
||||
c = ReadNumber(src);
|
||||
if(c < 0)
|
||||
ERROR("file truncated");
|
||||
row[i] = c;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Uint8 *dst = (kind == PBM) ? buf : row;
|
||||
if(!SDL_RWread(src, dst, bpl, 1))
|
||||
ERROR("file truncated");
|
||||
if(kind == PBM) {
|
||||
/* expand bitmap to 8bpp */
|
||||
int i;
|
||||
for(i = 0; i < width; i++) {
|
||||
int bit = 7 - (i & 7);
|
||||
row[i] = (buf[i >> 3] >> bit) & 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(maxval < 255) {
|
||||
/* scale up to full dynamic range (slow) */
|
||||
int i;
|
||||
for(i = 0; i < bpl; i++)
|
||||
row[i] = row[i] * 255 / maxval;
|
||||
}
|
||||
row += surface->pitch;
|
||||
}
|
||||
done:
|
||||
SDL_free(buf);
|
||||
if(error) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
return(surface);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isPNM(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a PNM type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadPNM_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_PNM */
|
||||
@@ -0,0 +1,340 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
/* This is a Targa image file loading framework */
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_endian.h"
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_TGA
|
||||
|
||||
/*
|
||||
* A TGA loader for the SDL library
|
||||
* Supports: Reading 8, 15, 16, 24 and 32bpp images, with alpha or colourkey,
|
||||
* uncompressed or RLE encoded.
|
||||
*
|
||||
* 2000-06-10 Mattias Engdegård <f91-men@nada.kth.se>: initial version
|
||||
* 2000-06-26 Mattias Engdegård <f91-men@nada.kth.se>: read greyscale TGAs
|
||||
* 2000-08-09 Mattias Engdegård <f91-men@nada.kth.se>: alpha inversion removed
|
||||
*/
|
||||
|
||||
struct TGAheader {
|
||||
Uint8 infolen; /* length of info field */
|
||||
Uint8 has_cmap; /* 1 if image has colormap, 0 otherwise */
|
||||
Uint8 type;
|
||||
|
||||
Uint8 cmap_start[2]; /* index of first colormap entry */
|
||||
Uint8 cmap_len[2]; /* number of entries in colormap */
|
||||
Uint8 cmap_bits; /* bits per colormap entry */
|
||||
|
||||
Uint8 yorigin[2]; /* image origin (ignored here) */
|
||||
Uint8 xorigin[2];
|
||||
Uint8 width[2]; /* image size */
|
||||
Uint8 height[2];
|
||||
Uint8 pixel_bits; /* bits/pixel */
|
||||
Uint8 flags;
|
||||
};
|
||||
|
||||
enum tga_type {
|
||||
TGA_TYPE_INDEXED = 1,
|
||||
TGA_TYPE_RGB = 2,
|
||||
TGA_TYPE_BW = 3,
|
||||
TGA_TYPE_RLE_INDEXED = 9,
|
||||
TGA_TYPE_RLE_RGB = 10,
|
||||
TGA_TYPE_RLE_BW = 11
|
||||
};
|
||||
|
||||
#define TGA_INTERLEAVE_MASK 0xc0
|
||||
#define TGA_INTERLEAVE_NONE 0x00
|
||||
#define TGA_INTERLEAVE_2WAY 0x40
|
||||
#define TGA_INTERLEAVE_4WAY 0x80
|
||||
|
||||
#define TGA_ORIGIN_MASK 0x30
|
||||
#define TGA_ORIGIN_LEFT 0x00
|
||||
#define TGA_ORIGIN_RIGHT 0x10
|
||||
#define TGA_ORIGIN_LOWER 0x00
|
||||
#define TGA_ORIGIN_UPPER 0x20
|
||||
|
||||
/* read/write unaligned little-endian 16-bit ints */
|
||||
#define LE16(p) ((p)[0] + ((p)[1] << 8))
|
||||
#define SETLE16(p, v) ((p)[0] = (v), (p)[1] = (v) >> 8)
|
||||
|
||||
/* Load a TGA type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadTGA_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
const char *error = NULL;
|
||||
struct TGAheader hdr;
|
||||
int rle = 0;
|
||||
int alpha = 0;
|
||||
int indexed = 0;
|
||||
int grey = 0;
|
||||
int ckey = -1;
|
||||
int ncols, w, h;
|
||||
SDL_Surface *img = NULL;
|
||||
Uint32 rmask, gmask, bmask, amask;
|
||||
Uint8 *dst;
|
||||
int i;
|
||||
int bpp;
|
||||
int lstep;
|
||||
Uint32 pixel;
|
||||
int count, rep;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if(!SDL_RWread(src, &hdr, sizeof(hdr), 1)) {
|
||||
error = "Error reading TGA data";
|
||||
goto error;
|
||||
}
|
||||
ncols = LE16(hdr.cmap_len);
|
||||
switch(hdr.type) {
|
||||
case TGA_TYPE_RLE_INDEXED:
|
||||
rle = 1;
|
||||
/* fallthrough */
|
||||
case TGA_TYPE_INDEXED:
|
||||
if(!hdr.has_cmap || hdr.pixel_bits != 8 || ncols > 256)
|
||||
goto unsupported;
|
||||
indexed = 1;
|
||||
break;
|
||||
|
||||
case TGA_TYPE_RLE_RGB:
|
||||
rle = 1;
|
||||
/* fallthrough */
|
||||
case TGA_TYPE_RGB:
|
||||
indexed = 0;
|
||||
break;
|
||||
|
||||
case TGA_TYPE_RLE_BW:
|
||||
rle = 1;
|
||||
/* fallthrough */
|
||||
case TGA_TYPE_BW:
|
||||
if(hdr.pixel_bits != 8)
|
||||
goto unsupported;
|
||||
/* Treat greyscale as 8bpp indexed images */
|
||||
indexed = grey = 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
goto unsupported;
|
||||
}
|
||||
|
||||
bpp = (hdr.pixel_bits + 7) >> 3;
|
||||
rmask = gmask = bmask = amask = 0;
|
||||
switch(hdr.pixel_bits) {
|
||||
case 8:
|
||||
if(!indexed) {
|
||||
goto unsupported;
|
||||
}
|
||||
break;
|
||||
|
||||
case 15:
|
||||
case 16:
|
||||
/* 15 and 16bpp both seem to use 5 bits/plane. The extra alpha bit
|
||||
is ignored for now. */
|
||||
rmask = 0x7c00;
|
||||
gmask = 0x03e0;
|
||||
bmask = 0x001f;
|
||||
break;
|
||||
|
||||
case 32:
|
||||
alpha = 1;
|
||||
/* fallthrough */
|
||||
case 24:
|
||||
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
||||
{
|
||||
int s = alpha ? 0 : 8;
|
||||
amask = 0x000000ff >> s;
|
||||
rmask = 0x0000ff00 >> s;
|
||||
gmask = 0x00ff0000 >> s;
|
||||
bmask = 0xff000000 >> s;
|
||||
}
|
||||
#else
|
||||
amask = alpha ? 0xff000000 : 0;
|
||||
rmask = 0x00ff0000;
|
||||
gmask = 0x0000ff00;
|
||||
bmask = 0x000000ff;
|
||||
#endif
|
||||
break;
|
||||
|
||||
default:
|
||||
goto unsupported;
|
||||
}
|
||||
|
||||
if((hdr.flags & TGA_INTERLEAVE_MASK) != TGA_INTERLEAVE_NONE
|
||||
|| hdr.flags & TGA_ORIGIN_RIGHT) {
|
||||
goto unsupported;
|
||||
}
|
||||
|
||||
SDL_RWseek(src, hdr.infolen, RW_SEEK_CUR); /* skip info field */
|
||||
|
||||
w = LE16(hdr.width);
|
||||
h = LE16(hdr.height);
|
||||
img = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
|
||||
bpp * 8,
|
||||
rmask, gmask, bmask, amask);
|
||||
if(img == NULL) {
|
||||
error = "Out of memory";
|
||||
goto error;
|
||||
}
|
||||
|
||||
if(hdr.has_cmap) {
|
||||
int palsiz = ncols * ((hdr.cmap_bits + 7) >> 3);
|
||||
if(indexed && !grey) {
|
||||
Uint8 *pal = (Uint8 *)SDL_malloc(palsiz), *p = pal;
|
||||
SDL_Color *colors = img->format->palette->colors;
|
||||
img->format->palette->ncolors = ncols;
|
||||
SDL_RWread(src, pal, palsiz, 1);
|
||||
for(i = 0; i < ncols; i++) {
|
||||
switch(hdr.cmap_bits) {
|
||||
case 15:
|
||||
case 16:
|
||||
{
|
||||
Uint16 c = p[0] + (p[1] << 8);
|
||||
p += 2;
|
||||
colors[i].r = (c >> 7) & 0xf8;
|
||||
colors[i].g = (c >> 2) & 0xf8;
|
||||
colors[i].b = c << 3;
|
||||
}
|
||||
break;
|
||||
case 24:
|
||||
case 32:
|
||||
colors[i].b = *p++;
|
||||
colors[i].g = *p++;
|
||||
colors[i].r = *p++;
|
||||
if(hdr.cmap_bits == 32 && *p++ < 128)
|
||||
ckey = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
SDL_free(pal);
|
||||
if(ckey >= 0)
|
||||
SDL_SetColorKey(img, SDL_TRUE, ckey);
|
||||
} else {
|
||||
/* skip unneeded colormap */
|
||||
SDL_RWseek(src, palsiz, RW_SEEK_CUR);
|
||||
}
|
||||
}
|
||||
|
||||
if(grey) {
|
||||
SDL_Color *colors = img->format->palette->colors;
|
||||
for(i = 0; i < 256; i++)
|
||||
colors[i].r = colors[i].g = colors[i].b = i;
|
||||
img->format->palette->ncolors = 256;
|
||||
}
|
||||
|
||||
if(hdr.flags & TGA_ORIGIN_UPPER) {
|
||||
lstep = img->pitch;
|
||||
dst = (Uint8 *)img->pixels;
|
||||
} else {
|
||||
lstep = -img->pitch;
|
||||
dst = (Uint8 *)img->pixels + (h - 1) * img->pitch;
|
||||
}
|
||||
|
||||
/* The RLE decoding code is slightly convoluted since we can't rely on
|
||||
spans not to wrap across scan lines */
|
||||
count = rep = 0;
|
||||
for(i = 0; i < h; i++) {
|
||||
if(rle) {
|
||||
int x = 0;
|
||||
for(;;) {
|
||||
Uint8 c;
|
||||
|
||||
if(count) {
|
||||
int n = count;
|
||||
if(n > w - x)
|
||||
n = w - x;
|
||||
SDL_RWread(src, dst + x * bpp, n * bpp, 1);
|
||||
count -= n;
|
||||
x += n;
|
||||
if(x == w)
|
||||
break;
|
||||
} else if(rep) {
|
||||
int n = rep;
|
||||
if(n > w - x)
|
||||
n = w - x;
|
||||
rep -= n;
|
||||
while(n--) {
|
||||
SDL_memcpy(dst + x * bpp, &pixel, bpp);
|
||||
x++;
|
||||
}
|
||||
if(x == w)
|
||||
break;
|
||||
}
|
||||
|
||||
SDL_RWread(src, &c, 1, 1);
|
||||
if(c & 0x80) {
|
||||
SDL_RWread(src, &pixel, bpp, 1);
|
||||
rep = (c & 0x7f) + 1;
|
||||
} else {
|
||||
count = c + 1;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
SDL_RWread(src, dst, w * bpp, 1);
|
||||
}
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
if (bpp == 2) {
|
||||
/* swap byte order */
|
||||
int x;
|
||||
Uint16 *p = (Uint16 *)dst;
|
||||
for(x = 0; x < w; x++)
|
||||
p[x] = SDL_Swap16(p[x]);
|
||||
}
|
||||
#endif
|
||||
dst += lstep;
|
||||
}
|
||||
return img;
|
||||
|
||||
unsupported:
|
||||
error = "Unsupported TGA format";
|
||||
|
||||
error:
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( img ) {
|
||||
SDL_FreeSurface(img);
|
||||
}
|
||||
IMG_SetError(error);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* dummy TGA load routine */
|
||||
SDL_Surface *IMG_LoadTGA_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_TGA */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,298 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#if !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND)
|
||||
|
||||
/* This is a TIFF image file loading framework */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_TIF
|
||||
|
||||
#include <tiffio.h>
|
||||
|
||||
static struct {
|
||||
int loaded;
|
||||
void *handle;
|
||||
TIFF* (*TIFFClientOpen)(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc);
|
||||
void (*TIFFClose)(TIFF*);
|
||||
int (*TIFFGetField)(TIFF*, ttag_t, ...);
|
||||
int (*TIFFReadRGBAImage)(TIFF*, uint32, uint32, uint32*, int);
|
||||
TIFFErrorHandler (*TIFFSetErrorHandler)(TIFFErrorHandler);
|
||||
} lib;
|
||||
|
||||
#ifdef LOAD_TIF_DYNAMIC
|
||||
int IMG_InitTIF()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.handle = SDL_LoadObject(LOAD_TIF_DYNAMIC);
|
||||
if ( lib.handle == NULL ) {
|
||||
return -1;
|
||||
}
|
||||
lib.TIFFClientOpen =
|
||||
(TIFF* (*)(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc))
|
||||
SDL_LoadFunction(lib.handle, "TIFFClientOpen");
|
||||
if ( lib.TIFFClientOpen == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.TIFFClose =
|
||||
(void (*)(TIFF*))
|
||||
SDL_LoadFunction(lib.handle, "TIFFClose");
|
||||
if ( lib.TIFFClose == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.TIFFGetField =
|
||||
(int (*)(TIFF*, ttag_t, ...))
|
||||
SDL_LoadFunction(lib.handle, "TIFFGetField");
|
||||
if ( lib.TIFFGetField == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.TIFFReadRGBAImage =
|
||||
(int (*)(TIFF*, uint32, uint32, uint32*, int))
|
||||
SDL_LoadFunction(lib.handle, "TIFFReadRGBAImage");
|
||||
if ( lib.TIFFReadRGBAImage == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
lib.TIFFSetErrorHandler =
|
||||
(TIFFErrorHandler (*)(TIFFErrorHandler))
|
||||
SDL_LoadFunction(lib.handle, "TIFFSetErrorHandler");
|
||||
if ( lib.TIFFSetErrorHandler == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitTIF()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#else
|
||||
int IMG_InitTIF()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.TIFFClientOpen = TIFFClientOpen;
|
||||
lib.TIFFClose = TIFFClose;
|
||||
lib.TIFFGetField = TIFFGetField;
|
||||
lib.TIFFReadRGBAImage = TIFFReadRGBAImage;
|
||||
lib.TIFFSetErrorHandler = TIFFSetErrorHandler;
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitTIF()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#endif /* LOAD_TIF_DYNAMIC */
|
||||
|
||||
/*
|
||||
* These are the thunking routine to use the SDL_RWops* routines from
|
||||
* libtiff's internals.
|
||||
*/
|
||||
|
||||
static tsize_t tiff_read(thandle_t fd, tdata_t buf, tsize_t size)
|
||||
{
|
||||
return SDL_RWread((SDL_RWops*)fd, buf, 1, size);
|
||||
}
|
||||
|
||||
static toff_t tiff_seek(thandle_t fd, toff_t offset, int origin)
|
||||
{
|
||||
return SDL_RWseek((SDL_RWops*)fd, offset, origin);
|
||||
}
|
||||
|
||||
static tsize_t tiff_write(thandle_t fd, tdata_t buf, tsize_t size)
|
||||
{
|
||||
return SDL_RWwrite((SDL_RWops*)fd, buf, 1, size);
|
||||
}
|
||||
|
||||
static int tiff_close(thandle_t fd)
|
||||
{
|
||||
/*
|
||||
* We don't want libtiff closing our SDL_RWops*, but if it's not given
|
||||
* a routine to try, and if the image isn't a TIFF, it'll segfault.
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tiff_map(thandle_t fd, tdata_t* pbase, toff_t* psize)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
||||
static void tiff_unmap(thandle_t fd, tdata_t base, toff_t size)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
static toff_t tiff_size(thandle_t fd)
|
||||
{
|
||||
Sint64 save_pos;
|
||||
toff_t size;
|
||||
|
||||
save_pos = SDL_RWtell((SDL_RWops*)fd);
|
||||
SDL_RWseek((SDL_RWops*)fd, 0, RW_SEEK_END);
|
||||
size = SDL_RWtell((SDL_RWops*)fd);
|
||||
SDL_RWseek((SDL_RWops*)fd, save_pos, RW_SEEK_SET);
|
||||
return size;
|
||||
}
|
||||
|
||||
int IMG_isTIF(SDL_RWops* src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_TIF;
|
||||
Uint8 magic[4];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_TIF = 0;
|
||||
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( (magic[0] == 'I' &&
|
||||
magic[1] == 'I' &&
|
||||
magic[2] == 0x2a &&
|
||||
magic[3] == 0x00) ||
|
||||
(magic[0] == 'M' &&
|
||||
magic[1] == 'M' &&
|
||||
magic[2] == 0x00 &&
|
||||
magic[3] == 0x2a) ) {
|
||||
is_TIF = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_TIF);
|
||||
}
|
||||
|
||||
SDL_Surface* IMG_LoadTIF_RW(SDL_RWops* src)
|
||||
{
|
||||
Sint64 start;
|
||||
TIFF* tiff;
|
||||
SDL_Surface* surface = NULL;
|
||||
Uint32 img_width, img_height;
|
||||
Uint32 Rmask, Gmask, Bmask, Amask;
|
||||
Uint32 x, y;
|
||||
Uint32 half;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( !IMG_Init(IMG_INIT_TIF) ) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* turn off memory mapped access with the m flag */
|
||||
tiff = lib.TIFFClientOpen("SDL_image", "rm", (thandle_t)src,
|
||||
tiff_read, tiff_write, tiff_seek, tiff_close, tiff_size, tiff_map, tiff_unmap);
|
||||
if(!tiff)
|
||||
goto error;
|
||||
|
||||
/* Retrieve the dimensions of the image from the TIFF tags */
|
||||
lib.TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &img_width);
|
||||
lib.TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &img_height);
|
||||
|
||||
Rmask = 0x000000FF;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x00FF0000;
|
||||
Amask = 0xFF000000;
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, img_width, img_height, 32,
|
||||
Rmask, Gmask, Bmask, Amask);
|
||||
if(!surface)
|
||||
goto error;
|
||||
|
||||
if(!lib.TIFFReadRGBAImage(tiff, img_width, img_height, (uint32 *)surface->pixels, 0))
|
||||
goto error;
|
||||
|
||||
/* libtiff loads the image upside-down, flip it back */
|
||||
half = img_height / 2;
|
||||
for(y = 0; y < half; y++)
|
||||
{
|
||||
Uint32 *top = (Uint32 *)surface->pixels + y * surface->pitch/4;
|
||||
Uint32 *bot = (Uint32 *)surface->pixels
|
||||
+ (img_height - y - 1) * surface->pitch/4;
|
||||
for(x = 0; x < img_width; x++)
|
||||
{
|
||||
Uint32 tmp = top[x];
|
||||
top[x] = bot[x];
|
||||
bot[x] = tmp;
|
||||
}
|
||||
}
|
||||
lib.TIFFClose(tiff);
|
||||
|
||||
return surface;
|
||||
|
||||
error:
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int IMG_InitTIF()
|
||||
{
|
||||
IMG_SetError("TIFF images are not supported");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
void IMG_QuitTIF()
|
||||
{
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isTIF(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a TIFF type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadTIF_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_TIF */
|
||||
|
||||
#endif /* !defined(__APPLE__) || defined(SDL_IMAGE_USE_COMMON_BACKEND) */
|
||||
@@ -0,0 +1,317 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a WEBP image file loading framework */
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_WEBP
|
||||
|
||||
/*=============================================================================
|
||||
File: SDL_webp.c
|
||||
Purpose: A WEBP loader for the SDL library
|
||||
Revision:
|
||||
Created by: Michael Bonfils (Murlock) (26 November 2011)
|
||||
murlock42@gmail.com
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include "SDL_endian.h"
|
||||
|
||||
#ifdef macintosh
|
||||
#define MACOS
|
||||
#endif
|
||||
#include <webp/decode.h>
|
||||
|
||||
static struct {
|
||||
int loaded;
|
||||
void *handle;
|
||||
VP8StatusCode (*webp_get_features_internal) (const uint8_t *data, size_t data_size, WebPBitstreamFeatures* features, int decoder_abi_version);
|
||||
uint8_t* (*webp_decode_rgb_into) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
|
||||
uint8_t* (*webp_decode_rgba_into) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
|
||||
} lib;
|
||||
|
||||
#ifdef LOAD_WEBP_DYNAMIC
|
||||
int IMG_InitWEBP()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
lib.handle = SDL_LoadObject(LOAD_WEBP_DYNAMIC);
|
||||
if ( lib.handle == NULL ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
lib.webp_get_features_internal =
|
||||
( VP8StatusCode (*) (const uint8_t *, size_t, WebPBitstreamFeatures*, int) )
|
||||
SDL_LoadFunction(lib.handle, "WebPGetFeaturesInternal" );
|
||||
if ( lib.webp_get_features_internal == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
|
||||
lib.webp_decode_rgb_into =
|
||||
( uint8_t* (*) (const uint8_t*, size_t, uint8_t*, size_t, int ) )
|
||||
SDL_LoadFunction(lib.handle, "WebPDecodeRGBInto" );
|
||||
if ( lib.webp_decode_rgb_into == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
|
||||
lib.webp_decode_rgba_into =
|
||||
( uint8_t* (*) (const uint8_t*, size_t, uint8_t*, size_t, int ) )
|
||||
SDL_LoadFunction(lib.handle, "WebPDecodeRGBAInto" );
|
||||
if ( lib.webp_decode_rgba_into == NULL ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitWEBP()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
SDL_UnloadObject(lib.handle);
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#else
|
||||
int IMG_InitWEBP()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
#ifdef __MACOSX__
|
||||
extern VP8StatusCode WebPGetFeaturesInternal(const uint8_t*, size_t, WebPBitstreamFeatures*, int) __attribute__((weak_import));
|
||||
if ( WebPGetFeaturesInternal == NULL )
|
||||
{
|
||||
/* Missing weakly linked framework */
|
||||
IMG_SetError("Missing webp.framework");
|
||||
return -1;
|
||||
}
|
||||
#endif // __MACOSX__
|
||||
|
||||
lib.webp_get_features_internal = WebPGetFeaturesInternal;
|
||||
lib.webp_decode_rgb_into = WebPDecodeRGBInto;
|
||||
lib.webp_decode_rgba_into = WebPDecodeRGBAInto;
|
||||
}
|
||||
++lib.loaded;
|
||||
|
||||
return 0;
|
||||
}
|
||||
void IMG_QuitWEBP()
|
||||
{
|
||||
if ( lib.loaded == 0 ) {
|
||||
return;
|
||||
}
|
||||
if ( lib.loaded == 1 ) {
|
||||
}
|
||||
--lib.loaded;
|
||||
}
|
||||
#endif /* LOAD_WEBP_DYNAMIC */
|
||||
|
||||
static int webp_getinfo( SDL_RWops *src, int *datasize ) {
|
||||
Sint64 start;
|
||||
int is_WEBP;
|
||||
Uint8 magic[20];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_WEBP = 0;
|
||||
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
|
||||
if ( magic[ 0] == 'R' &&
|
||||
magic[ 1] == 'I' &&
|
||||
magic[ 2] == 'F' &&
|
||||
magic[ 3] == 'F' &&
|
||||
magic[ 8] == 'W' &&
|
||||
magic[ 9] == 'E' &&
|
||||
magic[10] == 'B' &&
|
||||
magic[11] == 'P' &&
|
||||
magic[12] == 'V' &&
|
||||
magic[13] == 'P' &&
|
||||
magic[14] == '8' &&
|
||||
#if WEBP_DECODER_ABI_VERSION < 0x0003 /* old versions don't support WEBPVP8X and WEBPVP8L */
|
||||
magic[15] == ' ') {
|
||||
#else
|
||||
(magic[15] == ' ' || magic[15] == 'X' || magic[15] == 'L')) {
|
||||
#endif
|
||||
is_WEBP = 1;
|
||||
if ( datasize ) {
|
||||
*datasize = (int)SDL_RWseek(src, 0, SEEK_END);
|
||||
}
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_WEBP);
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isWEBP(SDL_RWops *src)
|
||||
{
|
||||
return webp_getinfo( src, NULL );
|
||||
}
|
||||
|
||||
SDL_Surface *IMG_LoadWEBP_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
const char *error = NULL;
|
||||
SDL_Surface *volatile surface = NULL;
|
||||
Uint32 Rmask;
|
||||
Uint32 Gmask;
|
||||
Uint32 Bmask;
|
||||
Uint32 Amask;
|
||||
WebPBitstreamFeatures features;
|
||||
int raw_data_size;
|
||||
uint8_t *raw_data = NULL;
|
||||
int r;
|
||||
uint8_t *ret;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
if ( !IMG_Init(IMG_INIT_WEBP) ) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
raw_data_size = -1;
|
||||
if ( !webp_getinfo( src, &raw_data_size ) ) {
|
||||
error = "Invalid WEBP";
|
||||
goto error;
|
||||
}
|
||||
|
||||
// seek to start of file
|
||||
SDL_RWseek(src, 0, RW_SEEK_SET );
|
||||
|
||||
raw_data = (uint8_t*) SDL_malloc( raw_data_size );
|
||||
if ( raw_data == NULL ) {
|
||||
error = "Failed to allocate enought buffer for WEBP";
|
||||
goto error;
|
||||
}
|
||||
|
||||
r = SDL_RWread(src, raw_data, 1, raw_data_size );
|
||||
if ( r != raw_data_size ) {
|
||||
error = "Failed to read WEBP";
|
||||
goto error;
|
||||
}
|
||||
|
||||
#if 0
|
||||
// extract size of picture, not interesting since we don't know about alpha channel
|
||||
int width = -1, height = -1;
|
||||
if ( !WebPGetInfo( raw_data, raw_data_size, &width, &height ) ) {
|
||||
printf("WebPGetInfo has failed\n" );
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( lib.webp_get_features_internal( raw_data, raw_data_size, &features, WEBP_DECODER_ABI_VERSION ) != VP8_STATUS_OK ) {
|
||||
error = "WebPGetFeatures has failed";
|
||||
goto error;
|
||||
}
|
||||
|
||||
/* Check if it's ok !*/
|
||||
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
||||
Rmask = 0x000000FF;
|
||||
Gmask = 0x0000FF00;
|
||||
Bmask = 0x00FF0000;
|
||||
Amask = (features.has_alpha) ? 0xFF000000 : 0;
|
||||
#else
|
||||
s = (features.has_alpha) ? 0 : 8;
|
||||
Rmask = 0xFF000000 >> s;
|
||||
Gmask = 0x00FF0000 >> s;
|
||||
Bmask = 0x0000FF00 >> s;
|
||||
Amask = 0x000000FF >> s;
|
||||
#endif
|
||||
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
|
||||
features.width, features.height,
|
||||
features.has_alpha?32:24, Rmask,Gmask,Bmask,Amask);
|
||||
|
||||
if ( surface == NULL ) {
|
||||
error = "Failed to allocate SDL_Surface";
|
||||
goto error;
|
||||
}
|
||||
|
||||
if ( features.has_alpha ) {
|
||||
ret = lib.webp_decode_rgba_into( raw_data, raw_data_size, (uint8_t *)surface->pixels, surface->pitch * surface->h, surface->pitch );
|
||||
} else {
|
||||
ret = lib.webp_decode_rgb_into( raw_data, raw_data_size, (uint8_t *)surface->pixels, surface->pitch * surface->h, surface->pitch );
|
||||
}
|
||||
|
||||
if ( !ret ) {
|
||||
error = "Failed to decode WEBP";
|
||||
goto error;
|
||||
}
|
||||
|
||||
return surface;
|
||||
|
||||
|
||||
error:
|
||||
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface( surface );
|
||||
}
|
||||
|
||||
if ( raw_data ) {
|
||||
SDL_free( raw_data );
|
||||
}
|
||||
|
||||
if ( error ) {
|
||||
IMG_SetError( error );
|
||||
}
|
||||
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int IMG_InitWEBP()
|
||||
{
|
||||
IMG_SetError("WEBP images are not supported");
|
||||
return(-1);
|
||||
}
|
||||
|
||||
void IMG_QuitWEBP()
|
||||
{
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isWEBP(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a WEBP type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadWEBP_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_WEBP */
|
||||
@@ -0,0 +1,841 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a XCF image file loading framework */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "SDL_endian.h"
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_XCF
|
||||
|
||||
#if DEBUG
|
||||
static char prop_names [][30] = {
|
||||
"end",
|
||||
"colormap",
|
||||
"active_layer",
|
||||
"active_channel",
|
||||
"selection",
|
||||
"floating_selection",
|
||||
"opacity",
|
||||
"mode",
|
||||
"visible",
|
||||
"linked",
|
||||
"preserve_transparency",
|
||||
"apply_mask",
|
||||
"edit_mask",
|
||||
"show_mask",
|
||||
"show_masked",
|
||||
"offsets",
|
||||
"color",
|
||||
"compression",
|
||||
"guides",
|
||||
"resolution",
|
||||
"tattoo",
|
||||
"parasites",
|
||||
"unit",
|
||||
"paths",
|
||||
"user_unit"
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PROP_END = 0,
|
||||
PROP_COLORMAP = 1,
|
||||
PROP_ACTIVE_LAYER = 2,
|
||||
PROP_ACTIVE_CHANNEL = 3,
|
||||
PROP_SELECTION = 4,
|
||||
PROP_FLOATING_SELECTION = 5,
|
||||
PROP_OPACITY = 6,
|
||||
PROP_MODE = 7,
|
||||
PROP_VISIBLE = 8,
|
||||
PROP_LINKED = 9,
|
||||
PROP_PRESERVE_TRANSPARENCY = 10,
|
||||
PROP_APPLY_MASK = 11,
|
||||
PROP_EDIT_MASK = 12,
|
||||
PROP_SHOW_MASK = 13,
|
||||
PROP_SHOW_MASKED = 14,
|
||||
PROP_OFFSETS = 15,
|
||||
PROP_COLOR = 16,
|
||||
PROP_COMPRESSION = 17,
|
||||
PROP_GUIDES = 18,
|
||||
PROP_RESOLUTION = 19,
|
||||
PROP_TATTOO = 20,
|
||||
PROP_PARASITES = 21,
|
||||
PROP_UNIT = 22,
|
||||
PROP_PATHS = 23,
|
||||
PROP_USER_UNIT = 24
|
||||
} xcf_prop_type;
|
||||
|
||||
typedef enum {
|
||||
COMPR_NONE = 0,
|
||||
COMPR_RLE = 1,
|
||||
COMPR_ZLIB = 2,
|
||||
COMPR_FRACTAL = 3
|
||||
} xcf_compr_type;
|
||||
|
||||
typedef enum {
|
||||
IMAGE_RGB = 0,
|
||||
IMAGE_GREYSCALE = 1,
|
||||
IMAGE_INDEXED = 2
|
||||
} xcf_image_type;
|
||||
|
||||
typedef struct {
|
||||
Uint32 id;
|
||||
Uint32 length;
|
||||
union {
|
||||
struct {
|
||||
Uint32 num;
|
||||
char * cmap;
|
||||
} colormap; // 1
|
||||
struct {
|
||||
Uint32 drawable_offset;
|
||||
} floating_selection; // 5
|
||||
Sint32 opacity;
|
||||
Sint32 mode;
|
||||
int visible;
|
||||
int linked;
|
||||
int preserve_transparency;
|
||||
int apply_mask;
|
||||
int show_mask;
|
||||
struct {
|
||||
Sint32 x;
|
||||
Sint32 y;
|
||||
} offset;
|
||||
unsigned char color [3];
|
||||
Uint8 compression;
|
||||
struct {
|
||||
Sint32 x;
|
||||
Sint32 y;
|
||||
} resolution;
|
||||
struct {
|
||||
char * name;
|
||||
Uint32 flags;
|
||||
Uint32 size;
|
||||
char * data;
|
||||
} parasite;
|
||||
} data;
|
||||
} xcf_prop;
|
||||
|
||||
typedef struct {
|
||||
char sign [14];
|
||||
Uint32 width;
|
||||
Uint32 height;
|
||||
Sint32 image_type;
|
||||
xcf_prop * properties;
|
||||
|
||||
Uint32 * layer_file_offsets;
|
||||
Uint32 * channel_file_offsets;
|
||||
|
||||
xcf_compr_type compr;
|
||||
Uint32 cm_num;
|
||||
unsigned char * cm_map;
|
||||
} xcf_header;
|
||||
|
||||
typedef struct {
|
||||
Uint32 width;
|
||||
Uint32 height;
|
||||
Sint32 layer_type;
|
||||
char * name;
|
||||
xcf_prop * properties;
|
||||
|
||||
Uint32 hierarchy_file_offset;
|
||||
Uint32 layer_mask_offset;
|
||||
|
||||
Uint32 offset_x;
|
||||
Uint32 offset_y;
|
||||
int visible;
|
||||
} xcf_layer;
|
||||
|
||||
typedef struct {
|
||||
Uint32 width;
|
||||
Uint32 height;
|
||||
char * name;
|
||||
xcf_prop * properties;
|
||||
|
||||
Uint32 hierarchy_file_offset;
|
||||
|
||||
Uint32 color;
|
||||
Uint32 opacity;
|
||||
int selection;
|
||||
int visible;
|
||||
} xcf_channel;
|
||||
|
||||
typedef struct {
|
||||
Uint32 width;
|
||||
Uint32 height;
|
||||
Uint32 bpp;
|
||||
|
||||
Uint32 * level_file_offsets;
|
||||
} xcf_hierarchy;
|
||||
|
||||
typedef struct {
|
||||
Uint32 width;
|
||||
Uint32 height;
|
||||
|
||||
Uint32 * tile_file_offsets;
|
||||
} xcf_level;
|
||||
|
||||
typedef unsigned char * xcf_tile;
|
||||
|
||||
typedef unsigned char * (* load_tile_type) (SDL_RWops *, Uint32, int, int, int);
|
||||
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXCF(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_XCF;
|
||||
char magic[14];
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_XCF = 0;
|
||||
if ( SDL_RWread(src, magic, sizeof(magic), 1) ) {
|
||||
if (SDL_strncmp(magic, "gimp xcf ", 9) == 0) {
|
||||
is_XCF = 1;
|
||||
}
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_XCF);
|
||||
}
|
||||
|
||||
static char * read_string (SDL_RWops * src) {
|
||||
Uint32 tmp;
|
||||
char * data;
|
||||
|
||||
tmp = SDL_ReadBE32 (src);
|
||||
if (tmp > 0) {
|
||||
data = (char *) SDL_malloc (sizeof (char) * tmp);
|
||||
SDL_RWread (src, data, tmp, 1);
|
||||
}
|
||||
else {
|
||||
data = NULL;
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
static Uint32 Swap32 (Uint32 v) {
|
||||
return
|
||||
((v & 0x000000FF) << 16)
|
||||
| ((v & 0x0000FF00))
|
||||
| ((v & 0x00FF0000) >> 16)
|
||||
| ((v & 0xFF000000));
|
||||
}
|
||||
|
||||
static void xcf_read_property (SDL_RWops * src, xcf_prop * prop) {
|
||||
prop->id = SDL_ReadBE32 (src);
|
||||
prop->length = SDL_ReadBE32 (src);
|
||||
|
||||
#if DEBUG
|
||||
printf ("%.8X: %s: %d\n", SDL_RWtell (src), prop->id < 25 ? prop_names [prop->id] : "unknown", prop->length);
|
||||
#endif
|
||||
|
||||
switch (prop->id) {
|
||||
case PROP_COLORMAP:
|
||||
prop->data.colormap.num = SDL_ReadBE32 (src);
|
||||
prop->data.colormap.cmap = (char *) SDL_malloc (sizeof (char) * prop->data.colormap.num * 3);
|
||||
SDL_RWread (src, prop->data.colormap.cmap, prop->data.colormap.num*3, 1);
|
||||
break;
|
||||
|
||||
case PROP_OFFSETS:
|
||||
prop->data.offset.x = SDL_ReadBE32 (src);
|
||||
prop->data.offset.y = SDL_ReadBE32 (src);
|
||||
break;
|
||||
case PROP_OPACITY:
|
||||
prop->data.opacity = SDL_ReadBE32 (src);
|
||||
break;
|
||||
case PROP_COMPRESSION:
|
||||
case PROP_COLOR:
|
||||
SDL_RWread (src, &prop->data, prop->length, 1);
|
||||
break;
|
||||
case PROP_VISIBLE:
|
||||
prop->data.visible = SDL_ReadBE32 (src);
|
||||
break;
|
||||
default:
|
||||
// SDL_RWread (src, &prop->data, prop->length, 1);
|
||||
SDL_RWseek (src, prop->length, RW_SEEK_CUR);
|
||||
}
|
||||
}
|
||||
|
||||
static void free_xcf_header (xcf_header * h) {
|
||||
if (h->cm_num)
|
||||
SDL_free (h->cm_map);
|
||||
if (h->layer_file_offsets)
|
||||
SDL_free (h->layer_file_offsets);
|
||||
SDL_free (h);
|
||||
}
|
||||
|
||||
static xcf_header * read_xcf_header (SDL_RWops * src) {
|
||||
xcf_header * h;
|
||||
xcf_prop prop;
|
||||
|
||||
h = (xcf_header *) SDL_malloc (sizeof (xcf_header));
|
||||
SDL_RWread (src, h->sign, 14, 1);
|
||||
h->width = SDL_ReadBE32 (src);
|
||||
h->height = SDL_ReadBE32 (src);
|
||||
h->image_type = SDL_ReadBE32 (src);
|
||||
|
||||
h->properties = NULL;
|
||||
h->layer_file_offsets = NULL;
|
||||
h->compr = COMPR_NONE;
|
||||
h->cm_num = 0;
|
||||
h->cm_map = NULL;
|
||||
|
||||
// Just read, don't save
|
||||
do {
|
||||
xcf_read_property (src, &prop);
|
||||
if (prop.id == PROP_COMPRESSION)
|
||||
h->compr = (xcf_compr_type)prop.data.compression;
|
||||
else if (prop.id == PROP_COLORMAP) {
|
||||
// unused var: int i;
|
||||
|
||||
h->cm_num = prop.data.colormap.num;
|
||||
h->cm_map = (unsigned char *) SDL_malloc (sizeof (unsigned char) * 3 * h->cm_num);
|
||||
SDL_memcpy (h->cm_map, prop.data.colormap.cmap, 3*sizeof (char)*h->cm_num);
|
||||
SDL_free (prop.data.colormap.cmap);
|
||||
}
|
||||
} while (prop.id != PROP_END);
|
||||
|
||||
return h;
|
||||
}
|
||||
|
||||
static void free_xcf_layer (xcf_layer * l) {
|
||||
SDL_free (l->name);
|
||||
SDL_free (l);
|
||||
}
|
||||
|
||||
static xcf_layer * read_xcf_layer (SDL_RWops * src) {
|
||||
xcf_layer * l;
|
||||
xcf_prop prop;
|
||||
|
||||
l = (xcf_layer *) SDL_malloc (sizeof (xcf_layer));
|
||||
l->width = SDL_ReadBE32 (src);
|
||||
l->height = SDL_ReadBE32 (src);
|
||||
l->layer_type = SDL_ReadBE32 (src);
|
||||
|
||||
l->name = read_string (src);
|
||||
|
||||
do {
|
||||
xcf_read_property (src, &prop);
|
||||
if (prop.id == PROP_OFFSETS) {
|
||||
l->offset_x = prop.data.offset.x;
|
||||
l->offset_y = prop.data.offset.y;
|
||||
} else if (prop.id == PROP_VISIBLE) {
|
||||
l->visible = prop.data.visible ? 1 : 0;
|
||||
}
|
||||
} while (prop.id != PROP_END);
|
||||
|
||||
l->hierarchy_file_offset = SDL_ReadBE32 (src);
|
||||
l->layer_mask_offset = SDL_ReadBE32 (src);
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
static void free_xcf_channel (xcf_channel * c) {
|
||||
SDL_free (c->name);
|
||||
SDL_free (c);
|
||||
}
|
||||
|
||||
static xcf_channel * read_xcf_channel (SDL_RWops * src) {
|
||||
xcf_channel * l;
|
||||
xcf_prop prop;
|
||||
|
||||
l = (xcf_channel *) SDL_malloc (sizeof (xcf_channel));
|
||||
l->width = SDL_ReadBE32 (src);
|
||||
l->height = SDL_ReadBE32 (src);
|
||||
|
||||
l->name = read_string (src);
|
||||
|
||||
l->selection = 0;
|
||||
do {
|
||||
xcf_read_property (src, &prop);
|
||||
switch (prop.id) {
|
||||
case PROP_OPACITY:
|
||||
l->opacity = prop.data.opacity << 24;
|
||||
break;
|
||||
case PROP_COLOR:
|
||||
l->color = ((Uint32) prop.data.color[0] << 16)
|
||||
| ((Uint32) prop.data.color[1] << 8)
|
||||
| ((Uint32) prop.data.color[2]);
|
||||
break;
|
||||
case PROP_SELECTION:
|
||||
l->selection = 1;
|
||||
break;
|
||||
case PROP_VISIBLE:
|
||||
l->visible = prop.data.visible ? 1 : 0;
|
||||
break;
|
||||
default:
|
||||
;
|
||||
}
|
||||
} while (prop.id != PROP_END);
|
||||
|
||||
l->hierarchy_file_offset = SDL_ReadBE32 (src);
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
static void free_xcf_hierarchy (xcf_hierarchy * h) {
|
||||
SDL_free (h->level_file_offsets);
|
||||
SDL_free (h);
|
||||
}
|
||||
|
||||
static xcf_hierarchy * read_xcf_hierarchy (SDL_RWops * src) {
|
||||
xcf_hierarchy * h;
|
||||
int i;
|
||||
|
||||
h = (xcf_hierarchy *) SDL_malloc (sizeof (xcf_hierarchy));
|
||||
h->width = SDL_ReadBE32 (src);
|
||||
h->height = SDL_ReadBE32 (src);
|
||||
h->bpp = SDL_ReadBE32 (src);
|
||||
|
||||
h->level_file_offsets = NULL;
|
||||
i = 0;
|
||||
do {
|
||||
h->level_file_offsets = (Uint32 *) SDL_realloc (h->level_file_offsets, sizeof (Uint32) * (i+1));
|
||||
h->level_file_offsets [i] = SDL_ReadBE32 (src);
|
||||
} while (h->level_file_offsets [i++]);
|
||||
|
||||
return h;
|
||||
}
|
||||
|
||||
static void free_xcf_level (xcf_level * l) {
|
||||
SDL_free (l->tile_file_offsets);
|
||||
SDL_free (l);
|
||||
}
|
||||
|
||||
static xcf_level * read_xcf_level (SDL_RWops * src) {
|
||||
xcf_level * l;
|
||||
int i;
|
||||
|
||||
l = (xcf_level *) SDL_malloc (sizeof (xcf_level));
|
||||
l->width = SDL_ReadBE32 (src);
|
||||
l->height = SDL_ReadBE32 (src);
|
||||
|
||||
l->tile_file_offsets = NULL;
|
||||
i = 0;
|
||||
do {
|
||||
l->tile_file_offsets = (Uint32 *) SDL_realloc (l->tile_file_offsets, sizeof (Uint32) * (i+1));
|
||||
l->tile_file_offsets [i] = SDL_ReadBE32 (src);
|
||||
} while (l->tile_file_offsets [i++]);
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
static void free_xcf_tile (unsigned char * t) {
|
||||
SDL_free (t);
|
||||
}
|
||||
|
||||
static unsigned char * load_xcf_tile_none (SDL_RWops * src, Uint32 len, int bpp, int x, int y) {
|
||||
unsigned char * load;
|
||||
|
||||
load = (unsigned char *) SDL_malloc (len); // expect this is okay
|
||||
SDL_RWread (src, load, len, 1);
|
||||
|
||||
return load;
|
||||
}
|
||||
|
||||
static unsigned char * load_xcf_tile_rle (SDL_RWops * src, Uint32 len, int bpp, int x, int y) {
|
||||
unsigned char * load, * t, * data, * d;
|
||||
Uint32 reallen;
|
||||
int i, size, count, j, length;
|
||||
unsigned char val;
|
||||
|
||||
t = load = (unsigned char *) SDL_malloc (len);
|
||||
reallen = SDL_RWread (src, t, 1, len);
|
||||
|
||||
data = (unsigned char *) SDL_malloc (x*y*bpp);
|
||||
for (i = 0; i < bpp; i++) {
|
||||
d = data + i;
|
||||
size = x*y;
|
||||
count = 0;
|
||||
|
||||
while (size > 0) {
|
||||
val = *t++;
|
||||
|
||||
length = val;
|
||||
if (length >= 128) {
|
||||
length = 255 - (length - 1);
|
||||
if (length == 128) {
|
||||
length = (*t << 8) + t[1];
|
||||
t += 2;
|
||||
}
|
||||
|
||||
count += length;
|
||||
size -= length;
|
||||
|
||||
while (length-- > 0) {
|
||||
*d = *t++;
|
||||
d += bpp;
|
||||
}
|
||||
}
|
||||
else {
|
||||
length += 1;
|
||||
if (length == 128) {
|
||||
length = (*t << 8) + t[1];
|
||||
t += 2;
|
||||
}
|
||||
|
||||
count += length;
|
||||
size -= length;
|
||||
|
||||
val = *t++;
|
||||
|
||||
for (j = 0; j < length; j++) {
|
||||
*d = val;
|
||||
d += bpp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SDL_free (load);
|
||||
return (data);
|
||||
}
|
||||
|
||||
static Uint32 rgb2grey (Uint32 a) {
|
||||
Uint8 l;
|
||||
l = (Uint8)(0.2990 * ((a & 0x00FF0000) >> 16)
|
||||
+ 0.5870 * ((a & 0x0000FF00) >> 8)
|
||||
+ 0.1140 * ((a & 0x000000FF)));
|
||||
|
||||
return (l << 16) | (l << 8) | l;
|
||||
}
|
||||
|
||||
static void create_channel_surface (SDL_Surface * surf, xcf_image_type itype, Uint32 color, Uint32 opacity) {
|
||||
Uint32 c = 0;
|
||||
|
||||
switch (itype) {
|
||||
case IMAGE_RGB:
|
||||
case IMAGE_INDEXED:
|
||||
c = opacity | color;
|
||||
break;
|
||||
case IMAGE_GREYSCALE:
|
||||
c = opacity | rgb2grey (color);
|
||||
break;
|
||||
}
|
||||
SDL_FillRect (surf, NULL, c);
|
||||
}
|
||||
|
||||
static int do_layer_surface (SDL_Surface * surface, SDL_RWops * src, xcf_header * head, xcf_layer * layer, load_tile_type load_tile) {
|
||||
xcf_hierarchy * hierarchy;
|
||||
xcf_level * level;
|
||||
unsigned char * tile;
|
||||
Uint8 * p8;
|
||||
Uint16 * p16;
|
||||
Uint32 * p;
|
||||
int i, j;
|
||||
Uint32 x, y, tx, ty, ox, oy;
|
||||
Uint32 *row;
|
||||
|
||||
SDL_RWseek (src, layer->hierarchy_file_offset, RW_SEEK_SET);
|
||||
hierarchy = read_xcf_hierarchy (src);
|
||||
|
||||
level = NULL;
|
||||
for (i = 0; hierarchy->level_file_offsets [i]; i++) {
|
||||
SDL_RWseek (src, hierarchy->level_file_offsets [i], RW_SEEK_SET);
|
||||
level = read_xcf_level (src);
|
||||
|
||||
ty = tx = 0;
|
||||
for (j = 0; level->tile_file_offsets [j]; j++) {
|
||||
SDL_RWseek (src, level->tile_file_offsets [j], RW_SEEK_SET);
|
||||
ox = tx+64 > level->width ? level->width % 64 : 64;
|
||||
oy = ty+64 > level->height ? level->height % 64 : 64;
|
||||
|
||||
if (level->tile_file_offsets [j+1]) {
|
||||
tile = load_tile
|
||||
(src,
|
||||
level->tile_file_offsets [j+1] - level->tile_file_offsets [j],
|
||||
hierarchy->bpp,
|
||||
ox, oy);
|
||||
}
|
||||
else {
|
||||
tile = load_tile
|
||||
(src,
|
||||
ox*oy*6,
|
||||
hierarchy->bpp,
|
||||
ox, oy);
|
||||
}
|
||||
|
||||
p8 = tile;
|
||||
p16 = (Uint16 *) p8;
|
||||
p = (Uint32 *) p8;
|
||||
for (y=ty; y < ty+oy; y++) {
|
||||
row = (Uint32 *)((Uint8 *)surface->pixels + y*surface->pitch + tx*4);
|
||||
switch (hierarchy->bpp) {
|
||||
case 4:
|
||||
for (x=tx; x < tx+ox; x++)
|
||||
*row++ = Swap32 (*p++);
|
||||
break;
|
||||
case 3:
|
||||
for (x=tx; x < tx+ox; x++) {
|
||||
*row = 0xFF000000;
|
||||
*row |= ((Uint32) *(p8++) << 16);
|
||||
*row |= ((Uint32) *(p8++) << 8);
|
||||
*row |= ((Uint32) *(p8++) << 0);
|
||||
row++;
|
||||
}
|
||||
break;
|
||||
case 2: // Indexed/Greyscale + Alpha
|
||||
switch (head->image_type) {
|
||||
case IMAGE_INDEXED:
|
||||
for (x=tx; x < tx+ox; x++) {
|
||||
*row = ((Uint32) (head->cm_map [*p8*3]) << 16);
|
||||
*row |= ((Uint32) (head->cm_map [*p8*3+1]) << 8);
|
||||
*row |= ((Uint32) (head->cm_map [*p8++*3+2]) << 0);
|
||||
*row |= ((Uint32) *p8++ << 24);;
|
||||
row++;
|
||||
}
|
||||
break;
|
||||
case IMAGE_GREYSCALE:
|
||||
for (x=tx; x < tx+ox; x++) {
|
||||
*row = ((Uint32) *p8 << 16);
|
||||
*row |= ((Uint32) *p8 << 8);
|
||||
*row |= ((Uint32) *p8++ << 0);
|
||||
*row |= ((Uint32) *p8++ << 24);;
|
||||
row++;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
fprintf (stderr, "Unknown Gimp image type (%d)\n", head->image_type);
|
||||
if (hierarchy)
|
||||
{
|
||||
if (hierarchy->level_file_offsets)
|
||||
SDL_free(hierarchy->level_file_offsets);
|
||||
|
||||
free_xcf_hierarchy(hierarchy);
|
||||
}
|
||||
if (level)
|
||||
free_xcf_level (level);
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
case 1: // Indexed/Greyscale
|
||||
switch (head->image_type) {
|
||||
case IMAGE_INDEXED:
|
||||
for (x = tx; x < tx+ox; x++) {
|
||||
*row++ = 0xFF000000
|
||||
| ((Uint32) (head->cm_map [*p8*3]) << 16)
|
||||
| ((Uint32) (head->cm_map [*p8*3+1]) << 8)
|
||||
| ((Uint32) (head->cm_map [*p8*3+2]) << 0);
|
||||
p8++;
|
||||
}
|
||||
break;
|
||||
case IMAGE_GREYSCALE:
|
||||
for (x=tx; x < tx+ox; x++) {
|
||||
*row++ = 0xFF000000
|
||||
| (((Uint32) (*p8)) << 16)
|
||||
| (((Uint32) (*p8)) << 8)
|
||||
| (((Uint32) (*p8)) << 0);
|
||||
++p8;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
fprintf (stderr, "Unknown Gimp image type (%d)\n", head->image_type);
|
||||
if (tile)
|
||||
free_xcf_tile (tile);
|
||||
if (level)
|
||||
free_xcf_level (level);
|
||||
if (hierarchy)
|
||||
free_xcf_hierarchy (hierarchy);
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
tx += 64;
|
||||
if (tx >= level->width) {
|
||||
tx = 0;
|
||||
ty += 64;
|
||||
}
|
||||
if (ty >= level->height) {
|
||||
break;
|
||||
}
|
||||
|
||||
free_xcf_tile (tile);
|
||||
}
|
||||
free_xcf_level (level);
|
||||
}
|
||||
|
||||
free_xcf_hierarchy (hierarchy);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
SDL_Surface *IMG_LoadXCF_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
const char *error = NULL;
|
||||
SDL_Surface *surface, *lays;
|
||||
xcf_header * head;
|
||||
xcf_layer * layer;
|
||||
xcf_channel ** channel;
|
||||
int chnls, i, offsets;
|
||||
Sint64 offset, fp;
|
||||
|
||||
unsigned char * (* load_tile) (SDL_RWops *, Uint32, int, int, int);
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
/* Initialize the data we will clean up when we're done */
|
||||
surface = NULL;
|
||||
|
||||
head = read_xcf_header (src);
|
||||
|
||||
switch (head->compr) {
|
||||
case COMPR_NONE:
|
||||
load_tile = load_xcf_tile_none;
|
||||
break;
|
||||
case COMPR_RLE:
|
||||
load_tile = load_xcf_tile_rle;
|
||||
break;
|
||||
default:
|
||||
fprintf (stderr, "Unsupported Compression.\n");
|
||||
free_xcf_header (head);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create the surface of the appropriate type */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
|
||||
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
|
||||
|
||||
if ( surface == NULL ) {
|
||||
error = "Out of memory";
|
||||
goto done;
|
||||
}
|
||||
|
||||
offsets = 0;
|
||||
|
||||
while ((offset = SDL_ReadBE32 (src))) {
|
||||
head->layer_file_offsets = (Uint32 *) SDL_realloc (head->layer_file_offsets, sizeof (Uint32) * (offsets+1));
|
||||
head->layer_file_offsets [offsets] = (Uint32)offset;
|
||||
offsets++;
|
||||
}
|
||||
fp = SDL_RWtell (src);
|
||||
|
||||
lays = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
|
||||
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
|
||||
|
||||
if ( lays == NULL ) {
|
||||
error = "Out of memory";
|
||||
goto done;
|
||||
}
|
||||
|
||||
// Blit layers backwards, because Gimp saves them highest first
|
||||
for (i = offsets; i > 0; i--) {
|
||||
SDL_Rect rs, rd;
|
||||
SDL_RWseek (src, head->layer_file_offsets [i-1], RW_SEEK_SET);
|
||||
|
||||
layer = read_xcf_layer (src);
|
||||
do_layer_surface (lays, src, head, layer, load_tile);
|
||||
rs.x = 0;
|
||||
rs.y = 0;
|
||||
rs.w = layer->width;
|
||||
rs.h = layer->height;
|
||||
rd.x = layer->offset_x;
|
||||
rd.y = layer->offset_y;
|
||||
rd.w = layer->width;
|
||||
rd.h = layer->height;
|
||||
|
||||
if (layer->visible)
|
||||
SDL_BlitSurface (lays, &rs, surface, &rd);
|
||||
free_xcf_layer (layer);
|
||||
}
|
||||
|
||||
SDL_FreeSurface (lays);
|
||||
|
||||
SDL_RWseek (src, fp, RW_SEEK_SET);
|
||||
|
||||
// read channels
|
||||
channel = NULL;
|
||||
chnls = 0;
|
||||
while ((offset = SDL_ReadBE32 (src))) {
|
||||
channel = (xcf_channel **) SDL_realloc (channel, sizeof (xcf_channel *) * (chnls+1));
|
||||
fp = SDL_RWtell (src);
|
||||
SDL_RWseek (src, offset, RW_SEEK_SET);
|
||||
channel [chnls++] = (read_xcf_channel (src));
|
||||
SDL_RWseek (src, fp, RW_SEEK_SET);
|
||||
}
|
||||
|
||||
if (chnls) {
|
||||
SDL_Surface * chs;
|
||||
|
||||
chs = SDL_CreateRGBSurface(SDL_SWSURFACE, head->width, head->height, 32,
|
||||
0x00FF0000,0x0000FF00,0x000000FF,0xFF000000);
|
||||
|
||||
if (chs == NULL) {
|
||||
error = "Out of memory";
|
||||
goto done;
|
||||
}
|
||||
for (i = 0; i < chnls; i++) {
|
||||
// printf ("CNLBLT %i\n", i);
|
||||
if (!channel [i]->selection && channel [i]->visible) {
|
||||
create_channel_surface (chs, (xcf_image_type)head->image_type, channel [i]->color, channel [i]->opacity);
|
||||
SDL_BlitSurface (chs, NULL, surface, NULL);
|
||||
}
|
||||
free_xcf_channel (channel [i]);
|
||||
}
|
||||
|
||||
SDL_FreeSurface (chs);
|
||||
}
|
||||
|
||||
done:
|
||||
free_xcf_header (head);
|
||||
if ( error ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
|
||||
return(surface);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXCF(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a XCF type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadXCF_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_XCF */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,165 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a XV thumbnail image file loading framework */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_XV
|
||||
|
||||
static int get_line(SDL_RWops *src, char *line, int size)
|
||||
{
|
||||
while ( size > 0 ) {
|
||||
if ( SDL_RWread(src, line, 1, 1) <= 0 ) {
|
||||
return -1;
|
||||
}
|
||||
if ( *line == '\r' ) {
|
||||
continue;
|
||||
}
|
||||
if ( *line == '\n' ) {
|
||||
*line = '\0';
|
||||
return 0;
|
||||
}
|
||||
++line;
|
||||
--size;
|
||||
}
|
||||
/* Out of space for the line */
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int get_header(SDL_RWops *src, int *w, int *h)
|
||||
{
|
||||
char line[1024];
|
||||
|
||||
*w = 0;
|
||||
*h = 0;
|
||||
|
||||
/* Check the header magic */
|
||||
if ( (get_line(src, line, sizeof(line)) < 0) ||
|
||||
(SDL_memcmp(line, "P7 332", 6) != 0) ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Read the header */
|
||||
while ( get_line(src, line, sizeof(line)) == 0 ) {
|
||||
if ( SDL_memcmp(line, "#BUILTIN:", 9) == 0 ) {
|
||||
/* Builtin image, no data */
|
||||
break;
|
||||
}
|
||||
if ( SDL_memcmp(line, "#END_OF_COMMENTS", 16) == 0 ) {
|
||||
if ( get_line(src, line, sizeof(line)) == 0 ) {
|
||||
SDL_sscanf(line, "%d %d", w, h);
|
||||
if ( *w >= 0 && *h >= 0 ) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* No image data */
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXV(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
int is_XV;
|
||||
int w, h;
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_XV = 0;
|
||||
if ( get_header(src, &w, &h) == 0 ) {
|
||||
is_XV = 1;
|
||||
}
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_XV);
|
||||
}
|
||||
|
||||
/* Load a XV thumbnail image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadXV_RW(SDL_RWops *src)
|
||||
{
|
||||
Sint64 start;
|
||||
const char *error = NULL;
|
||||
SDL_Surface *surface = NULL;
|
||||
int w, h;
|
||||
Uint8 *pixels;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
/* Read the header */
|
||||
if ( get_header(src, &w, &h) < 0 ) {
|
||||
error = "Unsupported image format";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Create the 3-3-2 indexed palette surface */
|
||||
surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 8, 0xe0, 0x1c, 0x03, 0);
|
||||
if ( surface == NULL ) {
|
||||
error = "Out of memory";
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Load the image data */
|
||||
for ( pixels = (Uint8 *)surface->pixels; h > 0; --h ) {
|
||||
if ( SDL_RWread(src, pixels, w, 1) <= 0 ) {
|
||||
error = "Couldn't read image data";
|
||||
goto done;
|
||||
}
|
||||
pixels += surface->pitch;
|
||||
}
|
||||
|
||||
done:
|
||||
if ( error ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
return surface;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXV(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a XXX type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadXV_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_XV */
|
||||
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* This is a generic "format not supported" image framework */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SDL_image.h"
|
||||
|
||||
#ifdef LOAD_XXX
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXXX(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
int is_XXX;
|
||||
|
||||
if ( !src )
|
||||
return 0;
|
||||
start = SDL_RWtell(src);
|
||||
is_XXX = 0;
|
||||
|
||||
/* Detect the image here */
|
||||
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
return(is_XXX);
|
||||
}
|
||||
|
||||
/* Load a XXX type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadXXX_RW(SDL_RWops *src)
|
||||
{
|
||||
int start;
|
||||
const char *error = NULL;
|
||||
SDL_Surface *surface = NULL;
|
||||
|
||||
if ( !src ) {
|
||||
/* The error message has been set in SDL_RWFromFile */
|
||||
return NULL;
|
||||
}
|
||||
start = SDL_RWtell(src);
|
||||
|
||||
/* Load the image here */
|
||||
|
||||
if ( error ) {
|
||||
SDL_RWseek(src, start, RW_SEEK_SET);
|
||||
if ( surface ) {
|
||||
SDL_FreeSurface(surface);
|
||||
surface = NULL;
|
||||
}
|
||||
IMG_SetError(error);
|
||||
}
|
||||
return surface;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* See if an image is contained in a data source */
|
||||
int IMG_isXXX(SDL_RWops *src)
|
||||
{
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Load a XXX type image from an SDL datasource */
|
||||
SDL_Surface *IMG_LoadXXX_RW(SDL_RWops *src)
|
||||
{
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
#endif /* LOAD_XXX */
|
||||
@@ -0,0 +1,78 @@
|
||||
# Makefile.am for the SDL sample image loading library and viewer
|
||||
|
||||
lib_LTLIBRARIES = libSDL2_image.la
|
||||
|
||||
libSDL2_imageincludedir = $(includedir)/SDL2
|
||||
libSDL2_imageinclude_HEADERS = \
|
||||
SDL_image.h
|
||||
|
||||
if USE_IMAGEIO
|
||||
IMAGEIO_SOURCE = IMG_ImageIO.m
|
||||
endif
|
||||
|
||||
libSDL2_image_la_SOURCES = \
|
||||
IMG.c \
|
||||
IMG_bmp.c \
|
||||
IMG_gif.c \
|
||||
IMG_jpg.c \
|
||||
IMG_lbm.c \
|
||||
IMG_pcx.c \
|
||||
IMG_png.c \
|
||||
IMG_pnm.c \
|
||||
IMG_tga.c \
|
||||
IMG_tif.c \
|
||||
IMG_xcf.c \
|
||||
IMG_xpm.c \
|
||||
IMG_xv.c \
|
||||
IMG_webp.c \
|
||||
$(IMAGEIO_SOURCE) \
|
||||
miniz.h
|
||||
|
||||
EXTRA_DIST = \
|
||||
Android.mk \
|
||||
debian \
|
||||
external \
|
||||
version.rc \
|
||||
VisualC \
|
||||
VisualCE \
|
||||
Xcode \
|
||||
Xcode-iOS \
|
||||
IMG_xxx.c \
|
||||
$(srcdir)/*.m \
|
||||
SDL2_image.spec \
|
||||
gcc-fat.sh \
|
||||
autogen.sh \
|
||||
$(srcdir)/*.txt
|
||||
|
||||
if USE_VERSION_RC
|
||||
libSDL2_image_la_LDFLAGS = \
|
||||
-no-undefined \
|
||||
-release $(LT_RELEASE) \
|
||||
-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) -Wl,version.o
|
||||
libSDL2_image_la_LIBADD = $(IMG_LIBS)
|
||||
libSDL2_image_la_DEPENDENCIES = version.o
|
||||
else
|
||||
libSDL2_image_la_LDFLAGS = \
|
||||
-no-undefined \
|
||||
-release $(LT_RELEASE) \
|
||||
-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
|
||||
libSDL2_image_la_LIBADD = $(IMG_LIBS)
|
||||
endif
|
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
pkgconfig_DATA = SDL2_image.pc
|
||||
|
||||
%.o : %.rc
|
||||
$(WINDRES) $< $@
|
||||
|
||||
noinst_PROGRAMS = showimage
|
||||
|
||||
showimage_LDADD = libSDL2_image.la
|
||||
|
||||
# Rule to build tar-gzipped distribution package
|
||||
$(PACKAGE)-$(VERSION).tar.gz: distcheck
|
||||
|
||||
# Rule to build RPM distribution package
|
||||
rpm: $(PACKAGE)-$(VERSION).tar.gz
|
||||
rpmbuild -ta $(PACKAGE)-$(VERSION).tar.gz
|
||||
|
||||
@@ -0,0 +1,998 @@
|
||||
# Makefile.in generated by automake 1.13.1 from Makefile.am.
|
||||
# @configure_input@
|
||||
|
||||
# Copyright (C) 1994-2012 Free Software Foundation, Inc.
|
||||
|
||||
# This Makefile.in is free software; the Free Software Foundation
|
||||
# gives unlimited permission to copy and/or distribute it,
|
||||
# with or without modifications, as long as this notice is preserved.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
# PARTICULAR PURPOSE.
|
||||
|
||||
@SET_MAKE@
|
||||
|
||||
# Makefile.am for the SDL sample image loading library and viewer
|
||||
|
||||
|
||||
|
||||
|
||||
VPATH = @srcdir@
|
||||
am__make_dryrun = \
|
||||
{ \
|
||||
am__dry=no; \
|
||||
case $$MAKEFLAGS in \
|
||||
*\\[\ \ ]*) \
|
||||
echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \
|
||||
| grep '^AM OK$$' >/dev/null || am__dry=yes;; \
|
||||
*) \
|
||||
for am__flg in $$MAKEFLAGS; do \
|
||||
case $$am__flg in \
|
||||
*=*|--*) ;; \
|
||||
*n*) am__dry=yes; break;; \
|
||||
esac; \
|
||||
done;; \
|
||||
esac; \
|
||||
test $$am__dry = yes; \
|
||||
}
|
||||
pkgdatadir = $(datadir)/@PACKAGE@
|
||||
pkgincludedir = $(includedir)/@PACKAGE@
|
||||
pkglibdir = $(libdir)/@PACKAGE@
|
||||
pkglibexecdir = $(libexecdir)/@PACKAGE@
|
||||
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
|
||||
install_sh_DATA = $(install_sh) -c -m 644
|
||||
install_sh_PROGRAM = $(install_sh) -c
|
||||
install_sh_SCRIPT = $(install_sh) -c
|
||||
INSTALL_HEADER = $(INSTALL_DATA)
|
||||
transform = $(program_transform_name)
|
||||
NORMAL_INSTALL = :
|
||||
PRE_INSTALL = :
|
||||
POST_INSTALL = :
|
||||
NORMAL_UNINSTALL = :
|
||||
PRE_UNINSTALL = :
|
||||
POST_UNINSTALL = :
|
||||
build_triplet = @build@
|
||||
host_triplet = @host@
|
||||
@USE_VERSION_RC_FALSE@libSDL2_image_la_DEPENDENCIES = \
|
||||
@USE_VERSION_RC_FALSE@ $(am__DEPENDENCIES_1)
|
||||
noinst_PROGRAMS = showimage$(EXEEXT)
|
||||
subdir = .
|
||||
DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
|
||||
$(top_srcdir)/configure $(am__configure_deps) \
|
||||
$(srcdir)/SDL2_image.spec.in $(srcdir)/SDL2_image.pc.in \
|
||||
depcomp $(libSDL2_imageinclude_HEADERS) config.guess \
|
||||
config.sub install-sh missing ltmain.sh
|
||||
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
|
||||
am__aclocal_m4_deps = $(top_srcdir)/acinclude/libtool.m4 \
|
||||
$(top_srcdir)/acinclude/ltoptions.m4 \
|
||||
$(top_srcdir)/acinclude/ltsugar.m4 \
|
||||
$(top_srcdir)/acinclude/ltversion.m4 \
|
||||
$(top_srcdir)/acinclude/lt~obsolete.m4 \
|
||||
$(top_srcdir)/acinclude/pkg.m4 $(top_srcdir)/acinclude/sdl2.m4 \
|
||||
$(top_srcdir)/configure.in
|
||||
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
|
||||
$(ACLOCAL_M4)
|
||||
am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
|
||||
configure.lineno config.status.lineno
|
||||
mkinstalldirs = $(install_sh) -d
|
||||
CONFIG_CLEAN_FILES = SDL2_image.spec SDL2_image.pc
|
||||
CONFIG_CLEAN_VPATH_FILES =
|
||||
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
|
||||
am__vpath_adj = case $$p in \
|
||||
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
|
||||
*) f=$$p;; \
|
||||
esac;
|
||||
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
|
||||
am__install_max = 40
|
||||
am__nobase_strip_setup = \
|
||||
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
|
||||
am__nobase_strip = \
|
||||
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
|
||||
am__nobase_list = $(am__nobase_strip_setup); \
|
||||
for p in $$list; do echo "$$p $$p"; done | \
|
||||
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
|
||||
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
|
||||
if (++n[$$2] == $(am__install_max)) \
|
||||
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
|
||||
END { for (dir in files) print dir, files[dir] }'
|
||||
am__base_list = \
|
||||
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
|
||||
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
|
||||
am__uninstall_files_from_dir = { \
|
||||
test -z "$$files" \
|
||||
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|
||||
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
|
||||
$(am__cd) "$$dir" && rm -f $$files; }; \
|
||||
}
|
||||
am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" \
|
||||
"$(DESTDIR)$(libSDL2_imageincludedir)"
|
||||
LTLIBRARIES = $(lib_LTLIBRARIES)
|
||||
am__DEPENDENCIES_1 =
|
||||
am__libSDL2_image_la_SOURCES_DIST = IMG.c IMG_bmp.c IMG_gif.c \
|
||||
IMG_jpg.c IMG_lbm.c IMG_pcx.c IMG_png.c IMG_pnm.c IMG_tga.c \
|
||||
IMG_tif.c IMG_xcf.c IMG_xpm.c IMG_xv.c IMG_webp.c \
|
||||
IMG_ImageIO.m miniz.h
|
||||
@USE_IMAGEIO_TRUE@am__objects_1 = IMG_ImageIO.lo
|
||||
am_libSDL2_image_la_OBJECTS = IMG.lo IMG_bmp.lo IMG_gif.lo IMG_jpg.lo \
|
||||
IMG_lbm.lo IMG_pcx.lo IMG_png.lo IMG_pnm.lo IMG_tga.lo \
|
||||
IMG_tif.lo IMG_xcf.lo IMG_xpm.lo IMG_xv.lo IMG_webp.lo \
|
||||
$(am__objects_1)
|
||||
libSDL2_image_la_OBJECTS = $(am_libSDL2_image_la_OBJECTS)
|
||||
AM_V_lt = $(am__v_lt_@AM_V@)
|
||||
am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
|
||||
am__v_lt_0 = --silent
|
||||
am__v_lt_1 =
|
||||
libSDL2_image_la_LINK = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \
|
||||
$(LIBTOOLFLAGS) --mode=link $(OBJCLD) $(AM_OBJCFLAGS) \
|
||||
$(OBJCFLAGS) $(libSDL2_image_la_LDFLAGS) $(LDFLAGS) -o $@
|
||||
PROGRAMS = $(noinst_PROGRAMS)
|
||||
showimage_SOURCES = showimage.c
|
||||
showimage_OBJECTS = showimage.$(OBJEXT)
|
||||
showimage_DEPENDENCIES = libSDL2_image.la
|
||||
AM_V_P = $(am__v_P_@AM_V@)
|
||||
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
|
||||
am__v_P_0 = false
|
||||
am__v_P_1 = :
|
||||
AM_V_GEN = $(am__v_GEN_@AM_V@)
|
||||
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
|
||||
am__v_GEN_0 = @echo " GEN " $@;
|
||||
am__v_GEN_1 =
|
||||
AM_V_at = $(am__v_at_@AM_V@)
|
||||
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
|
||||
am__v_at_0 = @
|
||||
am__v_at_1 =
|
||||
DEFAULT_INCLUDES = -I.@am__isrc@
|
||||
depcomp = $(SHELL) $(top_srcdir)/depcomp
|
||||
am__depfiles_maybe = depfiles
|
||||
am__mv = mv -f
|
||||
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
|
||||
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
|
||||
LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
|
||||
$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
|
||||
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
|
||||
$(AM_CFLAGS) $(CFLAGS)
|
||||
AM_V_CC = $(am__v_CC_@AM_V@)
|
||||
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
|
||||
am__v_CC_0 = @echo " CC " $@;
|
||||
am__v_CC_1 =
|
||||
CCLD = $(CC)
|
||||
LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
|
||||
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
|
||||
$(AM_LDFLAGS) $(LDFLAGS) -o $@
|
||||
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
|
||||
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
|
||||
am__v_CCLD_0 = @echo " CCLD " $@;
|
||||
am__v_CCLD_1 =
|
||||
OBJCCOMPILE = $(OBJC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
|
||||
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_OBJCFLAGS) $(OBJCFLAGS)
|
||||
LTOBJCCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \
|
||||
$(LIBTOOLFLAGS) --mode=compile $(OBJC) $(DEFS) \
|
||||
$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
|
||||
$(AM_OBJCFLAGS) $(OBJCFLAGS)
|
||||
AM_V_OBJC = $(am__v_OBJC_@AM_V@)
|
||||
am__v_OBJC_ = $(am__v_OBJC_@AM_DEFAULT_V@)
|
||||
am__v_OBJC_0 = @echo " OBJC " $@;
|
||||
am__v_OBJC_1 =
|
||||
OBJCLD = $(OBJC)
|
||||
OBJCLINK = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
|
||||
--mode=link $(OBJCLD) $(AM_OBJCFLAGS) $(OBJCFLAGS) \
|
||||
$(AM_LDFLAGS) $(LDFLAGS) -o $@
|
||||
AM_V_OBJCLD = $(am__v_OBJCLD_@AM_V@)
|
||||
am__v_OBJCLD_ = $(am__v_OBJCLD_@AM_DEFAULT_V@)
|
||||
am__v_OBJCLD_0 = @echo " OBJCLD " $@;
|
||||
am__v_OBJCLD_1 =
|
||||
SOURCES = $(libSDL2_image_la_SOURCES) showimage.c
|
||||
DIST_SOURCES = $(am__libSDL2_image_la_SOURCES_DIST) showimage.c
|
||||
am__can_run_installinfo = \
|
||||
case $$AM_UPDATE_INFO_DIR in \
|
||||
n|no|NO) false;; \
|
||||
*) (install-info --version) >/dev/null 2>&1;; \
|
||||
esac
|
||||
DATA = $(pkgconfig_DATA)
|
||||
HEADERS = $(libSDL2_imageinclude_HEADERS)
|
||||
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
|
||||
# Read a list of newline-separated strings from the standard input,
|
||||
# and print each of them once, without duplicates. Input order is
|
||||
# *not* preserved.
|
||||
am__uniquify_input = $(AWK) '\
|
||||
BEGIN { nonempty = 0; } \
|
||||
{ items[$$0] = 1; nonempty = 1; } \
|
||||
END { if (nonempty) { for (i in items) print i; }; } \
|
||||
'
|
||||
# Make sure the list of sources is unique. This is necessary because,
|
||||
# e.g., the same source file might be shared among _SOURCES variables
|
||||
# for different programs/libraries.
|
||||
am__define_uniq_tagged_files = \
|
||||
list='$(am__tagged_files)'; \
|
||||
unique=`for i in $$list; do \
|
||||
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
|
||||
done | $(am__uniquify_input)`
|
||||
ETAGS = etags
|
||||
CTAGS = ctags
|
||||
CSCOPE = cscope
|
||||
AM_RECURSIVE_TARGETS = cscope
|
||||
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
|
||||
distdir = $(PACKAGE)-$(VERSION)
|
||||
top_distdir = $(distdir)
|
||||
am__remove_distdir = \
|
||||
if test -d "$(distdir)"; then \
|
||||
find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
|
||||
&& rm -rf "$(distdir)" \
|
||||
|| { sleep 5 && rm -rf "$(distdir)"; }; \
|
||||
else :; fi
|
||||
am__post_remove_distdir = $(am__remove_distdir)
|
||||
DIST_ARCHIVES = $(distdir).tar.gz
|
||||
GZIP_ENV = --best
|
||||
DIST_TARGETS = dist-gzip
|
||||
distuninstallcheck_listfiles = find . -type f -print
|
||||
am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
|
||||
| sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
|
||||
distcleancheck_listfiles = find . -type f -print
|
||||
ACLOCAL = @ACLOCAL@
|
||||
AMTAR = @AMTAR@
|
||||
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
|
||||
AR = @AR@
|
||||
AS = @AS@
|
||||
AUTOCONF = @AUTOCONF@
|
||||
AUTOHEADER = @AUTOHEADER@
|
||||
AUTOMAKE = @AUTOMAKE@
|
||||
AWK = @AWK@
|
||||
BINARY_AGE = @BINARY_AGE@
|
||||
CC = @CC@
|
||||
CCDEPMODE = @CCDEPMODE@
|
||||
CFLAGS = @CFLAGS@
|
||||
CPP = @CPP@
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
CYGPATH_W = @CYGPATH_W@
|
||||
DEFS = @DEFS@
|
||||
DEPDIR = @DEPDIR@
|
||||
DLLTOOL = @DLLTOOL@
|
||||
DSYMUTIL = @DSYMUTIL@
|
||||
DUMPBIN = @DUMPBIN@
|
||||
ECHO_C = @ECHO_C@
|
||||
ECHO_N = @ECHO_N@
|
||||
ECHO_T = @ECHO_T@
|
||||
EGREP = @EGREP@
|
||||
EXEEXT = @EXEEXT@
|
||||
FGREP = @FGREP@
|
||||
GREP = @GREP@
|
||||
IMG_LIBS = @IMG_LIBS@
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
|
||||
INTERFACE_AGE = @INTERFACE_AGE@
|
||||
LD = @LD@
|
||||
LDFLAGS = @LDFLAGS@
|
||||
LIBOBJS = @LIBOBJS@
|
||||
LIBPNG_CFLAGS = @LIBPNG_CFLAGS@
|
||||
LIBPNG_LIBS = @LIBPNG_LIBS@
|
||||
LIBS = @LIBS@
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LIBWEBP_CFLAGS = @LIBWEBP_CFLAGS@
|
||||
LIBWEBP_LIBS = @LIBWEBP_LIBS@
|
||||
LIPO = @LIPO@
|
||||
LN_S = @LN_S@
|
||||
LTLIBOBJS = @LTLIBOBJS@
|
||||
LT_AGE = @LT_AGE@
|
||||
LT_CURRENT = @LT_CURRENT@
|
||||
LT_RELEASE = @LT_RELEASE@
|
||||
LT_REVISION = @LT_REVISION@
|
||||
MAJOR_VERSION = @MAJOR_VERSION@
|
||||
MAKEINFO = @MAKEINFO@
|
||||
MICRO_VERSION = @MICRO_VERSION@
|
||||
MINOR_VERSION = @MINOR_VERSION@
|
||||
MKDIR_P = @MKDIR_P@
|
||||
NM = @NM@
|
||||
NMEDIT = @NMEDIT@
|
||||
OBJC = @OBJC@
|
||||
OBJCDEPMODE = @OBJCDEPMODE@
|
||||
OBJCFLAGS = @OBJCFLAGS@
|
||||
OBJDUMP = @OBJDUMP@
|
||||
OBJEXT = @OBJEXT@
|
||||
OTOOL = @OTOOL@
|
||||
OTOOL64 = @OTOOL64@
|
||||
PACKAGE = @PACKAGE@
|
||||
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
|
||||
PACKAGE_NAME = @PACKAGE_NAME@
|
||||
PACKAGE_STRING = @PACKAGE_STRING@
|
||||
PACKAGE_TARNAME = @PACKAGE_TARNAME@
|
||||
PACKAGE_URL = @PACKAGE_URL@
|
||||
PACKAGE_VERSION = @PACKAGE_VERSION@
|
||||
PATH_SEPARATOR = @PATH_SEPARATOR@
|
||||
PKG_CONFIG = @PKG_CONFIG@
|
||||
RANLIB = @RANLIB@
|
||||
SDL2_CONFIG = @SDL2_CONFIG@
|
||||
SDL_CFLAGS = @SDL_CFLAGS@
|
||||
SDL_LIBS = @SDL_LIBS@
|
||||
SDL_VERSION = @SDL_VERSION@
|
||||
SED = @SED@
|
||||
SET_MAKE = @SET_MAKE@
|
||||
SHELL = @SHELL@
|
||||
STRIP = @STRIP@
|
||||
VERSION = @VERSION@
|
||||
WINDRES = @WINDRES@
|
||||
abs_builddir = @abs_builddir@
|
||||
abs_srcdir = @abs_srcdir@
|
||||
abs_top_builddir = @abs_top_builddir@
|
||||
abs_top_srcdir = @abs_top_srcdir@
|
||||
ac_ct_CC = @ac_ct_CC@
|
||||
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
|
||||
ac_ct_OBJC = @ac_ct_OBJC@
|
||||
am__include = @am__include@
|
||||
am__leading_dot = @am__leading_dot@
|
||||
am__quote = @am__quote@
|
||||
am__tar = @am__tar@
|
||||
am__untar = @am__untar@
|
||||
bindir = @bindir@
|
||||
build = @build@
|
||||
build_alias = @build_alias@
|
||||
build_cpu = @build_cpu@
|
||||
build_os = @build_os@
|
||||
build_vendor = @build_vendor@
|
||||
builddir = @builddir@
|
||||
datadir = @datadir@
|
||||
datarootdir = @datarootdir@
|
||||
docdir = @docdir@
|
||||
dvidir = @dvidir@
|
||||
exec_prefix = @exec_prefix@
|
||||
host = @host@
|
||||
host_alias = @host_alias@
|
||||
host_cpu = @host_cpu@
|
||||
host_os = @host_os@
|
||||
host_vendor = @host_vendor@
|
||||
htmldir = @htmldir@
|
||||
includedir = @includedir@
|
||||
infodir = @infodir@
|
||||
install_sh = @install_sh@
|
||||
libdir = @libdir@
|
||||
libexecdir = @libexecdir@
|
||||
localedir = @localedir@
|
||||
localstatedir = @localstatedir@
|
||||
lt_ECHO = @lt_ECHO@
|
||||
mandir = @mandir@
|
||||
mkdir_p = @mkdir_p@
|
||||
oldincludedir = @oldincludedir@
|
||||
pdfdir = @pdfdir@
|
||||
prefix = @prefix@
|
||||
program_transform_name = @program_transform_name@
|
||||
psdir = @psdir@
|
||||
sbindir = @sbindir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
srcdir = @srcdir@
|
||||
sysconfdir = @sysconfdir@
|
||||
target_alias = @target_alias@
|
||||
top_build_prefix = @top_build_prefix@
|
||||
top_builddir = @top_builddir@
|
||||
top_srcdir = @top_srcdir@
|
||||
lib_LTLIBRARIES = libSDL2_image.la
|
||||
libSDL2_imageincludedir = $(includedir)/SDL2
|
||||
libSDL2_imageinclude_HEADERS = \
|
||||
SDL_image.h
|
||||
|
||||
@USE_IMAGEIO_TRUE@IMAGEIO_SOURCE = IMG_ImageIO.m
|
||||
libSDL2_image_la_SOURCES = \
|
||||
IMG.c \
|
||||
IMG_bmp.c \
|
||||
IMG_gif.c \
|
||||
IMG_jpg.c \
|
||||
IMG_lbm.c \
|
||||
IMG_pcx.c \
|
||||
IMG_png.c \
|
||||
IMG_pnm.c \
|
||||
IMG_tga.c \
|
||||
IMG_tif.c \
|
||||
IMG_xcf.c \
|
||||
IMG_xpm.c \
|
||||
IMG_xv.c \
|
||||
IMG_webp.c \
|
||||
$(IMAGEIO_SOURCE) \
|
||||
miniz.h
|
||||
|
||||
EXTRA_DIST = \
|
||||
Android.mk \
|
||||
debian \
|
||||
external \
|
||||
version.rc \
|
||||
VisualC \
|
||||
VisualCE \
|
||||
Xcode \
|
||||
Xcode-iOS \
|
||||
IMG_xxx.c \
|
||||
$(srcdir)/*.m \
|
||||
SDL2_image.spec \
|
||||
gcc-fat.sh \
|
||||
autogen.sh \
|
||||
$(srcdir)/*.txt
|
||||
|
||||
@USE_VERSION_RC_FALSE@libSDL2_image_la_LDFLAGS = \
|
||||
@USE_VERSION_RC_FALSE@ -no-undefined \
|
||||
@USE_VERSION_RC_FALSE@ -release $(LT_RELEASE) \
|
||||
@USE_VERSION_RC_FALSE@ -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
|
||||
|
||||
@USE_VERSION_RC_TRUE@libSDL2_image_la_LDFLAGS = \
|
||||
@USE_VERSION_RC_TRUE@ -no-undefined \
|
||||
@USE_VERSION_RC_TRUE@ -release $(LT_RELEASE) \
|
||||
@USE_VERSION_RC_TRUE@ -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) -Wl,version.o
|
||||
|
||||
@USE_VERSION_RC_FALSE@libSDL2_image_la_LIBADD = $(IMG_LIBS)
|
||||
@USE_VERSION_RC_TRUE@libSDL2_image_la_LIBADD = $(IMG_LIBS)
|
||||
@USE_VERSION_RC_TRUE@libSDL2_image_la_DEPENDENCIES = version.o
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
pkgconfig_DATA = SDL2_image.pc
|
||||
showimage_LDADD = libSDL2_image.la
|
||||
all: all-am
|
||||
|
||||
.SUFFIXES:
|
||||
.SUFFIXES: .c .lo .m .o .obj
|
||||
am--refresh: Makefile
|
||||
@:
|
||||
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
|
||||
@for dep in $?; do \
|
||||
case '$(am__configure_deps)' in \
|
||||
*$$dep*) \
|
||||
echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
|
||||
$(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
|
||||
&& exit 0; \
|
||||
exit 1;; \
|
||||
esac; \
|
||||
done; \
|
||||
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
|
||||
$(am__cd) $(top_srcdir) && \
|
||||
$(AUTOMAKE) --foreign Makefile
|
||||
.PRECIOUS: Makefile
|
||||
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
|
||||
@case '$?' in \
|
||||
*config.status*) \
|
||||
echo ' $(SHELL) ./config.status'; \
|
||||
$(SHELL) ./config.status;; \
|
||||
*) \
|
||||
echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
|
||||
cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
|
||||
esac;
|
||||
|
||||
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
|
||||
$(SHELL) ./config.status --recheck
|
||||
|
||||
$(top_srcdir)/configure: $(am__configure_deps)
|
||||
$(am__cd) $(srcdir) && $(AUTOCONF)
|
||||
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
|
||||
$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
|
||||
$(am__aclocal_m4_deps):
|
||||
SDL2_image.spec: $(top_builddir)/config.status $(srcdir)/SDL2_image.spec.in
|
||||
cd $(top_builddir) && $(SHELL) ./config.status $@
|
||||
SDL2_image.pc: $(top_builddir)/config.status $(srcdir)/SDL2_image.pc.in
|
||||
cd $(top_builddir) && $(SHELL) ./config.status $@
|
||||
|
||||
install-libLTLIBRARIES: $(lib_LTLIBRARIES)
|
||||
@$(NORMAL_INSTALL)
|
||||
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
|
||||
list2=; for p in $$list; do \
|
||||
if test -f $$p; then \
|
||||
list2="$$list2 $$p"; \
|
||||
else :; fi; \
|
||||
done; \
|
||||
test -z "$$list2" || { \
|
||||
echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
|
||||
$(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
|
||||
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
|
||||
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
|
||||
}
|
||||
|
||||
uninstall-libLTLIBRARIES:
|
||||
@$(NORMAL_UNINSTALL)
|
||||
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
|
||||
for p in $$list; do \
|
||||
$(am__strip_dir) \
|
||||
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
|
||||
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
|
||||
done
|
||||
|
||||
clean-libLTLIBRARIES:
|
||||
-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
|
||||
@list='$(lib_LTLIBRARIES)'; \
|
||||
locs=`for p in $$list; do echo $$p; done | \
|
||||
sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
|
||||
sort -u`; \
|
||||
test -z "$$locs" || { \
|
||||
echo rm -f $${locs}; \
|
||||
rm -f $${locs}; \
|
||||
}
|
||||
libSDL2_image.la: $(libSDL2_image_la_OBJECTS) $(libSDL2_image_la_DEPENDENCIES) $(EXTRA_libSDL2_image_la_DEPENDENCIES)
|
||||
$(AM_V_OBJCLD)$(libSDL2_image_la_LINK) -rpath $(libdir) $(libSDL2_image_la_OBJECTS) $(libSDL2_image_la_LIBADD) $(LIBS)
|
||||
|
||||
clean-noinstPROGRAMS:
|
||||
@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
|
||||
echo " rm -f" $$list; \
|
||||
rm -f $$list || exit $$?; \
|
||||
test -n "$(EXEEXT)" || exit 0; \
|
||||
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
|
||||
echo " rm -f" $$list; \
|
||||
rm -f $$list
|
||||
showimage$(EXEEXT): $(showimage_OBJECTS) $(showimage_DEPENDENCIES) $(EXTRA_showimage_DEPENDENCIES)
|
||||
@rm -f showimage$(EXEEXT)
|
||||
$(AM_V_CCLD)$(LINK) $(showimage_OBJECTS) $(showimage_LDADD) $(LIBS)
|
||||
|
||||
mostlyclean-compile:
|
||||
-rm -f *.$(OBJEXT)
|
||||
|
||||
distclean-compile:
|
||||
-rm -f *.tab.c
|
||||
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_ImageIO.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_bmp.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_gif.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_jpg.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_lbm.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_pcx.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_png.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_pnm.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_tga.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_tif.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_webp.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_xcf.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_xpm.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IMG_xv.Plo@am__quote@
|
||||
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/showimage.Po@am__quote@
|
||||
|
||||
.c.o:
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c $<
|
||||
|
||||
.c.obj:
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'`
|
||||
|
||||
.c.lo:
|
||||
@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
|
||||
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
|
||||
|
||||
.m.o:
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_OBJC)$(OBJCCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ $(AM_V_OBJC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ DEPDIR=$(DEPDIR) $(OBJCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepOBJC_FALSE@ $(AM_V_OBJC@am__nodep@)$(OBJCCOMPILE) -c -o $@ $<
|
||||
|
||||
.m.obj:
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_OBJC)$(OBJCCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ $(AM_V_OBJC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ DEPDIR=$(DEPDIR) $(OBJCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepOBJC_FALSE@ $(AM_V_OBJC@am__nodep@)$(OBJCCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
|
||||
|
||||
.m.lo:
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_OBJC)$(LTOBJCCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
|
||||
@am__fastdepOBJC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ $(AM_V_OBJC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
|
||||
@AMDEP_TRUE@@am__fastdepOBJC_FALSE@ DEPDIR=$(DEPDIR) $(OBJCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
|
||||
@am__fastdepOBJC_FALSE@ $(AM_V_OBJC@am__nodep@)$(LTOBJCCOMPILE) -c -o $@ $<
|
||||
|
||||
mostlyclean-libtool:
|
||||
-rm -f *.lo
|
||||
|
||||
clean-libtool:
|
||||
-rm -rf .libs _libs
|
||||
|
||||
distclean-libtool:
|
||||
-rm -f libtool config.lt
|
||||
install-pkgconfigDATA: $(pkgconfig_DATA)
|
||||
@$(NORMAL_INSTALL)
|
||||
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
|
||||
if test -n "$$list"; then \
|
||||
echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
|
||||
$(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
|
||||
fi; \
|
||||
for p in $$list; do \
|
||||
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
|
||||
echo "$$d$$p"; \
|
||||
done | $(am__base_list) | \
|
||||
while read files; do \
|
||||
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
|
||||
$(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
|
||||
done
|
||||
|
||||
uninstall-pkgconfigDATA:
|
||||
@$(NORMAL_UNINSTALL)
|
||||
@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
|
||||
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
|
||||
dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
|
||||
install-libSDL2_imageincludeHEADERS: $(libSDL2_imageinclude_HEADERS)
|
||||
@$(NORMAL_INSTALL)
|
||||
@list='$(libSDL2_imageinclude_HEADERS)'; test -n "$(libSDL2_imageincludedir)" || list=; \
|
||||
if test -n "$$list"; then \
|
||||
echo " $(MKDIR_P) '$(DESTDIR)$(libSDL2_imageincludedir)'"; \
|
||||
$(MKDIR_P) "$(DESTDIR)$(libSDL2_imageincludedir)" || exit 1; \
|
||||
fi; \
|
||||
for p in $$list; do \
|
||||
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
|
||||
echo "$$d$$p"; \
|
||||
done | $(am__base_list) | \
|
||||
while read files; do \
|
||||
echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(libSDL2_imageincludedir)'"; \
|
||||
$(INSTALL_HEADER) $$files "$(DESTDIR)$(libSDL2_imageincludedir)" || exit $$?; \
|
||||
done
|
||||
|
||||
uninstall-libSDL2_imageincludeHEADERS:
|
||||
@$(NORMAL_UNINSTALL)
|
||||
@list='$(libSDL2_imageinclude_HEADERS)'; test -n "$(libSDL2_imageincludedir)" || list=; \
|
||||
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
|
||||
dir='$(DESTDIR)$(libSDL2_imageincludedir)'; $(am__uninstall_files_from_dir)
|
||||
|
||||
ID: $(am__tagged_files)
|
||||
$(am__define_uniq_tagged_files); mkid -fID $$unique
|
||||
tags: tags-am
|
||||
TAGS: tags
|
||||
|
||||
tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
|
||||
set x; \
|
||||
here=`pwd`; \
|
||||
$(am__define_uniq_tagged_files); \
|
||||
shift; \
|
||||
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
|
||||
test -n "$$unique" || unique=$$empty_fix; \
|
||||
if test $$# -gt 0; then \
|
||||
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
|
||||
"$$@" $$unique; \
|
||||
else \
|
||||
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
|
||||
$$unique; \
|
||||
fi; \
|
||||
fi
|
||||
ctags: ctags-am
|
||||
|
||||
CTAGS: ctags
|
||||
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
|
||||
$(am__define_uniq_tagged_files); \
|
||||
test -z "$(CTAGS_ARGS)$$unique" \
|
||||
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
|
||||
$$unique
|
||||
|
||||
GTAGS:
|
||||
here=`$(am__cd) $(top_builddir) && pwd` \
|
||||
&& $(am__cd) $(top_srcdir) \
|
||||
&& gtags -i $(GTAGS_ARGS) "$$here"
|
||||
cscope: cscope.files
|
||||
test ! -s cscope.files \
|
||||
|| $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
|
||||
clean-cscope:
|
||||
-rm -f cscope.files
|
||||
cscope.files: clean-cscope cscopelist
|
||||
cscopelist: cscopelist-am
|
||||
|
||||
cscopelist-am: $(am__tagged_files)
|
||||
list='$(am__tagged_files)'; \
|
||||
case "$(srcdir)" in \
|
||||
[\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
|
||||
*) sdir=$(subdir)/$(srcdir) ;; \
|
||||
esac; \
|
||||
for i in $$list; do \
|
||||
if test -f "$$i"; then \
|
||||
echo "$(subdir)/$$i"; \
|
||||
else \
|
||||
echo "$$sdir/$$i"; \
|
||||
fi; \
|
||||
done >> $(top_builddir)/cscope.files
|
||||
|
||||
distclean-tags:
|
||||
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
|
||||
-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
|
||||
|
||||
distdir: $(DISTFILES)
|
||||
$(am__remove_distdir)
|
||||
test -d "$(distdir)" || mkdir "$(distdir)"
|
||||
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
|
||||
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
|
||||
list='$(DISTFILES)'; \
|
||||
dist_files=`for file in $$list; do echo $$file; done | \
|
||||
sed -e "s|^$$srcdirstrip/||;t" \
|
||||
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
|
||||
case $$dist_files in \
|
||||
*/*) $(MKDIR_P) `echo "$$dist_files" | \
|
||||
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
|
||||
sort -u` ;; \
|
||||
esac; \
|
||||
for file in $$dist_files; do \
|
||||
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
|
||||
if test -d $$d/$$file; then \
|
||||
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
|
||||
if test -d "$(distdir)/$$file"; then \
|
||||
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
|
||||
fi; \
|
||||
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
|
||||
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
|
||||
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
|
||||
fi; \
|
||||
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
|
||||
else \
|
||||
test -f "$(distdir)/$$file" \
|
||||
|| cp -p $$d/$$file "$(distdir)/$$file" \
|
||||
|| exit 1; \
|
||||
fi; \
|
||||
done
|
||||
-test -n "$(am__skip_mode_fix)" \
|
||||
|| find "$(distdir)" -type d ! -perm -755 \
|
||||
-exec chmod u+rwx,go+rx {} \; -o \
|
||||
! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
|
||||
! -type d ! -perm -400 -exec chmod a+r {} \; -o \
|
||||
! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
|
||||
|| chmod -R a+r "$(distdir)"
|
||||
dist-gzip: distdir
|
||||
tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-bzip2: distdir
|
||||
tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-lzip: distdir
|
||||
tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-xz: distdir
|
||||
tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-tarZ: distdir
|
||||
tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-shar: distdir
|
||||
shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist-zip: distdir
|
||||
-rm -f $(distdir).zip
|
||||
zip -rq $(distdir).zip $(distdir)
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
dist dist-all:
|
||||
$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
|
||||
$(am__post_remove_distdir)
|
||||
|
||||
# This target untars the dist file and tries a VPATH configuration. Then
|
||||
# it guarantees that the distribution is self-contained by making another
|
||||
# tarfile.
|
||||
distcheck: dist
|
||||
case '$(DIST_ARCHIVES)' in \
|
||||
*.tar.gz*) \
|
||||
GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
|
||||
*.tar.bz2*) \
|
||||
bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
|
||||
*.tar.lz*) \
|
||||
lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
|
||||
*.tar.xz*) \
|
||||
xz -dc $(distdir).tar.xz | $(am__untar) ;;\
|
||||
*.tar.Z*) \
|
||||
uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
|
||||
*.shar.gz*) \
|
||||
GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
|
||||
*.zip*) \
|
||||
unzip $(distdir).zip ;;\
|
||||
esac
|
||||
chmod -R a-w $(distdir)
|
||||
chmod u+w $(distdir)
|
||||
mkdir $(distdir)/_build $(distdir)/_inst
|
||||
chmod a-w $(distdir)
|
||||
test -d $(distdir)/_build || exit 0; \
|
||||
dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
|
||||
&& dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
|
||||
&& am__cwd=`pwd` \
|
||||
&& $(am__cd) $(distdir)/_build \
|
||||
&& ../configure --srcdir=.. --prefix="$$dc_install_base" \
|
||||
$(AM_DISTCHECK_CONFIGURE_FLAGS) \
|
||||
$(DISTCHECK_CONFIGURE_FLAGS) \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) dvi \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) check \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) install \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) installcheck \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) uninstall \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
|
||||
distuninstallcheck \
|
||||
&& chmod -R a-w "$$dc_install_base" \
|
||||
&& ({ \
|
||||
(cd ../.. && umask 077 && mkdir "$$dc_destdir") \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
|
||||
distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
|
||||
} || { rm -rf "$$dc_destdir"; exit 1; }) \
|
||||
&& rm -rf "$$dc_destdir" \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) dist \
|
||||
&& rm -rf $(DIST_ARCHIVES) \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
|
||||
&& cd "$$am__cwd" \
|
||||
|| exit 1
|
||||
$(am__post_remove_distdir)
|
||||
@(echo "$(distdir) archives ready for distribution: "; \
|
||||
list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
|
||||
sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
|
||||
distuninstallcheck:
|
||||
@test -n '$(distuninstallcheck_dir)' || { \
|
||||
echo 'ERROR: trying to run $@ with an empty' \
|
||||
'$$(distuninstallcheck_dir)' >&2; \
|
||||
exit 1; \
|
||||
}; \
|
||||
$(am__cd) '$(distuninstallcheck_dir)' || { \
|
||||
echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
|
||||
exit 1; \
|
||||
}; \
|
||||
test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
|
||||
|| { echo "ERROR: files left after uninstall:" ; \
|
||||
if test -n "$(DESTDIR)"; then \
|
||||
echo " (check DESTDIR support)"; \
|
||||
fi ; \
|
||||
$(distuninstallcheck_listfiles) ; \
|
||||
exit 1; } >&2
|
||||
distcleancheck: distclean
|
||||
@if test '$(srcdir)' = . ; then \
|
||||
echo "ERROR: distcleancheck can only run from a VPATH build" ; \
|
||||
exit 1 ; \
|
||||
fi
|
||||
@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
|
||||
|| { echo "ERROR: files left in build directory after distclean:" ; \
|
||||
$(distcleancheck_listfiles) ; \
|
||||
exit 1; } >&2
|
||||
check-am: all-am
|
||||
check: check-am
|
||||
all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) $(DATA) $(HEADERS)
|
||||
installdirs:
|
||||
for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(libSDL2_imageincludedir)"; do \
|
||||
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
|
||||
done
|
||||
install: install-am
|
||||
install-exec: install-exec-am
|
||||
install-data: install-data-am
|
||||
uninstall: uninstall-am
|
||||
|
||||
install-am: all-am
|
||||
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
|
||||
|
||||
installcheck: installcheck-am
|
||||
install-strip:
|
||||
if test -z '$(STRIP)'; then \
|
||||
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
|
||||
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
|
||||
install; \
|
||||
else \
|
||||
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
|
||||
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
|
||||
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
|
||||
fi
|
||||
mostlyclean-generic:
|
||||
|
||||
clean-generic:
|
||||
|
||||
distclean-generic:
|
||||
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
|
||||
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
|
||||
|
||||
maintainer-clean-generic:
|
||||
@echo "This command is intended for maintainers to use"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
clean: clean-am
|
||||
|
||||
clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
|
||||
clean-noinstPROGRAMS mostlyclean-am
|
||||
|
||||
distclean: distclean-am
|
||||
-rm -f $(am__CONFIG_DISTCLEAN_FILES)
|
||||
-rm -rf ./$(DEPDIR)
|
||||
-rm -f Makefile
|
||||
distclean-am: clean-am distclean-compile distclean-generic \
|
||||
distclean-libtool distclean-tags
|
||||
|
||||
dvi: dvi-am
|
||||
|
||||
dvi-am:
|
||||
|
||||
html: html-am
|
||||
|
||||
html-am:
|
||||
|
||||
info: info-am
|
||||
|
||||
info-am:
|
||||
|
||||
install-data-am: install-libSDL2_imageincludeHEADERS \
|
||||
install-pkgconfigDATA
|
||||
|
||||
install-dvi: install-dvi-am
|
||||
|
||||
install-dvi-am:
|
||||
|
||||
install-exec-am: install-libLTLIBRARIES
|
||||
|
||||
install-html: install-html-am
|
||||
|
||||
install-html-am:
|
||||
|
||||
install-info: install-info-am
|
||||
|
||||
install-info-am:
|
||||
|
||||
install-man:
|
||||
|
||||
install-pdf: install-pdf-am
|
||||
|
||||
install-pdf-am:
|
||||
|
||||
install-ps: install-ps-am
|
||||
|
||||
install-ps-am:
|
||||
|
||||
installcheck-am:
|
||||
|
||||
maintainer-clean: maintainer-clean-am
|
||||
-rm -f $(am__CONFIG_DISTCLEAN_FILES)
|
||||
-rm -rf $(top_srcdir)/autom4te.cache
|
||||
-rm -rf ./$(DEPDIR)
|
||||
-rm -f Makefile
|
||||
maintainer-clean-am: distclean-am maintainer-clean-generic
|
||||
|
||||
mostlyclean: mostlyclean-am
|
||||
|
||||
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
|
||||
mostlyclean-libtool
|
||||
|
||||
pdf: pdf-am
|
||||
|
||||
pdf-am:
|
||||
|
||||
ps: ps-am
|
||||
|
||||
ps-am:
|
||||
|
||||
uninstall-am: uninstall-libLTLIBRARIES \
|
||||
uninstall-libSDL2_imageincludeHEADERS uninstall-pkgconfigDATA
|
||||
|
||||
.MAKE: install-am install-strip
|
||||
|
||||
.PHONY: CTAGS GTAGS TAGS all all-am am--refresh check check-am clean \
|
||||
clean-cscope clean-generic clean-libLTLIBRARIES clean-libtool \
|
||||
clean-noinstPROGRAMS cscope cscopelist-am ctags ctags-am dist \
|
||||
dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \
|
||||
dist-xz dist-zip distcheck distclean distclean-compile \
|
||||
distclean-generic distclean-libtool distclean-tags \
|
||||
distcleancheck distdir distuninstallcheck dvi dvi-am html \
|
||||
html-am info info-am install install-am install-data \
|
||||
install-data-am install-dvi install-dvi-am install-exec \
|
||||
install-exec-am install-html install-html-am install-info \
|
||||
install-info-am install-libLTLIBRARIES \
|
||||
install-libSDL2_imageincludeHEADERS install-man install-pdf \
|
||||
install-pdf-am install-pkgconfigDATA install-ps install-ps-am \
|
||||
install-strip installcheck installcheck-am installdirs \
|
||||
maintainer-clean maintainer-clean-generic mostlyclean \
|
||||
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
|
||||
pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
|
||||
uninstall-libLTLIBRARIES uninstall-libSDL2_imageincludeHEADERS \
|
||||
uninstall-pkgconfigDATA
|
||||
|
||||
|
||||
%.o : %.rc
|
||||
$(WINDRES) $< $@
|
||||
|
||||
# Rule to build tar-gzipped distribution package
|
||||
$(PACKAGE)-$(VERSION).tar.gz: distcheck
|
||||
|
||||
# Rule to build RPM distribution package
|
||||
rpm: $(PACKAGE)-$(VERSION).tar.gz
|
||||
rpmbuild -ta $(PACKAGE)-$(VERSION).tar.gz
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make to not export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
.NOEXPORT:
|
||||
@@ -0,0 +1,40 @@
|
||||
|
||||
SDL_image 2.0
|
||||
|
||||
The latest version of this library is available from:
|
||||
http://www.libsdl.org/projects/SDL_image/
|
||||
|
||||
This is a simple library to load images of various formats as SDL surfaces.
|
||||
This library supports BMP, PNM (PPM/PGM/PBM), XPM, LBM, PCX, GIF, JPEG, PNG,
|
||||
TGA, and TIFF formats.
|
||||
|
||||
API:
|
||||
#include "SDL_image.h"
|
||||
|
||||
SDL_Surface *IMG_Load(const char *file);
|
||||
or
|
||||
SDL_Surface *IMG_Load_RW(SDL_RWops *src, int freesrc);
|
||||
or
|
||||
SDL_Surface *IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, char *type);
|
||||
|
||||
where type is a string specifying the format (i.e. "PNG" or "pcx").
|
||||
Note that IMG_Load_RW cannot load TGA images.
|
||||
|
||||
To create a surface from an XPM image included in C source, use:
|
||||
|
||||
SDL_Surface *IMG_ReadXPMFromArray(char **xpm);
|
||||
|
||||
An example program 'showimage' is included, with source in showimage.c
|
||||
|
||||
JPEG support requires the JPEG library: http://www.ijg.org/
|
||||
PNG support requires the PNG library: http://www.libpng.org/pub/png/libpng.html
|
||||
and the Zlib library: http://www.gzip.org/zlib/
|
||||
TIFF support requires the TIFF library: ftp://ftp.sgi.com/graphics/tiff/
|
||||
|
||||
If you have these libraries installed in non-standard places, you can
|
||||
try adding those paths to the configure script, e.g.
|
||||
sh ./configure CPPFLAGS="-I/somewhere/include" LDFLAGS="-L/somewhere/lib"
|
||||
If this works, you may need to add /somewhere/lib to your LD_LIBRARY_PATH
|
||||
so shared library loading works correctly.
|
||||
|
||||
This library is under the zlib License, see the file "COPYING.txt" for details.
|
||||
@@ -0,0 +1,12 @@
|
||||
prefix=@prefix@
|
||||
exec_prefix=@exec_prefix@
|
||||
libdir=@libdir@
|
||||
includedir=@includedir@
|
||||
|
||||
Name: @PACKAGE@
|
||||
Description: image loading library for Simple DirectMedia Layer
|
||||
Version: @VERSION@
|
||||
Requires: sdl2 >= @SDL_VERSION@
|
||||
Libs: -L${libdir} -lSDL2_image
|
||||
Cflags: -I${includedir}/SDL2
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
%define name SDL2_image
|
||||
%define version 2.0.0
|
||||
%define release 1
|
||||
|
||||
Summary: Simple DirectMedia Layer - Sample Image Loading Library
|
||||
Name: %{name}
|
||||
Version: %{version}
|
||||
Release: %{release}
|
||||
Source0: %{name}-%{version}.tar.gz
|
||||
License: LGPL
|
||||
Group: System Environment/Libraries
|
||||
BuildRoot: /var/tmp/%{name}-buildroot
|
||||
Prefix: %{_prefix}
|
||||
Packager: Hakan Tandogan <hakan@iconsult.com>
|
||||
#BuildRequires: SDL2-devel
|
||||
#BuildRequires: libjpeg-devel
|
||||
#BuildRequires: libpng-devel
|
||||
#BuildRequires: libtiff-devel
|
||||
|
||||
%description
|
||||
This is a simple library to load images of various formats as SDL surfaces.
|
||||
This library supports BMP, PPM, PCX, GIF, JPEG, PNG, and TIFF formats.
|
||||
|
||||
%package devel
|
||||
Summary: Libraries, includes and more to develop SDL applications.
|
||||
Group: Development/Libraries
|
||||
Requires: %{name}
|
||||
Requires: SDL2-devel
|
||||
|
||||
%description devel
|
||||
This is a simple library to load images of various formats as SDL surfaces.
|
||||
This library supports BMP, PPM, PCX, GIF, JPEG, PNG, and TIFF formats.
|
||||
|
||||
%prep
|
||||
rm -rf ${RPM_BUILD_ROOT}
|
||||
|
||||
%setup
|
||||
|
||||
%build
|
||||
CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=%{prefix}
|
||||
make
|
||||
|
||||
%install
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
make install prefix=$RPM_BUILD_ROOT/%{prefix}
|
||||
|
||||
%clean
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
|
||||
%files
|
||||
%defattr(-,root,root)
|
||||
%doc README.txt CHANGES.txt COPYING.txt
|
||||
%{prefix}/lib/lib*.so.*
|
||||
|
||||
%files devel
|
||||
%defattr(-,root,root)
|
||||
%{prefix}/lib/lib*.a
|
||||
%{prefix}/lib/lib*.la
|
||||
%{prefix}/lib/lib*.so
|
||||
%{prefix}/include/*/
|
||||
%{prefix}/lib/pkgconfig/*.pc
|
||||
|
||||
%changelog
|
||||
* Wed Jan 19 2000 Sam Lantinga
|
||||
- converted to get package information from configure
|
||||
* Tue Jan 18 2000 Hakan Tandogan <hakan@iconsult.com>
|
||||
- initial spec file
|
||||
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
%define name @PACKAGE@
|
||||
%define version @VERSION@
|
||||
%define release 1
|
||||
|
||||
Summary: Simple DirectMedia Layer - Sample Image Loading Library
|
||||
Name: %{name}
|
||||
Version: %{version}
|
||||
Release: %{release}
|
||||
Source0: %{name}-%{version}.tar.gz
|
||||
License: LGPL
|
||||
Group: System Environment/Libraries
|
||||
BuildRoot: /var/tmp/%{name}-buildroot
|
||||
Prefix: %{_prefix}
|
||||
Packager: Hakan Tandogan <hakan@iconsult.com>
|
||||
#BuildRequires: SDL2-devel
|
||||
#BuildRequires: libjpeg-devel
|
||||
#BuildRequires: libpng-devel
|
||||
#BuildRequires: libtiff-devel
|
||||
|
||||
%description
|
||||
This is a simple library to load images of various formats as SDL surfaces.
|
||||
This library supports BMP, PPM, PCX, GIF, JPEG, PNG, and TIFF formats.
|
||||
|
||||
%package devel
|
||||
Summary: Libraries, includes and more to develop SDL applications.
|
||||
Group: Development/Libraries
|
||||
Requires: %{name}
|
||||
Requires: SDL2-devel
|
||||
|
||||
%description devel
|
||||
This is a simple library to load images of various formats as SDL surfaces.
|
||||
This library supports BMP, PPM, PCX, GIF, JPEG, PNG, and TIFF formats.
|
||||
|
||||
%prep
|
||||
rm -rf ${RPM_BUILD_ROOT}
|
||||
|
||||
%setup
|
||||
|
||||
%build
|
||||
CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=%{prefix}
|
||||
make
|
||||
|
||||
%install
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
make install prefix=$RPM_BUILD_ROOT/%{prefix}
|
||||
|
||||
%clean
|
||||
rm -rf $RPM_BUILD_ROOT
|
||||
|
||||
%files
|
||||
%defattr(-,root,root)
|
||||
%doc README.txt CHANGES.txt COPYING.txt
|
||||
%{prefix}/lib/lib*.so.*
|
||||
|
||||
%files devel
|
||||
%defattr(-,root,root)
|
||||
%{prefix}/lib/lib*.a
|
||||
%{prefix}/lib/lib*.la
|
||||
%{prefix}/lib/lib*.so
|
||||
%{prefix}/include/*/
|
||||
%{prefix}/lib/pkgconfig/*.pc
|
||||
|
||||
%changelog
|
||||
* Wed Jan 19 2000 Sam Lantinga
|
||||
- converted to get package information from configure
|
||||
* Tue Jan 18 2000 Hakan Tandogan <hakan@iconsult.com>
|
||||
- initial spec file
|
||||
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
/*
|
||||
SDL_image: An example image loading library for use with SDL
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
/* A simple library to load images of various formats as SDL surfaces */
|
||||
|
||||
#ifndef _SDL_IMAGE_H
|
||||
#define _SDL_IMAGE_H
|
||||
|
||||
#include "SDL.h"
|
||||
#include "SDL_version.h"
|
||||
#include "begin_code.h"
|
||||
|
||||
/* Set up for C function definitions, even when using C++ */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
|
||||
*/
|
||||
#define SDL_IMAGE_MAJOR_VERSION 2
|
||||
#define SDL_IMAGE_MINOR_VERSION 0
|
||||
#define SDL_IMAGE_PATCHLEVEL 0
|
||||
|
||||
/* This macro can be used to fill a version structure with the compile-time
|
||||
* version of the SDL_image library.
|
||||
*/
|
||||
#define SDL_IMAGE_VERSION(X) \
|
||||
{ \
|
||||
(X)->major = SDL_IMAGE_MAJOR_VERSION; \
|
||||
(X)->minor = SDL_IMAGE_MINOR_VERSION; \
|
||||
(X)->patch = SDL_IMAGE_PATCHLEVEL; \
|
||||
}
|
||||
|
||||
/* This function gets the version of the dynamically linked SDL_image library.
|
||||
it should NOT be used to fill a version structure, instead you should
|
||||
use the SDL_IMAGE_VERSION() macro.
|
||||
*/
|
||||
extern DECLSPEC const SDL_version * SDLCALL IMG_Linked_Version(void);
|
||||
|
||||
typedef enum
|
||||
{
|
||||
IMG_INIT_JPG = 0x00000001,
|
||||
IMG_INIT_PNG = 0x00000002,
|
||||
IMG_INIT_TIF = 0x00000004,
|
||||
IMG_INIT_WEBP = 0x00000008
|
||||
} IMG_InitFlags;
|
||||
|
||||
/* Loads dynamic libraries and prepares them for use. Flags should be
|
||||
one or more flags from IMG_InitFlags OR'd together.
|
||||
It returns the flags successfully initialized, or 0 on failure.
|
||||
*/
|
||||
extern DECLSPEC int SDLCALL IMG_Init(int flags);
|
||||
|
||||
/* Unloads libraries loaded with IMG_Init */
|
||||
extern DECLSPEC void SDLCALL IMG_Quit(void);
|
||||
|
||||
/* Load an image from an SDL data source.
|
||||
The 'type' may be one of: "BMP", "GIF", "PNG", etc.
|
||||
|
||||
If the image format supports a transparent pixel, SDL will set the
|
||||
colorkey for the surface. You can enable RLE acceleration on the
|
||||
surface afterwards by calling:
|
||||
SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
|
||||
*/
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, const char *type);
|
||||
/* Convenience functions */
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_Load(const char *file);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_Load_RW(SDL_RWops *src, int freesrc);
|
||||
|
||||
#if SDL_VERSION_ATLEAST(2,0,0)
|
||||
/* Load an image directly into a render texture.
|
||||
*/
|
||||
extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTexture(SDL_Renderer *renderer, const char *file);
|
||||
extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTexture_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc);
|
||||
extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTextureTyped_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc, const char *type);
|
||||
#endif /* SDL 2.0 */
|
||||
|
||||
/* Functions to detect a file type, given a seekable source */
|
||||
extern DECLSPEC int SDLCALL IMG_isICO(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isCUR(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isBMP(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isGIF(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isJPG(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isLBM(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isPCX(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isPNG(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isPNM(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isTIF(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isXCF(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isXPM(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isXV(SDL_RWops *src);
|
||||
extern DECLSPEC int SDLCALL IMG_isWEBP(SDL_RWops *src);
|
||||
|
||||
/* Individual loading functions */
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadICO_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadCUR_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadBMP_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadGIF_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadJPG_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadLBM_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPCX_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPNG_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPNM_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTGA_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTIF_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXCF_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXPM_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXV_RW(SDL_RWops *src);
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadWEBP_RW(SDL_RWops *src);
|
||||
|
||||
extern DECLSPEC SDL_Surface * SDLCALL IMG_ReadXPMFromArray(char **xpm);
|
||||
|
||||
/* Individual saving functions */
|
||||
extern DECLSPEC int SDLCALL IMG_SavePNG(SDL_Surface *surface, const char *file);
|
||||
extern DECLSPEC int SDLCALL IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst);
|
||||
|
||||
/* We'll use SDL for reporting errors */
|
||||
#define IMG_SetError SDL_SetError
|
||||
#define IMG_GetError SDL_GetError
|
||||
|
||||
/* Ends C function definitions when using C++ */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#include "close_code.h"
|
||||
|
||||
#endif /* _SDL_IMAGE_H */
|
||||
Vendored
+1107
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
aclocal -I acinclude
|
||||
automake --foreign --include-deps --add-missing --copy
|
||||
autoconf
|
||||
|
||||
#./configure $*
|
||||
echo "Now you are ready to run ./configure"
|
||||
Vendored
+1494
File diff suppressed because it is too large
Load Diff
Vendored
+1700
File diff suppressed because it is too large
Load Diff
Vendored
+15512
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,371 @@
|
||||
dnl Process this file with autoconf to produce a configure script.
|
||||
AC_INIT(README.txt)
|
||||
|
||||
dnl Set various version strings - taken gratefully from the GTk sources
|
||||
|
||||
# Making releases:
|
||||
# MICRO_VERSION += 1;
|
||||
# INTERFACE_AGE += 1;
|
||||
# BINARY_AGE += 1;
|
||||
# if any functions have been added, set INTERFACE_AGE to 0.
|
||||
# if backwards compatibility has been broken,
|
||||
# set BINARY_AGE and INTERFACE_AGE to 0.
|
||||
|
||||
MAJOR_VERSION=2
|
||||
MINOR_VERSION=0
|
||||
MICRO_VERSION=0
|
||||
INTERFACE_AGE=0
|
||||
BINARY_AGE=0
|
||||
VERSION=$MAJOR_VERSION.$MINOR_VERSION.$MICRO_VERSION
|
||||
|
||||
AC_SUBST(MAJOR_VERSION)
|
||||
AC_SUBST(MINOR_VERSION)
|
||||
AC_SUBST(MICRO_VERSION)
|
||||
AC_SUBST(INTERFACE_AGE)
|
||||
AC_SUBST(BINARY_AGE)
|
||||
AC_SUBST(VERSION)
|
||||
|
||||
# libtool versioning
|
||||
LT_INIT([win32-dll])
|
||||
|
||||
LT_RELEASE=$MAJOR_VERSION.$MINOR_VERSION
|
||||
LT_CURRENT=`expr $MICRO_VERSION - $INTERFACE_AGE`
|
||||
LT_REVISION=$INTERFACE_AGE
|
||||
LT_AGE=`expr $BINARY_AGE - $INTERFACE_AGE`
|
||||
|
||||
AC_SUBST(LT_RELEASE)
|
||||
AC_SUBST(LT_CURRENT)
|
||||
AC_SUBST(LT_REVISION)
|
||||
AC_SUBST(LT_AGE)
|
||||
|
||||
dnl Detect the canonical build and host environments
|
||||
AC_CANONICAL_HOST
|
||||
|
||||
dnl Setup for automake
|
||||
AM_INIT_AUTOMAKE(SDL2_image, $VERSION)
|
||||
|
||||
dnl Check for tools
|
||||
AC_PROG_LIBTOOL
|
||||
AC_PROG_CC
|
||||
AC_PROG_OBJC
|
||||
AC_C_INLINE
|
||||
AC_PROG_INSTALL
|
||||
AC_PROG_MAKE_SET
|
||||
if test -z "$host_alias"; then
|
||||
hostaliaswindres=
|
||||
else
|
||||
hostaliaswindres="$host_alias-windres"
|
||||
fi
|
||||
AC_CHECK_PROGS(WINDRES, [windres $hostaliaswindres $host_os-windres])
|
||||
|
||||
case "$host" in
|
||||
*-*-beos*)
|
||||
ac_default_prefix=/boot/develop/tools/gnupro
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
if test "$build" != "$host"; then # cross-compiling
|
||||
# Default cross-compile location
|
||||
ac_default_prefix=/usr/local/cross-tools/i386-mingw32
|
||||
else
|
||||
# Look for the location of the tools and install there
|
||||
if test "$BUILD_PREFIX" != ""; then
|
||||
ac_default_prefix=$BUILD_PREFIX
|
||||
fi
|
||||
fi
|
||||
if test x$WINDRES != x; then
|
||||
use_version_rc=true
|
||||
fi
|
||||
;;
|
||||
*-*-darwin*)
|
||||
AC_ARG_ENABLE([imageio], [AC_HELP_STRING([--enable-imageio], [use native Mac OS X frameworks for loading images [default=yes]])],
|
||||
[], [enable_imageio=yes])
|
||||
if test x$enable_imageio = xyes; then
|
||||
IMG_LIBS="-Wl,-framework,ApplicationServices $IMG_LIBS"
|
||||
else
|
||||
CFLAGS="$CFLAGS -DSDL_IMAGE_USE_COMMON_BACKEND"
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
AM_CONDITIONAL(USE_IMAGEIO, test x$enable_imageio = xyes)
|
||||
AM_CONDITIONAL(USE_VERSION_RC, test x$use_version_rc = xtrue)
|
||||
|
||||
dnl set this to use on systems that use lib64 instead of lib
|
||||
base_libdir=`echo \${libdir} | sed 's/.*\/\(.*\)/\1/; q'`
|
||||
|
||||
dnl Function to find a library in the compiler search path
|
||||
find_lib()
|
||||
{
|
||||
gcc_bin_path=[`$CC -print-search-dirs 2>/dev/null | fgrep programs: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]
|
||||
gcc_lib_path=[`$CC -print-search-dirs 2>/dev/null | fgrep libraries: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]
|
||||
env_lib_path=[`echo $LIBS $LDFLAGS $* | sed 's/-L[ ]*//g'`]
|
||||
if test "$cross_compiling" = yes; then
|
||||
host_lib_path=""
|
||||
else
|
||||
host_lib_path="/usr/$base_libdir /usr/local/$base_libdir"
|
||||
fi
|
||||
for path in $gcc_bin_path $gcc_lib_path $env_lib_path $host_lib_path; do
|
||||
lib=[`ls -- $path/$1 2>/dev/null | sed -e '/\.so\..*\./d' -e 's,.*/,,' | sort | tail -1`]
|
||||
if test x$lib != x; then
|
||||
echo $lib
|
||||
return
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
dnl Check for SDL
|
||||
SDL_VERSION=2.0.0
|
||||
AC_SUBST(SDL_VERSION)
|
||||
AM_PATH_SDL2($SDL_VERSION,
|
||||
:,
|
||||
AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
|
||||
)
|
||||
CFLAGS="$CFLAGS $SDL_CFLAGS"
|
||||
LIBS="$LIBS $SDL_LIBS"
|
||||
saved_LIBS="$LIBS"
|
||||
|
||||
dnl Check command-line options
|
||||
AC_ARG_ENABLE([bmp], [AC_HELP_STRING([--enable-bmp], [support loading BMP/ICO/CUR images [default=yes]])],
|
||||
[], [enable_bmp=yes])
|
||||
AC_ARG_ENABLE([gif], [AC_HELP_STRING([--enable-gif], [support loading GIF images [default=yes]])],
|
||||
[], [enable_gif=yes])
|
||||
AC_ARG_ENABLE([jpg], [AC_HELP_STRING([--enable-jpg], [support loading JPG images [default=yes]])],
|
||||
[], [enable_jpg=yes])
|
||||
AC_ARG_ENABLE([jpg-shared], AC_HELP_STRING([--enable-jpg-shared], [dynamically load JPG support [[default=yes]]]),
|
||||
[], [enable_jpg_shared=yes])
|
||||
AC_ARG_ENABLE([lbm], [AC_HELP_STRING([--enable-lbm], [support loading LBM images [default=yes]])],
|
||||
[], [enable_lbm=yes])
|
||||
AC_ARG_ENABLE([pcx], [AC_HELP_STRING([--enable-pcx], [support loading PCX images [default=yes]])],
|
||||
[], [enable_pcx=yes])
|
||||
AC_ARG_ENABLE([png], [AC_HELP_STRING([--enable-png], [support loading PNG images [default=yes]])],
|
||||
[], [enable_png=yes])
|
||||
AC_ARG_ENABLE([png-shared], AC_HELP_STRING([--enable-png-shared], [dynamically load PNG support [[default=yes]]]),
|
||||
[], [enable_png_shared=yes])
|
||||
AC_ARG_ENABLE([pnm], [AC_HELP_STRING([--enable-pnm], [support loading PNM images [default=yes]])],
|
||||
[], [enable_pnm=yes])
|
||||
AC_ARG_ENABLE([tga], [AC_HELP_STRING([--enable-tga], [support loading TGA images [default=yes]])],
|
||||
[], [enable_tga=yes])
|
||||
AC_ARG_ENABLE([tif], [AC_HELP_STRING([--enable-tif], [support loading TIFF images [default=yes]])],
|
||||
[], [enable_tif=yes])
|
||||
AC_ARG_ENABLE([tif-shared], AC_HELP_STRING([--enable-tif-shared], [dynamically load TIFF support [[default=yes]]]),
|
||||
[], [enable_tif_shared=yes])
|
||||
AC_ARG_ENABLE([xcf], [AC_HELP_STRING([--enable-xcf], [support loading XCF images [default=yes]])],
|
||||
[], [enable_xcf=yes])
|
||||
AC_ARG_ENABLE([xpm], [AC_HELP_STRING([--enable-xpm], [support loading XPM images [default=yes]])],
|
||||
[], [enable_xpm=yes])
|
||||
AC_ARG_ENABLE([xv], [AC_HELP_STRING([--enable-xv], [support loading XV images [default=yes]])],
|
||||
[], [enable_xv=yes])
|
||||
AC_ARG_ENABLE([webp], [AC_HELP_STRING([--enable-webp], [support loading WEBP images [default=yes]])],
|
||||
[], [enable_webp=yes])
|
||||
AC_ARG_ENABLE([webp-shared], AC_HELP_STRING([--enable-webp-shared], [dynamically load WEBP support [[default=yes]]]),
|
||||
[], [enable_webp_shared=yes])
|
||||
|
||||
dnl Show a message when we use ImageIO support so it's not a surprise
|
||||
AC_MSG_CHECKING([for ImageIO support])
|
||||
AC_MSG_RESULT($enable_imageio)
|
||||
|
||||
if (test x$enable_jpg = xyes || test x$enable_tif = xyes) && test x$enable_imageio != xyes; then
|
||||
AC_CHECK_HEADER([jpeglib.h], [have_jpg_hdr=yes])
|
||||
AC_CHECK_LIB([jpeg], [jpeg_CreateDecompress], [have_jpg_lib=yes])
|
||||
if test x$have_jpg_hdr = xyes -a x$have_jpg_lib = xyes; then
|
||||
if test x$enable_jpg = xyes; then
|
||||
AC_DEFINE([LOAD_JPG])
|
||||
fi
|
||||
LIBS="-ljpeg $LIBS"
|
||||
|
||||
case "$host" in
|
||||
*-*-darwin*)
|
||||
jpg_lib=[`find_lib libjpeg.dylib`]
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
jpg_lib=[`find_lib "libjpeg*.dll"`]
|
||||
;;
|
||||
*)
|
||||
jpg_lib=[`find_lib "libjpeg[0-9]*.so.*"`]
|
||||
if test x$jpg_lib = x; then
|
||||
jpg_lib=[`find_lib "libjpeg.so.*"`]
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
elif test x$enable_jpg = xyes; then
|
||||
AC_MSG_WARN([*** Unable to find JPEG library (http://www.ijg.org/)])
|
||||
AC_MSG_WARN([JPG image loading disabled])
|
||||
fi
|
||||
fi
|
||||
|
||||
if test x$enable_png = xyes -a x$enable_imageio != xyes; then
|
||||
PKG_CHECK_MODULES([LIBPNG], [libpng], [dnl
|
||||
have_png_hdr=yes
|
||||
CFLAGS="$LIBPNG_CFLAGS $CFLAGS"
|
||||
have_png_lib=yes
|
||||
], [dnl
|
||||
AC_CHECK_HEADER([png.h], [have_png_hdr=yes])
|
||||
AC_CHECK_LIB([png], [png_create_read_struct], [have_png_lib=yes], [], [-lz])
|
||||
])
|
||||
if test x$have_png_hdr = xyes -a x$have_png_lib = xyes; then
|
||||
AC_DEFINE([LOAD_PNG])
|
||||
|
||||
case "$host" in
|
||||
*-*-darwin*)
|
||||
png_lib=[`find_lib libpng.dylib`]
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
png_lib=[`find_lib "libpng*.dll"`]
|
||||
;;
|
||||
*)
|
||||
png_lib=[`find_lib "libpng[0-9]*.so.*"`]
|
||||
if test x$png_lib = x; then
|
||||
png_lib=[`find_lib "libpng.so.*"`]
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
else
|
||||
AC_MSG_WARN([*** Unable to find PNG library (http://www.libpng.org/pub/png/libpng.html)])
|
||||
AC_MSG_WARN([PNG image loading disabled])
|
||||
fi
|
||||
fi
|
||||
|
||||
if test x$enable_tif = xyes -a x$enable_imageio != xyes; then
|
||||
AC_CHECK_HEADER([tiffio.h], [have_tif_hdr=yes])
|
||||
AC_CHECK_LIB([tiff], [TIFFClientOpen], [have_tif_lib=yes], [], [-lz])
|
||||
if test x$have_tif_hdr = xyes -a x$have_tif_lib = xyes; then
|
||||
AC_DEFINE([LOAD_TIF])
|
||||
|
||||
case "$host" in
|
||||
*-*-darwin*)
|
||||
tif_lib=[`find_lib libtiff.dylib`]
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
tif_lib=[`find_lib "libtiff-*.dll"`]
|
||||
;;
|
||||
*)
|
||||
tif_lib=[`find_lib "libtiff[0-9]*.so.*"`]
|
||||
if test x$tif_lib = x; then
|
||||
tif_lib=[`find_lib "libtiff.so.*"`]
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
else
|
||||
AC_MSG_WARN([*** Unable to find Tiff library (http://www.remotesensing.org/libtiff/)])
|
||||
AC_MSG_WARN([TIF image loading disabled])
|
||||
fi
|
||||
fi
|
||||
|
||||
if test x$enable_webp = xyes; then
|
||||
PKG_CHECK_MODULES([LIBWEBP], [libwebp], [dnl
|
||||
have_webp_hdr=yes
|
||||
CFLAGS="$LIBWEBP_CFLAGS $CFLAGS"
|
||||
have_webp_lib=yes
|
||||
], [dnl
|
||||
AC_CHECK_HEADER([webp/decode.h], [have_webp_hdr=yes])
|
||||
AC_CHECK_LIB([webp], [WebPGetDecoderVersion], [have_webp_lib=yes], [], [-lm])
|
||||
])
|
||||
if test x$have_webp_hdr = xyes -a x$have_webp_lib = xyes; then
|
||||
AC_DEFINE([LOAD_WEBP])
|
||||
|
||||
case "$host" in
|
||||
*-*-darwin*)
|
||||
webp_lib=[`find_lib libwebp.dylib`]
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw32*)
|
||||
webp_lib=[`find_lib "libwebp*.dll"`]
|
||||
;;
|
||||
*)
|
||||
webp_lib=[`find_lib "libwebp[0-9]*.so.*"`]
|
||||
if test x$webp_lib = x; then
|
||||
webp_lib=[`find_lib "libwebp.so.*"`]
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
else
|
||||
AC_MSG_WARN([*** Unable to find WEBP library (http://code.google.com/intl/en-US/speed/webp/index.html)])
|
||||
AC_MSG_WARN([WEBP Pimage loading disabled])
|
||||
fi
|
||||
fi
|
||||
|
||||
if test x$enable_bmp = xyes; then
|
||||
AC_DEFINE([LOAD_BMP])
|
||||
fi
|
||||
|
||||
if test x$enable_gif = xyes; then
|
||||
AC_DEFINE([LOAD_GIF])
|
||||
fi
|
||||
|
||||
if test x$enable_lbm = xyes; then
|
||||
AC_DEFINE([LOAD_LBM])
|
||||
fi
|
||||
|
||||
if test x$enable_pcx = xyes; then
|
||||
AC_DEFINE([LOAD_PCX])
|
||||
fi
|
||||
|
||||
if test x$enable_pnm = xyes; then
|
||||
AC_DEFINE([LOAD_PNM])
|
||||
fi
|
||||
|
||||
if test x$enable_tga = xyes; then
|
||||
AC_DEFINE([LOAD_TGA])
|
||||
fi
|
||||
|
||||
if test x$enable_xcf = xyes; then
|
||||
AC_DEFINE([LOAD_XCF])
|
||||
fi
|
||||
|
||||
if test x$enable_xpm = xyes; then
|
||||
AC_DEFINE([LOAD_XPM])
|
||||
fi
|
||||
|
||||
if test x$enable_xv = xyes; then
|
||||
AC_DEFINE([LOAD_XV])
|
||||
fi
|
||||
|
||||
if test x$enable_webp = xyes -a x$have_webp_hdr = xyes -a x$have_webp_lib = xyes; then
|
||||
if test x$enable_webp_shared = xyes && test x$webp_lib != x; then
|
||||
echo "-- dynamic libwebp -> $webp_lib"
|
||||
AC_DEFINE_UNQUOTED(LOAD_WEBP_DYNAMIC, "$webp_lib")
|
||||
else
|
||||
IMG_LIBS="-lwebp $IMG_LIBS"
|
||||
fi
|
||||
fi
|
||||
|
||||
if test x$enable_tif = xyes -a x$have_tif_hdr = xyes -a x$have_tif_lib = xyes; then
|
||||
if test x$enable_tif_shared = xyes && test x$tif_lib != x; then
|
||||
echo "-- dynamic libtiff -> $tif_lib"
|
||||
AC_DEFINE_UNQUOTED(LOAD_TIF_DYNAMIC, "$tif_lib")
|
||||
else
|
||||
if test x$have_libjpeg = xyes; then
|
||||
# Disable dynamic jpeg since we're linking it explicitly
|
||||
jpg_lib=''
|
||||
fi
|
||||
IMG_LIBS="-ltiff -lz $IMG_LIBS"
|
||||
fi
|
||||
fi
|
||||
if test x$enable_jpg = xyes -a x$have_jpg_hdr = xyes -a x$have_jpg_lib = xyes; then
|
||||
if test x$enable_jpg_shared = xyes && test x$jpg_lib != x; then
|
||||
echo "-- dynamic libjpeg -> $jpg_lib"
|
||||
AC_DEFINE_UNQUOTED(LOAD_JPG_DYNAMIC, "$jpg_lib")
|
||||
else
|
||||
IMG_LIBS="-ljpeg $IMG_LIBS"
|
||||
fi
|
||||
fi
|
||||
if test x$enable_png = xyes -a x$have_png_hdr = xyes -a x$have_png_lib = xyes; then
|
||||
if test x$enable_png_shared = xyes && test x$png_lib != x; then
|
||||
echo "-- dynamic libpng -> $png_lib"
|
||||
AC_DEFINE_UNQUOTED(LOAD_PNG_DYNAMIC, "$png_lib")
|
||||
else
|
||||
IMG_LIBS="-lpng -lz $IMG_LIBS"
|
||||
fi
|
||||
fi
|
||||
|
||||
LIBS="$saved_LIBS"
|
||||
|
||||
AC_SUBST([WINDRES])
|
||||
AC_SUBST([IMG_LIBS])
|
||||
|
||||
OBJCFLAGS=$CFLAGS
|
||||
|
||||
# Finally create all the generated files
|
||||
AC_OUTPUT([
|
||||
Makefile
|
||||
SDL2_image.spec
|
||||
SDL2_image.pc
|
||||
])
|
||||
@@ -0,0 +1,584 @@
|
||||
#! /bin/sh
|
||||
# depcomp - compile a program generating dependencies as side-effects
|
||||
|
||||
scriptversion=2006-10-15.18
|
||||
|
||||
# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006 Free Software
|
||||
# Foundation, Inc.
|
||||
|
||||
# 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., 51 Franklin Street, Fifth Floor, Boston, MA
|
||||
# 02110-1301, USA.
|
||||
|
||||
# As a special exception to the GNU General Public License, if you
|
||||
# distribute this file as part of a program that contains a
|
||||
# configuration script generated by Autoconf, you may include it under
|
||||
# the same distribution terms that you use for the rest of that program.
|
||||
|
||||
# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
|
||||
|
||||
case $1 in
|
||||
'')
|
||||
echo "$0: No command. Try \`$0 --help' for more information." 1>&2
|
||||
exit 1;
|
||||
;;
|
||||
-h | --h*)
|
||||
cat <<\EOF
|
||||
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
|
||||
|
||||
Run PROGRAMS ARGS to compile a file, generating dependencies
|
||||
as side-effects.
|
||||
|
||||
Environment variables:
|
||||
depmode Dependency tracking mode.
|
||||
source Source file read by `PROGRAMS ARGS'.
|
||||
object Object file output by `PROGRAMS ARGS'.
|
||||
DEPDIR directory where to store dependencies.
|
||||
depfile Dependency file to output.
|
||||
tmpdepfile Temporary file to use when outputing dependencies.
|
||||
libtool Whether libtool is used (yes/no).
|
||||
|
||||
Report bugs to <bug-automake@gnu.org>.
|
||||
EOF
|
||||
exit $?
|
||||
;;
|
||||
-v | --v*)
|
||||
echo "depcomp $scriptversion"
|
||||
exit $?
|
||||
;;
|
||||
esac
|
||||
|
||||
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
|
||||
echo "depcomp: Variables source, object and depmode must be set" 1>&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
|
||||
depfile=${depfile-`echo "$object" |
|
||||
sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
|
||||
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
|
||||
|
||||
rm -f "$tmpdepfile"
|
||||
|
||||
# Some modes work just like other modes, but use different flags. We
|
||||
# parameterize here, but still list the modes in the big case below,
|
||||
# to make depend.m4 easier to write. Note that we *cannot* use a case
|
||||
# here, because this file can only contain one case statement.
|
||||
if test "$depmode" = hp; then
|
||||
# HP compiler uses -M and no extra arg.
|
||||
gccflag=-M
|
||||
depmode=gcc
|
||||
fi
|
||||
|
||||
if test "$depmode" = dashXmstdout; then
|
||||
# This is just like dashmstdout with a different argument.
|
||||
dashmflag=-xM
|
||||
depmode=dashmstdout
|
||||
fi
|
||||
|
||||
case "$depmode" in
|
||||
gcc3)
|
||||
## gcc 3 implements dependency tracking that does exactly what
|
||||
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
|
||||
## it if -MD -MP comes after the -MF stuff. Hmm.
|
||||
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
|
||||
## the command line argument order; so add the flags where they
|
||||
## appear in depend2.am. Note that the slowdown incurred here
|
||||
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
|
||||
for arg
|
||||
do
|
||||
case $arg in
|
||||
-c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
|
||||
*) set fnord "$@" "$arg" ;;
|
||||
esac
|
||||
shift # fnord
|
||||
shift # $arg
|
||||
done
|
||||
"$@"
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile"
|
||||
exit $stat
|
||||
fi
|
||||
mv "$tmpdepfile" "$depfile"
|
||||
;;
|
||||
|
||||
gcc)
|
||||
## There are various ways to get dependency output from gcc. Here's
|
||||
## why we pick this rather obscure method:
|
||||
## - Don't want to use -MD because we'd like the dependencies to end
|
||||
## up in a subdir. Having to rename by hand is ugly.
|
||||
## (We might end up doing this anyway to support other compilers.)
|
||||
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
|
||||
## -MM, not -M (despite what the docs say).
|
||||
## - Using -M directly means running the compiler twice (even worse
|
||||
## than renaming).
|
||||
if test -z "$gccflag"; then
|
||||
gccflag=-MD,
|
||||
fi
|
||||
"$@" -Wp,"$gccflag$tmpdepfile"
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile"
|
||||
exit $stat
|
||||
fi
|
||||
rm -f "$depfile"
|
||||
echo "$object : \\" > "$depfile"
|
||||
alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
|
||||
## The second -e expression handles DOS-style file names with drive letters.
|
||||
sed -e 's/^[^:]*: / /' \
|
||||
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
|
||||
## This next piece of magic avoids the `deleted header file' problem.
|
||||
## The problem is that when a header file which appears in a .P file
|
||||
## is deleted, the dependency causes make to die (because there is
|
||||
## typically no way to rebuild the header). We avoid this by adding
|
||||
## dummy dependencies for each header file. Too bad gcc doesn't do
|
||||
## this for us directly.
|
||||
tr ' ' '
|
||||
' < "$tmpdepfile" |
|
||||
## Some versions of gcc put a space before the `:'. On the theory
|
||||
## that the space means something, we add a space to the output as
|
||||
## well.
|
||||
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||
## correctly. Breaking it into two sed invocations is a workaround.
|
||||
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
hp)
|
||||
# This case exists only to let depend.m4 do its work. It works by
|
||||
# looking at the text of this script. This case will never be run,
|
||||
# since it is checked for above.
|
||||
exit 1
|
||||
;;
|
||||
|
||||
sgi)
|
||||
if test "$libtool" = yes; then
|
||||
"$@" "-Wp,-MDupdate,$tmpdepfile"
|
||||
else
|
||||
"$@" -MDupdate "$tmpdepfile"
|
||||
fi
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile"
|
||||
exit $stat
|
||||
fi
|
||||
rm -f "$depfile"
|
||||
|
||||
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
|
||||
echo "$object : \\" > "$depfile"
|
||||
|
||||
# Clip off the initial element (the dependent). Don't try to be
|
||||
# clever and replace this with sed code, as IRIX sed won't handle
|
||||
# lines with more than a fixed number of characters (4096 in
|
||||
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
|
||||
# the IRIX cc adds comments like `#:fec' to the end of the
|
||||
# dependency line.
|
||||
tr ' ' '
|
||||
' < "$tmpdepfile" \
|
||||
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
|
||||
tr '
|
||||
' ' ' >> $depfile
|
||||
echo >> $depfile
|
||||
|
||||
# The second pass generates a dummy entry for each header file.
|
||||
tr ' ' '
|
||||
' < "$tmpdepfile" \
|
||||
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
|
||||
>> $depfile
|
||||
else
|
||||
# The sourcefile does not contain any dependencies, so just
|
||||
# store a dummy comment line, to avoid errors with the Makefile
|
||||
# "include basename.Plo" scheme.
|
||||
echo "#dummy" > "$depfile"
|
||||
fi
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
aix)
|
||||
# The C for AIX Compiler uses -M and outputs the dependencies
|
||||
# in a .u file. In older versions, this file always lives in the
|
||||
# current directory. Also, the AIX compiler puts `$object:' at the
|
||||
# start of each line; $object doesn't have directory information.
|
||||
# Version 6 uses the directory in both cases.
|
||||
stripped=`echo "$object" | sed 's/\(.*\)\..*$/\1/'`
|
||||
tmpdepfile="$stripped.u"
|
||||
if test "$libtool" = yes; then
|
||||
"$@" -Wc,-M
|
||||
else
|
||||
"$@" -M
|
||||
fi
|
||||
stat=$?
|
||||
|
||||
if test -f "$tmpdepfile"; then :
|
||||
else
|
||||
stripped=`echo "$stripped" | sed 's,^.*/,,'`
|
||||
tmpdepfile="$stripped.u"
|
||||
fi
|
||||
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile"
|
||||
exit $stat
|
||||
fi
|
||||
|
||||
if test -f "$tmpdepfile"; then
|
||||
outname="$stripped.o"
|
||||
# Each line is of the form `foo.o: dependent.h'.
|
||||
# Do two passes, one to just change these to
|
||||
# `$object: dependent.h' and one to simply `dependent.h:'.
|
||||
sed -e "s,^$outname:,$object :," < "$tmpdepfile" > "$depfile"
|
||||
sed -e "s,^$outname: \(.*\)$,\1:," < "$tmpdepfile" >> "$depfile"
|
||||
else
|
||||
# The sourcefile does not contain any dependencies, so just
|
||||
# store a dummy comment line, to avoid errors with the Makefile
|
||||
# "include basename.Plo" scheme.
|
||||
echo "#dummy" > "$depfile"
|
||||
fi
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
icc)
|
||||
# Intel's C compiler understands `-MD -MF file'. However on
|
||||
# icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
|
||||
# ICC 7.0 will fill foo.d with something like
|
||||
# foo.o: sub/foo.c
|
||||
# foo.o: sub/foo.h
|
||||
# which is wrong. We want:
|
||||
# sub/foo.o: sub/foo.c
|
||||
# sub/foo.o: sub/foo.h
|
||||
# sub/foo.c:
|
||||
# sub/foo.h:
|
||||
# ICC 7.1 will output
|
||||
# foo.o: sub/foo.c sub/foo.h
|
||||
# and will wrap long lines using \ :
|
||||
# foo.o: sub/foo.c ... \
|
||||
# sub/foo.h ... \
|
||||
# ...
|
||||
|
||||
"$@" -MD -MF "$tmpdepfile"
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile"
|
||||
exit $stat
|
||||
fi
|
||||
rm -f "$depfile"
|
||||
# Each line is of the form `foo.o: dependent.h',
|
||||
# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
|
||||
# Do two passes, one to just change these to
|
||||
# `$object: dependent.h' and one to simply `dependent.h:'.
|
||||
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
|
||||
# Some versions of the HPUX 10.20 sed can't process this invocation
|
||||
# correctly. Breaking it into two sed invocations is a workaround.
|
||||
sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
|
||||
sed -e 's/$/ :/' >> "$depfile"
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
hp2)
|
||||
# The "hp" stanza above does not work with aCC (C++) and HP's ia64
|
||||
# compilers, which have integrated preprocessors. The correct option
|
||||
# to use with these is +Maked; it writes dependencies to a file named
|
||||
# 'foo.d', which lands next to the object file, wherever that
|
||||
# happens to be.
|
||||
# Much of this is similar to the tru64 case; see comments there.
|
||||
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
|
||||
test "x$dir" = "x$object" && dir=
|
||||
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
|
||||
if test "$libtool" = yes; then
|
||||
tmpdepfile1=$dir$base.d
|
||||
tmpdepfile2=$dir.libs/$base.d
|
||||
"$@" -Wc,+Maked
|
||||
else
|
||||
tmpdepfile1=$dir$base.d
|
||||
tmpdepfile2=$dir$base.d
|
||||
"$@" +Maked
|
||||
fi
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile1" "$tmpdepfile2"
|
||||
exit $stat
|
||||
fi
|
||||
|
||||
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
|
||||
do
|
||||
test -f "$tmpdepfile" && break
|
||||
done
|
||||
if test -f "$tmpdepfile"; then
|
||||
sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
|
||||
# Add `dependent.h:' lines.
|
||||
sed -ne '2,${; s/^ *//; s/ \\*$//; s/$/:/; p;}' "$tmpdepfile" >> "$depfile"
|
||||
else
|
||||
echo "#dummy" > "$depfile"
|
||||
fi
|
||||
rm -f "$tmpdepfile" "$tmpdepfile2"
|
||||
;;
|
||||
|
||||
tru64)
|
||||
# The Tru64 compiler uses -MD to generate dependencies as a side
|
||||
# effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
|
||||
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
|
||||
# dependencies in `foo.d' instead, so we check for that too.
|
||||
# Subdirectories are respected.
|
||||
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
|
||||
test "x$dir" = "x$object" && dir=
|
||||
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
|
||||
|
||||
if test "$libtool" = yes; then
|
||||
# With Tru64 cc, shared objects can also be used to make a
|
||||
# static library. This mechanism is used in libtool 1.4 series to
|
||||
# handle both shared and static libraries in a single compilation.
|
||||
# With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
|
||||
#
|
||||
# With libtool 1.5 this exception was removed, and libtool now
|
||||
# generates 2 separate objects for the 2 libraries. These two
|
||||
# compilations output dependencies in $dir.libs/$base.o.d and
|
||||
# in $dir$base.o.d. We have to check for both files, because
|
||||
# one of the two compilations can be disabled. We should prefer
|
||||
# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
|
||||
# automatically cleaned when .libs/ is deleted, while ignoring
|
||||
# the former would cause a distcleancheck panic.
|
||||
tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
|
||||
tmpdepfile2=$dir$base.o.d # libtool 1.5
|
||||
tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
|
||||
tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
|
||||
"$@" -Wc,-MD
|
||||
else
|
||||
tmpdepfile1=$dir$base.o.d
|
||||
tmpdepfile2=$dir$base.d
|
||||
tmpdepfile3=$dir$base.d
|
||||
tmpdepfile4=$dir$base.d
|
||||
"$@" -MD
|
||||
fi
|
||||
|
||||
stat=$?
|
||||
if test $stat -eq 0; then :
|
||||
else
|
||||
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
|
||||
exit $stat
|
||||
fi
|
||||
|
||||
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
|
||||
do
|
||||
test -f "$tmpdepfile" && break
|
||||
done
|
||||
if test -f "$tmpdepfile"; then
|
||||
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
|
||||
# That's a tab and a space in the [].
|
||||
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
|
||||
else
|
||||
echo "#dummy" > "$depfile"
|
||||
fi
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
#nosideeffect)
|
||||
# This comment above is used by automake to tell side-effect
|
||||
# dependency tracking mechanisms from slower ones.
|
||||
|
||||
dashmstdout)
|
||||
# Important note: in order to support this mode, a compiler *must*
|
||||
# always write the preprocessed file to stdout, regardless of -o.
|
||||
"$@" || exit $?
|
||||
|
||||
# Remove the call to Libtool.
|
||||
if test "$libtool" = yes; then
|
||||
while test $1 != '--mode=compile'; do
|
||||
shift
|
||||
done
|
||||
shift
|
||||
fi
|
||||
|
||||
# Remove `-o $object'.
|
||||
IFS=" "
|
||||
for arg
|
||||
do
|
||||
case $arg in
|
||||
-o)
|
||||
shift
|
||||
;;
|
||||
$object)
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
set fnord "$@" "$arg"
|
||||
shift # fnord
|
||||
shift # $arg
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
test -z "$dashmflag" && dashmflag=-M
|
||||
# Require at least two characters before searching for `:'
|
||||
# in the target name. This is to cope with DOS-style filenames:
|
||||
# a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
|
||||
"$@" $dashmflag |
|
||||
sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
|
||||
rm -f "$depfile"
|
||||
cat < "$tmpdepfile" > "$depfile"
|
||||
tr ' ' '
|
||||
' < "$tmpdepfile" | \
|
||||
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||
## correctly. Breaking it into two sed invocations is a workaround.
|
||||
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
dashXmstdout)
|
||||
# This case only exists to satisfy depend.m4. It is never actually
|
||||
# run, as this mode is specially recognized in the preamble.
|
||||
exit 1
|
||||
;;
|
||||
|
||||
makedepend)
|
||||
"$@" || exit $?
|
||||
# Remove any Libtool call
|
||||
if test "$libtool" = yes; then
|
||||
while test $1 != '--mode=compile'; do
|
||||
shift
|
||||
done
|
||||
shift
|
||||
fi
|
||||
# X makedepend
|
||||
shift
|
||||
cleared=no
|
||||
for arg in "$@"; do
|
||||
case $cleared in
|
||||
no)
|
||||
set ""; shift
|
||||
cleared=yes ;;
|
||||
esac
|
||||
case "$arg" in
|
||||
-D*|-I*)
|
||||
set fnord "$@" "$arg"; shift ;;
|
||||
# Strip any option that makedepend may not understand. Remove
|
||||
# the object too, otherwise makedepend will parse it as a source file.
|
||||
-*|$object)
|
||||
;;
|
||||
*)
|
||||
set fnord "$@" "$arg"; shift ;;
|
||||
esac
|
||||
done
|
||||
obj_suffix="`echo $object | sed 's/^.*\././'`"
|
||||
touch "$tmpdepfile"
|
||||
${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
|
||||
rm -f "$depfile"
|
||||
cat < "$tmpdepfile" > "$depfile"
|
||||
sed '1,2d' "$tmpdepfile" | tr ' ' '
|
||||
' | \
|
||||
## Some versions of the HPUX 10.20 sed can't process this invocation
|
||||
## correctly. Breaking it into two sed invocations is a workaround.
|
||||
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
|
||||
rm -f "$tmpdepfile" "$tmpdepfile".bak
|
||||
;;
|
||||
|
||||
cpp)
|
||||
# Important note: in order to support this mode, a compiler *must*
|
||||
# always write the preprocessed file to stdout.
|
||||
"$@" || exit $?
|
||||
|
||||
# Remove the call to Libtool.
|
||||
if test "$libtool" = yes; then
|
||||
while test $1 != '--mode=compile'; do
|
||||
shift
|
||||
done
|
||||
shift
|
||||
fi
|
||||
|
||||
# Remove `-o $object'.
|
||||
IFS=" "
|
||||
for arg
|
||||
do
|
||||
case $arg in
|
||||
-o)
|
||||
shift
|
||||
;;
|
||||
$object)
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
set fnord "$@" "$arg"
|
||||
shift # fnord
|
||||
shift # $arg
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
"$@" -E |
|
||||
sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
|
||||
-e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
|
||||
sed '$ s: \\$::' > "$tmpdepfile"
|
||||
rm -f "$depfile"
|
||||
echo "$object : \\" > "$depfile"
|
||||
cat < "$tmpdepfile" >> "$depfile"
|
||||
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
msvisualcpp)
|
||||
# Important note: in order to support this mode, a compiler *must*
|
||||
# always write the preprocessed file to stdout, regardless of -o,
|
||||
# because we must use -o when running libtool.
|
||||
"$@" || exit $?
|
||||
IFS=" "
|
||||
for arg
|
||||
do
|
||||
case "$arg" in
|
||||
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
|
||||
set fnord "$@"
|
||||
shift
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
set fnord "$@" "$arg"
|
||||
shift
|
||||
shift
|
||||
;;
|
||||
esac
|
||||
done
|
||||
"$@" -E |
|
||||
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::echo "`cygpath -u \\"\1\\"`":p' | sort | uniq > "$tmpdepfile"
|
||||
rm -f "$depfile"
|
||||
echo "$object : \\" > "$depfile"
|
||||
. "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
|
||||
echo " " >> "$depfile"
|
||||
. "$tmpdepfile" | sed 's% %\\ %g' | sed -n '/^\(.*\)$/ s::\1\::p' >> "$depfile"
|
||||
rm -f "$tmpdepfile"
|
||||
;;
|
||||
|
||||
none)
|
||||
exec "$@"
|
||||
;;
|
||||
|
||||
*)
|
||||
echo "Unknown depmode $depmode" 1>&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
exit 0
|
||||
|
||||
# Local Variables:
|
||||
# mode: shell-script
|
||||
# sh-indentation: 2
|
||||
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||
# time-stamp-start: "scriptversion="
|
||||
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||
# time-stamp-end: "$"
|
||||
# End:
|
||||
@@ -0,0 +1,103 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# Build Universal binaries on Mac OS X, thanks Ryan!
|
||||
#
|
||||
# Usage: ./configure CC="sh gcc-fat.sh" && make && rm -rf x86 x64
|
||||
|
||||
DEVELOPER="`xcode-select -print-path`/Platforms/MacOSX.platform/Developer"
|
||||
|
||||
# Intel 32-bit compiler flags (10.6 runtime compatibility)
|
||||
GCC_COMPILE_X86="gcc -arch i386 -mmacosx-version-min=10.6 \
|
||||
-DMAC_OS_X_VERSION_MIN_REQUIRED=1040 \
|
||||
-I/usr/local/include"
|
||||
|
||||
GCC_LINK_X86="-mmacosx-version-min=10.6"
|
||||
|
||||
# Intel 64-bit compiler flags (10.6 runtime compatibility)
|
||||
GCC_COMPILE_X64="gcc -arch x86_64 -mmacosx-version-min=10.6 \
|
||||
-DMAC_OS_X_VERSION_MIN_REQUIRED=1050 \
|
||||
-I/usr/local/include"
|
||||
|
||||
GCC_LINK_X64="-mmacosx-version-min=10.6"
|
||||
|
||||
# Output both PowerPC and Intel object files
|
||||
args="$*"
|
||||
compile=yes
|
||||
link=yes
|
||||
while test x$1 != x; do
|
||||
case $1 in
|
||||
--version) exec gcc $1;;
|
||||
-v) exec gcc $1;;
|
||||
-V) exec gcc $1;;
|
||||
-print-prog-name=*) exec gcc $1;;
|
||||
-print-search-dirs) exec gcc $1;;
|
||||
-E) GCC_COMPILE_X86="$GCC_COMPILE_X86 -E"
|
||||
GCC_COMPILE_X64="$GCC_COMPILE_X64 -E"
|
||||
compile=no; link=no;;
|
||||
-c) link=no;;
|
||||
-o) output=$2;;
|
||||
*.c|*.cc|*.cpp|*.S) source=$1;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
if test x$link = xyes; then
|
||||
GCC_COMPILE_X86="$GCC_COMPILE_X86 $GCC_LINK_X86"
|
||||
GCC_COMPILE_X64="$GCC_COMPILE_X64 $GCC_LINK_X64"
|
||||
fi
|
||||
if test x"$output" = x; then
|
||||
if test x$link = xyes; then
|
||||
output=a.out
|
||||
elif test x$compile = xyes; then
|
||||
output=`echo $source | sed -e 's|.*/||' -e 's|\(.*\)\.[^\.]*|\1|'`.o
|
||||
fi
|
||||
fi
|
||||
|
||||
# Compile X86 32-bit
|
||||
if test x"$output" != x; then
|
||||
dir=x86/`dirname $output`
|
||||
if test -d $dir; then
|
||||
:
|
||||
else
|
||||
mkdir -p $dir
|
||||
fi
|
||||
fi
|
||||
set -- $args
|
||||
while test x$1 != x; do
|
||||
if test -f "x86/$1" && test "$1" != "$output"; then
|
||||
x86_args="$x86_args x86/$1"
|
||||
else
|
||||
x86_args="$x86_args $1"
|
||||
fi
|
||||
shift
|
||||
done
|
||||
$GCC_COMPILE_X86 $x86_args || exit $?
|
||||
if test x"$output" != x; then
|
||||
cp $output x86/$output
|
||||
fi
|
||||
|
||||
# Compile X86 32-bit
|
||||
if test x"$output" != x; then
|
||||
dir=x64/`dirname $output`
|
||||
if test -d $dir; then
|
||||
:
|
||||
else
|
||||
mkdir -p $dir
|
||||
fi
|
||||
fi
|
||||
set -- $args
|
||||
while test x$1 != x; do
|
||||
if test -f "x64/$1" && test "$1" != "$output"; then
|
||||
x64_args="$x64_args x64/$1"
|
||||
else
|
||||
x64_args="$x64_args $1"
|
||||
fi
|
||||
shift
|
||||
done
|
||||
$GCC_COMPILE_X64 $x64_args || exit $?
|
||||
if test x"$output" != x; then
|
||||
cp $output x64/$output
|
||||
fi
|
||||
|
||||
if test x"$output" != x; then
|
||||
lipo -create -o $output x86/$output x64/$output
|
||||
fi
|
||||
@@ -0,0 +1,507 @@
|
||||
#!/bin/sh
|
||||
# install - install a program, script, or datafile
|
||||
|
||||
scriptversion=2006-10-14.15
|
||||
|
||||
# This originates from X11R5 (mit/util/scripts/install.sh), which was
|
||||
# later released in X11R6 (xc/config/util/install.sh) with the
|
||||
# following copyright and license.
|
||||
#
|
||||
# Copyright (C) 1994 X Consortium
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to
|
||||
# deal in the Software without restriction, including without limitation the
|
||||
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
# sell copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
|
||||
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
# Except as contained in this notice, the name of the X Consortium shall not
|
||||
# be used in advertising or otherwise to promote the sale, use or other deal-
|
||||
# ings in this Software without prior written authorization from the X Consor-
|
||||
# tium.
|
||||
#
|
||||
#
|
||||
# FSF changes to this file are in the public domain.
|
||||
#
|
||||
# Calling this script install-sh is preferred over install.sh, to prevent
|
||||
# `make' implicit rules from creating a file called install from it
|
||||
# when there is no Makefile.
|
||||
#
|
||||
# This script is compatible with the BSD install script, but was written
|
||||
# from scratch.
|
||||
|
||||
nl='
|
||||
'
|
||||
IFS=" "" $nl"
|
||||
|
||||
# set DOITPROG to echo to test this script
|
||||
|
||||
# Don't use :- since 4.3BSD and earlier shells don't like it.
|
||||
doit="${DOITPROG-}"
|
||||
if test -z "$doit"; then
|
||||
doit_exec=exec
|
||||
else
|
||||
doit_exec=$doit
|
||||
fi
|
||||
|
||||
# Put in absolute file names if you don't have them in your path;
|
||||
# or use environment vars.
|
||||
|
||||
mvprog="${MVPROG-mv}"
|
||||
cpprog="${CPPROG-cp}"
|
||||
chmodprog="${CHMODPROG-chmod}"
|
||||
chownprog="${CHOWNPROG-chown}"
|
||||
chgrpprog="${CHGRPPROG-chgrp}"
|
||||
stripprog="${STRIPPROG-strip}"
|
||||
rmprog="${RMPROG-rm}"
|
||||
mkdirprog="${MKDIRPROG-mkdir}"
|
||||
|
||||
posix_glob=
|
||||
posix_mkdir=
|
||||
|
||||
# Desired mode of installed file.
|
||||
mode=0755
|
||||
|
||||
chmodcmd=$chmodprog
|
||||
chowncmd=
|
||||
chgrpcmd=
|
||||
stripcmd=
|
||||
rmcmd="$rmprog -f"
|
||||
mvcmd="$mvprog"
|
||||
src=
|
||||
dst=
|
||||
dir_arg=
|
||||
dstarg=
|
||||
no_target_directory=
|
||||
|
||||
usage="Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
|
||||
or: $0 [OPTION]... SRCFILES... DIRECTORY
|
||||
or: $0 [OPTION]... -t DIRECTORY SRCFILES...
|
||||
or: $0 [OPTION]... -d DIRECTORIES...
|
||||
|
||||
In the 1st form, copy SRCFILE to DSTFILE.
|
||||
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
|
||||
In the 4th, create DIRECTORIES.
|
||||
|
||||
Options:
|
||||
-c (ignored)
|
||||
-d create directories instead of installing files.
|
||||
-g GROUP $chgrpprog installed files to GROUP.
|
||||
-m MODE $chmodprog installed files to MODE.
|
||||
-o USER $chownprog installed files to USER.
|
||||
-s $stripprog installed files.
|
||||
-t DIRECTORY install into DIRECTORY.
|
||||
-T report an error if DSTFILE is a directory.
|
||||
--help display this help and exit.
|
||||
--version display version info and exit.
|
||||
|
||||
Environment variables override the default commands:
|
||||
CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG
|
||||
"
|
||||
|
||||
while test $# -ne 0; do
|
||||
case $1 in
|
||||
-c) shift
|
||||
continue;;
|
||||
|
||||
-d) dir_arg=true
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-g) chgrpcmd="$chgrpprog $2"
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
--help) echo "$usage"; exit $?;;
|
||||
|
||||
-m) mode=$2
|
||||
shift
|
||||
shift
|
||||
case $mode in
|
||||
*' '* | *' '* | *'
|
||||
'* | *'*'* | *'?'* | *'['*)
|
||||
echo "$0: invalid mode: $mode" >&2
|
||||
exit 1;;
|
||||
esac
|
||||
continue;;
|
||||
|
||||
-o) chowncmd="$chownprog $2"
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-s) stripcmd=$stripprog
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-t) dstarg=$2
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-T) no_target_directory=true
|
||||
shift
|
||||
continue;;
|
||||
|
||||
--version) echo "$0 $scriptversion"; exit $?;;
|
||||
|
||||
--) shift
|
||||
break;;
|
||||
|
||||
-*) echo "$0: invalid option: $1" >&2
|
||||
exit 1;;
|
||||
|
||||
*) break;;
|
||||
esac
|
||||
done
|
||||
|
||||
if test $# -ne 0 && test -z "$dir_arg$dstarg"; then
|
||||
# When -d is used, all remaining arguments are directories to create.
|
||||
# When -t is used, the destination is already specified.
|
||||
# Otherwise, the last argument is the destination. Remove it from $@.
|
||||
for arg
|
||||
do
|
||||
if test -n "$dstarg"; then
|
||||
# $@ is not empty: it contains at least $arg.
|
||||
set fnord "$@" "$dstarg"
|
||||
shift # fnord
|
||||
fi
|
||||
shift # arg
|
||||
dstarg=$arg
|
||||
done
|
||||
fi
|
||||
|
||||
if test $# -eq 0; then
|
||||
if test -z "$dir_arg"; then
|
||||
echo "$0: no input file specified." >&2
|
||||
exit 1
|
||||
fi
|
||||
# It's OK to call `install-sh -d' without argument.
|
||||
# This can happen when creating conditional directories.
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if test -z "$dir_arg"; then
|
||||
trap '(exit $?); exit' 1 2 13 15
|
||||
|
||||
# Set umask so as not to create temps with too-generous modes.
|
||||
# However, 'strip' requires both read and write access to temps.
|
||||
case $mode in
|
||||
# Optimize common cases.
|
||||
*644) cp_umask=133;;
|
||||
*755) cp_umask=22;;
|
||||
|
||||
*[0-7])
|
||||
if test -z "$stripcmd"; then
|
||||
u_plus_rw=
|
||||
else
|
||||
u_plus_rw='% 200'
|
||||
fi
|
||||
cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
|
||||
*)
|
||||
if test -z "$stripcmd"; then
|
||||
u_plus_rw=
|
||||
else
|
||||
u_plus_rw=,u+rw
|
||||
fi
|
||||
cp_umask=$mode$u_plus_rw;;
|
||||
esac
|
||||
fi
|
||||
|
||||
for src
|
||||
do
|
||||
# Protect names starting with `-'.
|
||||
case $src in
|
||||
-*) src=./$src ;;
|
||||
esac
|
||||
|
||||
if test -n "$dir_arg"; then
|
||||
dst=$src
|
||||
dstdir=$dst
|
||||
test -d "$dstdir"
|
||||
dstdir_status=$?
|
||||
else
|
||||
|
||||
# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
|
||||
# might cause directories to be created, which would be especially bad
|
||||
# if $src (and thus $dsttmp) contains '*'.
|
||||
if test ! -f "$src" && test ! -d "$src"; then
|
||||
echo "$0: $src does not exist." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if test -z "$dstarg"; then
|
||||
echo "$0: no destination specified." >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
dst=$dstarg
|
||||
# Protect names starting with `-'.
|
||||
case $dst in
|
||||
-*) dst=./$dst ;;
|
||||
esac
|
||||
|
||||
# If destination is a directory, append the input filename; won't work
|
||||
# if double slashes aren't ignored.
|
||||
if test -d "$dst"; then
|
||||
if test -n "$no_target_directory"; then
|
||||
echo "$0: $dstarg: Is a directory" >&2
|
||||
exit 1
|
||||
fi
|
||||
dstdir=$dst
|
||||
dst=$dstdir/`basename "$src"`
|
||||
dstdir_status=0
|
||||
else
|
||||
# Prefer dirname, but fall back on a substitute if dirname fails.
|
||||
dstdir=`
|
||||
(dirname "$dst") 2>/dev/null ||
|
||||
expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
|
||||
X"$dst" : 'X\(//\)[^/]' \| \
|
||||
X"$dst" : 'X\(//\)$' \| \
|
||||
X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
|
||||
echo X"$dst" |
|
||||
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
|
||||
s//\1/
|
||||
q
|
||||
}
|
||||
/^X\(\/\/\)[^/].*/{
|
||||
s//\1/
|
||||
q
|
||||
}
|
||||
/^X\(\/\/\)$/{
|
||||
s//\1/
|
||||
q
|
||||
}
|
||||
/^X\(\/\).*/{
|
||||
s//\1/
|
||||
q
|
||||
}
|
||||
s/.*/./; q'
|
||||
`
|
||||
|
||||
test -d "$dstdir"
|
||||
dstdir_status=$?
|
||||
fi
|
||||
fi
|
||||
|
||||
obsolete_mkdir_used=false
|
||||
|
||||
if test $dstdir_status != 0; then
|
||||
case $posix_mkdir in
|
||||
'')
|
||||
# Create intermediate dirs using mode 755 as modified by the umask.
|
||||
# This is like FreeBSD 'install' as of 1997-10-28.
|
||||
umask=`umask`
|
||||
case $stripcmd.$umask in
|
||||
# Optimize common cases.
|
||||
*[2367][2367]) mkdir_umask=$umask;;
|
||||
.*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
|
||||
|
||||
*[0-7])
|
||||
mkdir_umask=`expr $umask + 22 \
|
||||
- $umask % 100 % 40 + $umask % 20 \
|
||||
- $umask % 10 % 4 + $umask % 2
|
||||
`;;
|
||||
*) mkdir_umask=$umask,go-w;;
|
||||
esac
|
||||
|
||||
# With -d, create the new directory with the user-specified mode.
|
||||
# Otherwise, rely on $mkdir_umask.
|
||||
if test -n "$dir_arg"; then
|
||||
mkdir_mode=-m$mode
|
||||
else
|
||||
mkdir_mode=
|
||||
fi
|
||||
|
||||
posix_mkdir=false
|
||||
case $umask in
|
||||
*[123567][0-7][0-7])
|
||||
# POSIX mkdir -p sets u+wx bits regardless of umask, which
|
||||
# is incompatible with FreeBSD 'install' when (umask & 300) != 0.
|
||||
;;
|
||||
*)
|
||||
tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
|
||||
trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
|
||||
|
||||
if (umask $mkdir_umask &&
|
||||
exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
|
||||
then
|
||||
if test -z "$dir_arg" || {
|
||||
# Check for POSIX incompatibilities with -m.
|
||||
# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
|
||||
# other-writeable bit of parent directory when it shouldn't.
|
||||
# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
|
||||
ls_ld_tmpdir=`ls -ld "$tmpdir"`
|
||||
case $ls_ld_tmpdir in
|
||||
d????-?r-*) different_mode=700;;
|
||||
d????-?--*) different_mode=755;;
|
||||
*) false;;
|
||||
esac &&
|
||||
$mkdirprog -m$different_mode -p -- "$tmpdir" && {
|
||||
ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
|
||||
test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
|
||||
}
|
||||
}
|
||||
then posix_mkdir=:
|
||||
fi
|
||||
rmdir "$tmpdir/d" "$tmpdir"
|
||||
else
|
||||
# Remove any dirs left behind by ancient mkdir implementations.
|
||||
rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
|
||||
fi
|
||||
trap '' 0;;
|
||||
esac;;
|
||||
esac
|
||||
|
||||
if
|
||||
$posix_mkdir && (
|
||||
umask $mkdir_umask &&
|
||||
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
|
||||
)
|
||||
then :
|
||||
else
|
||||
|
||||
# The umask is ridiculous, or mkdir does not conform to POSIX,
|
||||
# or it failed possibly due to a race condition. Create the
|
||||
# directory the slow way, step by step, checking for races as we go.
|
||||
|
||||
case $dstdir in
|
||||
/*) prefix=/ ;;
|
||||
-*) prefix=./ ;;
|
||||
*) prefix= ;;
|
||||
esac
|
||||
|
||||
case $posix_glob in
|
||||
'')
|
||||
if (set -f) 2>/dev/null; then
|
||||
posix_glob=true
|
||||
else
|
||||
posix_glob=false
|
||||
fi ;;
|
||||
esac
|
||||
|
||||
oIFS=$IFS
|
||||
IFS=/
|
||||
$posix_glob && set -f
|
||||
set fnord $dstdir
|
||||
shift
|
||||
$posix_glob && set +f
|
||||
IFS=$oIFS
|
||||
|
||||
prefixes=
|
||||
|
||||
for d
|
||||
do
|
||||
test -z "$d" && continue
|
||||
|
||||
prefix=$prefix$d
|
||||
if test -d "$prefix"; then
|
||||
prefixes=
|
||||
else
|
||||
if $posix_mkdir; then
|
||||
(umask=$mkdir_umask &&
|
||||
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
|
||||
# Don't fail if two instances are running concurrently.
|
||||
test -d "$prefix" || exit 1
|
||||
else
|
||||
case $prefix in
|
||||
*\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
|
||||
*) qprefix=$prefix;;
|
||||
esac
|
||||
prefixes="$prefixes '$qprefix'"
|
||||
fi
|
||||
fi
|
||||
prefix=$prefix/
|
||||
done
|
||||
|
||||
if test -n "$prefixes"; then
|
||||
# Don't fail if two instances are running concurrently.
|
||||
(umask $mkdir_umask &&
|
||||
eval "\$doit_exec \$mkdirprog $prefixes") ||
|
||||
test -d "$dstdir" || exit 1
|
||||
obsolete_mkdir_used=true
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
if test -n "$dir_arg"; then
|
||||
{ test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
|
||||
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
|
||||
{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
|
||||
test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
|
||||
else
|
||||
|
||||
# Make a couple of temp file names in the proper directory.
|
||||
dsttmp=$dstdir/_inst.$$_
|
||||
rmtmp=$dstdir/_rm.$$_
|
||||
|
||||
# Trap to clean up those temp files at exit.
|
||||
trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
|
||||
|
||||
# Copy the file name to the temp name.
|
||||
(umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
|
||||
|
||||
# and set any options; do chmod last to preserve setuid bits.
|
||||
#
|
||||
# If any of these fail, we abort the whole thing. If we want to
|
||||
# ignore errors from any of these, just make sure not to ignore
|
||||
# errors from the above "$doit $cpprog $src $dsttmp" command.
|
||||
#
|
||||
{ test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \
|
||||
&& { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \
|
||||
&& { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \
|
||||
&& { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
|
||||
|
||||
# Now rename the file to the real destination.
|
||||
{ $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null \
|
||||
|| {
|
||||
# The rename failed, perhaps because mv can't rename something else
|
||||
# to itself, or perhaps because mv is so ancient that it does not
|
||||
# support -f.
|
||||
|
||||
# Now remove or move aside any old file at destination location.
|
||||
# We try this two ways since rm can't unlink itself on some
|
||||
# systems and the destination file might be busy for other
|
||||
# reasons. In this case, the final cleanup might fail but the new
|
||||
# file should still install successfully.
|
||||
{
|
||||
if test -f "$dst"; then
|
||||
$doit $rmcmd -f "$dst" 2>/dev/null \
|
||||
|| { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null \
|
||||
&& { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }; }\
|
||||
|| {
|
||||
echo "$0: cannot unlink or rename $dst" >&2
|
||||
(exit 1); exit 1
|
||||
}
|
||||
else
|
||||
:
|
||||
fi
|
||||
} &&
|
||||
|
||||
# Now rename the file to the real destination.
|
||||
$doit $mvcmd "$dsttmp" "$dst"
|
||||
}
|
||||
} || exit 1
|
||||
|
||||
trap '' 0
|
||||
fi
|
||||
done
|
||||
|
||||
# Local variables:
|
||||
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||
# time-stamp-start: "scriptversion="
|
||||
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||
# time-stamp-end: "$"
|
||||
# End:
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,215 @@
|
||||
#! /bin/sh
|
||||
# Common wrapper for a few potentially missing GNU programs.
|
||||
|
||||
scriptversion=2012-06-26.16; # UTC
|
||||
|
||||
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
|
||||
# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
|
||||
|
||||
# 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
# As a special exception to the GNU General Public License, if you
|
||||
# distribute this file as part of a program that contains a
|
||||
# configuration script generated by Autoconf, you may include it under
|
||||
# the same distribution terms that you use for the rest of that program.
|
||||
|
||||
if test $# -eq 0; then
|
||||
echo 1>&2 "Try '$0 --help' for more information"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
case $1 in
|
||||
|
||||
--is-lightweight)
|
||||
# Used by our autoconf macros to check whether the available missing
|
||||
# script is modern enough.
|
||||
exit 0
|
||||
;;
|
||||
|
||||
--run)
|
||||
# Back-compat with the calling convention used by older automake.
|
||||
shift
|
||||
;;
|
||||
|
||||
-h|--h|--he|--hel|--help)
|
||||
echo "\
|
||||
$0 [OPTION]... PROGRAM [ARGUMENT]...
|
||||
|
||||
Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
|
||||
to PROGRAM being missing or too old.
|
||||
|
||||
Options:
|
||||
-h, --help display this help and exit
|
||||
-v, --version output version information and exit
|
||||
|
||||
Supported PROGRAM values:
|
||||
aclocal autoconf autoheader autom4te automake makeinfo
|
||||
bison yacc flex lex help2man
|
||||
|
||||
Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
|
||||
'g' are ignored when checking the name.
|
||||
|
||||
Send bug reports to <bug-automake@gnu.org>."
|
||||
exit $?
|
||||
;;
|
||||
|
||||
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
|
||||
echo "missing $scriptversion (GNU Automake)"
|
||||
exit $?
|
||||
;;
|
||||
|
||||
-*)
|
||||
echo 1>&2 "$0: unknown '$1' option"
|
||||
echo 1>&2 "Try '$0 --help' for more information"
|
||||
exit 1
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
# Run the given program, remember its exit status.
|
||||
"$@"; st=$?
|
||||
|
||||
# If it succeeded, we are done.
|
||||
test $st -eq 0 && exit 0
|
||||
|
||||
# Also exit now if we it failed (or wasn't found), and '--version' was
|
||||
# passed; such an option is passed most likely to detect whether the
|
||||
# program is present and works.
|
||||
case $2 in --version|--help) exit $st;; esac
|
||||
|
||||
# Exit code 63 means version mismatch. This often happens when the user
|
||||
# tries to use an ancient version of a tool on a file that requires a
|
||||
# minimum version.
|
||||
if test $st -eq 63; then
|
||||
msg="probably too old"
|
||||
elif test $st -eq 127; then
|
||||
# Program was missing.
|
||||
msg="missing on your system"
|
||||
else
|
||||
# Program was found and executed, but failed. Give up.
|
||||
exit $st
|
||||
fi
|
||||
|
||||
perl_URL=http://www.perl.org/
|
||||
flex_URL=http://flex.sourceforge.net/
|
||||
gnu_software_URL=http://www.gnu.org/software
|
||||
|
||||
program_details ()
|
||||
{
|
||||
case $1 in
|
||||
aclocal|automake)
|
||||
echo "The '$1' program is part of the GNU Automake package:"
|
||||
echo "<$gnu_software_URL/automake>"
|
||||
echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
|
||||
echo "<$gnu_software_URL/autoconf>"
|
||||
echo "<$gnu_software_URL/m4/>"
|
||||
echo "<$perl_URL>"
|
||||
;;
|
||||
autoconf|autom4te|autoheader)
|
||||
echo "The '$1' program is part of the GNU Autoconf package:"
|
||||
echo "<$gnu_software_URL/autoconf/>"
|
||||
echo "It also requires GNU m4 and Perl in order to run:"
|
||||
echo "<$gnu_software_URL/m4/>"
|
||||
echo "<$perl_URL>"
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
give_advice ()
|
||||
{
|
||||
# Normalize program name to check for.
|
||||
normalized_program=`echo "$1" | sed '
|
||||
s/^gnu-//; t
|
||||
s/^gnu//; t
|
||||
s/^g//; t'`
|
||||
|
||||
printf '%s\n' "'$1' is $msg."
|
||||
|
||||
configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
|
||||
case $normalized_program in
|
||||
autoconf*)
|
||||
echo "You should only need it if you modified 'configure.ac',"
|
||||
echo "or m4 files included by it."
|
||||
program_details 'autoconf'
|
||||
;;
|
||||
autoheader*)
|
||||
echo "You should only need it if you modified 'acconfig.h' or"
|
||||
echo "$configure_deps."
|
||||
program_details 'autoheader'
|
||||
;;
|
||||
automake*)
|
||||
echo "You should only need it if you modified 'Makefile.am' or"
|
||||
echo "$configure_deps."
|
||||
program_details 'automake'
|
||||
;;
|
||||
aclocal*)
|
||||
echo "You should only need it if you modified 'acinclude.m4' or"
|
||||
echo "$configure_deps."
|
||||
program_details 'aclocal'
|
||||
;;
|
||||
autom4te*)
|
||||
echo "You might have modified some maintainer files that require"
|
||||
echo "the 'automa4te' program to be rebuilt."
|
||||
program_details 'autom4te'
|
||||
;;
|
||||
bison*|yacc*)
|
||||
echo "You should only need it if you modified a '.y' file."
|
||||
echo "You may want to install the GNU Bison package:"
|
||||
echo "<$gnu_software_URL/bison/>"
|
||||
;;
|
||||
lex*|flex*)
|
||||
echo "You should only need it if you modified a '.l' file."
|
||||
echo "You may want to install the Fast Lexical Analyzer package:"
|
||||
echo "<$flex_URL>"
|
||||
;;
|
||||
help2man*)
|
||||
echo "You should only need it if you modified a dependency" \
|
||||
"of a man page."
|
||||
echo "You may want to install the GNU Help2man package:"
|
||||
echo "<$gnu_software_URL/help2man/>"
|
||||
;;
|
||||
makeinfo*)
|
||||
echo "You should only need it if you modified a '.texi' file, or"
|
||||
echo "any other file indirectly affecting the aspect of the manual."
|
||||
echo "You might want to install the Texinfo package:"
|
||||
echo "<$gnu_software_URL/texinfo/>"
|
||||
echo "The spurious makeinfo call might also be the consequence of"
|
||||
echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
|
||||
echo "want to install GNU make:"
|
||||
echo "<$gnu_software_URL/make/>"
|
||||
;;
|
||||
*)
|
||||
echo "You might have modified some files without having the proper"
|
||||
echo "tools for further handling them. Check the 'README' file, it"
|
||||
echo "often tells you about the needed prerequisites for installing"
|
||||
echo "this package. You may also peek at any GNU archive site, in"
|
||||
echo "case some other package contains this missing '$1' program."
|
||||
;;
|
||||
esac
|
||||
}
|
||||
|
||||
give_advice "$1" | sed -e '1s/^/WARNING: /' \
|
||||
-e '2,$s/^/ /' >&2
|
||||
|
||||
# Propagate the correct exit status (expected to be 127 for a program
|
||||
# not found, 63 for a program that failed due to version mismatch).
|
||||
exit $st
|
||||
|
||||
# Local variables:
|
||||
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||
# time-stamp-start: "scriptversion="
|
||||
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||
# time-stamp-time-zone: "UTC"
|
||||
# time-stamp-end: "; # UTC"
|
||||
# End:
|
||||
@@ -0,0 +1,175 @@
|
||||
/*
|
||||
showimage: A test application for the SDL image loading library.
|
||||
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "SDL.h"
|
||||
#include "SDL_image.h"
|
||||
|
||||
|
||||
/* Draw a Gimpish background pattern to show transparency in the image */
|
||||
static void draw_background(SDL_Renderer *renderer, int w, int h)
|
||||
{
|
||||
SDL_Color col[2] = {
|
||||
{ 0x66, 0x66, 0x66, 0xff },
|
||||
{ 0x99, 0x99, 0x99, 0xff },
|
||||
};
|
||||
int i, x, y;
|
||||
SDL_Rect rect;
|
||||
|
||||
rect.w = 8;
|
||||
rect.h = 8;
|
||||
for (y = 0; y < h; y += rect.h) {
|
||||
for (x = 0; x < w; x += rect.w) {
|
||||
/* use an 8x8 checkerboard pattern */
|
||||
i = (((x ^ y) >> 3) & 1);
|
||||
SDL_SetRenderDrawColor(renderer, col[i].r, col[i].g, col[i].b, col[i].a);
|
||||
|
||||
rect.x = x;
|
||||
rect.y = y;
|
||||
SDL_RenderFillRect(renderer, &rect);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
SDL_Window *window;
|
||||
SDL_Renderer *renderer;
|
||||
SDL_Texture *texture;
|
||||
Uint32 flags;
|
||||
int i, w, h, done;
|
||||
SDL_Event event;
|
||||
const char *saveFile = NULL;
|
||||
|
||||
/* Check command line usage */
|
||||
if ( ! argv[1] ) {
|
||||
fprintf(stderr, "Usage: %s [-fullscreen] [-save file.png] <image_file> ...\n", argv[0]);
|
||||
return(1);
|
||||
}
|
||||
|
||||
flags = SDL_WINDOW_HIDDEN;
|
||||
for ( i=1; argv[i]; ++i ) {
|
||||
if ( strcmp(argv[i], "-fullscreen") == 0 ) {
|
||||
SDL_ShowCursor(0);
|
||||
flags |= SDL_WINDOW_FULLSCREEN;
|
||||
}
|
||||
}
|
||||
|
||||
if (SDL_CreateWindowAndRenderer(0, 0, flags, &window, &renderer) < 0) {
|
||||
fprintf(stderr, "SDL_CreateWindowAndRenderer() failed: %s\n", SDL_GetError());
|
||||
return(2);
|
||||
}
|
||||
|
||||
for ( i=1; argv[i]; ++i ) {
|
||||
if ( strcmp(argv[i], "-fullscreen") == 0 ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( strcmp(argv[i], "-save") == 0 && argv[i+1] ) {
|
||||
++i;
|
||||
saveFile = argv[i];
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Open the image file */
|
||||
texture = IMG_LoadTexture(renderer, argv[i]);
|
||||
if (!texture) {
|
||||
fprintf(stderr, "Couldn't load %s: %s\n", argv[i], SDL_GetError());
|
||||
continue;
|
||||
}
|
||||
SDL_QueryTexture(texture, NULL, NULL, &w, &h);
|
||||
|
||||
/* Save the image file, if desired */
|
||||
if ( saveFile ) {
|
||||
SDL_Surface *surface = IMG_Load(argv[i]);
|
||||
if (surface) {
|
||||
if ( IMG_SavePNG(surface, saveFile) < 0 ) {
|
||||
fprintf(stderr, "Couldn't save %s: %s\n", saveFile, SDL_GetError());
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "Couldn't load %s: %s\n", argv[i], SDL_GetError());
|
||||
}
|
||||
}
|
||||
|
||||
/* Show the window */
|
||||
SDL_SetWindowTitle(window, argv[i]);
|
||||
SDL_SetWindowSize(window, w, h);
|
||||
SDL_ShowWindow(window);
|
||||
|
||||
done = 0;
|
||||
while ( ! done ) {
|
||||
while ( SDL_PollEvent(&event) ) {
|
||||
switch (event.type) {
|
||||
case SDL_KEYUP:
|
||||
switch (event.key.keysym.sym) {
|
||||
case SDLK_LEFT:
|
||||
if ( i > 1 ) {
|
||||
i -= 2;
|
||||
done = 1;
|
||||
}
|
||||
break;
|
||||
case SDLK_RIGHT:
|
||||
if ( argv[i+1] ) {
|
||||
done = 1;
|
||||
}
|
||||
break;
|
||||
case SDLK_ESCAPE:
|
||||
case SDLK_q:
|
||||
argv[i+1] = NULL;
|
||||
/* Drop through to done */
|
||||
case SDLK_SPACE:
|
||||
case SDLK_TAB:
|
||||
done = 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case SDL_MOUSEBUTTONDOWN:
|
||||
done = 1;
|
||||
break;
|
||||
case SDL_QUIT:
|
||||
argv[i+1] = NULL;
|
||||
done = 1;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* Draw a background pattern in case the image has transparency */
|
||||
draw_background(renderer, w, h);
|
||||
|
||||
/* Display the image */
|
||||
SDL_RenderCopy(renderer, texture, NULL, NULL);
|
||||
SDL_RenderPresent(renderer);
|
||||
|
||||
SDL_Delay(100);
|
||||
}
|
||||
SDL_DestroyTexture(texture);
|
||||
}
|
||||
|
||||
/* We're done! */
|
||||
SDL_Quit();
|
||||
return(0);
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
|
||||
#include "winresrc.h"
|
||||
|
||||
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Version
|
||||
//
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 2,0,0,0
|
||||
PRODUCTVERSION 2,0,0,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
FILEFLAGS 0x0L
|
||||
FILEOS 0x40004L
|
||||
FILETYPE 0x2L
|
||||
FILESUBTYPE 0x0L
|
||||
BEGIN
|
||||
BLOCK "StringFileInfo"
|
||||
BEGIN
|
||||
BLOCK "040904b0"
|
||||
BEGIN
|
||||
VALUE "CompanyName", "\0"
|
||||
VALUE "FileDescription", "SDL_image\0"
|
||||
VALUE "FileVersion", "2, 0, 0, 0\0"
|
||||
VALUE "InternalName", "SDL_image\0"
|
||||
VALUE "LegalCopyright", "Copyright © 2013 Sam Lantinga\0"
|
||||
VALUE "OriginalFilename", "SDL_image.dll\0"
|
||||
VALUE "ProductName", "Simple DirectMedia Layer\0"
|
||||
VALUE "ProductVersion", "2, 0, 0, 0\0"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
BEGIN
|
||||
VALUE "Translation", 0x409, 1200
|
||||
END
|
||||
END
|
||||
Reference in New Issue
Block a user