tif_win32.c File Reference

#include <precomp.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winnls.h>

Include dependency graph for tif_win32.c:

Go to the source code of this file.

Macros
#define	vsnprintf   _vsnprintf

Functions
static tmsize_t	_tiffReadProc (thandle_t fd, void *buf, tmsize_t size)
static tmsize_t	_tiffWriteProc (thandle_t fd, void *buf, tmsize_t size)
static uint64	_tiffSeekProc (thandle_t fd, uint64 off, int whence)
static int	_tiffCloseProc (thandle_t fd)
static uint64	_tiffSizeProc (thandle_t fd)
static int	_tiffDummyMapProc (thandle_t fd, void **pbase, toff_t *psize)
static int	_tiffMapProc (thandle_t fd, void **pbase, toff_t *psize)
static void	_tiffDummyUnmapProc (thandle_t fd, void *base, toff_t size)
static void	_tiffUnmapProc (thandle_t fd, void *base, toff_t size)
TIFF *	TIFFFdOpen (int ifd, const char *name, const char *mode)
TIFF *	TIFFOpen (const char *name, const char *mode)
TIFF *	TIFFOpenW (const wchar_t *name, const char *mode)
void *	_TIFFmalloc (tmsize_t s)
void *	_TIFFcalloc (tmsize_t nmemb, tmsize_t siz)
void	_TIFFfree (void *p)
void *	_TIFFrealloc (void *p, tmsize_t s)
void	_TIFFmemset (void *p, int v, tmsize_t c)
void	_TIFFmemcpy (void *d, const void *s, tmsize_t c)
int	_TIFFmemcmp (const void *p1, const void *p2, tmsize_t c)
static void	Win32WarningHandler (const char *module, const char *fmt, va_list ap)
static void	Win32ErrorHandler (const char *module, const char *fmt, va_list ap)

Variables
TIFFErrorHandler	_TIFFwarningHandler = Win32WarningHandler
TIFFErrorHandler	_TIFFerrorHandler = Win32ErrorHandler

Macro Definition Documentation

vsnprintf

#define vsnprintf   _vsnprintf

Definition at line 406 of file tif_win32.c.

Function Documentation

_TIFFcalloc()

void * _TIFFcalloc	(	tmsize_t	nmemb,
		tmsize_t	siz
	)

Definition at line 365 of file tif_win32.c.

{
    if( nmemb == 0 || siz == 0 )
        return ((void *) NULL);
 
    return calloc((size_t) nmemb, (size_t)siz);
}

_tiffCloseProc()

static int _tiffCloseProc ( thandle_t  fd )

static

Definition at line 150 of file tif_win32.c.

{
    return (CloseHandle(fd) ? 0 : -1);
}

Referenced by TIFFFdOpen().

_tiffDummyMapProc()

static int _tiffDummyMapProc ( thandle_t  fd, void **  pbase, toff_t *  psize  )

static

Definition at line 164 of file tif_win32.c.

{
    (void) fd;
    (void) pbase;
    (void) psize;
    return (0);
}

Referenced by TIFFFdOpen().

_tiffDummyUnmapProc()

static void _tiffDummyUnmapProc ( thandle_t  fd, void *  base, toff_t  size  )

static

Definition at line 209 of file tif_win32.c.

{
    (void) fd;
    (void) base;
    (void) size;
}

Referenced by TIFFFdOpen().

_TIFFfree()

void _TIFFfree

(

void *

p

)

Definition at line 374 of file tif_win32.c.

{
    free(p);
}

Referenced by TIFFOpenW().

_TIFFmalloc()

void * _TIFFmalloc

(

tmsize_t

s

)

Definition at line 357 of file tif_win32.c.

{
        if (s == 0)
                return ((void *) NULL);
 
    return (malloc((size_t) s));
}

Referenced by TIFFOpenW().

_tiffMapProc()

static int _tiffMapProc ( thandle_t  fd, void **  pbase, toff_t *  psize  )

static

Definition at line 184 of file tif_win32.c.

{
    uint64 size;
    tmsize_t sizem;
    HANDLE hMapFile;
 
    size = _tiffSizeProc(fd);
    sizem = (tmsize_t)size;
    if ((uint64)sizem!=size)
        return (0);
 
    /* By passing in 0 for the maximum file size, it specifies that we
       create a file mapping object for the full file size. */
    hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL);
    if (hMapFile == NULL)
        return (0);
    *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
    CloseHandle(hMapFile);
    if (*pbase == NULL)
        return (0);
    *psize = size;
    return(1);
}

