mirror of
https://github.com/opencv/opencv.git
synced 2024-12-11 22:59:16 +08:00
52f3f5a3f6
* libtiff upgrade to version 4.6.0 * fix tiffvers.h cmake generation * temp: force build 3rd party deps from source * remove libport.h and spintf.c * cmake fixes * don't use tiff_dummy_namespace on windows * introduce numeric_types namespace alias * include cstdint * uint16_t is not a numeric_types type * fix uint16 and uint32 type defs * use standard c++ types * remove unused files * remove more unused files * revert build 3rd party code from source --------- Co-authored-by: Misha Klatis <misha.klatis@autodesk.com>
371 lines
9.0 KiB
C
371 lines
9.0 KiB
C
/*
|
|
* Copyright (c) 1988-1997 Sam Leffler
|
|
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and
|
|
* its documentation for any purpose is hereby granted without fee, provided
|
|
* that (i) the above copyright notices and this permission notice appear in
|
|
* all copies of the software and related documentation, and (ii) the names of
|
|
* Sam Leffler and Silicon Graphics may not be used in any advertising or
|
|
* publicity relating to the software without the specific, prior written
|
|
* permission of Sam Leffler and Silicon Graphics.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
|
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
|
|
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
|
|
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
|
|
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
* OF THIS SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* TIFF Library UNIX-specific Routines. These are should also work with the
|
|
* Windows Common RunTime Library.
|
|
*/
|
|
|
|
#include "tif_config.h"
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_FCNTL_H
|
|
#include <fcntl.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_IO_H
|
|
#include <io.h>
|
|
#endif
|
|
|
|
#include "tiffiop.h"
|
|
|
|
#define TIFF_IO_MAX 2147483647U
|
|
|
|
typedef union fd_as_handle_union
|
|
{
|
|
int fd;
|
|
thandle_t h;
|
|
} fd_as_handle_union_t;
|
|
|
|
static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
|
|
{
|
|
fd_as_handle_union_t fdh;
|
|
const size_t bytes_total = (size_t)size;
|
|
size_t bytes_read;
|
|
tmsize_t count = -1;
|
|
if ((tmsize_t)bytes_total != size)
|
|
{
|
|
errno = EINVAL;
|
|
return (tmsize_t)-1;
|
|
}
|
|
fdh.h = fd;
|
|
for (bytes_read = 0; bytes_read < bytes_total; bytes_read += count)
|
|
{
|
|
char *buf_offset = (char *)buf + bytes_read;
|
|
size_t io_size = bytes_total - bytes_read;
|
|
if (io_size > TIFF_IO_MAX)
|
|
io_size = TIFF_IO_MAX;
|
|
count = read(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
|
|
if (count <= 0)
|
|
break;
|
|
}
|
|
if (count < 0)
|
|
return (tmsize_t)-1;
|
|
return (tmsize_t)bytes_read;
|
|
}
|
|
|
|
static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
|
|
{
|
|
fd_as_handle_union_t fdh;
|
|
const size_t bytes_total = (size_t)size;
|
|
size_t bytes_written;
|
|
tmsize_t count = -1;
|
|
if ((tmsize_t)bytes_total != size)
|
|
{
|
|
errno = EINVAL;
|
|
return (tmsize_t)-1;
|
|
}
|
|
fdh.h = fd;
|
|
for (bytes_written = 0; bytes_written < bytes_total; bytes_written += count)
|
|
{
|
|
const char *buf_offset = (char *)buf + bytes_written;
|
|
size_t io_size = bytes_total - bytes_written;
|
|
if (io_size > TIFF_IO_MAX)
|
|
io_size = TIFF_IO_MAX;
|
|
count = write(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
|
|
if (count <= 0)
|
|
break;
|
|
}
|
|
if (count < 0)
|
|
return (tmsize_t)-1;
|
|
return (tmsize_t)bytes_written;
|
|
/* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */
|
|
}
|
|
|
|
static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
|
|
{
|
|
fd_as_handle_union_t fdh;
|
|
_TIFF_off_t off_io = (_TIFF_off_t)off;
|
|
if ((uint64_t)off_io != off)
|
|
{
|
|
errno = EINVAL;
|
|
return (uint64_t)-1; /* this is really gross */
|
|
}
|
|
fdh.h = fd;
|
|
return ((uint64_t)_TIFF_lseek_f(fdh.fd, off_io, whence));
|
|
}
|
|
|
|
static int _tiffCloseProc(thandle_t fd)
|
|
{
|
|
fd_as_handle_union_t fdh;
|
|
fdh.h = fd;
|
|
return (close(fdh.fd));
|
|
}
|
|
|
|
static uint64_t _tiffSizeProc(thandle_t fd)
|
|
{
|
|
_TIFF_stat_s sb;
|
|
fd_as_handle_union_t fdh;
|
|
fdh.h = fd;
|
|
if (_TIFF_fstat_f(fdh.fd, &sb) < 0)
|
|
return (0);
|
|
else
|
|
return ((uint64_t)sb.st_size);
|
|
}
|
|
|
|
#ifdef HAVE_MMAP
|
|
#include <sys/mman.h>
|
|
|
|
static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
|
|
{
|
|
uint64_t size64 = _tiffSizeProc(fd);
|
|
tmsize_t sizem = (tmsize_t)size64;
|
|
if (size64 && (uint64_t)sizem == size64)
|
|
{
|
|
fd_as_handle_union_t fdh;
|
|
fdh.h = fd;
|
|
*pbase =
|
|
(void *)mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
|
|
if (*pbase != (void *)-1)
|
|
{
|
|
*psize = (tmsize_t)sizem;
|
|
return (1);
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
|
|
{
|
|
(void)fd;
|
|
(void)munmap(base, (off_t)size);
|
|
}
|
|
#else /* !HAVE_MMAP */
|
|
static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
|
|
{
|
|
(void)fd;
|
|
(void)pbase;
|
|
(void)psize;
|
|
return (0);
|
|
}
|
|
|
|
static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
|
|
{
|
|
(void)fd;
|
|
(void)base;
|
|
(void)size;
|
|
}
|
|
#endif /* !HAVE_MMAP */
|
|
|
|
/*
|
|
* Open a TIFF file descriptor for read/writing.
|
|
*/
|
|
TIFF *TIFFFdOpen(int fd, const char *name, const char *mode)
|
|
{
|
|
return TIFFFdOpenExt(fd, name, mode, NULL);
|
|
}
|
|
|
|
TIFF *TIFFFdOpenExt(int fd, const char *name, const char *mode,
|
|
TIFFOpenOptions *opts)
|
|
{
|
|
TIFF *tif;
|
|
|
|
fd_as_handle_union_t fdh;
|
|
fdh.fd = fd;
|
|
tif = TIFFClientOpenExt(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc,
|
|
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
|
|
_tiffMapProc, _tiffUnmapProc, opts);
|
|
if (tif)
|
|
tif->tif_fd = fd;
|
|
return (tif);
|
|
}
|
|
|
|
/*
|
|
* Open a TIFF file for read/writing.
|
|
*/
|
|
TIFF *TIFFOpen(const char *name, const char *mode)
|
|
{
|
|
return TIFFOpenExt(name, mode, NULL);
|
|
}
|
|
|
|
TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
|
|
{
|
|
static const char module[] = "TIFFOpen";
|
|
int m, fd;
|
|
TIFF *tif;
|
|
|
|
m = _TIFFgetMode(opts, NULL, mode, module);
|
|
if (m == -1)
|
|
return ((TIFF *)0);
|
|
|
|
/* for cygwin and mingw */
|
|
#ifdef O_BINARY
|
|
m |= O_BINARY;
|
|
#endif
|
|
|
|
fd = open(name, m, 0666);
|
|
if (fd < 0)
|
|
{
|
|
if (errno > 0 && strerror(errno) != NULL)
|
|
{
|
|
_TIFFErrorEarly(opts, NULL, module, "%s: %s", name,
|
|
strerror(errno));
|
|
}
|
|
else
|
|
{
|
|
_TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
|
|
}
|
|
return ((TIFF *)0);
|
|
}
|
|
|
|
tif = TIFFFdOpenExt((int)fd, name, mode, opts);
|
|
if (!tif)
|
|
close(fd);
|
|
return tif;
|
|
}
|
|
|
|
#ifdef __WIN32__
|
|
#include <windows.h>
|
|
/*
|
|
* Open a TIFF file with a Unicode filename, for read/writing.
|
|
*/
|
|
TIFF *TIFFOpenW(const wchar_t *name, const char *mode)
|
|
{
|
|
return TIFFOpenWExt(name, mode, NULL);
|
|
}
|
|
TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
|
|
{
|
|
static const char module[] = "TIFFOpenW";
|
|
int m, fd;
|
|
int mbsize;
|
|
char *mbname;
|
|
TIFF *tif;
|
|
|
|
m = _TIFFgetMode(opts, NULL, mode, module);
|
|
if (m == -1)
|
|
return ((TIFF *)0);
|
|
|
|
/* for cygwin and mingw */
|
|
#ifdef O_BINARY
|
|
m |= O_BINARY;
|
|
#endif
|
|
|
|
fd = _wopen(name, m, 0666);
|
|
if (fd < 0)
|
|
{
|
|
_TIFFErrorEarly(opts, NULL, module, "%ls: Cannot open", name);
|
|
return ((TIFF *)0);
|
|
}
|
|
|
|
mbname = NULL;
|
|
mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
|
|
if (mbsize > 0)
|
|
{
|
|
mbname = _TIFFmalloc(mbsize);
|
|
if (!mbname)
|
|
{
|
|
_TIFFErrorEarly(
|
|
opts, NULL, module,
|
|
"Can't allocate space for filename conversion buffer");
|
|
return ((TIFF *)0);
|
|
}
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
|
|
}
|
|
|
|
tif = TIFFFdOpenExt((int)fd, (mbname != NULL) ? mbname : "<unknown>", mode,
|
|
opts);
|
|
|
|
_TIFFfree(mbname);
|
|
|
|
if (!tif)
|
|
close(fd);
|
|
return tif;
|
|
}
|
|
#endif
|
|
|
|
void *_TIFFmalloc(tmsize_t s)
|
|
{
|
|
if (s == 0)
|
|
return ((void *)NULL);
|
|
|
|
return (malloc((size_t)s));
|
|
}
|
|
|
|
void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
|
|
{
|
|
if (nmemb == 0 || siz == 0)
|
|
return ((void *)NULL);
|
|
|
|
return calloc((size_t)nmemb, (size_t)siz);
|
|
}
|
|
|
|
void _TIFFfree(void *p) { free(p); }
|
|
|
|
void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
|
|
|
|
void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
|
|
|
|
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
|
|
{
|
|
memcpy(d, s, (size_t)c);
|
|
}
|
|
|
|
int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
|
|
{
|
|
return (memcmp(p1, p2, (size_t)c));
|
|
}
|
|
|
|
static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
|
|
{
|
|
if (module != NULL)
|
|
fprintf(stderr, "%s: ", module);
|
|
fprintf(stderr, "Warning, ");
|
|
vfprintf(stderr, fmt, ap);
|
|
fprintf(stderr, ".\n");
|
|
}
|
|
TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
|
|
|
|
static void unixErrorHandler(const char *module, const char *fmt, va_list ap)
|
|
{
|
|
if (module != NULL)
|
|
fprintf(stderr, "%s: ", module);
|
|
vfprintf(stderr, fmt, ap);
|
|
fprintf(stderr, ".\n");
|
|
}
|
|
TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
|