]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: imagtiff.cpp | |
3 | // Purpose: wxImage TIFF handler | |
4 | // Author: Robert Roebling | |
5 | // RCS-ID: $Id$ | |
6 | // Copyright: (c) Robert Roebling | |
7 | // Licence: wxWindows licence | |
8 | ///////////////////////////////////////////////////////////////////////////// | |
9 | ||
10 | #ifdef __GNUG__ | |
11 | #pragma implementation "imagtiff.h" | |
12 | #endif | |
13 | ||
14 | // For compilers that support precompilation, includes "wx.h". | |
15 | #include "wx/wxprec.h" | |
16 | ||
17 | #ifdef __BORLANDC__ | |
18 | #pragma hdrstop | |
19 | #endif | |
20 | ||
21 | #include "wx/defs.h" | |
22 | ||
23 | #if wxUSE_LIBTIFF | |
24 | ||
25 | #include "wx/imagtiff.h" | |
26 | #include "wx/bitmap.h" | |
27 | #include "wx/debug.h" | |
28 | #include "wx/log.h" | |
29 | #include "wx/app.h" | |
30 | extern "C" | |
31 | { | |
32 | #include "tiff.h" | |
33 | #include "tiffio.h" | |
34 | #include "tiffiop.h" | |
35 | } | |
36 | #include "wx/filefn.h" | |
37 | #include "wx/wfstream.h" | |
38 | #include "wx/intl.h" | |
39 | #include "wx/module.h" | |
40 | ||
41 | //----------------------------------------------------------------------------- | |
42 | // wxTIFFHandler | |
43 | //----------------------------------------------------------------------------- | |
44 | ||
45 | IMPLEMENT_DYNAMIC_CLASS(wxTIFFHandler,wxImageHandler) | |
46 | ||
47 | static tsize_t | |
48 | _tiffReadProc(thandle_t handle, tdata_t buf, tsize_t size) | |
49 | { | |
50 | wxInputStream *stream = (wxInputStream*) handle; | |
51 | stream->Read( (void*) buf, (size_t) size ); | |
52 | return stream->LastRead(); | |
53 | } | |
54 | ||
55 | static tsize_t | |
56 | _tiffWriteProc(thandle_t handle, tdata_t buf, tsize_t size) | |
57 | { | |
58 | wxOutputStream *stream = (wxOutputStream*) handle; | |
59 | stream->Write( (void*) buf, (size_t) size ); | |
60 | return stream->LastWrite(); | |
61 | } | |
62 | ||
63 | static toff_t | |
64 | _tiffSeekProc(thandle_t handle, toff_t off, int whence) | |
65 | { | |
66 | wxInputStream *stream = (wxInputStream*) handle; | |
67 | wxSeekMode mode; | |
68 | switch (whence) | |
69 | { | |
70 | case SEEK_SET: mode = wxFromStart; break; | |
71 | case SEEK_CUR: mode = wxFromCurrent; break; | |
72 | case SEEK_END: mode = wxFromEnd; break; | |
73 | default: mode = wxFromCurrent; break; | |
74 | } | |
75 | ||
76 | return (toff_t)stream->SeekI( (off_t)off, mode ); | |
77 | } | |
78 | ||
79 | static int | |
80 | _tiffCloseProc(thandle_t WXUNUSED(handle)) | |
81 | { | |
82 | return 0; // ? | |
83 | } | |
84 | ||
85 | static toff_t | |
86 | _tiffSizeProc(thandle_t handle) | |
87 | { | |
88 | wxInputStream *stream = (wxInputStream*) handle; | |
89 | return (toff_t) stream->GetSize(); | |
90 | } | |
91 | ||
92 | static int | |
93 | _tiffMapProc(thandle_t WXUNUSED(handle), | |
94 | tdata_t* WXUNUSED(pbase), | |
95 | toff_t* WXUNUSED(psize)) | |
96 | { | |
97 | return 0; | |
98 | } | |
99 | ||
100 | static void | |
101 | _tiffUnmapProc(thandle_t WXUNUSED(handle), | |
102 | tdata_t WXUNUSED(base), | |
103 | toff_t WXUNUSED(size)) | |
104 | { | |
105 | } | |
106 | ||
107 | TIFF* | |
108 | TIFFwxOpen(wxInputStream &stream, const char* name, const char* mode) | |
109 | { | |
110 | TIFF* tif = TIFFClientOpen(name, mode, | |
111 | (thandle_t) &stream, | |
112 | _tiffReadProc, _tiffWriteProc, | |
113 | _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, | |
114 | _tiffMapProc, _tiffUnmapProc); | |
115 | ||
116 | if (tif) | |
117 | tif->tif_fd = (int) &stream; | |
118 | ||
119 | return tif; | |
120 | } | |
121 | ||
122 | ||
123 | bool wxTIFFHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int index ) | |
124 | { | |
125 | image->Destroy(); | |
126 | ||
127 | TIFF *tif = TIFFwxOpen( stream, "image", "r" ); | |
128 | ||
129 | if (!tif) | |
130 | { | |
131 | if (verbose) | |
132 | wxLogError( _("TIFF: Error loading image.") ); | |
133 | ||
134 | return FALSE; | |
135 | } | |
136 | ||
137 | if (!TIFFSetDirectory( tif, (tdir_t)index )) | |
138 | { | |
139 | if (verbose) | |
140 | wxLogError( _("Invalid TIFF image index.") ); | |
141 | ||
142 | TIFFClose( tif ); | |
143 | ||
144 | return FALSE; | |
145 | } | |
146 | ||
147 | uint32 w, h; | |
148 | uint32 npixels; | |
149 | uint32 *raster; | |
150 | ||
151 | TIFFGetField( tif, TIFFTAG_IMAGEWIDTH, &w ); | |
152 | TIFFGetField( tif, TIFFTAG_IMAGELENGTH, &h ); | |
153 | ||
154 | npixels = w * h; | |
155 | ||
156 | raster = (uint32*) _TIFFmalloc( npixels * sizeof(uint32) ); | |
157 | ||
158 | if (!raster) | |
159 | { | |
160 | if (verbose) | |
161 | wxLogError( _("TIFF: Couldn't allocate memory.") ); | |
162 | ||
163 | return FALSE; | |
164 | } | |
165 | ||
166 | image->Create( (int)w, (int)h ); | |
167 | if (!image->Ok()) | |
168 | { | |
169 | if (verbose) | |
170 | wxLogError( _("TIFF: Couldn't allocate memory.") ); | |
171 | ||
172 | _TIFFfree( raster ); | |
173 | ||
174 | return FALSE; | |
175 | } | |
176 | ||
177 | if (!TIFFReadRGBAImage( tif, w, h, raster, 0 )) | |
178 | { | |
179 | if (verbose) | |
180 | wxLogError( _("TIFF: Error reading image.") ); | |
181 | ||
182 | _TIFFfree( raster ); | |
183 | image->Destroy(); | |
184 | ||
185 | return FALSE; | |
186 | } | |
187 | ||
188 | bool hasmask = FALSE; | |
189 | ||
190 | unsigned char *ptr = image->GetData(); | |
191 | ptr += w*3*(h-1); | |
192 | uint32 pos = 0; | |
193 | ||
194 | for (uint32 i = 0; i < h; i++) | |
195 | { | |
196 | for (uint32 j = 0; j < w; j++) | |
197 | { | |
198 | unsigned char alpha = (unsigned char)TIFFGetA(raster[pos]); | |
199 | if (alpha < 127) | |
200 | { | |
201 | hasmask = TRUE; | |
202 | ptr[0] = image->GetMaskRed(); | |
203 | ptr++; | |
204 | ptr[0] = image->GetMaskGreen(); | |
205 | ptr++; | |
206 | ptr[0] = image->GetMaskBlue(); | |
207 | ptr++; | |
208 | } | |
209 | else | |
210 | { | |
211 | ptr[0] = (unsigned char)TIFFGetR(raster[pos]); | |
212 | ptr++; | |
213 | ptr[0] = (unsigned char)TIFFGetG(raster[pos]); | |
214 | ptr++; | |
215 | ptr[0] = (unsigned char)TIFFGetB(raster[pos]); | |
216 | ptr++; | |
217 | } | |
218 | pos++; | |
219 | } | |
220 | ptr -= 2*w*3; // subtract line we just added plus one line | |
221 | } | |
222 | ||
223 | _TIFFfree( raster ); | |
224 | ||
225 | TIFFClose( tif ); | |
226 | ||
227 | image->SetMask( hasmask ); | |
228 | ||
229 | return TRUE; | |
230 | } | |
231 | ||
232 | int wxTIFFHandler::GetImageCount( wxInputStream& stream ) | |
233 | { | |
234 | TIFF *tif = TIFFwxOpen( stream, "image", "r" ); | |
235 | ||
236 | if (!tif) | |
237 | return 0; | |
238 | ||
239 | int dircount = 0; // according to the libtiff docs, dircount should be set to 1 here??? | |
240 | do { | |
241 | dircount++; | |
242 | } while (TIFFReadDirectory(tif)); | |
243 | ||
244 | TIFFClose( tif ); | |
245 | ||
246 | return dircount; | |
247 | } | |
248 | ||
249 | bool wxTIFFHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) ) | |
250 | { | |
251 | return FALSE; | |
252 | } | |
253 | ||
254 | bool wxTIFFHandler::DoCanRead( wxInputStream& stream ) | |
255 | { | |
256 | unsigned char hdr[2]; | |
257 | ||
258 | stream.Read(&hdr, 2); | |
259 | stream.SeekI(-2, wxFromCurrent); | |
260 | ||
261 | return ((hdr[0] == 0x49 && hdr[1] == 0x49) || | |
262 | (hdr[0] == 0x4D && hdr[1] == 0x4D)); | |
263 | } | |
264 | ||
265 | ||
266 | #endif | |
267 | // wxUSE_LIBTIFF | |
268 | ||
269 | ||
270 | ||
271 | ||
272 | ||
273 |