Subversion Repositories Kolibri OS

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
5131 clevermous 1 
/*
2 
    IMGLIB:  An example image loading library for use with SDL
3 
    Copyright (C) 1999  Sam Lantinga
4 
 
5 
    This library is free software; you can redistribute it and/or
6 
    modify it under the terms of the GNU Library General Public
7 
    License as published by the Free Software Foundation; either
8 
    version 2 of the License, or (at your option) any later version.
9 
 
10 
    This library is distributed in the hope that it will be useful,
11 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 
    Library General Public License for more details.
14 
 
15 
    You should have received a copy of the GNU Library General Public
16 
    License along with this library; if not, write to the Free
17 
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 
 
19 
    Sam Lantinga
20 
    5635-34 Springhouse Dr.
21 
    Pleasanton, CA 94588 (USA)
22 
    slouken@devolution.com
23 
 
24 
    5/29/2000: TIFF loader written. Mark Baker (mbaker@0x7a69.net)
25 
    2000-07-28: Fixed two off-by one bugs in reversal loop and made it work on
26 
                big-endian machines (Mattias)
27 
    2000-08-09: Removed alpha inversion (Mattias)
28 
*/
29 
 
30 
 
31 
 
32 
/* This is a TIFF image file loading framework */
33 
 
34 
#include
35 
 
36 
#include "SDL_image.h"
37 
 
38 
#ifdef LOAD_TIF
39 
 
40 
#include
41 
 
42 
/*
43 
 * These are the thunking routine to use the SDL_RWops* routines from
44 
 * libtiff's internals.
45 
*/
46 
 
47 
static tsize_t tiff_read(thandle_t fd, tdata_t buf, tsize_t size)
48 
{
49 
	return SDL_RWread((SDL_RWops*)fd, buf, 1, size);
50 
}
51 
 
52 
static toff_t tiff_seek(thandle_t fd, toff_t offset, int origin)
53 
{
54 
	return SDL_RWseek((SDL_RWops*)fd, offset, origin);
55 
}
56 
 
57 
static tsize_t tiff_write(thandle_t fd, tdata_t buf, tsize_t size)
58 
{
59 
	return SDL_RWwrite((SDL_RWops*)fd, buf, 1, size);
60 
}
61 
 
62 
static int tiff_close(thandle_t fd)
63 
{
64 
	/*
65 
	 * We don't want libtiff closing our SDL_RWops*, but if it's not given
66 
         * a routine to try, and if the image isn't a TIFF, it'll segfault.
67 
	 */
68 
	return 0;
69 
}
70 
 
71 
static toff_t tiff_size(thandle_t fd)
72 
{
73 
	Uint32 save_pos;
74 
	toff_t size;
75 
 
76 
	save_pos = SDL_RWtell((SDL_RWops*)fd);
77 
	SDL_RWseek((SDL_RWops*)fd, 0, SEEK_END);
78 
        size = SDL_RWtell((SDL_RWops*)fd);
79 
	SDL_RWseek((SDL_RWops*)fd, save_pos, SEEK_SET);
80 
	return size;
81 
}
82 
 
83 
int IMG_isTIF(SDL_RWops* src)
84 
{
85 
	TIFF* tiff;
86 
	TIFFErrorHandler prev_handler;
87 
 
88 
	/* Suppress output from libtiff */
89 
	prev_handler = TIFFSetErrorHandler(NULL);
90 
 
91 
	/* Attempt to process the given file data */
92 
	/* turn off memory mapped access with the m flag */
93 
	tiff = TIFFClientOpen("SDL_image", "rm", (thandle_t)src,
94 
		tiff_read, tiff_write, tiff_seek, tiff_close, tiff_size, NULL, NULL);
95 
 
96 
	/* Reset the default error handler, since it can be useful for info */
97 
	TIFFSetErrorHandler(prev_handler);
98 
 
99 
	/* If it's not a TIFF, then tiff will be NULL. */
100 
	if(!tiff)
101 
		return 0;
102 
 
103 
	/* Free up any dynamically allocated memory libtiff uses */
104 
	TIFFClose(tiff);
105 
 
106 
	return 1;
107 
}
108 
 
109 
SDL_Surface* IMG_LoadTIF_RW(SDL_RWops* src)
110 
{
111 
	TIFF* tiff;
112 
	SDL_Surface* surface = NULL;
113 
	Uint32 img_width, img_height;
114 
	Uint32 Rmask, Gmask, Bmask, Amask, mask;
115 
	Uint32 x, y;
116 
	Uint32 half;
117 
 
118 
 
119 
	/* turn off memory mapped access with the m flag */
120 
	tiff = TIFFClientOpen("SDL_image", "rm", (thandle_t)src,
121 
		tiff_read, tiff_write, tiff_seek, tiff_close, tiff_size, NULL, NULL);
122 
	if(!tiff)
123 
		return NULL;
124 
 
125 
	/* Retrieve the dimensions of the image from the TIFF tags */
126 
	TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &img_width);
127 
	TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &img_height);
128 
 
129 
	Rmask = 0x000000FF;
130 
	Gmask = 0x0000FF00;
131 
	Bmask = 0x00FF0000;
132 
	Amask = 0xFF000000;
133 
	surface = SDL_AllocSurface(SDL_SWSURFACE, img_width, img_height, 32,
134 
		Rmask, Gmask, Bmask, Amask);
135 
	if(!surface)
136 
		return NULL;
137 
 
138 
	if(!TIFFReadRGBAImage(tiff, img_width, img_height, surface->pixels, 0))
139 
		return NULL;
140 
 
141 
	/* libtiff loads the image upside-down, flip it back */
142 
	half = img_height / 2;
143 
	for(y = 0; y < half; y++)
144 
	{
145 
	        Uint32 *top = (Uint32 *)surface->pixels + y * surface->pitch/4;
146 
	        Uint32 *bot = (Uint32 *)surface->pixels
147 
		              + (img_height - y - 1) * surface->pitch/4;
148 
		for(x = 0; x < img_width; x++)
149 
		{
150 
		        Uint32 tmp = top[x];
151 
			top[x] = bot[x];
152 
			bot[x] = tmp;
153 
		}
154 
	}
155 
	TIFFClose(tiff);
156 
 
157 
	return surface;
158 
}
159 
 
160 
#else
161 
 
162 
/* See if an image is contained in a data source */
163 
int IMG_isTIF(SDL_RWops *src)
164 
{
165 
	return(0);
166 
}
167 
 
168 
/* Load a TIFF type image from an SDL datasource */
169 
SDL_Surface *IMG_LoadTIF_RW(SDL_RWops *src)
170 
{
171 
	return(NULL);
172 
}
173 
 
174 
#endif /* LOAD_TIF */