dll/3rdparty/libtiff/tif_win32.c

   1 /* $Id: tif_win32.c,v 1.39 2011-12-22 17:07:57 bfriesen 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 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 tmsize_t
  36 _tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
  37 {
  38         /* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes
  39          * 32bit sizes, so we loop through the data in suitable 32bit sized
  40          * chunks */
  41         uint8* ma;
  42         uint64 mb;
  43         DWORD n;
  44         DWORD o;
  45         tmsize_t p;
  46         ma=(uint8*)buf;
  47         mb=size;
  48         p=0;
  49         while (mb>0)
  50         {
  51                 n=0x80000000UL;
  52                 if ((uint64)n>mb)
  53                         n=(DWORD)mb;
  54                 if (!ReadFile(fd,(LPVOID)ma,n,&o,NULL))
  55                         return(0);
  56                 ma+=o;
  57                 mb-=o;
  58                 p+=o;
  59                 if (o!=n)
  60                         break;
  61         }
  62         return(p);
  63 }
  64
  65 static tmsize_t
  66 _tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
  67 {
  68         /* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes
  69          * 32bit sizes, so we loop through the data in suitable 32bit sized
  70          * chunks */
  71         uint8* ma;
  72         uint64 mb;
  73         DWORD n;
  74         DWORD o;
  75         tmsize_t p;
  76         ma=(uint8*)buf;
  77         mb=size;
  78         p=0;
  79         while (mb>0)
  80         {
  81                 n=0x80000000UL;
  82                 if ((uint64)n>mb)
  83                         n=(DWORD)mb;
  84                 if (!WriteFile(fd,(LPVOID)ma,n,&o,NULL))
  85                         return(0);
  86                 ma+=o;
  87                 mb-=o;
  88                 p+=o;
  89                 if (o!=n)
  90                         break;
  91         }
  92         return(p);
  93 }
  94
  95 static uint64
  96 _tiffSeekProc(thandle_t fd, uint64 off, int whence)
  97 {
  98         LARGE_INTEGER offli;
  99         DWORD dwMoveMethod;
 100         offli.QuadPart = off;
 101         switch(whence)
 102         {
 103                 case SEEK_SET:
 104                         dwMoveMethod = FILE_BEGIN;
 105                         break;
 106                 case SEEK_CUR:
 107                         dwMoveMethod = FILE_CURRENT;
 108                         break;
 109                 case SEEK_END:
 110                         dwMoveMethod = FILE_END;
 111                         break;
 112                 default:
 113                         dwMoveMethod = FILE_BEGIN;
 114                         break;
 115         }
 116         offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod);
 117         if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR))
 118                 offli.QuadPart=0;
 119         return(offli.QuadPart);
 120 }
 121
 122 static int
 123 _tiffCloseProc(thandle_t fd)
 124 {
 125         return (CloseHandle(fd) ? 0 : -1);
 126 }
 127
 128 static uint64
 129 _tiffSizeProc(thandle_t fd)
 130 {
 131         ULARGE_INTEGER m;
 132         m.LowPart=GetFileSize(fd,&m.HighPart);
 133         return(m.QuadPart);
 134 }
 135
 136 static int
 137 _tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
 138 {
 139         (void) fd;
 140         (void) pbase;
 141         (void) psize;
 142         return (0);
 143 }
 144
 145 /*
 146  * From "Hermann Josef Hill" <lhill@rhein-zeitung.de>:
 147  *
 148  * Windows uses both a handle and a pointer for file mapping,
 149  * but according to the SDK documentation and Richter's book
 150  * "Advanced Windows Programming" it is safe to free the handle
 151  * after obtaining the file mapping pointer
 152  *
 153  * This removes a nasty OS dependency and cures a problem
 154  * with Visual C++ 5.0
 155  */
 156 static int
 157 _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
 158 {
 159         uint64 size;
 160         tmsize_t sizem;
 161         HANDLE hMapFile;
 162
 163         size = _tiffSizeProc(fd);
 164         sizem = (tmsize_t)size;
 165         if ((uint64)sizem!=size)
 166                 return (0);
 167
 168         /* By passing in 0 for the maximum file size, it specifies that we
 169            create a file mapping object for the full file size. */
 170         hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL);
 171         if (hMapFile == NULL)
 172                 return (0);
 173         *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
 174         CloseHandle(hMapFile);
 175         if (*pbase == NULL)
 176                 return (0);
 177         *psize = size;
 178         return(1);
 179 }
 180
 181 static void
 182 _tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
 183 {
 184         (void) fd;
 185         (void) base;
 186         (void) size;
 187 }
 188
 189 static void
 190 _tiffUnmapProc(thandle_t fd, void* base, toff_t size)
 191 {
 192         (void) fd;
 193         (void) size;
 194         UnmapViewOfFile(base);
 195 }
 196
 197 /*
 198  * Open a TIFF file descriptor for read/writing.
 199  * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
 200  * string, which forces the file to be opened unmapped.
 201  */
 202 TIFF*
 203 TIFFFdOpen(int ifd, const char* name, const char* mode)
 204 {
 205         TIFF* tif;
 206         int fSuppressMap;
 207         int m;
 208         fSuppressMap=0;
 209         for (m=0; mode[m]!=0; m++)
 210         {
 211                 if (mode[m]=='u')
 212                 {
 213                         fSuppressMap=1;
 214                         break;
 215                 }
 216         }
 217         tif = TIFFClientOpen(name, mode, (thandle_t)ifd,
 218                         _tiffReadProc, _tiffWriteProc,
 219                         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
 220                         fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
 221                         fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
 222         if (tif)
 223                 tif->tif_fd = ifd;
 224         return (tif);
 225 }
 226
 227 #ifndef _WIN32_WCE
 228
 229 /*
 230  * Open a TIFF file for read/writing.
 231  */
 232 TIFF*
 233 TIFFOpen(const char* name, const char* mode)
 234 {
 235         static const char module[] = "TIFFOpen";
 236         thandle_t fd;
 237         int m;
 238         DWORD dwMode;
 239         TIFF* tif;
 240
 241         m = _TIFFgetMode(mode, module);
 242
 243         switch(m) {
 244                 case O_RDONLY:                  dwMode = OPEN_EXISTING; break;
 245                 case O_RDWR:                    dwMode = OPEN_ALWAYS;   break;
 246                 case O_RDWR|O_CREAT:            dwMode = OPEN_ALWAYS;   break;
 247                 case O_RDWR|O_TRUNC:            dwMode = CREATE_ALWAYS; break;
 248                 case O_RDWR|O_CREAT|O_TRUNC:    dwMode = CREATE_ALWAYS; break;
 249                 default:                        return ((TIFF*)0);
 250         }
 251
 252         fd = (thandle_t)CreateFileA(name,
 253                 (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
 254                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
 255                 (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
 256                 NULL);
 257         if (fd == INVALID_HANDLE_VALUE) {
 258                 TIFFErrorExt(0, module, "%s: Cannot open", name);
 259                 return ((TIFF *)0);
 260         }
 261
 262         tif = TIFFFdOpen((int)fd, name, mode);
 263         if(!tif)
 264                 CloseHandle(fd);
 265         return tif;
 266 }
 267
 268 /*
 269  * Open a TIFF file with a Unicode filename, for read/writing.
 270  */
 271 TIFF*
 272 TIFFOpenW(const wchar_t* name, const char* mode)
 273 {
 274         static const char module[] = "TIFFOpenW";
 275         thandle_t fd;
 276         int m;
 277         DWORD dwMode;
 278         int mbsize;
 279         char *mbname;
 280         TIFF *tif;
 281
 282         m = _TIFFgetMode(mode, module);
 283
 284         switch(m) {
 285                 case O_RDONLY:                  dwMode = OPEN_EXISTING; break;
 286                 case O_RDWR:                    dwMode = OPEN_ALWAYS;   break;
 287                 case O_RDWR|O_CREAT:            dwMode = OPEN_ALWAYS;   break;
 288                 case O_RDWR|O_TRUNC:            dwMode = CREATE_ALWAYS; break;
 289                 case O_RDWR|O_CREAT|O_TRUNC:    dwMode = CREATE_ALWAYS; break;
 290                 default:                        return ((TIFF*)0);
 291         }
 292
 293         fd = (thandle_t)CreateFileW(name,
 294                 (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
 295                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
 296                 (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
 297                 NULL);
 298         if (fd == INVALID_HANDLE_VALUE) {
 299                 TIFFErrorExt(0, module, "%S: Cannot open", name);
 300                 return ((TIFF *)0);
 301         }
 302
 303         mbname = NULL;
 304         mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
 305         if (mbsize > 0) {
 306                 mbname = (char *)_TIFFmalloc(mbsize);
 307                 if (!mbname) {
 308                         TIFFErrorExt(0, module,
 309                         "Can't allocate space for filename conversion buffer");
 310                         return ((TIFF*)0);
 311                 }
 312
 313                 WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
 314                                     NULL, NULL);
 315         }
 316
 317         tif = TIFFFdOpen((int)fd,
 318                          (mbname != NULL) ? mbname : "<unknown>", mode);
 319         if(!tif)
 320                 CloseHandle(fd);
 321
 322         _TIFFfree(mbname);
 323
 324         return tif;
 325 }
 326
 327 #endif /* ndef _WIN32_WCE */
 328
 329 void*
 330 _TIFFmalloc(tmsize_t s)
 331 {
 332         return (malloc((size_t) s));
 333 }
 334
 335 void
 336 _TIFFfree(void* p)
 337 {
 338         free(p);
 339 }
 340
 341 void*
 342 _TIFFrealloc(void* p, tmsize_t s)
 343 {
 344         return (realloc(p, (size_t) s));
 345 }
 346
 347 void
 348 _TIFFmemset(void* p, int v, tmsize_t c)
 349 {
 350         memset(p, v, (size_t) c);
 351 }
 352
 353 void
 354 _TIFFmemcpy(void* d, const void* s, tmsize_t c)
 355 {
 356         memcpy(d, s, (size_t) c);
 357 }
 358
 359 int
 360 _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
 361 {
 362         return (memcmp(p1, p2, (size_t) c));
 363 }
 364
 365 #ifndef _WIN32_WCE
 366
 367 #if (_MSC_VER < 1500)
 368 #  define vsnprintf _vsnprintf
 369 #endif
 370
 371 static void
 372 Win32WarningHandler(const char* module, const char* fmt, va_list ap)
 373 {
 374 #ifndef TIF_PLATFORM_CONSOLE
 375         LPTSTR szTitle;
 376         LPTSTR szTmp;
 377         LPCTSTR szTitleText = "%s Warning";
 378         LPCTSTR szDefaultModule = "LIBTIFF";
 379         LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
 380         SIZE_T nBufSize = (strlen(szTmpModule) +
 381                         strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char);
 382
 383         if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL)
 384                 return;
 385         sprintf(szTitle, szTitleText, szTmpModule);
 386         szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
 387         vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap);
 388         MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
 389         LocalFree(szTitle);
 390
 391         return;
 392 #else
 393         if (module != NULL)
 394                 fprintf(stderr, "%s: ", module);
 395         fprintf(stderr, "Warning, ");
 396         vfprintf(stderr, fmt, ap);
 397         fprintf(stderr, ".\n");
 398 #endif
 399 }
 400 TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
 401
 402 static void
 403 Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
 404 {
 405 #ifndef TIF_PLATFORM_CONSOLE
 406         LPTSTR szTitle;
 407         LPTSTR szTmp;
 408         LPCTSTR szTitleText = "%s Error";
 409         LPCTSTR szDefaultModule = "LIBTIFF";
 410         LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
 411         SIZE_T nBufSize = (strlen(szTmpModule) +
 412                         strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char);
 413
 414         if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL)
 415                 return;
 416         sprintf(szTitle, szTitleText, szTmpModule);
 417         szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
 418         vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap);
 419         MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
 420         LocalFree(szTitle);
 421         return;
 422 #else
 423         if (module != NULL)
 424                 fprintf(stderr, "%s: ", module);
 425         vfprintf(stderr, fmt, ap);
 426         fprintf(stderr, ".\n");
 427 #endif
 428 }
 429 TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
 430
 431 #endif /* ndef _WIN32_WCE */
 432
 433 /* vim: set ts=8 sts=8 sw=8 noet: */
 434 /*
 435  * Local Variables:
 436  * mode: c
 437  * c-basic-offset: 8
 438  * fill-column: 78
 439  * End:
 440  */