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 Win32-specific Routines. Adapted from tif_unix.c 4/5/95 by 29 * Scott Wagner (wagner@itek.com), Itek Graphix, Rochester, NY USA 30 */ 31#include <windows.h> 32#include "tiffiop.h" 33 34static tsize_t 35_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size) 36{ 37 DWORD dwSizeRead; 38 if (!ReadFile(fd, buf, size, &dwSizeRead, NULL)) 39 return(0); 40 return ((tsize_t) dwSizeRead); 41} 42 43static tsize_t 44_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size) 45{ 46 DWORD dwSizeWritten; 47 if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL)) 48 return(0); 49 return ((tsize_t) dwSizeWritten); 50} 51 52static toff_t 53_tiffSeekProc(thandle_t fd, toff_t off, int whence) 54{ 55 DWORD dwMoveMethod, dwMoveHigh; 56 57 /* we use this as a special code, so avoid accepting it */ 58 if( off == 0xFFFFFFFF ) 59 return 0xFFFFFFFF; 60 61 switch(whence) 62 { 63 case SEEK_SET: 64 dwMoveMethod = FILE_BEGIN; 65 break; 66 case SEEK_CUR: 67 dwMoveMethod = FILE_CURRENT; 68 break; 69 case SEEK_END: 70 dwMoveMethod = FILE_END; 71 break; 72 default: 73 dwMoveMethod = FILE_BEGIN; 74 break; 75 } 76 dwMoveHigh = 0; 77 return ((toff_t)SetFilePointer(fd, (LONG) off, (PLONG)&dwMoveHigh, 78 dwMoveMethod)); 79} 80 81static int 82_tiffCloseProc(thandle_t fd) 83{ 84 return (CloseHandle(fd) ? 0 : -1); 85} 86 87static toff_t 88_tiffSizeProc(thandle_t fd) 89{ 90 return ((toff_t)GetFileSize(fd, NULL)); 91} 92 93#ifdef __BORLANDC__ 94#pragma argsused 95#endif 96static int 97_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) 98{ 99 return (0); 100} 101 102/* 103 * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>: 104 * 105 * Windows uses both a handle and a pointer for file mapping, 106 * but according to the SDK documentation and Richter's book 107 * "Advanced Windows Programming" it is safe to free the handle 108 * after obtaining the file mapping pointer 109 * 110 * This removes a nasty OS dependency and cures a problem 111 * with Visual C++ 5.0 112 */ 113static int 114_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize) 115{ 116 toff_t size; 117 HANDLE hMapFile; 118 119 if ((size = _tiffSizeProc(fd)) == 0xFFFFFFFF) 120 return (0); 121 hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL); 122 if (hMapFile == NULL) 123 return (0); 124 *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0); 125 CloseHandle(hMapFile); 126 if (*pbase == NULL) 127 return (0); 128 *psize = size; 129 return(1); 130} 131 132#ifdef __BORLANDC__ 133#pragma argsused 134#endif 135static void 136_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size) 137{ 138} 139 140static void 141_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size) 142{ 143 UnmapViewOfFile(base); 144} 145 146/* 147 * Open a TIFF file descriptor for read/writing. 148 * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode 149 * string, which forces the file to be opened unmapped. 150 */ 151TIFF* 152TIFFFdOpen(int ifd, const char* name, const char* mode) 153{ 154 TIFF* tif; 155 BOOL fSuppressMap = (mode[1] == 'u' || (mode[1]!=0 && mode[2] == 'u')); 156 157 tif = TIFFClientOpen(name, mode, 158 (thandle_t)ifd, 159 _tiffReadProc, _tiffWriteProc, 160 _tiffSeekProc, _tiffCloseProc, _tiffSizeProc, 161 fSuppressMap ? _tiffDummyMapProc : _tiffMapProc, 162 fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc); 163 if (tif) 164 tif->tif_fd = ifd; 165 return (tif); 166} 167 168/* 169 * Open a TIFF file for read/writing. 170 */ 171TIFF* 172TIFFOpen(const char* name, const char* mode) 173{ 174 static const char module[] = "TIFFOpen"; 175 thandle_t fd; 176 int m; 177 DWORD dwMode; 178 179 m = _TIFFgetMode(mode, module); 180 181 switch(m) 182 { 183 case O_RDONLY: 184 dwMode = OPEN_EXISTING; 185 break; 186 case O_RDWR: 187 dwMode = OPEN_ALWAYS; 188 break; 189 case O_RDWR|O_CREAT: 190 dwMode = OPEN_ALWAYS; 191 break; 192 case O_RDWR|O_TRUNC: 193 dwMode = CREATE_ALWAYS; 194 break; 195 case O_RDWR|O_CREAT|O_TRUNC: 196 dwMode = CREATE_ALWAYS; 197 break; 198 default: 199 return ((TIFF*)0); 200 } 201 fd = (thandle_t)CreateFile(name, (m == O_RDONLY) ? GENERIC_READ : 202 (GENERIC_READ | GENERIC_WRITE), FILE_SHARE_READ, NULL, dwMode, 203 (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL, NULL); 204 if (fd == INVALID_HANDLE_VALUE) { 205 TIFFError(module, "%s: Cannot open", name); 206 return ((TIFF *)0); 207 } 208 return (TIFFFdOpen((int)fd, name, mode)); 209} 210 211tdata_t 212_TIFFmalloc(tsize_t s) 213{ 214 return ((tdata_t)GlobalAlloc(GMEM_FIXED, s)); 215} 216 217void 218_TIFFfree(tdata_t p) 219{ 220 GlobalFree(p); 221 return; 222} 223 224tdata_t 225_TIFFrealloc(tdata_t p, tsize_t s) 226{ 227 void* pvTmp; 228 tsize_t old; 229 230 if(p == NULL) 231 return ((tdata_t)GlobalAlloc(GMEM_FIXED, s)); 232 233 old = GlobalSize(p); 234 235 if (old>=s) 236 { 237 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) { 238 CopyMemory(pvTmp, p, s); 239 GlobalFree(p); 240 } 241 } 242 else 243 { 244 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) { 245 CopyMemory(pvTmp, p, old); 246 GlobalFree(p); 247 } 248 } 249 return ((tdata_t)pvTmp); 250} 251 252void 253_TIFFmemset(void* p, int v, tsize_t c) 254{ 255 FillMemory(p, c, (BYTE)v); 256} 257 258void 259_TIFFmemcpy(void* d, const tdata_t s, tsize_t c) 260{ 261 CopyMemory(d, s, c); 262} 263 264int 265_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c) 266{ 267 register const BYTE *pb1 = (const BYTE *) p1; 268 register const BYTE *pb2 = (const BYTE *) p2; 269 register DWORD dwTmp = c; 270 register int iTmp; 271 for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++) 272 ; 273 return (iTmp); 274} 275 276static void 277Win32WarningHandler(const char* module, const char* fmt, va_list ap) 278{ 279#ifndef TIF_PLATFORM_CONSOLE 280 LPTSTR szTitle; 281 LPTSTR szTmp; 282 LPCTSTR szTitleText = "%s Warning"; 283 LPCTSTR szDefaultModule = "TIFFLIB"; 284 szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module; 285 if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) + 286 lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL) 287 return; 288 wsprintf(szTitle, szTitleText, szTmp); 289 szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR); 290 wvsprintf(szTmp, fmt, ap); 291 MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION); 292 LocalFree(szTitle); 293 return; 294#else 295 if (module != NULL) 296 fprintf(stderr, "%s: ", module); 297 fprintf(stderr, "Warning, "); 298 vfprintf(stderr, fmt, ap); 299 fprintf(stderr, ".\n"); 300#endif 301} 302TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler; 303 304static void 305Win32ErrorHandler(const char* module, const char* fmt, va_list ap) 306{ 307#ifndef TIF_PLATFORM_CONSOLE 308 LPTSTR szTitle; 309 LPTSTR szTmp; 310 LPCTSTR szTitleText = "%s Error"; 311 LPCTSTR szDefaultModule = "TIFFLIB"; 312 szTmp = (module == NULL) ? (LPTSTR)szDefaultModule : (LPTSTR)module; 313 if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (lstrlen(szTmp) + 314 lstrlen(szTitleText) + lstrlen(fmt) + 128)*sizeof(TCHAR))) == NULL) 315 return; 316 wsprintf(szTitle, szTitleText, szTmp); 317 szTmp = szTitle + (lstrlen(szTitle)+2)*sizeof(TCHAR); 318 wvsprintf(szTmp, fmt, ap); 319 MessageBox(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION); 320 LocalFree(szTitle); 321 return; 322#else 323 if (module != NULL) 324 fprintf(stderr, "%s: ", module); 325 vfprintf(stderr, fmt, ap); 326 fprintf(stderr, ".\n"); 327#endif 328} 329TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler; 330