generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

updated libtiff: from 3.9.5 to 4.0.1 #1609

Browse Source
This commit is contained in:
Alexander Shishkov 2012-02-29 15:01:28 +00:00
parent d00fa6b817
commit bc4f63e5bd
53 changed files with 15547 additions and 8447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
3rdparty/libtiff/CMakeLists.txt vendored
View File

@ -67,10 +67,6 @@ if(WIN32)
set(lib_srcs ${lib_srcs} tif_win32.c)
endif(WIN32)
#if(APPLE)
# set(lib_srcs ${lib_srcs} tif_apple.c)
#endif(APPLE)
file(GLOB lib_hdrs *.h*)
if(MSVC)

38
3rdparty/libtiff/t4.h vendored
View File

@ -1,26 +1,26 @@
/* $Id: t4.h,v 1.1.1.1.2.1 2010-06-08 18:50:41 bfriesen Exp $ */
/* $Id: t4.h,v 1.3 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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
* 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.
*/
@ -33,18 +33,18 @@
* worthwhile to make code & length 8 bits.
*/
typedef struct tableentry {
unsigned short length; /* bit length of g3 code */
unsigned short code; /* g3 code */
short runlen; /* run length in bits */
unsigned short length; /* bit length of g3 code */
unsigned short code; /* g3 code */
short runlen; /* run length in bits */
} tableentry;
#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */
#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */
/* status values returned instead of a run length */
#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */
#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */
#define G3CODE_EOF -3 /* end of input data */
#define G3CODE_INCOMP -4 /* incomplete run code */
#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */
#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */
#define G3CODE_EOF -3 /* end of input data */
#define G3CODE_INCOMP -4 /* incomplete run code */
/*
* Note that these tables are ordered such that the
@ -279,8 +279,8 @@ const tableentry TIFFFaxBlackCodes[] = {
{ 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */
};
#else
extern const tableentry TIFFFaxWhiteCodes[];
extern const tableentry TIFFFaxBlackCodes[];
extern const tableentry TIFFFaxWhiteCodes[];
extern const tableentry TIFFFaxBlackCodes[];
#endif
#endif /* _T4_ */
/*

281
3rdparty/libtiff/tif_apple.c vendored
View File

@ -1,281 +0,0 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/Attic/tif_apple.c,v 1.3.2.1 2010-06-08 18:50:41 bfriesen Exp $ */
/*
* 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 Macintosh-specific routines.
*
* These routines use only Toolbox and high-level File Manager traps.
* They make no calls to the THINK C "unix" compatibility library. Also,
* malloc is not used directly but it is still referenced internally by
* the ANSI library in rare cases. Heap fragmentation by the malloc ring
* buffer is therefore minimized.
*
* O_RDONLY and O_RDWR are treated identically here. The tif_mode flag is
* checked in TIFFWriteCheck().
*
* Create below fills in a blank creator signature and sets the file type
* to 'TIFF'. It is much better for the application to do this by Create'ing
* the file first and TIFFOpen'ing it later.
* ---------
* This code has been "Carbonized", and may not work with older MacOS versions.
* If so, grab the tif_apple.c out of an older libtiff distribution, like
* 3.5.5 from www.libtiff.org.
*/
#include "tiffiop.h"
#include <Errors.h>
#include <Files.h>
#include <Memory.h>
#include <Script.h>
#if defined(__PPCC__) || defined(__SC__) || defined(__MRC__) || defined(applec)
#define CtoPstr c2pstr
#endif
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (FSRead((short) fd, (long*) &size, (char*) buf) == noErr ?
size : (tsize_t) -1);
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (FSWrite((short) fd, (long*) &size, (char*) buf) == noErr ?
size : (tsize_t) -1);
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
long fpos, size;
if (GetEOF((short) fd, &size) != noErr)
return EOF;
(void) GetFPos((short) fd, &fpos);
switch (whence) {
case SEEK_CUR:
if (off + fpos > size)
SetEOF((short) fd, off + fpos);
if (SetFPos((short) fd, fsFromMark, off) != noErr)
return EOF;
break;
case SEEK_END:
if (off > 0)
SetEOF((short) fd, off + size);
if (SetFPos((short) fd, fsFromStart, off + size) != noErr)
return EOF;
break;
case SEEK_SET:
if (off > size)
SetEOF((short) fd, off);
if (SetFPos((short) fd, fsFromStart, off) != noErr)
return EOF;
break;
}
return (toff_t)(GetFPos((short) fd, &fpos) == noErr ? fpos : EOF);
}
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
{
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
{
}
static int
_tiffCloseProc(thandle_t fd)
{
return (FSClose((short) fd));
}
static toff_t
_tiffSizeProc(thandle_t fd)
{
long size;
if (GetEOF((short) fd, &size) != noErr) {
TIFFErrorExt(fd, "_tiffSizeProc", "%s: Cannot get file size");
return (-1L);
}
return ((toff_t) size);
}
/*
* Open a TIFF file descriptor for read/writing.
*/
TIFF*
TIFFFdOpen(int fd, const char* name, const char* mode)
{
TIFF* tif;
tif = TIFFClientOpen(name, mode, (thandle_t) fd,
_tiffReadProc, _tiffWriteProc, _tiffSeekProc, _tiffCloseProc,
_tiffSizeProc, _tiffMapProc, _tiffUnmapProc);
if (tif)
tif->tif_fd = fd;
return (tif);
}
static void ourc2pstr( char* inString )
{
int sLen = strlen( inString );
BlockMoveData( inString, &inString[1], sLen );
inString[0] = sLen;
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
Str255 pname;
FInfo finfo;
short fref;
OSErr err;
FSSpec fSpec;
strcpy((char*) pname, name);
ourc2pstr((char*) pname);
err = FSMakeFSSpec( 0, 0, pname, &fSpec );
switch (_TIFFgetMode(mode, module)) {
default:
return ((TIFF*) 0);
case O_RDWR | O_CREAT | O_TRUNC:
if (FSpGetFInfo(&fSpec, &finfo) == noErr)
FSpDelete(&fSpec);
/* fall through */
case O_RDWR | O_CREAT:
if ((err = FSpGetFInfo(&fSpec, &finfo)) == fnfErr) {
if (FSpCreate(&fSpec, ' ', 'TIFF', smSystemScript) != noErr)
goto badCreate;
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
} else if (err == noErr) {
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
} else
goto badOpen;
break;
case O_RDONLY:
if (FSpOpenDF(&fSpec, fsRdPerm, &fref) != noErr)
goto badOpen;
break;
case O_RDWR:
if (FSpOpenDF(&fSpec, fsRdWrPerm, &fref) != noErr)
goto badOpen;
break;
}
return (TIFFFdOpen((int) fref, name, mode));
badCreate:
TIFFErrorExt(0, module, "%s: Cannot create", name);
return ((TIFF*) 0);
badOpen:
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF*) 0);
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
tdata_t
_TIFFmalloc(tsize_t s)
{
return (NewPtr((size_t) s));
}
void
_TIFFfree(tdata_t p)
{
DisposePtr(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
{
Ptr n = p;
SetPtrSize(p, (size_t) s);
if (MemError() && (n = NewPtr((size_t) s)) != NULL) {
BlockMove(p, n, GetPtrSize(p));
DisposePtr(p);
}
return ((tdata_t) n);
}
static void
appleWarningHandler(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 = appleWarningHandler;
static void
appleErrorHandler(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 = appleErrorHandler;
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

98
3rdparty/libtiff/tif_aux.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_aux.c,v 1.20.2.3 2010-06-09 21:15:27 bfriesen Exp $ */
/* $Id: tif_aux.c,v 1.26 2010-07-01 15:33:28 dron Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@ -33,12 +33,38 @@
#include "tif_predict.h"
#include <math.h>
tdata_t
_TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
size_t nmemb, size_t elem_size, const char* what)
uint32
_TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where)
{
tdata_t cp = NULL;
tsize_t bytes = nmemb * elem_size;
uint32 bytes = first * second;
if (second && bytes / second != first) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return bytes;
}
uint64
_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where)
{
uint64 bytes = first * second;
if (second && bytes / second != first) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return bytes;
}
void*
_TIFFCheckRealloc(TIFF* tif, void* buffer,
tmsize_t nmemb, tmsize_t elem_size, const char* what)
{
void* cp = NULL;
tmsize_t bytes = nmemb * elem_size;
/*
* XXX: Check for integer overflow.
@ -46,32 +72,33 @@ _TIFFCheckRealloc(TIFF* tif, tdata_t buffer,
if (nmemb && elem_size && bytes / elem_size == nmemb)
cp = _TIFFrealloc(buffer, bytes);
if (cp == NULL)
if (cp == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Failed to allocate memory for %s "
"(%ld elements of %ld bytes each)",
what,(long) nmemb, (long) elem_size);
}
return cp;
}
tdata_t
_TIFFCheckMalloc(TIFF* tif, size_t nmemb, size_t elem_size, const char* what)
void*
_TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what)
{
return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
}
static int
TIFFDefaultTransferFunction(TIFFDirectory* td)
{
uint16 **tf = td->td_transferfunction;
tsize_t i, n, nbytes;
tmsize_t i, n, nbytes;
tf[0] = tf[1] = tf[2] = 0;
if (td->td_bitspersample >= sizeof(tsize_t) * 8 - 2)
if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2)
return 0;
n = 1<<td->td_bitspersample;
n = ((tmsize_t)1)<<td->td_bitspersample;
nbytes = n * sizeof (uint16);
if (!(tf[0] = (uint16 *)_TIFFmalloc(nbytes)))
return 0;
@ -140,7 +167,7 @@ TIFFDefaultRefBlackWhite(TIFFDirectory* td)
* place in the library -- in TIFFDefaultDirectory.
*/
int
TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap)
TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
{
TIFFDirectory *td = &tif->tif_dir;
@ -269,7 +296,7 @@ TIFFVGetFieldDefaulted(TIFF* tif, ttag_t tag, va_list ap)
* value if the tag is not present in the directory.
*/
int
TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...)
TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...)
{
int ok;
va_list ap;
@ -280,6 +307,47 @@ TIFFGetFieldDefaulted(TIFF* tif, ttag_t tag, ...)
return (ok);
}
struct _Int64Parts {
int32 low, high;
};
typedef union {
struct _Int64Parts part;
int64 value;
} _Int64;
float
_TIFFUInt64ToFloat(uint64 ui64)
{
_Int64 i;
i.value = ui64;
if (i.part.high >= 0) {
return (float)i.value;
} else {
long double df;
df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */
return (float)df;
}
}
double
_TIFFUInt64ToDouble(uint64 ui64)
{
_Int64 i;
i.value = ui64;
if (i.part.high >= 0) {
return (double)i.value;
} else {
long double df;
df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */
return (double)df;
}
}
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:

58
3rdparty/libtiff/tif_close.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_close.c,v 1.10.2.1 2010-06-08 18:50:41 bfriesen Exp $ */
/* $Id: tif_close.c,v 1.19 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -28,6 +28,7 @@
* TIFF Library.
*/
#include "tiffiop.h"
#include <string.h>
/************************************************************************/
/* TIFFCleanup() */
@ -45,18 +46,20 @@
void
TIFFCleanup(TIFF* tif)
{
/*
* Flush buffered data and directory (if dirty).
*/
if (tif->tif_mode != O_RDONLY)
/*
* Flush buffered data and directory (if dirty).
*/
TIFFFlush(tif);
TIFFFlush(tif);
(*tif->tif_cleanup)(tif);
TIFFFreeDirectory(tif);
if (tif->tif_dirlist)
_TIFFfree(tif->tif_dirlist);
/* Clean up client info links */
/*
* Clean up client info links.
*/
while( tif->tif_clientinfo )
{
TIFFClientInfoLink *link = tif->tif_clientinfo;
@ -69,27 +72,36 @@ TIFFCleanup(TIFF* tif)
if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER))
_TIFFfree(tif->tif_rawdata);
if (isMapped(tif))
TIFFUnmapFileContents(tif, tif->tif_base, tif->tif_size);
TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size);
/* Clean up custom fields */
if (tif->tif_nfields > 0)
{
size_t i;
/*
* Clean up custom fields.
*/
if (tif->tif_fields && tif->tif_nfields > 0) {
uint32 i;
for (i = 0; i < tif->tif_nfields; i++)
{
TIFFFieldInfo *fld = tif->tif_fieldinfo[i];
if (fld->field_bit == FIELD_CUSTOM &&
strncmp("Tag ", fld->field_name, 4) == 0)
{
_TIFFfree(fld->field_name);
_TIFFfree(fld);
for (i = 0; i < tif->tif_nfields; i++) {
TIFFField *fld = tif->tif_fields[i];
if (fld->field_bit == FIELD_CUSTOM &&
strncmp("Tag ", fld->field_name, 4) == 0) {
_TIFFfree(fld->field_name);
_TIFFfree(fld);
}
}
}
_TIFFfree(tif->tif_fieldinfo);
_TIFFfree(tif->tif_fields);
}
if (tif->tif_nfieldscompat > 0) {
uint32 i;
for (i = 0; i < tif->tif_nfieldscompat; i++) {
if (tif->tif_fieldscompat[i].allocated_size)
_TIFFfree(tif->tif_fieldscompat[i].fields);
}
_TIFFfree(tif->tif_fieldscompat);
}
_TIFFfree(tif);
}
@ -117,6 +129,8 @@ TIFFClose(TIFF* tif)
(void) (*closeproc)(fd);
}
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c

85
3rdparty/libtiff/tif_codec.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_codec.c,v 1.10.2.2 2010-06-08 18:50:41 bfriesen Exp $ */
/* $Id: tif_codec.c,v 1.15 2010-12-14 12:53:00 dron Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -31,43 +31,46 @@
*/
#include "tiffiop.h"
static int NotConfigured(TIFF*, int);
static int NotConfigured(TIFF*, int);
#ifndef LZW_SUPPORT
#define TIFFInitLZW NotConfigured
#ifndef LZW_SUPPORT
#define TIFFInitLZW NotConfigured
#endif
#ifndef PACKBITS_SUPPORT
#define TIFFInitPackBits NotConfigured
#ifndef PACKBITS_SUPPORT
#define TIFFInitPackBits NotConfigured
#endif
#ifndef THUNDER_SUPPORT
#define TIFFInitThunderScan NotConfigured
#ifndef THUNDER_SUPPORT
#define TIFFInitThunderScan NotConfigured
#endif
#ifndef NEXT_SUPPORT
#define TIFFInitNeXT NotConfigured
#ifndef NEXT_SUPPORT
#define TIFFInitNeXT NotConfigured
#endif
#ifndef JPEG_SUPPORT
#define TIFFInitJPEG NotConfigured
#ifndef JPEG_SUPPORT
#define TIFFInitJPEG NotConfigured
#endif
#ifndef OJPEG_SUPPORT
#define TIFFInitOJPEG NotConfigured
#ifndef OJPEG_SUPPORT
#define TIFFInitOJPEG NotConfigured
#endif
#ifndef CCITT_SUPPORT
#define TIFFInitCCITTRLE NotConfigured
#define TIFFInitCCITTRLEW NotConfigured
#define TIFFInitCCITTFax3 NotConfigured
#define TIFFInitCCITTFax4 NotConfigured
#ifndef CCITT_SUPPORT
#define TIFFInitCCITTRLE NotConfigured
#define TIFFInitCCITTRLEW NotConfigured
#define TIFFInitCCITTFax3 NotConfigured
#define TIFFInitCCITTFax4 NotConfigured
#endif
#ifndef JBIG_SUPPORT
#define TIFFInitJBIG NotConfigured
#define TIFFInitJBIG NotConfigured
#endif
#ifndef ZIP_SUPPORT
#define TIFFInitZIP NotConfigured
#ifndef ZIP_SUPPORT
#define TIFFInitZIP NotConfigured
#endif
#ifndef PIXARLOG_SUPPORT
#define TIFFInitPixarLog NotConfigured
#ifndef PIXARLOG_SUPPORT
#define TIFFInitPixarLog NotConfigured
#endif
#ifndef LOGLUV_SUPPORT
#define TIFFInitSGILog NotConfigured
#define TIFFInitSGILog NotConfigured
#endif
#ifndef LZMA_SUPPORT
#define TIFFInitLZMA NotConfigured
#endif
/*
@ -95,6 +98,7 @@ TIFFCodec _TIFFBuiltinCODECS[] = {
{ "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog },
{ "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog },
{ "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog },
{ "LZMA", COMPRESSION_LZMA, TIFFInitLZMA },
{ NULL, 0, NULL }
};
@ -114,13 +118,14 @@ _notConfigured(TIFF* tif)
static int
NotConfigured(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decodestatus = FALSE;
tif->tif_setupdecode = _notConfigured;
tif->tif_encodestatus = FALSE;
tif->tif_setupencode = _notConfigured;
return (1);
(void) scheme;
tif->tif_fixuptags = _notConfigured;
tif->tif_decodestatus = FALSE;
tif->tif_setupdecode = _notConfigured;
tif->tif_encodestatus = FALSE;
tif->tif_setupencode = _notConfigured;
return (1);
}
/************************************************************************/
@ -129,7 +134,7 @@ NotConfigured(TIFF* tif, int scheme)
/**
* Check whether we have working codec for the specific coding scheme.
*
*
* @return returns 1 if the codec is configured and working. Otherwise
* 0 will be returned.
*/
@ -140,14 +145,14 @@ TIFFIsCODECConfigured(uint16 scheme)
const TIFFCodec* codec = TIFFFindCODEC(scheme);
if(codec == NULL) {
return 0;
}
if(codec->init == NULL) {
return 0;
}
return 0;
}
if(codec->init == NULL) {
return 0;
}
if(codec->init != NotConfigured){
return 1;
}
return 1;
}
return 0;
}

6
3rdparty/libtiff/tif_color.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_color.c,v 1.12.2.2 2010-12-14 02:23:09 faxguy Exp $ */
/* $Id: tif_color.c,v 1.19 2010-12-14 02:22:42 faxguy Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -123,7 +123,7 @@ TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
*/
int
TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
TIFFDisplay *display, float *refWhite)
const TIFFDisplay *display, float *refWhite)
{
int i;
double gamma;
@ -224,7 +224,7 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
#define LumaBlue luma[2]
clamptab = (TIFFRGBValue*)(
(tidata_t) ycbcr+TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long)));
(uint8*) ycbcr+TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long)));
_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
ycbcr->clamptab = (clamptab += 256);
for (i = 0; i < 256; i++)

71
3rdparty/libtiff/tif_compress.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_compress.c,v 1.13.2.1 2010-06-08 18:50:41 bfriesen Exp $ */
/* $Id: tif_compress.c,v 1.22 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -36,11 +36,11 @@ TIFFNoEncode(TIFF* tif, const char* method)
{
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c) {
if (c) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"%s %s encoding is not implemented",
c->name, method);
} else {
} else {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Compression scheme %u %s encoding is not implemented",
tif->tif_dir.td_compression, method);
@ -49,21 +49,21 @@ TIFFNoEncode(TIFF* tif, const char* method)
}
int
_TIFFNoRowEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "scanline"));
}
int
_TIFFNoStripEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "strip"));
}
int
_TIFFNoTileEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoTileEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoEncode(tif, "tile"));
@ -86,21 +86,28 @@ TIFFNoDecode(TIFF* tif, const char* method)
}
int
_TIFFNoRowDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
int
_TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "scanline"));
}
int
_TIFFNoStripDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "strip"));
}
int
_TIFFNoTileDecode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
_TIFFNoTileDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) pp; (void) cc; (void) s;
return (TIFFNoDecode(tif, "tile"));
@ -116,7 +123,7 @@ _TIFFNoSeek(TIFF* tif, uint32 off)
}
int
_TIFFNoPreCode(TIFF* tif, tsample_t s)
_TIFFNoPreCode(TIFF* tif, uint16 s)
{
(void) tif; (void) s;
return (1);
@ -128,19 +135,20 @@ static void _TIFFvoid(TIFF* tif) { (void) tif; }
void
_TIFFSetDefaultCompressionState(TIFF* tif)
{
tif->tif_fixuptags = _TIFFNoFixupTags;
tif->tif_decodestatus = TRUE;
tif->tif_setupdecode = _TIFFtrue;
tif->tif_predecode = _TIFFNoPreCode;
tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_decodestrip = _TIFFNoStripDecode;
tif->tif_decodetile = _TIFFNoTileDecode;
tif->tif_decodetile = _TIFFNoTileDecode;
tif->tif_encodestatus = TRUE;
tif->tif_setupencode = _TIFFtrue;
tif->tif_preencode = _TIFFNoPreCode;
tif->tif_postencode = _TIFFtrue;
tif->tif_encoderow = _TIFFNoRowEncode;
tif->tif_encodestrip = _TIFFNoStripEncode;
tif->tif_encodetile = _TIFFNoTileEncode;
tif->tif_encodestrip = _TIFFNoStripEncode;
tif->tif_encodetile = _TIFFNoTileEncode;
tif->tif_close = _TIFFvoid;
tif->tif_seek = _TIFFNoSeek;
tif->tif_cleanup = _TIFFvoid;
@ -170,10 +178,10 @@ TIFFSetCompressionScheme(TIFF* tif, int scheme)
* by this library.
*/
typedef struct _codec {
struct _codec* next;
TIFFCodec* info;
struct _codec* next;
TIFFCodec* info;
} codec_t;
static codec_t* registeredCODECS = NULL;
static codec_t* registeredCODECS = NULL;
const TIFFCodec*
TIFFFindCODEC(uint16 scheme)
@ -194,12 +202,12 @@ TIFFCodec*
TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
{
codec_t* cd = (codec_t*)
_TIFFmalloc(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1);
_TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1));
if (cd != NULL) {
cd->info = (TIFFCodec*) ((tidata_t) cd + sizeof (codec_t));
cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t));
cd->info->name = (char*)
((tidata_t) cd->info + sizeof (TIFFCodec));
((uint8*) cd->info + sizeof (TIFFCodec));
strcpy(cd->info->name, name);
cd->info->scheme = scheme;
cd->info->init = init;
@ -244,13 +252,14 @@ TIFFUnRegisterCODEC(TIFFCodec* c)
TIFFCodec*
TIFFGetConfiguredCODECs()
{
int i = 1;
codec_t *cd;
const TIFFCodec *c;
TIFFCodec *codecs = NULL, *new_codecs;
int i = 1;
codec_t *cd;
const TIFFCodec* c;
TIFFCodec* codecs = NULL;
TIFFCodec* new_codecs;
for (cd = registeredCODECS; cd; cd = cd->next) {
new_codecs = (TIFFCodec *)
for (cd = registeredCODECS; cd; cd = cd->next) {
new_codecs = (TIFFCodec *)
_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
if (!new_codecs) {
_TIFFfree (codecs);
@ -260,16 +269,16 @@ TIFFGetConfiguredCODECs()
_TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
i++;
}
for (c = _TIFFBuiltinCODECS; c->name; c++) {
if (TIFFIsCODECConfigured(c->scheme)) {
new_codecs = (TIFFCodec *)
for (c = _TIFFBuiltinCODECS; c->name; c++) {
if (TIFFIsCODECConfigured(c->scheme)) {
new_codecs = (TIFFCodec *)
_TIFFrealloc(codecs, i * sizeof(TIFFCodec));
if (!new_codecs) {
_TIFFfree (codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, (const tdata_t)c, sizeof(TIFFCodec));
_TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec));
i++;
}
}
@ -282,7 +291,7 @@ TIFFGetConfiguredCODECs()
codecs = new_codecs;
_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
return codecs;
return codecs;
}
/* vim: set ts=8 sts=8 sw=8 noet: */

392
3rdparty/libtiff/tif_config.h vendored
View File

@ -1,24 +1,120 @@
/* libtiff/tif_config.h. Generated from tif_config.h.in by configure. */
/* libtiff/tif_config.h.in. Generated from configure.ac by autoheader. */
/* Define if building universal (internal helper macro) */
/* #undef AC_APPLE_UNIVERSAL_BUILD */
/* Support CCITT Group 3 & 4 algorithms */
#define CCITT_SUPPORT 1
/* Pick up YCbCr subsampling info from the JPEG data stream to support files
lacking the tag (default enabled). */
#define CHECK_JPEG_YCBCR_SUBSAMPLING 1
/* enable partial strip reading for large strips (experimental) */
/* #undef CHUNKY_STRIP_READ_SUPPORT */
/* Support C++ stream API (requires C++ compiler) */
#define CXX_SUPPORT 1
/* Treat extra sample as alpha (default enabled). The RGBA interface will
treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many
packages produce RGBA files but don't mark the alpha properly. */
#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1
/* enable deferred strip/tile offset/size loading (experimental) */
/* #undef DEFER_STRILE_LOAD */
/* Define to 1 if you have the <assert.h> header file. */
#define HAVE_ASSERT_H 1
/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1
/* Define to 1 if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H 1
/* Define to 1 if you have the `floor' function. */
#define HAVE_FLOOR 1
/* Define to 1 if you have the `getopt' function. */
#define HAVE_GETOPT 1
/* Define to 1 if you have the <GLUT/glut.h> header file. */
/* #undef HAVE_GLUT_GLUT_H */
/* Define to 1 if you have the <GL/glut.h> header file. */
#define HAVE_GL_GLUT_H 1
/* Define to 1 if you have the <GL/glu.h> header file. */
#define HAVE_GL_GLU_H 1
/* Define to 1 if you have the <GL/gl.h> header file. */
#define HAVE_GL_GL_H 1
/* Define as 0 or 1 according to the floating point format suported by the
machine */
#define HAVE_IEEEFP 1
/* Define to 1 if you have the `jbg_newlen' function. */
#define HAVE_JBG_NEWLEN 1
/* Define to 1 if the system has the type `int16'. */
/* #undef HAVE_INT16 */
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if the system has the type `int32'. */
/* #undef HAVE_INT32 */
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if the system has the type `int8'. */
/* #undef HAVE_INT8 */
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the <io.h> header file. */
#define HAVE_IO_H 1
/* #undef HAVE_IO_H */
/* Define to 1 if you have the `isascii' function. */
#define HAVE_ISASCII 1
/* Define to 1 if you have the `jbg_newlen' function. */
/* #undef HAVE_JBG_NEWLEN */
/* Define to 1 if you have the `lfind' function. */
#define HAVE_LFIND 1
/* Define to 1 if you have the `c' library (-lc). */
#define HAVE_LIBC 1
/* Define to 1 if you have the `m' library (-lm). */
#define HAVE_LIBM 1
/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1
/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1
/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1
/* Define to 1 if you have the `mmap' function. */
#define HAVE_MMAP 1
/* Define to 1 if you have the <OpenGL/glu.h> header file. */
/* #undef HAVE_OPENGL_GLU_H */
/* Define to 1 if you have the <OpenGL/gl.h> header file. */
/* #undef HAVE_OPENGL_GL_H */
/* Define to 1 if you have the `pow' function. */
#define HAVE_POW 1
/* Define if you have POSIX threads libraries and header files. */
#define HAVE_PTHREAD 1
#if !__ANDROID__
/* Define to 1 if you have the <search.h> header file. */
@ -26,14 +122,221 @@
#endif
/* Define to 1 if you have the `setmode' function. */
#define HAVE_SETMODE 1
/* #undef HAVE_SETMODE */
/* The size of a `int', as computed by sizeof. */
#define SIZEOF_INT 4
/* Define to 1 if you have the `sqrt' function. */
#define HAVE_SQRT 1
/* The size of a `long', as computed by sizeof. */
#define SIZEOF_LONG 4
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the `strcasecmp' function. */
#define HAVE_STRCASECMP 1
/* Define to 1 if you have the `strchr' function. */
#define HAVE_STRCHR 1
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strrchr' function. */
#define HAVE_STRRCHR 1
/* Define to 1 if you have the `strstr' function. */
#define HAVE_STRSTR 1
/* Define to 1 if you have the `strtol' function. */
#define HAVE_STRTOL 1
/* Define to 1 if you have the `strtoul' function. */
#define HAVE_STRTOUL 1
/* Define to 1 if you have the `strtoull' function. */
#define HAVE_STRTOULL 1
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/time.h> header file. */
#define HAVE_SYS_TIME_H 1
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Use nonstandard varargs form for the GLU tesselator callback */
/* #undef HAVE_VARARGS_GLU_TESSCB */
/* Define to 1 if you have the <windows.h> header file. */
/* #undef HAVE_WINDOWS_H */
/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
(Intel) */
#define HOST_BIGENDIAN 0
/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
#define HOST_FILLORDER FILLORDER_LSB2MSB
/* Support ISO JBIG compression (requires JBIG-KIT library) */
/* #undef JBIG_SUPPORT */
/* 8/12 bit libjpeg dual mode enabled */
/* #undef JPEG_DUAL_MODE_8_12 */
/* Support JPEG compression (requires IJG JPEG library) */
//#define JPEG_SUPPORT 1
/* 12bit libjpeg primary include file with path */
/* #undef LIBJPEG_12_PATH */
/* Support LogLuv high dynamic range encoding */
#define LOGLUV_SUPPORT 1
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#define LT_OBJDIR ".libs/"
/* Support LZMA2 compression */
/* #undef LZMA_SUPPORT */
/* Support LZW algorithm */
#define LZW_SUPPORT 1
/* Support Microsoft Document Imaging format */
#define MDI_SUPPORT 1
/* Support NeXT 2-bit RLE algorithm */
#define NEXT_SUPPORT 1
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */
/* Support Old JPEG compresson (read-only) */
//#define OJPEG_SUPPORT 1
/* Name of package */
#define PACKAGE "tiff"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "tiff@lists.maptools.org"
/* Define to the full name of this package. */
#define PACKAGE_NAME "LibTIFF Software"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "LibTIFF Software 4.0.1"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "tiff"
/* Define to the home page for this package. */
#define PACKAGE_URL ""
/* Define to the version of this package. */
#define PACKAGE_VERSION "4.0.1"
/* Support Macintosh PackBits algorithm */
#define PACKBITS_SUPPORT 1
/* Support Pixar log-format algorithm (requires Zlib) */
//#define PIXARLOG_SUPPORT 1
/* Define to necessary symbol if this constant uses a non-standard name on
your system. */
/* #undef PTHREAD_CREATE_JOINABLE */
/* The size of `signed int', as computed by sizeof. */
#define SIZEOF_SIGNED_INT 4
/* The size of `signed long', as computed by sizeof. */
#define SIZEOF_SIGNED_LONG 8
/* The size of `signed long long', as computed by sizeof. */
#define SIZEOF_SIGNED_LONG_LONG 8
/* The size of `signed short', as computed by sizeof. */
#define SIZEOF_SIGNED_SHORT 2
/* The size of `unsigned char *', as computed by sizeof. */
#define SIZEOF_UNSIGNED_CHAR_P 8
/* The size of `unsigned int', as computed by sizeof. */
#define SIZEOF_UNSIGNED_INT 4
/* The size of `unsigned long', as computed by sizeof. */
#define SIZEOF_UNSIGNED_LONG 8
/* The size of `unsigned long long', as computed by sizeof. */
#define SIZEOF_UNSIGNED_LONG_LONG 8
/* The size of `unsigned short', as computed by sizeof. */
#define SIZEOF_UNSIGNED_SHORT 2
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Support strip chopping (whether or not to convert single-strip uncompressed
images to mutiple strips of specified size to reduce memory usage) */
#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP
/* Default size of the strip in bytes (when strip chopping enabled) */
#define STRIP_SIZE_DEFAULT 8192
/* Enable SubIFD tag (330) support */
#define SUBIFD_SUPPORT 1
/* Support ThunderScan 4-bit RLE algorithm */
#define THUNDER_SUPPORT 1
/* Signed 16-bit type */
#define TIFF_INT16_T signed short
/* Signed 32-bit type formatter */
#define TIFF_INT32_FORMAT "%d"
/* Signed 32-bit type */
#define TIFF_INT32_T signed int
/* Signed 64-bit type formatter */
#define TIFF_INT64_FORMAT "%ld"
/* Signed 64-bit type */
//#define TIFF_INT64_T signed long
/* Signed 8-bit type */
#define TIFF_INT8_T signed char
/* Pointer difference type formatter */
#define TIFF_PTRDIFF_FORMAT "%ld"
/* Pointer difference type */
#define TIFF_PTRDIFF_T ptrdiff_t
/* Signed size type formatter */
#define TIFF_SSIZE_FORMAT "%ld"
/* Signed size type */
#define TIFF_SSIZE_T size_t
/* Unsigned 16-bit type */
#define TIFF_UINT16_T unsigned short
/* Unsigned 32-bit type formatter */
#define TIFF_UINT32_FORMAT "%u"
/* Unsigned 32-bit type */
#define TIFF_UINT32_T unsigned int
/* Unsigned 64-bit type formatter */
#define TIFF_UINT64_FORMAT "%lu"
#ifdef _MSC_VER
/* Signed 64-bit type */
@ -47,26 +350,59 @@
#define TIFF_UINT64_T unsigned long long
#endif
/* Set the native cpu bit order */
#define HOST_FILLORDER FILLORDER_LSB2MSB
/* Unsigned 64-bit type */
//#define TIFF_UINT64_T unsigned long
/* Define to 1 if your processor stores words with the most significant byte
first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */
/* Unsigned 8-bit type */
#define TIFF_UINT8_T unsigned char
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
#define TIME_WITH_SYS_TIME 1
/* Define to 1 if your <sys/time.h> declares `struct tm'. */
/* #undef TM_IN_SYS_TIME */
/* define to use win32 IO system */
/* #undef USE_WIN32_FILEIO */
/* Version number of package */
#define VERSION "4.0.1"
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
#if defined AC_APPLE_UNIVERSAL_BUILD
# if defined __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
# ifndef WORDS_BIGENDIAN
/* # undef WORDS_BIGENDIAN */
# endif
#endif
/* Define to 1 if the X Window System is missing or not being used. */
/* #undef X_DISPLAY_MISSING */
/* Support Deflate compression */
//#define ZIP_SUPPORT 1
/* Number of bits in a file offset, on hosts where this is settable. */
/* #undef _FILE_OFFSET_BITS */
/* Define for large files, on AIX-style hosts. */
/* #undef _LARGE_FILES */
/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
# ifndef inline
# define inline __inline
# endif
/* #undef inline */
#endif
#define lfind _lfind
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/
/* Define to `long int' if <sys/types.h> does not define. */
/* #undef off_t */
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */

1516
3rdparty/libtiff/tif_dir.c vendored
View File

File diff suppressed because it is too large Load Diff

293
3rdparty/libtiff/tif_dir.h vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_dir.h,v 1.30.2.3 2010-06-09 21:15:27 bfriesen Exp $ */
/* $Id: tif_dir.h,v 1.54 2011-02-18 20:53:05 fwarmerdam Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -30,13 +30,41 @@
* ``Library-private'' Directory-related Definitions.
*/
typedef struct {
const TIFFField *info;
int count;
void *value;
} TIFFTagValue;
/*
* TIFF Image File Directories are comprised of a table of field
* descriptors of the form shown below. The table is sorted in
* ascending order by tag. The values associated with each entry are
* disjoint and may appear anywhere in the file (so long as they are
* placed on a word boundary).
*
* If the value is 4 bytes or less, in ClassicTIFF, or 8 bytes or less in
* BigTIFF, then it is placed in the offset field to save space. If so,
* it is left-justified in the offset field.
*/
typedef struct {
uint16 tdir_tag; /* see below */
uint16 tdir_type; /* data type; see below */
uint64 tdir_count; /* number of items; length in spec */
union {
uint16 toff_short;
uint32 toff_long;
uint64 toff_long8;
} tdir_offset; /* either offset or the data itself if fits */
} TIFFDirEntry;
/*
* Internal format of a TIFF directory entry.
*/
typedef struct {
#define FIELD_SETLONGS 4
typedef struct {
#define FIELD_SETLONGS 4
/* bit vector of fields that are set */
unsigned long td_fieldsset[FIELD_SETLONGS];
unsigned long td_fieldsset[FIELD_SETLONGS];
uint32 td_imagewidth, td_imagelength, td_imagedepth;
uint32 td_tilewidth, td_tilelength, td_tiledepth;
@ -51,7 +79,8 @@ typedef struct {
uint16 td_samplesperpixel;
uint32 td_rowsperstrip;
uint16 td_minsamplevalue, td_maxsamplevalue;
double td_sminsamplevalue, td_smaxsamplevalue;
double* td_sminsamplevalue;
double* td_smaxsamplevalue;
float td_xresolution, td_yresolution;
uint16 td_resolutionunit;
uint16 td_planarconfig;
@ -64,19 +93,23 @@ typedef struct {
/* even though the name is misleading, td_stripsperimage is the number
* of striles (=strips or tiles) per plane, and td_nstrips the total
* number of striles */
tstrile_t td_stripsperimage;
tstrile_t td_nstrips; /* size of offset & bytecount arrays */
toff_t* td_stripoffset;
toff_t* td_stripbytecount; /* FIXME: it should be tsize_t array */
uint32 td_stripsperimage;
uint32 td_nstrips; /* size of offset & bytecount arrays */
uint64* td_stripoffset;
uint64* td_stripbytecount;
int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
#if defined(DEFER_STRILE_LOAD)
TIFFDirEntry td_stripoffset_entry; /* for deferred loading */
TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */
#endif
uint16 td_nsubifd;
uint32* td_subifd;
uint64* td_subifd;
/* YCbCr parameters */
uint16 td_ycbcrsubsampling[2];
uint16 td_ycbcrpositioning;
/* Colorimetry parameters */
float* td_refblackwhite;
uint16* td_transferfunction[3];
float* td_refblackwhite;
/* CMYK parameters */
int td_inknameslen;
char* td_inknames;
@ -86,115 +119,178 @@ typedef struct {
} TIFFDirectory;
/*
* Field flags used to indicate fields that have
* been set in a directory, and to reference fields
* when manipulating a directory.
* Field flags used to indicate fields that have been set in a directory, and
* to reference fields when manipulating a directory.
*/
/*
* FIELD_IGNORE is used to signify tags that are to
* be processed but otherwise ignored. This permits
* antiquated tags to be quietly read and discarded.
* Note that a bit *is* allocated for ignored tags;
* this is understood by the directory reading logic
* which uses this fact to avoid special-case handling
*/
#define FIELD_IGNORE 0
* FIELD_IGNORE is used to signify tags that are to be processed but otherwise
* ignored. This permits antiquated tags to be quietly read and discarded.
* Note that a bit *is* allocated for ignored tags; this is understood by the
* directory reading logic which uses this fact to avoid special-case handling
*/
#define FIELD_IGNORE 0
/* multi-item fields */
#define FIELD_IMAGEDIMENSIONS 1
#define FIELD_TILEDIMENSIONS 2
#define FIELD_RESOLUTION 3
#define FIELD_POSITION 4
#define FIELD_IMAGEDIMENSIONS 1
#define FIELD_TILEDIMENSIONS 2
#define FIELD_RESOLUTION 3
#define FIELD_POSITION 4
/* single-item fields */
#define FIELD_SUBFILETYPE 5
#define FIELD_BITSPERSAMPLE 6
#define FIELD_COMPRESSION 7
#define FIELD_PHOTOMETRIC 8
#define FIELD_THRESHHOLDING 9
#define FIELD_FILLORDER 10
#define FIELD_ORIENTATION 15
#define FIELD_SAMPLESPERPIXEL 16
#define FIELD_ROWSPERSTRIP 17
#define FIELD_MINSAMPLEVALUE 18
#define FIELD_MAXSAMPLEVALUE 19
#define FIELD_PLANARCONFIG 20
#define FIELD_RESOLUTIONUNIT 22
#define FIELD_PAGENUMBER 23
#define FIELD_STRIPBYTECOUNTS 24
#define FIELD_STRIPOFFSETS 25
#define FIELD_COLORMAP 26
#define FIELD_EXTRASAMPLES 31
#define FIELD_SAMPLEFORMAT 32
#define FIELD_SMINSAMPLEVALUE 33
#define FIELD_SMAXSAMPLEVALUE 34
#define FIELD_IMAGEDEPTH 35
#define FIELD_TILEDEPTH 36
#define FIELD_HALFTONEHINTS 37
#define FIELD_YCBCRSUBSAMPLING 39
#define FIELD_YCBCRPOSITIONING 40
#define FIELD_REFBLACKWHITE 41
#define FIELD_TRANSFERFUNCTION 44
#define FIELD_INKNAMES 46
#define FIELD_SUBIFD 49
/* FIELD_CUSTOM (see tiffio.h) 65 */
#define FIELD_SUBFILETYPE 5
#define FIELD_BITSPERSAMPLE 6
#define FIELD_COMPRESSION 7
#define FIELD_PHOTOMETRIC 8
#define FIELD_THRESHHOLDING 9
#define FIELD_FILLORDER 10
#define FIELD_ORIENTATION 15
#define FIELD_SAMPLESPERPIXEL 16
#define FIELD_ROWSPERSTRIP 17
#define FIELD_MINSAMPLEVALUE 18
#define FIELD_MAXSAMPLEVALUE 19
#define FIELD_PLANARCONFIG 20
#define FIELD_RESOLUTIONUNIT 22
#define FIELD_PAGENUMBER 23
#define FIELD_STRIPBYTECOUNTS 24
#define FIELD_STRIPOFFSETS 25
#define FIELD_COLORMAP 26
#define FIELD_EXTRASAMPLES 31
#define FIELD_SAMPLEFORMAT 32
#define FIELD_SMINSAMPLEVALUE 33
#define FIELD_SMAXSAMPLEVALUE 34
#define FIELD_IMAGEDEPTH 35
#define FIELD_TILEDEPTH 36
#define FIELD_HALFTONEHINTS 37
#define FIELD_YCBCRSUBSAMPLING 39
#define FIELD_YCBCRPOSITIONING 40
#define FIELD_REFBLACKWHITE 41
#define FIELD_TRANSFERFUNCTION 44
#define FIELD_INKNAMES 46
#define FIELD_SUBIFD 49
/* FIELD_CUSTOM (see tiffio.h) 65 */
/* end of support for well-known tags; codec-private tags follow */
#define FIELD_CODEC 66 /* base of codec-private tags */
#define FIELD_CODEC 66 /* base of codec-private tags */
/*
* Pseudo-tags don't normally need field bits since they
* are not written to an output file (by definition).
* The library also has express logic to always query a
* codec for a pseudo-tag so allocating a field bit for
* one is a waste. If codec wants to promote the notion
* of a pseudo-tag being ``set'' or ``unset'' then it can
* do using internal state flags without polluting the
* field bit space defined for real tags.
* Pseudo-tags don't normally need field bits since they are not written to an
* output file (by definition). The library also has express logic to always
* query a codec for a pseudo-tag so allocating a field bit for one is a
* waste. If codec wants to promote the notion of a pseudo-tag being ``set''
* or ``unset'' then it can do using internal state flags without polluting
* the field bit space defined for real tags.
*/
#define FIELD_PSEUDO 0
#define FIELD_PSEUDO 0
#define FIELD_LAST (32*FIELD_SETLONGS-1)
#define FIELD_LAST (32*FIELD_SETLONGS-1)
#define TIFFExtractData(tif, type, v) \
((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
((v) >> (tif)->tif_typeshift[type]) & (tif)->tif_typemask[type] : \
(v) & (tif)->tif_typemask[type]))
#define TIFFInsertData(tif, type, v) \
((uint32) ((tif)->tif_header.tiff_magic == TIFF_BIGENDIAN ? \
((v) & (tif)->tif_typemask[type]) << (tif)->tif_typeshift[type] : \
(v) & (tif)->tif_typemask[type]))
#define BITn(n) (((unsigned long)1L)<<((n)&0x1f))
#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32])
#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
#define BITn(n) (((unsigned long)1L)<<((n)&0x1f))
#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32])
#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
#define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field))
#define FieldSet(fields, f) (fields[(f)/32] & BITn(f))
#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f))
#define FieldSet(fields, f) (fields[(f)/32] & BITn(f))
#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f))
typedef enum {
TIFF_SETGET_UNDEFINED = 0,
TIFF_SETGET_ASCII = 1,
TIFF_SETGET_UINT8 = 2,
TIFF_SETGET_SINT8 = 3,
TIFF_SETGET_UINT16 = 4,
TIFF_SETGET_SINT16 = 5,
TIFF_SETGET_UINT32 = 6,
TIFF_SETGET_SINT32 = 7,
TIFF_SETGET_UINT64 = 8,
TIFF_SETGET_SINT64 = 9,
TIFF_SETGET_FLOAT = 10,
TIFF_SETGET_DOUBLE = 11,
TIFF_SETGET_IFD8 = 12,
TIFF_SETGET_INT = 13,
TIFF_SETGET_UINT16_PAIR = 14,
TIFF_SETGET_C0_ASCII = 15,
TIFF_SETGET_C0_UINT8 = 16,
TIFF_SETGET_C0_SINT8 = 17,
TIFF_SETGET_C0_UINT16 = 18,
TIFF_SETGET_C0_SINT16 = 19,
TIFF_SETGET_C0_UINT32 = 20,
TIFF_SETGET_C0_SINT32 = 21,
TIFF_SETGET_C0_UINT64 = 22,
TIFF_SETGET_C0_SINT64 = 23,
TIFF_SETGET_C0_FLOAT = 24,
TIFF_SETGET_C0_DOUBLE = 25,
TIFF_SETGET_C0_IFD8 = 26,
TIFF_SETGET_C16_ASCII = 27,
TIFF_SETGET_C16_UINT8 = 28,
TIFF_SETGET_C16_SINT8 = 29,
TIFF_SETGET_C16_UINT16 = 30,
TIFF_SETGET_C16_SINT16 = 31,
TIFF_SETGET_C16_UINT32 = 32,
TIFF_SETGET_C16_SINT32 = 33,
TIFF_SETGET_C16_UINT64 = 34,
TIFF_SETGET_C16_SINT64 = 35,
TIFF_SETGET_C16_FLOAT = 36,
TIFF_SETGET_C16_DOUBLE = 37,
TIFF_SETGET_C16_IFD8 = 38,
TIFF_SETGET_C32_ASCII = 39,
TIFF_SETGET_C32_UINT8 = 40,
TIFF_SETGET_C32_SINT8 = 41,
TIFF_SETGET_C32_UINT16 = 42,
TIFF_SETGET_C32_SINT16 = 43,
TIFF_SETGET_C32_UINT32 = 44,
TIFF_SETGET_C32_SINT32 = 45,
TIFF_SETGET_C32_UINT64 = 46,
TIFF_SETGET_C32_SINT64 = 47,
TIFF_SETGET_C32_FLOAT = 48,
TIFF_SETGET_C32_DOUBLE = 49,
TIFF_SETGET_C32_IFD8 = 50,
TIFF_SETGET_OTHER = 51
} TIFFSetGetFieldType;
#if defined(__cplusplus)
extern "C" {
#endif
extern const TIFFFieldInfo *_TIFFGetFieldInfo(size_t *);
extern const TIFFFieldInfo *_TIFFGetExifFieldInfo(size_t *);
extern void _TIFFSetupFieldInfo(TIFF*, const TIFFFieldInfo[], size_t);
extern int _TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int);
extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
extern TIFFDataType _TIFFSampleToTagType(TIFF*);
extern const TIFFFieldInfo* _TIFFFindOrRegisterFieldInfo( TIFF *tif,
ttag_t tag,
TIFFDataType dt );
extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag,
TIFFDataType dt );
#define _TIFFFindFieldInfo TIFFFindFieldInfo
#define _TIFFFindFieldInfoByName TIFFFindFieldInfoByName
#define _TIFFFieldWithTag TIFFFieldWithTag
#define _TIFFFieldWithName TIFFFieldWithName
extern const TIFFFieldArray* _TIFFGetFields(void);
extern const TIFFFieldArray* _TIFFGetExifFields(void);
extern void _TIFFSetupFields(TIFF* tif, const TIFFFieldArray* infoarray);
extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
extern int _TIFFFillStriles(TIFF*);
typedef enum {
tfiatImage,
tfiatExif,
tfiatOther
} TIFFFieldArrayType;
struct _TIFFFieldArray {
TIFFFieldArrayType type; /* array type, will be used to determine if IFD is image and such */
uint32 allocated_size; /* 0 if array is constant, other if modified by future definition extension support */
uint32 count; /* number of elements in fields array */
TIFFField* fields; /* actual field info */
};
struct _TIFFField {
uint32 field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
short field_writecount; /* write count/TIFF_VARIABLE */
TIFFDataType field_type; /* type of associated data */
uint32 reserved; /* reserved for future extension */
TIFFSetGetFieldType set_field_type; /* type to be passed to TIFFSetField */
TIFFSetGetFieldType get_field_type; /* type to be passed to TIFFGetField */
unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char* field_name; /* ASCII name */
TIFFFieldArray* field_subfields; /* if field points to child ifds, child ifd field definition array */
};
extern int _TIFFMergeFields(TIFF*, const TIFFField[], uint32);
extern const TIFFField* _TIFFFindOrRegisterField(TIFF *, uint32, TIFFDataType);
extern TIFFField* _TIFFCreateAnonField(TIFF *, uint32, TIFFDataType);
#if defined(__cplusplus)
}
@ -202,6 +298,7 @@ extern TIFFFieldInfo* _TIFFCreateAnonFieldInfo( TIFF *tif, ttag_t tag,
#endif /* _TIFFDIR_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c

1327
3rdparty/libtiff/tif_dirinfo.c vendored
View File

File diff suppressed because it is too large Load Diff

6453
3rdparty/libtiff/tif_dirread.c vendored
View File

File diff suppressed because it is too large Load Diff

4040
3rdparty/libtiff/tif_dirwrite.c vendored
View File

File diff suppressed because it is too large Load Diff

41
3rdparty/libtiff/tif_dumpmode.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_dumpmode.c,v 1.5.2.2 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_dumpmode.c,v 1.14 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -31,22 +31,29 @@
*/
#include "tiffiop.h"
static int
DumpFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
/*
* Encode a hunk of pixels.
*/
static int
DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
DumpModeEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
{
(void) s;
while (cc > 0) {
tsize_t n;
tmsize_t n;
n = cc;
if (tif->tif_rawcc + n > tif->tif_rawdatasize)
n = tif->tif_rawdatasize - tif->tif_rawcc;
assert( n > 0 );
/*
* Avoid copy if client has setup raw
* data buffer to avoid extra copy.
@ -68,15 +75,24 @@ DumpModeEncode(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
* Decode a hunk of pixels.
*/
static int
DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
DumpModeDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
{
static const char module[] = "DumpModeDecode";
(void) s;
/* fprintf(stderr,"DumpModeDecode: scanline %ld, expected %ld bytes, got %ld bytes\n", */
/* (long) tif->tif_row, (long) tif->tif_rawcc, (long) cc); */
if (tif->tif_rawcc < cc) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"DumpModeDecode: Not enough data for scanline %d",
tif->tif_row);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data for scanline %lu, expected a request for at most %I64d bytes, got a request for %I64d bytes",
(unsigned long) tif->tif_row,
(signed __int64) tif->tif_rawcc,
(signed __int64) cc);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data for scanline %lu, expected a request for at most %lld bytes, got a request for %lld bytes",
(unsigned long) tif->tif_row,
(signed long long) tif->tif_rawcc,
(signed long long) cc);
#endif
return (0);
}
/*
@ -86,7 +102,7 @@ DumpModeDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
if (tif->tif_rawcp != buf)
_TIFFmemcpy(buf, tif->tif_rawcp, cc);
tif->tif_rawcp += cc;
tif->tif_rawcc -= cc;
tif->tif_rawcc -= cc;
return (1);
}
@ -108,12 +124,13 @@ int
TIFFInitDumpMode(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_fixuptags = DumpFixupTags;
tif->tif_decoderow = DumpModeDecode;
tif->tif_decodestrip = DumpModeDecode;
tif->tif_decodetile = DumpModeDecode;
tif->tif_encoderow = DumpModeEncode;
tif->tif_encodestrip = DumpModeEncode;
tif->tif_encodetile = DumpModeEncode;
tif->tif_encodetile = DumpModeEncode;
tif->tif_seek = DumpModeSeek;
return (1);
}

2
3rdparty/libtiff/tif_error.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_error.c,v 1.4.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_error.c,v 1.5 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler

8
3rdparty/libtiff/tif_extension.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_extension.c,v 1.4.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_extension.c,v 1.7 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -41,13 +41,13 @@ int TIFFGetTagListCount( TIFF *tif )
return td->td_customValueCount;
}
ttag_t TIFFGetTagListEntry( TIFF *tif, int tag_index )
uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index )
{
TIFFDirectory* td = &tif->tif_dir;
if( tag_index < 0 || tag_index >= td->td_customValueCount )
return (ttag_t) -1;
return (uint32)(-1);
else
return td->td_customValues[tag_index].info->field_tag;
}
@ -102,7 +102,7 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
link = (TIFFClientInfoLink *) _TIFFmalloc(sizeof(TIFFClientInfoLink));
assert (link != NULL);
link->next = tif->tif_clientinfo;
link->name = (char *) _TIFFmalloc(strlen(name)+1);
link->name = (char *) _TIFFmalloc((tmsize_t)(strlen(name)+1));
assert (link->name != NULL);
strcpy(link->name, name);
link->data = data;

308
3rdparty/libtiff/tif_fax3.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_fax3.c,v 1.43.2.10 2010-06-09 17:16:58 bfriesen Exp $ */
/* $Id: tif_fax3.c,v 1.72 2010-06-09 17:17:13 bfriesen Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
@ -48,22 +48,19 @@
* derived from this ``base state'' block.
*/
typedef struct {
int rw_mode; /* O_RDONLY for decode, else encode */
int mode; /* operating mode */
uint32 rowbytes; /* bytes in a decoded scanline */
uint32 rowpixels; /* pixels in a scanline */
int rw_mode; /* O_RDONLY for decode, else encode */
int mode; /* operating mode */
tmsize_t rowbytes; /* bytes in a decoded scanline */
uint32 rowpixels; /* pixels in a scanline */
uint16 cleanfaxdata; /* CleanFaxData tag */
uint32 badfaxrun; /* BadFaxRun tag */
uint32 badfaxlines; /* BadFaxLines tag */
uint32 groupoptions; /* Group 3/4 options tag */
uint32 recvparams; /* encoded Class 2 session params */
char* subaddress; /* subaddress string */
uint32 recvtime; /* time spent receiving (secs) */
char* faxdcs; /* Table 2/T.30 encoded session params */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
uint16 cleanfaxdata; /* CleanFaxData tag */
uint32 badfaxrun; /* BadFaxRun tag */
uint32 badfaxlines; /* BadFaxLines tag */
uint32 groupoptions; /* Group 3/4 options tag */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
} Fax3BaseState;
#define Fax3State(tif) ((Fax3BaseState*) (tif)->tif_data)
@ -89,12 +86,11 @@ typedef struct {
int line;
} Fax3CodecState;
#define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif))
#define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif))
#define DecoderState(tif) ((Fax3CodecState*) Fax3State(tif))
#define EncoderState(tif) ((Fax3CodecState*) Fax3State(tif))
#define is2DEncoding(sp) \
(sp->b.groupoptions & GROUP3OPT_2DENCODING)
#define isAligned(p,t) ((((unsigned long)(p)) & (sizeof (t)-1)) == 0)
#define is2DEncoding(sp) (sp->b.groupoptions & GROUP3OPT_2DENCODING)
#define isAligned(p,t) ((((size_t)(p)) & (sizeof (t)-1)) == 0)
/*
* Group 3 and Group 4 Decoding.
@ -140,15 +136,15 @@ typedef struct {
sp->bit = BitsAvail; \
sp->data = BitAcc; \
sp->EOLcnt = EOLcnt; \
tif->tif_rawcc -= (tidata_t) cp - tif->tif_rawcp; \
tif->tif_rawcp = (tidata_t) cp; \
tif->tif_rawcc -= (tmsize_t)((uint8*) cp - tif->tif_rawcp); \
tif->tif_rawcp = (uint8*) cp; \
} while (0)
/*
* Setup state for decoding a strip.
*/
static int
Fax3PreDecode(TIFF* tif, tsample_t s)
Fax3PreDecode(TIFF* tif, uint16 s)
{
Fax3CodecState* sp = DecoderState(tif);
@ -183,10 +179,10 @@ Fax3PreDecode(TIFF* tif, tsample_t s)
static void
Fax3Unexpected(const char* module, TIFF* tif, uint32 line, uint32 a0)
{
TIFFErrorExt(tif->tif_clientdata, module, "%s: Bad code word at line %u of %s %u (x %u)",
tif->tif_name, line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
TIFFErrorExt(tif->tif_clientdata, module, "Bad code word at line %u of %s %u (x %u)",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
}
#define unexpected(table, a0) Fax3Unexpected(module, tif, sp->line, a0)
@ -194,33 +190,31 @@ static void
Fax3Extension(const char* module, TIFF* tif, uint32 line, uint32 a0)
{
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Uncompressed data (not supported) at line %u of %s %u (x %u)",
tif->tif_name, line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
"Uncompressed data (not supported) at line %u of %s %u (x %u)",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
}
#define extension(a0) Fax3Extension(module, tif, sp->line, a0)
static void
Fax3BadLength(const char* module, TIFF* tif, uint32 line, uint32 a0, uint32 lastx)
{
TIFFWarningExt(tif->tif_clientdata, module, "%s: %s at line %u of %s %u (got %u, expected %u)",
tif->tif_name,
a0 < lastx ? "Premature EOL" : "Line length mismatch",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0, lastx);
TIFFWarningExt(tif->tif_clientdata, module, "%s at line %u of %s %u (got %u, expected %u)",
a0 < lastx ? "Premature EOL" : "Line length mismatch",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0, lastx);
}
#define badlength(a0,lastx) Fax3BadLength(module, tif, sp->line, a0, lastx)
static void
Fax3PrematureEOF(const char* module, TIFF* tif, uint32 line, uint32 a0)
{
TIFFWarningExt(tif->tif_clientdata, module, "%s: Premature EOF at line %u of %s %u (x %u)",
tif->tif_name,
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
TIFFWarningExt(tif->tif_clientdata, module, "Premature EOF at line %u of %s %u (x %u)",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip),
a0);
}
#define prematureEOF(a0) Fax3PrematureEOF(module, tif, sp->line, a0)
@ -230,14 +224,18 @@ Fax3PrematureEOF(const char* module, TIFF* tif, uint32 line, uint32 a0)
* Decode the requested amount of G3 1D-encoded data.
*/
static int
Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
Fax3Decode1D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
DECLARE_STATE(tif, sp, "Fax3Decode1D");
(void) s;
if (occ % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (-1);
}
CACHE_STATE(tif, sp);
thisrun = sp->curruns;
while ((long)occ > 0) {
while (occ > 0) {
a0 = 0;
RunLength = 0;
pa = thisrun;
@ -269,14 +267,18 @@ Fax3Decode1D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
* Decode the requested amount of G3 2D-encoded data.
*/
static int
Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
Fax3Decode2D(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
DECLARE_STATE_2D(tif, sp, "Fax3Decode2D");
int is1D; /* current line is 1d/2d-encoded */
(void) s;
if (occ % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (-1);
}
CACHE_STATE(tif, sp);
while ((long)occ > 0) {
while (occ > 0) {
a0 = 0;
RunLength = 0;
pa = thisrun = sp->curruns;
@ -324,7 +326,7 @@ Fax3Decode2D(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
* this is <8 bytes. We optimize the code here to reflect the
* machine characteristics.
*/
#if SIZEOF_LONG == 8
#if SIZEOF_UNSIGNED_LONG == 8
# define FILL(n, cp) \
switch (n) { \
case 15:(cp)[14] = 0xff; case 14:(cp)[13] = 0xff; case 13: (cp)[12] = 0xff;\
@ -452,6 +454,13 @@ _TIFFFax3fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
#undef ZERO
#undef FILL
static int
Fax3FixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
/*
* Setup G3/G4-related compression/decompression state
* before data is processed. This routine is called once
@ -462,14 +471,16 @@ _TIFFFax3fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx)
static int
Fax3SetupState(TIFF* tif)
{
static const char module[] = "Fax3SetupState";
TIFFDirectory* td = &tif->tif_dir;
Fax3BaseState* sp = Fax3State(tif);
int needsRefLine;
Fax3CodecState* dsp = (Fax3CodecState*) Fax3State(tif);
uint32 rowbytes, rowpixels, nruns;
tmsize_t rowbytes;
uint32 rowpixels, nruns;
if (td->td_bitspersample != 1) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"Bits/sample must be 1 for Group 3/4 encoding/decoding");
return (0);
}
@ -483,8 +494,8 @@ Fax3SetupState(TIFF* tif)
rowbytes = TIFFScanlineSize(tif);
rowpixels = td->td_imagewidth;
}
sp->rowbytes = (uint32) rowbytes;
sp->rowpixels = (uint32) rowpixels;
sp->rowbytes = rowbytes;
sp->rowpixels = rowpixels;
/*
* Allocate any additional space required for decoding/encoding.
*/
@ -495,11 +506,11 @@ Fax3SetupState(TIFF* tif)
/*
Assure that allocation computations do not overflow.
TIFFroundup and TIFFSafeMultiply return zero on integer overflow
*/
dsp->runs=(uint32*) NULL;
nruns = TIFFroundup(rowpixels,32);
nruns = TIFFroundup_32(rowpixels,32);
if (needsRefLine) {
nruns = TIFFSafeMultiply(uint32,nruns,2);
}
@ -538,9 +549,8 @@ Fax3SetupState(TIFF* tif)
*/
esp->refline = (unsigned char*) _TIFFmalloc(rowbytes);
if (esp->refline == NULL) {
TIFFErrorExt(tif->tif_clientdata, "Fax3SetupState",
"%s: No space for Group 3/4 reference line",
tif->tif_name);
TIFFErrorExt(tif->tif_clientdata, module,
"No space for Group 3/4 reference line");
return (0);
}
} else /* 1d encoding */
@ -556,14 +566,14 @@ Fax3SetupState(TIFF* tif)
#define Fax3FlushBits(tif, sp) { \
if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
(void) TIFFFlushData1(tif); \
*(tif)->tif_rawcp++ = (tidataval_t) (sp)->data; \
*(tif)->tif_rawcp++ = (uint8) (sp)->data; \
(tif)->tif_rawcc++; \
(sp)->data = 0, (sp)->bit = 8; \
}
#define _FlushBits(tif) { \
if ((tif)->tif_rawcc >= (tif)->tif_rawdatasize) \
(void) TIFFFlushData1(tif); \
*(tif)->tif_rawcp++ = (tidataval_t) data; \
*(tif)->tif_rawcp++ = (uint8) data; \
(tif)->tif_rawcc++; \
data = 0, bit = 8; \
}
@ -575,6 +585,7 @@ static const int _msbmask[9] =
length -= bit; \
_FlushBits(tif); \
} \
assert( length < 9 ); \
data |= (bits & _msbmask[length]) << (bit - length); \
bit -= length; \
if (bit == 0) \
@ -702,7 +713,7 @@ Fax3PutEOL(TIFF* tif)
* Reset encoding state at the start of a strip.
*/
static int
Fax3PreEncode(TIFF* tif, tsample_t s)
Fax3PreEncode(TIFF* tif, uint16 s)
{
Fax3CodecState* sp = EncoderState(tif);
@ -1023,12 +1034,17 @@ Fax3Encode2DRow(TIFF* tif, unsigned char* bp, unsigned char* rp, uint32 bits)
* Encode a buffer of pixels.
*/
static int
Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
Fax3Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
static const char module[] = "Fax3Encode";
Fax3CodecState* sp = EncoderState(tif);
(void) s;
while ((long)cc > 0) {
if (cc % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
return (0);
}
while (cc > 0) {
if ((sp->b.mode & FAXMODE_NOEOL) == 0)
Fax3PutEOL(tif);
if (is2DEncoding(sp)) {
@ -1038,7 +1054,7 @@ Fax3Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
sp->tag = G3_2D;
} else {
if (!Fax3Encode2DRow(tif, bp, sp->refline,
sp->b.rowpixels))
sp->b.rowpixels))
return (0);
sp->k--;
}
@ -1100,11 +1116,6 @@ Fax3Cleanup(TIFF* tif)
if (sp->refline)
_TIFFfree(sp->refline);
if (Fax3State(tif)->subaddress)
_TIFFfree(Fax3State(tif)->subaddress);
if (Fax3State(tif)->faxdcs)
_TIFFfree(Fax3State(tif)->faxdcs);
_TIFFfree(tif->tif_data);
tif->tif_data = NULL;
@ -1114,59 +1125,34 @@ Fax3Cleanup(TIFF* tif)
#define FIELD_BADFAXLINES (FIELD_CODEC+0)
#define FIELD_CLEANFAXDATA (FIELD_CODEC+1)
#define FIELD_BADFAXRUN (FIELD_CODEC+2)
#define FIELD_RECVPARAMS (FIELD_CODEC+3)
#define FIELD_SUBADDRESS (FIELD_CODEC+4)
#define FIELD_RECVTIME (FIELD_CODEC+5)
#define FIELD_FAXDCS (FIELD_CODEC+6)
#define FIELD_OPTIONS (FIELD_CODEC+7)
static const TIFFFieldInfo faxFieldInfo[] = {
{ TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
FALSE, FALSE, "FaxMode" },
{ TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, FIELD_PSEUDO,
FALSE, FALSE, "FaxFillFunc" },
{ TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, FIELD_BADFAXLINES,
TRUE, FALSE, "BadFaxLines" },
{ TIFFTAG_BADFAXLINES, 1, 1, TIFF_SHORT, FIELD_BADFAXLINES,
TRUE, FALSE, "BadFaxLines" },
{ TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, FIELD_CLEANFAXDATA,
TRUE, FALSE, "CleanFaxData" },
{ TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_LONG, FIELD_BADFAXRUN,
TRUE, FALSE, "ConsecutiveBadFaxLines" },
{ TIFFTAG_CONSECUTIVEBADFAXLINES,1,1, TIFF_SHORT, FIELD_BADFAXRUN,
TRUE, FALSE, "ConsecutiveBadFaxLines" },
{ TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS,
TRUE, FALSE, "FaxRecvParams" },
{ TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS,
TRUE, FALSE, "FaxSubAddress" },
{ TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME,
TRUE, FALSE, "FaxRecvTime" },
{ TIFFTAG_FAXDCS, -1,-1, TIFF_ASCII, FIELD_FAXDCS,
TRUE, FALSE, "FaxDcs" },
static const TIFFField faxFields[] = {
{ TIFFTAG_FAXMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxMode", NULL },
{ TIFFTAG_FAXFILLFUNC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_OTHER, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "FaxFillFunc", NULL },
{ TIFFTAG_BADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXLINES, TRUE, FALSE, "BadFaxLines", NULL },
{ TIFFTAG_CLEANFAXDATA, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_CLEANFAXDATA, TRUE, FALSE, "CleanFaxData", NULL },
{ TIFFTAG_CONSECUTIVEBADFAXLINES, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_BADFAXRUN, TRUE, FALSE, "ConsecutiveBadFaxLines", NULL }};
static const TIFFField fax3Fields[] = {
{ TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group3Options", NULL },
};
static const TIFFFieldInfo fax3FieldInfo[] = {
{ TIFFTAG_GROUP3OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS,
FALSE, FALSE, "Group3Options" },
static const TIFFField fax4Fields[] = {
{ TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, TIFF_SETGET_UINT32, FIELD_OPTIONS, FALSE, FALSE, "Group4Options", NULL },
};
static const TIFFFieldInfo fax4FieldInfo[] = {
{ TIFFTAG_GROUP4OPTIONS, 1, 1, TIFF_LONG, FIELD_OPTIONS,
FALSE, FALSE, "Group4Options" },
};
#define N(a) (sizeof (a) / sizeof (a[0]))
static int
Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
Fax3VSetField(TIFF* tif, uint32 tag, va_list ap)
{
Fax3BaseState* sp = Fax3State(tif);
const TIFFFieldInfo* fip;
const TIFFField* fip;
assert(sp != 0);
assert(sp->vsetparent != 0);
switch (tag) {
case TIFFTAG_FAXMODE:
sp->mode = va_arg(ap, int);
sp->mode = (int) va_arg(ap, int);
return 1; /* NB: pseudo tag */
case TIFFTAG_FAXFILLFUNC:
DecoderState(tif)->fill = va_arg(ap, TIFFFaxFillFunc);
@ -1174,39 +1160,27 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
case TIFFTAG_GROUP3OPTIONS:
/* XXX: avoid reading options if compression mismatches. */
if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX3)
sp->groupoptions = va_arg(ap, uint32);
sp->groupoptions = (uint32) va_arg(ap, uint32);
break;
case TIFFTAG_GROUP4OPTIONS:
/* XXX: avoid reading options if compression mismatches. */
if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4)
sp->groupoptions = va_arg(ap, uint32);
sp->groupoptions = (uint32) va_arg(ap, uint32);
break;
case TIFFTAG_BADFAXLINES:
sp->badfaxlines = va_arg(ap, uint32);
sp->badfaxlines = (uint32) va_arg(ap, uint32);
break;
case TIFFTAG_CLEANFAXDATA:
sp->cleanfaxdata = (uint16) va_arg(ap, int);
sp->cleanfaxdata = (uint16) va_arg(ap, uint16_vap);
break;
case TIFFTAG_CONSECUTIVEBADFAXLINES:
sp->badfaxrun = va_arg(ap, uint32);
break;
case TIFFTAG_FAXRECVPARAMS:
sp->recvparams = va_arg(ap, uint32);
break;
case TIFFTAG_FAXSUBADDRESS:
_TIFFsetString(&sp->subaddress, va_arg(ap, char*));
break;
case TIFFTAG_FAXRECVTIME:
sp->recvtime = va_arg(ap, uint32);
break;
case TIFFTAG_FAXDCS:
_TIFFsetString(&sp->faxdcs, va_arg(ap, char*));
sp->badfaxrun = (uint32) va_arg(ap, uint32);
break;
default:
return (*sp->vsetparent)(tif, tag, ap);
}
if ((fip = _TIFFFieldWithTag(tif, tag)))
if ((fip = TIFFFieldWithTag(tif, tag)))
TIFFSetFieldBit(tif, fip->field_bit);
else
return 0;
@ -1216,7 +1190,7 @@ Fax3VSetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap)
Fax3VGetField(TIFF* tif, uint32 tag, va_list ap)
{
Fax3BaseState* sp = Fax3State(tif);
@ -1242,18 +1216,6 @@ Fax3VGetField(TIFF* tif, ttag_t tag, va_list ap)
case TIFFTAG_CONSECUTIVEBADFAXLINES:
*va_arg(ap, uint32*) = sp->badfaxrun;
break;
case TIFFTAG_FAXRECVPARAMS:
*va_arg(ap, uint32*) = sp->recvparams;
break;
case TIFFTAG_FAXSUBADDRESS:
*va_arg(ap, char**) = sp->subaddress;
break;
case TIFFTAG_FAXRECVTIME:
*va_arg(ap, uint32*) = sp->recvtime;
break;
case TIFFTAG_FAXDCS:
*va_arg(ap, char**) = sp->faxdcs;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
@ -1310,27 +1272,20 @@ Fax3PrintDir(TIFF* tif, FILE* fd, long flags)
if (TIFFFieldSet(tif,FIELD_BADFAXRUN))
fprintf(fd, " Consecutive Bad Fax Lines: %lu\n",
(unsigned long) sp->badfaxrun);
if (TIFFFieldSet(tif,FIELD_RECVPARAMS))
fprintf(fd, " Fax Receive Parameters: %08lx\n",
(unsigned long) sp->recvparams);
if (TIFFFieldSet(tif,FIELD_SUBADDRESS))
fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress);
if (TIFFFieldSet(tif,FIELD_RECVTIME))
fprintf(fd, " Fax Receive Time: %lu secs\n",
(unsigned long) sp->recvtime);
if (TIFFFieldSet(tif,FIELD_FAXDCS))
fprintf(fd, " Fax DCS: %s\n", sp->faxdcs);
if (sp->printdir)
(*sp->printdir)(tif, fd, flags);
}
static int
InitCCITTFax3(TIFF* tif)
{
static const char module[] = "InitCCITTFax3";
Fax3BaseState* sp;
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, faxFieldInfo, N(faxFieldInfo))) {
if (!_TIFFMergeFields(tif, faxFields, TIFFArrayCount(faxFields))) {
TIFFErrorExt(tif->tif_clientdata, "InitCCITTFax3",
"Merging common CCITT Fax codec-specific tags failed");
return 0;
@ -1339,12 +1294,12 @@ InitCCITTFax3(TIFF* tif)
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t)
tif->tif_data = (uint8*)
_TIFFmalloc(sizeof (Fax3CodecState));
if (tif->tif_data == NULL) {
TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3",
"%s: No space for state block", tif->tif_name);
TIFFErrorExt(tif->tif_clientdata, module,
"No space for state block");
return (0);
}
@ -1361,9 +1316,6 @@ InitCCITTFax3(TIFF* tif)
sp->printdir = tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir = Fax3PrintDir; /* hook for codec tags */
sp->groupoptions = 0;
sp->recvparams = 0;
sp->subaddress = NULL;
sp->faxdcs = NULL;
if (sp->rw_mode == O_RDONLY) /* FIXME: improve for in place update */
tif->tif_flags |= TIFF_NOBITREV; /* decoder does bit reversal */
@ -1374,6 +1326,7 @@ InitCCITTFax3(TIFF* tif)
/*
* Install codec methods.
*/
tif->tif_fixuptags = Fax3FixupTags;
tif->tif_setupdecode = Fax3SetupState;
tif->tif_predecode = Fax3PreDecode;
tif->tif_decoderow = Fax3Decode1D;
@ -1399,7 +1352,8 @@ TIFFInitCCITTFax3(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, fax3FieldInfo, N(fax3FieldInfo))) {
if (!_TIFFMergeFields(tif, fax3Fields,
TIFFArrayCount(fax3Fields))) {
TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax3",
"Merging CCITT Fax 3 codec-specific tags failed");
return 0;
@ -1418,18 +1372,22 @@ TIFFInitCCITTFax3(TIFF* tif, int scheme)
* Compression Scheme Support.
*/
#define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
#define SWAP(t,a,b) { t x; x = (a); (a) = (b); (b) = x; }
/*
* Decode the requested amount of G4-encoded data.
*/
static int
Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
Fax4Decode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
DECLARE_STATE_2D(tif, sp, "Fax4Decode");
(void) s;
if (occ % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (-1);
}
CACHE_STATE(tif, sp);
while ((long)occ > 0) {
while (occ > 0) {
a0 = 0;
RunLength = 0;
pa = thisrun = sp->curruns;
@ -1471,12 +1429,17 @@ Fax4Decode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
* Encode the requested amount of data.
*/
static int
Fax4Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
Fax4Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
static const char module[] = "Fax4Encode";
Fax3CodecState *sp = EncoderState(tif);
(void) s;
while ((long)cc > 0) {
if (cc % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be written");
return (0);
}
while (cc > 0) {
if (!Fax3Encode2DRow(tif, bp, sp->refline, sp->b.rowpixels))
return (0);
_TIFFmemcpy(sp->refline, bp, sp->b.rowbytes);
@ -1507,7 +1470,8 @@ TIFFInitCCITTFax4(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, fax4FieldInfo, N(fax4FieldInfo))) {
if (!_TIFFMergeFields(tif, fax4Fields,
TIFFArrayCount(fax4Fields))) {
TIFFErrorExt(tif->tif_clientdata, "TIFFInitCCITTFax4",
"Merging CCITT Fax 4 codec-specific tags failed");
return 0;
@ -1537,15 +1501,19 @@ TIFFInitCCITTFax4(TIFF* tif, int scheme)
* Decode the requested amount of RLE-encoded data.
*/
static int
Fax3DecodeRLE(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
Fax3DecodeRLE(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
DECLARE_STATE(tif, sp, "Fax3DecodeRLE");
int mode = sp->b.mode;
(void) s;
if (occ % sp->b.rowbytes)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (-1);
}
CACHE_STATE(tif, sp);
thisrun = sp->curruns;
while ((long)occ > 0) {
while (occ > 0) {
a0 = 0;
RunLength = 0;
pa = thisrun;
@ -1605,7 +1573,7 @@ TIFFInitCCITTRLEW(TIFF* tif, int scheme)
if (InitCCITTFax3(tif)) { /* reuse G3 support */
tif->tif_decoderow = Fax3DecodeRLE;
tif->tif_decodestrip = Fax3DecodeRLE;
tif->tif_decodetile = Fax3DecodeRLE;
tif->tif_decodetile = Fax3DecodeRLE;
/*
* Suppress RTC+EOLs when encoding and word-align data.
*/

46
3rdparty/libtiff/tif_fax3.h vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_fax3.h,v 1.5.2.3 2011-03-10 20:22:33 fwarmerdam Exp $ */
/* $Id: tif_fax3.h,v 1.9 2011-03-10 20:23:07 fwarmerdam Exp $ */
/*
* Copyright (c) 1990-1997 Sam Leffler
@ -52,7 +52,7 @@
* data in the run array as needed (e.g. to append zero runs to bring
* the count up to a nice multiple).
*/
typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
/*
* The default run filler; made external for other decoders.
@ -60,36 +60,36 @@ typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32*, uint32*, uint32);
#if defined(__cplusplus)
extern "C" {
#endif
extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
#if defined(__cplusplus)
}
#endif
/* finite state machine codes */
#define S_Null 0
#define S_Pass 1
#define S_Horiz 2
#define S_V0 3
#define S_VR 4
#define S_VL 5
#define S_Ext 6
#define S_TermW 7
#define S_TermB 8
#define S_MakeUpW 9
#define S_MakeUpB 10
#define S_MakeUp 11
#define S_EOL 12
#define S_Null 0
#define S_Pass 1
#define S_Horiz 2
#define S_V0 3
#define S_VR 4
#define S_VL 5
#define S_Ext 6
#define S_TermW 7
#define S_TermB 8
#define S_MakeUpW 9
#define S_MakeUpB 10
#define S_MakeUp 11
#define S_EOL 12
typedef struct { /* state table entry */
unsigned char State; /* see above */
unsigned char Width; /* width of code in bits */
uint32 Param; /* unsigned 32-bit run length in bits */
typedef struct { /* state table entry */
unsigned char State; /* see above */
unsigned char Width; /* width of code in bits */
uint32 Param; /* unsigned 32-bit run length in bits */
} TIFFFaxTabEnt;
extern const TIFFFaxTabEnt TIFFFaxMainTable[];
extern const TIFFFaxTabEnt TIFFFaxWhiteTable[];
extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
extern const TIFFFaxTabEnt TIFFFaxMainTable[];
extern const TIFFFaxTabEnt TIFFFaxWhiteTable[];
extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
/*
* The following macros define the majority of the G3/G4 decoder

64
3rdparty/libtiff/tif_flush.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_flush.c,v 1.3.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_flush.c,v 1.9 2010-03-31 06:40:10 fwarmerdam Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -32,15 +32,58 @@
int
TIFFFlush(TIFF* tif)
{
if( tif->tif_mode == O_RDONLY )
return 1;
if (tif->tif_mode != O_RDONLY) {
if (!TIFFFlushData(tif))
return (0);
if ((tif->tif_flags & TIFF_DIRTYDIRECT) &&
!TIFFWriteDirectory(tif))
return (0);
}
return (1);
if (!TIFFFlushData(tif))
return (0);
/* In update (r+) mode we try to detect the case where
only the strip/tile map has been altered, and we try to
rewrite only that portion of the directory without
making any other changes */
if( (tif->tif_flags & TIFF_DIRTYSTRIP)
&& !(tif->tif_flags & TIFF_DIRTYDIRECT)
&& tif->tif_mode == O_RDWR )
{
uint64 *offsets=NULL, *sizes=NULL;
if( TIFFIsTiled(tif) )
{
if( TIFFGetField( tif, TIFFTAG_TILEOFFSETS, &offsets )
&& TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &sizes )
&& _TIFFRewriteField( tif, TIFFTAG_TILEOFFSETS, TIFF_LONG8,
tif->tif_dir.td_nstrips, offsets )
&& _TIFFRewriteField( tif, TIFFTAG_TILEBYTECOUNTS, TIFF_LONG8,
tif->tif_dir.td_nstrips, sizes ) )
{
tif->tif_flags &= ~TIFF_DIRTYSTRIP;
tif->tif_flags &= ~TIFF_BEENWRITING;
return 1;
}
}
else
{
if( TIFFGetField( tif, TIFFTAG_STRIPOFFSETS, &offsets )
&& TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &sizes )
&& _TIFFRewriteField( tif, TIFFTAG_STRIPOFFSETS, TIFF_LONG8,
tif->tif_dir.td_nstrips, offsets )
&& _TIFFRewriteField( tif, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG8,
tif->tif_dir.td_nstrips, sizes ) )
{
tif->tif_flags &= ~TIFF_DIRTYSTRIP;
tif->tif_flags &= ~TIFF_BEENWRITING;
return 1;
}
}
}
if ((tif->tif_flags & (TIFF_DIRTYDIRECT|TIFF_DIRTYSTRIP))
&& !TIFFRewriteDirectory(tif))
return (0);
return (1);
}
/*
@ -56,7 +99,7 @@ int
TIFFFlushData(TIFF* tif)
{
if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
return (0);
return (1);
if (tif->tif_flags & TIFF_POSTENCODE) {
tif->tif_flags &= ~TIFF_POSTENCODE;
if (!(*tif->tif_postencode)(tif))
@ -65,6 +108,7 @@ TIFFFlushData(TIFF* tif)
return (TIFFFlushData1(tif));
}
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c

317
3rdparty/libtiff/tif_getimage.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_getimage.c,v 1.63.2.6 2010-07-02 13:38:27 dron Exp $ */
/* $Id: tif_getimage.c,v 1.78 2011-02-23 21:46:09 fwarmerdam Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@ -38,6 +38,10 @@ static int gtStripContig(TIFFRGBAImage*, uint32*, uint32, uint32);
static int gtStripSeparate(TIFFRGBAImage*, uint32*, uint32, uint32);
static int PickContigCase(TIFFRGBAImage*);
static int PickSeparateCase(TIFFRGBAImage*);
static int BuildMapUaToAa(TIFFRGBAImage* img);
static int BuildMapBitdepth16To8(TIFFRGBAImage* img);
static const char photoTag[] = "PhotometricInterpretation";
/*
@ -50,7 +54,7 @@ static const char photoTag[] = "PhotometricInterpretation";
* Color conversion constants. We will define display types here.
*/
TIFFDisplay display_sRGB = {
static const TIFFDisplay display_sRGB = {
{ /* XYZ -> luminance matrix */
{ 3.2410F, -1.5374F, -0.4986F },
{ -0.9692F, 1.8760F, 0.0416F },
@ -202,10 +206,16 @@ TIFFRGBAImageEnd(TIFFRGBAImage* img)
_TIFFfree(img->ycbcr), img->ycbcr = NULL;
if (img->cielab)
_TIFFfree(img->cielab), img->cielab = NULL;
if (img->UaToAa)
_TIFFfree(img->UaToAa), img->UaToAa = NULL;
if (img->Bitdepth16To8)
_TIFFfree(img->Bitdepth16To8), img->Bitdepth16To8 = NULL;
if( img->redcmap ) {
_TIFFfree( img->redcmap );
_TIFFfree( img->greencmap );
_TIFFfree( img->bluecmap );
img->redcmap = img->greencmap = img->bluecmap = NULL;
}
}
@ -252,7 +262,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
default:
sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
img->bitspersample);
return (0);
goto fail_return;
}
img->alpha = 0;
TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
@ -301,7 +311,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
break;
default:
sprintf(emsg, "Missing needed %s tag", photoTag);
return (0);
goto fail_return;
}
}
switch (img->photometric) {
@ -309,7 +319,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
&red_orig, &green_orig, &blue_orig)) {
sprintf(emsg, "Missing required \"Colormap\" tag");
return (0);
goto fail_return;
}
/* copy the colormaps so we can modify them */
@ -319,7 +329,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
if( !img->redcmap || !img->greencmap || !img->bluecmap ) {
sprintf(emsg, "Out of memory for colormap copy");
return (0);
goto fail_return;
}
_TIFFmemcpy( img->redcmap, red_orig, n_color * 2 );
@ -338,7 +348,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
photoTag, img->photometric,
"Samples/pixel", img->samplesperpixel,
img->bitspersample);
return (0);
goto fail_return;
}
break;
case PHOTOMETRIC_YCBCR:
@ -371,7 +381,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
if (colorchannels < 3) {
sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
"Color channels", colorchannels);
return (0);
goto fail_return;
}
break;
case PHOTOMETRIC_SEPARATED:
@ -381,12 +391,12 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
if (inkset != INKSET_CMYK) {
sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
"InkSet", inkset);
return (0);
goto fail_return;
}
if (img->samplesperpixel < 4) {
sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
"Samples/pixel", img->samplesperpixel);
return (0);
goto fail_return;
}
}
break;
@ -394,7 +404,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
if (compress != COMPRESSION_SGILOG) {
sprintf(emsg, "Sorry, LogL data must have %s=%d",
"Compression", COMPRESSION_SGILOG);
return (0);
goto fail_return;
}
TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
img->photometric = PHOTOMETRIC_MINISBLACK; /* little white lie */
@ -404,7 +414,7 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) {
sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
"Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
return (0);
goto fail_return;
}
if (planarconfig != PLANARCONFIG_CONTIG) {
sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
@ -420,30 +430,39 @@ TIFFRGBAImageBegin(TIFFRGBAImage* img, TIFF* tif, int stop, char emsg[1024])
default:
sprintf(emsg, "Sorry, can not handle image with %s=%d",
photoTag, img->photometric);
return (0);
goto fail_return;
}
img->Map = NULL;
img->BWmap = NULL;
img->PALmap = NULL;
img->ycbcr = NULL;
img->cielab = NULL;
img->UaToAa = NULL;
img->Bitdepth16To8 = NULL;
TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
img->isContig =
!(planarconfig == PLANARCONFIG_SEPARATE && colorchannels > 1);
!(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1);
if (img->isContig) {
if (!PickContigCase(img)) {
sprintf(emsg, "Sorry, can not handle image");
return 0;
goto fail_return;
}
} else {
if (!PickSeparateCase(img)) {
sprintf(emsg, "Sorry, can not handle image");
return 0;
goto fail_return;
}
}
return 1;
fail_return:
_TIFFfree( img->redcmap );
_TIFFfree( img->greencmap );
_TIFFfree( img->bluecmap );
img->redcmap = img->greencmap = img->bluecmap = NULL;
return 0;
}
int
@ -572,7 +591,7 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint32 col, row, y, rowstoread;
uint32 pos;
tmsize_t pos;
uint32 tw, th;
unsigned char* buf;
int32 fromskew, toskew;
@ -581,7 +600,7 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
buf = (unsigned char*) _TIFFmalloc(TIFFTileSize(tif));
if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");
return (0);
}
_TIFFmemset(buf, 0, TIFFTileSize(tif));
@ -604,14 +623,14 @@ gtTileContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
nrow = (row + rowstoread > h ? h - row : rowstoread);
for (col = 0; col < w; col += tw)
{
if ((int)TIFFReadTile(tif, buf, col+img->col_offset,
row+img->row_offset, 0, 0) < 0 && img->stoponerr)
if (TIFFReadTile(tif, buf, col+img->col_offset,
row+img->row_offset, 0, 0)==(tmsize_t)(-1) && img->stoponerr)
{
ret = 0;
break;
}
pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
if (col + tw > w)
{
@ -665,23 +684,24 @@ gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
TIFF* tif = img->tif;
tileSeparateRoutine put = img->put.separate;
uint32 col, row, y, rowstoread;
uint32 pos;
tmsize_t pos;
uint32 tw, th;
unsigned char* buf;
unsigned char* p0;
unsigned char* p1;
unsigned char* p2;
unsigned char* pa;
tsize_t tilesize;
tmsize_t tilesize;
int32 fromskew, toskew;
int alpha = img->alpha;
uint32 nrow;
int ret = 1, flip;
int colorchannels;
tilesize = TIFFTileSize(tif);
tilesize = TIFFTileSize(tif);
buf = (unsigned char*) _TIFFmalloc((alpha?4:3)*tilesize);
if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", "No space for tile buffer");
return (0);
}
_TIFFmemset(buf, 0, (alpha?4:3)*tilesize);
@ -702,41 +722,58 @@ gtTileSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
toskew = -(int32)(tw - w);
}
switch( img->photometric )
{
case PHOTOMETRIC_MINISWHITE:
case PHOTOMETRIC_MINISBLACK:
case PHOTOMETRIC_PALETTE:
colorchannels = 1;
p2 = p1 = p0;
break;
default:
colorchannels = 3;
break;
}
for (row = 0; row < h; row += nrow)
{
rowstoread = th - (row + img->row_offset) % th;
nrow = (row + rowstoread > h ? h - row : rowstoread);
for (col = 0; col < w; col += tw)
{
if ((int)TIFFReadTile(tif, p0, col+img->col_offset,
row+img->row_offset,0,0) < 0 && img->stoponerr)
if (TIFFReadTile(tif, p0, col+img->col_offset,
row+img->row_offset,0,0)==(tmsize_t)(-1) && img->stoponerr)
{
ret = 0;
break;
}
if ((int)TIFFReadTile(tif, p1, col+img->col_offset,
row+img->row_offset,0,1) < 0 && img->stoponerr)
if (colorchannels > 1
&& TIFFReadTile(tif, p1, col+img->col_offset,
row+img->row_offset,0,1) == (tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
break;
}
if ((int)TIFFReadTile(tif, p2, col+img->col_offset,
row+img->row_offset,0,2) < 0 && img->stoponerr)
if (colorchannels > 1
&& TIFFReadTile(tif, p2, col+img->col_offset,
row+img->row_offset,0,2) == (tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
break;
}
if (alpha)
{
if ((int)TIFFReadTile(tif,pa,col+img->col_offset,
row+img->row_offset,0,3) < 0 && img->stoponerr)
{
ret = 0;
break;
}
if (alpha
&& TIFFReadTile(tif,pa,col+img->col_offset,
row+img->row_offset,0,colorchannels) == (tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
break;
}
pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
pos = ((row+img->row_offset) % th) * TIFFTileRowSize(tif);
if (col + tw > w)
{
@ -790,12 +827,12 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
TIFF* tif = img->tif;
tileContigRoutine put = img->put.contig;
uint32 row, y, nrow, nrowsub, rowstoread;
uint32 pos;
tmsize_t pos;
unsigned char* buf;
uint32 rowsperstrip;
uint16 subsamplinghor,subsamplingver;
uint32 imagewidth = img->width;
tsize_t scanline;
tmsize_t scanline;
int32 fromskew, toskew;
int ret = 1, flip;
@ -817,7 +854,7 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING, &subsamplinghor, &subsamplingver);
scanline = TIFFNewScanlineSize(tif);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0);
for (row = 0; row < h; row += nrow)
{
@ -826,10 +863,10 @@ gtStripContig(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
nrowsub = nrow;
if ((nrowsub%subsamplingver)!=0)
nrowsub+=subsamplingver-nrowsub%subsamplingver;
if ((int)TIFFReadEncodedStrip(tif,
if (TIFFReadEncodedStrip(tif,
TIFFComputeStrip(tif,row+img->row_offset, 0),
buf,
((row + img->row_offset)%rowsperstrip + nrowsub) * scanline) < 0
((row + img->row_offset)%rowsperstrip + nrowsub) * scanline)==(tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
@ -875,16 +912,16 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
unsigned char *buf;
unsigned char *p0, *p1, *p2, *pa;
uint32 row, y, nrow, rowstoread;
uint32 pos;
tsize_t scanline;
tmsize_t pos;
tmsize_t scanline;
uint32 rowsperstrip, offset_row;
uint32 imagewidth = img->width;
tsize_t stripsize;
tmsize_t stripsize;
int32 fromskew, toskew;
int alpha = img->alpha;
int ret = 1, flip;
int ret = 1, flip, colorchannels;
stripsize = TIFFStripSize(tif);
stripsize = TIFFStripSize(tif);
p0 = buf = (unsigned char *)_TIFFmalloc((alpha?4:3)*stripsize);
if (buf == 0) {
TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for tile buffer");
@ -905,30 +942,46 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
toskew = -(int32)(w - w);
}
switch( img->photometric )
{
case PHOTOMETRIC_MINISWHITE:
case PHOTOMETRIC_MINISBLACK:
case PHOTOMETRIC_PALETTE:
colorchannels = 1;
p2 = p1 = p0;
break;
default:
colorchannels = 3;
break;
}
TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
scanline = TIFFScanlineSize(tif);
scanline = TIFFScanlineSize(tif);
fromskew = (w < imagewidth ? imagewidth - w : 0);
for (row = 0; row < h; row += nrow)
{
rowstoread = rowsperstrip - (row + img->row_offset) % rowsperstrip;
nrow = (row + rowstoread > h ? h - row : rowstoread);
offset_row = row + img->row_offset;
if ((int)TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 0),
p0, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
break;
}
if ((int)TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
if (colorchannels > 1
&& TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 1),
p1, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
break;
}
if ((int)TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
if (colorchannels > 1
&& TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 2),
p2, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) == (tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
@ -936,8 +989,8 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
}
if (alpha)
{
if ((int)TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, 3),
pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline) < 0
if (TIFFReadEncodedStrip(tif, TIFFComputeStrip(tif, offset_row, colorchannels),
pa, ((row + img->row_offset)%rowsperstrip + nrow) * scanline)==(tmsize_t)(-1)
&& img->stoponerr)
{
ret = 0;
@ -1036,6 +1089,7 @@ gtStripSeparate(TIFFRGBAImage* img, uint32* raster, uint32 w, uint32 h)
#define PACK4(r,g,b,a) \
((uint32)(r)|((uint32)(g)<<8)|((uint32)(b)<<16)|((uint32)(a)<<24))
#define W2B(v) (((v)>>8)&0xff)
/* TODO: PACKW should have be made redundant in favor of Bitdepth16To8 LUT */
#define PACKW(r,g,b) \
((uint32)W2B(r)|((uint32)W2B(g)<<8)|((uint32)W2B(b)<<16)|A1)
#define PACKW4(r,g,b,a) \
@ -1266,11 +1320,13 @@ DECLAREContigPutFunc(putRGBUAcontig8bittile)
fromskew *= samplesperpixel;
while (h-- > 0) {
uint32 r, g, b, a;
uint8* m;
for (x = w; x-- > 0;) {
a = pp[3];
r = (a*pp[0] + 127) / 255;
g = (a*pp[1] + 127) / 255;
b = (a*pp[2] + 127) / 255;
m = img->UaToAa+(a<<8);
r = m[pp[0]];
g = m[pp[1]];
b = m[pp[2]];
*cp++ = PACK4(r,g,b,a);
pp += samplesperpixel;
}
@ -1290,8 +1346,10 @@ DECLAREContigPutFunc(putRGBcontig16bittile)
fromskew *= samplesperpixel;
while (h-- > 0) {
for (x = w; x-- > 0;) {
*cp++ = PACKW(wp[0],wp[1],wp[2]);
wp += samplesperpixel;
*cp++ = PACK(img->Bitdepth16To8[wp[0]],
img->Bitdepth16To8[wp[1]],
img->Bitdepth16To8[wp[2]]);
wp += samplesperpixel;
}
cp += toskew;
wp += fromskew;
@ -1310,8 +1368,11 @@ DECLAREContigPutFunc(putRGBAAcontig16bittile)
fromskew *= samplesperpixel;
while (h-- > 0) {
for (x = w; x-- > 0;) {
*cp++ = PACKW4(wp[0],wp[1],wp[2],wp[3]);
wp += samplesperpixel;
*cp++ = PACK4(img->Bitdepth16To8[wp[0]],
img->Bitdepth16To8[wp[1]],
img->Bitdepth16To8[wp[2]],
img->Bitdepth16To8[wp[3]]);
wp += samplesperpixel;
}
cp += toskew;
wp += fromskew;
@ -1330,13 +1391,15 @@ DECLAREContigPutFunc(putRGBUAcontig16bittile)
fromskew *= samplesperpixel;
while (h-- > 0) {
uint32 r,g,b,a;
uint8* m;
for (x = w; x-- > 0;) {
a = W2B(wp[3]);
r = (a*W2B(wp[0]) + 127) / 255;
g = (a*W2B(wp[1]) + 127) / 255;
b = (a*W2B(wp[2]) + 127) / 255;
*cp++ = PACK4(r,g,b,a);
wp += samplesperpixel;
a = img->Bitdepth16To8[wp[3]];
m = img->UaToAa+(a<<8);
r = m[img->Bitdepth16To8[wp[0]]];
g = m[img->Bitdepth16To8[wp[1]]];
b = m[img->Bitdepth16To8[wp[2]]];
*cp++ = PACK4(r,g,b,a);
wp += samplesperpixel;
}
cp += toskew;
wp += fromskew;
@ -1423,7 +1486,7 @@ DECLARESepPutFunc(putRGBseparate8bittile)
*/
DECLARESepPutFunc(putRGBAAseparate8bittile)
{
(void) img; (void) x; (void) y;
(void) img; (void) x; (void) y;
while (h-- > 0) {
UNROLL8(w, NOP, *cp++ = PACK4(*r++, *g++, *b++, *a++));
SKEW4(r, g, b, a, fromskew);
@ -1439,11 +1502,13 @@ DECLARESepPutFunc(putRGBUAseparate8bittile)
(void) img; (void) y;
while (h-- > 0) {
uint32 rv, gv, bv, av;
uint8* m;
for (x = w; x-- > 0;) {
av = *a++;
rv = (av* *r++ + 127) / 255;
gv = (av* *g++ + 127) / 255;
bv = (av* *b++ + 127) / 255;
m = img->UaToAa+(av<<8);
rv = m[*r++];
gv = m[*g++];
bv = m[*b++];
*cp++ = PACK4(rv,gv,bv,av);
}
SKEW4(r, g, b, a, fromskew);
@ -1462,7 +1527,9 @@ DECLARESepPutFunc(putRGBseparate16bittile)
(void) img; (void) y; (void) a;
while (h-- > 0) {
for (x = 0; x < w; x++)
*cp++ = PACKW(*wr++,*wg++,*wb++);
*cp++ = PACK(img->Bitdepth16To8[*wr++],
img->Bitdepth16To8[*wg++],
img->Bitdepth16To8[*wb++]);
SKEW(wr, wg, wb, fromskew);
cp += toskew;
}
@ -1480,7 +1547,10 @@ DECLARESepPutFunc(putRGBAAseparate16bittile)
(void) img; (void) y;
while (h-- > 0) {
for (x = 0; x < w; x++)
*cp++ = PACKW4(*wr++,*wg++,*wb++,*wa++);
*cp++ = PACK4(img->Bitdepth16To8[*wr++],
img->Bitdepth16To8[*wg++],
img->Bitdepth16To8[*wb++],
img->Bitdepth16To8[*wa++]);
SKEW4(wr, wg, wb, wa, fromskew);
cp += toskew;
}
@ -1498,12 +1568,14 @@ DECLARESepPutFunc(putRGBUAseparate16bittile)
(void) img; (void) y;
while (h-- > 0) {
uint32 r,g,b,a;
uint8* m;
for (x = w; x-- > 0;) {
a = W2B(*wa++);
r = (a*W2B(*wr++) + 127) / 255;
g = (a*W2B(*wg++) + 127) / 255;
b = (a*W2B(*wb++) + 127) / 255;
*cp++ = PACK4(r,g,b,a);
a = img->Bitdepth16To8[*wa++];
m = img->UaToAa+(a<<8);
r = m[img->Bitdepth16To8[*wr++]];
g = m[img->Bitdepth16To8[*wg++]];
b = m[img->Bitdepth16To8[*wb++]];
*cp++ = PACK4(r,g,b,a);
}
SKEW4(wr, wg, wb, wa, fromskew);
cp += toskew;
@ -2018,13 +2090,13 @@ DECLARESepPutFunc(putseparate8bitYCbCr11tile)
static int
initYCbCrConversion(TIFFRGBAImage* img)
{
static char module[] = "initYCbCrConversion";
static const char module[] = "initYCbCrConversion";
float *luma, *refBlackWhite;
if (img->ycbcr == NULL) {
img->ycbcr = (TIFFYCbCrToRGB*) _TIFFmalloc(
TIFFroundup(sizeof (TIFFYCbCrToRGB), sizeof (long))
TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long))
+ 4*256*sizeof (TIFFRGBValue)
+ 2*256*sizeof (int)
+ 3*256*sizeof (int32)
@ -2047,7 +2119,7 @@ initYCbCrConversion(TIFFRGBAImage* img)
static tileContigRoutine
initCIELabConversion(TIFFRGBAImage* img)
{
static char module[] = "initCIELabConversion";
static const char module[] = "initCIELabConversion";
float *whitePoint;
float refWhite[3];
@ -2327,23 +2399,28 @@ PickContigCase(TIFFRGBAImage* img)
img->put.contig = putRGBAAcontig8bittile;
else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
{
img->put.contig = putRGBUAcontig8bittile;
if (BuildMapUaToAa(img))
img->put.contig = putRGBUAcontig8bittile;
}
else
img->put.contig = putRGBcontig8bittile;
img->put.contig = putRGBcontig8bittile;
break;
case 16:
if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
{
img->put.contig = putRGBAAcontig16bittile;
if (BuildMapBitdepth16To8(img))
img->put.contig = putRGBAAcontig16bittile;
}
else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
{
img->put.contig = putRGBUAcontig16bittile;
if (BuildMapBitdepth16To8(img) &&
BuildMapUaToAa(img))
img->put.contig = putRGBUAcontig16bittile;
}
else
{
img->put.contig = putRGBcontig16bittile;
if (BuildMapBitdepth16To8(img))
img->put.contig = putRGBcontig16bittile;
}
break;
}
@ -2463,6 +2540,9 @@ PickSeparateCase(TIFFRGBAImage* img)
img->get = TIFFIsTiled(img->tif) ? gtTileSeparate : gtStripSeparate;
img->put.separate = NULL;
switch (img->photometric) {
case PHOTOMETRIC_MINISWHITE:
case PHOTOMETRIC_MINISBLACK:
/* greyscale images processed pretty much as RGB by gtTileSeparate */
case PHOTOMETRIC_RGB:
switch (img->bitspersample) {
case 8:
@ -2470,7 +2550,8 @@ PickSeparateCase(TIFFRGBAImage* img)
img->put.separate = putRGBAAseparate8bittile;
else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
{
img->put.separate = putRGBUAseparate8bittile;
if (BuildMapUaToAa(img))
img->put.separate = putRGBUAseparate8bittile;
}
else
img->put.separate = putRGBseparate8bittile;
@ -2478,15 +2559,19 @@ PickSeparateCase(TIFFRGBAImage* img)
case 16:
if (img->alpha == EXTRASAMPLE_ASSOCALPHA)
{
img->put.separate = putRGBAAseparate16bittile;
if (BuildMapBitdepth16To8(img))
img->put.separate = putRGBAAseparate16bittile;
}
else if (img->alpha == EXTRASAMPLE_UNASSALPHA)
{
img->put.separate = putRGBUAseparate16bittile;
if (BuildMapBitdepth16To8(img) &&
BuildMapUaToAa(img))
img->put.separate = putRGBUAseparate16bittile;
}
else
{
img->put.separate = putRGBseparate16bittile;
if (BuildMapBitdepth16To8(img))
img->put.separate = putRGBseparate16bittile;
}
break;
}
@ -2511,6 +2596,48 @@ PickSeparateCase(TIFFRGBAImage* img)
return ((img->get!=NULL) && (img->put.separate!=NULL));
}
static int
BuildMapUaToAa(TIFFRGBAImage* img)
{
static const char module[]="BuildMapUaToAa";
uint8* m;
uint16 na,nv;
assert(img->UaToAa==NULL);
img->UaToAa=_TIFFmalloc(65536);
if (img->UaToAa==NULL)
{
TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory");
return(0);
}
m=img->UaToAa;
for (na=0; na<256; na++)
{
for (nv=0; nv<256; nv++)
*m++=(nv*na+127)/255;
}
return(1);
}
static int
BuildMapBitdepth16To8(TIFFRGBAImage* img)
{
static const char module[]="BuildMapBitdepth16To8";
uint8* m;
uint32 n;
assert(img->Bitdepth16To8==NULL);
img->Bitdepth16To8=_TIFFmalloc(65536);
if (img->Bitdepth16To8==NULL)
{
TIFFErrorExt(img->tif->tif_clientdata,module,"Out of memory");
return(0);
}
m=img->Bitdepth16To8;
for (n=0; n<65536; n++)
*m++=(n+128)/257;
return(1);
}
/*
* Read a whole strip off data from the file, and convert to RGBA form.
* If this is the last strip, then it will only contain the portion of

404
3rdparty/libtiff/tif_jbig.c vendored
View File

@ -1,26 +1,26 @@
/* $Id: tif_jbig.c,v 1.2.2.3 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_jbig.c,v 1.15 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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
* 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.
*/
@ -29,7 +29,7 @@
*
* JBIG Compression Algorithm Support.
* Contributed by Lee Howard <faxguy@deanox.com>
*
*
*/
#include "tiffiop.h"
@ -37,339 +37,167 @@
#ifdef JBIG_SUPPORT
#include "jbig.h"
typedef struct
{
uint32 recvparams; /* encoded Class 2 session params */
char* subaddress; /* subaddress string */
uint32 recvtime; /* time spend receiving in seconds */
char* faxdcs; /* encoded fax parameters (DCS, Table 2/T.30) */
TIFFVGetMethod vgetparent;
TIFFVSetMethod vsetparent;
} JBIGState;
#define GetJBIGState(tif) ((JBIGState*)(tif)->tif_data)
#define FIELD_RECVPARAMS (FIELD_CODEC+0)
#define FIELD_SUBADDRESS (FIELD_CODEC+1)
#define FIELD_RECVTIME (FIELD_CODEC+2)
#define FIELD_FAXDCS (FIELD_CODEC+3)
static const TIFFFieldInfo jbigFieldInfo[] =
{
{TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS, TRUE, FALSE, "FaxRecvParams"},
{TIFFTAG_FAXSUBADDRESS, -1, -1, TIFF_ASCII, FIELD_SUBADDRESS, TRUE, FALSE, "FaxSubAddress"},
{TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME, TRUE, FALSE, "FaxRecvTime"},
{TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, FIELD_FAXDCS, TRUE, FALSE, "FaxDcs"},
};
static int JBIGSetupDecode(TIFF* tif)
{
if (TIFFNumberOfStrips(tif) != 1)
{
TIFFError("JBIG", "Multistrip images not supported in decoder");
return 0;
}
if (TIFFNumberOfStrips(tif) != 1)
{
TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in decoder");
return 0;
}
return 1;
return 1;
}
static int JBIGDecode(TIFF* tif, tidata_t buffer, tsize_t size, tsample_t s)
static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
{
struct jbg_dec_state decoder;
int decodeStatus = 0;
unsigned char* pImage = NULL;
struct jbg_dec_state decoder;
int decodeStatus = 0;
unsigned char* pImage = NULL;
(void) size, (void) s;
if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{
TIFFReverseBits(tif->tif_rawdata, tif->tif_rawdatasize);
}
if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{
TIFFReverseBits(tif->tif_rawdata, tif->tif_rawdatasize);
}
jbg_dec_init(&decoder);
jbg_dec_init(&decoder);
#if defined(HAVE_JBG_NEWLEN)
jbg_newlen(tif->tif_rawdata, tif->tif_rawdatasize);
/*
* I do not check the return status of jbg_newlen because even if this
* function fails it does not necessarily mean that decoding the image
* will fail. It is generally only needed for received fax images
* that do not contain the actual length of the image in the BIE
* header. I do not log when an error occurs because that will cause
* problems when converting JBIG encoded TIFF's to
* PostScript. As long as the actual image length is contained in the
* BIE header jbg_dec_in should succeed.
*/
jbg_newlen(tif->tif_rawdata, (size_t)tif->tif_rawdatasize);
/*
* I do not check the return status of jbg_newlen because even if this
* function fails it does not necessarily mean that decoding the image
* will fail. It is generally only needed for received fax images
* that do not contain the actual length of the image in the BIE
* header. I do not log when an error occurs because that will cause
* problems when converting JBIG encoded TIFF's to
* PostScript. As long as the actual image length is contained in the
* BIE header jbg_dec_in should succeed.
*/
#endif /* HAVE_JBG_NEWLEN */
decodeStatus = jbg_dec_in(&decoder, tif->tif_rawdata,
tif->tif_rawdatasize, NULL);
if (JBG_EOK != decodeStatus)
{
decodeStatus = jbg_dec_in(&decoder, (unsigned char*)tif->tif_rawdata,
(size_t)tif->tif_rawdatasize, NULL);
if (JBG_EOK != decodeStatus)
{
/*
* XXX: JBG_EN constant was defined in pre-2.0 releases of the
* JBIG-KIT. Since the 2.0 the error reporting functions were
* changed. We will handle both cases here.
*/
TIFFError("JBIG", "Error (%d) decoding: %s", decodeStatus,
TIFFErrorExt(tif->tif_clientdata,
"JBIG", "Error (%d) decoding: %s",
decodeStatus,
#if defined(JBG_EN)
jbg_strerror(decodeStatus, JBG_EN)
jbg_strerror(decodeStatus, JBG_EN)
#else
jbg_strerror(decodeStatus)
jbg_strerror(decodeStatus)
#endif
);
return 0;
}
pImage = jbg_dec_getimage(&decoder, 0);
_TIFFmemcpy(buffer, pImage, jbg_dec_getsize(&decoder));
jbg_dec_free(&decoder);
return 1;
);
return 0;
}
pImage = jbg_dec_getimage(&decoder, 0);
_TIFFmemcpy(buffer, pImage, jbg_dec_getsize(&decoder));
jbg_dec_free(&decoder);
return 1;
}
static int JBIGSetupEncode(TIFF* tif)
{
if (TIFFNumberOfStrips(tif) != 1)
{
TIFFError("JBIG", "Multistrip images not supported in encoder");
return 0;
}
if (TIFFNumberOfStrips(tif) != 1)
{
TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in encoder");
return 0;
}
return 1;
return 1;
}
static int JBIGCopyEncodedData(TIFF* tif, tidata_t pp, tsize_t cc, tsample_t s)
static int JBIGCopyEncodedData(TIFF* tif, unsigned char* pp, size_t cc, uint16 s)
{
(void) s;
while (cc > 0)
{
tsize_t n = cc;
(void) s;
while (cc > 0)
{
tmsize_t n = (tmsize_t)cc;
if (tif->tif_rawcc + n > tif->tif_rawdatasize)
{
n = tif->tif_rawdatasize - tif->tif_rawcc;
}
if (tif->tif_rawcc + n > tif->tif_rawdatasize)
{
n = tif->tif_rawdatasize - tif->tif_rawcc;
}
assert(n > 0);
_TIFFmemcpy(tif->tif_rawcp, pp, n);
tif->tif_rawcp += n;
tif->tif_rawcc += n;
pp += n;
cc -= n;
if (tif->tif_rawcc >= tif->tif_rawdatasize &&
!TIFFFlushData1(tif))
{
return (-1);
}
}
assert(n > 0);
_TIFFmemcpy(tif->tif_rawcp, pp, n);
tif->tif_rawcp += n;
tif->tif_rawcc += n;
pp += n;
cc -= (size_t)n;
if (tif->tif_rawcc >= tif->tif_rawdatasize &&
!TIFFFlushData1(tif))
{
return (-1);
}
}
return (1);
return (1);
}
static void JBIGOutputBie(unsigned char* buffer, size_t len, void *userData)
static void JBIGOutputBie(unsigned char* buffer, size_t len, void* userData)
{
TIFF* tif = (TIFF*)userData;
TIFF* tif = (TIFF*)userData;
if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{
TIFFReverseBits(buffer, len);
}
if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{
TIFFReverseBits(buffer, (tmsize_t)len);
}
JBIGCopyEncodedData(tif, buffer, len, 0);
JBIGCopyEncodedData(tif, buffer, len, 0);
}
static int JBIGEncode(TIFF* tif, tidata_t buffer, tsize_t size, tsample_t s)
static int JBIGEncode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
{
TIFFDirectory* dir = &tif->tif_dir;
struct jbg_enc_state encoder;
TIFFDirectory* dir = &tif->tif_dir;
struct jbg_enc_state encoder;
(void) size, (void) s;
jbg_enc_init(&encoder,
dir->td_imagewidth,
dir->td_imagelength,
1,
&buffer,
JBIGOutputBie,
tif);
/*
* jbg_enc_out does the "real" encoding. As data is encoded,
* JBIGOutputBie is called, which writes the data to the directory.
*/
jbg_enc_out(&encoder);
jbg_enc_free(&encoder);
jbg_enc_init(&encoder,
dir->td_imagewidth,
dir->td_imagelength,
1,
&buffer,
JBIGOutputBie,
tif);
/*
* jbg_enc_out does the "real" encoding. As data is encoded,
* JBIGOutputBie is called, which writes the data to the directory.
*/
jbg_enc_out(&encoder);
jbg_enc_free(&encoder);
return 1;
}
static void JBIGCleanup(TIFF* tif)
{
JBIGState *sp = GetJBIGState(tif);
assert(sp != 0);
tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent;
_TIFFfree(tif->tif_data);
tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif);
}
static void JBIGPrintDir(TIFF* tif, FILE* fd, long flags)
{
JBIGState* codec = GetJBIGState(tif);
(void)flags;
if (TIFFFieldSet(tif, FIELD_RECVPARAMS))
{
fprintf(fd,
" Fax Receive Parameters: %08lx\n",
(unsigned long)codec->recvparams);
}
if (TIFFFieldSet(tif, FIELD_SUBADDRESS))
{
fprintf(fd,
" Fax SubAddress: %s\n",
codec->subaddress);
}
if (TIFFFieldSet(tif, FIELD_RECVTIME))
{
fprintf(fd,
" Fax Receive Time: %lu secs\n",
(unsigned long)codec->recvtime);
}
if (TIFFFieldSet(tif, FIELD_FAXDCS))
{
fprintf(fd,
" Fax DCS: %s\n",
codec->faxdcs);
}
}
static int JBIGVGetField(TIFF* tif, ttag_t tag, va_list ap)
{
JBIGState* codec = GetJBIGState(tif);
switch (tag)
{
case TIFFTAG_FAXRECVPARAMS:
*va_arg(ap, uint32*) = codec->recvparams;
break;
case TIFFTAG_FAXSUBADDRESS:
*va_arg(ap, char**) = codec->subaddress;
break;
case TIFFTAG_FAXRECVTIME:
*va_arg(ap, uint32*) = codec->recvtime;
break;
case TIFFTAG_FAXDCS:
*va_arg(ap, char**) = codec->faxdcs;
break;
default:
return (*codec->vgetparent)(tif, tag, ap);
}
return 1;
}
static int JBIGVSetField(TIFF* tif, ttag_t tag, va_list ap)
{
JBIGState* codec = GetJBIGState(tif);
switch (tag)
{
case TIFFTAG_FAXRECVPARAMS:
codec->recvparams = va_arg(ap, uint32);
break;
case TIFFTAG_FAXSUBADDRESS:
_TIFFsetString(&codec->subaddress, va_arg(ap, char*));
break;
case TIFFTAG_FAXRECVTIME:
codec->recvtime = va_arg(ap, uint32);
break;
case TIFFTAG_FAXDCS:
_TIFFsetString(&codec->faxdcs, va_arg(ap, char*));
break;
default:
return (*codec->vsetparent)(tif, tag, ap);
}
TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
tif->tif_flags |= TIFF_DIRTYDIRECT;
return 1;
return 1;
}
int TIFFInitJBIG(TIFF* tif, int scheme)
{
JBIGState* codec = NULL;
assert(scheme == COMPRESSION_JBIG);
/*
* Merge codec-specific tag information.
* These flags are set so the JBIG Codec can control when to reverse
* bits and when not to and to allow the jbig decoder and bit reverser
* to write to memory when necessary.
*/
if (!_TIFFMergeFieldInfo(tif, jbigFieldInfo,
TIFFArrayCount(jbigFieldInfo))) {
TIFFErrorExt(tif->tif_clientdata, "TIFFInitJBIG",
"Merging JBIG codec-specific tags failed");
return 0;
}
tif->tif_flags |= TIFF_NOBITREV;
tif->tif_flags &= ~TIFF_MAPPED;
/* Allocate memory for the JBIGState structure.*/
tif->tif_data = (tdata_t)_TIFFmalloc(sizeof(JBIGState));
if (tif->tif_data == NULL)
{
TIFFError("TIFFInitJBIG", "Not enough memory for JBIGState");
return 0;
}
_TIFFmemset(tif->tif_data, 0, sizeof(JBIGState));
codec = GetJBIGState(tif);
/* Setup the function pointers for encode, decode, and cleanup. */
tif->tif_setupdecode = JBIGSetupDecode;
tif->tif_decodestrip = JBIGDecode;
/* Initialize codec private fields */
codec->recvparams = 0;
codec->subaddress = NULL;
codec->faxdcs = NULL;
codec->recvtime = 0;
tif->tif_setupencode = JBIGSetupEncode;
tif->tif_encodestrip = JBIGEncode;
/*
* Override parent get/set field methods.
*/
codec->vgetparent = tif->tif_tagmethods.vgetfield;
codec->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vgetfield = JBIGVGetField;
tif->tif_tagmethods.vsetfield = JBIGVSetField;
tif->tif_tagmethods.printdir = JBIGPrintDir;
/*
* These flags are set so the JBIG Codec can control when to reverse
* bits and when not to and to allow the jbig decoder and bit reverser
* to write to memory when necessary.
*/
tif->tif_flags |= TIFF_NOBITREV;
tif->tif_flags &= ~TIFF_MAPPED;
/* Setup the function pointers for encode, decode, and cleanup. */
tif->tif_setupdecode = JBIGSetupDecode;
tif->tif_decodestrip = JBIGDecode;
tif->tif_setupencode = JBIGSetupEncode;
tif->tif_encodestrip = JBIGEncode;
tif->tif_cleanup = JBIGCleanup;
return 1;
return 1;
}
#endif /* JBIG_SUPPORT */

1042
3rdparty/libtiff/tif_jpeg.c vendored
View File

File diff suppressed because it is too large Load Diff

65
3rdparty/libtiff/tif_jpeg_12.c vendored Executable file
View File

@ -0,0 +1,65 @@
#include "tiffiop.h"
#if defined(JPEG_DUAL_MODE_8_12)
# define TIFFInitJPEG TIFFInitJPEG_12
# include LIBJPEG_12_PATH
# include "tif_jpeg.c"
int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode )
{
JPEGState* sp;
assert(scheme == COMPRESSION_JPEG);
sp = JState(tif);
sp->tif = tif; /* back link */
/*
* Override parent get/set field methods.
*/
tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
/*
* Install codec methods.
*/
tif->tif_fixuptags = JPEGFixupTags;
tif->tif_setupdecode = JPEGSetupDecode;
tif->tif_predecode = JPEGPreDecode;
tif->tif_decoderow = JPEGDecode;
tif->tif_decodestrip = JPEGDecode;
tif->tif_decodetile = JPEGDecode;
tif->tif_setupencode = JPEGSetupEncode;
tif->tif_preencode = JPEGPreEncode;
tif->tif_postencode = JPEGPostEncode;
tif->tif_encoderow = JPEGEncode;
tif->tif_encodestrip = JPEGEncode;
tif->tif_encodetile = JPEGEncode;
tif->tif_cleanup = JPEGCleanup;
tif->tif_defstripsize = JPEGDefaultStripSize;
tif->tif_deftilesize = JPEGDefaultTileSize;
tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
sp->cinfo_initialized = FALSE;
if( is_encode )
return JPEGSetupEncode(tif);
else
return JPEGSetupDecode(tif);
}
#endif /* defined(JPEG_DUAL_MODE_8_12) */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

396
3rdparty/libtiff/tif_luv.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_luv.c,v 1.17.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_luv.c,v 1.35 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1997 Greg Ward Larson
@ -155,40 +155,44 @@
* State block for each open TIFF
* file using LogLuv compression/decompression.
*/
typedef struct logLuvState LogLuvState;
typedef struct logLuvState LogLuvState;
struct logLuvState {
int user_datafmt; /* user data format */
int encode_meth; /* encoding method */
int pixel_size; /* bytes per pixel */
int user_datafmt; /* user data format */
int encode_meth; /* encoding method */
int pixel_size; /* bytes per pixel */
tidata_t* tbuf; /* translation buffer */
int tbuflen; /* buffer length */
void (*tfunc)(LogLuvState*, tidata_t, int);
uint8* tbuf; /* translation buffer */
tmsize_t tbuflen; /* buffer length */
void (*tfunc)(LogLuvState*, uint8*, tmsize_t);
TIFFVSetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFVSetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
};
#define DecoderState(tif) ((LogLuvState*) (tif)->tif_data)
#define EncoderState(tif) ((LogLuvState*) (tif)->tif_data)
#define DecoderState(tif) ((LogLuvState*) (tif)->tif_data)
#define EncoderState(tif) ((LogLuvState*) (tif)->tif_data)
#define SGILOGDATAFMT_UNKNOWN -1
#define SGILOGDATAFMT_UNKNOWN -1
#define MINRUN 4 /* minimum run length */
#define MINRUN 4 /* minimum run length */
/*
* Decode a string of 16-bit gray pixels.
*/
static int
LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
LogL16Decode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "LogL16Decode";
LogLuvState* sp = DecoderState(tif);
int shft, i, npixels;
int shft;
tmsize_t i;
tmsize_t npixels;
unsigned char* bp;
int16* tp;
int16 b;
int cc, rc;
tmsize_t cc;
int rc;
assert(s == 0);
assert(sp != NULL);
@ -201,15 +205,15 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
assert(sp->tbuflen >= npixels);
tp = (int16*) sp->tbuf;
}
_TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0]));
_TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0]));
bp = (unsigned char*) tif->tif_rawcp;
cc = tif->tif_rawcc;
/* get each byte string */
/* get each byte string */
for (shft = 2*8; (shft -= 8) >= 0; ) {
for (i = 0; i < npixels && cc > 0; )
if (*bp >= 128) { /* run */
rc = *bp++ + (2-128);
rc = *bp++ + (2-128); /* TODO: potential input buffer overrun when decoding corrupt or truncated data */
b = (int16)(*bp++ << shft);
cc -= 2;
while (rc-- && i < npixels)
@ -220,16 +224,24 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
tp[i++] |= (int16)*bp++ << shft;
}
if (i != npixels) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LogL16Decode: Not enough data at row %d (short %d pixels)",
tif->tif_row, npixels - i);
tif->tif_rawcp = (tidata_t) bp;
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %I64d pixels)",
(unsigned long) tif->tif_row,
(unsigned __int64) (npixels - i));
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %llu pixels)",
(unsigned long) tif->tif_row,
(unsigned long long) (npixels - i));
#endif
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
return (0);
}
}
(*sp->tfunc)(sp, op, npixels);
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
return (1);
}
@ -238,10 +250,13 @@ LogL16Decode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
* Decode a string of 24-bit pixels.
*/
static int
LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
LogLuvDecode24(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "LogLuvDecode24";
LogLuvState* sp = DecoderState(tif);
int cc, i, npixels;
tmsize_t cc;
tmsize_t i;
tmsize_t npixels;
unsigned char* bp;
uint32* tp;
@ -256,7 +271,7 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
assert(sp->tbuflen >= npixels);
tp = (uint32 *) sp->tbuf;
}
/* copy to array of uint32 */
/* copy to array of uint32 */
bp = (unsigned char*) tif->tif_rawcp;
cc = tif->tif_rawcc;
for (i = 0; i < npixels && cc > 0; i++) {
@ -264,12 +279,20 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
bp += 3;
cc -= 3;
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
if (i != npixels) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LogLuvDecode24: Not enough data at row %d (short %d pixels)",
tif->tif_row, npixels - i);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %I64d pixels)",
(unsigned long) tif->tif_row,
(unsigned __int64) (npixels - i));
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %llu pixels)",
(unsigned long) tif->tif_row,
(unsigned long long) (npixels - i));
#endif
return (0);
}
(*sp->tfunc)(sp, op, npixels);
@ -280,14 +303,18 @@ LogLuvDecode24(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
* Decode a string of 32-bit pixels.
*/
static int
LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
LogLuvDecode32(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "LogLuvDecode32";
LogLuvState* sp;
int shft, i, npixels;
int shft;
tmsize_t i;
tmsize_t npixels;
unsigned char* bp;
uint32* tp;
uint32 b;
int cc, rc;
tmsize_t cc;
int rc;
assert(s == 0);
sp = DecoderState(tif);
@ -301,17 +328,17 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
assert(sp->tbuflen >= npixels);
tp = (uint32*) sp->tbuf;
}
_TIFFmemset((tdata_t) tp, 0, npixels*sizeof (tp[0]));
_TIFFmemset((void*) tp, 0, npixels*sizeof (tp[0]));
bp = (unsigned char*) tif->tif_rawcp;
cc = tif->tif_rawcc;
/* get each byte string */
/* get each byte string */
for (shft = 4*8; (shft -= 8) >= 0; ) {
for (i = 0; i < npixels && cc > 0; )
if (*bp >= 128) { /* run */
rc = *bp++ + (2-128);
b = (uint32)*bp++ << shft;
cc -= 2;
cc -= 2; /* TODO: potential input buffer overrun when decoding corrupt or truncated data */
while (rc-- && i < npixels)
tp[i++] |= b;
} else { /* non-run */
@ -320,16 +347,24 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
tp[i++] |= (uint32)*bp++ << shft;
}
if (i != npixels) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LogLuvDecode32: Not enough data at row %d (short %d pixels)",
tif->tif_row, npixels - i);
tif->tif_rawcp = (tidata_t) bp;
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %I64d pixels)",
(unsigned long) tif->tif_row,
(unsigned __int64) (npixels - i));
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at row %lu (short %llu pixels)",
(unsigned long) tif->tif_row,
(unsigned long long) (npixels - i));
#endif
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
return (0);
}
}
(*sp->tfunc)(sp, op, npixels);
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
return (1);
}
@ -340,9 +375,9 @@ LogLuvDecode32(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
* is row by row.
*/
static int
LogLuvDecodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvDecodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
tsize_t rowlen = TIFFScanlineSize(tif);
tmsize_t rowlen = TIFFScanlineSize(tif);
assert(cc%rowlen == 0);
while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s))
@ -356,9 +391,9 @@ LogLuvDecodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* is row by row.
*/
static int
LogLuvDecodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvDecodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
tsize_t rowlen = TIFFTileRowSize(tif);
tmsize_t rowlen = TIFFTileRowSize(tif);
assert(cc%rowlen == 0);
while (cc && (*tif->tif_decoderow)(tif, bp, rowlen, s))
@ -370,14 +405,19 @@ LogLuvDecodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* Encode a row of 16-bit pixels.
*/
static int
LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogL16Encode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
LogLuvState* sp = EncoderState(tif);
int shft, i, j, npixels;
tidata_t op;
int shft;
tmsize_t i;
tmsize_t j;
tmsize_t npixels;
uint8* op;
int16* tp;
int16 b;
int occ, rc=0, mask, beg;
tmsize_t occ;
int rc=0, mask;
tmsize_t beg;
assert(s == 0);
assert(sp != NULL);
@ -390,7 +430,7 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
assert(sp->tbuflen >= npixels);
(*sp->tfunc)(sp, bp, npixels);
}
/* compress each byte string */
/* compress each byte string */
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
for (shft = 2*8; (shft -= 8) >= 0; )
@ -408,7 +448,7 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
b = (int16) (tp[beg] & mask);
rc = 1;
while (rc < 127+2 && beg+rc < npixels &&
(tp[beg+rc] & mask) == b)
(tp[beg+rc] & mask) == b)
rc++;
if (rc >= MINRUN)
break; /* long enough */
@ -417,33 +457,33 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
b = (int16) (tp[i] & mask);/*check short run */
j = i+1;
while ((tp[j++] & mask) == b)
if (j == beg) {
*op++ = (tidataval_t)(128-2+j-i);
*op++ = (tidataval_t) (b >> shft);
occ -= 2;
i = beg;
break;
}
if (j == beg) {
*op++ = (uint8)(128-2+j-i);
*op++ = (uint8)(b >> shft);
occ -= 2;
i = beg;
break;
}
}
while (i < beg) { /* write out non-run */
if ((j = beg-i) > 127) j = 127;
if (occ < j+3) {
tif->tif_rawcp = op;
tif->tif_rawcc = tif->tif_rawdatasize - occ;
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
tif->tif_rawcp = op;
tif->tif_rawcc = tif->tif_rawdatasize - occ;
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
}
*op++ = (tidataval_t) j; occ--;
*op++ = (uint8) j; occ--;
while (j--) {
*op++ = (tidataval_t) (tp[i++] >> shft & 0xff);
*op++ = (uint8) (tp[i++] >> shft & 0xff);
occ--;
}
}
if (rc >= MINRUN) { /* write out run */
*op++ = (tidataval_t) (128-2+rc);
*op++ = (tidataval_t) (tp[beg] >> shft & 0xff);
*op++ = (uint8) (128-2+rc);
*op++ = (uint8) (tp[beg] >> shft & 0xff);
occ -= 2;
} else
rc = 0;
@ -458,11 +498,13 @@ LogL16Encode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* Encode a row of 24-bit pixels.
*/
static int
LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvEncode24(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
LogLuvState* sp = EncoderState(tif);
int i, npixels, occ;
tidata_t op;
tmsize_t i;
tmsize_t npixels;
tmsize_t occ;
uint8* op;
uint32* tp;
assert(s == 0);
@ -476,7 +518,7 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
assert(sp->tbuflen >= npixels);
(*sp->tfunc)(sp, bp, npixels);
}
/* write out encoded pixels */
/* write out encoded pixels */
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
for (i = npixels; i--; ) {
@ -488,9 +530,9 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
}
*op++ = (tidataval_t)(*tp >> 16);
*op++ = (tidataval_t)(*tp >> 8 & 0xff);
*op++ = (tidataval_t)(*tp++ & 0xff);
*op++ = (uint8)(*tp >> 16);
*op++ = (uint8)(*tp >> 8 & 0xff);
*op++ = (uint8)(*tp++ & 0xff);
occ -= 3;
}
tif->tif_rawcp = op;
@ -503,14 +545,19 @@ LogLuvEncode24(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* Encode a row of 32-bit pixels.
*/
static int
LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvEncode32(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
LogLuvState* sp = EncoderState(tif);
int shft, i, j, npixels;
tidata_t op;
int shft;
tmsize_t i;
tmsize_t j;
tmsize_t npixels;
uint8* op;
uint32* tp;
uint32 b;
int occ, rc=0, mask, beg;
tmsize_t occ;
int rc=0, mask;
tmsize_t beg;
assert(s == 0);
assert(sp != NULL);
@ -524,7 +571,7 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
assert(sp->tbuflen >= npixels);
(*sp->tfunc)(sp, bp, npixels);
}
/* compress each byte string */
/* compress each byte string */
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
for (shft = 4*8; (shft -= 8) >= 0; )
@ -552,8 +599,8 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
j = i+1;
while ((tp[j++] & mask) == b)
if (j == beg) {
*op++ = (tidataval_t)(128-2+j-i);
*op++ = (tidataval_t)(b >> shft);
*op++ = (uint8)(128-2+j-i);
*op++ = (uint8)(b >> shft);
occ -= 2;
i = beg;
break;
@ -569,15 +616,15 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
op = tif->tif_rawcp;
occ = tif->tif_rawdatasize - tif->tif_rawcc;
}
*op++ = (tidataval_t) j; occ--;
*op++ = (uint8) j; occ--;
while (j--) {
*op++ = (tidataval_t)(tp[i++] >> shft & 0xff);
*op++ = (uint8)(tp[i++] >> shft & 0xff);
occ--;
}
}
if (rc >= MINRUN) { /* write out run */
*op++ = (tidataval_t) (128-2+rc);
*op++ = (tidataval_t)(tp[beg] >> shft & 0xff);
*op++ = (uint8) (128-2+rc);
*op++ = (uint8)(tp[beg] >> shft & 0xff);
occ -= 2;
} else
rc = 0;
@ -593,9 +640,9 @@ LogLuvEncode32(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* avoid encoding runs across row boundaries.
*/
static int
LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvEncodeStrip(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
tsize_t rowlen = TIFFScanlineSize(tif);
tmsize_t rowlen = TIFFScanlineSize(tif);
assert(cc%rowlen == 0);
while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
@ -608,9 +655,9 @@ LogLuvEncodeStrip(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* avoid encoding runs across row boundaries.
*/
static int
LogLuvEncodeTile(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LogLuvEncodeTile(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
tsize_t rowlen = TIFFTileRowSize(tif);
tmsize_t rowlen = TIFFTileRowSize(tif);
assert(cc%rowlen == 0);
while (cc && (*tif->tif_encoderow)(tif, bp, rowlen, s) == 1)
@ -676,7 +723,7 @@ LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */
}
static void
L16toY(LogLuvState* sp, tidata_t op, int n)
L16toY(LogLuvState* sp, uint8* op, tmsize_t n)
{
int16* l16 = (int16*) sp->tbuf;
float* yp = (float*) op;
@ -686,7 +733,7 @@ L16toY(LogLuvState* sp, tidata_t op, int n)
}
static void
L16toGry(LogLuvState* sp, tidata_t op, int n)
L16toGry(LogLuvState* sp, uint8* op, tmsize_t n)
{
int16* l16 = (int16*) sp->tbuf;
uint8* gp = (uint8*) op;
@ -698,7 +745,7 @@ L16toGry(LogLuvState* sp, tidata_t op, int n)
}
static void
L16fromY(LogLuvState* sp, tidata_t op, int n)
L16fromY(LogLuvState* sp, uint8* op, tmsize_t n)
{
int16* l16 = (int16*) sp->tbuf;
float* yp = (float*) op;
@ -760,7 +807,7 @@ oog_encode(double u, double v) /* encode out-of-gamut chroma */
static int oog_table[NANGLES];
static int initialized = 0;
register int i;
if (!initialized) { /* set up perimeter table */
double eps[NANGLES], ua, va, ang, epsa;
int ui, vi, ustep;
@ -774,7 +821,7 @@ oog_encode(double u, double v) /* encode out-of-gamut chroma */
for (ui = uv_row[vi].nus-1; ui >= 0; ui -= ustep) {
ua = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ;
ang = uv2ang(ua, va);
i = (int) ang;
i = (int) ang;
epsa = fabs(ang - (i+.5));
if (epsa < eps[i]) {
oog_table[i] = uv_row[vi].ncum + ui;
@ -916,9 +963,9 @@ LogLuv24fromXYZ(float XYZ[3], int em)
}
static void
Luv24toXYZ(LogLuvState* sp, tidata_t op, int n)
Luv24toXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
float* xyz = (float*) op;
while (n-- > 0) {
@ -929,9 +976,9 @@ Luv24toXYZ(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv24toLuv48(LogLuvState* sp, tidata_t op, int n)
Luv24toLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
int16* luv3 = (int16*) op;
while (n-- > 0) {
@ -949,9 +996,9 @@ Luv24toLuv48(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv24toRGB(LogLuvState* sp, tidata_t op, int n)
Luv24toRGB(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
uint8* rgb = (uint8*) op;
while (n-- > 0) {
@ -964,9 +1011,9 @@ Luv24toRGB(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv24fromXYZ(LogLuvState* sp, tidata_t op, int n)
Luv24fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
float* xyz = (float*) op;
while (n-- > 0) {
@ -976,9 +1023,9 @@ Luv24fromXYZ(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv24fromLuv48(LogLuvState* sp, tidata_t op, int n)
Luv24fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
int16* luv3 = (int16*) op;
while (n-- > 0) {
@ -1057,9 +1104,9 @@ LogLuv32fromXYZ(float XYZ[3], int em)
}
static void
Luv32toXYZ(LogLuvState* sp, tidata_t op, int n)
Luv32toXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
float* xyz = (float*) op;
while (n-- > 0) {
@ -1069,9 +1116,9 @@ Luv32toXYZ(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv32toLuv48(LogLuvState* sp, tidata_t op, int n)
Luv32toLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
int16* luv3 = (int16*) op;
while (n-- > 0) {
@ -1087,9 +1134,9 @@ Luv32toLuv48(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv32toRGB(LogLuvState* sp, tidata_t op, int n)
Luv32toRGB(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
uint8* rgb = (uint8*) op;
while (n-- > 0) {
@ -1102,9 +1149,9 @@ Luv32toRGB(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv32fromXYZ(LogLuvState* sp, tidata_t op, int n)
Luv32fromXYZ(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
uint32* luv = (uint32*) sp->tbuf;
float* xyz = (float*) op;
while (n-- > 0) {
@ -1114,7 +1161,7 @@ Luv32fromXYZ(LogLuvState* sp, tidata_t op, int n)
}
static void
Luv32fromLuv48(LogLuvState* sp, tidata_t op, int n)
Luv32fromLuv48(LogLuvState* sp, uint8* op, tmsize_t n)
{
uint32* luv = (uint32*) sp->tbuf;
int16* luv3 = (int16*) op;
@ -1137,7 +1184,7 @@ Luv32fromLuv48(LogLuvState* sp, tidata_t op, int n)
}
static void
_logLuvNop(LogLuvState* sp, tidata_t op, int n)
_logLuvNop(LogLuvState* sp, uint8* op, tmsize_t n)
{
(void) sp; (void) op; (void) n;
}
@ -1161,10 +1208,10 @@ LogL16GuessDataFmt(TIFFDirectory *td)
return (SGILOGDATAFMT_UNKNOWN);
}
static uint32
multiply(size_t m1, size_t m2)
static tmsize_t
multiply_ms(tmsize_t m1, tmsize_t m2)
{
uint32 bytes = m1 * m2;
tmsize_t bytes = m1 * m2;
if (m1 && bytes / m1 != m2)
bytes = 0;
@ -1175,9 +1222,9 @@ multiply(size_t m1, size_t m2)
static int
LogL16InitState(TIFF* tif)
{
static const char module[] = "LogL16InitState";
TIFFDirectory *td = &tif->tif_dir;
LogLuvState* sp = DecoderState(tif);
static const char module[] = "LogL16InitState";
assert(sp != NULL);
assert(td->td_photometric == PHOTOMETRIC_LOGL);
@ -1196,18 +1243,17 @@ LogL16InitState(TIFF* tif)
sp->pixel_size = sizeof (uint8);
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"No support for converting user data format to LogL");
return (0);
}
if( isTiled(tif) )
sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength);
sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
else
sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip);
if (multiply(sp->tbuflen, sizeof (int16)) == 0 ||
(sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (int16))) == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for SGILog translation buffer",
tif->tif_name);
sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
if (multiply_ms(sp->tbuflen, sizeof (int16)) == 0 ||
(sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (int16))) == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer");
return (0);
}
return (1);
@ -1268,9 +1314,9 @@ LogLuvGuessDataFmt(TIFFDirectory *td)
static int
LogLuvInitState(TIFF* tif)
{
static const char module[] = "LogLuvInitState";
TIFFDirectory* td = &tif->tif_dir;
LogLuvState* sp = DecoderState(tif);
static const char module[] = "LogLuvInitState";
assert(sp != NULL);
assert(td->td_photometric == PHOTOMETRIC_LOGLUV);
@ -1297,26 +1343,33 @@ LogLuvInitState(TIFF* tif)
sp->pixel_size = 3*sizeof (uint8);
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"No support for converting user data format to LogLuv");
return (0);
}
if( isTiled(tif) )
sp->tbuflen = multiply(td->td_tilewidth, td->td_tilelength);
sp->tbuflen = multiply_ms(td->td_tilewidth, td->td_tilelength);
else
sp->tbuflen = multiply(td->td_imagewidth, td->td_rowsperstrip);
if (multiply(sp->tbuflen, sizeof (uint32)) == 0 ||
(sp->tbuf = (tidata_t*) _TIFFmalloc(sp->tbuflen * sizeof (uint32))) == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for SGILog translation buffer",
tif->tif_name);
sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_rowsperstrip);
if (multiply_ms(sp->tbuflen, sizeof (uint32)) == 0 ||
(sp->tbuf = (uint8*) _TIFFmalloc(sp->tbuflen * sizeof (uint32))) == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "No space for SGILog translation buffer");
return (0);
}
return (1);
}
static int
LogLuvFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
static int
LogLuvSetupDecode(TIFF* tif)
{
static const char module[] = "LogLuvSetupDecode";
LogLuvState* sp = DecoderState(tif);
TIFFDirectory* td = &tif->tif_dir;
@ -1329,10 +1382,10 @@ LogLuvSetupDecode(TIFF* tif)
tif->tif_decoderow = LogLuvDecode24;
switch (sp->user_datafmt) {
case SGILOGDATAFMT_FLOAT:
sp->tfunc = Luv24toXYZ;
sp->tfunc = Luv24toXYZ;
break;
case SGILOGDATAFMT_16BIT:
sp->tfunc = Luv24toLuv48;
sp->tfunc = Luv24toLuv48;
break;
case SGILOGDATAFMT_8BIT:
sp->tfunc = Luv24toRGB;
@ -1367,8 +1420,8 @@ LogLuvSetupDecode(TIFF* tif)
}
return (1);
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Inappropriate photometric interpretation %d for SGILog compression; %s",
TIFFErrorExt(tif->tif_clientdata, module,
"Inappropriate photometric interpretation %d for SGILog compression; %s",
td->td_photometric, "must be either LogLUV or LogL");
break;
}
@ -1378,6 +1431,7 @@ LogLuvSetupDecode(TIFF* tif)
static int
LogLuvSetupEncode(TIFF* tif)
{
static const char module[] = "LogLuvSetupEncode";
LogLuvState* sp = EncoderState(tif);
TIFFDirectory* td = &tif->tif_dir;
@ -1392,7 +1446,7 @@ LogLuvSetupEncode(TIFF* tif)
sp->tfunc = Luv24fromXYZ;
break;
case SGILOGDATAFMT_16BIT:
sp->tfunc = Luv24fromLuv48;
sp->tfunc = Luv24fromLuv48;
break;
case SGILOGDATAFMT_RAW:
break;
@ -1400,13 +1454,13 @@ LogLuvSetupEncode(TIFF* tif)
goto notsupported;
}
} else {
tif->tif_encoderow = LogLuvEncode32;
tif->tif_encoderow = LogLuvEncode32;
switch (sp->user_datafmt) {
case SGILOGDATAFMT_FLOAT:
sp->tfunc = Luv32fromXYZ;
sp->tfunc = Luv32fromXYZ;
break;
case SGILOGDATAFMT_16BIT:
sp->tfunc = Luv32fromLuv48;
sp->tfunc = Luv32fromLuv48;
break;
case SGILOGDATAFMT_RAW:
break;
@ -1418,7 +1472,7 @@ LogLuvSetupEncode(TIFF* tif)
case PHOTOMETRIC_LOGL:
if (!LogL16InitState(tif))
break;
tif->tif_encoderow = LogL16Encode;
tif->tif_encoderow = LogL16Encode;
switch (sp->user_datafmt) {
case SGILOGDATAFMT_FLOAT:
sp->tfunc = L16fromY;
@ -1430,14 +1484,14 @@ LogLuvSetupEncode(TIFF* tif)
}
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Inappropriate photometric interpretation %d for SGILog compression; %s",
td->td_photometric, "must be either LogLUV or LogL");
TIFFErrorExt(tif->tif_clientdata, module,
"Inappropriate photometric interpretation %d for SGILog compression; %s",
td->td_photometric, "must be either LogLUV or LogL");
break;
}
return (1);
notsupported:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"SGILog compression supported only for %s, or raw data",
td->td_photometric == PHOTOMETRIC_LOGL ? "Y, L" : "XYZ, Luv");
return (0);
@ -1480,14 +1534,15 @@ LogLuvCleanup(TIFF* tif)
}
static int
LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap)
LogLuvVSetField(TIFF* tif, uint32 tag, va_list ap)
{
static const char module[] = "LogLuvVSetField";
LogLuvState* sp = DecoderState(tif);
int bps, fmt;
switch (tag) {
case TIFFTAG_SGILOGDATAFMT:
sp->user_datafmt = va_arg(ap, int);
sp->user_datafmt = (int) va_arg(ap, int);
/*
* Tweak the TIFF header so that the rest of libtiff knows what
* size of data will be passed between app and library, and
@ -1519,16 +1574,16 @@ LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap)
/*
* Must recalculate sizes should bits/sample change.
*/
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t) -1;
tif->tif_scanlinesize = TIFFScanlineSize(tif);
return (1);
case TIFFTAG_SGILOGENCODE:
sp->encode_meth = va_arg(ap, int);
sp->encode_meth = (int) va_arg(ap, int);
if (sp->encode_meth != SGILOGENCODE_NODITHER &&
sp->encode_meth != SGILOGENCODE_RANDITHER) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Unknown encoding %d for LogLuv compression",
sp->encode_meth);
sp->encode_meth != SGILOGENCODE_RANDITHER) {
TIFFErrorExt(tif->tif_clientdata, module,
"Unknown encoding %d for LogLuv compression",
sp->encode_meth);
return (0);
}
return (1);
@ -1538,7 +1593,7 @@ LogLuvVSetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
LogLuvVGetField(TIFF* tif, ttag_t tag, va_list ap)
LogLuvVGetField(TIFF* tif, uint32 tag, va_list ap)
{
LogLuvState *sp = (LogLuvState *)tif->tif_data;
@ -1551,11 +1606,9 @@ LogLuvVGetField(TIFF* tif, ttag_t tag, va_list ap)
}
}
static const TIFFFieldInfo LogLuvFieldInfo[] = {
{ TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, FIELD_PSEUDO,
TRUE, FALSE, "SGILogDataFmt"},
{ TIFFTAG_SGILOGENCODE, 0, 0, TIFF_SHORT, FIELD_PSEUDO,
TRUE, FALSE, "SGILogEncode"}
static const TIFFField LogLuvFields[] = {
{ TIFFTAG_SGILOGDATAFMT, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "SGILogDataFmt", NULL},
{ TIFFTAG_SGILOGENCODE, 0, 0, TIFF_SHORT, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "SGILogEncode", NULL}
};
int
@ -1569,24 +1622,24 @@ TIFFInitSGILog(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, LogLuvFieldInfo,
TIFFArrayCount(LogLuvFieldInfo))) {
if (!_TIFFMergeFields(tif, LogLuvFields,
TIFFArrayCount(LogLuvFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging SGILog codec-specific tags failed");
"Merging SGILog codec-specific tags failed");
return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LogLuvState));
tif->tif_data = (uint8*) _TIFFmalloc(sizeof (LogLuvState));
if (tif->tif_data == NULL)
goto bad;
sp = (LogLuvState*) tif->tif_data;
_TIFFmemset((tdata_t)sp, 0, sizeof (*sp));
_TIFFmemset((void*)sp, 0, sizeof (*sp));
sp->user_datafmt = SGILOGDATAFMT_UNKNOWN;
sp->encode_meth = (scheme == COMPRESSION_SGILOG24) ?
SGILOGENCODE_RANDITHER : SGILOGENCODE_NODITHER;
SGILOGENCODE_RANDITHER : SGILOGENCODE_NODITHER;
sp->tfunc = _logLuvNop;
/*
@ -1594,16 +1647,17 @@ TIFFInitSGILog(TIFF* tif, int scheme)
* NB: tif_decoderow & tif_encoderow are filled
* in at setup time.
*/
tif->tif_fixuptags = LogLuvFixupTags;
tif->tif_setupdecode = LogLuvSetupDecode;
tif->tif_decodestrip = LogLuvDecodeStrip;
tif->tif_decodetile = LogLuvDecodeTile;
tif->tif_setupencode = LogLuvSetupEncode;
tif->tif_encodestrip = LogLuvEncodeStrip;
tif->tif_encodestrip = LogLuvEncodeStrip;
tif->tif_encodetile = LogLuvEncodeTile;
tif->tif_close = LogLuvClose;
tif->tif_cleanup = LogLuvCleanup;
/*
/*
* Override parent get/set field methods.
*/
sp->vgetparent = tif->tif_tagmethods.vgetfield;

495
3rdparty/libtiff/tif_lzma.c vendored Executable file
View File

@ -0,0 +1,495 @@
/* $Id: tif_lzma.c,v 1.4 2011-12-22 00:29:29 bfriesen Exp $ */
/*
* Copyright (c) 2010, Andrey Kiselev <dron@ak4719.spb.edu>
*
* 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.
*/
#include "tiffiop.h"
#ifdef LZMA_SUPPORT
/*
* TIFF Library.
*
* LZMA2 Compression Support
*
* You need an LZMA2 SDK to link with. See http://tukaani.org/xz/ for details.
*
* The codec is derived from ZLIB codec (tif_zip.c).
*/
#include "tif_predict.h"
#include "lzma.h"
#include <stdio.h>
/*
* State block for each open TIFF file using LZMA2 compression/decompression.
*/
typedef struct {
TIFFPredictorState predict;
lzma_stream stream;
lzma_filter filters[LZMA_FILTERS_MAX + 1];
lzma_options_delta opt_delta; /* delta filter options */
lzma_options_lzma opt_lzma; /* LZMA2 filter options */
int preset; /* compression level */
lzma_check check; /* type of the integrity check */
int state; /* state flags */
#define LSTATE_INIT_DECODE 0x01
#define LSTATE_INIT_ENCODE 0x02
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
} LZMAState;
#define LState(tif) ((LZMAState*) (tif)->tif_data)
#define DecoderState(tif) LState(tif)
#define EncoderState(tif) LState(tif)
static int LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
static int LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
static const char *
LZMAStrerror(lzma_ret ret)
{
switch (ret) {
case LZMA_OK:
return "operation completed successfully";
case LZMA_STREAM_END:
return "end of stream was reached";
case LZMA_NO_CHECK:
return "input stream has no integrity check";
case LZMA_UNSUPPORTED_CHECK:
return "cannot calculate the integrity check";
case LZMA_GET_CHECK:
return "integrity check type is now available";
case LZMA_MEM_ERROR:
return "cannot allocate memory";
case LZMA_MEMLIMIT_ERROR:
return "memory usage limit was reached";
case LZMA_FORMAT_ERROR:
return "file format not recognized";
case LZMA_OPTIONS_ERROR:
return "invalid or unsupported options";
case LZMA_DATA_ERROR:
return "data is corrupt";
case LZMA_BUF_ERROR:
return "no progress is possible (stream is truncated or corrupt)";
case LZMA_PROG_ERROR:
return "programming error";
default:
return "unindentified liblzma error";
}
}
static int
LZMAFixupTags(TIFF* tif)
{
(void) tif;
return 1;
}
static int
LZMASetupDecode(TIFF* tif)
{
LZMAState* sp = DecoderState(tif);
assert(sp != NULL);
/* if we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) {
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE;
return 1;
}
/*
* Setup state for decoding a strip.
*/
static int
LZMAPreDecode(TIFF* tif, uint16 s)
{
static const char module[] = "LZMAPreDecode";
LZMAState* sp = DecoderState(tif);
lzma_ret ret;
(void) s;
assert(sp != NULL);
if( (sp->state & LSTATE_INIT_DECODE) == 0 )
tif->tif_setupdecode(tif);
sp->stream.next_in = tif->tif_rawdata;
sp->stream.avail_in = (size_t) tif->tif_rawcc;
if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) {
TIFFErrorExt(tif->tif_clientdata, module,
"Liblzma cannot deal with buffers this size");
return 0;
}
/*
* Disable memory limit when decoding. UINT64_MAX is a flag to disable
* the limit, we are passing (uint64_t)-1 which should be the same.
*/
ret = lzma_stream_decoder(&sp->stream, (uint64_t)-1, 0);
if (ret != LZMA_OK) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error initializing the stream decoder, %s",
LZMAStrerror(ret));
return 0;
}
return 1;
}
static int
LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "LZMADecode";
LZMAState* sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
assert(sp->state == LSTATE_INIT_DECODE);
sp->stream.next_in = tif->tif_rawcp;
sp->stream.avail_in = (size_t) tif->tif_rawcc;
sp->stream.next_out = op;
sp->stream.avail_out = (size_t) occ;
if ((tmsize_t)sp->stream.avail_out != occ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Liblzma cannot deal with buffers this size");
return 0;
}
do {
/*
* Save the current stream state to properly recover from the
* decoding errors later.
*/
const uint8_t *next_in = sp->stream.next_in;
size_t avail_in = sp->stream.avail_in;
lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
if (ret == LZMA_STREAM_END)
break;
if (ret == LZMA_MEMLIMIT_ERROR) {
lzma_ret r = lzma_stream_decoder(&sp->stream,
lzma_memusage(&sp->stream), 0);
if (r != LZMA_OK) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error initializing the stream decoder, %s",
LZMAStrerror(r));
break;
}
sp->stream.next_in = next_in;
sp->stream.avail_in = avail_in;
continue;
}
if (ret != LZMA_OK) {
TIFFErrorExt(tif->tif_clientdata, module,
"Decoding error at scanline %lu, %s",
(unsigned long) tif->tif_row, LZMAStrerror(ret));
break;
}
} while (sp->stream.avail_out > 0);
if (sp->stream.avail_out != 0) {
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %lu (short %lu bytes)",
(unsigned long) tif->tif_row, (unsigned long) sp->stream.avail_out);
return 0;
}
tif->tif_rawcp = (uint8 *)sp->stream.next_in; /* cast away const */
tif->tif_rawcc = sp->stream.avail_in;
return 1;
}
static int
LZMASetupEncode(TIFF* tif)
{
LZMAState* sp = EncoderState(tif);
assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) {
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE;
return 1;
}
/*
* Reset encoding state at the start of a strip.
*/
static int
LZMAPreEncode(TIFF* tif, uint16 s)
{
static const char module[] = "LZMAPreEncode";
LZMAState *sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
if( sp->state != LSTATE_INIT_ENCODE )
tif->tif_setupencode(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (size_t)tif->tif_rawdatasize;
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
TIFFErrorExt(tif->tif_clientdata, module,
"Liblzma cannot deal with buffers this size");
return 0;
}
return (lzma_stream_encoder(&sp->stream, sp->filters, sp->check) == LZMA_OK);
}
/*
* Encode a chunk of pixels.
*/
static int
LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
static const char module[] = "LZMAEncode";
LZMAState *sp = EncoderState(tif);
assert(sp != NULL);
assert(sp->state == LSTATE_INIT_ENCODE);
(void) s;
sp->stream.next_in = bp;
sp->stream.avail_in = (size_t) cc;
if ((tmsize_t)sp->stream.avail_in != cc) {
TIFFErrorExt(tif->tif_clientdata, module,
"Liblzma cannot deal with buffers this size");
return 0;
}
do {
lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
if (ret != LZMA_OK) {
TIFFErrorExt(tif->tif_clientdata, module,
"Encoding error at scanline %lu, %s",
(unsigned long) tif->tif_row, LZMAStrerror(ret));
return 0;
}
if (sp->stream.avail_out == 0) {
tif->tif_rawcc = tif->tif_rawdatasize;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (size_t)tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in LZMAPreEncode */
}
} while (sp->stream.avail_in > 0);
return 1;
}
/*
* Finish off an encoded strip by flushing the last
* string and tacking on an End Of Information code.
*/
static int
LZMAPostEncode(TIFF* tif)
{
static const char module[] = "LZMAPostEncode";
LZMAState *sp = EncoderState(tif);
lzma_ret ret;
sp->stream.avail_in = 0;
do {
ret = lzma_code(&sp->stream, LZMA_FINISH);
switch (ret) {
case LZMA_STREAM_END:
case LZMA_OK:
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (size_t)tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */
}
break;
default:
TIFFErrorExt(tif->tif_clientdata, module, "Liblzma error: %s",
LZMAStrerror(ret));
return 0;
}
} while (ret != LZMA_STREAM_END);
return 1;
}
static void
LZMACleanup(TIFF* tif)
{
LZMAState* sp = LState(tif);
assert(sp != 0);
(void)TIFFPredictorCleanup(tif);
tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent;
if (sp->state) {
lzma_end(&sp->stream);
sp->state = 0;
}
_TIFFfree(sp);
tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif);
}
static int
LZMAVSetField(TIFF* tif, uint32 tag, va_list ap)
{
static const char module[] = "LZMAVSetField";
LZMAState* sp = LState(tif);
switch (tag) {
case TIFFTAG_LZMAPRESET:
sp->preset = (int) va_arg(ap, int);
lzma_lzma_preset(&sp->opt_lzma, sp->preset);
if (sp->state & LSTATE_INIT_ENCODE) {
lzma_ret ret = lzma_stream_encoder(&sp->stream,
sp->filters,
sp->check);
if (ret != LZMA_OK) {
TIFFErrorExt(tif->tif_clientdata, module,
"Liblzma error: %s",
LZMAStrerror(ret));
}
}
return 1;
default:
return (*sp->vsetparent)(tif, tag, ap);
}
/*NOTREACHED*/
}
static int
LZMAVGetField(TIFF* tif, uint32 tag, va_list ap)
{
LZMAState* sp = LState(tif);
switch (tag) {
case TIFFTAG_LZMAPRESET:
*va_arg(ap, int*) = sp->preset;
break;
default:
return (*sp->vgetparent)(tif, tag, ap);
}
return 1;
}
static const TIFFField lzmaFields[] = {
{ TIFFTAG_LZMAPRESET, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED,
FIELD_PSEUDO, TRUE, FALSE, "LZMA2 Compression Preset", NULL },
};
int
TIFFInitLZMA(TIFF* tif, int scheme)
{
static const char module[] = "TIFFInitLZMA";
LZMAState* sp;
lzma_stream tmp_stream = LZMA_STREAM_INIT;
assert( scheme == COMPRESSION_LZMA );
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFields(tif, lzmaFields, TIFFArrayCount(lzmaFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging LZMA2 codec-specific tags failed");
return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (uint8*) _TIFFmalloc(sizeof(LZMAState));
if (tif->tif_data == NULL)
goto bad;
sp = LState(tif);
memcpy(&sp->stream, &tmp_stream, sizeof(lzma_stream));
/*
* Override parent get/set field methods.
*/
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = LZMAVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = LZMAVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->preset = LZMA_PRESET_DEFAULT; /* default comp. level */
sp->check = LZMA_CHECK_NONE;
sp->state = 0;
/* Data filters. So far we are using delta and LZMA2 filters only. */
sp->opt_delta.type = LZMA_DELTA_TYPE_BYTE;
/*
* The sample size in bytes seems to be reasonable distance for delta
* filter.
*/
sp->opt_delta.dist = (tif->tif_dir.td_bitspersample % 8) ?
1 : tif->tif_dir.td_bitspersample / 8;
sp->filters[0].id = LZMA_FILTER_DELTA;
sp->filters[0].options = &sp->opt_delta;
lzma_lzma_preset(&sp->opt_lzma, sp->preset);
sp->filters[1].id = LZMA_FILTER_LZMA2;
sp->filters[1].options = &sp->opt_lzma;
sp->filters[2].id = LZMA_VLI_UNKNOWN;
sp->filters[2].options = NULL;
/*
* Install codec methods.
*/
tif->tif_fixuptags = LZMAFixupTags;
tif->tif_setupdecode = LZMASetupDecode;
tif->tif_predecode = LZMAPreDecode;
tif->tif_decoderow = LZMADecode;
tif->tif_decodestrip = LZMADecode;
tif->tif_decodetile = LZMADecode;
tif->tif_setupencode = LZMASetupEncode;
tif->tif_preencode = LZMAPreEncode;
tif->tif_postencode = LZMAPostEncode;
tif->tif_encoderow = LZMAEncode;
tif->tif_encodestrip = LZMAEncode;
tif->tif_encodetile = LZMAEncode;
tif->tif_cleanup = LZMACleanup;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
return 1;
bad:
TIFFErrorExt(tif->tif_clientdata, module,
"No space for LZMA2 state block");
return 0;
}
#endif /* LZMA_SUPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */

348
3rdparty/libtiff/tif_lzw.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_lzw.c,v 1.29.2.6 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_lzw.c,v 1.45 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -27,7 +27,7 @@
#include "tiffiop.h"
#ifdef LZW_SUPPORT
/*
* TIFF Library.
* TIFF Library.
* Rev 5.0 Lempel-Ziv & Welch Compression Support
*
* This code is derived from the compress program whose code is
@ -53,34 +53,34 @@
*
* Future revisions to the TIFF spec are expected to "clarify this issue".
*/
#define LZW_COMPAT /* include backwards compatibility code */
#define LZW_COMPAT /* include backwards compatibility code */
/*
* Each strip of data is supposed to be terminated by a CODE_EOI.
* If the following #define is included, the decoder will also
* check for end-of-strip w/o seeing this code. This makes the
* library more robust, but also slower.
*/
#define LZW_CHECKEOS /* include checks for strips w/o EOI code */
#define LZW_CHECKEOS /* include checks for strips w/o EOI code */
#define MAXCODE(n) ((1L<<(n))-1)
/*
* The TIFF spec specifies that encoded bit
* strings range from 9 to 12 bits.
*/
#define BITS_MIN 9 /* start with 9 bits */
#define BITS_MAX 12 /* max of 12 bit strings */
#define BITS_MIN 9 /* start with 9 bits */
#define BITS_MAX 12 /* max of 12 bit strings */
/* predefined codes */
#define CODE_CLEAR 256 /* code to clear string table */
#define CODE_EOI 257 /* end-of-information code */
#define CODE_FIRST 258 /* first free code entry */
#define CODE_MAX MAXCODE(BITS_MAX)
#define HSIZE 9001L /* 91% occupancy */
#define HSHIFT (13-8)
#define CODE_CLEAR 256 /* code to clear string table */
#define CODE_EOI 257 /* end-of-information code */
#define CODE_FIRST 258 /* first free code entry */
#define CODE_MAX MAXCODE(BITS_MAX)
#define HSIZE 9001L /* 91% occupancy */
#define HSHIFT (13-8)
#ifdef LZW_COMPAT
/* NB: +1024 is for compatibility with old files */
#define CSIZE (MAXCODE(BITS_MAX)+1024L)
#define CSIZE (MAXCODE(BITS_MAX)+1024L)
#else
#define CSIZE (MAXCODE(BITS_MAX)+1L)
#define CSIZE (MAXCODE(BITS_MAX)+1L)
#endif
/*
@ -88,23 +88,23 @@
* compression/decompression. Note that the predictor
* state block must be first in this data structure.
*/
typedef struct {
TIFFPredictorState predict; /* predictor super class */
typedef struct {
TIFFPredictorState predict; /* predictor super class */
unsigned short nbits; /* # of bits/code */
unsigned short maxcode; /* maximum code for lzw_nbits */
unsigned short free_ent; /* next free entry in hash table */
long nextdata; /* next bits of i/o */
long nextbits; /* # of valid bits in lzw_nextdata */
unsigned short nbits; /* # of bits/code */
unsigned short maxcode; /* maximum code for lzw_nbits */
unsigned short free_ent; /* next free entry in hash table */
long nextdata; /* next bits of i/o */
long nextbits; /* # of valid bits in lzw_nextdata */
int rw_mode; /* preserve rw_mode from init */
int rw_mode; /* preserve rw_mode from init */
} LZWBaseState;
#define lzw_nbits base.nbits
#define lzw_maxcode base.maxcode
#define lzw_free_ent base.free_ent
#define lzw_nextdata base.nextdata
#define lzw_nextbits base.nextbits
#define lzw_nbits base.nbits
#define lzw_maxcode base.maxcode
#define lzw_free_ent base.free_ent
#define lzw_nextdata base.nextdata
#define lzw_nextbits base.nextbits
/*
* Encoding-specific state.
@ -125,44 +125,44 @@ typedef struct code_ent {
unsigned char firstchar; /* first token of string */
} code_t;
typedef int (*decodeFunc)(TIFF*, tidata_t, tsize_t, tsample_t);
typedef int (*decodeFunc)(TIFF*, uint8*, tmsize_t, uint16);
typedef struct {
LZWBaseState base;
/* Decoding specific data */
long dec_nbitsmask; /* lzw_nbits 1 bits, right adjusted */
long dec_restart; /* restart count */
long dec_nbitsmask; /* lzw_nbits 1 bits, right adjusted */
long dec_restart; /* restart count */
#ifdef LZW_CHECKEOS
long dec_bitsleft; /* available bits in raw data */
uint64 dec_bitsleft; /* available bits in raw data */
#endif
decodeFunc dec_decode; /* regular or backwards compatible */
code_t* dec_codep; /* current recognized code */
code_t* dec_oldcodep; /* previously recognized code */
code_t* dec_free_entp; /* next free entry */
code_t* dec_maxcodep; /* max available entry */
code_t* dec_codetab; /* kept separate for small machines */
code_t* dec_codep; /* current recognized code */
code_t* dec_oldcodep; /* previously recognized code */
code_t* dec_free_entp; /* next free entry */
code_t* dec_maxcodep; /* max available entry */
code_t* dec_codetab; /* kept separate for small machines */
/* Encoding specific data */
int enc_oldcode; /* last code encountered */
long enc_checkpoint; /* point at which to clear table */
int enc_oldcode; /* last code encountered */
long enc_checkpoint; /* point at which to clear table */
#define CHECK_GAP 10000 /* enc_ratio check interval */
long enc_ratio; /* current compression ratio */
long enc_incount; /* (input) data bytes encoded */
long enc_outcount; /* encoded (output) bytes */
tidata_t enc_rawlimit; /* bound on tif_rawdata buffer */
hash_t* enc_hashtab; /* kept separate for small machines */
long enc_ratio; /* current compression ratio */
long enc_incount; /* (input) data bytes encoded */
long enc_outcount; /* encoded (output) bytes */
uint8* enc_rawlimit; /* bound on tif_rawdata buffer */
hash_t* enc_hashtab; /* kept separate for small machines */
} LZWCodecState;
#define LZWState(tif) ((LZWBaseState*) (tif)->tif_data)
#define DecoderState(tif) ((LZWCodecState*) LZWState(tif))
#define EncoderState(tif) ((LZWCodecState*) LZWState(tif))
#define LZWState(tif) ((LZWBaseState*) (tif)->tif_data)
#define DecoderState(tif) ((LZWCodecState*) LZWState(tif))
#define EncoderState(tif) ((LZWCodecState*) LZWState(tif))
static int LZWDecode(TIFF*, tidata_t, tsize_t, tsample_t);
static int LZWDecode(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
#ifdef LZW_COMPAT
static int LZWDecodeCompat(TIFF*, tidata_t, tsize_t, tsample_t);
static int LZWDecodeCompat(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
#endif
static void cl_hash(LZWCodecState*);
static void cl_hash(LZWCodecState*);
/*
* LZW Decoder.
@ -174,8 +174,8 @@ static void cl_hash(LZWCodecState*);
* strip is suppose to be terminated with CODE_EOI.
*/
#define NextCode(_tif, _sp, _bp, _code, _get) { \
if ((_sp)->dec_bitsleft < nbits) { \
TIFFWarningExt(_tif->tif_clientdata, _tif->tif_name, \
if ((_sp)->dec_bitsleft < (uint64)nbits) { \
TIFFWarningExt(_tif->tif_clientdata, module, \
"LZWDecode: Strip %d not terminated with EOI code", \
_tif->tif_curstrip); \
_code = CODE_EOI; \
@ -188,37 +188,44 @@ static void cl_hash(LZWCodecState*);
#define NextCode(tif, sp, bp, code, get) get(sp, bp, code)
#endif
static int
LZWFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
static int
LZWSetupDecode(TIFF* tif)
{
static const char module[] = "LZWSetupDecode";
LZWCodecState* sp = DecoderState(tif);
static const char module[] = " LZWSetupDecode";
int code;
if( sp == NULL )
{
/*
* Allocate state block so tag methods have storage to record
* values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof(LZWCodecState));
if (tif->tif_data == NULL)
{
TIFFErrorExt(tif->tif_clientdata, "LZWPreDecode", "No space for LZW state block");
return (0);
}
if( sp == NULL )
{
/*
* Allocate state block so tag methods have storage to record
* values.
*/
tif->tif_data = (uint8*) _TIFFmalloc(sizeof(LZWCodecState));
if (tif->tif_data == NULL)
{
TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW state block");
return (0);
}
DecoderState(tif)->dec_codetab = NULL;
DecoderState(tif)->dec_decode = NULL;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
DecoderState(tif)->dec_codetab = NULL;
DecoderState(tif)->dec_decode = NULL;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
sp = DecoderState(tif);
}
sp = DecoderState(tif);
}
assert(sp != NULL);
if (sp->dec_codetab == NULL) {
@ -231,13 +238,13 @@ LZWSetupDecode(TIFF* tif)
/*
* Pre-load the table.
*/
code = 255;
do {
sp->dec_codetab[code].value = code;
sp->dec_codetab[code].firstchar = code;
sp->dec_codetab[code].length = 1;
sp->dec_codetab[code].next = NULL;
} while (code--);
code = 255;
do {
sp->dec_codetab[code].value = code;
sp->dec_codetab[code].firstchar = code;
sp->dec_codetab[code].length = 1;
sp->dec_codetab[code].next = NULL;
} while (code--);
/*
* Zero-out the unused entries
*/
@ -251,13 +258,14 @@ LZWSetupDecode(TIFF* tif)
* Setup state for decoding a strip.
*/
static int
LZWPreDecode(TIFF* tif, tsample_t s)
LZWPreDecode(TIFF* tif, uint16 s)
{
static const char module[] = "LZWPreDecode";
LZWCodecState *sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
if( sp->dec_codetab == NULL )
if( sp->dec_codetab == NULL )
{
tif->tif_setupdecode( tif );
}
@ -268,7 +276,7 @@ LZWPreDecode(TIFF* tif, tsample_t s)
if (tif->tif_rawdata[0] == 0 && (tif->tif_rawdata[1] & 0x1)) {
#ifdef LZW_COMPAT
if (!sp->dec_decode) {
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
TIFFWarningExt(tif->tif_clientdata, module,
"Old-style LZW codes, convert file");
/*
* Override default decoding methods with
@ -291,7 +299,7 @@ LZWPreDecode(TIFF* tif, tsample_t s)
sp->lzw_maxcode = MAXCODE(BITS_MIN);
#else /* !LZW_COMPAT */
if (!sp->dec_decode) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"Old-style LZW codes not supported");
sp->dec_decode = LZWDecode;
}
@ -308,7 +316,7 @@ LZWPreDecode(TIFF* tif, tsample_t s)
sp->dec_restart = 0;
sp->dec_nbitsmask = MAXCODE(BITS_MIN);
#ifdef LZW_CHECKEOS
sp->dec_bitsleft = tif->tif_rawcc << 3;
sp->dec_bitsleft = ((uint64)tif->tif_rawcc) << 3;
#endif
sp->dec_free_entp = sp->dec_codetab + CODE_FIRST;
/*
@ -339,16 +347,17 @@ LZWPreDecode(TIFF* tif, tsample_t s)
}
static void
codeLoop(TIFF* tif)
codeLoop(TIFF* tif, const char* module)
{
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Bogus encoding, loop in the code table; scanline %d",
TIFFErrorExt(tif->tif_clientdata, module,
"Bogus encoding, loop in the code table; scanline %d",
tif->tif_row);
}
static int
LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
LZWDecode(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s)
{
static const char module[] = "LZWDecode";
LZWCodecState *sp = DecoderState(tif);
char *op = (char*) op0;
long occ = (long) occ0;
@ -362,6 +371,12 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
(void) s;
assert(sp != NULL);
assert(sp->dec_codetab != NULL);
/*
Fail if value does not fit in long.
*/
if ((tmsize_t) occ != occ0)
return (0);
/*
* Restart interrupted output operation.
*/
@ -428,7 +443,7 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
NextCode(tif, sp, bp, code, GetNextCode);
if (code == CODE_EOI)
break;
if (code == CODE_CLEAR) {
if (code >= CODE_CLEAR) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Corrupted LZW table at scanline %d",
tif->tif_row);
@ -441,22 +456,22 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
codep = sp->dec_codetab + code;
/*
* Add the new entry to the code table.
*/
* Add the new entry to the code table.
*/
if (free_entp < &sp->dec_codetab[0] ||
free_entp >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Corrupted LZW table at scanline %d",
tif->tif_row);
free_entp >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, module,
"Corrupted LZW table at scanline %d",
tif->tif_row);
return (0);
}
free_entp->next = oldcodep;
if (free_entp->next < &sp->dec_codetab[0] ||
free_entp->next >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Corrupted LZW table at scanline %d",
tif->tif_row);
free_entp->next >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, module,
"Corrupted LZW table at scanline %d",
tif->tif_row);
return (0);
}
free_entp->firstchar = free_entp->next->firstchar;
@ -472,15 +487,15 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
oldcodep = codep;
if (code >= 256) {
/*
* Code maps to a string, copy string
* Code maps to a string, copy string
* value to output (written in reverse).
*/
*/
if(codep->length == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Wrong length of decoded string: "
"data probably corrupted at scanline %d",
tif->tif_row);
return (0);
TIFFErrorExt(tif->tif_clientdata, module,
"Wrong length of decoded string: "
"data probably corrupted at scanline %d",
tif->tif_row);
return (0);
}
if (codep->length > occ) {
/*
@ -494,14 +509,14 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
codep = codep->next;
} while (codep && codep->length > occ);
if (codep) {
sp->dec_restart = occ;
sp->dec_restart = (long)occ;
tp = op + occ;
do {
*--tp = codep->value;
codep = codep->next;
} while (--occ && codep);
if (codep)
codeLoop(tif);
codeLoop(tif, module);
}
break;
}
@ -515,15 +530,16 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
*tp = t;
} while (codep && tp > op);
if (codep) {
codeLoop(tif);
codeLoop(tif, module);
break;
}
assert(occ >= len);
op += len, occ -= len;
} else
*op++ = (char)code, occ--;
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
sp->lzw_nbits = (unsigned short) nbits;
sp->lzw_nextdata = nextdata;
sp->lzw_nextbits = nextbits;
@ -533,9 +549,15 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
sp->dec_maxcodep = maxcodep;
if (occ > 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Not enough data at scanline %d (short %ld bytes)",
tif->tif_row, occ);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %d (short %I64d bytes)",
tif->tif_row, (unsigned __int64) occ);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %d (short %llu bytes)",
tif->tif_row, (unsigned long long) occ);
#endif
return (0);
}
return (1);
@ -558,8 +580,9 @@ LZWDecode(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
}
static int
LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
LZWDecodeCompat(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s)
{
static const char module[] = "LZWDecodeCompat";
LZWCodecState *sp = DecoderState(tif);
char *op = (char*) op0;
long occ = (long) occ0;
@ -571,6 +594,13 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
(void) s;
assert(sp != NULL);
/*
Fail if value does not fit in long.
*/
if ((tmsize_t) occ != occ0)
return (0);
/*
* Restart interrupted output operation.
*/
@ -632,7 +662,7 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
NextCode(tif, sp, bp, code, GetNextCodeCompat);
if (code == CODE_EOI)
break;
if (code == CODE_CLEAR) {
if (code >= CODE_CLEAR) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecode: Corrupted LZW table at scanline %d",
tif->tif_row);
@ -645,22 +675,20 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
codep = sp->dec_codetab + code;
/*
* Add the new entry to the code table.
*/
* Add the new entry to the code table.
*/
if (free_entp < &sp->dec_codetab[0] ||
free_entp >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecodeCompat: Corrupted LZW table at scanline %d",
tif->tif_row);
free_entp >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, module,
"Corrupted LZW table at scanline %d", tif->tif_row);
return (0);
}
free_entp->next = oldcodep;
if (free_entp->next < &sp->dec_codetab[0] ||
free_entp->next >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecodeCompat: Corrupted LZW table at scanline %d",
tif->tif_row);
free_entp->next >= &sp->dec_codetab[CSIZE]) {
TIFFErrorExt(tif->tif_clientdata, module,
"Corrupted LZW table at scanline %d", tif->tif_row);
return (0);
}
free_entp->firstchar = free_entp->next->firstchar;
@ -675,17 +703,16 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
}
oldcodep = codep;
if (code >= 256) {
char *op_orig = op;
/*
* Code maps to a string, copy string
* Code maps to a string, copy string
* value to output (written in reverse).
*/
*/
if(codep->length == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecodeCompat: Wrong length of decoded "
"string: data probably corrupted at scanline %d",
tif->tif_row);
return (0);
TIFFErrorExt(tif->tif_clientdata, module,
"Wrong length of decoded "
"string: data probably corrupted at scanline %d",
tif->tif_row);
return (0);
}
if (codep->length > occ) {
/*
@ -706,16 +733,17 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
} while (--occ);
break;
}
assert(occ >= codep->length);
op += codep->length, occ -= codep->length;
tp = op;
do {
*--tp = codep->value;
} while( (codep = codep->next) != NULL && tp > op_orig);
} while( (codep = codep->next) != NULL );
} else
*op++ = code, occ--;
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
sp->lzw_nbits = nbits;
sp->lzw_nextdata = nextdata;
sp->lzw_nextbits = nextbits;
@ -725,9 +753,15 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
sp->dec_maxcodep = maxcodep;
if (occ > 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"LZWDecodeCompat: Not enough data at scanline %d (short %ld bytes)",
tif->tif_row, occ);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %d (short %I64d bytes)",
tif->tif_row, (unsigned __int64) occ);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %d (short %llu bytes)",
tif->tif_row, (unsigned long long) occ);
#endif
return (0);
}
return (1);
@ -741,13 +775,14 @@ LZWDecodeCompat(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
static int
LZWSetupEncode(TIFF* tif)
{
LZWCodecState* sp = EncoderState(tif);
static const char module[] = "LZWSetupEncode";
LZWCodecState* sp = EncoderState(tif);
assert(sp != NULL);
sp->enc_hashtab = (hash_t*) _TIFFmalloc(HSIZE*sizeof (hash_t));
if (sp->enc_hashtab == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "No space for LZW hash table");
TIFFErrorExt(tif->tif_clientdata, module,
"No space for LZW hash table");
return (0);
}
return (1);
@ -757,14 +792,14 @@ LZWSetupEncode(TIFF* tif)
* Reset encoding state at the start of a strip.
*/
static int
LZWPreEncode(TIFF* tif, tsample_t s)
LZWPreEncode(TIFF* tif, uint16 s)
{
LZWCodecState *sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
if( sp->enc_hashtab == NULL )
if( sp->enc_hashtab == NULL )
{
tif->tif_setupencode( tif );
}
@ -822,7 +857,7 @@ LZWPreEncode(TIFF* tif, tsample_t s)
* for the decoder.
*/
static int
LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
LZWEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
register LZWCodecState *sp = EncoderState(tif);
register long fcode;
@ -833,7 +868,8 @@ LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
long incount, outcount, checkpoint;
long nextdata, nextbits;
int free_ent, maxcode, nbits;
tidata_t op, limit;
uint8* op;
uint8* limit;
(void) s;
if (sp == NULL)
@ -912,7 +948,7 @@ LZWEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
* are at least 4 bytes free--room for 2 codes.
*/
if (op > limit) {
tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata);
tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata);
TIFFFlushData1(tif);
op = tif->tif_rawdata;
}
@ -990,14 +1026,14 @@ static int
LZWPostEncode(TIFF* tif)
{
register LZWCodecState *sp = EncoderState(tif);
tidata_t op = tif->tif_rawcp;
uint8* op = tif->tif_rawcp;
long nextbits = sp->lzw_nextbits;
long nextdata = sp->lzw_nextdata;
long outcount = sp->enc_outcount;
int nbits = sp->lzw_nbits;
if (op > sp->enc_rawlimit) {
tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata);
tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata);
TIFFFlushData1(tif);
op = tif->tif_rawdata;
}
@ -1008,7 +1044,7 @@ LZWPostEncode(TIFF* tif)
PutNextCode(op, CODE_EOI);
if (nextbits > 0)
*op++ = (unsigned char)(nextdata << (8-nextbits));
tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata);
tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata);
return (1);
}
@ -1021,7 +1057,7 @@ cl_hash(LZWCodecState* sp)
register hash_t *hp = &sp->enc_hashtab[HSIZE-1];
register long i = HSIZE-8;
do {
do {
i -= 8;
hp[-7].hash = -1;
hp[-6].hash = -1;
@ -1033,7 +1069,7 @@ cl_hash(LZWCodecState* sp)
hp[ 0].hash = -1;
hp -= 8;
} while (i >= 0);
for (i += 8; i > 0; i--, hp--)
for (i += 8; i > 0; i--, hp--)
hp->hash = -1;
}
@ -1059,11 +1095,12 @@ LZWCleanup(TIFF* tif)
int
TIFFInitLZW(TIFF* tif, int scheme)
{
static const char module[] = "TIFFInitLZW";
assert(scheme == COMPRESSION_LZW);
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LZWCodecState));
tif->tif_data = (uint8*) _TIFFmalloc(sizeof (LZWCodecState));
if (tif->tif_data == NULL)
goto bad;
DecoderState(tif)->dec_codetab = NULL;
@ -1074,6 +1111,7 @@ TIFFInitLZW(TIFF* tif, int scheme)
/*
* Install codec methods.
*/
tif->tif_fixuptags = LZWFixupTags;
tif->tif_setupdecode = LZWSetupDecode;
tif->tif_predecode = LZWPreDecode;
tif->tif_decoderow = LZWDecode;
@ -1092,7 +1130,7 @@ TIFFInitLZW(TIFF* tif, int scheme)
(void) TIFFPredictorInit(tif);
return (1);
bad:
TIFFErrorExt(tif->tif_clientdata, "TIFFInitLZW",
TIFFErrorExt(tif->tif_clientdata, module,
"No space for LZW state block");
return (0);
}

30
3rdparty/libtiff/tif_next.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_next.c,v 1.8.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_next.c,v 1.13 2010-03-10 18:56:48 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -46,12 +46,13 @@
#define WHITE ((1<<2)-1)
static int
NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
static const char module[] = "NeXTDecode";
unsigned char *bp, *op;
tsize_t cc;
tidata_t row;
tsize_t scanline, n;
tmsize_t cc;
uint8* row;
tmsize_t scanline, n;
(void) s;
/*
@ -59,12 +60,17 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
* white (we assume a PhotometricInterpretation
* of ``min-is-black'').
*/
for (op = buf, cc = occ; cc-- > 0;)
for (op = (unsigned char*) buf, cc = occ; cc-- > 0;)
*op++ = 0xff;
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
scanline = tif->tif_scanlinesize;
if (occ % scanline)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (0);
}
for (row = buf; occ > 0; occ -= scanline, row += scanline) {
n = *bp++, cc--;
switch (n) {
@ -79,7 +85,7 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
cc -= scanline;
break;
case LITERALSPAN: {
tsize_t off;
tmsize_t off;
/*
* The scanline has a literal span that begins at some
* offset.
@ -105,7 +111,7 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
*/
op = row;
for (;;) {
grey = (n>>6) & 0x3;
grey = (uint32)((n>>6) & 0x3);
n &= 0x3f;
/*
* Ensure the run does not exceed the scanline
@ -124,11 +130,11 @@ NeXTDecode(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
}
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
return (1);
bad:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "NeXTDecode: Not enough data for scanline %ld",
TIFFErrorExt(tif->tif_clientdata, module, "Not enough data for scanline %ld",
(long) tif->tif_row);
return (0);
}
@ -137,8 +143,8 @@ int
TIFFInitNeXT(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = NeXTDecode;
tif->tif_decodestrip = NeXTDecode;
tif->tif_decoderow = NeXTDecode;
tif->tif_decodestrip = NeXTDecode;
tif->tif_decodetile = NeXTDecode;
return (1);
}

275
3rdparty/libtiff/tif_ojpeg.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_ojpeg.c,v 1.24.2.8 2010-12-11 21:25:04 faxguy Exp $ */
/* $Id: tif_ojpeg.c,v 1.54 2011-05-31 17:05:07 bfriesen Exp $ */
/* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0
specification is now totally obsolete and deprecated for new applications and
@ -120,6 +120,8 @@
session.
*/
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#include "tiffiop.h"
#ifdef OJPEG_SUPPORT
@ -146,7 +148,7 @@
* absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
*/
/* #define LIBJPEG_ENCAP_EXTERNAL */
/* define LIBJPEG_ENCAP_EXTERNAL */
#define SETJMP(jbuf) setjmp(jbuf)
#define LONGJMP(jbuf,code) longjmp(jbuf,code)
#define JMP_BUF jmp_buf
@ -173,22 +175,45 @@
#define FIELD_OJPEG_JPEGACTABLES (FIELD_CODEC+4)
#define FIELD_OJPEG_JPEGPROC (FIELD_CODEC+5)
#define FIELD_OJPEG_JPEGRESTARTINTERVAL (FIELD_CODEC+6)
#define FIELD_OJPEG_COUNT 7
static const TIFFFieldInfo ojpeg_field_info[] = {
{TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat"},
{TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength"},
{TIFFTAG_JPEGQTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables"},
{TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables"},
{TIFFTAG_JPEGACTABLES,TIFF_VARIABLE,TIFF_VARIABLE,TIFF_LONG,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables"},
{TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc"},
{TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval"},
static const TIFFField ojpegFields[] = {
{TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat",NULL},
{TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength",NULL},
{TIFFTAG_JPEGQTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables",NULL},
{TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables",NULL},
{TIFFTAG_JPEGACTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables",NULL},
{TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc",NULL},
{TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval",NULL},
};
#ifndef LIBJPEG_ENCAP_EXTERNAL
#include <setjmp.h>
#endif
/* We undefine FAR to avoid conflict with JPEG definition */
#ifdef FAR
#undef FAR
#endif
/*
Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is
not defined. Unfortunately, the MinGW and Borland compilers include
a typedef for INT32, which causes a conflict. MSVC does not include
a conficting typedef given the headers which are included.
*/
#if defined(__BORLANDC__) || defined(__MINGW32__)
# define XMD_H 1
#endif
/* Define "boolean" as unsigned char, not int, per Windows custom. */
#if defined(__WIN32__) && !defined(__MINGW32__)
# ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */
typedef unsigned char boolean;
# endif
# define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */
#endif
#include "jpeglib.h"
#include "jerror.h"
@ -224,7 +249,8 @@ typedef struct {
#endif
TIFFVGetMethod vgetparent;
TIFFVSetMethod vsetparent;
toff_t file_size;
TIFFPrintMethod printdir;
uint64 file_size;
uint32 image_width;
uint32 image_length;
uint32 strile_width;
@ -233,8 +259,8 @@ typedef struct {
uint8 samples_per_pixel;
uint8 plane_sample_offset;
uint8 samples_per_pixel_per_plane;
toff_t jpeg_interchange_format;
toff_t jpeg_interchange_format_length;
uint64 jpeg_interchange_format;
uint64 jpeg_interchange_format_length;
uint8 jpeg_proc;
uint8 subsamplingcorrect;
uint8 subsamplingcorrect_done;
@ -245,9 +271,9 @@ typedef struct {
uint8 qtable_offset_count;
uint8 dctable_offset_count;
uint8 actable_offset_count;
toff_t qtable_offset[3];
toff_t dctable_offset[3];
toff_t actable_offset[3];
uint64 qtable_offset[3];
uint64 dctable_offset[3];
uint64 actable_offset[3];
uint8* qtable[4];
uint8* dctable[4];
uint8* actable[4];
@ -265,14 +291,14 @@ typedef struct {
struct {
uint8 log;
OJPEGStateInBufferSource in_buffer_source;
tstrile_t in_buffer_next_strile;
toff_t in_buffer_file_pos;
toff_t in_buffer_file_togo;
uint32 in_buffer_next_strile;
uint64 in_buffer_file_pos;
uint64 in_buffer_file_togo;
} sos_end[3];
uint8 readheader_done;
uint8 writeheader_done;
tsample_t write_cursample;
tstrile_t write_curstrile;
uint16 write_cursample;
uint32 write_curstrile;
uint8 libjpeg_session_active;
uint8 libjpeg_jpeg_query_style;
jpeg_error_mgr libjpeg_jpeg_error_mgr;
@ -297,11 +323,11 @@ typedef struct {
uint32 bytes_per_line; /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows */
OJPEGStateInBufferSource in_buffer_source;
tstrile_t in_buffer_next_strile;
tstrile_t in_buffer_strile_count;
toff_t in_buffer_file_pos;
uint32 in_buffer_next_strile;
uint32 in_buffer_strile_count;
uint64 in_buffer_file_pos;
uint8 in_buffer_file_pos_log;
toff_t in_buffer_file_togo;
uint64 in_buffer_file_togo;
uint16 in_buffer_togo;
uint8* in_buffer_cur;
uint8 in_buffer[OJPEG_BUFFER];
@ -310,27 +336,28 @@ typedef struct {
uint8* skip_buffer;
} OJPEGState;
static int OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap);
static int OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap);
static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap);
static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap);
static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
static int OJPEGFixupTags(TIFF* tif);
static int OJPEGSetupDecode(TIFF* tif);
static int OJPEGPreDecode(TIFF* tif, tsample_t s);
static int OJPEGPreDecode(TIFF* tif, uint16 s);
static int OJPEGPreDecodeSkipRaw(TIFF* tif);
static int OJPEGPreDecodeSkipScanlines(TIFF* tif);
static int OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s);
static int OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc);
static int OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc);
static void OJPEGPostDecode(TIFF* tif, tidata_t buf, tsize_t cc);
static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc);
static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc);
static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
static int OJPEGSetupEncode(TIFF* tif);
static int OJPEGPreEncode(TIFF* tif, tsample_t s);
static int OJPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s);
static int OJPEGPreEncode(TIFF* tif, uint16 s);
static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
static int OJPEGPostEncode(TIFF* tif);
static void OJPEGCleanup(TIFF* tif);
static void OJPEGSubsamplingCorrect(TIFF* tif);
static int OJPEGReadHeaderInfo(TIFF* tif);
static int OJPEGReadSecondarySos(TIFF* tif, tsample_t s);
static int OJPEGReadSecondarySos(TIFF* tif, uint16 s);
static int OJPEGWriteHeaderInfo(TIFF* tif);
static void OJPEGLibjpegSessionAbort(TIFF* tif);
@ -399,9 +426,9 @@ TIFFInitOJPEG(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif,ojpeg_field_info,FIELD_OJPEG_COUNT)) {
if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging Old JPEG codec-specific tags failed");
"Merging Old JPEG codec-specific tags failed");
return 0;
}
@ -419,25 +446,27 @@ TIFFInitOJPEG(TIFF* tif, int scheme)
sp->subsampling_ver=2;
TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
/* tif codec methods */
tif->tif_fixuptags=OJPEGFixupTags;
tif->tif_setupdecode=OJPEGSetupDecode;
tif->tif_predecode=OJPEGPreDecode;
tif->tif_postdecode=OJPEGPostDecode;
tif->tif_decoderow=OJPEGDecode;
tif->tif_decodestrip=OJPEGDecode;
tif->tif_decodetile=OJPEGDecode;
tif->tif_postdecode=OJPEGPostDecode;
tif->tif_decoderow=OJPEGDecode;
tif->tif_decodestrip=OJPEGDecode;
tif->tif_decodetile=OJPEGDecode;
tif->tif_setupencode=OJPEGSetupEncode;
tif->tif_preencode=OJPEGPreEncode;
tif->tif_postencode=OJPEGPostEncode;
tif->tif_encoderow=OJPEGEncode;
tif->tif_encodestrip=OJPEGEncode;
tif->tif_encodetile=OJPEGEncode;
tif->tif_encoderow=OJPEGEncode;
tif->tif_encodestrip=OJPEGEncode;
tif->tif_encodetile=OJPEGEncode;
tif->tif_cleanup=OJPEGCleanup;
tif->tif_data=(tidata_t)sp;
tif->tif_data=(uint8*)sp;
/* tif tag methods */
sp->vgetparent=tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield=OJPEGVGetField;
sp->vsetparent=tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield=OJPEGVSetField;
sp->printdir=tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir=OJPEGPrintDir;
/* Some OJPEG files don't have strip or tile offsets or bytecounts tags.
Some others do, but have totally meaningless or corrupt values
@ -450,16 +479,16 @@ TIFFInitOJPEG(TIFF* tif, int scheme)
}
static int
OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
{
OJPEGState* sp=(OJPEGState*)tif->tif_data;
switch(tag)
{
case TIFFTAG_JPEGIFOFFSET:
*va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format;
*va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format;
break;
case TIFFTAG_JPEGIFBYTECOUNT:
*va_arg(ap,uint32*)=(uint32)sp->jpeg_interchange_format_length;
*va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length;
break;
case TIFFTAG_YCBCRSUBSAMPLING:
if (sp->subsamplingcorrect_done==0)
@ -469,11 +498,11 @@ OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
break;
case TIFFTAG_JPEGQTABLES:
*va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
*va_arg(ap,void**)=(void*)sp->qtable_offset;
*va_arg(ap,void**)=(void*)sp->qtable_offset;
break;
case TIFFTAG_JPEGDCTABLES:
*va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count;
*va_arg(ap,void**)=(void*)sp->dctable_offset;
*va_arg(ap,void**)=(void*)sp->dctable_offset;
break;
case TIFFTAG_JPEGACTABLES:
*va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
@ -492,30 +521,30 @@ OJPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
{
static const char module[]="OJPEGVSetField";
OJPEGState* sp=(OJPEGState*)tif->tif_data;
uint32 ma;
uint32* mb;
uint64* mb;
uint32 n;
switch(tag)
{
case TIFFTAG_JPEGIFOFFSET:
sp->jpeg_interchange_format=(toff_t)va_arg(ap,uint32);
sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
break;
case TIFFTAG_JPEGIFBYTECOUNT:
sp->jpeg_interchange_format_length=(toff_t)va_arg(ap,uint32);
sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
break;
case TIFFTAG_YCBCRSUBSAMPLING:
sp->subsampling_tag=1;
sp->subsampling_hor=(uint8)va_arg(ap,int);
sp->subsampling_ver=(uint8)va_arg(ap,int);
sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
break;
case TIFFTAG_JPEGQTABLES:
ma=va_arg(ap,uint32);
ma=(uint32)va_arg(ap,uint32);
if (ma!=0)
{
if (ma>3)
@ -524,13 +553,13 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
return(0);
}
sp->qtable_offset_count=(uint8)ma;
mb=va_arg(ap,uint32*);
mb=(uint64*)va_arg(ap,uint64*);
for (n=0; n<ma; n++)
sp->qtable_offset[n]=(toff_t)mb[n];
sp->qtable_offset[n]=mb[n];
}
break;
case TIFFTAG_JPEGDCTABLES:
ma=va_arg(ap,uint32);
ma=(uint32)va_arg(ap,uint32);
if (ma!=0)
{
if (ma>3)
@ -539,13 +568,13 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
return(0);
}
sp->dctable_offset_count=(uint8)ma;
mb=va_arg(ap,uint32*);
mb=(uint64*)va_arg(ap,uint64*);
for (n=0; n<ma; n++)
sp->dctable_offset[n]=(toff_t)mb[n];
sp->dctable_offset[n]=mb[n];
}
break;
case TIFFTAG_JPEGACTABLES:
ma=va_arg(ap,uint32);
ma=(uint32)va_arg(ap,uint32);
if (ma!=0)
{
if (ma>3)
@ -554,21 +583,21 @@ OJPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
return(0);
}
sp->actable_offset_count=(uint8)ma;
mb=va_arg(ap,uint32*);
mb=(uint64*)va_arg(ap,uint64*);
for (n=0; n<ma; n++)
sp->actable_offset[n]=(toff_t)mb[n];
sp->actable_offset[n]=mb[n];
}
break;
case TIFFTAG_JPEGPROC:
sp->jpeg_proc=(uint8)va_arg(ap,uint32);
sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
break;
case TIFFTAG_JPEGRESTARTINTERVAL:
sp->restart_interval=(uint16)va_arg(ap,uint32);
sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
break;
default:
return (*sp->vsetparent)(tif,tag,ap);
}
TIFFSetFieldBit(tif,_TIFFFieldWithTag(tif,tag)->field_bit);
TIFFSetFieldBit(tif,TIFFFieldWithTag(tif,tag)->field_bit);
tif->tif_flags|=TIFF_DIRTYDIRECT;
return(1);
}
@ -581,34 +610,43 @@ OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
(void)flags;
assert(sp!=NULL);
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
fprintf(fd," JpegInterchangeFormat: %lu\n",(unsigned long)sp->jpeg_interchange_format);
fprintf(fd," JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
fprintf(fd," JpegInterchangeFormatLength: %lu\n",(unsigned long)sp->jpeg_interchange_format_length);
fprintf(fd," JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
{
fprintf(fd," JpegQTables:");
for (m=0; m<sp->qtable_offset_count; m++)
fprintf(fd," %lu",(unsigned long)sp->qtable_offset[m]);
fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
fprintf(fd,"\n");
}
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
{
fprintf(fd," JpegDcTables:");
for (m=0; m<sp->dctable_offset_count; m++)
fprintf(fd," %lu",(unsigned long)sp->dctable_offset[m]);
fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
fprintf(fd,"\n");
}
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
{
fprintf(fd," JpegAcTables:");
for (m=0; m<sp->actable_offset_count; m++)
fprintf(fd," %lu",(unsigned long)sp->actable_offset[m]);
fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
fprintf(fd,"\n");
}
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
fprintf(fd," JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
fprintf(fd," JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
if (sp->printdir)
(*sp->printdir)(tif, fd, flags);
}
static int
OJPEGFixupTags(TIFF* tif)
{
(void) tif;
return(1);
}
static int
@ -620,10 +658,10 @@ OJPEGSetupDecode(TIFF* tif)
}
static int
OJPEGPreDecode(TIFF* tif, tsample_t s)
OJPEGPreDecode(TIFF* tif, uint16 s)
{
OJPEGState* sp=(OJPEGState*)tif->tif_data;
tstrile_t m;
uint32 m;
if (sp->subsamplingcorrect_done==0)
OJPEGSubsamplingCorrect(tif);
if (sp->readheader_done==0)
@ -637,9 +675,9 @@ OJPEGPreDecode(TIFF* tif, tsample_t s)
return(0);
}
if isTiled(tif)
m=(tstrile_t)tif->tif_curtile;
m=tif->tif_curtile;
else
m=(tstrile_t)tif->tif_curstrip;
m=tif->tif_curstrip;
if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
{
if (sp->libjpeg_session_active!=0)
@ -648,7 +686,7 @@ OJPEGPreDecode(TIFF* tif, tsample_t s)
}
if (sp->writeheader_done==0)
{
sp->plane_sample_offset=s;
sp->plane_sample_offset=(uint8)s;
sp->write_cursample=s;
sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
if ((sp->in_buffer_file_pos_log==0) ||
@ -739,7 +777,7 @@ OJPEGPreDecodeSkipScanlines(TIFF* tif)
}
static int
OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
{
OJPEGState* sp=(OJPEGState*)tif->tif_data;
(void)s;
@ -757,12 +795,12 @@ OJPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
}
static int
OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc)
OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
{
static const char module[]="OJPEGDecodeRaw";
OJPEGState* sp=(OJPEGState*)tif->tif_data;
uint8* m;
uint32 n;
tmsize_t n;
uint8* oy;
uint8* ocb;
uint8* ocr;
@ -812,12 +850,12 @@ OJPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc)
}
static int
OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc)
OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
{
static const char module[]="OJPEGDecodeScanlines";
OJPEGState* sp=(OJPEGState*)tif->tif_data;
uint8* m;
uint32 n;
tmsize_t n;
if (cc%sp->bytes_per_line!=0)
{
TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
@ -837,13 +875,13 @@ OJPEGDecodeScanlines(TIFF* tif, tidata_t buf, tsize_t cc)
}
static void
OJPEGPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc)
{
OJPEGState* sp=(OJPEGState*)tif->tif_data;
(void)buf;
(void)cc;
sp->write_curstrile++;
if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0)
if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0)
{
assert(sp->libjpeg_session_active!=0);
OJPEGLibjpegSessionAbort(tif);
@ -860,7 +898,7 @@ OJPEGSetupEncode(TIFF* tif)
}
static int
OJPEGPreEncode(TIFF* tif, tsample_t s)
OJPEGPreEncode(TIFF* tif, uint16 s)
{
static const char module[]="OJPEGPreEncode";
(void)s;
@ -869,7 +907,7 @@ OJPEGPreEncode(TIFF* tif, tsample_t s)
}
static int
OJPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
{
static const char module[]="OJPEGEncode";
(void)buf;
@ -895,6 +933,7 @@ OJPEGCleanup(TIFF* tif)
{
tif->tif_tagmethods.vgetfield=sp->vgetparent;
tif->tif_tagmethods.vsetfield=sp->vsetparent;
tif->tif_tagmethods.printdir=sp->printdir;
if (sp->qtable[0]!=0)
_TIFFfree(sp->qtable[0]);
if (sp->qtable[1]!=0)
@ -940,6 +979,8 @@ OJPEGSubsamplingCorrect(TIFF* tif)
OJPEGState* sp=(OJPEGState*)tif->tif_data;
uint8 mh;
uint8 mv;
_TIFFFillStriles( tif );
assert(sp->subsamplingcorrect_done==0);
if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
(tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB)))
@ -1006,9 +1047,9 @@ OJPEGReadHeaderInfo(TIFF* tif)
sp->strile_length=tif->tif_dir.td_rowsperstrip;
sp->strile_length_total=sp->image_length;
}
sp->samples_per_pixel=tif->tif_dir.td_samplesperpixel;
if (sp->samples_per_pixel==1)
if (tif->tif_dir.td_samplesperpixel==1)
{
sp->samples_per_pixel=1;
sp->plane_sample_offset=0;
sp->samples_per_pixel_per_plane=sp->samples_per_pixel;
sp->subsampling_hor=1;
@ -1016,11 +1057,12 @@ OJPEGReadHeaderInfo(TIFF* tif)
}
else
{
if (sp->samples_per_pixel!=3)
if (tif->tif_dir.td_samplesperpixel!=3)
{
TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
return(0);
}
sp->samples_per_pixel=3;
sp->plane_sample_offset=0;
if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
sp->samples_per_pixel_per_plane=3;
@ -1042,13 +1084,13 @@ OJPEGReadHeaderInfo(TIFF* tif)
sp->sos_end[0].in_buffer_source=sp->in_buffer_source;
sp->sos_end[0].in_buffer_next_strile=sp->in_buffer_next_strile;
sp->sos_end[0].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
sp->readheader_done=1;
return(1);
}
static int
OJPEGReadSecondarySos(TIFF* tif, tsample_t s)
OJPEGReadSecondarySos(TIFF* tif, uint16 s)
{
OJPEGState* sp=(OJPEGState*)tif->tif_data;
uint8 m;
@ -1061,7 +1103,7 @@ OJPEGReadSecondarySos(TIFF* tif, tsample_t s)
sp->plane_sample_offset--;
sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source;
sp->in_buffer_next_strile=sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile;
sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos;
sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos;
sp->in_buffer_file_pos_log=0;
sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo;
sp->in_buffer_togo=0;
@ -1223,7 +1265,7 @@ OJPEGReadHeaderInfoSec(TIFF* tif)
}
sp->in_buffer_source=osibsNotSetYet;
sp->in_buffer_next_strile=0;
sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
sp->in_buffer_file_togo=0;
sp->in_buffer_togo=0;
do
@ -1391,12 +1433,15 @@ OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
nb[sizeof(uint32)+2]=0;
nb[sizeof(uint32)+3]=67;
if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0)
if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
_TIFFfree(nb);
return(0);
}
o=nb[sizeof(uint32)+4]&15;
if (3<o)
{
TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
_TIFFfree(nb);
return(0);
}
if (sp->qtable[o]!=0)
@ -1540,7 +1585,7 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
/* Y: Number of lines */
if (OJPEGReadWord(sp,&p)==0)
return(0);
if ((p<sp->image_length) && (p<sp->strile_length_total))
if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total))
{
TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
return(0);
@ -1549,7 +1594,7 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
/* X: Number of samples per line */
if (OJPEGReadWord(sp,&p)==0)
return(0);
if ((p<sp->image_width) && (p<sp->strile_width))
if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width))
{
TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
return(0);
@ -1721,7 +1766,7 @@ OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
ob[sizeof(uint32)+2]=0;
ob[sizeof(uint32)+3]=67;
ob[sizeof(uint32)+4]=m;
TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
if (p!=64)
return(0);
@ -1828,7 +1873,7 @@ OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
return(0);
}
}
TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
p=TIFFReadFile(tif,o,16);
if (p!=16)
return(0);
@ -1866,7 +1911,7 @@ static int
OJPEGReadBufferFill(OJPEGState* sp)
{
uint16 m;
tsize_t n;
tmsize_t n;
/* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made
* in any other case, seek or read errors should be passed through */
do
@ -1879,15 +1924,15 @@ OJPEGReadBufferFill(OJPEGState* sp)
sp->in_buffer_file_pos_log=1;
}
m=OJPEG_BUFFER;
if (m>sp->in_buffer_file_togo)
if ((uint64)m>sp->in_buffer_file_togo)
m=(uint16)sp->in_buffer_file_togo;
n=TIFFReadFile(sp->tif,sp->in_buffer,(tsize_t)m);
n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m);
if (n==0)
return(0);
assert(n>0);
assert(n<=OJPEG_BUFFER);
assert(n<65536);
assert((uint16)n<=sp->in_buffer_file_togo);
assert((uint64)n<=sp->in_buffer_file_togo);
m=(uint16)n;
sp->in_buffer_togo=m;
sp->in_buffer_cur=sp->in_buffer;
@ -1909,15 +1954,11 @@ OJPEGReadBufferFill(OJPEGState* sp)
case osibsJpegInterchangeFormat:
sp->in_buffer_source=osibsStrile;
case osibsStrile:
if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
sp->in_buffer_source=osibsEof;
else
{
if (sp->tif->tif_dir.td_stripoffset == 0) {
TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip offsets are missing");
return(0);
}
sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile];
sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile];
if (sp->in_buffer_file_pos!=0)
{
if (sp->in_buffer_file_pos>=sp->file_size)
@ -1930,7 +1971,7 @@ OJPEGReadBufferFill(OJPEGState* sp)
TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing");
return(0);
}
sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];
sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];
if (sp->in_buffer_file_togo==0)
sp->in_buffer_file_pos=0;
else if (sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size)
@ -2041,8 +2082,8 @@ OJPEGReadSkip(OJPEGState* sp, uint16 len)
{
assert(sp->in_buffer_togo==0);
n=m;
if (n>sp->in_buffer_file_togo)
n=sp->in_buffer_file_togo;
if ((uint64)n>sp->in_buffer_file_togo)
n=(uint16)sp->in_buffer_file_togo;
sp->in_buffer_file_pos+=n;
sp->in_buffer_file_togo-=n;
sp->in_buffer_file_pos_log=0;
@ -2281,7 +2322,7 @@ OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
switch(sp->in_buffer_source)
{
case osibsStrile:
if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
sp->out_state=ososRst;
else
sp->out_state=ososEoi;
@ -2376,7 +2417,7 @@ OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo)
{
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message)(cinfo,buffer);
TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg", "%s", buffer);
TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
}
static void
@ -2384,7 +2425,7 @@ OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo)
{
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message)(cinfo,buffer);
TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg", "%s", buffer);
TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
jpeg_encap_unwind((TIFF*)(cinfo->client_data));
}
@ -2400,7 +2441,7 @@ OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
TIFF* tif=(TIFF*)cinfo->client_data;
OJPEGState* sp=(OJPEGState*)tif->tif_data;
void* mem=0;
uint32 len=0;
uint32 len=0U;
if (OJPEGWriteStream(tif,&mem,&len)==0)
{
TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");

494
3rdparty/libtiff/tif_open.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_open.c,v 1.33.2.2 2010-12-06 16:54:22 faxguy Exp $ */
/* $Id: tif_open.c,v 1.46 2010-12-06 16:54:54 faxguy Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -29,90 +29,22 @@
*/
#include "tiffiop.h"
static const long typemask[13] = {
(long)0L, /* TIFF_NOTYPE */
(long)0x000000ffL, /* TIFF_BYTE */
(long)0xffffffffL, /* TIFF_ASCII */
(long)0x0000ffffL, /* TIFF_SHORT */
(long)0xffffffffL, /* TIFF_LONG */
(long)0xffffffffL, /* TIFF_RATIONAL */
(long)0x000000ffL, /* TIFF_SBYTE */
(long)0x000000ffL, /* TIFF_UNDEFINED */
(long)0x0000ffffL, /* TIFF_SSHORT */
(long)0xffffffffL, /* TIFF_SLONG */
(long)0xffffffffL, /* TIFF_SRATIONAL */
(long)0xffffffffL, /* TIFF_FLOAT */
(long)0xffffffffL, /* TIFF_DOUBLE */
};
static const int bigTypeshift[13] = {
0, /* TIFF_NOTYPE */
24, /* TIFF_BYTE */
0, /* TIFF_ASCII */
16, /* TIFF_SHORT */
0, /* TIFF_LONG */
0, /* TIFF_RATIONAL */
24, /* TIFF_SBYTE */
24, /* TIFF_UNDEFINED */
16, /* TIFF_SSHORT */
0, /* TIFF_SLONG */
0, /* TIFF_SRATIONAL */
0, /* TIFF_FLOAT */
0, /* TIFF_DOUBLE */
};
static const int litTypeshift[13] = {
0, /* TIFF_NOTYPE */
0, /* TIFF_BYTE */
0, /* TIFF_ASCII */
0, /* TIFF_SHORT */
0, /* TIFF_LONG */
0, /* TIFF_RATIONAL */
0, /* TIFF_SBYTE */
0, /* TIFF_UNDEFINED */
0, /* TIFF_SSHORT */
0, /* TIFF_SLONG */
0, /* TIFF_SRATIONAL */
0, /* TIFF_FLOAT */
0, /* TIFF_DOUBLE */
};
/*
* Dummy functions to fill the omitted client procedures.
*/
static int
_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
(void) fd; (void) pbase; (void) psize;
return (0);
}
static void
_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
{
(void) fd; (void) base; (void) size;
}
/*
* Initialize the shift & mask tables, and the
* byte swapping state according to the file
* contents and the machine architecture.
*/
static void
TIFFInitOrder(TIFF* tif, int magic)
{
tif->tif_typemask = typemask;
if (magic == TIFF_BIGENDIAN) {
tif->tif_typeshift = bigTypeshift;
#ifndef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
} else {
tif->tif_typeshift = litTypeshift;
#ifdef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
}
}
int
_TIFFgetMode(const char* mode, const char* module)
{
@ -155,10 +87,36 @@ TIFFClientOpen(
int m;
const char* cp;
/* The following are configuration checks. They should be redundant, but should not
* compile to any actual code in an optimised release build anyway. If any of them
* fail, (makefile-based or other) configuration is not correct */
assert(sizeof(uint8)==1);
assert(sizeof(int8)==1);
assert(sizeof(uint16)==2);
assert(sizeof(int16)==2);
assert(sizeof(uint32)==4);
assert(sizeof(int32)==4);
assert(sizeof(uint64)==8);
assert(sizeof(int64)==8);
assert(sizeof(tmsize_t)==sizeof(void*));
{
union{
uint8 a8[2];
uint16 a16;
} n;
n.a8[0]=1;
n.a8[1]=0;
#ifdef WORDS_BIGENDIAN
assert(n.a16==256);
#else
assert(n.a16==1);
#endif
}
m = _TIFFgetMode(mode, module);
if (m == -1)
goto bad2;
tif = (TIFF *)_TIFFmalloc(sizeof (TIFF) + strlen(name) + 1);
tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
if (tif == NULL) {
TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
goto bad2;
@ -167,14 +125,14 @@ TIFFClientOpen(
tif->tif_name = (char *)tif + sizeof (TIFF);
strcpy(tif->tif_name, name);
tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
tif->tif_curdir = (tdir_t) -1; /* non-existent directory */
tif->tif_curdir = (uint16) -1; /* non-existent directory */
tif->tif_curoff = 0;
tif->tif_curstrip = (tstrip_t) -1; /* invalid strip */
tif->tif_curstrip = (uint32) -1; /* invalid strip */
tif->tif_row = (uint32) -1; /* read/write pre-increment */
tif->tif_clientdata = clientdata;
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
TIFFErrorExt(clientdata, module,
"One of the client procedures is NULL pointer.");
"One of the client procedures is NULL pointer.");
goto bad2;
}
tif->tif_readproc = readproc;
@ -182,7 +140,7 @@ TIFFClientOpen(
tif->tif_seekproc = seekproc;
tif->tif_closeproc = closeproc;
tif->tif_sizeproc = sizeproc;
if (mapproc)
if (mapproc)
tif->tif_mapproc = mapproc;
else
tif->tif_mapproc = _tiffDummyMapProc;
@ -190,7 +148,7 @@ TIFFClientOpen(
tif->tif_unmapproc = unmapproc;
else
tif->tif_unmapproc = _tiffDummyUnmapProc;
_TIFFSetDefaultCompressionState(tif); /* setup default state */
_TIFFSetDefaultCompressionState(tif); /* setup default state */
/*
* Default is to return data MSB2LSB and enable the
* use of memory-mapped files and strip chopping when
@ -200,10 +158,10 @@ TIFFClientOpen(
if (m == O_RDONLY )
tif->tif_flags |= TIFF_MAPPED;
#ifdef STRIPCHOP_DEFAULT
#ifdef STRIPCHOP_DEFAULT
if (m == O_RDONLY || m == O_RDWR)
tif->tif_flags |= STRIPCHOP_DEFAULT;
#endif
#endif
/*
* Process library-specific flags in the open mode string.
@ -213,16 +171,18 @@ TIFFClientOpen(
* TIFF but only supports some braindead idea of what the
* vendor thinks TIFF is):
*
* 'l' use little-endian byte order for creating a file
* 'b' use big-endian byte order for creating a file
* 'L' read/write information using LSB2MSB bit order
* 'B' read/write information using MSB2LSB bit order
* 'H' read/write information using host bit order
* 'M' enable use of memory-mapped files when supported
* 'm' disable use of memory-mapped files
* 'C' enable strip chopping support when reading
* 'c' disable strip chopping support
* 'h' read TIFF header only, do not load the first IFD
* 'l' use little-endian byte order for creating a file
* 'b' use big-endian byte order for creating a file
* 'L' read/write information using LSB2MSB bit order
* 'B' read/write information using MSB2LSB bit order
* 'H' read/write information using host bit order
* 'M' enable use of memory-mapped files when supported
* 'm' disable use of memory-mapped files
* 'C' enable strip chopping support when reading
* 'c' disable strip chopping support
* 'h' read TIFF header only, do not load the first IFD
* '4' ClassicTIFF for creating a file (default)
* '8' BigTIFF for creating a file
*
* The use of the 'l' and 'b' flags is strongly discouraged.
* These flags are provided solely because numerous vendors,
@ -257,94 +217,120 @@ TIFFClientOpen(
*/
for (cp = mode; *cp; cp++)
switch (*cp) {
case 'b':
#ifndef WORDS_BIGENDIAN
if (m&O_CREAT)
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'l':
#ifdef WORDS_BIGENDIAN
if ((m&O_CREAT))
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_MSB2LSB;
break;
case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_LSB2MSB;
break;
case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
HOST_FILLORDER;
break;
case 'M':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_MAPPED;
break;
case 'm':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_MAPPED;
break;
case 'C':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_STRIPCHOP;
break;
case 'c':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_STRIPCHOP;
break;
case 'h':
tif->tif_flags |= TIFF_HEADERONLY;
break;
case 'b':
#ifndef WORDS_BIGENDIAN
if (m&O_CREAT)
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'l':
#ifdef WORDS_BIGENDIAN
if ((m&O_CREAT))
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_MSB2LSB;
break;
case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
FILLORDER_LSB2MSB;
break;
case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
HOST_FILLORDER;
break;
case 'M':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_MAPPED;
break;
case 'm':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_MAPPED;
break;
case 'C':
if (m == O_RDONLY)
tif->tif_flags |= TIFF_STRIPCHOP;
break;
case 'c':
if (m == O_RDONLY)
tif->tif_flags &= ~TIFF_STRIPCHOP;
break;
case 'h':
tif->tif_flags |= TIFF_HEADERONLY;
break;
case '8':
if (m&O_CREAT)
tif->tif_flags |= TIFF_BIGTIFF;
break;
}
/*
* Read in TIFF header.
*/
if ((m & O_TRUNC) ||
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
if (tif->tif_mode == O_RDONLY) {
TIFFErrorExt(tif->tif_clientdata, name,
"Cannot read TIFF header");
"Cannot read TIFF header");
goto bad;
}
/*
* Setup header and write.
*/
#ifdef WORDS_BIGENDIAN
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
#ifdef WORDS_BIGENDIAN
tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
#else
tif->tif_header.tiff_magic = tif->tif_flags & TIFF_SWAB
#else
tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
#endif
tif->tif_header.tiff_version = TIFF_VERSION;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.tiff_version);
tif->tif_header.tiff_diroff = 0; /* filled in later */
/*
* The doc for "fopen" for some STD_C_LIBs says that if you
* open a file for modify ("+"), then you must fseek (or
* fflush?) between any freads and fwrites. This is not
* necessary on most systems, but has been shown to be needed
* on Solaris.
*/
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
#endif
if (!(tif->tif_flags&TIFF_BIGTIFF))
{
tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
tif->tif_header.classic.tiff_diroff = 0;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.common.tiff_version);
tif->tif_header_size = sizeof(TIFFHeaderClassic);
}
else
{
tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
tif->tif_header.big.tiff_offsetsize = 8;
tif->tif_header.big.tiff_unused = 0;
tif->tif_header.big.tiff_diroff = 0;
if (tif->tif_flags & TIFF_SWAB)
{
TIFFSwabShort(&tif->tif_header.common.tiff_version);
TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
}
tif->tif_header_size = sizeof (TIFFHeaderBig);
}
/*
* The doc for "fopen" for some STD_C_LIBs says that if you
* open a file for modify ("+"), then you must fseek (or
* fflush?) between any freads and fwrites. This is not
* necessary on most systems, but has been shown to be needed
* on Solaris.
*/
TIFFSeekFile( tif, 0, SEEK_SET );
if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
TIFFErrorExt(tif->tif_clientdata, name,
"Error writing TIFF header");
"Error writing TIFF header");
goto bad;
}
/*
* Setup the byte order handling.
*/
TIFFInitOrder(tif, tif->tif_header.tiff_magic);
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
#ifndef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
} else {
#ifdef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
}
/*
* Setup default directory.
*/
@ -359,95 +345,139 @@ TIFFClientOpen(
/*
* Setup the byte order handling.
*/
if (tif->tif_header.tiff_magic != TIFF_BIGENDIAN &&
tif->tif_header.tiff_magic != TIFF_LITTLEENDIAN
#if MDI_SUPPORT
if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
#if MDI_SUPPORT
&&
#if HOST_BIGENDIAN
tif->tif_header.tiff_magic != MDI_BIGENDIAN
#else
tif->tif_header.tiff_magic != MDI_LITTLEENDIAN
#endif
#if HOST_BIGENDIAN
tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
#else
tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
#endif
) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF or MDI file, bad magic number %d (0x%x)",
#else
"Not a TIFF or MDI file, bad magic number %d (0x%x)",
#else
) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad magic number %d (0x%x)",
#endif
tif->tif_header.tiff_magic,
tif->tif_header.tiff_magic);
"Not a TIFF file, bad magic number %d (0x%x)",
#endif
tif->tif_header.common.tiff_magic,
tif->tif_header.common.tiff_magic);
goto bad;
}
TIFFInitOrder(tif, tif->tif_header.tiff_magic);
/*
* Swap header if required.
*/
if (tif->tif_flags & TIFF_SWAB) {
TIFFSwabShort(&tif->tif_header.tiff_version);
TIFFSwabLong(&tif->tif_header.tiff_diroff);
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
#ifndef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
} else {
#ifdef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
}
/*
* Now check version (if needed, it's been byte-swapped).
* Note that this isn't actually a version number, it's a
* magic number that doesn't change (stupid).
*/
if (tif->tif_header.tiff_version == TIFF_BIGTIFF_VERSION) {
TIFFErrorExt(tif->tif_clientdata, name,
"This is a BigTIFF file. This format not supported\n"
"by this version of libtiff." );
goto bad;
}
if (tif->tif_header.tiff_version != TIFF_VERSION) {
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.common.tiff_version);
if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
(tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad version number %d (0x%x)",
tif->tif_header.tiff_version,
tif->tif_header.tiff_version);
tif->tif_header.common.tiff_version,
tif->tif_header.common.tiff_version);
goto bad;
}
if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
{
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
tif->tif_header_size = sizeof(TIFFHeaderClassic);
}
else
{
if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
{
TIFFErrorExt(tif->tif_clientdata, name,
"Cannot read TIFF header");
goto bad;
}
if (tif->tif_flags & TIFF_SWAB)
{
TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
}
if (tif->tif_header.big.tiff_offsetsize != 8)
{
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
tif->tif_header.big.tiff_offsetsize,
tif->tif_header.big.tiff_offsetsize);
goto bad;
}
if (tif->tif_header.big.tiff_unused != 0)
{
TIFFErrorExt(tif->tif_clientdata, name,
"Not a TIFF file, bad BigTIFF unused %d (0x%x)",
tif->tif_header.big.tiff_unused,
tif->tif_header.big.tiff_unused);
goto bad;
}
tif->tif_header_size = sizeof(TIFFHeaderBig);
tif->tif_flags |= TIFF_BIGTIFF;
}
tif->tif_flags |= TIFF_MYBUFFER;
tif->tif_rawcp = tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
tif->tif_rawdataoff = 0;
tif->tif_rawdataloaded = 0;
/*
* Sometimes we do not want to read the first directory (for example,
* it may be broken) and want to proceed to other directories. I this
* case we use the TIFF_HEADERONLY flag to open file and return
* immediately after reading TIFF header.
*/
if (tif->tif_flags & TIFF_HEADERONLY)
return (tif);
/*
* Setup initial directory.
*/
switch (mode[0]) {
case 'r':
tif->tif_nextdiroff = tif->tif_header.tiff_diroff;
/*
* Try to use a memory-mapped file if the client
* has not explicitly suppressed usage with the
* 'm' flag in the open mode (see above).
*/
if ((tif->tif_flags & TIFF_MAPPED) &&
!TIFFMapFileContents(tif, (tdata_t*) &tif->tif_base, &tif->tif_size))
tif->tif_flags &= ~TIFF_MAPPED;
if (TIFFReadDirectory(tif)) {
tif->tif_rawcc = -1;
tif->tif_flags |= TIFF_BUFFERSETUP;
case 'r':
if (!(tif->tif_flags&TIFF_BIGTIFF))
tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
else
tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
/*
* Try to use a memory-mapped file if the client
* has not explicitly suppressed usage with the
* 'm' flag in the open mode (see above).
*/
if (tif->tif_flags & TIFF_MAPPED)
{
toff_t n;
if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
{
tif->tif_size=(tmsize_t)n;
assert((toff_t)tif->tif_size==n);
}
else
tif->tif_flags &= ~TIFF_MAPPED;
}
/*
* Sometimes we do not want to read the first directory (for example,
* it may be broken) and want to proceed to other directories. I this
* case we use the TIFF_HEADERONLY flag to open file and return
* immediately after reading TIFF header.
*/
if (tif->tif_flags & TIFF_HEADERONLY)
return (tif);
/*
* Setup initial directory.
*/
if (TIFFReadDirectory(tif)) {
tif->tif_rawcc = (tmsize_t)-1;
tif->tif_flags |= TIFF_BUFFERSETUP;
return (tif);
}
break;
case 'a':
/*
* New directories are automatically append
* to the end of the directory chain when they
* are written out (see TIFFWriteDirectory).
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
}
break;
case 'a':
/*
* New directories are automatically append
* to the end of the directory chain when they
* are written out (see TIFFWriteDirectory).
*/
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
}
bad:
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
@ -562,7 +592,7 @@ TIFFCurrentRow(TIFF* tif)
/*
* Return index of the current directory.
*/
tdir_t
uint16
TIFFCurrentDirectory(TIFF* tif)
{
return (tif->tif_curdir);
@ -571,7 +601,7 @@ TIFFCurrentDirectory(TIFF* tif)
/*
* Return current strip.
*/
tstrip_t
uint32
TIFFCurrentStrip(TIFF* tif)
{
return (tif->tif_curstrip);
@ -580,7 +610,7 @@ TIFFCurrentStrip(TIFF* tif)
/*
* Return current tile.
*/
ttile_t
uint32
TIFFCurrentTile(TIFF* tif)
{
return (tif->tif_curtile);
@ -619,7 +649,7 @@ TIFFIsMSB2LSB(TIFF* tif)
int
TIFFIsBigEndian(TIFF* tif)
{
return (tif->tif_header.tiff_magic == TIFF_BIGENDIAN);
return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
}
/*

126
3rdparty/libtiff/tif_packbits.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_packbits.c,v 1.13.2.2 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_packbits.c,v 1.20 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -34,19 +34,19 @@
#include <stdio.h>
static int
PackBitsPreEncode(TIFF* tif, tsample_t s)
PackBitsPreEncode(TIFF* tif, uint16 s)
{
(void) s;
if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof(tsize_t))))
if (!(tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t))))
return (0);
/*
* Calculate the scanline/tile-width size in bytes.
*/
if (isTiled(tif))
*(tsize_t*)tif->tif_data = TIFFTileRowSize(tif);
*(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif);
else
*(tsize_t*)tif->tif_data = TIFFScanlineSize(tif);
*(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif);
return (1);
}
@ -58,21 +58,16 @@ PackBitsPostEncode(TIFF* tif)
return (1);
}
/*
* NB: tidata is the type representing *(tidata_t);
* if tidata_t is made signed then this type must
* be adjusted accordingly.
*/
typedef unsigned char tidata;
/*
* Encode a run of pixels.
*/
static int
PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
{
unsigned char* bp = (unsigned char*) buf;
tidata_t op, ep, lastliteral;
uint8* op;
uint8* ep;
uint8* lastliteral;
long n, slop;
int b;
enum { BASE, LITERAL, RUN, LITERAL_RUN } state;
@ -98,8 +93,8 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
* front of the buffer.
*/
if (state == LITERAL || state == LITERAL_RUN) {
slop = op - lastliteral;
tif->tif_rawcc += lastliteral - tif->tif_rawcp;
slop = (long)(op - lastliteral);
tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
@ -107,7 +102,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
*op++ = *lastliteral++;
lastliteral = tif->tif_rawcp;
} else {
tif->tif_rawcc += op - tif->tif_rawcp;
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
if (!TIFFFlushData1(tif))
return (-1);
op = tif->tif_rawcp;
@ -118,17 +113,17 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
if (n > 1) {
state = RUN;
if (n > 128) {
*op++ = (tidata) -127;
*op++ = (tidataval_t) b;
*op++ = (uint8) -127;
*op++ = (uint8) b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1));
*op++ = (tidataval_t) b;
*op++ = (uint8)(-(n-1));
*op++ = (uint8) b;
} else {
lastliteral = op;
*op++ = 0;
*op++ = (tidataval_t) b;
*op++ = (uint8) b;
state = LITERAL;
}
break;
@ -136,33 +131,33 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
if (n > 1) {
state = LITERAL_RUN;
if (n > 128) {
*op++ = (tidata) -127;
*op++ = (tidataval_t) b;
*op++ = (uint8) -127;
*op++ = (uint8) b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1)); /* encode run */
*op++ = (tidataval_t) b;
*op++ = (uint8)(-(n-1)); /* encode run */
*op++ = (uint8) b;
} else { /* extend literal */
if (++(*lastliteral) == 127)
state = BASE;
*op++ = (tidataval_t) b;
*op++ = (uint8) b;
}
break;
case RUN: /* last object was run */
if (n > 1) {
if (n > 128) {
*op++ = (tidata) -127;
*op++ = (tidataval_t) b;
*op++ = (uint8) -127;
*op++ = (uint8) b;
n -= 128;
goto again;
}
*op++ = (tidataval_t)(-(n-1));
*op++ = (tidataval_t) b;
*op++ = (uint8)(-(n-1));
*op++ = (uint8) b;
} else {
lastliteral = op;
*op++ = 0;
*op++ = (tidataval_t) b;
*op++ = (uint8) b;
state = LITERAL;
}
break;
@ -173,7 +168,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
* case we convert literal-run-literal
* to a single literal.
*/
if (n == 1 && op[-2] == (tidata) -1 &&
if (n == 1 && op[-2] == (uint8) -1 &&
*lastliteral < 126) {
state = (((*lastliteral) += 2) == 127 ?
BASE : LITERAL);
@ -183,7 +178,7 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
goto again;
}
}
tif->tif_rawcc += op - tif->tif_rawcp;
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
tif->tif_rawcp = op;
return (1);
}
@ -196,12 +191,12 @@ PackBitsEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
* when it was encoded by strips.
*/
static int
PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
tsize_t rowsize = *(tsize_t*)tif->tif_data;
tmsize_t rowsize = *(tmsize_t*)tif->tif_data;
while ((long)cc > 0) {
int chunk = rowsize;
while (cc > 0) {
tmsize_t chunk = rowsize;
if( cc < chunk )
chunk = cc;
@ -215,17 +210,18 @@ PackBitsEncodeChunk(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
}
static int
PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "PackBitsDecode";
char *bp;
tsize_t cc;
tmsize_t cc;
long n;
int b;
(void) s;
bp = (char*) tif->tif_rawcp;
cc = tif->tif_rawcc;
while (cc > 0 && (long)occ > 0) {
while (cc > 0 && occ > 0) {
n = (long) *bp++, cc--;
/*
* Watch out for compilers that
@ -236,39 +232,37 @@ PackBitsDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
if (n < 0) { /* replicate next byte -n+1 times */
if (n == -128) /* nop */
continue;
n = -n + 1;
if( occ < n )
{
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
"PackBitsDecode: discarding %ld bytes "
"to avoid buffer overrun",
n - occ);
n = occ;
}
n = -n + 1;
if( occ < (tmsize_t)n )
{
TIFFWarningExt(tif->tif_clientdata, module,
"Discarding %lu bytes to avoid buffer overrun",
(unsigned long) ((tmsize_t)n - occ));
n = (long)occ;
}
occ -= n;
b = *bp++, cc--;
b = *bp++, cc--; /* TODO: may be reading past input buffer here when input data is corrupt or ends prematurely */
while (n-- > 0)
*op++ = (tidataval_t) b;
*op++ = (uint8) b;
} else { /* copy next n+1 bytes literally */
if (occ < n + 1)
{
TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
"PackBitsDecode: discarding %ld bytes "
"to avoid buffer overrun",
n - occ + 1);
n = occ - 1;
}
_TIFFmemcpy(op, bp, ++n);
if (occ < (tmsize_t)(n + 1))
{
TIFFWarningExt(tif->tif_clientdata, module,
"Discarding %lu bytes to avoid buffer overrun",
(unsigned long) ((tmsize_t)n - occ + 1));
n = (long)occ - 1;
}
_TIFFmemcpy(op, bp, ++n); /* TODO: may be reading past input buffer here when input data is corrupt or ends prematurely */
op += n; occ -= n;
bp += n; cc -= n;
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
if (occ > 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"PackBitsDecode: Not enough data for scanline %ld",
(long) tif->tif_row);
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data for scanline %lu",
(unsigned long) tif->tif_row);
return (0);
}
return (1);
@ -282,7 +276,7 @@ TIFFInitPackBits(TIFF* tif, int scheme)
tif->tif_decodestrip = PackBitsDecode;
tif->tif_decodetile = PackBitsDecode;
tif->tif_preencode = PackBitsPreEncode;
tif->tif_postencode = PackBitsPostEncode;
tif->tif_postencode = PackBitsPostEncode;
tif->tif_encoderow = PackBitsEncode;
tif->tif_encodestrip = PackBitsEncodeChunk;
tif->tif_encodetile = PackBitsEncodeChunk;

205
3rdparty/libtiff/tif_pixarlog.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_pixarlog.c,v 1.15.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_pixarlog.c,v 1.35 2011-01-06 16:00:23 fwarmerdam Exp $ */
/*
* Copyright (c) 1996-1997 Sam Leffler
@ -83,7 +83,10 @@
* The codec also handle byte swapping the encoded values as necessary
* since the library does not have the information necessary
* to know the bit depth of the raw unencoded buffer.
*
*
* NOTE: This decoder does not appear to update tif_rawcp, and tif_rawcc.
* This can cause problems with the implementation of CHUNKY_STRIP_READ_SUPPORT
* as noted in http://trac.osgeo.org/gdal/ticket/3894. FrankW - Jan'11
*/
#include "tif_predict.h"
@ -108,7 +111,7 @@ static float LogK1, LogK2;
#define REPEAT(n, op) { int i; i=n; do { i--; op; } while (i>0); }
static void
horizontalAccumulateF(uint16 *wp, int n, int stride, float *op,
horizontalAccumulateF(uint16 *wp, int n, int stride, float *op,
float *ToLinearF)
{
register unsigned int cr, cg, cb, ca, mask;
@ -587,11 +590,11 @@ PixarLogMakeTables(PixarLogState *sp)
return 1;
}
#define DecoderState(tif) ((PixarLogState*) (tif)->tif_data)
#define EncoderState(tif) ((PixarLogState*) (tif)->tif_data)
#define DecoderState(tif) ((PixarLogState*) (tif)->tif_data)
#define EncoderState(tif) ((PixarLogState*) (tif)->tif_data)
static int PixarLogEncode(TIFF*, tidata_t, tsize_t, tsample_t);
static int PixarLogDecode(TIFF*, tidata_t, tsize_t, tsample_t);
static int PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
static int PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
#define PIXARLOGDATAFMT_UNKNOWN -1
@ -630,10 +633,10 @@ PixarLogGuessDataFmt(TIFFDirectory *td)
return guess;
}
static uint32
multiply(size_t m1, size_t m2)
static tmsize_t
multiply_ms(tmsize_t m1, tmsize_t m2)
{
uint32 bytes = m1 * m2;
tmsize_t bytes = m1 * m2;
if (m1 && bytes / m1 != m2)
bytes = 0;
@ -641,28 +644,35 @@ multiply(size_t m1, size_t m2)
return bytes;
}
static int
PixarLogFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
static int
PixarLogSetupDecode(TIFF* tif)
{
static const char module[] = "PixarLogSetupDecode";
TIFFDirectory *td = &tif->tif_dir;
PixarLogState* sp = DecoderState(tif);
tsize_t tbuf_size;
static const char module[] = "PixarLogSetupDecode";
tmsize_t tbuf_size;
assert(sp != NULL);
/* Make sure no byte swapping happens on the data
* after decompression. */
tif->tif_postdecode = _TIFFNoPostDecode;
tif->tif_postdecode = _TIFFNoPostDecode;
/* for some reason, we can't do this in TIFFInitPixarLog */
sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
td->td_samplesperpixel : 1);
tbuf_size = multiply(multiply(multiply(sp->stride, td->td_imagewidth),
tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth),
td->td_rowsperstrip), sizeof(uint16));
if (tbuf_size == 0)
return (0);
return (0); /* TODO: this is an error return without error report through TIFFErrorExt */
sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size);
if (sp->tbuf == NULL)
return (0);
@ -676,7 +686,7 @@ PixarLogSetupDecode(TIFF* tif)
}
if (inflateInit(&sp->stream) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
return (0);
} else {
sp->state |= PLSTATE_INIT;
@ -688,24 +698,36 @@ PixarLogSetupDecode(TIFF* tif)
* Setup state for decoding a strip.
*/
static int
PixarLogPreDecode(TIFF* tif, tsample_t s)
PixarLogPreDecode(TIFF* tif, uint16 s)
{
static const char module[] = "PixarLogPreDecode";
PixarLogState* sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
sp->stream.next_in = tif->tif_rawdata;
sp->stream.avail_in = tif->tif_rawcc;
assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_in = (uInt) tif->tif_rawcc;
if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
return (inflateReset(&sp->stream) == Z_OK);
}
static int
PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
PixarLogDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
static const char module[] = "PixarLogDecode";
TIFFDirectory *td = &tif->tif_dir;
PixarLogState* sp = DecoderState(tif);
static const char module[] = "PixarLogDecode";
int i, nsamples, llen;
tmsize_t i;
tmsize_t nsamples;
int llen;
uint16 *up;
switch (sp->user_datafmt) {
@ -722,7 +744,7 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
nsamples = occ;
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"%d bit input not supported in PixarLog",
td->td_bitspersample);
return 0;
@ -733,7 +755,16 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
(void) s;
assert(sp != NULL);
sp->stream.next_out = (unsigned char *) sp->tbuf;
sp->stream.avail_out = nsamples * sizeof(uint16);
assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_out = (uInt) (nsamples * sizeof(uint16));
if (sp->stream.avail_out != nsamples * sizeof(uint16))
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
do {
int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
if (state == Z_STREAM_END) {
@ -741,15 +772,15 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
}
if (state == Z_DATA_ERROR) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Decoding error at scanline %d, %s",
tif->tif_name, tif->tif_row, sp->stream.msg);
"Decoding error at scanline %lu, %s",
(unsigned long) tif->tif_row, sp->stream.msg);
if (inflateSync(&sp->stream) != Z_OK)
return (0);
continue;
}
if (state != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
} while (sp->stream.avail_out > 0);
@ -757,8 +788,8 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
/* hopefully, we got all the bytes we needed */
if (sp->stream.avail_out != 0) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Not enough data at scanline %d (short %d bytes)",
tif->tif_name, tif->tif_row, sp->stream.avail_out);
"Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",
(unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);
return (0);
}
@ -767,15 +798,15 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfShort(up, nsamples);
/*
/*
* if llen is not an exact multiple of nsamples, the decode operation
* may overflow the output buffer, so truncate it enough to prevent
* that but still salvage as much data as possible.
*/
if (nsamples % llen) {
TIFFWarningExt(tif->tif_clientdata, module,
"%s: stride %d is not a multiple of sample count, "
"%d, data truncated.", tif->tif_name, llen, nsamples);
"stride %lu is not a multiple of sample count, "
"%lu, data truncated.", (unsigned long) llen, (unsigned long) nsamples);
nsamples -= nsamples % llen;
}
@ -812,8 +843,8 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
op += llen * sizeof(unsigned char);
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"PixarLogDecode: unsupported bits/sample: %d",
TIFFErrorExt(tif->tif_clientdata, module,
"Unsupported bits/sample: %d",
td->td_bitspersample);
return (0);
}
@ -825,10 +856,10 @@ PixarLogDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
static int
PixarLogSetupEncode(TIFF* tif)
{
static const char module[] = "PixarLogSetupEncode";
TIFFDirectory *td = &tif->tif_dir;
PixarLogState* sp = EncoderState(tif);
tsize_t tbuf_size;
static const char module[] = "PixarLogSetupEncode";
tmsize_t tbuf_size;
assert(sp != NULL);
@ -836,10 +867,10 @@ PixarLogSetupEncode(TIFF* tif)
sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
td->td_samplesperpixel : 1);
tbuf_size = multiply(multiply(multiply(sp->stride, td->td_imagewidth),
tbuf_size = multiply_ms(multiply_ms(multiply_ms(sp->stride, td->td_imagewidth),
td->td_rowsperstrip), sizeof(uint16));
if (tbuf_size == 0)
return (0);
return (0); /* TODO: this is an error return without error report through TIFFErrorExt */
sp->tbuf = (uint16 *) _TIFFmalloc(tbuf_size);
if (sp->tbuf == NULL)
return (0);
@ -851,7 +882,7 @@ PixarLogSetupEncode(TIFF* tif)
}
if (deflateInit(&sp->stream, sp->quality) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
return (0);
} else {
sp->state |= PLSTATE_INIT;
@ -863,21 +894,30 @@ PixarLogSetupEncode(TIFF* tif)
* Reset encoding state at the start of a strip.
*/
static int
PixarLogPreEncode(TIFF* tif, tsample_t s)
PixarLogPreEncode(TIFF* tif, uint16 s)
{
static const char module[] = "PixarLogPreEncode";
PixarLogState *sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
sp->stream.next_out = tif->tif_rawdata;
assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_out = tif->tif_rawdatasize;
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
return (deflateReset(&sp->stream) == Z_OK);
}
static void
horizontalDifferenceF(float *ip, int n, int stride, uint16 *wp, uint16 *FromLT2)
{
int32 r1, g1, b1, a1, r2, g2, b2, a2, mask;
float fltsize = Fltsize;
@ -1042,12 +1082,14 @@ horizontalDifference8(unsigned char *ip, int n, int stride,
* Encode a chunk of pixels.
*/
static int
PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
PixarLogEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
static const char module[] = "PixarLogEncode";
TIFFDirectory *td = &tif->tif_dir;
PixarLogState *sp = EncoderState(tif);
static const char module[] = "PixarLogEncode";
int i, n, llen;
tmsize_t i;
tmsize_t n;
int llen;
unsigned short * up;
(void) s;
@ -1066,7 +1108,7 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
n = cc;
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"%d bit input not supported in PixarLog",
td->td_bitspersample);
return 0;
@ -1092,7 +1134,7 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
bp += llen * sizeof(unsigned char);
break;
default:
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"%d bit input not supported in PixarLog",
td->td_bitspersample);
return 0;
@ -1100,19 +1142,29 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
}
sp->stream.next_in = (unsigned char *) sp->tbuf;
sp->stream.avail_in = n * sizeof(uint16);
assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_in = (uInt) (n * sizeof(uint16));
if ((sp->stream.avail_in / sizeof(uint16)) != (uInt) n)
{
TIFFErrorExt(tif->tif_clientdata, module,
"ZLib cannot deal with buffers this size");
return (0);
}
do {
if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Encoder error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s",
sp->stream.msg);
return (0);
}
if (sp->stream.avail_out == 0) {
tif->tif_rawcc = tif->tif_rawdatasize;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in PixarLogPreEncode */
}
} while (sp->stream.avail_in > 0);
return (1);
@ -1126,8 +1178,8 @@ PixarLogEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
static int
PixarLogPostEncode(TIFF* tif)
{
PixarLogState *sp = EncoderState(tif);
static const char module[] = "PixarLogPostEncode";
PixarLogState *sp = EncoderState(tif);
int state;
sp->stream.avail_in = 0;
@ -1137,17 +1189,17 @@ PixarLogPostEncode(TIFF* tif)
switch (state) {
case Z_STREAM_END:
case Z_OK:
if (sp->stream.avail_out != (uint32)tif->tif_rawdatasize) {
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) {
tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in PixarLogPreEncode */
}
break;
default:
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
} while (state != Z_STREAM_END);
@ -1159,9 +1211,11 @@ PixarLogClose(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
/* In a really sneaky maneuver, on close, we covertly modify both
* bitspersample and sampleformat in the directory to indicate
* 8-bit linear. This way, the decode "just works" even for
/* In a really sneaky (and really incorrect, and untruthfull, and
* troublesome, and error-prone) maneuver that completely goes against
* the spirit of TIFF, and breaks TIFF, on close, we covertly
* modify both bitspersample and sampleformat in the directory to
* indicate 8-bit linear. This way, the decode "just works" even for
* readers that don't know about PixarLog, or how to set
* the PIXARLOGDATFMT pseudo-tag.
*/
@ -1202,26 +1256,26 @@ PixarLogCleanup(TIFF* tif)
}
static int
PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap)
PixarLogVSetField(TIFF* tif, uint32 tag, va_list ap)
{
static const char module[] = "PixarLogVSetField";
PixarLogState *sp = (PixarLogState *)tif->tif_data;
int result;
static const char module[] = "PixarLogVSetField";
switch (tag) {
case TIFFTAG_PIXARLOGQUALITY:
sp->quality = va_arg(ap, int);
sp->quality = (int) va_arg(ap, int);
if (tif->tif_mode != O_RDONLY && (sp->state&PLSTATE_INIT)) {
if (deflateParams(&sp->stream,
sp->quality, Z_DEFAULT_STRATEGY) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
}
return (1);
case TIFFTAG_PIXARLOGDATAFMT:
sp->user_datafmt = va_arg(ap, int);
sp->user_datafmt = (int) va_arg(ap, int);
/* Tweak the TIFF header so that the rest of libtiff knows what
* size of data will be passed between app and library, and
* assume that the app knows what it is doing and is not
@ -1253,7 +1307,7 @@ PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap)
/*
* Must recalculate sizes should bits/sample change.
*/
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
tif->tif_scanlinesize = TIFFScanlineSize(tif);
result = 1; /* NB: pseudo tag */
break;
@ -1264,7 +1318,7 @@ PixarLogVSetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
PixarLogVGetField(TIFF* tif, ttag_t tag, va_list ap)
PixarLogVGetField(TIFF* tif, uint32 tag, va_list ap)
{
PixarLogState *sp = (PixarLogState *)tif->tif_data;
@ -1281,9 +1335,9 @@ PixarLogVGetField(TIFF* tif, ttag_t tag, va_list ap)
return (1);
}
static const TIFFFieldInfo pixarlogFieldInfo[] = {
{TIFFTAG_PIXARLOGDATAFMT,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""},
{TIFFTAG_PIXARLOGQUALITY,0,0,TIFF_ANY, FIELD_PSEUDO,FALSE,FALSE,""}
static const TIFFField pixarlogFields[] = {
{TIFFTAG_PIXARLOGDATAFMT, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL},
{TIFFTAG_PIXARLOGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL}
};
int
@ -1298,8 +1352,8 @@ TIFFInitPixarLog(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, pixarlogFieldInfo,
TIFFArrayCount(pixarlogFieldInfo))) {
if (!_TIFFMergeFields(tif, pixarlogFields,
TIFFArrayCount(pixarlogFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging PixarLog codec-specific tags failed");
return 0;
@ -1308,7 +1362,7 @@ TIFFInitPixarLog(TIFF* tif, int scheme)
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (PixarLogState));
tif->tif_data = (uint8*) _TIFFmalloc(sizeof (PixarLogState));
if (tif->tif_data == NULL)
goto bad;
sp = (PixarLogState*) tif->tif_data;
@ -1319,17 +1373,18 @@ TIFFInitPixarLog(TIFF* tif, int scheme)
/*
* Install codec methods.
*/
tif->tif_fixuptags = PixarLogFixupTags;
tif->tif_setupdecode = PixarLogSetupDecode;
tif->tif_predecode = PixarLogPreDecode;
tif->tif_decoderow = PixarLogDecode;
tif->tif_decodestrip = PixarLogDecode;
tif->tif_decodestrip = PixarLogDecode;
tif->tif_decodetile = PixarLogDecode;
tif->tif_setupencode = PixarLogSetupEncode;
tif->tif_preencode = PixarLogPreEncode;
tif->tif_postencode = PixarLogPostEncode;
tif->tif_encoderow = PixarLogEncode;
tif->tif_encoderow = PixarLogEncode;
tif->tif_encodestrip = PixarLogEncode;
tif->tif_encodetile = PixarLogEncode;
tif->tif_encodetile = PixarLogEncode;
tif->tif_close = PixarLogClose;
tif->tif_cleanup = PixarLogCleanup;

234
3rdparty/libtiff/tif_predict.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_predict.c,v 1.11.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_predict.c,v 1.32 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -34,20 +34,20 @@
#define PredictorState(tif) ((TIFFPredictorState*) (tif)->tif_data)
static void horAcc8(TIFF*, tidata_t, tsize_t);
static void horAcc16(TIFF*, tidata_t, tsize_t);
static void horAcc32(TIFF*, tidata_t, tsize_t);
static void swabHorAcc16(TIFF*, tidata_t, tsize_t);
static void swabHorAcc32(TIFF*, tidata_t, tsize_t);
static void horDiff8(TIFF*, tidata_t, tsize_t);
static void horDiff16(TIFF*, tidata_t, tsize_t);
static void horDiff32(TIFF*, tidata_t, tsize_t);
static void fpAcc(TIFF*, tidata_t, tsize_t);
static void fpDiff(TIFF*, tidata_t, tsize_t);
static int PredictorDecodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorDecodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorEncodeRow(TIFF*, tidata_t, tsize_t, tsample_t);
static int PredictorEncodeTile(TIFF*, tidata_t, tsize_t, tsample_t);
static void horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc);
static void horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc);
static void horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc);
static void swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc);
static void swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc);
static void horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc);
static void horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc);
static void horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc);
static void fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc);
static void fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc);
static int PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
static int PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s);
static int PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
static int PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s);
static int
PredictorSetup(TIFF* tif)
@ -66,23 +66,23 @@ PredictorSetup(TIFF* tif)
&& td->td_bitspersample != 16
&& td->td_bitspersample != 32) {
TIFFErrorExt(tif->tif_clientdata, module,
"Horizontal differencing \"Predictor\" not supported with %d-bit samples",
td->td_bitspersample);
"Horizontal differencing \"Predictor\" not supported with %d-bit samples",
td->td_bitspersample);
return 0;
}
break;
case PREDICTOR_FLOATINGPOINT:
if (td->td_sampleformat != SAMPLEFORMAT_IEEEFP) {
TIFFErrorExt(tif->tif_clientdata, module,
"Floating point \"Predictor\" not supported with %d data format",
td->td_sampleformat);
"Floating point \"Predictor\" not supported with %d data format",
td->td_sampleformat);
return 0;
}
break;
default:
TIFFErrorExt(tif->tif_clientdata, module,
"\"Predictor\" value %d not supported",
sp->predictor);
"\"Predictor\" value %d not supported",
sp->predictor);
return 0;
}
sp->stride = (td->td_planarconfig == PLANARCONFIG_CONTIG ?
@ -94,6 +94,8 @@ PredictorSetup(TIFF* tif)
sp->rowsize = TIFFTileRowSize(tif);
else
sp->rowsize = TIFFScanlineSize(tif);
if (sp->rowsize == 0)
return 0;
return 1;
}
@ -126,6 +128,7 @@ PredictorSetupDecode(TIFF* tif)
sp->decodetile = tif->tif_decodetile;
tif->tif_decodetile = PredictorDecodeTile;
}
/*
* If the data is horizontally differenced 16-bit data that
* requires byte-swapping, then it must be byte swapped before
@ -137,10 +140,10 @@ PredictorSetupDecode(TIFF* tif)
if (sp->decodepfunc == horAcc16) {
sp->decodepfunc = swabHorAcc16;
tif->tif_postdecode = _TIFFNoPostDecode;
} else if (sp->decodepfunc == horAcc32) {
} else if (sp->decodepfunc == horAcc32) {
sp->decodepfunc = swabHorAcc32;
tif->tif_postdecode = _TIFFNoPostDecode;
}
}
}
}
@ -205,7 +208,7 @@ PredictorSetupEncode(TIFF* tif)
tif->tif_encodetile = PredictorEncodeTile;
}
}
else if (sp->predictor == 3) {
sp->encodepfunc = fpDiff;
/*
@ -228,7 +231,7 @@ PredictorSetupEncode(TIFF* tif)
#define REPEAT4(n, op) \
switch (n) { \
default: { int i; for (i = n-4; i > 0; i--) { op; } } \
default: { tmsize_t i; for (i = n-4; i > 0; i--) { op; } } \
case 4: op; \
case 3: op; \
case 2: op; \
@ -237,13 +240,13 @@ PredictorSetupEncode(TIFF* tif)
}
static void
horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc)
horAcc8(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
char* cp = (char*) cp0;
assert((cc%stride)==0);
if (cc > stride) {
cc -= stride;
/*
* Pipeline the most common cases.
*/
@ -251,40 +254,49 @@ horAcc8(TIFF* tif, tidata_t cp0, tsize_t cc)
unsigned int cr = cp[0];
unsigned int cg = cp[1];
unsigned int cb = cp[2];
do {
cc -= 3, cp += 3;
cc -= 3;
cp += 3;
while (cc>0) {
cp[0] = (char) (cr += cp[0]);
cp[1] = (char) (cg += cp[1]);
cp[2] = (char) (cb += cp[2]);
} while ((int32) cc > 0);
cc -= 3;
cp += 3;
}
} else if (stride == 4) {
unsigned int cr = cp[0];
unsigned int cg = cp[1];
unsigned int cb = cp[2];
unsigned int ca = cp[3];
do {
cc -= 4, cp += 4;
cc -= 4;
cp += 4;
while (cc>0) {
cp[0] = (char) (cr += cp[0]);
cp[1] = (char) (cg += cp[1]);
cp[2] = (char) (cb += cp[2]);
cp[3] = (char) (ca += cp[3]);
} while ((int32) cc > 0);
cc -= 4;
cp += 4;
}
} else {
cc -= stride;
do {
REPEAT4(stride, cp[stride] =
(char) (cp[stride] + *cp); cp++)
cc -= stride;
} while ((int32) cc > 0);
} while (cc>0);
}
}
}
static void
swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
swabHorAcc16(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint16* wp = (uint16*) cp0;
tsize_t wc = cc / 2;
tmsize_t wc = cc / 2;
assert((cc%(2*stride))==0);
if (wc > stride) {
TIFFSwabArrayOfShort(wp, wc);
@ -292,32 +304,36 @@ swabHorAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
static void
horAcc16(TIFF* tif, tidata_t cp0, tsize_t cc)
horAcc16(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint16* wp = (uint16*) cp0;
tsize_t wc = cc / 2;
tmsize_t wc = cc / 2;
assert((cc%(2*stride))==0);
if (wc > stride) {
wc -= stride;
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
static void
swabHorAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
swabHorAcc32(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint32* wp = (uint32*) cp0;
tsize_t wc = cc / 4;
tmsize_t wc = cc / 4;
assert((cc%(4*stride))==0);
if (wc > stride) {
TIFFSwabArrayOfLong(wp, wc);
@ -325,23 +341,25 @@ swabHorAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
static void
horAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
horAcc32(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint32* wp = (uint32*) cp0;
tsize_t wc = cc / 4;
tmsize_t wc = cc / 4;
assert((cc%(4*stride))==0);
if (wc > stride) {
wc -= stride;
do {
REPEAT4(stride, wp[stride] += wp[0]; wp++)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
@ -349,15 +367,17 @@ horAcc32(TIFF* tif, tidata_t cp0, tsize_t cc)
* Floating point predictor accumulation routine.
*/
static void
fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc)
fpAcc(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint32 bps = tif->tif_dir.td_bitspersample / 8;
tsize_t wc = cc / bps;
tsize_t count = cc;
tmsize_t wc = cc / bps;
tmsize_t count = cc;
uint8 *cp = (uint8 *) cp0;
uint8 *tmp = (uint8 *)_TIFFmalloc(cc);
assert((cc%(bps*stride))==0);
if (!tmp)
return;
@ -371,12 +391,12 @@ fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc)
for (count = 0; count < wc; count++) {
uint32 byte;
for (byte = 0; byte < bps; byte++) {
#if WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
cp[bps * count + byte] = tmp[byte * wc + count];
#else
#else
cp[bps * count + byte] =
tmp[(bps - byte - 1) * wc + count];
#endif
#endif
}
}
_TIFFfree(tmp);
@ -386,13 +406,13 @@ fpAcc(TIFF* tif, tidata_t cp0, tsize_t cc)
* Decode a scanline and apply the predictor routine.
*/
static int
PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
PredictorDecodeRow(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s)
{
TIFFPredictorState *sp = PredictorState(tif);
assert(sp != NULL);
assert(sp->decoderow != NULL);
assert(sp->decodepfunc != NULL);
assert(sp->decodepfunc != NULL);
if ((*sp->decoderow)(tif, op0, occ0, s)) {
(*sp->decodepfunc)(tif, op0, occ0);
@ -409,7 +429,7 @@ PredictorDecodeRow(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
* strip/tile dimensions.
*/
static int
PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
PredictorDecodeTile(TIFF* tif, uint8* op0, tmsize_t occ0, uint16 s)
{
TIFFPredictorState *sp = PredictorState(tif);
@ -417,11 +437,12 @@ PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
assert(sp->decodetile != NULL);
if ((*sp->decodetile)(tif, op0, occ0, s)) {
tsize_t rowsize = sp->rowsize;
tmsize_t rowsize = sp->rowsize;
assert(rowsize > 0);
assert((occ0%rowsize)==0);
assert(sp->decodepfunc != NULL);
while ((long)occ0 > 0) {
(*sp->decodepfunc)(tif, op0, (tsize_t) rowsize);
while (occ0 > 0) {
(*sp->decodepfunc)(tif, op0, rowsize);
occ0 -= rowsize;
op0 += rowsize;
}
@ -431,12 +452,14 @@ PredictorDecodeTile(TIFF* tif, tidata_t op0, tsize_t occ0, tsample_t s)
}
static void
horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc)
horDiff8(TIFF* tif, uint8* cp0, tmsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
tmsize_t stride = sp->stride;
char* cp = (char*) cp0;
assert((cc%stride)==0);
if (cc > stride) {
cc -= stride;
/*
@ -452,7 +475,7 @@ horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc)
g1 = cp[4]; cp[4] = g1-g2; g2 = g1;
b1 = cp[5]; cp[5] = b1-b2; b2 = b1;
cp += 3;
} while ((int32)(cc -= 3) > 0);
} while ((cc -= 3) > 0);
} else if (stride == 4) {
int r1, g1, b1, a1;
int r2 = cp[0];
@ -465,23 +488,25 @@ horDiff8(TIFF* tif, tidata_t cp0, tsize_t cc)
b1 = cp[6]; cp[6] = b1-b2; b2 = b1;
a1 = cp[7]; cp[7] = a1-a2; a2 = a1;
cp += 4;
} while ((int32)(cc -= 4) > 0);
} while ((cc -= 4) > 0);
} else {
cp += cc - 1;
do {
REPEAT4(stride, cp[stride] -= cp[0]; cp--)
} while ((int32)(cc -= stride) > 0);
} while ((cc -= stride) > 0);
}
}
}
static void
horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc)
horDiff16(TIFF* tif, uint8* cp0, tmsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
tmsize_t stride = sp->stride;
int16 *wp = (int16*) cp0;
tsize_t wc = cc/2;
tmsize_t wc = cc/2;
assert((cc%(2*stride))==0);
if (wc > stride) {
wc -= stride;
@ -489,17 +514,19 @@ horDiff16(TIFF* tif, tidata_t cp0, tsize_t cc)
do {
REPEAT4(stride, wp[stride] -= wp[0]; wp--)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
static void
horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc)
horDiff32(TIFF* tif, uint8* cp0, tmsize_t cc)
{
TIFFPredictorState* sp = PredictorState(tif);
tsize_t stride = sp->stride;
tmsize_t stride = sp->stride;
int32 *wp = (int32*) cp0;
tsize_t wc = cc/4;
tmsize_t wc = cc/4;
assert((cc%(4*stride))==0);
if (wc > stride) {
wc -= stride;
@ -507,7 +534,7 @@ horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc)
do {
REPEAT4(stride, wp[stride] -= wp[0]; wp--)
wc -= stride;
} while ((int32) wc > 0);
} while (wc > 0);
}
}
@ -515,15 +542,17 @@ horDiff32(TIFF* tif, tidata_t cp0, tsize_t cc)
* Floating point predictor differencing routine.
*/
static void
fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc)
fpDiff(TIFF* tif, uint8* cp0, tmsize_t cc)
{
tsize_t stride = PredictorState(tif)->stride;
tmsize_t stride = PredictorState(tif)->stride;
uint32 bps = tif->tif_dir.td_bitspersample / 8;
tsize_t wc = cc / bps;
tsize_t count;
tmsize_t wc = cc / bps;
tmsize_t count;
uint8 *cp = (uint8 *) cp0;
uint8 *tmp = (uint8 *)_TIFFmalloc(cc);
assert((cc%(bps*stride))==0);
if (!tmp)
return;
@ -531,12 +560,12 @@ fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc)
for (count = 0; count < wc; count++) {
uint32 byte;
for (byte = 0; byte < bps; byte++) {
#if WORDS_BIGENDIAN
cp[byte * wc + count] = tmp[bps * count + byte];
#else
#if WORDS_BIGENDIAN
cp[byte * wc + count] = tmp[bps * count + byte];
#else
cp[(bps - byte - 1) * wc + count] =
tmp[bps * count + byte];
#endif
#endif
}
}
_TIFFfree(tmp);
@ -548,7 +577,7 @@ fpDiff(TIFF* tif, tidata_t cp0, tsize_t cc)
}
static int
PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
PredictorEncodeRow(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
TIFFPredictorState *sp = PredictorState(tif);
@ -562,12 +591,12 @@ PredictorEncodeRow(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
}
static int
PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
PredictorEncodeTile(TIFF* tif, uint8* bp0, tmsize_t cc0, uint16 s)
{
static const char module[] = "PredictorEncodeTile";
TIFFPredictorState *sp = PredictorState(tif);
uint8 *working_copy;
tsize_t cc = cc0, rowsize;
tmsize_t cc = cc0, rowsize;
unsigned char* bp;
int result_code;
@ -583,8 +612,8 @@ PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
if( working_copy == NULL )
{
TIFFErrorExt(tif->tif_clientdata, module,
"Out of memory allocating %d byte temp buffer.",
(int)cc0 );
"Out of memory allocating " TIFF_SSIZE_FORMAT " byte temp buffer.",
cc0 );
return 0;
}
memcpy( working_copy, bp0, cc0 );
@ -607,13 +636,12 @@ PredictorEncodeTile(TIFF* tif, tidata_t bp0, tsize_t cc0, tsample_t s)
#define FIELD_PREDICTOR (FIELD_CODEC+0) /* XXX */
static const TIFFFieldInfo predictFieldInfo[] = {
{ TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, FIELD_PREDICTOR,
FALSE, FALSE, "Predictor" },
static const TIFFField predictFields[] = {
{ TIFFTAG_PREDICTOR, 1, 1, TIFF_SHORT, 0, TIFF_SETGET_UINT16, TIFF_SETGET_UINT16, FIELD_PREDICTOR, FALSE, FALSE, "Predictor", NULL },
};
static int
PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
PredictorVSetField(TIFF* tif, uint32 tag, va_list ap)
{
TIFFPredictorState *sp = PredictorState(tif);
@ -622,7 +650,7 @@ PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
switch (tag) {
case TIFFTAG_PREDICTOR:
sp->predictor = (uint16) va_arg(ap, int);
sp->predictor = (uint16) va_arg(ap, uint16_vap);
TIFFSetFieldBit(tif, FIELD_PREDICTOR);
break;
default:
@ -633,7 +661,7 @@ PredictorVSetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
PredictorVGetField(TIFF* tif, ttag_t tag, va_list ap)
PredictorVGetField(TIFF* tif, uint32 tag, va_list ap)
{
TIFFPredictorState *sp = PredictorState(tif);
@ -659,9 +687,9 @@ PredictorPrintDir(TIFF* tif, FILE* fd, long flags)
if (TIFFFieldSet(tif,FIELD_PREDICTOR)) {
fprintf(fd, " Predictor: ");
switch (sp->predictor) {
case 1: fprintf(fd, "none "); break;
case 2: fprintf(fd, "horizontal differencing "); break;
case 3: fprintf(fd, "floating point predictor "); break;
case 1: fprintf(fd, "none "); break;
case 2: fprintf(fd, "horizontal differencing "); break;
case 3: fprintf(fd, "floating point predictor "); break;
}
fprintf(fd, "%u (0x%x)\n", sp->predictor, sp->predictor);
}
@ -679,10 +707,10 @@ TIFFPredictorInit(TIFF* tif)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, predictFieldInfo,
TIFFArrayCount(predictFieldInfo))) {
if (!_TIFFMergeFields(tif, predictFields,
TIFFArrayCount(predictFields))) {
TIFFErrorExt(tif->tif_clientdata, "TIFFPredictorInit",
"Merging Predictor codec-specific tags failed");
"Merging Predictor codec-specific tags failed");
return 0;
}
@ -694,7 +722,7 @@ TIFFPredictorInit(TIFF* tif)
PredictorVGetField;/* hook for predictor tag */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield =
PredictorVSetField;/* hook for predictor tag */
PredictorVSetField;/* hook for predictor tag */
sp->printdir = tif->tif_tagmethods.printdir;
tif->tif_tagmethods.printdir =
PredictorPrintDir; /* hook for predictor tag */

56
3rdparty/libtiff/tif_predict.h vendored
View File

@ -1,26 +1,26 @@
/* $Id: tif_predict.h,v 1.3.2.2 2010-06-08 18:50:42 bfriesen Exp $ */
/* $Id: tif_predict.h,v 1.8 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
* Copyright (c) 1995-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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
* 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.
*/
@ -36,32 +36,32 @@
* the predictor code can cast tif_data to find its state.
*/
typedef struct {
int predictor; /* predictor tag value */
int stride; /* sample stride over data */
tsize_t rowsize; /* tile/strip row size */
int predictor; /* predictor tag value */
tmsize_t stride; /* sample stride over data */
tmsize_t rowsize; /* tile/strip row size */
TIFFCodeMethod encoderow; /* parent codec encode/decode row */
TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod encodetile; /* parent codec encode/decode tile */
TIFFPostMethod encodepfunc; /* horizontal differencer */
TIFFCodeMethod decoderow; /* parent codec encode/decode row */
TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod decodetile; /* parent codec encode/decode tile */
TIFFPostMethod decodepfunc; /* horizontal accumulator */
TIFFCodeMethod encoderow; /* parent codec encode/decode row */
TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod encodetile; /* parent codec encode/decode tile */
TIFFPostMethod encodepfunc; /* horizontal differencer */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
TIFFBoolMethod setupdecode; /* super-class method */
TIFFBoolMethod setupencode; /* super-class method */
TIFFCodeMethod decoderow; /* parent codec encode/decode row */
TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod decodetile; /* parent codec encode/decode tile */
TIFFPostMethod decodepfunc; /* horizontal accumulator */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */
TIFFBoolMethod setupdecode; /* super-class method */
TIFFBoolMethod setupencode; /* super-class method */
} TIFFPredictorState;
#if defined(__cplusplus)
extern "C" {
#endif
extern int TIFFPredictorInit(TIFF*);
extern int TIFFPredictorCleanup(TIFF*);
extern int TIFFPredictorInit(TIFF*);
extern int TIFFPredictorCleanup(TIFF*);
#if defined(__cplusplus)
}
#endif

319
3rdparty/libtiff/tif_print.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_print.c,v 1.36.2.5 2010-07-06 14:05:30 dron Exp $ */
/* $Id: tif_print.c,v 1.54 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -31,7 +31,7 @@
*/
#include "tiffiop.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
static const char *photoNames[] = {
@ -61,7 +61,7 @@ static const char *orientNames[] = {
#define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0]))
static void
_TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip,
_TIFFPrintField(FILE* fd, const TIFFField *fip,
uint32 value_count, void *raw_data)
{
uint32 j;
@ -73,7 +73,7 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip,
fprintf(fd, "%u", ((uint8 *) raw_data)[j]);
else if(fip->field_type == TIFF_UNDEFINED)
fprintf(fd, "0x%x",
(unsigned int) ((unsigned char *) raw_data)[j]);
(unsigned int) ((unsigned char *) raw_data)[j]);
else if(fip->field_type == TIFF_SBYTE)
fprintf(fd, "%d", ((int8 *) raw_data)[j]);
else if(fip->field_type == TIFF_SHORT)
@ -82,23 +82,46 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip,
fprintf(fd, "%d", ((int16 *) raw_data)[j]);
else if(fip->field_type == TIFF_LONG)
fprintf(fd, "%lu",
(unsigned long)((uint32 *) raw_data)[j]);
(unsigned long)((uint32 *) raw_data)[j]);
else if(fip->field_type == TIFF_SLONG)
fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]);
else if(fip->field_type == TIFF_IFD)
fprintf(fd, "0x%lx",
(unsigned long)((uint32 *) raw_data)[j]);
else if(fip->field_type == TIFF_RATIONAL
|| fip->field_type == TIFF_SRATIONAL
|| fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *) raw_data)[j]);
else if(fip->field_type == TIFF_IFD)
fprintf(fd, "0x%ulx", ((uint32 *) raw_data)[j]);
else if(fip->field_type == TIFF_LONG8)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "%I64u",
(unsigned __int64)((uint64 *) raw_data)[j]);
#else
fprintf(fd, "%llu",
(unsigned long long)((uint64 *) raw_data)[j]);
#endif
else if(fip->field_type == TIFF_SLONG8)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "%I64d", (__int64)((int64 *) raw_data)[j]);
#else
fprintf(fd, "%lld", (long long)((int64 *) raw_data)[j]);
#endif
else if(fip->field_type == TIFF_IFD8)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "0x%I64x",
(unsigned __int64)((uint64 *) raw_data)[j]);
#else
fprintf(fd, "0x%llx",
(unsigned long long)((uint64 *) raw_data)[j]);
#endif
else if(fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *)raw_data)[j]);
else if(fip->field_type == TIFF_DOUBLE)
fprintf(fd, "%f", ((double *) raw_data)[j]);
else if(fip->field_type == TIFF_ASCII) {
fprintf(fd, "%s", (char *) raw_data);
break;
}
else if(fip->field_type == TIFF_DOUBLE)
fprintf(fd, "%f", ((double *) raw_data)[j]);
else if(fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *)raw_data)[j]);
else {
fprintf(fd, "<unsupported data type in TIFFPrint>");
break;
@ -112,9 +135,11 @@ _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip,
}
static int
_TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
_TIFFPrettyPrintField(TIFF* tif, FILE* fd, uint32 tag,
uint32 value_count, void *raw_data)
{
(void) tif;
switch (tag)
{
case TIFFTAG_INKSET:
@ -125,29 +150,23 @@ _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
break;
default:
fprintf(fd, "%u (0x%x)\n",
*((uint16*)raw_data),
*((uint16*)raw_data));
*((uint16*)raw_data),
*((uint16*)raw_data));
break;
}
return 1;
case TIFFTAG_DOTRANGE:
fprintf(fd, " Dot Range: %u-%u\n",
((uint16*)raw_data)[0], ((uint16*)raw_data)[1]);
return 1;
case TIFFTAG_WHITEPOINT:
fprintf(fd, " White Point: %g-%g\n",
((float *)raw_data)[0], ((float *)raw_data)[1]); return 1;
case TIFFTAG_REFERENCEBLACKWHITE:
{
uint16 i;
fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < 3; i++)
fprintf(fd, " %2d: %5g %5g\n", i,
((float *)raw_data)[2*i+0],
((float *)raw_data)[2*i+1]);
((float *)raw_data)[0], ((float *)raw_data)[1]);
return 1;
}
case TIFFTAG_XMLPACKET:
{
uint32 i;
fprintf(fd, " XMLPacket (XMP Metadata):\n" );
for(i = 0; i < value_count; i++)
fputc(((char *)raw_data)[i], fd);
@ -160,23 +179,23 @@ _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
* defined as array of LONG values.
*/
fprintf(fd,
" RichTIFFIPTC Data: <present>, %lu bytes\n",
(unsigned long) value_count * 4);
" RichTIFFIPTC Data: <present>, %lu bytes\n",
(unsigned long) value_count * 4);
return 1;
case TIFFTAG_PHOTOSHOP:
fprintf(fd, " Photoshop Data: <present>, %lu bytes\n",
(unsigned long) value_count);
(unsigned long) value_count);
return 1;
case TIFFTAG_ICCPROFILE:
fprintf(fd, " ICC Profile: <present>, %lu bytes\n",
(unsigned long) value_count);
(unsigned long) value_count);
return 1;
case TIFFTAG_STONITS:
fprintf(fd,
" Sample to Nits conversion factor: %.4e\n",
*((double*)raw_data));
" Sample to Nits conversion factor: %.4e\n",
*((double*)raw_data));
return 1;
}
}
return 0;
}
@ -193,8 +212,15 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
uint16 i;
long l, n;
fprintf(fd, "TIFF Directory at offset 0x%lx (%lu)\n",
(unsigned long)tif->tif_diroff, (unsigned long)tif->tif_diroff);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "TIFF Directory at offset 0x%I64x (%I64u)\n",
(unsigned __int64) tif->tif_diroff,
(unsigned __int64) tif->tif_diroff);
#else
fprintf(fd, "TIFF Directory at offset 0x%llx (%llu)\n",
(unsigned long long) tif->tif_diroff,
(unsigned long long) tif->tif_diroff);
#endif
if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
fprintf(fd, " Subfile Type:");
sep = " ";
@ -380,18 +406,9 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
}
if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
{
/*
* For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling),
* we need to fetch this rather than trust what is in our
* structures.
*/
uint16 subsampling[2];
TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
subsampling + 0, subsampling + 1 );
fprintf(fd, " YCbCr Subsampling: %u, %u\n",
subsampling[0], subsampling[1] );
}
td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1] );
}
if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
fprintf(fd, " YCbCr Positioning: ");
switch (td->td_ycbcrpositioning) {
@ -431,12 +448,18 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue);
if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
fprintf(fd, " SMin Sample Value: %g\n",
td->td_sminsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
fprintf(fd, " SMax Sample Value: %g\n",
td->td_smaxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) {
fprintf(fd, " SMin Sample Value:");
for (i = 0; i < td->td_samplesperpixel; ++i)
fprintf(fd, " %g", td->td_sminsamplevalue[i]);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) {
fprintf(fd, " SMax Sample Value:");
for (i = 0; i < td->td_samplesperpixel; ++i)
fprintf(fd, " %g", td->td_smaxsamplevalue[i]);
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
fprintf(fd, " Planar Configuration: ");
switch (td->td_planarconfig) {
@ -469,6 +492,13 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
} else
fprintf(fd, "(present)\n");
}
if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) {
fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < 3; i++)
fprintf(fd, " %2d: %5g %5g\n", i,
td->td_refblackwhite[2*i+0],
td->td_refblackwhite[2*i+1]);
}
if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES) {
@ -488,117 +518,130 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) {
fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++)
fprintf(fd, " %5lu", (long) td->td_subifd[i]);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, " %5I64u",
(unsigned __int64) td->td_subifd[i]);
#else
fprintf(fd, " %5llu",
(unsigned long long) td->td_subifd[i]);
#endif
fputc('\n', fd);
}
/*
** Custom tag support.
*/
{
int i;
short count;
/*
** Custom tag support.
*/
{
int i;
short count;
count = (short) TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) {
ttag_t tag = TIFFGetTagListEntry(tif, i);
const TIFFFieldInfo *fip;
uint32 value_count;
int mem_alloc = 0;
void *raw_data;
count = (short) TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) {
uint32 tag = TIFFGetTagListEntry(tif, i);
const TIFFField *fip;
uint32 value_count;
int mem_alloc = 0;
void *raw_data;
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL)
continue;
if(fip->field_passcount) {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
fip = TIFFFieldWithTag(tif, tag);
if(fip == NULL)
continue;
} else {
if (fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2)
value_count = 1;
else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel;
else
value_count = fip->field_readcount;
if ((fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1)
&& fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
if(TIFFGetField(tif, tag, &raw_data) != 1)
if(fip->field_passcount) {
if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
continue;
} else if (fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1) {
_TIFFfree(raw_data);
continue;
}
} else {
/*
* XXX: Should be fixed and removed, see the
* notes related to TIFFTAG_PAGENUMBER,
* TIFFTAG_HALFTONEHINTS,
* TIFFTAG_YCBCRSUBSAMPLING and
* TIFFTAG_DOTRANGE tags in tif_dir.c. */
char *tmp;
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
tmp = raw_data;
mem_alloc = 1;
if(TIFFGetField(tif, tag, tmp,
tmp + _TIFFDataSize(fip->field_type)) != 1) {
_TIFFfree(raw_data);
continue;
if (fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2)
value_count = 1;
else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel;
else
value_count = fip->field_readcount;
if ((fip->field_type == TIFF_ASCII
|| fip->field_readcount == TIFF_VARIABLE
|| fip->field_readcount == TIFF_VARIABLE2
|| fip->field_readcount == TIFF_SPP
|| value_count > 1)
&& fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
if(TIFFGetField(tif, tag, &raw_data) != 1)
continue;
} else if (fip->field_tag != TIFFTAG_PAGENUMBER
&& fip->field_tag != TIFFTAG_HALFTONEHINTS
&& fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
&& fip->field_tag != TIFFTAG_DOTRANGE) {
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1) {
_TIFFfree(raw_data);
continue;
}
} else {
/*
* XXX: Should be fixed and removed,
* see the notes related to
* TIFFTAG_PAGENUMBER,
* TIFFTAG_HALFTONEHINTS,
* TIFFTAG_YCBCRSUBSAMPLING and
* TIFFTAG_DOTRANGE tags in tif_dir.c.
*/
char *tmp;
raw_data = _TIFFmalloc(
_TIFFDataSize(fip->field_type)
* value_count);
tmp = raw_data;
mem_alloc = 1;
if(TIFFGetField(tif, tag, tmp,
tmp + _TIFFDataSize(fip->field_type)) != 1) {
_TIFFfree(raw_data);
continue;
}
}
}
}
/*
* Catch the tags which needs to be specially handled and
* pretty print them. If tag not handled in
* _TIFFPrettyPrintField() fall down and print it as any other
* tag.
*/
if (_TIFFPrettyPrintField(tif, fd, tag, value_count, raw_data)) {
/*
* Catch the tags which needs to be specially handled
* and pretty print them. If tag not handled in
* _TIFFPrettyPrintField() fall down and print it as
* any other tag.
*/
if (!_TIFFPrettyPrintField(tif, fd, tag, value_count, raw_data))
_TIFFPrintField(fd, fip, value_count, raw_data);
if(mem_alloc)
_TIFFfree(raw_data);
continue;
}
else
_TIFFPrintField(fd, fip, value_count, raw_data);
if(mem_alloc)
_TIFFfree(raw_data);
}
}
}
if (tif->tif_tagmethods.printdir)
(*tif->tif_tagmethods.printdir)(tif, fd, flags);
_TIFFFillStriles( tif );
if ((flags & TIFFPRINT_STRIPS) &&
TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
tstrip_t s;
uint32 s;
fprintf(fd, " %lu %s:\n",
(long) td->td_nstrips,
isTiled(tif) ? "Tiles" : "Strips");
for (s = 0; s < td->td_nstrips; s++)
fprintf(fd, " %3lu: [%8lu, %8lu]\n",
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, " %3lu: [%8I64u, %8I64u]\n",
(unsigned long) s,
(unsigned long) td->td_stripoffset[s],
(unsigned long) td->td_stripbytecount[s]);
(unsigned __int64) td->td_stripoffset[s],
(unsigned __int64) td->td_stripbytecount[s]);
#else
fprintf(fd, " %3lu: [%8llu, %8llu]\n",
(unsigned long) s,
(unsigned long long) td->td_stripoffset[s],
(unsigned long long) td->td_stripbytecount[s]);
#endif
}
}

810
3rdparty/libtiff/tif_read.c vendored
View File

File diff suppressed because it is too large Load Diff

302
3rdparty/libtiff/tif_stream.cxx vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_stream.cxx,v 1.6.2.1 2009-01-01 00:10:43 bfriesen Exp $ */
/* $Id: tif_stream.cxx,v 1.11 2010-12-11 23:12:29 faxguy Exp $ */
/*
* Copyright (c) 1988-1996 Sam Leffler
@ -34,76 +34,166 @@
using namespace std;
#endif
class tiffis_data
{
public:
/*
ISO C++ uses a 'std::streamsize' type to define counts. This makes
it similar to, (but perhaps not the same as) size_t.
istream *myIS;
long myStreamStartPos;
The std::ios::pos_type is used to represent stream positions as used
by tellg(), tellp(), seekg(), and seekp(). This makes it similar to
(but perhaps not the same as) 'off_t'. The std::ios::streampos type
is used for character streams, but is documented to not be an
integral type anymore, so it should *not* be assigned to an integral
type.
The std::ios::off_type is used to specify relative offsets needed by
the variants of seekg() and seekp() which accept a relative offset
argument.
Useful prototype knowledge:
Obtain read position
ios::pos_type basic_istream::tellg()
Set read position
basic_istream& basic_istream::seekg(ios::pos_type)
basic_istream& basic_istream::seekg(ios::off_type, ios_base::seekdir)
Read data
basic_istream& istream::read(char *str, streamsize count)
Number of characters read in last unformatted read
streamsize istream::gcount();
Obtain write position
ios::pos_type basic_ostream::tellp()
Set write position
basic_ostream& basic_ostream::seekp(ios::pos_type)
basic_ostream& basic_ostream::seekp(ios::off_type, ios_base::seekdir)
Write data
basic_ostream& ostream::write(const char *str, streamsize count)
*/
struct tiffis_data;
struct tiffos_data;
extern "C" {
static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
static uint64 _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
static uint64 _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
static uint64 _tiffosSizeProc(thandle_t fd);
static uint64 _tiffisSizeProc(thandle_t fd);
static int _tiffosCloseProc(thandle_t fd);
static int _tiffisCloseProc(thandle_t fd);
static int _tiffDummyMapProc(thandle_t , void** base, toff_t* size );
static void _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
static TIFF* _tiffStreamOpen(const char* name, const char* mode, void *fd);
struct tiffis_data
{
istream *stream;
ios::pos_type start_pos;
};
class tiffos_data
struct tiffos_data
{
public:
ostream *myOS;
long myStreamStartPos;
ostream *stream;
ios::pos_type start_pos;
};
static tsize_t
_tiffosReadProc(thandle_t, tdata_t, tsize_t)
static tmsize_t
_tiffosReadProc(thandle_t, void*, tmsize_t)
{
return 0;
}
static tsize_t
_tiffisReadProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size)
{
tiffis_data *data = (tiffis_data *)fd;
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
data->myIS->read((char *)buf, (int)size);
// Verify that type does not overflow.
streamsize request_size = size;
if (static_cast<tmsize_t>(request_size) != size)
return static_cast<tmsize_t>(-1);
return data->myIS->gcount();
data->stream->read((char *) buf, request_size);
return static_cast<tmsize_t>(data->stream->gcount());
}
static tsize_t
_tiffosWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size)
{
tiffos_data *data = (tiffos_data *)fd;
ostream *os = data->myOS;
int pos = os->tellp();
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
ostream *os = data->stream;
ios::pos_type pos = os->tellp();
os->write((const char *)buf, size);
// Verify that type does not overflow.
streamsize request_size = size;
if (static_cast<tmsize_t>(request_size) != size)
return static_cast<tmsize_t>(-1);
return ((int)os->tellp()) - pos;
os->write(reinterpret_cast<const char *>(buf), request_size);
return static_cast<tmsize_t>(os->tellp() - pos);
}
static tsize_t
_tiffisWriteProc(thandle_t, tdata_t, tsize_t)
static tmsize_t
_tiffisWriteProc(thandle_t, void*, tmsize_t)
{
return 0;
}
static toff_t
_tiffosSeekProc(thandle_t fd, toff_t off, int whence)
static uint64
_tiffosSeekProc(thandle_t fd, uint64 off, int whence)
{
tiffos_data *data = (tiffos_data *)fd;
ostream *os = data->myOS;
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
ostream *os = data->stream;
// if the stream has already failed, don't do anything
if( os->fail() )
return os->tellp();
return static_cast<uint64>(-1);
switch(whence) {
case SEEK_SET:
os->seekp(data->myStreamStartPos + off, ios::beg);
{
// Compute 64-bit offset
uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(new_offset);
if (static_cast<uint64>(offset) != new_offset)
return static_cast<uint64>(-1);
os->seekp(offset, ios::beg);
break;
}
case SEEK_CUR:
os->seekp(off, ios::cur);
break;
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
os->seekp(offset, ios::cur);
break;
}
case SEEK_END:
os->seekp(off, ios::end);
break;
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
os->seekp(offset, ios::end);
break;
}
}
// Attempt to workaround problems with seeking past the end of the
@ -116,14 +206,15 @@ _tiffosSeekProc(thandle_t fd, toff_t off, int whence)
#else
ios::iostate old_state;
#endif
toff_t origin=0;
ios::pos_type origin;
old_state = os->rdstate();
// reset the fail bit or else tellp() won't work below
os->clear(os->rdstate() & ~ios::failbit);
switch( whence ) {
case SEEK_SET:
origin = data->myStreamStartPos;
default:
origin = data->start_pos;
break;
case SEEK_CUR:
origin = os->tellp();
@ -137,80 +228,104 @@ _tiffosSeekProc(thandle_t fd, toff_t off, int whence)
os->clear(old_state);
// only do something if desired seek position is valid
if( origin + off > data->myStreamStartPos ) {
toff_t num_fill;
if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) {
uint64 num_fill;
// clear the fail bit
os->clear(os->rdstate() & ~ios::failbit);
// extend the stream to the expected size
os->seekp(0, ios::end);
num_fill = origin + off - (toff_t)os->tellp();
for( toff_t i = 0; i < num_fill; i++ )
num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
for( uint64 i = 0; i < num_fill; i++ )
os->put('\0');
// retry the seek
os->seekp(origin + off, ios::beg);
os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg);
}
}
return os->tellp();
return static_cast<uint64>(os->tellp());
}
static toff_t
_tiffisSeekProc(thandle_t fd, toff_t off, int whence)
static uint64
_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
{
tiffis_data *data = (tiffis_data *)fd;
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
switch(whence) {
case SEEK_SET:
data->myIS->seekg(data->myStreamStartPos + off, ios::beg);
break;
{
// Compute 64-bit offset
uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(new_offset);
if (static_cast<uint64>(offset) != new_offset)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::beg);
break;
}
case SEEK_CUR:
data->myIS->seekg(off, ios::cur);
break;
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::cur);
break;
}
case SEEK_END:
data->myIS->seekg(off, ios::end);
break;
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::end);
break;
}
}
return ((long)data->myIS->tellg()) - data->myStreamStartPos;
return (uint64) (data->stream->tellg() - data->start_pos);
}
static toff_t
static uint64
_tiffosSizeProc(thandle_t fd)
{
tiffos_data *data = (tiffos_data *)fd;
ostream *os = data->myOS;
toff_t pos = os->tellp();
toff_t len;
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
ostream *os = data->stream;
ios::pos_type pos = os->tellp();
ios::pos_type len;
os->seekp(0, ios::end);
len = os->tellp();
os->seekp(pos);
return len;
return (uint64) len;
}
static toff_t
static uint64
_tiffisSizeProc(thandle_t fd)
{
tiffis_data *data = (tiffis_data *)fd;
int pos = data->myIS->tellg();
int len;
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
ios::pos_type pos = data->stream->tellg();
ios::pos_type len;
data->myIS->seekg(0, ios::end);
len = data->myIS->tellg();
data->myIS->seekg(pos);
data->stream->seekg(0, ios::end);
len = data->stream->tellg();
data->stream->seekg(pos);
return len;
return (uint64) len;
}
static int
_tiffosCloseProc(thandle_t fd)
{
// Our stream was not allocated by us, so it shouldn't be closed by us.
delete (tiffos_data *)fd;
delete reinterpret_cast<tiffos_data *>(fd);
return 0;
}
@ -218,18 +333,18 @@ static int
_tiffisCloseProc(thandle_t fd)
{
// Our stream was not allocated by us, so it shouldn't be closed by us.
delete (tiffis_data *)fd;
delete reinterpret_cast<tiffis_data *>(fd);
return 0;
}
static int
_tiffDummyMapProc(thandle_t , tdata_t* , toff_t* )
_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
{
return (0);
}
static void
_tiffDummyUnmapProc(thandle_t , tdata_t , toff_t )
_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
{
}
@ -243,32 +358,40 @@ _tiffStreamOpen(const char* name, const char* mode, void *fd)
if( strchr(mode, 'w') ) {
tiffos_data *data = new tiffos_data;
data->myOS = (ostream *)fd;
data->myStreamStartPos = data->myOS->tellp();
data->stream = reinterpret_cast<ostream *>(fd);
data->start_pos = data->stream->tellp();
// Open for writing.
tif = TIFFClientOpen(name, mode,
(thandle_t) data,
_tiffosReadProc, _tiffosWriteProc,
_tiffosSeekProc, _tiffosCloseProc,
reinterpret_cast<thandle_t>(data),
_tiffosReadProc,
_tiffosWriteProc,
_tiffosSeekProc,
_tiffosCloseProc,
_tiffosSizeProc,
_tiffDummyMapProc, _tiffDummyUnmapProc);
_tiffDummyMapProc,
_tiffDummyUnmapProc);
} else {
tiffis_data *data = new tiffis_data;
data->myIS = (istream *)fd;
data->myStreamStartPos = data->myIS->tellg();
data->stream = reinterpret_cast<istream *>(fd);
data->start_pos = data->stream->tellg();
// Open for reading.
tif = TIFFClientOpen(name, mode,
(thandle_t) data,
_tiffisReadProc, _tiffisWriteProc,
_tiffisSeekProc, _tiffisCloseProc,
reinterpret_cast<thandle_t>(data),
_tiffisReadProc,
_tiffisWriteProc,
_tiffisSeekProc,
_tiffisCloseProc,
_tiffisSizeProc,
_tiffDummyMapProc, _tiffDummyUnmapProc);
_tiffDummyMapProc,
_tiffDummyUnmapProc);
}
return (tif);
}
} /* extern "C" */
TIFF*
TIFFStreamOpen(const char* name, ostream *os)
{
@ -276,7 +399,7 @@ TIFFStreamOpen(const char* name, ostream *os)
// written to it yet, then tellp() will return -1 which will break us.
// We workaround this by writing out a dummy character and
// then seek back to the beginning.
if( !os->fail() && (int)os->tellp() < 0 ) {
if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) {
*os << '\0';
os->seekp(0);
}
@ -293,3 +416,10 @@ TIFFStreamOpen(const char* name, istream *is)
}
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
Local Variables:
mode: c
indent-tabs-mode: true
c-basic-offset: 8
End:
*/

419
3rdparty/libtiff/tif_strip.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_strip.c,v 1.19.2.3 2010-12-15 00:50:30 faxguy Exp $ */
/* $Id: tif_strip.c,v 1.34 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@ -31,54 +31,25 @@
*/
#include "tiffiop.h"
static uint32
summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where)
{
/*
* XXX: We are using casting to uint32 here, bacause sizeof(size_t)
* may be larger than sizeof(uint32) on 64-bit architectures.
*/
uint32 bytes = summand1 + summand2;
if (bytes - summand1 != summand2) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
static uint32
multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where)
{
uint32 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
/*
* Compute which strip a (row,sample) value is in.
*/
tstrip_t
TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample)
uint32
TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample)
{
static const char module[] = "TIFFComputeStrip";
TIFFDirectory *td = &tif->tif_dir;
tstrip_t strip;
uint32 strip;
strip = row / td->td_rowsperstrip;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
if (sample >= td->td_samplesperpixel) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, module,
"%lu: Sample out of range, max %lu",
(unsigned long) sample, (unsigned long) td->td_samplesperpixel);
return ((tstrip_t) 0);
return (0);
}
strip += sample*td->td_stripsperimage;
strip += (uint32)sample*td->td_stripsperimage;
}
return (strip);
}
@ -86,33 +57,34 @@ TIFFComputeStrip(TIFF* tif, uint32 row, tsample_t sample)
/*
* Compute how many strips are in an image.
*/
tstrip_t
uint32
TIFFNumberOfStrips(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tstrip_t nstrips;
uint32 nstrips;
nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 :
TIFFhowmany(td->td_imagelength, td->td_rowsperstrip));
TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
nstrips = multiply(tif, nstrips, td->td_samplesperpixel,
"TIFFNumberOfStrips");
nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel,
"TIFFNumberOfStrips");
return (nstrips);
}
/*
* Compute the # bytes in a variable height, row-aligned strip.
*/
tsize_t
TIFFVStripSize(TIFF* tif, uint32 nrows)
uint64
TIFFVStripSize64(TIFF* tif, uint32 nrows)
{
static const char module[] = "TIFFVStripSize64";
TIFFDirectory *td = &tif->tif_dir;
if (nrows == (uint32) -1)
nrows = td->td_imagelength;
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_photometric == PHOTOMETRIC_YCBCR &&
!isUpSampled(tif)) {
if (nrows==(uint32)(-1))
nrows=td->td_imagelength;
if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
(td->td_photometric == PHOTOMETRIC_YCBCR)&&
(!isUpSampled(tif)))
{
/*
* Packed YCbCr data contain one Cb+Cr for every
* HorizontalSampling*VerticalSampling Y values.
@ -122,53 +94,100 @@ TIFFVStripSize(TIFF* tif, uint32 nrows)
* YCbCr data for the extended image.
*/
uint16 ycbcrsubsampling[2];
tsize_t w, scanline, samplingarea;
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0,
ycbcrsubsampling + 1);
samplingarea = ycbcrsubsampling[0]*ycbcrsubsampling[1];
if (samplingarea == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Invalid YCbCr subsampling");
uint16 samplingblock_samples;
uint32 samplingblocks_hor;
uint32 samplingblocks_ver;
uint64 samplingrow_samples;
uint64 samplingrow_size;
if(td->td_samplesperpixel!=3)
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid td_samplesperpixel value");
return 0;
}
w = TIFFroundup(td->td_imagewidth, ycbcrsubsampling[0]);
scanline = TIFFhowmany8(multiply(tif, w, td->td_bitspersample,
"TIFFVStripSize"));
nrows = TIFFroundup(nrows, ycbcrsubsampling[1]);
/* NB: don't need TIFFhowmany here 'cuz everything is rounded */
scanline = multiply(tif, nrows, scanline, "TIFFVStripSize");
return ((tsize_t)
summarize(tif, scanline,
multiply(tif, 2, scanline / samplingarea,
"TIFFVStripSize"), "TIFFVStripSize"));
} else
return ((tsize_t) multiply(tif, nrows, TIFFScanlineSize(tif),
"TIFFVStripSize"));
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
ycbcrsubsampling+1);
if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid YCbCr subsampling");
return 0;
}
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
}
else
return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module));
}
tmsize_t
TIFFVStripSize(TIFF* tif, uint32 nrows)
{
static const char module[] = "TIFFVStripSize";
uint64 m;
tmsize_t n;
m=TIFFVStripSize64(tif,nrows);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
return(n);
}
/*
* Compute the # bytes in a raw strip.
*/
tsize_t
TIFFRawStripSize(TIFF* tif, tstrip_t strip)
uint64
TIFFRawStripSize64(TIFF* tif, uint32 strip)
{
static const char module[] = "TIFFRawStripSize64";
TIFFDirectory* td = &tif->tif_dir;
tsize_t bytecount = td->td_stripbytecount[strip];
uint64 bytecount = td->td_stripbytecount[strip];
if (bytecount <= 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"%lu: Invalid strip byte count, strip %lu",
(unsigned long) bytecount, (unsigned long) strip);
bytecount = (tsize_t) -1;
if (bytecount == 0)
{
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"%I64u: Invalid strip byte count, strip %lu",
(unsigned __int64) bytecount,
(unsigned long) strip);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"%llu: Invalid strip byte count, strip %lu",
(unsigned long long) bytecount,
(unsigned long) strip);
#endif
bytecount = (uint64) -1;
}
return bytecount;
}
tmsize_t
TIFFRawStripSize(TIFF* tif, uint32 strip)
{
static const char module[] = "TIFFRawStripSize";
uint64 m;
tmsize_t n;
m=TIFFRawStripSize64(tif,strip);
if (m==(uint64)(-1))
n=(tmsize_t)(-1);
else
{
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
}
return(n);
}
/*
* Compute the # bytes in a (row-aligned) strip.
@ -178,14 +197,29 @@ TIFFRawStripSize(TIFF* tif, tstrip_t strip)
* truncated to reflect the actual space required
* to hold the strip.
*/
tsize_t
TIFFStripSize(TIFF* tif)
uint64
TIFFStripSize64(TIFF* tif)
{
TIFFDirectory* td = &tif->tif_dir;
uint32 rps = td->td_rowsperstrip;
if (rps > td->td_imagelength)
rps = td->td_imagelength;
return (TIFFVStripSize(tif, rps));
return (TIFFVStripSize64(tif, rps));
}
tmsize_t
TIFFStripSize(TIFF* tif)
{
static const char module[] = "TIFFStripSize";
uint64 m;
tmsize_t n;
m=TIFFStripSize64(tif);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
return(n);
}
/*
@ -209,78 +243,21 @@ _TIFFDefaultStripSize(TIFF* tif, uint32 s)
* image up into strips that are approximately
* STRIP_SIZE_DEFAULT bytes long.
*/
tsize_t scanline = TIFFScanlineSize(tif);
s = (uint32)STRIP_SIZE_DEFAULT / (scanline == 0 ? 1 : scanline);
if (s == 0) /* very wide images */
s = 1;
uint64 scanlinesize;
uint64 rows;
scanlinesize=TIFFScanlineSize64(tif);
if (scanlinesize==0)
scanlinesize=1;
rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize;
if (rows==0)
rows=1;
else if (rows>0xFFFFFFFF)
rows=0xFFFFFFFF;
s=(uint32)rows;
}
return (s);
}
/*
* Return the number of bytes to read/write in a call to
* one of the scanline-oriented i/o routines. Note that
* this number may be 1/samples-per-pixel if data is
* stored as separate planes.
*/
tsize_t
TIFFScanlineSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
if (td->td_photometric == PHOTOMETRIC_YCBCR
&& !isUpSampled(tif)) {
uint16 ycbcrsubsampling[2];
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0,
ycbcrsubsampling + 1);
if (ycbcrsubsampling[0]*ycbcrsubsampling[1] == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Invalid YCbCr subsampling");
return 0;
}
/* number of sample clumps per line */
scanline = TIFFhowmany(td->td_imagewidth,
ycbcrsubsampling[0]);
/* number of samples per line */
scanline = multiply(tif, scanline,
ycbcrsubsampling[0]*ycbcrsubsampling[1] + 2,
"TIFFScanlineSize");
} else {
scanline = multiply(tif, td->td_imagewidth,
td->td_samplesperpixel,
"TIFFScanlineSize");
}
} else
scanline = td->td_imagewidth;
return ((tsize_t) TIFFhowmany8(multiply(tif, scanline,
td->td_bitspersample,
"TIFFScanlineSize")));
}
/*
* Some stuff depends on this older version of TIFFScanlineSize
* TODO: resolve this
*/
tsize_t
TIFFOldScanlineSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
scanline = multiply (tif, td->td_bitspersample, td->td_imagewidth,
"TIFFScanlineSize");
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
scanline = multiply (tif, scanline, td->td_samplesperpixel,
"TIFFScanlineSize");
return ((tsize_t) TIFFhowmany8(scanline));
}
/*
* Return the number of bytes to read/write in a call to
* one of the scanline-oriented i/o routines. Note that
@ -290,46 +267,71 @@ TIFFOldScanlineSize(TIFF* tif)
* strip size divided by the strip height, i.e. the size of a pack of vertical
* subsampling lines divided by vertical subsampling. It should thus make
* sense when multiplied by a multiple of vertical subsampling.
* Some stuff depends on this newer version of TIFFScanlineSize
* TODO: resolve this
*/
tsize_t
TIFFNewScanlineSize(TIFF* tif)
uint64
TIFFScanlineSize64(TIFF* tif)
{
static const char module[] = "TIFFScanlineSize64";
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
if (td->td_photometric == PHOTOMETRIC_YCBCR
&& !isUpSampled(tif)) {
uint64 scanline_size;
if (td->td_planarconfig==PLANARCONFIG_CONTIG)
{
if ((td->td_photometric==PHOTOMETRIC_YCBCR)&&
(td->td_samplesperpixel==3)&&
(!isUpSampled(tif)))
{
uint16 ycbcrsubsampling[2];
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0,
ycbcrsubsampling + 1);
if (ycbcrsubsampling[0]*ycbcrsubsampling[1] == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Invalid YCbCr subsampling");
return 0;
uint16 samplingblock_samples;
uint32 samplingblocks_hor;
uint64 samplingrow_samples;
uint64 samplingrow_size;
if(td->td_samplesperpixel!=3)
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid td_samplesperpixel value");
return 0;
}
return((tsize_t) ((((td->td_imagewidth+ycbcrsubsampling[0]-1)
/ycbcrsubsampling[0])
*(ycbcrsubsampling[0]*ycbcrsubsampling[1]+2)
*td->td_bitspersample+7)
/8)/ycbcrsubsampling[1]);
} else {
scanline = multiply(tif, td->td_imagewidth,
td->td_samplesperpixel,
"TIFFScanlineSize");
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling+0,
ycbcrsubsampling+1);
if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid YCbCr subsampling");
return 0;
}
samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
}
} else
scanline = td->td_imagewidth;
return ((tsize_t) TIFFhowmany8(multiply(tif, scanline,
td->td_bitspersample,
"TIFFScanlineSize")));
else
{
uint64 scanline_samples;
scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
}
}
else
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8);
return(scanline_size);
}
tmsize_t
TIFFScanlineSize(TIFF* tif)
{
static const char module[] = "TIFFScanlineSize";
uint64 m;
tmsize_t n;
m=TIFFScanlineSize64(tif);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow");
n=0;
}
return(n);
}
/*
@ -338,22 +340,35 @@ TIFFNewScanlineSize(TIFF* tif)
* I/O size returned by TIFFScanlineSize which may be less
* if data is store as separate planes).
*/
tsize_t
uint64
TIFFRasterScanlineSize64(TIFF* tif)
{
static const char module[] = "TIFFRasterScanlineSize64";
TIFFDirectory *td = &tif->tif_dir;
uint64 scanline;
scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
return (TIFFhowmany8_64(scanline));
} else
return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
td->td_samplesperpixel, module));
}
tmsize_t
TIFFRasterScanlineSize(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t scanline;
scanline = multiply (tif, td->td_bitspersample, td->td_imagewidth,
"TIFFRasterScanlineSize");
if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
scanline = multiply (tif, scanline, td->td_samplesperpixel,
"TIFFRasterScanlineSize");
return ((tsize_t) TIFFhowmany8(scanline));
} else
return ((tsize_t) multiply (tif, TIFFhowmany8(scanline),
td->td_samplesperpixel,
"TIFFRasterScanlineSize"));
static const char module[] = "TIFFRasterScanlineSize";
uint64 m;
tmsize_t n;
m=TIFFRasterScanlineSize64(tif);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer arithmetic overflow");
n=0;
}
return(n);
}
/* vim: set ts=8 sts=8 sw=8 noet: */

114
3rdparty/libtiff/tif_swab.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_swab.c,v 1.4.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_swab.c,v 1.13 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -37,7 +37,7 @@ TIFFSwabShort(uint16* wp)
{
register unsigned char* cp = (unsigned char*) wp;
unsigned char t;
assert(sizeof(uint16)==2);
t = cp[1]; cp[1] = cp[0]; cp[0] = t;
}
#endif
@ -48,19 +48,33 @@ TIFFSwabLong(uint32* lp)
{
register unsigned char* cp = (unsigned char*) lp;
unsigned char t;
assert(sizeof(uint32)==4);
t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t = cp[2]; cp[2] = cp[1]; cp[1] = t;
}
#endif
#ifndef TIFFSwabLong8
void
TIFFSwabLong8(uint64* lp)
{
register unsigned char* cp = (unsigned char*) lp;
unsigned char t;
assert(sizeof(uint64)==8);
t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t;
}
#endif
#ifndef TIFFSwabArrayOfShort
void
TIFFSwabArrayOfShort(uint16* wp, register unsigned long n)
TIFFSwabArrayOfShort(register uint16* wp, tmsize_t n)
{
register unsigned char* cp;
register unsigned char t;
assert(sizeof(uint16)==2);
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char*) wp;
@ -72,7 +86,7 @@ TIFFSwabArrayOfShort(uint16* wp, register unsigned long n)
#ifndef TIFFSwabArrayOfTriples
void
TIFFSwabArrayOfTriples(uint8* tp, unsigned long n)
TIFFSwabArrayOfTriples(register uint8* tp, tmsize_t n)
{
unsigned char* cp;
unsigned char t;
@ -88,11 +102,11 @@ TIFFSwabArrayOfTriples(uint8* tp, unsigned long n)
#ifndef TIFFSwabArrayOfLong
void
TIFFSwabArrayOfLong(register uint32* lp, register unsigned long n)
TIFFSwabArrayOfLong(register uint32* lp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
assert(sizeof(uint32)==4);
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char *)lp;
@ -103,30 +117,84 @@ TIFFSwabArrayOfLong(register uint32* lp, register unsigned long n)
}
#endif
#ifndef TIFFSwabArrayOfLong8
void
TIFFSwabArrayOfLong8(register uint64* lp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
assert(sizeof(uint64)==8);
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char *)lp;
t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t;
lp++;
}
}
#endif
#ifndef TIFFSwabFloat
void
TIFFSwabFloat(float* fp)
{
register unsigned char* cp = (unsigned char*) fp;
unsigned char t;
assert(sizeof(float)==4);
t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t = cp[2]; cp[2] = cp[1]; cp[1] = t;
}
#endif
#ifndef TIFFSwabArrayOfFloat
void
TIFFSwabArrayOfFloat(register float* fp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
assert(sizeof(float)==4);
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char *)fp;
t = cp[3]; cp[3] = cp[0]; cp[0] = t;
t = cp[2]; cp[2] = cp[1]; cp[1] = t;
fp++;
}
}
#endif
#ifndef TIFFSwabDouble
void
TIFFSwabDouble(double *dp)
{
register uint32* lp = (uint32*) dp;
uint32 t;
TIFFSwabArrayOfLong(lp, 2);
t = lp[0]; lp[0] = lp[1]; lp[1] = t;
register unsigned char* cp = (unsigned char*) dp;
unsigned char t;
assert(sizeof(double)==8);
t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t;
}
#endif
#ifndef TIFFSwabArrayOfDouble
void
TIFFSwabArrayOfDouble(double* dp, register unsigned long n)
TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
{
register uint32* lp = (uint32*) dp;
register uint32 t;
TIFFSwabArrayOfLong(lp, n + n);
while (n-- > 0) {
t = lp[0]; lp[0] = lp[1]; lp[1] = t;
lp += 2;
}
register unsigned char *cp;
register unsigned char t;
assert(sizeof(double)==8);
/* XXX unroll loop some */
while (n-- > 0) {
cp = (unsigned char *)dp;
t = cp[7]; cp[7] = cp[0]; cp[0] = t;
t = cp[6]; cp[6] = cp[1]; cp[1] = t;
t = cp[5]; cp[5] = cp[2]; cp[2] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t;
dp++;
}
}
#endif
@ -215,7 +283,7 @@ TIFFGetBitRevTable(int reversed)
}
void
TIFFReverseBits(register unsigned char* cp, register unsigned long n)
TIFFReverseBits(uint8* cp, tmsize_t n)
{
for (; n > 8; n -= 8) {
cp[0] = TIFFBitRevTable[cp[0]];

58
3rdparty/libtiff/tif_thunder.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_thunder.c,v 1.5.2.2 2011-03-21 16:01:28 fwarmerdam Exp $ */
/* $Id: tif_thunder.c,v 1.12 2011-04-02 20:54:09 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -63,7 +63,7 @@ static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 };
if (npixels++ & 1) \
*op++ |= lastpixel; \
else \
op[0] = (tidataval_t) (lastpixel << 4); \
op[0] = (uint8) (lastpixel << 4); \
} \
}
@ -85,12 +85,13 @@ ThunderSetupDecode(TIFF* tif)
}
static int
ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels)
ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels)
{
static const char module[] = "ThunderDecode";
register unsigned char *bp;
register tsize_t cc;
register tmsize_t cc;
unsigned int lastpixel;
tsize_t npixels;
tmsize_t npixels;
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
@ -114,7 +115,7 @@ ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels)
npixels += n;
if (npixels < maxpixels) {
for (; n > 0; n -= 2)
*op++ = (tidataval_t) lastpixel;
*op++ = (uint8) lastpixel;
}
if (n == -1)
*--op &= 0xf0;
@ -139,41 +140,59 @@ ThunderDecode(TIFF* tif, tidata_t op, tsize_t maxpixels)
break;
}
}
tif->tif_rawcp = (tidata_t) bp;
tif->tif_rawcp = (uint8*) bp;
tif->tif_rawcc = cc;
if (npixels != maxpixels) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"ThunderDecode: %s data at scanline %ld (%lu != %lu)",
npixels < maxpixels ? "Not enough" : "Too much",
(long) tif->tif_row, (long) npixels, (long) maxpixels);
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"%s data at scanline %lu (%I64u != %I64u)",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row,
(unsigned __int64) npixels,
(unsigned __int64) maxpixels);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"%s data at scanline %lu (%llu != %llu)",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row,
(unsigned long long) npixels,
(unsigned long long) maxpixels);
#endif
return (0);
}
return (1);
return (1);
}
static int
ThunderDecodeRow(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{
tidata_t row = buf;
static const char module[] = "ThunderDecodeRow";
uint8* row = buf;
(void) s;
while ((long)occ > 0) {
if (occ % tif->tif_scanlinesize)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (0);
}
while (occ > 0) {
if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
return (0);
occ -= tif->tif_scanlinesize;
row += tif->tif_scanlinesize;
}
return (1);
return (1);
}
int
TIFFInitThunderScan(TIFF* tif, int scheme)
{
(void) scheme;
tif->tif_decoderow = ThunderDecodeRow;
tif->tif_decodestrip = ThunderDecodeRow;
tif->tif_setupdecode = ThunderSetupDecode;
tif->tif_decoderow = ThunderDecodeRow;
tif->tif_decodestrip = ThunderDecodeRow;
return (1);
}
#endif /* THUNDER_SUPPORT */
@ -186,4 +205,3 @@ TIFFInitThunderScan(TIFF* tif, int scheme)
* fill-column: 78
* End:
*/

196
3rdparty/libtiff/tif_tile.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_tile.c,v 1.12.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_tile.c,v 1.22 2010-07-01 15:33:28 dron Exp $ */
/*
* Copyright (c) 1991-1997 Sam Leffler
@ -31,47 +31,17 @@
*/
#include "tiffiop.h"
static uint32
summarize(TIFF* tif, size_t summand1, size_t summand2, const char* where)
{
/*
* XXX: We are using casting to uint32 here, because sizeof(size_t)
* may be larger than sizeof(uint32) on 64-bit architectures.
*/
uint32 bytes = summand1 + summand2;
if (bytes - summand1 != summand2) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
static uint32
multiply(TIFF* tif, size_t nmemb, size_t elem_size, const char* where)
{
uint32 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
/*
* Compute which tile an (x,y,z,s) value is in.
*/
ttile_t
TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
uint32
TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth;
uint32 dy = td->td_tilelength;
uint32 dz = td->td_tiledepth;
ttile_t tile = 1;
uint32 tile = 1;
if (td->td_imagedepth == 1)
z = 0;
@ -82,9 +52,9 @@ TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
if (dz == (uint32) -1)
dz = td->td_imagedepth;
if (dx != 0 && dy != 0 && dz != 0) {
uint32 xpt = TIFFhowmany(td->td_imagewidth, dx);
uint32 ypt = TIFFhowmany(td->td_imagelength, dy);
uint32 zpt = TIFFhowmany(td->td_imagedepth, dz);
uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx);
uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy);
uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz);
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
tile = (xpt*ypt*zpt)*s +
@ -102,7 +72,7 @@ TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
* against the image bounds.
*/
int
TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
{
TIFFDirectory *td = &tif->tif_dir;
@ -141,14 +111,14 @@ TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, tsample_t s)
/*
* Compute how many tiles are in an image.
*/
ttile_t
uint32
TIFFNumberOfTiles(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth;
uint32 dy = td->td_tilelength;
uint32 dz = td->td_tiledepth;
ttile_t ntiles;
uint32 ntiles;
if (dx == (uint32) -1)
dx = td->td_imagewidth;
@ -157,50 +127,66 @@ TIFFNumberOfTiles(TIFF* tif)
if (dz == (uint32) -1)
dz = td->td_imagedepth;
ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
multiply(tif, multiply(tif, TIFFhowmany(td->td_imagewidth, dx),
TIFFhowmany(td->td_imagelength, dy),
"TIFFNumberOfTiles"),
TIFFhowmany(td->td_imagedepth, dz), "TIFFNumberOfTiles");
_TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
TIFFhowmany_32(td->td_imagelength, dy),
"TIFFNumberOfTiles"),
TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
ntiles = multiply(tif, ntiles, td->td_samplesperpixel,
"TIFFNumberOfTiles");
ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
"TIFFNumberOfTiles");
return (ntiles);
}
/*
* Compute the # bytes in each row of a tile.
*/
tsize_t
TIFFTileRowSize(TIFF* tif)
uint64
TIFFTileRowSize64(TIFF* tif)
{
TIFFDirectory *td = &tif->tif_dir;
tsize_t rowsize;
uint64 rowsize;
if (td->td_tilelength == 0 || td->td_tilewidth == 0)
return ((tsize_t) 0);
rowsize = multiply(tif, td->td_bitspersample, td->td_tilewidth,
"TIFFTileRowSize");
return (0);
rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
"TIFFTileRowSize");
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
rowsize = multiply(tif, rowsize, td->td_samplesperpixel,
"TIFFTileRowSize");
return ((tsize_t) TIFFhowmany8(rowsize));
rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
"TIFFTileRowSize");
return (TIFFhowmany8_64(rowsize));
}
tmsize_t
TIFFTileRowSize(TIFF* tif)
{
static const char module[] = "TIFFTileRowSize";
uint64 m;
tmsize_t n;
m=TIFFTileRowSize64(tif);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
return(n);
}
/*
* Compute the # bytes in a variable length, row-aligned tile.
*/
tsize_t
TIFFVTileSize(TIFF* tif, uint32 nrows)
uint64
TIFFVTileSize64(TIFF* tif, uint32 nrows)
{
static const char module[] = "TIFFVTileSize64";
TIFFDirectory *td = &tif->tif_dir;
tsize_t tilesize;
if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
td->td_tiledepth == 0)
return ((tsize_t) 0);
if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_photometric == PHOTOMETRIC_YCBCR &&
!isUpSampled(tif)) {
return (0);
if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
(td->td_photometric==PHOTOMETRIC_YCBCR)&&
(td->td_samplesperpixel==3)&&
(!isUpSampled(tif)))
{
/*
* Packed YCbCr data contain one Cb+Cr for every
* HorizontalSampling*VerticalSampling Y values.
@ -209,38 +195,70 @@ TIFFVTileSize(TIFF* tif, uint32 nrows)
* horizontal/vertical subsampling area include
* YCbCr data for the extended image.
*/
tsize_t w =
TIFFroundup(td->td_tilewidth, td->td_ycbcrsubsampling[0]);
tsize_t rowsize =
TIFFhowmany8(multiply(tif, w, td->td_bitspersample,
"TIFFVTileSize"));
tsize_t samplingarea =
td->td_ycbcrsubsampling[0]*td->td_ycbcrsubsampling[1];
if (samplingarea == 0) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Invalid YCbCr subsampling");
uint16 ycbcrsubsampling[2];
uint16 samplingblock_samples;
uint32 samplingblocks_hor;
uint32 samplingblocks_ver;
uint64 samplingrow_samples;
uint64 samplingrow_size;
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
ycbcrsubsampling+1);
assert((ycbcrsubsampling[0]==1)||(ycbcrsubsampling[0]==2)||(ycbcrsubsampling[0]==4));
assert((ycbcrsubsampling[1]==1)||(ycbcrsubsampling[1]==2)||(ycbcrsubsampling[1]==4));
if (ycbcrsubsampling[0]*ycbcrsubsampling[1]==0)
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid YCbCr subsampling");
return 0;
}
nrows = TIFFroundup(nrows, td->td_ycbcrsubsampling[1]);
/* NB: don't need TIFFhowmany here 'cuz everything is rounded */
tilesize = multiply(tif, nrows, rowsize, "TIFFVTileSize");
tilesize = summarize(tif, tilesize,
multiply(tif, 2, tilesize / samplingarea,
"TIFFVTileSize"),
"TIFFVTileSize");
} else
tilesize = multiply(tif, nrows, TIFFTileRowSize(tif),
"TIFFVTileSize");
return ((tsize_t)
multiply(tif, tilesize, td->td_tiledepth, "TIFFVTileSize"));
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
}
else
return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
}
tmsize_t
TIFFVTileSize(TIFF* tif, uint32 nrows)
{
static const char module[] = "TIFFVTileSize";
uint64 m;
tmsize_t n;
m=TIFFVTileSize64(tif,nrows);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
return(n);
}
/*
* Compute the # bytes in a row-aligned tile.
*/
tsize_t
uint64
TIFFTileSize64(TIFF* tif)
{
return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
}
tmsize_t
TIFFTileSize(TIFF* tif)
{
return (TIFFVTileSize(tif, tif->tif_dir.td_tilelength));
static const char module[] = "TIFFTileSize";
uint64 m;
tmsize_t n;
m=TIFFTileSize64(tif);
n=(tmsize_t)m;
if ((uint64)n!=m)
{
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
n=0;
}
return(n);
}
/*
@ -265,9 +283,9 @@ _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
*th = 256;
/* roundup to a multiple of 16 per the spec */
if (*tw & 0xf)
*tw = TIFFroundup(*tw, 16);
*tw = TIFFroundup_32(*tw, 16);
if (*th & 0xf)
*th = TIFFroundup(*th, 16);
*th = TIFFroundup_32(*th, 16);
}
/* vim: set ts=8 sts=8 sw=8 noet: */

139
3rdparty/libtiff/tif_unix.c vendored
View File

@ -1,26 +1,26 @@
/* $Id: tif_unix.c,v 1.12.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_unix.c,v 1.22 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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
* 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.
*/
@ -28,18 +28,20 @@
* 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 <stdio.h>
#include <sys/stat.h>
#if defined HAVE_UNISTD_H || defined __linux__
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
@ -47,57 +49,77 @@
# include <fcntl.h>
#endif
#ifdef HAVE_IO_H
# include <io.h>
#endif
#include "tiffiop.h"
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
{
return ((tsize_t) read((int) (size_t)fd, buf, (size_t) size));
size_t size_io = (size_t) size;
if ((tmsize_t) size_io != size)
{
errno=EINVAL;
return (tmsize_t) -1;
}
return ((tmsize_t) read((int) fd, buf, size_io));
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
{
return ((tsize_t) write((int) (size_t)fd, buf, (size_t) size));
size_t size_io = (size_t) size;
if ((tmsize_t) size_io != size)
{
errno=EINVAL;
return (tmsize_t) -1;
}
return ((tmsize_t) write((int) fd, buf, size_io));
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
static uint64
_tiffSeekProc(thandle_t fd, uint64 off, int whence)
{
return ((toff_t) lseek((int) (size_t)fd, (off_t) off, whence));
off_t off_io = (off_t) off;
if ((uint64) off_io != off)
{
errno=EINVAL;
return (uint64) -1; /* this is really gross */
}
return((uint64)lseek((int)fd,off_io,whence));
}
static int
_tiffCloseProc(thandle_t fd)
{
return (close((int) (size_t)fd));
return(close((int)fd));
}
static toff_t
static uint64
_tiffSizeProc(thandle_t fd)
{
#ifdef _AM29K
long fsize;
return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
#else
struct stat sb;
return (toff_t) (fstat((int) (size_t)fd, &sb) < 0 ? 0 : sb.st_size);
#endif
if (fstat((int)fd,&sb)<0)
return(0);
else
return((uint64)sb.st_size);
}
#ifdef HAVE_MMAP
#include <sys/mman.h>
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
toff_t size = _tiffSizeProc(fd);
if (size != (toff_t) -1) {
*pbase = (tdata_t)
mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
if (*pbase != (tdata_t) -1) {
*psize = size;
uint64 size64 = _tiffSizeProc(fd);
tmsize_t sizem = (tmsize_t)size64;
if ((uint64)sizem==size64) {
*pbase = (void*)
mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, (int) fd, 0);
if (*pbase != (void*) -1) {
*psize = (tmsize_t)sizem;
return (1);
}
}
@ -105,21 +127,21 @@ _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
_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, tdata_t* pbase, toff_t* psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
(void) fd; (void) pbase; (void) psize;
return (0);
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
{
(void) fd; (void) base; (void) size;
}
@ -134,7 +156,7 @@ TIFFFdOpen(int fd, const char* name, const char* mode)
TIFF* tif;
tif = TIFFClientOpen(name, mode,
(thandle_t) (size_t)fd,
(thandle_t) fd,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
@ -151,22 +173,18 @@ TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int m, fd;
TIFF* tif;
TIFF* tif;
m = _TIFFgetMode(mode, module);
if (m == -1)
return ((TIFF*)0);
/* for cygwin and mingw */
/* for cygwin and mingw */
#ifdef O_BINARY
m |= O_BINARY;
#endif
#ifdef _AM29K
fd = open(name, m);
#else
fd = open(name, m, 0666);
m |= O_BINARY;
#endif
fd = open(name, m, 0666);
if (fd < 0) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF *)0);
@ -196,11 +214,11 @@ TIFFOpenW(const wchar_t* name, const char* mode)
if (m == -1)
return ((TIFF*)0);
/* for cygwin and mingw */
/* for cygwin and mingw */
#ifdef O_BINARY
m |= O_BINARY;
#endif
m |= O_BINARY;
#endif
fd = _wopen(name, m, 0666);
if (fd < 0) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
@ -233,37 +251,37 @@ TIFFOpenW(const wchar_t* name, const char* mode)
#endif
void*
_TIFFmalloc(tsize_t s)
_TIFFmalloc(tmsize_t s)
{
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
_TIFFfree(void* p)
{
free(p);
}
void*
_TIFFrealloc(tdata_t p, tsize_t s)
_TIFFrealloc(void* p, tmsize_t s)
{
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(tdata_t p, int v, tsize_t c)
_TIFFmemset(void* p, int v, tmsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
@ -288,6 +306,9 @@ unixErrorHandler(const char* module, const char* fmt, va_list ap)
fprintf(stderr, ".\n");
}
TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c

2
3rdparty/libtiff/tif_version.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_version.c,v 1.2.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_version.c,v 1.3 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1992-1997 Sam Leffler
* Copyright (c) 1992-1997 Silicon Graphics, Inc.

2
3rdparty/libtiff/tif_warning.c vendored
View File

@ -1,4 +1,4 @@
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_warning.c,v 1.2.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Header: /cvs/maptools/cvsroot/libtiff/libtiff/tif_warning.c,v 1.3 2010-03-10 18:56:49 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler

254
3rdparty/libtiff/tif_win32.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_win32.c,v 1.21.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_win32.c,v 1.39 2011-12-22 17:07:57 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -32,49 +32,91 @@
#include <windows.h>
static tsize_t
_tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
{
DWORD dwSizeRead;
if (!ReadFile(fd, buf, size, &dwSizeRead, NULL))
return(0);
return ((tsize_t) dwSizeRead);
/* 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);
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
static tmsize_t
_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
{
DWORD dwSizeWritten;
if (!WriteFile(fd, buf, size, &dwSizeWritten, NULL))
return(0);
return ((tsize_t) dwSizeWritten);
/* 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);
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
static uint64
_tiffSeekProc(thandle_t fd, uint64 off, int whence)
{
ULARGE_INTEGER li;
LARGE_INTEGER offli;
DWORD dwMoveMethod;
li.QuadPart = off;
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;
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;
}
return ((toff_t)SetFilePointer(fd, (LONG) li.LowPart,
(PLONG)&li.HighPart, dwMoveMethod));
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);
}
static int
@ -83,14 +125,16 @@ _tiffCloseProc(thandle_t fd)
return (CloseHandle(fd) ? 0 : -1);
}
static toff_t
static uint64
_tiffSizeProc(thandle_t fd)
{
return ((toff_t)GetFileSize(fd, NULL));
ULARGE_INTEGER m;
m.LowPart=GetFileSize(fd,&m.HighPart);
return(m.QuadPart);
}
static int
_tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
(void) fd;
(void) pbase;
@ -110,14 +154,20 @@ _tiffDummyMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
* with Visual C++ 5.0
*/
static int
_tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
toff_t size;
uint64 size;
tmsize_t sizem;
HANDLE hMapFile;
if ((size = _tiffSizeProc(fd)) == 0xFFFFFFFF)
size = _tiffSizeProc(fd);
sizem = (tmsize_t)size;
if ((uint64)sizem!=size)
return (0);
hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, size, NULL);
/* 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);
@ -129,7 +179,7 @@ _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
}
static void
_tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
{
(void) fd;
(void) base;
@ -137,8 +187,10 @@ _tiffDummyUnmapProc(thandle_t fd, tdata_t base, toff_t size)
}
static void
_tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
{
(void) fd;
(void) size;
UnmapViewOfFile(base);
}
@ -151,8 +203,17 @@ TIFF*
TIFFFdOpen(int ifd, const char* name, const char* mode)
{
TIFF* tif;
BOOL fSuppressMap = (mode[1] == 'u' || (mode[1]!=0 && mode[2] == 'u'));
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,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
@ -179,26 +240,15 @@ TIFFOpen(const char* name, const char* mode)
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);
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,
@ -242,7 +292,7 @@ TIFFOpenW(const wchar_t* name, const char* mode)
fd = (thandle_t)CreateFileW(name,
(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE),
FILE_SHARE_READ, NULL, dwMode,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
NULL);
if (fd == INVALID_HANDLE_VALUE) {
@ -276,71 +326,48 @@ TIFFOpenW(const wchar_t* name, const char* mode)
#endif /* ndef _WIN32_WCE */
tdata_t
_TIFFmalloc(tsize_t s)
void*
_TIFFmalloc(tmsize_t s)
{
return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
return (malloc((size_t) s));
}
void
_TIFFfree(tdata_t p)
_TIFFfree(void* p)
{
GlobalFree(p);
return;
free(p);
}
tdata_t
_TIFFrealloc(tdata_t p, tsize_t s)
void*
_TIFFrealloc(void* p, tmsize_t s)
{
void* pvTmp;
tsize_t old;
if(p == NULL)
return ((tdata_t)GlobalAlloc(GMEM_FIXED, s));
old = GlobalSize(p);
if (old>=s) {
if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
CopyMemory(pvTmp, p, s);
GlobalFree(p);
}
} else {
if ((pvTmp = GlobalAlloc(GMEM_FIXED, s)) != NULL) {
CopyMemory(pvTmp, p, old);
GlobalFree(p);
}
}
return ((tdata_t)pvTmp);
return (realloc(p, (size_t) s));
}
void
_TIFFmemset(void* p, int v, tsize_t c)
_TIFFmemset(void* p, int v, tmsize_t c)
{
FillMemory(p, c, (BYTE)v);
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(void* d, const tdata_t s, tsize_t c)
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{
CopyMemory(d, s, c);
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{
register const BYTE *pb1 = (const BYTE *) p1;
register const BYTE *pb2 = (const BYTE *) p2;
register DWORD dwTmp = c;
register int iTmp;
for (iTmp = 0; dwTmp-- && !iTmp; iTmp = (int)*pb1++ - (int)*pb2++)
;
return (iTmp);
return (memcmp(p1, p2, (size_t) c));
}
#ifndef _WIN32_WCE
#if (_MSC_VER < 1500)
# define vsnprintf _vsnprintf
#endif
static void
Win32WarningHandler(const char* module, const char* fmt, va_list ap)
{
@ -350,14 +377,17 @@ Win32WarningHandler(const char* module, const char* fmt, va_list ap)
LPCTSTR szTitleText = "%s Warning";
LPCTSTR szDefaultModule = "LIBTIFF";
LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
SIZE_T nBufSize = (strlen(szTmpModule) +
strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char);
if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL)
return;
sprintf(szTitle, szTitleText, szTmpModule);
szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
vsprintf(szTmp, fmt, ap);
vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap);
MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONINFORMATION);
LocalFree(szTitle);
return;
#else
if (module != NULL)
@ -378,12 +408,14 @@ Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
LPCTSTR szTitleText = "%s Error";
LPCTSTR szDefaultModule = "LIBTIFF";
LPCTSTR szTmpModule = (module == NULL) ? szDefaultModule : module;
if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, (strlen(szTmpModule) +
strlen(szTitleText) + strlen(fmt) + 128)*sizeof(char))) == NULL)
SIZE_T nBufSize = (strlen(szTmpModule) +
strlen(szTitleText) + strlen(fmt) + 256)*sizeof(char);
if ((szTitle = (LPTSTR)LocalAlloc(LMEM_FIXED, nBufSize)) == NULL)
return;
sprintf(szTitle, szTitleText, szTmpModule);
szTmp = szTitle + (strlen(szTitle)+2)*sizeof(char);
vsprintf(szTmp, fmt, ap);
vsnprintf(szTmp, nBufSize-(strlen(szTitle)+2)*sizeof(char), fmt, ap);
MessageBoxA(GetFocus(), szTmp, szTitle, MB_OK | MB_ICONEXCLAMATION);
LocalFree(szTitle);
return;

287
3rdparty/libtiff/tif_write.c vendored
View File

@ -1,26 +1,26 @@
/* $Id: tif_write.c,v 1.22.2.5 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_write.c,v 1.36 2011-02-18 20:53:04 fwarmerdam Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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
* 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.
*/
@ -32,26 +32,26 @@
#include "tiffiop.h"
#include <stdio.h>
#define STRIPINCR 20 /* expansion factor on strip array */
#define STRIPINCR 20 /* expansion factor on strip array */
#define WRITECHECKSTRIPS(tif, module) \
#define WRITECHECKSTRIPS(tif, module) \
(((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module))
#define WRITECHECKTILES(tif, module) \
#define WRITECHECKTILES(tif, module) \
(((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module))
#define BUFFERCHECK(tif) \
#define BUFFERCHECK(tif) \
((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
TIFFWriteBufferSetup((tif), NULL, (tsize_t) -1))
TIFFWriteBufferSetup((tif), NULL, (tmsize_t) -1))
static int TIFFGrowStrips(TIFF*, int, const char*);
static int TIFFAppendToStrip(TIFF*, tstrip_t, tidata_t, tsize_t);
static int TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module);
static int TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc);
int
TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
{
static const char module[] = "TIFFWriteScanline";
register TIFFDirectory *td;
int status, imagegrew = 0;
tstrip_t strip;
uint32 strip;
if (!WRITECHECKSTRIPS(tif, module))
return (-1);
@ -62,6 +62,8 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
*/
if (!BUFFERCHECK(tif))
return (-1);
tif->tif_flags |= TIFF_BUF4WRITE; /* not strictly sure this is right*/
td = &tif->tif_dir;
/*
* Extend image length if needed
@ -69,8 +71,8 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
*/
if (row >= td->td_imagelength) { /* extend image */
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Can not change \"ImageLength\" when using separate planes");
TIFFErrorExt(tif->tif_clientdata, module,
"Can not change \"ImageLength\" when using separate planes");
return (-1);
}
td->td_imagelength = row+1;
@ -81,9 +83,9 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
*/
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
if (sample >= td->td_samplesperpixel) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"%d: Sample out of range, max %d",
sample, td->td_samplesperpixel);
TIFFErrorExt(tif->tif_clientdata, module,
"%lu: Sample out of range, max %lu",
(unsigned long) sample, (unsigned long) td->td_samplesperpixel);
return (-1);
}
strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
@ -112,7 +114,7 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
*/
if (strip >= td->td_stripsperimage && imagegrew)
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip);
tif->tif_row =
(strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
@ -161,10 +163,10 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
tif->tif_row = row;
}
/* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (tidata_t) buf, tif->tif_scanlinesize );
/* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) buf, tif->tif_scanlinesize );
status = (*tif->tif_encoderow)(tif, (tidata_t) buf,
status = (*tif->tif_encoderow)(tif, (uint8*) buf,
tif->tif_scanlinesize, sample);
/* we are now poised at the beginning of the next row */
@ -178,15 +180,15 @@ TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
*
* NB: Image length must be setup before writing.
*/
tsize_t
TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
tmsize_t
TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
{
static const char module[] = "TIFFWriteEncodedStrip";
TIFFDirectory *td = &tif->tif_dir;
tsample_t sample;
uint16 sample;
if (!WRITECHECKSTRIPS(tif, module))
return ((tsize_t) -1);
return ((tmsize_t) -1);
/*
* Check strip array to make sure there's space.
* We don't support dynamically growing files that
@ -198,14 +200,14 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
*/
if (strip >= td->td_nstrips) {
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Can not grow image by strips when using separate planes");
return ((tsize_t) -1);
TIFFErrorExt(tif->tif_clientdata, module,
"Can not grow image by strips when using separate planes");
return ((tmsize_t) -1);
}
if (!TIFFGrowStrips(tif, 1, module))
return ((tsize_t) -1);
return ((tmsize_t) -1);
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength, td->td_rowsperstrip);
TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip);
}
/*
* Handle delayed allocation of data buffer. This
@ -213,19 +215,22 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
* info.
*/
if (!BUFFERCHECK(tif))
return ((tsize_t) -1);
return ((tmsize_t) -1);
tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return ((tsize_t) -1);
return ((tmsize_t) -1);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
tif->tif_rawcp = tif->tif_rawdata;
if( td->td_stripbytecount[strip] > 0 )
if( td->td_stripbytecount[strip] > 0 )
{
/* Force TIFFAppendToStrip() to consider placing data at end
of file. */
@ -233,23 +238,23 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
}
tif->tif_flags &= ~TIFF_POSTENCODE;
sample = (tsample_t)(strip / td->td_stripsperimage);
sample = (uint16)(strip / td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample))
return ((tsize_t) -1);
return ((tmsize_t) -1);
/* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (tidata_t) data, cc );
tif->tif_postdecode( tif, (uint8*) data, cc );
if (!(*tif->tif_encodestrip)(tif, (tidata_t) data, cc, sample))
return ((tsize_t) 0);
if (!(*tif->tif_encodestrip)(tif, (uint8*) data, cc, sample))
return (0);
if (!(*tif->tif_postencode)(tif))
return ((tsize_t) -1);
return ((tmsize_t) -1);
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 &&
!TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc))
return ((tsize_t) -1);
return ((tmsize_t) -1);
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
return (cc);
@ -260,14 +265,14 @@ TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
*
* NB: Image length must be setup before writing.
*/
tsize_t
TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
tmsize_t
TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
{
static const char module[] = "TIFFWriteRawStrip";
TIFFDirectory *td = &tif->tif_dir;
if (!WRITECHECKSTRIPS(tif, module))
return ((tsize_t) -1);
return ((tmsize_t) -1);
/*
* Check strip array to make sure there's space.
* We don't support dynamically growing files that
@ -279,9 +284,9 @@ TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
*/
if (strip >= td->td_nstrips) {
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Can not grow image by strips when using separate planes");
return ((tsize_t) -1);
TIFFErrorExt(tif->tif_clientdata, module,
"Can not grow image by strips when using separate planes");
return ((tmsize_t) -1);
}
/*
* Watch out for a growing image. The value of
@ -290,26 +295,25 @@ TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
*/
if (strip >= td->td_stripsperimage)
td->td_stripsperimage =
TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip);
if (!TIFFGrowStrips(tif, 1, module))
return ((tsize_t) -1);
return ((tmsize_t) -1);
}
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
return (TIFFAppendToStrip(tif, strip, (tidata_t) data, cc) ?
cc : (tsize_t) -1);
return (TIFFAppendToStrip(tif, strip, (uint8*) data, cc) ?
cc : (tmsize_t) -1);
}
/*
* Write and compress a tile of data. The
* tile is selected by the (x,y,z,s) coordinates.
*/
tsize_t
TIFFWriteTile(TIFF* tif,
tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
tmsize_t
TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
{
if (!TIFFCheckTile(tif, x, y, z, s))
return (-1);
return ((tmsize_t)(-1));
/*
* NB: A tile size of -1 is used instead of tif_tilesize knowing
* that TIFFWriteEncodedTile will clamp this to the tile size.
@ -317,7 +321,7 @@ TIFFWriteTile(TIFF* tif,
* after the output buffer is setup in TIFFWriteBufferSetup.
*/
return (TIFFWriteEncodedTile(tif,
TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
}
/*
@ -332,20 +336,20 @@ TIFFWriteTile(TIFF* tif,
* interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does).
*/
tsize_t
TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
tmsize_t
TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
{
static const char module[] = "TIFFWriteEncodedTile";
TIFFDirectory *td;
tsample_t sample;
uint16 sample;
if (!WRITECHECKTILES(tif, module))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
td = &tif->tif_dir;
if (tile >= td->td_nstrips) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu",
tif->tif_name, (unsigned long) tile, (unsigned long) td->td_nstrips);
return ((tsize_t) -1);
TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
(unsigned long) tile, (unsigned long) td->td_nstrips);
return ((tmsize_t)(-1));
}
/*
* Handle delayed allocation of data buffer. This
@ -353,13 +357,15 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
* directory information).
*/
if (!BUFFERCHECK(tif))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curtile = tile;
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
if( td->td_stripbytecount[tile] > 0 )
if( td->td_stripbytecount[tile] > 0 )
{
/* Force TIFFAppendToStrip() to consider placing data at end
of file. */
@ -370,20 +376,20 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
* Compute tiles per row & per column to compute
* current row and column
*/
tif->tif_row = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength))
tif->tif_row = (tile % TIFFhowmany_32(td->td_imagelength, td->td_tilelength))
* td->td_tilelength;
tif->tif_col = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth))
tif->tif_col = (tile % TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth))
* td->td_tilewidth;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
if (!(*tif->tif_setupencode)(tif))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_flags &= ~TIFF_POSTENCODE;
sample = (tsample_t)(tile/td->td_stripsperimage);
sample = (uint16)(tile/td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
/*
* Clamp write amount to the tile size. This is mostly
* done so that callers can pass in some large number
@ -393,18 +399,18 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
cc = tif->tif_tilesize;
/* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (tidata_t) data, cc );
tif->tif_postdecode( tif, (uint8*) data, cc );
if (!(*tif->tif_encodetile)(tif, (tidata_t) data, cc, sample))
return ((tsize_t) 0);
if (!(*tif->tif_encodetile)(tif, (uint8*) data, cc, sample))
return (0);
if (!(*tif->tif_postencode)(tif))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((unsigned char *)tif->tif_rawdata, tif->tif_rawcc);
TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile,
tif->tif_rawdata, tif->tif_rawcc))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
return (cc);
@ -419,21 +425,21 @@ TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
* interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does).
*/
tsize_t
TIFFWriteRawTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
tmsize_t
TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
{
static const char module[] = "TIFFWriteRawTile";
if (!WRITECHECKTILES(tif, module))
return ((tsize_t) -1);
return ((tmsize_t)(-1));
if (tile >= tif->tif_dir.td_nstrips) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu",
tif->tif_name, (unsigned long) tile,
TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
(unsigned long) tile,
(unsigned long) tif->tif_dir.td_nstrips);
return ((tsize_t) -1);
return ((tmsize_t)(-1));
}
return (TIFFAppendToStrip(tif, tile, (tidata_t) data, cc) ?
cc : (tsize_t) -1);
return (TIFFAppendToStrip(tif, tile, (uint8*) data, cc) ?
cc : (tmsize_t)(-1));
}
#define isUnspecified(tif, f) \
@ -455,18 +461,18 @@ TIFFSetupStrips(TIFF* tif)
td->td_nstrips = td->td_stripsperimage;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
td->td_stripsperimage /= td->td_samplesperpixel;
td->td_stripoffset = (uint32 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint32));
td->td_stripbytecount = (uint32 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint32));
td->td_stripoffset = (uint64 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint64));
td->td_stripbytecount = (uint64 *)
_TIFFmalloc(td->td_nstrips * sizeof (uint64));
if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL)
return (0);
/*
* Place data at the end-of-file
* (by setting offsets to zero).
*/
_TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint32));
_TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint32));
_TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint64));
_TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint64));
TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
return (1);
@ -483,16 +489,17 @@ int
TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
{
if (tif->tif_mode == O_RDONLY) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: File not open for writing",
tif->tif_name);
TIFFErrorExt(tif->tif_clientdata, module, "File not open for writing");
return (0);
}
if (tiles ^ isTiled(tif)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ?
TIFFErrorExt(tif->tif_clientdata, module, tiles ?
"Can not write tiles to a stripped image" :
"Can not write scanlines to a tiled image");
return (0);
}
_TIFFFillStriles( tif );
/*
* On the first write verify all the required information
@ -506,8 +513,7 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
*/
if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Must set \"ImageWidth\" before writing data",
tif->tif_name);
"Must set \"ImageWidth\" before writing data");
return (0);
}
if (tif->tif_dir.td_samplesperpixel == 1) {
@ -522,19 +528,27 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
} else {
if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Must set \"PlanarConfiguration\" before writing data",
tif->tif_name);
"Must set \"PlanarConfiguration\" before writing data");
return (0);
}
}
if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) {
tif->tif_dir.td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for %s arrays",
tif->tif_name, isTiled(tif) ? "tile" : "strip");
TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays",
isTiled(tif) ? "tile" : "strip");
return (0);
}
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
if (isTiled(tif))
{
tif->tif_tilesize = TIFFTileSize(tif);
if (tif->tif_tilesize == 0)
return (0);
}
else
tif->tif_tilesize = (tmsize_t)(-1);
tif->tif_scanlinesize = TIFFScanlineSize(tif);
if (tif->tif_scanlinesize == 0)
return (0);
tif->tif_flags |= TIFF_BEENWRITING;
return (1);
}
@ -543,7 +557,7 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
* Setup the raw data buffer used for encoding.
*/
int
TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size)
{
static const char module[] = "TIFFWriteBufferSetup";
@ -554,7 +568,7 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
}
tif->tif_rawdata = NULL;
}
if (size == (tsize_t) -1) {
if (size == (tmsize_t)(-1)) {
size = (isTiled(tif) ?
tif->tif_tilesize : TIFFStripSize(tif));
/*
@ -567,14 +581,13 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
if (bp == NULL) {
bp = _TIFFmalloc(size);
if (bp == NULL) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for output buffer",
tif->tif_name);
TIFFErrorExt(tif->tif_clientdata, module, "No space for output buffer");
return (0);
}
tif->tif_flags |= TIFF_MYBUFFER;
} else
tif->tif_flags &= ~TIFF_MYBUFFER;
tif->tif_rawdata = (tidata_t) bp;
tif->tif_rawdata = (uint8*) bp;
tif->tif_rawdatasize = size;
tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata;
@ -586,33 +599,35 @@ TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
* Grow the strip data structures by delta strips.
*/
static int
TIFFGrowStrips(TIFF* tif, int delta, const char* module)
TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module)
{
TIFFDirectory *td = &tif->tif_dir;
uint32 *new_stripoffset, *new_stripbytecount;
TIFFDirectory *td = &tif->tif_dir;
uint64* new_stripoffset;
uint64* new_stripbytecount;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
new_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset,
(td->td_nstrips + delta) * sizeof (uint32));
new_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount,
(td->td_nstrips + delta) * sizeof (uint32));
new_stripoffset = (uint64*)_TIFFrealloc(td->td_stripoffset,
(td->td_nstrips + delta) * sizeof (uint64));
new_stripbytecount = (uint64*)_TIFFrealloc(td->td_stripbytecount,
(td->td_nstrips + delta) * sizeof (uint64));
if (new_stripoffset == NULL || new_stripbytecount == NULL) {
if (new_stripoffset)
_TIFFfree(new_stripoffset);
if (new_stripbytecount)
_TIFFfree(new_stripbytecount);
td->td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module, "%s: No space to expand strip arrays",
tif->tif_name);
TIFFErrorExt(tif->tif_clientdata, module, "No space to expand strip arrays");
return (0);
}
td->td_stripoffset = new_stripoffset;
td->td_stripbytecount = new_stripbytecount;
_TIFFmemset(td->td_stripoffset + td->td_nstrips,
0, delta*sizeof (uint32));
0, delta*sizeof (uint64));
_TIFFmemset(td->td_stripbytecount + td->td_nstrips,
0, delta*sizeof (uint32));
0, delta*sizeof (uint64));
td->td_nstrips += delta;
tif->tif_flags |= TIFF_DIRTYDIRECT;
return (1);
}
@ -620,21 +635,23 @@ TIFFGrowStrips(TIFF* tif, int delta, const char* module)
* Append the data to the specified strip.
*/
static int
TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
{
static const char module[] = "TIFFAppendToStrip";
TIFFDirectory *td = &tif->tif_dir;
uint64 m;
int64 old_byte_count = -1;
if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
assert(td->td_nstrips > 0);
if( td->td_stripbytecount[strip] != 0
&& td->td_stripoffset[strip] != 0
&& td->td_stripbytecount[strip] >= cc )
&& td->td_stripbytecount[strip] >= (uint64) cc )
{
/*
* There is already tile data on disk, and the new tile
* data we have to will fit in the same space. The only
* data we have will fit in the same space. The only
* aspect of this that is risky is that there could be
* more data to append to this strip before we are done
* depending on how we are getting called.
@ -653,6 +670,7 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
* write this strip.
*/
td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END);
tif->tif_flags |= TIFF_DIRTYSTRIP;
}
tif->tif_curoff = td->td_stripoffset[strip];
@ -660,16 +678,29 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
/*
* We are starting a fresh strip/tile, so set the size to zero.
*/
old_byte_count = td->td_stripbytecount[strip];
td->td_stripbytecount[strip] = 0;
}
m = tif->tif_curoff+cc;
if (!(tif->tif_flags&TIFF_BIGTIFF))
m = (uint32)m;
if ((m<tif->tif_curoff)||(m<(uint64)cc))
{
TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded");
return (0);
}
if (!WriteOK(tif, data, cc)) {
TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
(unsigned long) tif->tif_row);
return (0);
}
tif->tif_curoff = tif->tif_curoff+cc;
tif->tif_curoff = m;
td->td_stripbytecount[strip] += cc;
if( (int64) td->td_stripbytecount[strip] != old_byte_count )
tif->tif_flags |= TIFF_DIRTYSTRIP;
return (1);
}
@ -681,10 +712,10 @@ TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
int
TIFFFlushData1(TIFF* tif)
{
if (tif->tif_rawcc > 0) {
if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE ) {
if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((unsigned char *)tif->tif_rawdata,
TIFFReverseBits((uint8*)tif->tif_rawdata,
tif->tif_rawcc);
if (!TIFFAppendToStrip(tif,
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,

202
3rdparty/libtiff/tif_zip.c vendored
View File

@ -1,4 +1,4 @@
/* $Id: tif_zip.c,v 1.11.2.4 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tif_zip.c,v 1.31 2011-01-06 16:00:23 fwarmerdam Exp $ */
/*
* Copyright (c) 1995-1997 Sam Leffler
@ -65,41 +65,48 @@
* State block for each open TIFF
* file using ZIP compression/decompression.
*/
typedef struct {
typedef struct {
TIFFPredictorState predict;
z_stream stream;
int zipquality; /* compression level */
int state; /* state flags */
z_stream stream;
int zipquality; /* compression level */
int state; /* state flags */
#define ZSTATE_INIT_DECODE 0x01
#define ZSTATE_INIT_ENCODE 0x02
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */
} ZIPState;
#define ZState(tif) ((ZIPState*) (tif)->tif_data)
#define DecoderState(tif) ZState(tif)
#define EncoderState(tif) ZState(tif)
#define ZState(tif) ((ZIPState*) (tif)->tif_data)
#define DecoderState(tif) ZState(tif)
#define EncoderState(tif) ZState(tif)
static int ZIPEncode(TIFF*, tidata_t, tsize_t, tsample_t);
static int ZIPDecode(TIFF*, tidata_t, tsize_t, tsample_t);
static int ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s);
static int ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s);
static int
ZIPFixupTags(TIFF* tif)
{
(void) tif;
return (1);
}
static int
ZIPSetupDecode(TIFF* tif)
{
ZIPState* sp = DecoderState(tif);
static const char module[] = "ZIPSetupDecode";
ZIPState* sp = DecoderState(tif);
assert(sp != NULL);
/* if we were last encoding, terminate this mode */
if (sp->state & ZSTATE_INIT_ENCODE) {
deflateEnd(&sp->stream);
sp->state = 0;
}
deflateEnd(&sp->stream);
sp->state = 0;
}
if (inflateInit(&sp->stream) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
return (0);
} else {
sp->state |= ZSTATE_INIT_DECODE;
@ -111,74 +118,100 @@ ZIPSetupDecode(TIFF* tif)
* Setup state for decoding a strip.
*/
static int
ZIPPreDecode(TIFF* tif, tsample_t s)
ZIPPreDecode(TIFF* tif, uint16 s)
{
static const char module[] = "ZIPPreDecode";
ZIPState* sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
if( (sp->state & ZSTATE_INIT_DECODE) == 0 )
if( (sp->state & ZSTATE_INIT_DECODE) == 0 )
tif->tif_setupdecode( tif );
sp->stream.next_in = tif->tif_rawdata;
sp->stream.avail_in = tif->tif_rawcc;
assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_in = (uInt) tif->tif_rawcc;
if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
return (inflateReset(&sp->stream) == Z_OK);
}
static int
ZIPDecode(TIFF* tif, tidata_t op, tsize_t occ, tsample_t s)
ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{
ZIPState* sp = DecoderState(tif);
static const char module[] = "ZIPDecode";
ZIPState* sp = DecoderState(tif);
(void) s;
assert(sp != NULL);
assert(sp->state == ZSTATE_INIT_DECODE);
assert(sp->state == ZSTATE_INIT_DECODE);
sp->stream.next_in = tif->tif_rawcp;
sp->stream.avail_in = (uInt) tif->tif_rawcc;
sp->stream.next_out = op;
sp->stream.avail_out = occ;
assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_out = (uInt) occ;
if ((tmsize_t)sp->stream.avail_out != occ)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
do {
int state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
if (state == Z_STREAM_END)
break;
if (state == Z_DATA_ERROR) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Decoding error at scanline %d, %s",
tif->tif_name, tif->tif_row, sp->stream.msg);
"Decoding error at scanline %lu, %s",
(unsigned long) tif->tif_row, sp->stream.msg);
if (inflateSync(&sp->stream) != Z_OK)
return (0);
continue;
}
if (state != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
} while (sp->stream.avail_out > 0);
if (sp->stream.avail_out != 0) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s: Not enough data at scanline %d (short %d bytes)",
tif->tif_name, tif->tif_row, sp->stream.avail_out);
"Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)",
(unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out);
return (0);
}
tif->tif_rawcp = sp->stream.next_in;
tif->tif_rawcc = sp->stream.avail_in;
return (1);
}
static int
ZIPSetupEncode(TIFF* tif)
{
ZIPState* sp = EncoderState(tif);
static const char module[] = "ZIPSetupEncode";
ZIPState* sp = EncoderState(tif);
assert(sp != NULL);
if (sp->state & ZSTATE_INIT_DECODE) {
inflateEnd(&sp->stream);
sp->state = 0;
}
inflateEnd(&sp->stream);
sp->state = 0;
}
if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: %s", tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "%s", sp->stream.msg);
return (0);
} else {
sp->state |= ZSTATE_INIT_ENCODE;
@ -190,17 +223,27 @@ ZIPSetupEncode(TIFF* tif)
* Reset encoding state at the start of a strip.
*/
static int
ZIPPreEncode(TIFF* tif, tsample_t s)
ZIPPreEncode(TIFF* tif, uint16 s)
{
static const char module[] = "ZIPPreEncode";
ZIPState *sp = EncoderState(tif);
(void) s;
assert(sp != NULL);
if( sp->state != ZSTATE_INIT_ENCODE )
if( sp->state != ZSTATE_INIT_ENCODE )
tif->tif_setupencode( tif );
sp->stream.next_out = tif->tif_rawdata;
assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_out = tif->tif_rawdatasize;
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
return (deflateReset(&sp->stream) == Z_OK);
}
@ -208,28 +251,37 @@ ZIPPreEncode(TIFF* tif, tsample_t s)
* Encode a chunk of pixels.
*/
static int
ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{
ZIPState *sp = EncoderState(tif);
static const char module[] = "ZIPEncode";
ZIPState *sp = EncoderState(tif);
assert(sp != NULL);
assert(sp->state == ZSTATE_INIT_ENCODE);
assert(sp != NULL);
assert(sp->state == ZSTATE_INIT_ENCODE);
(void) s;
sp->stream.next_in = bp;
sp->stream.avail_in = cc;
assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised,
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
apropriately even before we simplify it */
sp->stream.avail_in = (uInt) cc;
if ((tmsize_t)sp->stream.avail_in != cc)
{
TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size");
return (0);
}
do {
if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: Encoder error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s",
sp->stream.msg);
return (0);
}
if (sp->stream.avail_out == 0) {
tif->tif_rawcc = tif->tif_rawdatasize;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */
}
} while (sp->stream.avail_in > 0);
return (1);
@ -242,8 +294,8 @@ ZIPEncode(TIFF* tif, tidata_t bp, tsize_t cc, tsample_t s)
static int
ZIPPostEncode(TIFF* tif)
{
ZIPState *sp = EncoderState(tif);
static const char module[] = "ZIPPostEncode";
ZIPState *sp = EncoderState(tif);
int state;
sp->stream.avail_in = 0;
@ -252,19 +304,18 @@ ZIPPostEncode(TIFF* tif)
switch (state) {
case Z_STREAM_END:
case Z_OK:
if ((int)sp->stream.avail_out != (int)tif->tif_rawdatasize)
{
tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = tif->tif_rawdatasize;
}
break;
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{
tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out;
TIFFFlushData1(tif);
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */
}
break;
default:
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
return (0);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
} while (state != Z_STREAM_END);
return (1);
@ -283,11 +334,11 @@ ZIPCleanup(TIFF* tif)
tif->tif_tagmethods.vsetfield = sp->vsetparent;
if (sp->state & ZSTATE_INIT_ENCODE) {
deflateEnd(&sp->stream);
sp->state = 0;
} else if( sp->state & ZSTATE_INIT_DECODE) {
inflateEnd(&sp->stream);
sp->state = 0;
deflateEnd(&sp->stream);
sp->state = 0;
} else if( sp->state & ZSTATE_INIT_DECODE) {
inflateEnd(&sp->stream);
sp->state = 0;
}
_TIFFfree(sp);
tif->tif_data = NULL;
@ -296,19 +347,19 @@ ZIPCleanup(TIFF* tif)
}
static int
ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap)
ZIPVSetField(TIFF* tif, uint32 tag, va_list ap)
{
ZIPState* sp = ZState(tif);
static const char module[] = "ZIPVSetField";
ZIPState* sp = ZState(tif);
switch (tag) {
case TIFFTAG_ZIPQUALITY:
sp->zipquality = va_arg(ap, int);
sp->zipquality = (int) va_arg(ap, int);
if ( sp->state&ZSTATE_INIT_ENCODE ) {
if (deflateParams(&sp->stream,
sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) {
TIFFErrorExt(tif->tif_clientdata, module, "%s: zlib error: %s",
tif->tif_name, sp->stream.msg);
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s",
sp->stream.msg);
return (0);
}
}
@ -320,7 +371,7 @@ ZIPVSetField(TIFF* tif, ttag_t tag, va_list ap)
}
static int
ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap)
ZIPVGetField(TIFF* tif, uint32 tag, va_list ap)
{
ZIPState* sp = ZState(tif);
@ -334,9 +385,8 @@ ZIPVGetField(TIFF* tif, ttag_t tag, va_list ap)
return (1);
}
static const TIFFFieldInfo zipFieldInfo[] = {
{ TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,
TRUE, FALSE, "" },
static const TIFFField zipFields[] = {
{ TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL },
};
int
@ -351,8 +401,7 @@ TIFFInitZIP(TIFF* tif, int scheme)
/*
* Merge codec-specific tag information.
*/
if (!_TIFFMergeFieldInfo(tif, zipFieldInfo,
TIFFArrayCount(zipFieldInfo))) {
if (!_TIFFMergeFields(tif, zipFields, TIFFArrayCount(zipFields))) {
TIFFErrorExt(tif->tif_clientdata, module,
"Merging Deflate codec-specific tags failed");
return 0;
@ -361,7 +410,7 @@ TIFFInitZIP(TIFF* tif, int scheme)
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (ZIPState));
tif->tif_data = (uint8*) _TIFFmalloc(sizeof (ZIPState));
if (tif->tif_data == NULL)
goto bad;
sp = ZState(tif);
@ -385,11 +434,12 @@ TIFFInitZIP(TIFF* tif, int scheme)
/*
* Install codec methods.
*/
tif->tif_fixuptags = ZIPFixupTags;
tif->tif_setupdecode = ZIPSetupDecode;
tif->tif_predecode = ZIPPreDecode;
tif->tif_decoderow = ZIPDecode;
tif->tif_decodestrip = ZIPDecode;
tif->tif_decodetile = ZIPDecode;
tif->tif_decodetile = ZIPDecode;
tif->tif_setupencode = ZIPSetupEncode;
tif->tif_preencode = ZIPPreEncode;
tif->tif_postencode = ZIPPostEncode;

158
3rdparty/libtiff/tiff.h vendored
View File

@ -1,4 +1,4 @@
/* $Id: tiff.h,v 1.43.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tiff.h,v 1.67 2011-01-24 21:06:32 olivier Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -27,7 +27,7 @@
#ifndef _TIFF_
#define _TIFF_
#include "tiffconf.h"
#include "tif_config.h"
/*
* Tag Image File Format (TIFF)
@ -39,87 +39,75 @@
* Suite 200
* Seattle, WA 98104
* 206-622-5500
*
*
* (http://partners.adobe.com/asn/developer/PDFS/TN/TIFF6.pdf)
*
* For Big TIFF design notes see the following link
* For BigTIFF design notes see the following links
* http://www.remotesensing.org/libtiff/bigtiffdesign.html
* http://www.awaresystems.be/imaging/tiff/bigtiff.html
*/
#define TIFF_VERSION 42
#define TIFF_BIGTIFF_VERSION 43
#define TIFF_BIGENDIAN 0x4d4d
#define TIFF_LITTLEENDIAN 0x4949
#define MDI_LITTLEENDIAN 0x5045
#define MDI_BIGENDIAN 0x4550
#define TIFF_VERSION_CLASSIC 42
#define TIFF_VERSION_BIG 43
#define TIFF_BIGENDIAN 0x4d4d
#define TIFF_LITTLEENDIAN 0x4949
#define MDI_LITTLEENDIAN 0x5045
#define MDI_BIGENDIAN 0x4550
/*
* Intrinsic data types required by the file format:
*
* 8-bit quantities int8/uint8
* 16-bit quantities int16/uint16
* 32-bit quantities int32/uint32
* strings unsigned char*
* 8-bit quantities int8/uint8
* 16-bit quantities int16/uint16
* 32-bit quantities int32/uint32
* 64-bit quantities int64/uint64
* strings unsigned char*
*/
#ifndef HAVE_INT8
typedef signed char int8; /* NB: non-ANSI compilers may not grok */
#endif
typedef unsigned char uint8;
#ifndef HAVE_INT16
typedef short int16;
#endif
typedef unsigned short uint16; /* sizeof (uint16) must == 2 */
#if SIZEOF_INT == 4
#ifndef HAVE_INT32
typedef int int32;
#endif
typedef unsigned int uint32; /* sizeof (uint32) must == 4 */
#elif SIZEOF_LONG == 4
#ifndef HAVE_INT32
typedef long int32;
#endif
typedef unsigned long uint32; /* sizeof (uint32) must == 4 */
#endif
typedef TIFF_INT8_T int8;
typedef TIFF_UINT8_T uint8;
/* For TIFFReassignTagToIgnore */
enum TIFFIgnoreSense /* IGNORE tag table */
{
TIS_STORE,
TIS_EXTRACT,
TIS_EMPTY
};
typedef TIFF_INT16_T int16;
typedef TIFF_UINT16_T uint16;
typedef TIFF_INT32_T int32;
typedef TIFF_UINT32_T uint32;
typedef TIFF_INT64_T int64;
typedef TIFF_UINT64_T uint64;
/*
* Some types as promoted in a variable argument list
* We use uint16_vap rather then directly using int, because this way
* we document the type we actually want to pass through, conceptually,
* rather then confusing the issue by merely stating the type it gets
* promoted to
*/
typedef int uint16_vap;
/*
* TIFF header.
*/
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
#define TIFF_MAGIC_SIZE 2
uint16 tiff_version; /* TIFF version number */
#define TIFF_VERSION_SIZE 2
uint32 tiff_diroff; /* byte offset to first directory */
#define TIFF_DIROFFSET_SIZE 4
} TIFFHeader;
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
uint16 tiff_version; /* TIFF version number */
} TIFFHeaderCommon;
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
uint16 tiff_version; /* TIFF version number */
uint32 tiff_diroff; /* byte offset to first directory */
} TIFFHeaderClassic;
typedef struct {
uint16 tiff_magic; /* magic number (defines byte order) */
uint16 tiff_version; /* TIFF version number */
uint16 tiff_offsetsize; /* size of offsets, should be 8 */
uint16 tiff_unused; /* unused word, should be 0 */
uint64 tiff_diroff; /* byte offset to first directory */
} TIFFHeaderBig;
/*
* TIFF Image File Directories are comprised of a table of field
* descriptors of the form shown below. The table is sorted in
* ascending order by tag. The values associated with each entry are
* disjoint and may appear anywhere in the file (so long as they are
* placed on a word boundary).
*
* If the value is 4 bytes or less, then it is placed in the offset
* field to save space. If the value is less than 4 bytes, it is
* left-justified in the offset field.
*/
typedef struct {
uint16 tdir_tag; /* see below */
uint16 tdir_type; /* data type; see below */
uint32 tdir_count; /* number of items; length in spec */
uint32 tdir_offset; /* byte offset to field data */
} TIFFDirEntry;
/*
* NB: In the comments below,
* - items marked with a + are obsoleted by revision 5.0,
@ -134,21 +122,24 @@ typedef struct {
*
* Note: RATIONALs are the ratio of two 32-bit integer values.
*/
typedef enum {
TIFF_NOTYPE = 0, /* placeholder */
TIFF_BYTE = 1, /* 8-bit unsigned integer */
TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */
TIFF_SHORT = 3, /* 16-bit unsigned integer */
TIFF_LONG = 4, /* 32-bit unsigned integer */
TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */
TIFF_SBYTE = 6, /* !8-bit signed integer */
TIFF_UNDEFINED = 7, /* !8-bit untyped data */
TIFF_SSHORT = 8, /* !16-bit signed integer */
TIFF_SLONG = 9, /* !32-bit signed integer */
TIFF_SRATIONAL = 10, /* !64-bit signed fraction */
TIFF_FLOAT = 11, /* !32-bit IEEE floating point */
TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */
TIFF_IFD = 13 /* %32-bit unsigned integer (offset) */
typedef enum {
TIFF_NOTYPE = 0, /* placeholder */
TIFF_BYTE = 1, /* 8-bit unsigned integer */
TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */
TIFF_SHORT = 3, /* 16-bit unsigned integer */
TIFF_LONG = 4, /* 32-bit unsigned integer */
TIFF_RATIONAL = 5, /* 64-bit unsigned fraction */
TIFF_SBYTE = 6, /* !8-bit signed integer */
TIFF_UNDEFINED = 7, /* !8-bit untyped data */
TIFF_SSHORT = 8, /* !16-bit signed integer */
TIFF_SLONG = 9, /* !32-bit signed integer */
TIFF_SRATIONAL = 10, /* !64-bit signed fraction */
TIFF_FLOAT = 11, /* !32-bit IEEE floating point */
TIFF_DOUBLE = 12, /* !64-bit IEEE floating point */
TIFF_IFD = 13, /* %32-bit unsigned integer (offset) */
TIFF_LONG8 = 16, /* BigTIFF 64-bit unsigned integer */
TIFF_SLONG8 = 17, /* BigTIFF 64-bit signed integer */
TIFF_IFD8 = 18 /* BigTIFF 64-bit unsigned integer (offset) */
} TIFFDataType;
/*
@ -196,6 +187,7 @@ typedef enum {
#define COMPRESSION_SGILOG 34676 /* SGI Log Luminance RLE */
#define COMPRESSION_SGILOG24 34677 /* SGI Log 24-bit packed */
#define COMPRESSION_JP2000 34712 /* Leadtools JPEG2000 */
#define COMPRESSION_LZMA 34925 /* LZMA2 */
#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */
#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */
#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */
@ -576,6 +568,10 @@ typedef enum {
#define TIFFTAG_SGILOGENCODE 65561 /* SGILog data encoding control*/
#define SGILOGENCODE_NODITHER 0 /* do not dither encoded values*/
#define SGILOGENCODE_RANDITHER 1 /* randomly dither encd values */
#define TIFFTAG_LZMAPRESET 65562 /* LZMA2 preset (compression level) */
#define TIFFTAG_PERSAMPLE 65563 /* interface for per sample tags */
#define PERSAMPLE_MERGED 0 /* present as a single value */
#define PERSAMPLE_MULTI 1 /* present as multiple values */
/*
* EXIF tags

124
3rdparty/libtiff/tiffconf.h vendored
View File

@ -1,124 +0,0 @@
/*
Configuration defines for installed libtiff.
This file maintained for backward compatibility. Do not use definitions
from this file in your programs.
*/
#ifndef _TIFFCONF_
#define _TIFFCONF_
/* Define to 1 if the system has the type `int16'. */
/* #undef HAVE_INT16 */
/* Define to 1 if the system has the type `int32'. */
/* #undef HAVE_INT32 */
/* Define to 1 if the system has the type `int8'. */
/* #undef HAVE_INT8 */
/* The size of a `int', as computed by sizeof. */
#define SIZEOF_INT 4
/* The size of a `long', as computed by sizeof. */
#define SIZEOF_LONG 4
/* Signed 64-bit type formatter */
#define TIFF_INT64_FORMAT "%I64d"
/* Signed 64-bit type */
#ifdef _MSC_VER
#define TIFF_INT64_T signed __int64
#else
#define TIFF_INT64_T long long
#endif
/* Unsigned 64-bit type formatter */
#define TIFF_UINT64_FORMAT "%I64u"
/* Unsigned 64-bit type */
#ifdef _MSC_VER
#define TIFF_UINT64_T unsigned __int64
#else
#define TIFF_UINT64_T unsigned long long
#endif
/* Compatibility stuff. */
/* Define as 0 or 1 according to the floating point format suported by the
machine */
#define HAVE_IEEEFP 1
/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */
#define HOST_FILLORDER FILLORDER_LSB2MSB
/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
(Intel) */
#define HOST_BIGENDIAN 0
/* Support CCITT Group 3 & 4 algorithms */
#define CCITT_SUPPORT 1
/* Support JPEG compression (requires IJG JPEG library) */
/* #undef JPEG_SUPPORT */
/* Support LogLuv high dynamic range encoding */
#define LOGLUV_SUPPORT 1
/* Support LZW algorithm */
#define LZW_SUPPORT 1
/* Support NeXT 2-bit RLE algorithm */
#define NEXT_SUPPORT 1
/* Support Old JPEG compresson (read contrib/ojpeg/README first! Compilation
fails with unpatched IJG JPEG library) */
/* #undef OJPEG_SUPPORT */
/* Support Macintosh PackBits algorithm */
#define PACKBITS_SUPPORT 1
/* Support Pixar log-format algorithm (requires Zlib) */
/* #undef PIXARLOG_SUPPORT */
/* Support ThunderScan 4-bit RLE algorithm */
#define THUNDER_SUPPORT 1
/* Support Deflate compression */
/* #undef ZIP_SUPPORT */
/* Support strip chopping (whether or not to convert single-strip uncompressed
images to mutiple strips of ~8Kb to reduce memory usage) */
#define STRIPCHOP_DEFAULT TIFF_STRIPCHOP
/* Enable SubIFD tag (330) support */
#define SUBIFD_SUPPORT 1
/* Treat extra sample as alpha (default enabled). The RGBA interface will
treat a fourth sample with no EXTRASAMPLE_ value as being ASSOCALPHA. Many
packages produce RGBA files but don't mark the alpha properly. */
#define DEFAULT_EXTRASAMPLE_AS_ALPHA 1
/* Pick up YCbCr subsampling info from the JPEG data stream to support files
lacking the tag (default enabled). */
#define CHECK_JPEG_YCBCR_SUBSAMPLING 1
/*
* Feature support definitions.
* XXX: These macros are obsoleted. Don't use them in your apps!
* Macros stays here for backward compatibility and should be always defined.
*/
#define COLORIMETRY_SUPPORT
#define YCBCR_SUPPORT
#define CMYK_SUPPORT
#define ICC_SUPPORT
#define PHOTOSHOP_SUPPORT
#define IPTC_SUPPORT
#endif /* _TIFFCONF_ */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

575
3rdparty/libtiff/tiffio.h vendored
View File

@ -1,21 +1,21 @@
/* $Id: tiffio.h,v 1.56.2.4 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tiffio.h,v 1.89 2012-02-18 16:20:26 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* 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.
*
*
* 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,
@ -37,7 +37,7 @@
* TIFF is defined as an incomplete type to hide the
* library's internal data structures from clients.
*/
typedef struct tiff TIFF;
typedef struct tiff TIFF;
/*
* The following typedefs define the intrinsic size of
@ -55,18 +55,27 @@ typedef struct tiff TIFF;
* NB: tsize_t is int32 and not uint32 because some functions
* return -1.
* NB: toff_t is not off_t for many reasons; TIFFs max out at
* 32-bit file offsets being the most important, and to ensure
* that it is unsigned, rather than signed.
* 32-bit file offsets, and BigTIFF maxes out at 64-bit
* offsets being the most important, and to ensure use of
* a consistently unsigned type across architectures.
* Prior to libtiff 4.0, this was an unsigned 32 bit type.
*/
/*
* this is the machine addressing size type, only it's signed, so make it
* int32 on 32bit machines, int64 on 64bit machines
*/
typedef TIFF_SSIZE_T tmsize_t;
typedef uint64 toff_t; /* file offset */
/* the following are deprecated and should be replaced by their defining
counterparts */
typedef uint32 ttag_t; /* directory tag */
typedef uint16 tdir_t; /* directory index */
typedef uint16 tsample_t; /* sample number */
typedef uint32 tstrile_t; /* strip or tile number */
typedef tstrile_t tstrip_t; /* strip number */
typedef tstrile_t ttile_t; /* tile number */
typedef size_t tsize_t; /* i/o size in bytes */
typedef tmsize_t tsize_t; /* i/o size in bytes */
typedef void* tdata_t; /* image data ref */
typedef uint32 toff_t; /* file offset */
#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
#define __WIN32__
@ -89,12 +98,12 @@ typedef uint32 toff_t; /* file offset */
# define VC_EXTRALEAN
# include <windows.h>
# ifdef __WIN32__
DECLARE_HANDLE(thandle_t); /* Win32 file handle */
DECLARE_HANDLE(thandle_t); /* Win32 file handle */
# else
typedef HFILE thandle_t; /* client data handle */
typedef HFILE thandle_t; /* client data handle */
# endif /* __WIN32__ */
#else
typedef void* thandle_t; /* client data handle */
typedef void* thandle_t; /* client data handle */
#endif /* USE_WIN32_FILEIO */
/*
@ -103,13 +112,13 @@ typedef void* thandle_t; /* client data handle */
* very large. Bit-or these flags to enable printing
* multiple items.
*/
#define TIFFPRINT_NONE 0x0 /* no extra info */
#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */
#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */
#define TIFFPRINT_COLORMAP 0x4 /* colormap */
#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */
#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
#define TIFFPRINT_NONE 0x0 /* no extra info */
#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */
#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */
#define TIFFPRINT_COLORMAP 0x4 /* colormap */
#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */
#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
/*
* Colour conversion stuff
@ -126,42 +135,42 @@ typedef void* thandle_t; /* client data handle */
/* Structure for holding information about a display device. */
typedef unsigned char TIFFRGBValue; /* 8-bit samples */
typedef unsigned char TIFFRGBValue; /* 8-bit samples */
typedef struct {
float d_mat[3][3]; /* XYZ -> luminance matrix */
float d_YCR; /* Light o/p for reference white */
float d_mat[3][3]; /* XYZ -> luminance matrix */
float d_YCR; /* Light o/p for reference white */
float d_YCG;
float d_YCB;
uint32 d_Vrwr; /* Pixel values for ref. white */
uint32 d_Vrwr; /* Pixel values for ref. white */
uint32 d_Vrwg;
uint32 d_Vrwb;
float d_Y0R; /* Residual light for black pixel */
float d_Y0R; /* Residual light for black pixel */
float d_Y0G;
float d_Y0B;
float d_gammaR; /* Gamma values for the three guns */
float d_gammaR; /* Gamma values for the three guns */
float d_gammaG;
float d_gammaB;
} TIFFDisplay;
typedef struct { /* YCbCr->RGB support */
TIFFRGBValue* clamptab; /* range clamping table */
int* Cr_r_tab;
int* Cb_b_tab;
int32* Cr_g_tab;
int32* Cb_g_tab;
int32* Y_tab;
typedef struct { /* YCbCr->RGB support */
TIFFRGBValue* clamptab; /* range clamping table */
int* Cr_r_tab;
int* Cb_b_tab;
int32* Cr_g_tab;
int32* Cb_g_tab;
int32* Y_tab;
} TIFFYCbCrToRGB;
typedef struct { /* CIE Lab 1976->RGB support */
int range; /* Size of conversion table */
typedef struct { /* CIE Lab 1976->RGB support */
int range; /* Size of conversion table */
#define CIELABTORGB_TABLE_RANGE 1500
float rstep, gstep, bstep;
float X0, Y0, Z0; /* Reference white point */
float rstep, gstep, bstep;
float X0, Y0, Z0; /* Reference white point */
TIFFDisplay display;
float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
} TIFFCIELabToRGB;
/*
@ -216,6 +225,9 @@ struct _TIFFRGBAImage {
TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */
TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */
uint8* UaToAa; /* Unassociated alpha to associated alpha convertion LUT */
uint8* Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */
int row_offset;
int col_offset;
};
@ -224,10 +236,10 @@ struct _TIFFRGBAImage {
* Macros for extracting components from the
* packed ABGR form returned by TIFFReadRGBAImage.
*/
#define TIFFGetR(abgr) ((abgr) & 0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
#define TIFFGetR(abgr) ((abgr) & 0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
/*
* A CODEC is a software package that implements decoding,
@ -236,11 +248,11 @@ struct _TIFFRGBAImage {
* More codecs may be registered through calls to the library
* and/or the builtin implementations may be overridden.
*/
typedef int (*TIFFInitMethod)(TIFF*, int);
typedef int (*TIFFInitMethod)(TIFF*, int);
typedef struct {
char* name;
uint16 scheme;
TIFFInitMethod init;
char* name;
uint16 scheme;
TIFFInitMethod init;
} TIFFCodec;
#include <stdio.h>
@ -248,7 +260,7 @@ typedef struct {
/* share internal LogLuv conversion routines? */
#ifndef LOGLUV_PUBLIC
#define LOGLUV_PUBLIC 1
#define LOGLUV_PUBLIC 1
#endif
#if !defined(__GNUC__) && !defined(__attribute__)
@ -258,48 +270,254 @@ typedef struct {
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list);
typedef tsize_t (*TIFFReadWriteProc)(thandle_t, tdata_t, tsize_t);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef int (*TIFFCloseProc)(thandle_t);
typedef toff_t (*TIFFSizeProc)(thandle_t);
typedef int (*TIFFMapFileProc)(thandle_t, tdata_t*, toff_t*);
typedef void (*TIFFUnmapFileProc)(thandle_t, tdata_t, toff_t);
typedef void (*TIFFExtendProc)(TIFF*);
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list);
typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list);
typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void*, tmsize_t);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef int (*TIFFCloseProc)(thandle_t);
typedef toff_t (*TIFFSizeProc)(thandle_t);
typedef int (*TIFFMapFileProc)(thandle_t, void** base, toff_t* size);
typedef void (*TIFFUnmapFileProc)(thandle_t, void* base, toff_t size);
typedef void (*TIFFExtendProc)(TIFF*);
extern const char* TIFFGetVersion(void);
extern const char* TIFFGetVersion(void);
extern const TIFFCodec* TIFFFindCODEC(uint16);
extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*);
extern int TIFFIsCODECConfigured(uint16);
extern TIFFCodec* TIFFGetConfiguredCODECs(void);
extern const TIFFCodec* TIFFFindCODEC(uint16);
extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*);
extern int TIFFIsCODECConfigured(uint16);
extern TIFFCodec* TIFFGetConfiguredCODECs(void);
/*
* Auxiliary functions.
*/
extern tdata_t _TIFFmalloc(tsize_t);
extern tdata_t _TIFFrealloc(tdata_t, tsize_t);
extern void _TIFFmemset(tdata_t, int, tsize_t);
extern void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t);
extern int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t);
extern void _TIFFfree(tdata_t);
extern void* _TIFFmalloc(tmsize_t s);
extern void* _TIFFrealloc(void* p, tmsize_t s);
extern void _TIFFmemset(void* p, int v, tmsize_t c);
extern void _TIFFmemcpy(void* d, const void* s, tmsize_t c);
extern int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c);
extern void _TIFFfree(void* p);
/*
** Stuff, related to tag handling and creating custom tags.
*/
extern int TIFFGetTagListCount( TIFF * );
extern ttag_t TIFFGetTagListEntry( TIFF *, int tag_index );
extern int TIFFGetTagListCount( TIFF * );
extern uint32 TIFFGetTagListEntry( TIFF *, int tag_index );
#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */
#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */
#define FIELD_CUSTOM 65
#define FIELD_CUSTOM 65
typedef struct _TIFFField TIFFField;
typedef struct _TIFFFieldArray TIFFFieldArray;
extern const TIFFField* TIFFFindField(TIFF *, uint32, TIFFDataType);
extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32);
extern const TIFFField* TIFFFieldWithName(TIFF*, const char *);
typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list);
typedef int (*TIFFVGetMethod)(TIFF*, uint32, va_list);
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
typedef struct {
TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *);
extern void *TIFFGetClientInfo(TIFF *, const char *);
extern void TIFFSetClientInfo(TIFF *, void *, const char *);
extern void TIFFCleanup(TIFF* tif);
extern void TIFFClose(TIFF* tif);
extern int TIFFFlush(TIFF* tif);
extern int TIFFFlushData(TIFF* tif);
extern int TIFFGetField(TIFF* tif, uint32 tag, ...);
extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap);
extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...);
extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap);
extern int TIFFReadDirectory(TIFF* tif);
extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray);
extern int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff);
extern uint64 TIFFScanlineSize64(TIFF* tif);
extern tmsize_t TIFFScanlineSize(TIFF* tif);
extern uint64 TIFFRasterScanlineSize64(TIFF* tif);
extern tmsize_t TIFFRasterScanlineSize(TIFF* tif);
extern uint64 TIFFStripSize64(TIFF* tif);
extern tmsize_t TIFFStripSize(TIFF* tif);
extern uint64 TIFFRawStripSize64(TIFF* tif, uint32 strip);
extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip);
extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows);
extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows);
extern uint64 TIFFTileRowSize64(TIFF* tif);
extern tmsize_t TIFFTileRowSize(TIFF* tif);
extern uint64 TIFFTileSize64(TIFF* tif);
extern tmsize_t TIFFTileSize(TIFF* tif);
extern uint64 TIFFVTileSize64(TIFF* tif, uint32 nrows);
extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows);
extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern int TIFFFileno(TIFF*);
extern int TIFFSetFileno(TIFF*, int);
extern thandle_t TIFFClientdata(TIFF*);
extern thandle_t TIFFSetClientdata(TIFF*, thandle_t);
extern int TIFFGetMode(TIFF*);
extern int TIFFSetMode(TIFF*, int);
extern int TIFFIsTiled(TIFF*);
extern int TIFFIsByteSwapped(TIFF*);
extern int TIFFIsUpSampled(TIFF*);
extern int TIFFIsMSB2LSB(TIFF*);
extern int TIFFIsBigEndian(TIFF*);
extern TIFFReadWriteProc TIFFGetReadProc(TIFF*);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*);
extern TIFFSeekProc TIFFGetSeekProc(TIFF*);
extern TIFFCloseProc TIFFGetCloseProc(TIFF*);
extern TIFFSizeProc TIFFGetSizeProc(TIFF*);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*);
extern uint32 TIFFCurrentRow(TIFF*);
extern uint16 TIFFCurrentDirectory(TIFF*);
extern uint16 TIFFNumberOfDirectories(TIFF*);
extern uint64 TIFFCurrentDirOffset(TIFF*);
extern uint32 TIFFCurrentStrip(TIFF*);
extern uint32 TIFFCurrentTile(TIFF* tif);
extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size);
extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size);
extern int TIFFSetupStrips(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *);
extern void TIFFFreeDirectory(TIFF*);
extern int TIFFCreateDirectory(TIFF*);
extern int TIFFLastDirectory(TIFF*);
extern int TIFFSetDirectory(TIFF*, uint16);
extern int TIFFSetSubDirectory(TIFF*, uint64);
extern int TIFFUnlinkDirectory(TIFF*, uint16);
extern int TIFFSetField(TIFF*, uint32, ...);
extern int TIFFVSetField(TIFF*, uint32, va_list);
extern int TIFFUnsetField(TIFF*, uint32);
extern int TIFFWriteDirectory(TIFF *);
extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *);
#if defined(c_plusplus) || defined(__cplusplus)
extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0);
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*,
int = ORIENTATION_BOTLEFT, int = 0);
#else
extern void TIFFPrintDirectory(TIFF*, FILE*, long);
extern int TIFFReadScanline(TIFF* tif, void* buf, uint32 row, uint16 sample);
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int);
#endif
extern int TIFFReadRGBAStrip(TIFF*, uint32, uint32 * );
extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
extern int TIFFRGBAImageOK(TIFF*, char [1024]);
extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
extern void TIFFRGBAImageEnd(TIFFRGBAImage*);
extern TIFF* TIFFOpen(const char*, const char*);
# ifdef __WIN32__
extern TIFF* TIFFOpenW(const wchar_t*, const char*);
# endif /* __WIN32__ */
extern TIFF* TIFFFdOpen(int, const char*, const char*);
extern TIFF* TIFFClientOpen(const char*, const char*,
thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc,
TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern const char* TIFFFileName(TIFF*);
extern const char* TIFFSetFileName(TIFF*, const char *);
extern void TIFFError(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3)));
extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4)));
extern void TIFFWarning(const char*, const char*, ...) __attribute__((__format__ (__printf__,2,3)));
extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) __attribute__((__format__ (__printf__,3,4)));
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern uint32 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
extern uint32 TIFFNumberOfTiles(TIFF*);
extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);
extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);
extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16);
extern uint32 TIFFNumberOfStrips(TIFF*);
extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);
extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */
extern void TIFFSetWriteOffset(TIFF* tif, toff_t off);
extern void TIFFSwabShort(uint16*);
extern void TIFFSwabLong(uint32*);
extern void TIFFSwabLong8(uint64*);
extern void TIFFSwabFloat(float*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n);
extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n);
extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n);
extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n);
extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n);
extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n);
extern void TIFFReverseBits(uint8* cp, tmsize_t n);
extern const unsigned char* TIFFGetBitRevTable(int);
#ifdef LOGLUV_PUBLIC
#define U_NEU 0.210526316
#define V_NEU 0.473684211
#define UVSCALE 410.
extern double LogL16toY(int);
extern double LogL10toY(int);
extern void XYZtoRGB24(float*, uint8*);
extern int uv_decode(double*, double*, int);
extern void LogLuv24toXYZ(uint32, float*);
extern void LogLuv32toXYZ(uint32, float*);
#if defined(c_plusplus) || defined(__cplusplus)
extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
#else
extern int LogL16fromY(double, int);
extern int LogL10fromY(double, int);
extern int uv_encode(double, double, int);
extern uint32 LogLuv24fromXYZ(float*, int);
extern uint32 LogLuv32fromXYZ(float*, int);
#endif
#endif /* LOGLUV_PUBLIC */
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, const TIFFDisplay *, float*);
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32,
float *, float *, float *);
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float,
uint32 *, uint32 *, uint32 *);
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*);
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32,
uint32 *, uint32 *, uint32 *);
/****************************************************************************
* O B S O L E T E D I N T E R F A C E S
*
* Don't use this stuff in your applications, it may be removed in the future
* libtiff versions.
****************************************************************************/
typedef struct {
ttag_t field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
@ -311,205 +529,8 @@ typedef struct {
char *field_name; /* ASCII name */
} TIFFFieldInfo;
typedef struct _TIFFTagValue {
const TIFFFieldInfo *info;
int count;
void *value;
} TIFFTagValue;
extern void TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], int);
extern const TIFFFieldInfo* TIFFFindFieldInfo(TIFF*, ttag_t, TIFFDataType);
extern const TIFFFieldInfo* TIFFFindFieldInfoByName(TIFF* , const char *,
TIFFDataType);
extern const TIFFFieldInfo* TIFFFieldWithTag(TIFF*, ttag_t);
extern const TIFFFieldInfo* TIFFFieldWithName(TIFF*, const char *);
typedef int (*TIFFVSetMethod)(TIFF*, ttag_t, va_list);
typedef int (*TIFFVGetMethod)(TIFF*, ttag_t, va_list);
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long);
typedef struct {
TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32);
extern TIFFTagMethods *TIFFAccessTagMethods( TIFF * );
extern void *TIFFGetClientInfo( TIFF *, const char * );
extern void TIFFSetClientInfo( TIFF *, void *, const char * );
extern void TIFFCleanup(TIFF*);
extern void TIFFClose(TIFF*);
extern int TIFFFlush(TIFF*);
extern int TIFFFlushData(TIFF*);
extern int TIFFGetField(TIFF*, ttag_t, ...);
extern int TIFFVGetField(TIFF*, ttag_t, va_list);
extern int TIFFGetFieldDefaulted(TIFF*, ttag_t, ...);
extern int TIFFVGetFieldDefaulted(TIFF*, ttag_t, va_list);
extern int TIFFReadDirectory(TIFF*);
extern int TIFFReadCustomDirectory(TIFF*, toff_t, const TIFFFieldInfo[],
size_t);
extern int TIFFReadEXIFDirectory(TIFF*, toff_t);
extern tsize_t TIFFScanlineSize(TIFF*);
extern tsize_t TIFFOldScanlineSize(TIFF*);
extern tsize_t TIFFNewScanlineSize(TIFF*);
extern tsize_t TIFFRasterScanlineSize(TIFF*);
extern tsize_t TIFFStripSize(TIFF*);
extern tsize_t TIFFRawStripSize(TIFF*, tstrip_t);
extern tsize_t TIFFVStripSize(TIFF*, uint32);
extern tsize_t TIFFTileRowSize(TIFF*);
extern tsize_t TIFFTileSize(TIFF*);
extern tsize_t TIFFVTileSize(TIFF*, uint32);
extern uint32 TIFFDefaultStripSize(TIFF*, uint32);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern int TIFFFileno(TIFF*);
extern int TIFFSetFileno(TIFF*, int);
extern thandle_t TIFFClientdata(TIFF*);
extern thandle_t TIFFSetClientdata(TIFF*, thandle_t);
extern int TIFFGetMode(TIFF*);
extern int TIFFSetMode(TIFF*, int);
extern int TIFFIsTiled(TIFF*);
extern int TIFFIsByteSwapped(TIFF*);
extern int TIFFIsUpSampled(TIFF*);
extern int TIFFIsMSB2LSB(TIFF*);
extern int TIFFIsBigEndian(TIFF*);
extern TIFFReadWriteProc TIFFGetReadProc(TIFF*);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*);
extern TIFFSeekProc TIFFGetSeekProc(TIFF*);
extern TIFFCloseProc TIFFGetCloseProc(TIFF*);
extern TIFFSizeProc TIFFGetSizeProc(TIFF*);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*);
extern uint32 TIFFCurrentRow(TIFF*);
extern tdir_t TIFFCurrentDirectory(TIFF*);
extern tdir_t TIFFNumberOfDirectories(TIFF*);
extern uint32 TIFFCurrentDirOffset(TIFF*);
extern tstrip_t TIFFCurrentStrip(TIFF*);
extern ttile_t TIFFCurrentTile(TIFF*);
extern int TIFFReadBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFWriteBufferSetup(TIFF*, tdata_t, tsize_t);
extern int TIFFSetupStrips(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *);
extern void TIFFFreeDirectory(TIFF*);
extern int TIFFCreateDirectory(TIFF*);
extern int TIFFLastDirectory(TIFF*);
extern int TIFFSetDirectory(TIFF*, tdir_t);
extern int TIFFSetSubDirectory(TIFF*, uint32);
extern int TIFFUnlinkDirectory(TIFF*, tdir_t);
extern int TIFFSetField(TIFF*, ttag_t, ...);
extern int TIFFVSetField(TIFF*, ttag_t, va_list);
extern int TIFFWriteDirectory(TIFF *);
extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *);
extern int TIFFReassignTagToIgnore(enum TIFFIgnoreSense, int);
#if defined(c_plusplus) || defined(__cplusplus)
extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*,
int = ORIENTATION_BOTLEFT, int = 0);
#else
extern void TIFFPrintDirectory(TIFF*, FILE*, long);
extern int TIFFReadScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFWriteScanline(TIFF*, tdata_t, uint32, tsample_t);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int);
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, int, int);
#endif
extern int TIFFReadRGBAStrip(TIFF*, tstrip_t, uint32 * );
extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * );
extern int TIFFRGBAImageOK(TIFF*, char [1024]);
extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32);
extern void TIFFRGBAImageEnd(TIFFRGBAImage*);
extern TIFF* TIFFOpen(const char*, const char*);
# ifdef __WIN32__
extern TIFF* TIFFOpenW(const wchar_t*, const char*);
# endif /* __WIN32__ */
extern TIFF* TIFFFdOpen(int, const char*, const char*);
extern TIFF* TIFFClientOpen(const char*, const char*,
thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc,
TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern const char* TIFFFileName(TIFF*);
extern const char* TIFFSetFileName(TIFF*, const char *);
extern void TIFFError(const char*, const char*, ...) __attribute__((format (printf,2,3)));
extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) __attribute__((format (printf,3,4)));
extern void TIFFWarning(const char*, const char*, ...) __attribute__((format (printf,2,3)));
extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) __attribute__((format (printf,3,4)));
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern ttile_t TIFFComputeTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern int TIFFCheckTile(TIFF*, uint32, uint32, uint32, tsample_t);
extern ttile_t TIFFNumberOfTiles(TIFF*);
extern tsize_t TIFFReadTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tsize_t TIFFWriteTile(TIFF*,
tdata_t, uint32, uint32, uint32, tsample_t);
extern tstrip_t TIFFComputeStrip(TIFF*, uint32, tsample_t);
extern tstrip_t TIFFNumberOfStrips(TIFF*);
extern tsize_t TIFFReadEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFReadEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFReadRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawStrip(TIFF*, tstrip_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteEncodedTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern tsize_t TIFFWriteRawTile(TIFF*, ttile_t, tdata_t, tsize_t);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */
extern void TIFFSetWriteOffset(TIFF*, toff_t);
extern void TIFFSwabShort(uint16*);
extern void TIFFSwabLong(uint32*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16*, unsigned long);
extern void TIFFSwabArrayOfTriples(uint8*, unsigned long);
extern void TIFFSwabArrayOfLong(uint32*, unsigned long);
extern void TIFFSwabArrayOfDouble(double*, unsigned long);
extern void TIFFReverseBits(unsigned char *, unsigned long);
extern const unsigned char* TIFFGetBitRevTable(int);
#ifdef LOGLUV_PUBLIC
#define U_NEU 0.210526316
#define V_NEU 0.473684211
#define UVSCALE 410.
extern double LogL16toY(int);
extern double LogL10toY(int);
extern void XYZtoRGB24(float*, uint8*);
extern int uv_decode(double*, double*, int);
extern void LogLuv24toXYZ(uint32, float*);
extern void LogLuv32toXYZ(uint32, float*);
#if defined(c_plusplus) || defined(__cplusplus)
extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER);
extern uint32 LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER);
#else
extern int LogL16fromY(double, int);
extern int LogL10fromY(double, int);
extern int uv_encode(double, double, int);
extern uint32 LogLuv24fromXYZ(float*, int);
extern uint32 LogLuv32fromXYZ(float*, int);
#endif
#endif /* LOGLUV_PUBLIC */
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, TIFFDisplay *, float*);
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32, int32, int32,
float *, float *, float *);
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float,
uint32 *, uint32 *, uint32 *);
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*);
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32, int32, int32,
uint32 *, uint32 *, uint32 *);
#if defined(c_plusplus) || defined(__cplusplus)
}
#endif

6
3rdparty/libtiff/tiffio.hxx vendored
View File

@ -1,4 +1,4 @@
/* $Id: tiffio.hxx,v 1.1.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
/* $Id: tiffio.hxx,v 1.3 2010-06-08 18:55:15 bfriesen Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -34,8 +34,8 @@
#include <iostream>
#include "tiff.h"
extern TIFF* TIFFStreamOpen(const char*, std::ostream *);
extern TIFF* TIFFStreamOpen(const char*, std::istream *);
extern TIFF* TIFFStreamOpen(const char*, std::ostream *);
extern TIFF* TIFFStreamOpen(const char*, std::istream *);
#endif /* _TIFFIO_HXX_ */

405
3rdparty/libtiff/tiffiop.h vendored
View File

@ -1,4 +1,4 @@
/* $Id: tiffiop.h,v 1.51.2.7 2011-03-21 21:09:19 fwarmerdam Exp $ */
/* $Id: tiffiop.h,v 1.82 2011-02-18 20:53:05 fwarmerdam Exp $ */
/*
* Copyright (c) 1988-1997 Sam Leffler
@ -57,17 +57,8 @@ extern void *lfind(const void *, const void *, size_t *, size_t,
int (*)(const void *, const void *));
#endif
/*
Libtiff itself does not require a 64-bit type, but bundled TIFF
utilities may use it.
*/
#if !defined(__xlC__) && !defined(__xlc__) // Already defined there (#2301)
typedef TIFF_INT64_T int64;
typedef TIFF_UINT64_T uint64;
#endif
#include "tiffio.h"
#include "tif_dir.h"
#ifndef STRIP_SIZE_DEFAULT
@ -83,167 +74,180 @@ typedef TIFF_UINT64_T uint64;
typedef struct client_info {
struct client_info *next;
void *data;
char *name;
void *data;
char *name;
} TIFFClientInfoLink;
/*
* Typedefs for ``method pointers'' used internally.
* these are depriciated and provided only for backwards compatibility
*/
typedef unsigned char tidataval_t; /* internal image data value type */
typedef tidataval_t* tidata_t; /* reference to internal image data */
typedef unsigned char tidataval_t; /* internal image data value type */
typedef tidataval_t* tidata_t; /* reference to internal image data */
typedef void (*TIFFVoidMethod)(TIFF*);
typedef int (*TIFFBoolMethod)(TIFF*);
typedef int (*TIFFPreMethod)(TIFF*, tsample_t);
typedef int (*TIFFCodeMethod)(TIFF*, tidata_t, tsize_t, tsample_t);
typedef int (*TIFFSeekMethod)(TIFF*, uint32);
typedef void (*TIFFPostMethod)(TIFF*, tidata_t, tsize_t);
typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
typedef void (*TIFFVoidMethod)(TIFF*);
typedef int (*TIFFBoolMethod)(TIFF*);
typedef int (*TIFFPreMethod)(TIFF*, uint16);
typedef int (*TIFFCodeMethod)(TIFF* tif, uint8* buf, tmsize_t size, uint16 sample);
typedef int (*TIFFSeekMethod)(TIFF*, uint32);
typedef void (*TIFFPostMethod)(TIFF* tif, uint8* buf, tmsize_t size);
typedef uint32 (*TIFFStripMethod)(TIFF*, uint32);
typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*);
struct tiff {
char* tif_name; /* name of open file */
int tif_fd; /* open file descriptor */
int tif_mode; /* open mode (O_*) */
uint32 tif_flags;
#define TIFF_FILLORDER 0x00003 /* natural bit fill order for machine */
#define TIFF_DIRTYHEADER 0x00004 /* header must be written on close */
#define TIFF_DIRTYDIRECT 0x00008 /* current directory must be written */
#define TIFF_BUFFERSETUP 0x00010 /* data buffers setup */
#define TIFF_CODERSETUP 0x00020 /* encoder/decoder setup done */
#define TIFF_BEENWRITING 0x00040 /* written 1+ scanlines to file */
#define TIFF_SWAB 0x00080 /* byte swap file information */
#define TIFF_NOBITREV 0x00100 /* inhibit bit reversal logic */
#define TIFF_MYBUFFER 0x00200 /* my raw data buffer; free on close */
#define TIFF_ISTILED 0x00400 /* file is tile, not strip- based */
#define TIFF_MAPPED 0x00800 /* file is mapped into memory */
#define TIFF_POSTENCODE 0x01000 /* need call to postencode routine */
#define TIFF_INSUBIFD 0x02000 /* currently writing a subifd */
#define TIFF_UPSAMPLED 0x04000 /* library is doing data up-sampling */
#define TIFF_STRIPCHOP 0x08000 /* enable strip chopping support */
#define TIFF_HEADERONLY 0x10000 /* read header only, do not process */
/* the first directory */
#define TIFF_NOREADRAW 0x20000 /* skip reading of raw uncompressed */
/* image data */
#define TIFF_INCUSTOMIFD 0x40000 /* currently writing a custom IFD */
toff_t tif_diroff; /* file offset of current directory */
toff_t tif_nextdiroff; /* file offset of following directory */
toff_t* tif_dirlist; /* list of offsets to already seen */
/* directories to prevent IFD looping */
tsize_t tif_dirlistsize;/* number of entires in offset list */
uint16 tif_dirnumber; /* number of already seen directories */
TIFFDirectory tif_dir; /* internal rep of current directory */
TIFFDirectory tif_customdir; /* custom IFDs are separated from
the main ones */
TIFFHeader tif_header; /* file's header block */
const int* tif_typeshift; /* data type shift counts */
const long* tif_typemask; /* data type masks */
uint32 tif_row; /* current scanline */
tdir_t tif_curdir; /* current directory (index) */
tstrip_t tif_curstrip; /* current strip for read/write */
toff_t tif_curoff; /* current offset for read/write */
toff_t tif_dataoff; /* current offset for writing dir */
/* SubIFD support */
uint16 tif_nsubifd; /* remaining subifds to write */
toff_t tif_subifdoff; /* offset for patching SubIFD link */
/* tiling support */
uint32 tif_col; /* current column (offset by row too) */
ttile_t tif_curtile; /* current tile for read/write */
tsize_t tif_tilesize; /* # of bytes in a tile */
/* compression scheme hooks */
int tif_decodestatus;
TIFFBoolMethod tif_setupdecode;/* called once before predecode */
TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
TIFFBoolMethod tif_setupencode;/* called once before preencode */
int tif_encodestatus;
TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
TIFFCodeMethod tif_decodestrip;/* strip decoding routine */
TIFFCodeMethod tif_encodestrip;/* strip encoding routine */
TIFFCodeMethod tif_decodetile; /* tile decoding routine */
TIFFCodeMethod tif_encodetile; /* tile encoding routine */
TIFFVoidMethod tif_close; /* cleanup-on-close routine */
TIFFSeekMethod tif_seek; /* position within a strip routine */
TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFStripMethod tif_defstripsize;/* calculate/constrain strip size */
TIFFTileMethod tif_deftilesize;/* calculate/constrain tile size */
tidata_t tif_data; /* compression scheme private data */
/* input/output buffering */
tsize_t tif_scanlinesize;/* # of bytes in a scanline */
tsize_t tif_scanlineskew;/* scanline skew for reading strips */
tidata_t tif_rawdata; /* raw data buffer */
tsize_t tif_rawdatasize;/* # of bytes in raw data buffer */
tidata_t tif_rawcp; /* current spot in raw buffer */
tsize_t tif_rawcc; /* bytes unread from raw buffer */
/* memory-mapped file support */
tidata_t tif_base; /* base of mapped file */
toff_t tif_size; /* size of mapped file region (bytes)
FIXME: it should be tsize_t */
TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc;/* unmap file method */
/* input/output callback methods */
thandle_t tif_clientdata; /* callback parameter */
TIFFReadWriteProc tif_readproc; /* read method */
TIFFReadWriteProc tif_writeproc;/* write method */
TIFFSeekProc tif_seekproc; /* lseek method */
TIFFCloseProc tif_closeproc; /* close method */
TIFFSizeProc tif_sizeproc; /* filesize method */
/* post-decoding support */
TIFFPostMethod tif_postdecode; /* post decoding routine */
/* tag support */
TIFFFieldInfo** tif_fieldinfo; /* sorted table of registered tags */
size_t tif_nfields; /* # entries in registered tag table */
const TIFFFieldInfo *tif_foundfield;/* cached pointer to already found tag */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */
TIFFClientInfoLink *tif_clientinfo; /* extra client information. */
char* tif_name; /* name of open file */
int tif_fd; /* open file descriptor */
int tif_mode; /* open mode (O_*) */
uint32 tif_flags;
#define TIFF_FILLORDER 0x00003 /* natural bit fill order for machine */
#define TIFF_DIRTYHEADER 0x00004 /* header must be written on close */
#define TIFF_DIRTYDIRECT 0x00008 /* current directory must be written */
#define TIFF_BUFFERSETUP 0x00010 /* data buffers setup */
#define TIFF_CODERSETUP 0x00020 /* encoder/decoder setup done */
#define TIFF_BEENWRITING 0x00040 /* written 1+ scanlines to file */
#define TIFF_SWAB 0x00080 /* byte swap file information */
#define TIFF_NOBITREV 0x00100 /* inhibit bit reversal logic */
#define TIFF_MYBUFFER 0x00200 /* my raw data buffer; free on close */
#define TIFF_ISTILED 0x00400 /* file is tile, not strip- based */
#define TIFF_MAPPED 0x00800 /* file is mapped into memory */
#define TIFF_POSTENCODE 0x01000 /* need call to postencode routine */
#define TIFF_INSUBIFD 0x02000 /* currently writing a subifd */
#define TIFF_UPSAMPLED 0x04000 /* library is doing data up-sampling */
#define TIFF_STRIPCHOP 0x08000 /* enable strip chopping support */
#define TIFF_HEADERONLY 0x10000 /* read header only, do not process the first directory */
#define TIFF_NOREADRAW 0x20000 /* skip reading of raw uncompressed image data */
#define TIFF_INCUSTOMIFD 0x40000 /* currently writing a custom IFD */
#define TIFF_BIGTIFF 0x80000 /* read/write bigtiff */
#define TIFF_BUF4WRITE 0x100000 /* rawcc bytes are for writing */
#define TIFF_DIRTYSTRIP 0x200000 /* stripoffsets/stripbytecount dirty*/
#define TIFF_PERSAMPLE 0x400000 /* get/set per sample tags as arrays */
uint64 tif_diroff; /* file offset of current directory */
uint64 tif_nextdiroff; /* file offset of following directory */
uint64* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */
uint16 tif_dirlistsize; /* number of entires in offset list */
uint16 tif_dirnumber; /* number of already seen directories */
TIFFDirectory tif_dir; /* internal rep of current directory */
TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */
union {
TIFFHeaderCommon common;
TIFFHeaderClassic classic;
TIFFHeaderBig big;
} tif_header;
uint16 tif_header_size; /* file's header block and its length */
uint32 tif_row; /* current scanline */
uint16 tif_curdir; /* current directory (index) */
uint32 tif_curstrip; /* current strip for read/write */
uint64 tif_curoff; /* current offset for read/write */
uint64 tif_dataoff; /* current offset for writing dir */
/* SubIFD support */
uint16 tif_nsubifd; /* remaining subifds to write */
uint64 tif_subifdoff; /* offset for patching SubIFD link */
/* tiling support */
uint32 tif_col; /* current column (offset by row too) */
uint32 tif_curtile; /* current tile for read/write */
tmsize_t tif_tilesize; /* # of bytes in a tile */
/* compression scheme hooks */
int tif_decodestatus;
TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */
TIFFBoolMethod tif_setupdecode; /* called once before predecode */
TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
TIFFBoolMethod tif_setupencode; /* called once before preencode */
int tif_encodestatus;
TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
TIFFCodeMethod tif_decodestrip; /* strip decoding routine */
TIFFCodeMethod tif_encodestrip; /* strip encoding routine */
TIFFCodeMethod tif_decodetile; /* tile decoding routine */
TIFFCodeMethod tif_encodetile; /* tile encoding routine */
TIFFVoidMethod tif_close; /* cleanup-on-close routine */
TIFFSeekMethod tif_seek; /* position within a strip routine */
TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */
uint8* tif_data; /* compression scheme private data */
/* input/output buffering */
tmsize_t tif_scanlinesize; /* # of bytes in a scanline */
tmsize_t tif_scanlineskew; /* scanline skew for reading strips */
uint8* tif_rawdata; /* raw data buffer */
tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */
tmsize_t tif_rawdataoff; /* rawdata offset within strip */
tmsize_t tif_rawdataloaded;/* amount of data in rawdata */
uint8* tif_rawcp; /* current spot in raw buffer */
tmsize_t tif_rawcc; /* bytes unread from raw buffer */
/* memory-mapped file support */
uint8* tif_base; /* base of mapped file */
tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */
TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc; /* unmap file method */
/* input/output callback methods */
thandle_t tif_clientdata; /* callback parameter */
TIFFReadWriteProc tif_readproc; /* read method */
TIFFReadWriteProc tif_writeproc; /* write method */
TIFFSeekProc tif_seekproc; /* lseek method */
TIFFCloseProc tif_closeproc; /* close method */
TIFFSizeProc tif_sizeproc; /* filesize method */
/* post-decoding support */
TIFFPostMethod tif_postdecode; /* post decoding routine */
/* tag support */
TIFFField** tif_fields; /* sorted table of registered tags */
size_t tif_nfields; /* # entries in registered tag table */
const TIFFField* tif_foundfield; /* cached pointer to already found tag */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */
TIFFClientInfoLink* tif_clientinfo; /* extra client information. */
/* Backward compatibility stuff. We need these two fields for
* setting up an old tag extension scheme. */
TIFFFieldArray* tif_fieldscompat;
size_t tif_nfieldscompat;
};
#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
#define TIFFReadFile(tif, buf, size) \
((*(tif)->tif_readproc)((tif)->tif_clientdata,buf,size))
#define TIFFWriteFile(tif, buf, size) \
((*(tif)->tif_writeproc)((tif)->tif_clientdata,buf,size))
#define TIFFSeekFile(tif, off, whence) \
((*(tif)->tif_seekproc)((tif)->tif_clientdata,(toff_t)(off),whence))
#define TIFFCloseFile(tif) \
#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
#define TIFFReadFile(tif, buf, size) \
((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size)))
#define TIFFWriteFile(tif, buf, size) \
((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size)))
#define TIFFSeekFile(tif, off, whence) \
((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence)))
#define TIFFCloseFile(tif) \
((*(tif)->tif_closeproc)((tif)->tif_clientdata))
#define TIFFGetFileSize(tif) \
#define TIFFGetFileSize(tif) \
((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
#define TIFFMapFileContents(tif, paddr, psize) \
((*(tif)->tif_mapproc)((tif)->tif_clientdata,paddr,psize))
#define TIFFUnmapFileContents(tif, addr, size) \
((*(tif)->tif_unmapproc)((tif)->tif_clientdata,addr,size))
#define TIFFMapFileContents(tif, paddr, psize) \
((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize)))
#define TIFFUnmapFileContents(tif, addr, size) \
((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size)))
/*
* Default Read/Seek/Write definitions.
*/
#ifndef ReadOK
#define ReadOK(tif, buf, size) \
(TIFFReadFile(tif, (tdata_t) buf, (tsize_t)(size)) == (tsize_t)(size))
#define ReadOK(tif, buf, size) \
(TIFFReadFile((tif),(buf),(size))==(size))
#endif
#ifndef SeekOK
#define SeekOK(tif, off) \
(TIFFSeekFile(tif, (toff_t) off, SEEK_SET) == (toff_t) off)
#define SeekOK(tif, off) \
(TIFFSeekFile((tif),(off),SEEK_SET)==(off))
#endif
#ifndef WriteOK
#define WriteOK(tif, buf, size) \
(TIFFWriteFile(tif, (tdata_t) buf, (tsize_t) size) == (tsize_t) size)
#define WriteOK(tif, buf, size) \
(TIFFWriteFile((tif),(buf),(size))==(size))
#endif
/* NB: the uint32 casts are to silence certain ANSI-C compilers */
#define TIFFhowmany(x, y) (((uint32)x < (0xffffffff - (uint32)(y-1))) ? \
#define TIFFhowmany_32(x, y) (((uint32)x < (0xffffffff - (uint32)(y-1))) ? \
((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) : \
0U)
#define TIFFhowmany8(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
#define TIFFroundup(x, y) (TIFFhowmany(x,y)*(y))
#define TIFFhowmany8_32(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
#define TIFFroundup_32(x, y) (TIFFhowmany_32(x,y)*(y))
#define TIFFhowmany_64(x, y) ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y)))
#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3)
#define TIFFroundup_64(x, y) (TIFFhowmany_64(x,y)*(y))
/* Safe multiply which returns zero if there is an integer overflow */
#define TIFFSafeMultiply(t,v,m) ((((t)m != (t)0) && (((t)((v*m)/m)) == (t)v)) ? (t)(v*m) : (t)0)
@ -256,86 +260,95 @@ struct tiff {
#if defined(__cplusplus)
extern "C" {
#endif
extern int _TIFFgetMode(const char*, const char*);
extern int _TIFFNoRowEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoStripEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoTileEncode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoRowDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoStripDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern int _TIFFNoTileDecode(TIFF*, tidata_t, tsize_t, tsample_t);
extern void _TIFFNoPostDecode(TIFF*, tidata_t, tsize_t);
extern int _TIFFNoPreCode (TIFF*, tsample_t);
extern int _TIFFNoSeek(TIFF*, uint32);
extern void _TIFFSwab16BitData(TIFF*, tidata_t, tsize_t);
extern void _TIFFSwab24BitData(TIFF*, tidata_t, tsize_t);
extern void _TIFFSwab32BitData(TIFF*, tidata_t, tsize_t);
extern void _TIFFSwab64BitData(TIFF*, tidata_t, tsize_t);
extern int TIFFFlushData1(TIFF*);
extern int TIFFDefaultDirectory(TIFF*);
extern void _TIFFSetDefaultCompressionState(TIFF*);
extern int TIFFSetCompressionScheme(TIFF*, int);
extern int TIFFSetDefaultCompressionState(TIFF*);
extern uint32 _TIFFDefaultStripSize(TIFF*, uint32);
extern void _TIFFDefaultTileSize(TIFF*, uint32*, uint32*);
extern int _TIFFDataSize(TIFFDataType);
extern int _TIFFgetMode(const char* mode, const char* module);
extern int _TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
extern int _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
extern int _TIFFNoTileEncode(TIFF*, uint8* pp, tmsize_t cc, uint16 s);
extern int _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
extern int _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s);
extern int _TIFFNoTileDecode(TIFF*, uint8* pp, tmsize_t cc, uint16 s);
extern void _TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
extern int _TIFFNoPreCode(TIFF* tif, uint16 s);
extern int _TIFFNoSeek(TIFF* tif, uint32 off);
extern void _TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc);
extern void _TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc);
extern void _TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc);
extern void _TIFFSwab64BitData(TIFF* tif, uint8* buf, tmsize_t cc);
extern int TIFFFlushData1(TIFF* tif);
extern int TIFFDefaultDirectory(TIFF* tif);
extern void _TIFFSetDefaultCompressionState(TIFF* tif);
extern int _TIFFRewriteField(TIFF *, uint16, TIFFDataType, tmsize_t, void *);
extern int TIFFSetCompressionScheme(TIFF* tif, int scheme);
extern int TIFFSetDefaultCompressionState(TIFF* tif);
extern uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s);
extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th);
extern int _TIFFDataSize(TIFFDataType type);
extern void _TIFFsetByteArray(void**, void*, uint32);
extern void _TIFFsetString(char**, char*);
extern void _TIFFsetShortArray(uint16**, uint16*, uint32);
extern void _TIFFsetLongArray(uint32**, uint32*, uint32);
extern void _TIFFsetFloatArray(float**, float*, uint32);
extern void _TIFFsetDoubleArray(double**, double*, uint32);
extern void _TIFFsetByteArray(void**, void*, uint32);
extern void _TIFFsetString(char**, char*);
extern void _TIFFsetShortArray(uint16**, uint16*, uint32);
extern void _TIFFsetLongArray(uint32**, uint32*, uint32);
extern void _TIFFsetFloatArray(float**, float*, uint32);
extern void _TIFFsetDoubleArray(double**, double*, uint32);
extern void _TIFFprintAscii(FILE*, const char*);
extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
extern void _TIFFprintAscii(FILE*, const char*);
extern void _TIFFprintAsciiTag(FILE*, const char*, const char*);
extern TIFFErrorHandler _TIFFwarningHandler;
extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
extern TIFFErrorHandler _TIFFwarningHandler;
extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
extern tdata_t _TIFFCheckMalloc(TIFF*, size_t, size_t, const char*);
extern tdata_t _TIFFCheckRealloc(TIFF*, tdata_t, size_t, size_t, const char*);
extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*);
extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*);
extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*);
extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*);
extern int TIFFInitDumpMode(TIFF*, int);
extern double _TIFFUInt64ToDouble(uint64);
extern float _TIFFUInt64ToFloat(uint64);
extern int TIFFInitDumpMode(TIFF*, int);
#ifdef PACKBITS_SUPPORT
extern int TIFFInitPackBits(TIFF*, int);
extern int TIFFInitPackBits(TIFF*, int);
#endif
#ifdef CCITT_SUPPORT
extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int);
extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int);
#endif
#ifdef THUNDER_SUPPORT
extern int TIFFInitThunderScan(TIFF*, int);
extern int TIFFInitThunderScan(TIFF*, int);
#endif
#ifdef NEXT_SUPPORT
extern int TIFFInitNeXT(TIFF*, int);
extern int TIFFInitNeXT(TIFF*, int);
#endif
#ifdef LZW_SUPPORT
extern int TIFFInitLZW(TIFF*, int);
extern int TIFFInitLZW(TIFF*, int);
#endif
#ifdef OJPEG_SUPPORT
extern int TIFFInitOJPEG(TIFF*, int);
extern int TIFFInitOJPEG(TIFF*, int);
#endif
#ifdef JPEG_SUPPORT
extern int TIFFInitJPEG(TIFF*, int);
extern int TIFFInitJPEG(TIFF*, int);
#endif
#ifdef JBIG_SUPPORT
extern int TIFFInitJBIG(TIFF*, int);
extern int TIFFInitJBIG(TIFF*, int);
#endif
#ifdef ZIP_SUPPORT
extern int TIFFInitZIP(TIFF*, int);
extern int TIFFInitZIP(TIFF*, int);
#endif
#ifdef PIXARLOG_SUPPORT
extern int TIFFInitPixarLog(TIFF*, int);
extern int TIFFInitPixarLog(TIFF*, int);
#endif
#ifdef LOGLUV_SUPPORT
extern int TIFFInitSGILog(TIFF*, int);
extern int TIFFInitSGILog(TIFF*, int);
#endif
#ifdef LZMA_SUPPORT
extern int TIFFInitLZMA(TIFF*, int);
#endif
#ifdef VMS
extern const TIFFCodec _TIFFBuiltinCODECS[];
extern const TIFFCodec _TIFFBuiltinCODECS[];
#else
extern TIFFCodec _TIFFBuiltinCODECS[];
extern TIFFCodec _TIFFBuiltinCODECS[];
#endif
#if defined(__cplusplus)

4
3rdparty/libtiff/tiffvers.h vendored
View File

@ -1,4 +1,4 @@
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.9.5\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.0.1\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/*
* This define can be used in code that requires
* compilation-related definitions specific to a
@ -6,4 +6,4 @@
* version checking should be done based on the
* string returned by TIFFGetVersion.
*/
#define TIFFLIB_VERSION 20110409
#define TIFFLIB_VERSION 20120218