Referenced by TIFFFdOpen().

_TIFFmemcmp()

int _TIFFmemcmp	(	const void *	p1,
		const void *	p2,
		tmsize_t	c
	)

Definition at line 398 of file tif_win32.c.

{
    return (memcmp(p1, p2, (size_t) c));
}

_TIFFmemcpy()

void _TIFFmemcpy	(	void *	d,
		const void *	s,
		tmsize_t	c
	)

Definition at line 392 of file tif_win32.c.

{
    memcpy(d, s, (size_t) c);
}

_TIFFmemset()

void _TIFFmemset	(	void *	p,
		int	v,
		tmsize_t	c
	)

Definition at line 386 of file tif_win32.c.

{
    memset(p, v, (size_t) c);
}

_tiffReadProc()

static tmsize_t _tiffReadProc ( thandle_t  fd, void *  buf, tmsize_t  size  )

static

Definition at line 63 of file tif_win32.c.

{
    /* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes
     * 32bit sizes, so we loop through the data in suitable 32bit sized
     * chunks */
    uint8* ma;
    uint64 mb;
    DWORD n;
    DWORD o;
    tmsize_t p;
    ma=(uint8*)buf;
    mb=size;
    p=0;
    while (mb>0)
    {
        n=0x80000000UL;
        if ((uint64)n>mb)
            n=(DWORD)mb;
        if (!ReadFile(fd,(LPVOID)ma,n,&o,NULL))
            return(0);
        ma+=o;
        mb-=o;
        p+=o;
        if (o!=n)
            break;
    }
    return(p);
}

Referenced by TIFFFdOpen().

_TIFFrealloc()

void * _TIFFrealloc	(	void *	p,
		tmsize_t	s
	)

Definition at line 380 of file tif_win32.c.

{
    return (realloc(p, (size_t) s));
}

_tiffSeekProc()

static uint64 _tiffSeekProc ( thandle_t  fd, uint64  off, int  whence  )

static

Definition at line 123 of file tif_win32.c.

{
    LARGE_INTEGER offli;
    DWORD dwMoveMethod;
    offli.QuadPart = off;
    switch(whence)
    {
        case SEEK_SET:
            dwMoveMethod = FILE_BEGIN;
            break;
        case SEEK_CUR:
            dwMoveMethod = FILE_CURRENT;
            break;
        case SEEK_END:
            dwMoveMethod = FILE_END;
            break;
        default:
            dwMoveMethod = FILE_BEGIN;
            break;
    }
    offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod);
    if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR))
        offli.QuadPart=0;
    return(offli.QuadPart);
}

Referenced by TIFFFdOpen().

_tiffSizeProc()

static uint64 _tiffSizeProc ( thandle_t  fd )

static

Definition at line 156 of file tif_win32.c.

{
    ULARGE_INTEGER m;
    m.LowPart=GetFileSize(fd,&m.HighPart);
    return(m.QuadPart);
}

Referenced by _tiffMapProc(), and TIFFFdOpen().

_tiffUnmapProc()

static void _tiffUnmapProc ( thandle_t  fd, void *  base, toff_t  size  )

static

Definition at line 217 of file tif_win32.c.

{
    (void) fd;
    (void) size;
    UnmapViewOfFile(base);
}

Referenced by TIFFFdOpen().

_tiffWriteProc()

static tmsize_t _tiffWriteProc ( thandle_t  fd, void *  buf, tmsize_t  size  )

static

Definition at line 93 of file tif_win32.c.

{
    /* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes
     * 32bit sizes, so we loop through the data in suitable 32bit sized
     * chunks */
    uint8* ma;
    uint64 mb;
    DWORD n;
    DWORD o;
    tmsize_t p;
    ma=(uint8*)buf;
    mb=size;
    p=0;
    while (mb>0)
    {
        n=0x80000000UL;
        if ((uint64)n>mb)
            n=(DWORD)mb;
        if (!WriteFile(fd,(LPVOID)ma,n,&o,NULL))
            return(0);
        ma+=o;
        mb-=o;
        p+=o;
        if (o!=n)
            break;
    }
    return(p);
}

Referenced by TIFFFdOpen().

TIFFFdOpen()

TIFF * TIFFFdOpen	(	int	ifd,
		const char *	name,
		const char *	mode
	)

Definition at line 230 of file tif_win32.c.

