]> git.saurik.com Git - wxWidgets.git/blob - src/tiff/tif_open.c
Change up font selection process
[wxWidgets.git] / src / tiff / tif_open.c
1 /* $Header$ */
2
3 /*
4 * Copyright (c) 1988-1997 Sam Leffler
5 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and
8 * its documentation for any purpose is hereby granted without fee, provided
9 * that (i) the above copyright notices and this permission notice appear in
10 * all copies of the software and related documentation, and (ii) the names of
11 * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Sam Leffler and Silicon Graphics.
14 *
15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 *
19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 */
26
27 /*
28 * TIFF Library.
29 */
30 #include "tiffiop.h"
31
32 void LINKAGEMODE _TIFFSetDefaultCompressionState(TIFF* tif);
33
34 static const long typemask[13] = {
35 0L, /* TIFF_NOTYPE */
36 0x000000ffL, /* TIFF_BYTE */
37 0xffffffffL, /* TIFF_ASCII */
38 0x0000ffffL, /* TIFF_SHORT */
39 0xffffffffL, /* TIFF_LONG */
40 0xffffffffL, /* TIFF_RATIONAL */
41 0x000000ffL, /* TIFF_SBYTE */
42 0x000000ffL, /* TIFF_UNDEFINED */
43 0x0000ffffL, /* TIFF_SSHORT */
44 0xffffffffL, /* TIFF_SLONG */
45 0xffffffffL, /* TIFF_SRATIONAL */
46 0xffffffffL, /* TIFF_FLOAT */
47 0xffffffffL, /* TIFF_DOUBLE */
48 };
49 static const int bigTypeshift[13] = {
50 0, /* TIFF_NOTYPE */
51 24, /* TIFF_BYTE */
52 0, /* TIFF_ASCII */
53 16, /* TIFF_SHORT */
54 0, /* TIFF_LONG */
55 0, /* TIFF_RATIONAL */
56 24, /* TIFF_SBYTE */
57 24, /* TIFF_UNDEFINED */
58 16, /* TIFF_SSHORT */
59 0, /* TIFF_SLONG */
60 0, /* TIFF_SRATIONAL */
61 0, /* TIFF_FLOAT */
62 0, /* TIFF_DOUBLE */
63 };
64 static const int litTypeshift[13] = {
65 0, /* TIFF_NOTYPE */
66 0, /* TIFF_BYTE */
67 0, /* TIFF_ASCII */
68 0, /* TIFF_SHORT */
69 0, /* TIFF_LONG */
70 0, /* TIFF_RATIONAL */
71 0, /* TIFF_SBYTE */
72 0, /* TIFF_UNDEFINED */
73 0, /* TIFF_SSHORT */
74 0, /* TIFF_SLONG */
75 0, /* TIFF_SRATIONAL */
76 0, /* TIFF_FLOAT */
77 0, /* TIFF_DOUBLE */
78 };
79
80 /*
81 * Initialize the shift & mask tables, and the
82 * byte swapping state according to the file
83 * contents and the machine architecture.
84 */
85 static void
86 TIFFInitOrder(TIFF* tif, int magic, int bigendian)
87 {
88 tif->tif_typemask = typemask;
89 if (magic == TIFF_BIGENDIAN) {
90 tif->tif_typeshift = bigTypeshift;
91 if (!bigendian)
92 tif->tif_flags |= TIFF_SWAB;
93 } else {
94 tif->tif_typeshift = litTypeshift;
95 if (bigendian)
96 tif->tif_flags |= TIFF_SWAB;
97 }
98 }
99
100 int
101 _TIFFgetMode(const char* mode, const char* module)
102 {
103 int m = -1;
104
105 switch (mode[0]) {
106 case 'r':
107 m = O_RDONLY;
108 if (mode[1] == '+')
109 m = O_RDWR;
110 break;
111 case 'w':
112 case 'a':
113 m = O_RDWR|O_CREAT;
114 if (mode[0] == 'w')
115 m |= O_TRUNC;
116 break;
117 default:
118 TIFFError(module, "\"%s\": Bad mode", mode);
119 break;
120 }
121 return (m);
122 }
123
124 TIFF*
125 TIFFClientOpen(
126 const char* name, const char* mode,
127 thandle_t clientdata,
128 TIFFReadWriteProc readproc,
129 TIFFReadWriteProc writeproc,
130 TIFFSeekProc seekproc,
131 TIFFCloseProc closeproc,
132 TIFFSizeProc sizeproc,
133 TIFFMapFileProc mapproc,
134 TIFFUnmapFileProc unmapproc
135 )
136 {
137 static const char module[] = "TIFFClientOpen";
138 TIFF *tif;
139 int m, bigendian;
140 const char* cp;
141
142 m = _TIFFgetMode(mode, module);
143 if (m == -1)
144 goto bad2;
145 tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
146 if (tif == NULL) {
147 TIFFError(module, "%s: Out of memory (TIFF structure)", name);
148 goto bad2;
149 }
150 _TIFFmemset(tif, 0, sizeof (*tif));
151 tif->tif_name = (char *)tif + sizeof (TIFF);
152 strcpy(tif->tif_name, name);
153 tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
154 tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
155 tif->tif_curoff = 0;
156 tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
157 tif->tif_row = (uint32) -1; /* read/write pre-increment */
158 tif->tif_clientdata = clientdata;
159 tif->tif_readproc = readproc;
160 tif->tif_writeproc = writeproc;
161 tif->tif_seekproc = seekproc;
162 tif->tif_closeproc = closeproc;
163 tif->tif_sizeproc = sizeproc;
164 tif->tif_mapproc = mapproc;
165 tif->tif_unmapproc = unmapproc;
166 _TIFFSetDefaultCompressionState(tif); /* setup default state */
167 /*
168 * Default is to return data MSB2LSB and enable the
169 * use of memory-mapped files and strip chopping when
170 * a file is opened read-only.
171 */
172 tif->tif_flags = FILLORDER_MSB2LSB;
173 if (m == O_RDONLY)
174 #ifdef STRIPCHOP_DEFAULT
175 tif->tif_flags |= TIFF_MAPPED|STRIPCHOP_DEFAULT;
176 #else
177 tif->tif_flags |= TIFF_MAPPED;
178 #endif
179
180 { union { int32 i; char c[4]; } u; u.i = 1; bigendian = u.c[0] == 0; }
181 /*
182 * Process library-specific flags in the open mode string.
183 * The following flags may be used to control intrinsic library
184 * behaviour that may or may not be desirable (usually for
185 * compatibility with some application that claims to support
186 * TIFF but only supports some braindead idea of what the
187 * vendor thinks TIFF is):
188 *
189 * 'l' use little-endian byte order for creating a file
190 * 'b' use big-endian byte order for creating a file
191 * 'L' read/write information using LSB2MSB bit order
192 * 'B' read/write information using MSB2LSB bit order
193 * 'H' read/write information using host bit order
194 * 'M' enable use of memory-mapped files when supported
195 * 'm' disable use of memory-mapped files
196 * 'C' enable strip chopping support when reading
197 * 'c' disable strip chopping support
198 *
199 * The use of the 'l' and 'b' flags is strongly discouraged.
200 * These flags are provided solely because numerous vendors,
201 * typically on the PC, do not correctly support TIFF; they
202 * only support the Intel little-endian byte order. This
203 * support is not configured by default because it supports
204 * the violation of the TIFF spec that says that readers *MUST*
205 * support both byte orders. It is strongly recommended that
206 * you not use this feature except to deal with busted apps
207 * that write invalid TIFF. And even in those cases you should
208 * bang on the vendors to fix their software.
209 *
210 * The 'L', 'B', and 'H' flags are intended for applications
211 * that can optimize operations on data by using a particular
212 * bit order. By default the library returns data in MSB2LSB
213 * bit order for compatibiltiy with older versions of this
214 * library. Returning data in the bit order of the native cpu
215 * makes the most sense but also requires applications to check
216 * the value of the FillOrder tag; something they probabyl do
217 * not do right now.
218 *
219 * The 'M' and 'm' flags are provided because some virtual memory
220 * systems exhibit poor behaviour when large images are mapped.
221 * These options permit clients to control the use of memory-mapped
222 * files on a per-file basis.
223 *
224 * The 'C' and 'c' flags are provided because the library support
225 * for chopping up large strips into multiple smaller strips is not
226 * application-transparent and as such can cause problems. The 'c'
227 * option permits applications that only want to look at the tags,
228 * for example, to get the unadulterated TIFF tag information.
229 */
230 for (cp = mode; *cp; cp++)
231 switch (*cp) {
232 case 'b':
233 if ((m&O_CREAT) && !bigendian)
234 tif->tif_flags |= TIFF_SWAB;
235 break;
236 case 'l':
237 if ((m&O_CREAT) && bigendian)
238 tif->tif_flags |= TIFF_SWAB;
239 break;
240 case 'B':
241 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
242 FILLORDER_MSB2LSB;
243 break;
244 case 'L':
245 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
246 FILLORDER_LSB2MSB;
247 break;
248 case 'H':
249 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
250 HOST_FILLORDER;
251 break;
252 case 'M':
253 if (m == O_RDONLY)
254 tif->tif_flags |= TIFF_MAPPED;
255 break;
256 case 'm':
257 if (m == O_RDONLY)
258 tif->tif_flags &= ~TIFF_MAPPED;
259 break;
260 case 'C':
261 if (m == O_RDONLY)
262 tif->tif_flags |= TIFF_STRIPCHOP;
263 break;
264 case 'c':
265 if (m == O_RDONLY)
266 tif->tif_flags &= ~TIFF_STRIPCHOP;
267 break;
268 }
269 /*
270 * Read in TIFF header.
271 */
272 if (!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
273 if (tif->tif_mode == O_RDONLY) {
274 TIFFError(name, "Cannot read TIFF header");
275 goto bad;
276 }
277 /*
278 * Setup header and write.
279 */
280 tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
281 ? (bigendian ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN)
282 : (bigendian ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN);
283 tif->tif_header.tiff_version = TIFF_VERSION;
284 if (tif->tif_flags & TIFF_SWAB)
285 TIFFSwabShort(&tif->tif_header.tiff_version);
286 tif->tif_header.tiff_diroff = 0; /* filled in later */
287 if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
288 TIFFError(name, "Error writing TIFF header");
289 goto bad;
290 }
291 /*
292 * Setup the byte order handling.
293 */
294 TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
295 /*
296 * Setup default directory.
297 */
298 if (!TIFFDefaultDirectory(tif))
299 goto bad;
300 tif->tif_diroff = 0;
301 return (tif);
302 }
303 /*
304 * Setup the byte order handling.
305 */
306 if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
307 tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN) {
308 TIFFError(name, "Not a TIFF file, bad magic number %d (0x%x)",
309 tif->tif_header.tiff_magic,
310 tif->tif_header.tiff_magic);
311 goto bad;
312 }
313 TIFFInitOrder(tif, tif->tif_header.tiff_magic, bigendian);
314 /*
315 * Swap header if required.
316 */
317 if (tif->tif_flags & TIFF_SWAB) {
318 TIFFSwabShort(&tif->tif_header.tiff_version);
319 TIFFSwabLong(&tif->tif_header.tiff_diroff);
320 }
321 /*
322 * Now check version (if needed, it's been byte-swapped).
323 * Note that this isn't actually a version number, it's a
324 * magic number that doesn't change (stupid).
325 */
326 if (tif->tif_header.tiff_version != TIFF_VERSION) {
327 TIFFError(name,
328 "Not a TIFF file, bad version number %d (0x%x)",
329 tif->tif_header.tiff_version,
330 tif->tif_header.tiff_version);
331 goto bad;
332 }
333 tif->tif_flags |= TIFF_MYBUFFER;
334 tif->tif_rawcp = tif->tif_rawdata = 0;
335 tif->tif_rawdatasize = 0;
336 /*
337 * Setup initial directory.
338 */
339 switch (mode[0]) {
340 case 'r':
341 tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
342 /*
343 * Try to use a memory-mapped file if the client
344 * has not explicitly suppressed usage with the
345 * 'm' flag in the open mode (see above).
346 */
347 if ((tif->tif_flags & TIFF_MAPPED) &&
348 !TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
349 tif->tif_flags &= ~TIFF_MAPPED;
350 if (TIFFReadDirectory(tif)) {
351 tif->tif_rawcc = -1;
352 tif->tif_flags |= TIFF_BUFFERSETUP;
353 return (tif);
354 }
355 break;
356 case 'a':
357 /*
358 * New directories are automatically append
359 * to the end of the directory chain when they
360 * are written out (see TIFFWriteDirectory).
361 */
362 if (!TIFFDefaultDirectory(tif))
363 goto bad;
364 return (tif);
365 }
366 bad:
367 tif->tif_mode = O_RDONLY; /* XXX avoid flush */
368 TIFFClose(tif);
369 return ((TIFF*)0);
370 bad2:
371 (void) (*closeproc)(clientdata);
372 return ((TIFF*)0);
373 }
374
375 /*
376 * Query functions to access private data.
377 */
378
379 /*
380 * Return open file's name.
381 */
382 const char *
383 TIFFFileName(TIFF* tif)
384 {
385 return (tif->tif_name);
386 }
387
388 /*
389 * Return open file's I/O descriptor.
390 */
391 int
392 TIFFFileno(TIFF* tif)
393 {
394 return (tif->tif_fd);
395 }
396
397 /*
398 * Return read/write mode.
399 */
400 int
401 TIFFGetMode(TIFF* tif)
402 {
403 return (tif->tif_mode);
404 }
405
406 /*
407 * Return nonzero if file is organized in
408 * tiles; zero if organized as strips.
409 */
410 int
411 TIFFIsTiled(TIFF* tif)
412 {
413 return (isTiled(tif));
414 }
415
416 /*
417 * Return current row being read/written.
418 */
419 uint32
420 TIFFCurrentRow(TIFF* tif)
421 {
422 return (tif->tif_row);
423 }
424
425 /*
426 * Return index of the current directory.
427 */
428 tdir_t
429 TIFFCurrentDirectory(TIFF* tif)
430 {
431 return (tif->tif_curdir);
432 }
433
434 /*
435 * Return current strip.
436 */
437 tstrip_t
438 TIFFCurrentStrip(TIFF* tif)
439 {
440 return (tif->tif_curstrip);
441 }
442
443 /*
444 * Return current tile.
445 */
446 ttile_t
447 TIFFCurrentTile(TIFF* tif)
448 {
449 return (tif->tif_curtile);
450 }
451
452 /*
453 * Return nonzero if the file has byte-swapped data.
454 */
455 int
456 TIFFIsByteSwapped(TIFF* tif)
457 {
458 return ((tif->tif_flags & TIFF_SWAB) != 0);
459 }
460
461 /*
462 * Return nonzero if the data is returned up-sampled.
463 */
464 int
465 TIFFIsUpSampled(TIFF* tif)
466 {
467 return (isUpSampled(tif));
468 }
469
470 /*
471 * Return nonzero if the data is returned in MSB-to-LSB bit order.
472 */
473 int
474 TIFFIsMSB2LSB(TIFF* tif)
475 {
476 return (isFillOrder(tif, FILLORDER_MSB2LSB));
477 }