src/tiff/libtiff/tif_win32.c

   1 /* $Id$ */
   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 "tiffiop.h"
  32
  33 #include <windows.h>
  34
  35 static tsize_t
  36 _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  37 {
  38         DWORD dwSizeRead;
  39         if (!ReadFile(fd, buf, size, &dwSizeRead, NULL))
  40                 return(0);
  41         return ((tsize_t) dwSizeRead);
  42 }
  43
  44 static tsize_t
  45 _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  46 {
  47         DWORD dwSizeWritten;
  48         if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL))
  49                 return(0);
  50         return ((tsize_t) dwSizeWritten);
  51 }
  52
  53 static toff_t
  54 _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  55 {
  56         DWORD dwMoveMethod, dwMoveHigh;
  57
  58         /* we use this as a special code, so avoid accepting it */
  59         if( off == 0xFFFFFFFF )
  60             return 0xFFFFFFFF;
  61
  62         switch(whence)
  63         {
  64         case SEEK_SET:
  65                 dwMoveMethod = FILE_BEGIN;
  66                 break;
  67         case SEEK_CUR:
  68                 dwMoveMethod = FILE_CURRENT;
  69                 break;
  70         case SEEK_END:
  71                 dwMoveMethod = FILE_END;
  72                 break;
  73         default:
  74                 dwMoveMethod = FILE_BEGIN;
  75                 break;
  76         }
  77         dwMoveHigh = 0;
  78         return ((toff_t)SetFilePointer(fd, (LONG) off, (PLONG)&dwMoveHigh,
  79                                        dwMoveMethod));
  80 }
  81
  82 static int
  83 _tiffCloseProc(thandle_t fd)
  84 {
  85         return (CloseHandle(fd) ? 0 : -1);
  86 }
  87
  88 static toff_t
  89 _tiffSizeProc(thandle_t fd)
  90 {
  91         return ((toff_t)GetFileSize(fd, NULL));
  92 }
  93
  94 #ifdef __BORLANDC__
  95 #pragma argsused
  96 #endif
  97 static int
  98 _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  99 {
 100         return (0);
 101 }
 102
 103 /*
 104  * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>:
 105  *
 106  * Windows uses both a handle and a pointer for file mapping,
 107  * but according to the SDK documentation and Richter's book
 108  * "Advanced Windows Programming" it is safe to free the handle
 109  * after obtaining the file mapping pointer
 110  *
 111  * This removes a nasty OS dependency and cures a problem
 112  * with Visual C++ 5.0
 113  */
 114 static int
 115 _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
 116 {
 117         toff_t size;
 118         HANDLE hMapFile;
 119
 120         if ((size = _tiffSizeProc(fd)) == 0xFFFFFFFF)
 121                 return (0);
 122         hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL);
 123         if (hMapFile == NULL)
 124                 return (0);
 125         *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
 126         CloseHandle(hMapFile);
 127         if (*pbase == NULL)
 128                 return (0);
 129         *psize = size;
 130         return(1);
 131 }
 132
 133 #ifdef __BORLANDC__
 134 #pragma argsused
 135 #endif
 136 static void
 137 _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 138 {
 139 }
 140
 141 static void
 142 _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
 143 {
 144         UnmapViewOfFile(base);
 145 }
 146
 147 /*
 148  * Open a TIFF file descriptor for read/writing.
 149  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
 150  * string, which forces the file to be opened unmapped.
 151  */
 152 TIFF*
 153 TIFFFdOpen(int ifd, const char* name, const char* mode)
 154 {
 155         TIFF* tif;
 156         BOOL fSuppressMap = (mode[1] == 'u' || (mode[1]!=0 && mode[2] == 'u'));
 157
 158         tif = TIFFClientOpen(name, mode, (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  */
 171 TIFF*
 172 TIFFOpen(const char* name, const char* mode)
 173 {
 174         static const char module[] = "TIFFOpen";
 175         thandle_t fd;
 176         int m;
 177         DWORD dwMode;
 178         TIFF* tif;
 179
 180         m = _TIFFgetMode(mode, module);
 181
 182         switch(m)
 183         {
 184         case O_RDONLY:
 185                 dwMode = OPEN_EXISTING;
 186                 break;
 187         case O_RDWR:
 188                 dwMode = OPEN_ALWAYS;
 189                 break;
 190         case O_RDWR|O_CREAT:
 191                 dwMode = OPEN_ALWAYS;
 192                 break;
 193         case O_RDWR|O_TRUNC:
 194                 dwMode = CREATE_ALWAYS;
 195                 break;
 196         case O_RDWR|O_CREAT|O_TRUNC:
 197                 dwMode = CREATE_ALWAYS;
 198                 break;
 199         default:
 200                 return ((TIFF*)0);
 201         }
 202         fd = (thandle_t)CreateFileA(name,
 203                 (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
 204                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
 205                 (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
 206                 NULL);
 207         if (fd == INVALID_HANDLE_VALUE) {
 208                 TIFFErrorExt(0, module, "%s: Cannot open", name);
 209                 return ((TIFF *)0);
 210         }
 211
 212         tif = TIFFFdOpen((int)fd, name, mode);
 213         if(!tif)
 214                 CloseHandle(fd);
 215         return tif;
 216 }
 217
 218 /*
 219  * Open a TIFF file with a Unicode filename, for read/writing.
 220  */
 221 TIFF*
 222 TIFFOpenW(const wchar_t* name, const char* mode)
 223 {
 224         static const char module[] = "TIFFOpenW";
 225         thandle_t fd;
 226         int m;
 227         DWORD dwMode;
 228         int mbsize;
 229         char *mbname;
 230         TIFF *tif;
 231
 232         m = _TIFFgetMode(mode, module);
 233
 234         switch(m) {
 235                 case O_RDONLY:                  dwMode = OPEN_EXISTING; break;
 236                 case O_RDWR:                    dwMode = OPEN_ALWAYS;   break;
 237                 case O_RDWR|O_CREAT:            dwMode = OPEN_ALWAYS;   break;
 238                 case O_RDWR|O_TRUNC:            dwMode = CREATE_ALWAYS; break;
 239                 case O_RDWR|O_CREAT|O_TRUNC:    dwMode = CREATE_ALWAYS; break;
 240                 default:                        return ((TIFF*)0);
 241         }
 242
 243         fd = (thandle_t)CreateFileW(name,
 244                 (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
 245                 FILE_SHARE_READ, NULL, dwMode,
 246                 (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
 247                 NULL);
 248         if (fd == INVALID_HANDLE_VALUE) {
 249                 TIFFErrorExt(0, module, "%S: Cannot open", name);
 250                 return ((TIFF *)0);
 251         }
 252
 253         mbname = NULL;
 254         mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
 255         if (mbsize > 0) {
 256                 mbname = (char *)_TIFFmalloc(mbsize);
 257                 if (!mbname) {
 258                         TIFFErrorExt(0, module,
 259                         "Can't allocate space for filename conversion buffer");
 260                         return ((TIFF*)0);
 261                 }
 262
 263                 WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
 264                                     NULL, NULL);
 265         }
 266
 267         tif = TIFFFdOpen((int)fd,
 268                          (mbname != NULL) ? mbname : "<unknown>", mode);
 269         if(!tif)
 270                 CloseHandle(fd);
 271
 272         _TIFFfree(mbname);
 273
 274         return tif;
 275 }
 276
 277 tdata_t
 278 _TIFFmalloc(tsize_t s)
 279 {
 280         return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
 281 }
 282
 283 void
 284 _TIFFfree(tdata_t p)
 285 {
 286         GlobalFree(p);
 287         return;
 288 }
 289
 290 tdata_t
 291 _TIFFrealloc(tdata_t p, tsize_t s)
 292 {
 293         void* pvTmp;
 294         tsize_t old;
 295
 296         if(p == NULL)
 297                 return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
 298
 299         old = GlobalSize(p);
 300
 301         if (old>=s) {
 302                 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
 303                         CopyMemory(pvTmp, p, s);
 304                         GlobalFree(p);
 305                 }
 306         } else {
 307                 if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
 308                         CopyMemory(pvTmp, p, old);
 309                         GlobalFree(p);
 310                 }
 311         }
 312         return ((tdata_t)pvTmp);
 313 }
 314
 315 void
 316 _TIFFmemset(void* p, int v, tsize_t c)
 317 {
 318         FillMemory(p, c, (BYTE)v);
 319 }
 320
 321 void
 322 _TIFFmemcpy(void* d, const tdata_t s, tsize_t c)
 323 {
 324         CopyMemory(d, s, c);
 325 }
 326
 327 int
 328 _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
 329 {
 330         register const BYTE *pb1 = (const BYTE *) p1;
 331         register const BYTE *pb2 = (const BYTE *) p2;
 332         register DWORD dwTmp = c;
 333         register int iTmp;
 334         for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++)
 335                 ;
 336         return (iTmp);
 337 }
 338
 339 static void
 340 Win32WarningHandler(const char* module, const char* fmt, va_list ap)
 341 {
 342 #ifndef TIF_PLATFORM_CONSOLE
 343         LPTSTR szTitle;
 344         LPTSTR szTmp;
 345         LPCTSTR szTitleText = "%s Warning";
 346         LPCTSTR szDefaultModule = "LIBTIFF";
 347         LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
 348         if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
 349                 strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
 350                 return;
 351         sprintf(szTitle, szTitleText, szTmpModule);
 352         szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
 353         vsprintf(szTmp, fmt, ap);
 354         MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
 355         LocalFree(szTitle);
 356         return;
 357 #else
 358         if (module != NULL)
 359                 fprintf(stderr, "%s: ", module);
 360         fprintf(stderr, "Warning, ");
 361         vfprintf(stderr, fmt, ap);
 362         fprintf(stderr, ".\n");
 363 #endif
 364 }
 365 TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
 366
 367 static void
 368 Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
 369 {
 370 #ifndef TIF_PLATFORM_CONSOLE
 371         LPTSTR szTitle;
 372         LPTSTR szTmp;
 373         LPCTSTR szTitleText = "%s Error";
 374         LPCTSTR szDefaultModule = "LIBTIFF";
 375         LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
 376         if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
 377                 strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
 378                 return;
 379         sprintf(szTitle, szTitleText, szTmpModule);
 380         szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
 381         vsprintf(szTmp, fmt, ap);
 382         MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
 383         LocalFree(szTitle);
 384         return;
 385 #else
 386         if (module != NULL)
 387                 fprintf(stderr, "%s: ", module);
 388         vfprintf(stderr, fmt, ap);
 389         fprintf(stderr, ".\n");
 390 #endif
 391 }
 392 TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
 393
 394 /* vim: set ts=8 sts=8 sw=8 noet: */