"Initial commit to Gerrit"
[profile/ivi/libtiff.git] / libtiff / tif_open.c
1 /* $Id: tif_open.c,v 1.33.2.2 2010-12-06 16:54:22 faxguy Exp $ */
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 static const long typemask[13] = {
33         (long)0L,               /* TIFF_NOTYPE */
34         (long)0x000000ffL,      /* TIFF_BYTE */
35         (long)0xffffffffL,      /* TIFF_ASCII */
36         (long)0x0000ffffL,      /* TIFF_SHORT */
37         (long)0xffffffffL,      /* TIFF_LONG */
38         (long)0xffffffffL,      /* TIFF_RATIONAL */
39         (long)0x000000ffL,      /* TIFF_SBYTE */
40         (long)0x000000ffL,      /* TIFF_UNDEFINED */
41         (long)0x0000ffffL,      /* TIFF_SSHORT */
42         (long)0xffffffffL,      /* TIFF_SLONG */
43         (long)0xffffffffL,      /* TIFF_SRATIONAL */
44         (long)0xffffffffL,      /* TIFF_FLOAT */
45         (long)0xffffffffL,      /* TIFF_DOUBLE */
46 };
47 static const int bigTypeshift[13] = {
48         0,              /* TIFF_NOTYPE */
49         24,             /* TIFF_BYTE */
50         0,              /* TIFF_ASCII */
51         16,             /* TIFF_SHORT */
52         0,              /* TIFF_LONG */
53         0,              /* TIFF_RATIONAL */
54         24,             /* TIFF_SBYTE */
55         24,             /* TIFF_UNDEFINED */
56         16,             /* TIFF_SSHORT */
57         0,              /* TIFF_SLONG */
58         0,              /* TIFF_SRATIONAL */
59         0,              /* TIFF_FLOAT */
60         0,              /* TIFF_DOUBLE */
61 };
62 static const int litTypeshift[13] = {
63         0,              /* TIFF_NOTYPE */
64         0,              /* TIFF_BYTE */
65         0,              /* TIFF_ASCII */
66         0,              /* TIFF_SHORT */
67         0,              /* TIFF_LONG */
68         0,              /* TIFF_RATIONAL */
69         0,              /* TIFF_SBYTE */
70         0,              /* TIFF_UNDEFINED */
71         0,              /* TIFF_SSHORT */
72         0,              /* TIFF_SLONG */
73         0,              /* TIFF_SRATIONAL */
74         0,              /* TIFF_FLOAT */
75         0,              /* TIFF_DOUBLE */
76 };
77
78 /*
79  * Dummy functions to fill the omitted client procedures.
80  */
81 static int
82 _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
83 {
84         (void) fd; (void) pbase; (void) psize;
85         return (0);
86 }
87
88 static void
89 _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
90 {
91         (void) fd; (void) base; (void) size;
92 }
93
94 /*
95  * Initialize the shift & mask tables, and the
96  * byte swapping state according to the file
97  * contents and the machine architecture.
98  */
99 static void
100 TIFFInitOrder(TIFF* tif, int magic)
101 {
102         tif->tif_typemask = typemask;
103         if (magic == TIFF_BIGENDIAN) {
104                 tif->tif_typeshift = bigTypeshift;
105 #ifndef WORDS_BIGENDIAN
106                 tif->tif_flags |= TIFF_SWAB;
107 #endif
108         } else {
109                 tif->tif_typeshift = litTypeshift;
110 #ifdef WORDS_BIGENDIAN
111                 tif->tif_flags |= TIFF_SWAB;
112 #endif
113         }
114 }
115
116 int
117 _TIFFgetMode(const char* mode, const char* module)
118 {
119         int m = -1;
120
121         switch (mode[0]) {
122         case 'r':
123                 m = O_RDONLY;
124                 if (mode[1] == '+')
125                         m = O_RDWR;
126                 break;
127         case 'w':
128         case 'a':
129                 m = O_RDWR|O_CREAT;
130                 if (mode[0] == 'w')
131                         m |= O_TRUNC;
132                 break;
133         default:
134                 TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
135                 break;
136         }
137         return (m);
138 }
139
140 TIFF*
141 TIFFClientOpen(
142         const char* name, const char* mode,
143         thandle_t clientdata,
144         TIFFReadWriteProc readproc,
145         TIFFReadWriteProc writeproc,
146         TIFFSeekProc seekproc,
147         TIFFCloseProc closeproc,
148         TIFFSizeProc sizeproc,
149         TIFFMapFileProc mapproc,
150         TIFFUnmapFileProc unmapproc
151 )
152 {
153         static const char module[] = "TIFFClientOpen";
154         TIFF *tif;
155         int m;
156         const char* cp;
157
158         m = _TIFFgetMode(mode, module);
159         if (m == -1)
160                 goto bad2;
161         tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
162         if (tif == NULL) {
163                 TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
164                 goto bad2;
165         }
166         _TIFFmemset(tif, 0, sizeof (*tif));
167         tif->tif_name = (char *)tif + sizeof (TIFF);
168         strcpy(tif->tif_name, name);
169         tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
170         tif->tif_curdir = (tdir_t) -1;          /* non-existent directory */
171         tif->tif_curoff = 0;
172         tif->tif_curstrip = (tstrip_t) -1;      /* invalid strip */
173         tif->tif_row = (uint32) -1;             /* read/write pre-increment */
174         tif->tif_clientdata = clientdata;
175         if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
176                 TIFFErrorExt(clientdata, module,
177                           "One of the client procedures is NULL pointer.");
178                 goto bad2;
179         }
180         tif->tif_readproc = readproc;
181         tif->tif_writeproc = writeproc;
182         tif->tif_seekproc = seekproc;
183         tif->tif_closeproc = closeproc;
184         tif->tif_sizeproc = sizeproc;
185         if (mapproc)
186                 tif->tif_mapproc = mapproc;
187         else
188                 tif->tif_mapproc = _tiffDummyMapProc;
189         if (unmapproc)
190                 tif->tif_unmapproc = unmapproc;
191         else
192                 tif->tif_unmapproc = _tiffDummyUnmapProc;
193         _TIFFSetDefaultCompressionState(tif);   /* setup default state */
194         /*
195          * Default is to return data MSB2LSB and enable the
196          * use of memory-mapped files and strip chopping when
197          * a file is opened read-only.
198          */
199         tif->tif_flags = FILLORDER_MSB2LSB;
200         if (m == O_RDONLY )
201                 tif->tif_flags |= TIFF_MAPPED;
202
203 #ifdef STRIPCHOP_DEFAULT
204         if (m == O_RDONLY || m == O_RDWR)
205                 tif->tif_flags |= STRIPCHOP_DEFAULT;
206 #endif
207
208         /*
209          * Process library-specific flags in the open mode string.
210          * The following flags may be used to control intrinsic library
211          * behaviour that may or may not be desirable (usually for
212          * compatibility with some application that claims to support
213          * TIFF but only supports some braindead idea of what the
214          * vendor thinks TIFF is):
215          *
216          * 'l'          use little-endian byte order for creating a file
217          * 'b'          use big-endian byte order for creating a file
218          * 'L'          read/write information using LSB2MSB bit order
219          * 'B'          read/write information using MSB2LSB bit order
220          * 'H'          read/write information using host bit order
221          * 'M'          enable use of memory-mapped files when supported
222          * 'm'          disable use of memory-mapped files
223          * 'C'          enable strip chopping support when reading
224          * 'c'          disable strip chopping support
225          * 'h'          read TIFF header only, do not load the first IFD
226          *
227          * The use of the 'l' and 'b' flags is strongly discouraged.
228          * These flags are provided solely because numerous vendors,
229          * typically on the PC, do not correctly support TIFF; they
230          * only support the Intel little-endian byte order.  This
231          * support is not configured by default because it supports
232          * the violation of the TIFF spec that says that readers *MUST*
233          * support both byte orders.  It is strongly recommended that
234          * you not use this feature except to deal with busted apps
235          * that write invalid TIFF.  And even in those cases you should
236          * bang on the vendors to fix their software.
237          *
238          * The 'L', 'B', and 'H' flags are intended for applications
239          * that can optimize operations on data by using a particular
240          * bit order.  By default the library returns data in MSB2LSB
241          * bit order for compatibiltiy with older versions of this
242          * library.  Returning data in the bit order of the native cpu
243          * makes the most sense but also requires applications to check
244          * the value of the FillOrder tag; something they probably do
245          * not do right now.
246          *
247          * The 'M' and 'm' flags are provided because some virtual memory
248          * systems exhibit poor behaviour when large images are mapped.
249          * These options permit clients to control the use of memory-mapped
250          * files on a per-file basis.
251          *
252          * The 'C' and 'c' flags are provided because the library support
253          * for chopping up large strips into multiple smaller strips is not
254          * application-transparent and as such can cause problems.  The 'c'
255          * option permits applications that only want to look at the tags,
256          * for example, to get the unadulterated TIFF tag information.
257          */
258         for (cp = mode; *cp; cp++)
259                 switch (*cp) {
260                 case 'b':
261 #ifndef WORDS_BIGENDIAN
262                     if (m&O_CREAT)
263                                 tif->tif_flags |= TIFF_SWAB;
264 #endif
265                         break;
266                 case 'l':
267 #ifdef WORDS_BIGENDIAN
268                         if ((m&O_CREAT))
269                                 tif->tif_flags |= TIFF_SWAB;
270 #endif
271                         break;
272                 case 'B':
273                         tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
274                             FILLORDER_MSB2LSB;
275                         break;
276                 case 'L':
277                         tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
278                             FILLORDER_LSB2MSB;
279                         break;
280                 case 'H':
281                         tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
282                             HOST_FILLORDER;
283                         break;
284                 case 'M':
285                         if (m == O_RDONLY)
286                                 tif->tif_flags |= TIFF_MAPPED;
287                         break;
288                 case 'm':
289                         if (m == O_RDONLY)
290                                 tif->tif_flags &= ~TIFF_MAPPED;
291                         break;
292                 case 'C':
293                         if (m == O_RDONLY)
294                                 tif->tif_flags |= TIFF_STRIPCHOP;
295                         break;
296                 case 'c':
297                         if (m == O_RDONLY)
298                                 tif->tif_flags &= ~TIFF_STRIPCHOP;
299                         break;
300                 case 'h':
301                         tif->tif_flags |= TIFF_HEADERONLY;
302                         break;
303                 }
304         /*
305          * Read in TIFF header.
306          */
307         if ((m & O_TRUNC) ||
308             !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
309                 if (tif->tif_mode == O_RDONLY) {
310                         TIFFErrorExt(tif->tif_clientdata, name,
311                                      "Cannot read TIFF header");
312                         goto bad;
313                 }
314                 /*
315                  * Setup header and write.
316                  */
317 #ifdef WORDS_BIGENDIAN
318                 tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
319                     ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
320 #else
321                 tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
322                     ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
323 #endif
324                 tif->tif_header.tiff_version = TIFF_VERSION;
325                 if (tif->tif_flags & TIFF_SWAB)
326                         TIFFSwabShort(&tif->tif_header.tiff_version);
327                 tif->tif_header.tiff_diroff = 0;        /* filled in later */
328
329
330                 /*
331                  * The doc for "fopen" for some STD_C_LIBs says that if you 
332                  * open a file for modify ("+"), then you must fseek (or 
333                  * fflush?) between any freads and fwrites.  This is not
334                  * necessary on most systems, but has been shown to be needed
335                  * on Solaris. 
336                  */
337                 TIFFSeekFile( tif, 0, SEEK_SET );
338                
339                 if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
340                         TIFFErrorExt(tif->tif_clientdata, name,
341                                      "Error writing TIFF header");
342                         goto bad;
343                 }
344                 /*
345                  * Setup the byte order handling.
346                  */
347                 TIFFInitOrder(tif, tif->tif_header.tiff_magic);
348                 /*
349                  * Setup default directory.
350                  */
351                 if (!TIFFDefaultDirectory(tif))
352                         goto bad;
353                 tif->tif_diroff = 0;
354                 tif->tif_dirlist = NULL;
355                 tif->tif_dirlistsize = 0;
356                 tif->tif_dirnumber = 0;
357                 return (tif);
358         }
359         /*
360          * Setup the byte order handling.
361          */
362         if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
363             tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN
364 #if MDI_SUPPORT
365             &&
366 #if HOST_BIGENDIAN
367             tif->tif_header.tiff_magic != MDI_BIGENDIAN
368 #else
369             tif->tif_header.tiff_magic != MDI_LITTLEENDIAN
370 #endif
371             ) {
372                 TIFFErrorExt(tif->tif_clientdata, name,
373                         "Not a TIFF or MDI file, bad magic number %d (0x%x)",
374 #else
375             ) {
376                 TIFFErrorExt(tif->tif_clientdata, name,
377                              "Not a TIFF file, bad magic number %d (0x%x)",
378 #endif
379                     tif->tif_header.tiff_magic,
380                     tif->tif_header.tiff_magic);
381                 goto bad;
382         }
383         TIFFInitOrder(tif, tif->tif_header.tiff_magic);
384         /*
385          * Swap header if required.
386          */
387         if (tif->tif_flags & TIFF_SWAB) {
388                 TIFFSwabShort(&tif->tif_header.tiff_version);
389                 TIFFSwabLong(&tif->tif_header.tiff_diroff);
390         }
391         /*
392          * Now check version (if needed, it's been byte-swapped).
393          * Note that this isn't actually a version number, it's a
394          * magic number that doesn't change (stupid).
395          */
396         if (tif->tif_header.tiff_version == TIFF_BIGTIFF_VERSION) {
397                 TIFFErrorExt(tif->tif_clientdata, name,
398                           "This is a BigTIFF file.  This format not supported\n"
399                           "by this version of libtiff." );
400                 goto bad;
401         }
402         if (tif->tif_header.tiff_version != TIFF_VERSION) {
403                 TIFFErrorExt(tif->tif_clientdata, name,
404                     "Not a TIFF file, bad version number %d (0x%x)",
405                     tif->tif_header.tiff_version,
406                     tif->tif_header.tiff_version);
407                 goto bad;
408         }
409         tif->tif_flags |= TIFF_MYBUFFER;
410         tif->tif_rawcp = tif->tif_rawdata = 0;
411         tif->tif_rawdatasize = 0;
412
413         /*
414          * Sometimes we do not want to read the first directory (for example,
415          * it may be broken) and want to proceed to other directories. I this
416          * case we use the TIFF_HEADERONLY flag to open file and return
417          * immediately after reading TIFF header.
418          */
419         if (tif->tif_flags & TIFF_HEADERONLY)
420                 return (tif);
421
422         /*
423          * Setup initial directory.
424          */
425         switch (mode[0]) {
426         case 'r':
427                 tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
428                 /*
429                  * Try to use a memory-mapped file if the client
430                  * has not explicitly suppressed usage with the
431                  * 'm' flag in the open mode (see above).
432                  */
433                 if ((tif->tif_flags & TIFF_MAPPED) &&
434         !TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
435                         tif->tif_flags &= ~TIFF_MAPPED;
436                 if (TIFFReadDirectory(tif)) {
437                         tif->tif_rawcc = -1;
438                         tif->tif_flags |= TIFF_BUFFERSETUP;
439                         return (tif);
440                 }
441                 break;
442         case 'a':
443                 /*
444                  * New directories are automatically append
445                  * to the end of the directory chain when they
446                  * are written out (see TIFFWriteDirectory).
447                  */
448                 if (!TIFFDefaultDirectory(tif))
449                         goto bad;
450                 return (tif);
451         }
452 bad:
453         tif->tif_mode = O_RDONLY;       /* XXX avoid flush */
454         TIFFCleanup(tif);
455 bad2:
456         return ((TIFF*)0);
457 }
458
459 /*
460  * Query functions to access private data.
461  */
462
463 /*
464  * Return open file's name.
465  */
466 const char *
467 TIFFFileName(TIFF* tif)
468 {
469         return (tif->tif_name);
470 }
471
472 /*
473  * Set the file name.
474  */
475 const char *
476 TIFFSetFileName(TIFF* tif, const char *name)
477 {
478         const char* old_name = tif->tif_name;
479         tif->tif_name = (char *)name;
480         return (old_name);
481 }
482
483 /*
484  * Return open file's I/O descriptor.
485  */
486 int
487 TIFFFileno(TIFF* tif)
488 {
489         return (tif->tif_fd);
490 }
491
492 /*
493  * Set open file's I/O descriptor, and return previous value.
494  */
495 int
496 TIFFSetFileno(TIFF* tif, int fd)
497 {
498         int old_fd = tif->tif_fd;
499         tif->tif_fd = fd;
500         return old_fd;
501 }
502
503 /*
504  * Return open file's clientdata.
505  */
506 thandle_t
507 TIFFClientdata(TIFF* tif)
508 {
509         return (tif->tif_clientdata);
510 }
511
512 /*
513  * Set open file's clientdata, and return previous value.
514  */
515 thandle_t
516 TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
517 {
518         thandle_t m = tif->tif_clientdata;
519         tif->tif_clientdata = newvalue;
520         return m;
521 }
522
523 /*
524  * Return read/write mode.
525  */
526 int
527 TIFFGetMode(TIFF* tif)
528 {
529         return (tif->tif_mode);
530 }
531
532 /*
533  * Return read/write mode.
534  */
535 int
536 TIFFSetMode(TIFF* tif, int mode)
537 {
538         int old_mode = tif->tif_mode;
539         tif->tif_mode = mode;
540         return (old_mode);
541 }
542
543 /*
544  * Return nonzero if file is organized in
545  * tiles; zero if organized as strips.
546  */
547 int
548 TIFFIsTiled(TIFF* tif)
549 {
550         return (isTiled(tif));
551 }
552
553 /*
554  * Return current row being read/written.
555  */
556 uint32
557 TIFFCurrentRow(TIFF* tif)
558 {
559         return (tif->tif_row);
560 }
561
562 /*
563  * Return index of the current directory.
564  */
565 tdir_t
566 TIFFCurrentDirectory(TIFF* tif)
567 {
568         return (tif->tif_curdir);
569 }
570
571 /*
572  * Return current strip.
573  */
574 tstrip_t
575 TIFFCurrentStrip(TIFF* tif)
576 {
577         return (tif->tif_curstrip);
578 }
579
580 /*
581  * Return current tile.
582  */
583 ttile_t
584 TIFFCurrentTile(TIFF* tif)
585 {
586         return (tif->tif_curtile);
587 }
588
589 /*
590  * Return nonzero if the file has byte-swapped data.
591  */
592 int
593 TIFFIsByteSwapped(TIFF* tif)
594 {
595         return ((tif->tif_flags & TIFF_SWAB) != 0);
596 }
597
598 /*
599  * Return nonzero if the data is returned up-sampled.
600  */
601 int
602 TIFFIsUpSampled(TIFF* tif)
603 {
604         return (isUpSampled(tif));
605 }
606
607 /*
608  * Return nonzero if the data is returned in MSB-to-LSB bit order.
609  */
610 int
611 TIFFIsMSB2LSB(TIFF* tif)
612 {
613         return (isFillOrder(tif, FILLORDER_MSB2LSB));
614 }
615
616 /*
617  * Return nonzero if given file was written in big-endian order.
618  */
619 int
620 TIFFIsBigEndian(TIFF* tif)
621 {
622         return (tif->tif_header.tiff_magic == TIFF_BIGENDIAN);
623 }
624
625 /*
626  * Return pointer to file read method.
627  */
628 TIFFReadWriteProc
629 TIFFGetReadProc(TIFF* tif)
630 {
631         return (tif->tif_readproc);
632 }
633
634 /*
635  * Return pointer to file write method.
636  */
637 TIFFReadWriteProc
638 TIFFGetWriteProc(TIFF* tif)
639 {
640         return (tif->tif_writeproc);
641 }
642
643 /*
644  * Return pointer to file seek method.
645  */
646 TIFFSeekProc
647 TIFFGetSeekProc(TIFF* tif)
648 {
649         return (tif->tif_seekproc);
650 }
651
652 /*
653  * Return pointer to file close method.
654  */
655 TIFFCloseProc
656 TIFFGetCloseProc(TIFF* tif)
657 {
658         return (tif->tif_closeproc);
659 }
660
661 /*
662  * Return pointer to file size requesting method.
663  */
664 TIFFSizeProc
665 TIFFGetSizeProc(TIFF* tif)
666 {
667         return (tif->tif_sizeproc);
668 }
669
670 /*
671  * Return pointer to memory mapping method.
672  */
673 TIFFMapFileProc
674 TIFFGetMapFileProc(TIFF* tif)
675 {
676         return (tif->tif_mapproc);
677 }
678
679 /*
680  * Return pointer to memory unmapping method.
681  */
682 TIFFUnmapFileProc
683 TIFFGetUnmapFileProc(TIFF* tif)
684 {
685         return (tif->tif_unmapproc);
686 }
687
688 /* vim: set ts=8 sts=8 sw=8 noet: */
689 /*
690  * Local Variables:
691  * mode: c
692  * c-basic-offset: 8
693  * fill-column: 78
694  * End:
695  */