{
    TIFF* tif;
    int fSuppressMap;
    int m;
    fSuppressMap=0;
    for (m=0; mode[m]!=0; m++)
    {
        if (mode[m]=='u')
        {
            fSuppressMap=1;
            break;
        }
    }
    tif = TIFFClientOpen(name, mode, (thandle_t)ifd, /* FIXME: WIN64 cast to pointer warning */
            _tiffReadProc, _tiffWriteProc,
            _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
            fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
            fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc);
    if (tif)
        tif->tif_fd = ifd;
    return (tif);
}

Referenced by TIFFOpen(), and TIFFOpenW().

TIFFOpen()

TIFF * TIFFOpen	(	const char *	name,
		const char *	mode
	)

Definition at line 260 of file tif_win32.c.

{
    static const char module[] = "TIFFOpen";
    thandle_t fd;
    int m;
    DWORD dwMode;
    TIFF* tif;
 
    m = _TIFFgetMode(mode, module);
 
    switch(m) {
        case O_RDONLY:          dwMode = OPEN_EXISTING; break;
        case O_RDWR:            dwMode = OPEN_ALWAYS;   break;
        case O_RDWR|O_CREAT:        dwMode = OPEN_ALWAYS;   break;
        case O_RDWR|O_TRUNC:        dwMode = CREATE_ALWAYS; break;
        case O_RDWR|O_CREAT|O_TRUNC:    dwMode = CREATE_ALWAYS; break;
        default:            return ((TIFF*)0);
    }
        
    fd = (thandle_t)CreateFileA(name,
        (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
        (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
        NULL);
    if (fd == INVALID_HANDLE_VALUE) {
        TIFFErrorExt(0, module, "%s: Cannot open", name);
        return ((TIFF *)0);
    }
 
    tif = TIFFFdOpen((int)fd, name, mode);   /* FIXME: WIN64 cast from pointer to int warning */
    if(!tif)
        CloseHandle(fd);
    return tif;
}

TIFFOpenW()

TIFF * TIFFOpenW	(	const wchar_t *	name,
		const char *	mode
	)

Definition at line 299 of file tif_win32.c.

{
    static const char module[] = "TIFFOpenW";
    thandle_t fd;
    int m;
    DWORD dwMode;
    int mbsize;
    char *mbname;
    TIFF *tif;
 
    m = _TIFFgetMode(mode, module);
 
    switch(m) {
        case O_RDONLY:          dwMode = OPEN_EXISTING; break;
        case O_RDWR:            dwMode = OPEN_ALWAYS;   break;
        case O_RDWR|O_CREAT:        dwMode = OPEN_ALWAYS;   break;
        case O_RDWR|O_TRUNC:        dwMode = CREATE_ALWAYS; break;
        case O_RDWR|O_CREAT|O_TRUNC:    dwMode = CREATE_ALWAYS; break;
        default:            return ((TIFF*)0);
    }
 
    fd = (thandle_t)CreateFileW(name,
        (m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
        (m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
        NULL);
    if (fd == INVALID_HANDLE_VALUE) {
        TIFFErrorExt(0, module, "%S: Cannot open", name);
        return ((TIFF *)0);
    }
 
    mbname = NULL;
    mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
    if (mbsize > 0) {
        mbname = (char *)_TIFFmalloc(mbsize);
        if (!mbname) {
            TIFFErrorExt(0, module,
            "Can't allocate space for filename conversion buffer");
            return ((TIFF*)0);
        }
 
        WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize,
                    NULL, NULL);
    }
 
    tif = TIFFFdOpen((int)fd,    /* FIXME: WIN64 cast from pointer to int warning */
             (mbname != NULL) ? mbname : "<unknown>", mode);
    if(!tif)
        CloseHandle(fd);
 
    _TIFFfree(mbname);
 
    return tif;
}

Win32ErrorHandler()

static void Win32ErrorHandler ( const char *  module, const char *  fmt, va_list  ap  )

static

Definition at line 421 of file tif_win32.c.

{
    if (module != NULL)
        fprintf(stderr, "%s: ", module);
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, ".\n");
}

Win32WarningHandler()

static void Win32WarningHandler ( const char *  module, const char *  fmt, va_list  ap  )

static

Definition at line 410 of file tif_win32.c.

{
    if (module != NULL)
        fprintf(stderr, "%s: ", module);
    fprintf(stderr, "Warning, ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, ".\n");
}

Variable Documentation

_TIFFerrorHandler

TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler

Definition at line 428 of file tif_win32.c.

_TIFFwarningHandler

TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler

Definition at line 418 of file tif_win32.c.