home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / tiff / tif_unix.c < prev    next >
C/C++ Source or Header  |  2002-11-10  |  5KB  |  216 lines
  1. /* $Header: /pack/cvsroots/wxwindows/wxWindows/src/tiff/tif_unix.c,v 1.1.6.1 2002/11/10 13:13:57 JS 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 UNIX-specific Routines.
  29.  */
  30. #include "tiffiop.h"
  31. #include <sys/types.h>
  32. #include <unistd.h>
  33. #include <stdlib.h>
  34.  
  35. static tsize_t
  36. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  37. {
  38.     return ((tsize_t) read((int) fd, buf, (size_t) size));
  39. }
  40.  
  41. static tsize_t
  42. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  43. {
  44.     return ((tsize_t) write((int) fd, buf, (size_t) size));
  45. }
  46.  
  47. static toff_t
  48. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  49. {
  50.     return ((toff_t) lseek((int) fd, (off_t) off, whence));
  51. }
  52.  
  53. static int
  54. _tiffCloseProc(thandle_t fd)
  55. {
  56.     return (close((int) fd));
  57. }
  58.  
  59. #include <sys/stat.h>
  60.  
  61. static toff_t
  62. _tiffSizeProc(thandle_t fd)
  63. {
  64. #ifdef _AM29K
  65.     long fsize;
  66.     return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
  67. #else
  68.     struct stat sb;
  69.     return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  70. #endif
  71. }
  72.  
  73. #ifdef HAVE_MMAP
  74. #include <sys/mman.h>
  75.  
  76. static int
  77. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  78. {
  79.     toff_t size = _tiffSizeProc(fd);
  80.     if (size != (toff_t) -1) {
  81.         *pbase = (tdata_t)
  82.             mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
  83.         if (*pbase != (tdata_t) -1) {
  84.             *psize = size;
  85.             return (1);
  86.         }
  87.     }
  88.     return (0);
  89. }
  90.  
  91. static void
  92. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  93. {
  94.     (void) fd;
  95.     (void) munmap(base, (off_t) size);
  96. }
  97. #else /* !HAVE_MMAP */
  98. static int
  99. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  100. {
  101.     (void) fd; (void) pbase; (void) psize;
  102.     return (0);
  103. }
  104.  
  105. static void
  106. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  107. {
  108.     (void) fd; (void) base; (void) size;
  109. }
  110. #endif /* !HAVE_MMAP */
  111.  
  112. /*
  113.  * Open a TIFF file descriptor for read/writing.
  114.  */
  115. TIFF*
  116. TIFFFdOpen(int fd, const char* name, const char* mode)
  117. {
  118.     TIFF* tif;
  119.  
  120.     tif = TIFFClientOpen(name, mode,
  121.         (thandle_t) fd,
  122.         _tiffReadProc, _tiffWriteProc,
  123.         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  124.         _tiffMapProc, _tiffUnmapProc);
  125.     if (tif)
  126.         tif->tif_fd = fd;
  127.     return (tif);
  128. }
  129.  
  130. /*
  131.  * Open a TIFF file for read/writing.
  132.  */
  133. TIFF*
  134. TIFFOpen(const char* name, const char* mode)
  135. {
  136.     static const char module[] = "TIFFOpen";
  137.     int m, fd;
  138.  
  139.     m = _TIFFgetMode(mode, module);
  140.     if (m == -1)
  141.         return ((TIFF*)0);
  142.  
  143. /* for cygwin */        
  144. #ifdef O_BINARY
  145.         m |= O_BINARY;
  146. #endif        
  147.         
  148. #ifdef _AM29K
  149.     fd = open(name, m);
  150. #else
  151.     fd = open(name, m, 0666);
  152. #endif
  153.     if (fd < 0) {
  154.         TIFFError(module, "%s: Cannot open", name);
  155.         return ((TIFF *)0);
  156.     }
  157.     return (TIFFFdOpen(fd, name, mode));
  158. }
  159.  
  160. void*
  161. _TIFFmalloc(tsize_t s)
  162. {
  163.     return (malloc((size_t) s));
  164. }
  165.  
  166. void
  167. _TIFFfree(tdata_t p)
  168. {
  169.     free(p);
  170. }
  171.  
  172. void*
  173. _TIFFrealloc(tdata_t p, tsize_t s)
  174. {
  175.     return (realloc(p, (size_t) s));
  176. }
  177.  
  178. void
  179. _TIFFmemset(tdata_t p, int v, tsize_t c)
  180. {
  181.     memset(p, v, (size_t) c);
  182. }
  183.  
  184. void
  185. _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
  186. {
  187.     memcpy(d, s, (size_t) c);
  188. }
  189.  
  190. int
  191. _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
  192. {
  193.     return (memcmp(p1, p2, (size_t) c));
  194. }
  195.  
  196. static void
  197. unixWarningHandler(const char* module, const char* fmt, va_list ap)
  198. {
  199.     if (module != NULL)
  200.         fprintf(stderr, "%s: ", module);
  201.     fprintf(stderr, "Warning, ");
  202.     vfprintf(stderr, fmt, ap);
  203.     fprintf(stderr, ".\n");
  204. }
  205. TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
  206.  
  207. static void
  208. unixErrorHandler(const char* module, const char* fmt, va_list ap)
  209. {
  210.     if (module != NULL)
  211.         fprintf(stderr, "%s: ", module);
  212.     vfprintf(stderr, fmt, ap);
  213.     fprintf(stderr, ".\n");
  214. }
  215. TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
  216.